标签: bigdata

嗨,我想知道jobconf和job对象之间的基本区别,目前我正在提交我的工作

JobClient.runJob(jobconf);

我看到了提交这样的工作的其他方式

Configuration conf = getConf();
Job job = new Job(conf, "secondary sort");
job.waitForCompletion(true);     
return 0;

如何使用jobconf为作业指定sortcomparator类？

任何人都可以向我解释这个概念吗？

假设我们有一张包含600万条记录的表格.有16个整数列和几个文本列.它是只读表,因此每个整数列都有一个索引.每条记录大约50-60字节.

表名为"Item"
服务器为:12 GB RAM,1,5 TB SATA,4 CORES.postgres的所有服务器.
此数据库中有更多表,因此RAM不包括所有数据库.

我想向表"Item"添加一列"a_elements"(大整数的数组类型)每列记录在此列中不超过50-60个元素.

之后,我将在此列上创建索引GIN,典型查询应如下所示:

select * from item where ...... and '{5}' <@ a_elements;

我还有第二个,更经典的选择.

不要将列a_elements添加到表项,而是创建具有两列的表元素:

• id_item
• id_element

该表将有大约200万条记录.

我能够对这些表进行分区,因此表元素中的记录数将减少到20万,表项中减少500 K.

第二个选项查询如下所示:

select item.* 
from item 
    left join elements on (item.id_item=elements.id_item) 
where .... 
and 5 = elements.id_element

我想知道在性能方面哪种选择会更好.postgres能够在单个查询中使用索引GIN(选项1)的许多不同索引吗？

我需要做出一个好的决定,因为导入这些数据需要20天.

我想按给定字段进行分组,并使用分组字段获取输出.以下是我想要实现的一个例子: -

想象一下名为'sample_table'的表,其中有两列如下: -

F1  F2
001 111
001 222
001 123
002 222
002 333
003 555

我想编写Hive Query,它将提供以下输出: -

001 [111, 222, 123]
002 [222, 333]
003 [555]

在猪中,这可以通过以下方式轻松实现: -

grouped_relation = GROUP sample_table BY F1;

有人可以建议在Hive中有一个简单的方法吗？我能想到的是为此编写用户定义函数(UDF),但这可能是一个非常耗时的选项.

我正在使用简单的命令:SELECT DISTINCT * FROM first_working_table; 在HIVE 0.11中,我收到以下错误消息:

FAILED:当前上下文不支持SemanticException TOK_ALLCOLREF.

有谁知道为什么会这样？我们怎么解决呢？

谢谢你,加尔.

我正在寻找解决方案来加速我编写的函数来循环遍历pandas数据帧并比较当前行和前一行之间的列值.

例如,这是我的问题的简化版本:

   User  Time                 Col1  newcol1  newcol2  newcol3  newcol4
0     1     6     [cat, dog, goat]        0        0        0        0
1     1     6         [cat, sheep]        0        0        0        0
2     1    12        [sheep, goat]        0        0        0        0
3     2     3          [cat, lion]        0        0        0        0
4     2     5  [fish, goat, lemur]        0        0        0        0
5     3     9           [cat, dog]        0        0        0        0
6     4     4          [dog, goat]        0        0        0        0
7     4    11                [cat]        0        0 …

它将如何有益的是使用Python/PHP非持久阵列存储6GB +数据超过800万分美元排在RAM中,而不是使用MySQL /的MongoDB /卡桑德拉/ BigTable的/ BigData(持久性数据库)数据库,当谈到速度,简单的查询执行/延迟？

例如,在1秒内找到800多万行中的一个名称:是否可能？有没有人有处理超过1-2亿行数据集的经验,并在1秒内获得简单搜索查询的结果？

是否有更好的,经过验证的方法来处理数十亿行？

我找不到关于Apache Parquet文件的任何简单的英文解释.如:

1. 这些是什么？
2. 我是否需要Hadoop或HDFS来查看/创建/存储它们？
3. 如何创建镶木地板文件？
4. 如何查看镶木地板文件？

有关这些问题的任何帮助表示赞赏.

我有一个用例,我初始化一个包含一组查找数据的HashMap(有关物联网设备的物理位置等的信息).该查找数据用作第二数据集的参考数据,该第二数据集是PCollection.此PCollection是一个数据流,提供IoT设备记录的数据.来自物联网设备的数据流使用Apache Beam管道,该管道作为Google Dataflow使用Google Cloud pub/sub运行.

当我处理PCollection(设备数据)时,我将Google Cloud发布/订阅数据链接到HashMap中的相关查找条目.

我需要更新HashMap,基于第二个将更改推送到其数据的pub/sub.这是我到目前为止获得PCollection并使用HashMap进行查找的方法:

HashMap - >包含预加载的查找数据(有关IoT设备的信息)

PCollection - >包含来自管道数据流的数据(物联网设备记录的数据)

我正在为IoT设备查找数据生成一个HashMap作为单例:

public class MyData {

    private static final MyData instance = new MyData ();

    private MyData () {     
            HashMap myDataMap = new HashMap<String, String>();          
               ... logic to populate the map

            this.referenceData = myDataMap;

    }

    public HashMap<Integer, DeviceReference> referenceData;

    public static DeviceData getInstance(){
        return instance;
    }
}

然后我在不同的类中使用HashMap,我订阅了数据的更新(这些是例如给我新的数据的消息,这些数据与已经存储在HashMap中的实体有关).我正在使用带有Apache beam的Google pub/sub订阅更改:

HashMap<String, String> referenceData = MyData.getInstance().referenceData;

Pipeline pipeLine = Pipeline.create(options);           

// subscribe to changes in data

org.apache.beam.sdk.values.PCollection myDataUpdates; …

将数百万条记录从 Spark 数据帧插入到 Postgres 表的最有效方法是 5000 万条记录。过去，我通过使用批量复制和批量大小选项从 spark 到MSSQL做到了这一点， 这也很成功。

Postgres 是否有类似的东西？

添加我尝试过的代码以及运行该过程所需的时间：

def inserter():
    start = timer()
    sql_res.write.format("jdbc").option("numPartitions","5").option("batchsize","200000")\
    .option("url", "jdbc:postgresql://xyz.com:5435/abc_db") \
    .option("dbtable", "public.full_load").option("user", "root").option("password", "password").save()
    end = timer()
    print(timedelta(seconds=end-start))
inserter()

因此，我对 1000 万条记录执行了上述方法，并按照 中指定的numPartitions方式进行了 5 个并行连接，并且还尝试了 200k 的批量大小。

该过程花费的总时间为0:14:05.760926（十四分五秒）。

有没有其他有效的方法可以减少时间？

我可以使用的有效或最佳批量大小是多少？增加我的批量大小会更快地完成工作吗？或者打开多个连接，即> 5 帮助我加快进程？

1000 万条记录的平均 14 分钟还不错，但正在寻找以前会这样做的人来帮助回答这个问题。

对于两个逻辑矢量,x并且y,长度> 1E8的,什么是计算2×2交叉表格最快的方法？

我怀疑答案是用C/C++编写它,但我想知道R中是否有一些关于这个问题已经非常聪明,因为它并不罕见.

示例代码,对于300M条目(如果3E8太大,可以让N = 1E8;我选择的总大小不到2.5GB(2.4GB).我的目标密度为0.02,只是为了让它更有趣(可以使用稀疏向量,如果这有帮助,但类型转换可能需要时间).

set.seed(0)
N = 3E8
p = 0.02
x = sample(c(TRUE, FALSE), N, prob = c(p, 1-p), replace = TRUE)
y = sample(c(TRUE, FALSE), N, prob = c(p, 1-p), replace = TRUE)

一些明显的方法:

1. table
2. bigtabulate
3. 简单的逻辑运算(例如sum(x & y))
4. 矢量乘法(嘘)
5. data.table
6. 上面的一些,parallel从multicore包(或新parallel包)

我已经尝试了前三个选项(请参阅我的回答),但我觉得必须有更好更好的东西.

我觉得这table很慢. bigtabulate对于一对逻辑向量来说似乎有些过分.最后,进行vanilla逻辑运算看起来像一个kludge,它看了每个向量太多次(3X？7X？),更不用说它在处理期间填充了大量额外的内存,这是一个巨大的时间浪费.

向量乘法通常是一个坏主意,但是当向量稀疏时,可能会因为存储它而获得优势,然后使用向量乘法.

随意改变N和p,如果将展示的制表功能,任何有趣的行为.:)

更新1.我的第一个答案给出了三种天真方法的时间,这是相信table速度缓慢的基础.然而,要意识到的关键是"逻辑"方法效率极低.看看它在做什么:

• 4个逻辑向量运算
• 4种类型转换(逻辑到整数或FP - 用于sum)
• 4矢量求和 …