Google cloud dataflow GoogleDataflow：从BigQuery读取，合并三个字符串字段，将键/值字段写入GoogleCloud扳手

没有一个提供的数据流模板与我需要做的匹配，所以我尝试编写自己的模板。我成功地运行了像word count示例这样的示例代码，没有任何问题，所以我尝试将从BigQuery读取和写入Panner的独立示例分割在一起，但源代码中有太多东西我不理解，无法适应我自己的问题

我真的迷路了，非常感谢您的帮助

目标是使用DataFlow和Apache Beam SDK读取包含3个字符串字段和1个整数字段的BigQuery表，然后将3个字符串字段的内容连接成一个字符串，并将该新字符串放入名为“key”的新字段中，然后我想写入key字段和整数字段（不变）对于已存在的扳手表，理想情况下，使用新键追加行，并使用已存在的键更新行的整数字段

我正试图用Java实现这一点，因为Python没有I/o连接器。非常感谢关于使用Python执行此操作的任何建议

现在，如果我能从BigQuery中读取一个表，然后用扳手将从该表中得到的任何内容写入一个表，我会非常高兴，但我甚至不能做到这一点

问题：

• 我正在使用Maven，不知道需要在pom文件中添加哪些依赖项
  
• 我不知道在java文件的开头需要哪个包和导入
  
• 我不知道是否应该使用readTableRows（）或read（SerializableFunction）来读取BigQuery
  
• 我不知道如何访问PCollection中的字符串字段来连接它们，也不知道如何仅使用key和integer字段创建新的PCollection
  
• 我不知何故需要将PCollection变成一个突变，以便写入到Spaner
  
• 我想使用INSERT UPDATE查询写入扳手表，这似乎不是扳手I/o连接器中的选项。
  

老实说，我太尴尬了，甚至不敢展示我正在运行的代码

public class SimpleTransfer {

    public static void main(String[] args) {
        // Create and set your PipelineOptions.
        DataflowPipelineOptions options = PipelineOptionsFactory.as(DataflowPipelineOptions.class);

        // For Cloud execution, set the Cloud Platform project, staging location, and specify DataflowRunner.
        options.setProject("myproject");
        options.setStagingLocation("gs://mybucket");
        options.setRunner(DataflowRunner.class);

        // Create the Pipeline with the specified options.
        Pipeline p = Pipeline.create(options);

        String tableSpec = "database.mytable";

        // read whole table from bigquery
        rowsFromBigQuery =
            p.apply(
                BigQueryIO.readTableRows()
                    .from(tableSpec);

        // Hopefully some day add a transform

        // Somehow make a Mutation
        PCollection<Mutation> mutation = rowsFromBigQuery;

        // Only way I found to write to Spanner, not even sure if that works.
        SpannerWriteResult result = mutation.apply(
            SpannerIO.write().withInstanceId("myinstance").withDatabaseId("mydatabase").grouped());

        p.run().waitUntilFinish();

    }
}

公共类SimpleTransfer{
公共静态void main（字符串[]args）{
//创建并设置管道选项。
DataflowPipelineOptions=PipelineOptions工厂.as（DataflowPipelineOptions.class）；
//对于云执行，设置云平台项目、暂存位置，并指定DataflowRunner。
选项。setProject（“myproject”）；
选项。设置标记位置（“gs://mybucket”）；
options.setRunner（DataflowRunner.class）；
//使用指定的选项创建管道。
Pipeline p=Pipeline.create（选项）；
String tableSpec=“database.mytable”；
//从bigquery读取整个表
rowsFromBigQuery=
p、 申请(
BigQueryIO.readTableRows（）
.来自（表spec）；
//希望有一天能添加一个转换
//不知怎的发生了变异
PCollection-mutation=rowsFromBigQuery；
//我找到的唯一方法是给扳手写信，甚至不确定这是否有效。
扳手writeresult=mutation.apply(
span.write（）.withInstanceId（“myinstance”）.withDatabaseId（“mydatabase”）.grouped（）；
p、 run（）.waitUntilFinish（）；
}
}

处理这些奇怪的数据类型是很可怕的，但是一旦你习惯了

表格行

和

变异

类型，你就可以编写健壮的管道了

您需要做的第一件事是获取

TableRow

s的

PCollection

，并将其转换为方便您使用的中间格式。让我们使用Beam的

KV

，它定义了一个键值对。在下面的代码段中，我们从

TableRow

提取值，并连接st你要的电话号码：

rowsFromBigQuery
            .apply(
                MapElements.into(TypeDescriptors.kvs(TypeDescriptors.strings()
                                                     TypeDescriptors.integers()))
                    .via(tableRow -> KV.of(
                               (String) tableRow.get("myKey1")
                               + (String) tableRow.get("myKey2")
                               + (String) tableRow.get("myKey3"),
                               (Integer) tableRow.get("myIntegerField"))))

最后，为了写入扳手，我们使用

突变

类型的对象，这些对象定义了我们要应用于扳手中某一行的突变类型。我们将使用另一个

映射元素

转换来完成这一操作，该转换接受N个输入，并返回N个输出。我们在其中定义插入或更新突变：

myKvPairsPCollection
            .apply(
                MapElements.into(TypeDescriptor.of(Mutation.class))
                    .via(elm -> Mutation.newInsertOrUpdateBuilder("myTableName)
                                    .set("key").to(elm.getKey())
                                    .set("value").to(elm.getValue()));

然后您可以将输出传递到

span.write

。整个管道如下所示：

        Pipeline p = Pipeline.create(options);

        String tableSpec = "database.mytable";

        // read whole table from bigquery
        PCollection<TableRow> rowsFromBigQuery =
            p.apply(
                BigQueryIO.readTableRows().from(tableSpec));

        // Take in a TableRow, and convert it into a key-value pair
        PCollection<Mutation> mutations = rowsFromBigQuery
            // First we make the TableRows into the appropriate key-value
            // pair of string key and integer.
            .apply(
                MapElements.into(TypeDescriptors.kvs(TypeDescriptors.strings()
                                                     TypeDescriptors.integers()))
                    .via(tableRow -> KV.of(
                               (String) tableRow.get("myKey1")
                               + (String) tableRow.get("myKey2")
                               + (String) tableRow.get("myKey3"),
                               (Integer) tableRow.get("myIntegerField"))))
            // Now we construct the mutations
            .apply(
                MapElements.into(TypeDescriptor.of(Mutation.class))
                    .via(elm -> Mutation.newInsertOrUpdateBuilder("myTableName)
                                    .set("key").to(elm.getKey())
                                    .set("value").to(elm.getValue()));

        // Now we pass the mutations to spanner
        SpannerWriteResult result = mutations.apply(
            SpannerIO.write()
                    .withInstanceId("myinstance")
                    .withDatabaseId("mydatabase").grouped());

        p.run().waitUntilFinish();

    }

Pipeline p=Pipeline.create（选项）；
String tableSpec=“database.mytable”；
//从bigquery读取整个表
PCollection rowsFromBigQuery=
p、 申请(
（tableSpec）中的BigQueryIO.readTableRows（）；
//获取TableRow，并将其转换为键值对
PCollection=rowsFromBigQuery
//首先，我们将TableRows转换成适当的键值
//一对字符串键和整数。
.申请(
MapElements.into（TypeDescriptors.kvs（TypeDescriptors.strings）（）
TypeDescriptors.integers（））
.通孔（表行->千伏）(
（字符串）tableRow.get（“myKey1”）
+（字符串）tableRow.get（“myKey2”）
+（字符串）tableRow.get（“myKey3”），
（整数）tableRow.get（“myIntegerField”））
//现在我们构建突变
.申请(
MapElements.into（TypeDescriptor.of（Mutation.class））
.via（elm->Mutation.newInsertOrUpdateBuilder（“myTableName”）
.set（“key”）.to（elm.getKey（））
.set（“value”）.to（elm.getValue（））；
//现在我们把突变传给扳手
扳手WriteResult=突变。应用(
写
.withInstanceId（“myinstance”）
.withDatabaseId（“mydatabase”）.grouped（）；
p、 run（）.waitUntilFinish（）；