Question

我想做两个PCollections的笛卡尔积。 PCollection都不能适应内存，所以做侧输入是不可行的。

我的目标是：我有两个数据集。一个是小尺寸的许多元素。另一个是非常大的很少（~10）。我想获取这两个元素的乘积，然后生成键值对象。

Answer 1

我认为CoGroupByKey可能适用于您的情况：

https://cloud.google.com/dataflow/model/group-by-key#join

这就是我为类似的用例所做的。虽然我的内存可能没有受到限制（你是否尝试过更大的机器群？）：

  PCollection<KV<String, TableRow>> inputClassifiedKeyed = inputClassified
            .apply(ParDo.named("Actuals : Keys").of(new ActualsRowToKeyedRow()));

  PCollection<KV<String, Iterable<Map<String, String>>>> groupedCategories = p
  [...]
   .apply(GroupByKey.create());

所以收藏品都用同一把钥匙键入。

然后我宣布了标签：

 final TupleTag<Iterable<Map<String, String>>> categoryTag = new TupleTag<>();
 final TupleTag<TableRow> actualsTag = new TupleTag<>();

合并他们：

 PCollection<KV<String, CoGbkResult>> actualCategoriesCombined =
            KeyedPCollectionTuple.of(actualsTag, inputClassifiedKeyed)
                    .and(categoryTag, groupedCategories)
                    .apply(CoGroupByKey.create());

在我的情况下，最后一步 - 重新格式化结果（来自连续流程中的标记组：

   actualCategoriesCombined
            .apply(
                    ParDo.named("Actuals : Formatting")
                            .of(
                                    new DoFn<KV<String, CoGbkResult>, TableRow>() {
                                        @Override
                                        public void processElement(ProcessContext c) throws Exception {

                                            KV<String, CoGbkResult> e = c.element();

                                            Iterable<TableRow> actualTableRows = e.getValue().getAll(actualsTag);
                                            Iterable<Iterable<Map<String, String>>> categoriesAll = e.getValue().getAll(categoryTag);

                                            for (TableRow row : actualTableRows) {

                                                // Some of the actuals do not have categories
                                                if (categoriesAll.iterator().hasNext()) {
                                                    row.put("advertiser", categoriesAll.iterator().next());
                                                }

                                                c.output(row);
                                            }
                                        }
                                    }
                            )
            )

希望这会有所帮助。再次 - 不确定内存限制。如果你尝试这种方法，请告诉结果。

Answer 2

使用Apache Beam extension Join

创建笛卡尔积

import org.apache.beam.sdk.extensions.joinlibrary.Join;

...

// Use function Join.fullOuterJoin(final PCollection<KV<K, V1>> leftCollection, final PCollection<KV<K, V2>> rightCollection, final V1 leftNullValue, final V2 rightNullValue)
// and the same key for all rows to create cartesian product as it is shown below:

    public static void process(Pipeline pipeline, DataInputOptions options) {
        PCollection<KV<Integer, CpuItem>> cpuList = pipeline
                .apply("ReadCPUs", TextIO.read().from(options.getInputCpuFile()))
                .apply("Creating Cpu Objects", new CpuItem()).apply("Preprocess Cpu",
                        MapElements
                                .into(TypeDescriptors.kvs(TypeDescriptors.integers(), TypeDescriptor.of(CpuItem.class)))
                                .via((CpuItem e) -> KV.of(0, e)));

        PCollection<KV<Integer, GpuItem>> gpuList = pipeline
                .apply("ReadGPUs", TextIO.read().from(options.getInputGpuFile()))
                .apply("Creating Gpu Objects", new GpuItem()).apply("Preprocess Gpu",
                        MapElements
                                .into(TypeDescriptors.kvs(TypeDescriptors.integers(), TypeDescriptor.of(GpuItem.class)))
                                .via((GpuItem e) -> KV.of(0, e)));

        PCollection<KV<Integer,KV<CpuItem,GpuItem>>>  cartesianProduct = Join.fullOuterJoin(cpuList, gpuList, new CpuItem(), new GpuItem());
        PCollection<String> finalResultCollection = cartesianProduct.apply("Format results", MapElements.into(TypeDescriptors.strings())
                .via((KV<Integer, KV<CpuItem,GpuItem>> e) -> e.getValue().toString()));
        finalResultCollection.apply("Output the results",
                TextIO.write().to("fps.batchproc\\parsed_cpus").withSuffix(".log"));
        pipeline.run();
    }

在此行上方的代码中

...
        .via((CpuItem e) -> KV.of(0, e)));
...

我为输入数据中可用的所有行创建键等于0的Map。结果，所有行都匹配。等于没有WHERE子句的SQL表达式JOIN

如何在Dataflow中做两个PCollections的笛卡尔积？

2 个答案: