Flink Table API 与 SQL 编程整理

Flink API 总共分为4层链接这里主要整理 Table API 的使用

Table API是流处理和批处理通用的关系型 API，Table API可以基于流输入或者批输入来运行而不需要进行任何修改。Table API 是 SQL语言的超集并专门为 Apache Flink设计的，Table API是 Scala 和 Java语言集成式的 API。与常规 SQL语言中将查询指定为字符串不同，Table API查询是以 Java或 Scala 中的语言嵌入样式来定义的，具有IDE支持如：自动完成和语法检测。需要引入的 pom依赖如下：

1 <dependency>
2     <groupId>org.apache.flink</groupId>
3     <artifactId>flink-table_2.12</artifactId>
4     <version>1.7.2</version>
5 </dependency>

Table API & SQL

TableAPI：WordCount案例

tab.groupBy("word").select("word,count(1) as count")

SQL：WordCount案例

SELECT word,COUNT(*) AS cnt FROM MyTable GROUP BY word

【1】声明式：用户只关系做什么，不用关心怎么做；
【2】高性能：支持查询优化，可以获取更好的执行性能，因为它的底层有一个优化器，跟SQL底层有优化器是一样的。
【3】流批统一：相同的统计逻辑，即可以流模型运行，也可以批模式运行；
【4】标准稳定：语义遵循SQL标准，不易改动。当升级等底层修改，不用考虑API兼容问题；
【5】易理解：语义明确，所见即所得；

Table API 特点

Table API 使得多声明的数据处理写起来比较容易。

1 #例如，我们将a<10的数据过滤插入到xxx表中
2 table.filter(a<10).insertInto("xxx")
3 #我们将a>10的数据过滤插入到yyy表中
4 table.filter(a>10).insertInto("yyy")

albe 是Flink自身的一种API 使得更容易扩展标准的 SQL（当且仅当需要的时候），两者的关系如下：

Table API 编程

WordCount 编程示例

 1 package org.apache.flink.table.api.example.stream;
 2 
 3 import org.apache.flink.api.common.typeinfo.Types;
 4 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
 5 import org.apache.flink.table.api.Table;
 6 import org.apache.flink.table.api.TableEnvironment;
 7 import org.apache.flink.table.api.java.StreamTableEnvironment;
 8 import org.apache.flink.table.descriptors.FileSystem;
 9 import org.apache.flink.table.descriptors.OldCsv;
10 import org.apache.flink.table.descriptors.Schema;
11 import org.apache.flink.types.Row;
12 
13 public class JavaStreamWordCount {
14 
15     public static void main(String[] args) throws Exception {
16                 //获取执行环境：CTRL + ALT + V
17         StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
18         StreamTableEnvironment tEnv = TableEnvironment.getTableEnvironment(env);
19                 //指定一个路径
20         String path = JavaStreamWordCount.class.getClassLoader().getResource("words.txt").getPath();
21                 //指定文件格式和分隔符，对应的Schema(架构）这里只有一列，类型是String
22         tEnv.connect(new FileSystem().path(path))
23             .withFormat(new OldCsv().field("word", Types.STRING).lineDelimiter("\n"))
24             .withSchema(new Schema().field("word", Types.STRING))
25             .inAppendMode()
26             .registerTableSource("fileSource");//将source注册到env中
27                 //通过 scan 拿到table，然后执行table的操作。
28         Table result = tEnv.scan("fileSource")
29             .groupBy("word")
30             .select("word, count(1) as count");
31                 //将table输出
32         tEnv.toRetractStream(result, Row.class).print();
33                 //执行
34         env.execute();
35     }
36 }

怎么定义一个 Table

Table myTable = tableEnvironment.scan("myTable") 都是从 Environment中 scan出来的。而这个 myTable 又是我们注册进去的。问题就是有哪些方式可以注册 Table。
【1】Table descriptor：类似于上述的 WordCount，指定一个文件系统fs，也可以是 kafka等，还需要一些格式和 Schema等。

1 tEnv.connect(new FileSystem().path(path))
2             .withFormat(new OldCsv().field("word", Types.STRING).lineDelimiter("\n"))
3             .withSchema(new Schema().field("word", Types.STRING))
4             .inAppendMode()
5             .registerTableSource("fileSource");//将source注册到env中

【2】自定义一个 Table source，然后把自己的 Table source 注册进去。

1 TableSource csvSource = new CsvTableSource(path,new String[]{"word"},new TypeInformation[]{Types.STRING});
2 tEnv.registerTableSource("sourceTable2", csvSource);

【3】注册一个 DataStream，例如下面一个 String类型的DataStream，命名为 myTable3 对应的 schema 只有一列叫 word。

1 DataStream<String> stream = ...
2 // register the DataStream as table " myTable3" with 
3 // fields "word"
4 tableEnv.registerDataStream("myTable3", stream, "word");

动态表

如果流中的数据类型是 case class 可以直接根据 case class的结构生成 table

tableEnv.fromDataStream(ecommerceLogDstream)

或者根据字段顺序单独命名：用单引放到字段前面来标识字段名。

tableEnv.fromDataStream(ecommerceLogDstream,'mid,'uid ......)

最后的动态表可以转换为流进行输出，如果不是简单的插入就使用toRetractStream

table.toAppendStream[(String,String)]

如何输出一个 table

当我们获取到一个结构表的时候（table类型）执行 insertInto 目标表中：resultTable.insertInto("TargetTable");

【1】Table descriptor：类似于注入，最终使用Sink进行输出，例如如下输出到 targetTable中，主要是最后一段的区别。

1 tEnv
2 .connect(new FileSystem().path(path)).withFormat(new OldCsv().field("word", Types.STRING)
3 .lineDelimiter("\n")).withSchema(new Schema()
4 .field("word", Types.STRING))
5 .registerTableSink("targetTable");

【2】自定义一个 Table sink，输出到自己的 sinkTable2注册进去。

1 TableSink csvSink = new CsvTableSink(path,new String[]{"word"},new TypeInformation[]{Types.STRING});
2 tEnv.registerTableSink("sinkTable2", csvSink);

【3】输出一个 DataStream，例如下面产生一个RetractStream，对应要给 Tuple2的联系。Boolean 这行记录时add还是delete。如果使用了 groupby，table 转化为流的时候只能使用 toRetractStream。得到的第一个 boolean型字段标识 true就是最新的数据(Insert)，false表示过期老数据(Delete)。如果使用的 api包括时间窗口，那么窗口的字段必须出现在 groupBy中。

1 // emit the result table to a DataStream
2 DataStream<Tuple2<Boolean, Row>> stream = tableEnv.toRetractStream(resultTable, Row.class)
3 stream.filter(_._1).print()

案例代码：

 1 package com.zzx.flink
 2 
 3 import java.util.Properties
 4 
 5 import com.alibaba.fastjson.JSON
 6 import org.apache.flink.api.common.serialization.SimpleStringSchema
 7 import org.apache.flink.streaming.api.TimeCharacteristic
 8 import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
 9 import org.apache.flink.streaming.api.scala._
10 import org.apache.flink.streaming.api.windowing.time.Time
11 import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer011
12 import org.apache.flink.table.api.java.Tumble
13 import org.apache.flink.table.api.{StreamTableEnvironment, Table, TableEnvironment}
14 
15 
16 
17 object FlinkTableAndSql {
18   def main(args: Array[String]): Unit = {
19     //执行环境
20     val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
21     //设置 时间特定为 EventTime
22     env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
23 
24     //读取数据  MyKafkaConsumer 为自定义的 kafka 工具类,并传入 topic
25     val dstream: DataStream[String] = env.addSource(MyKafkaConsumer.getConsumer("FLINKTABLE&SQL"))
26 
27     //将字符串转换为对象
28     val ecommerceLogDstream:DataStream[SensorReding] = dstream.map{
29      /* 引入如下依赖
30       <dependency>
31         <groupId>com.alibaba</groupId>
32         <artifactId>fastjson</artifactId>
33         <version>1.2.36</version>
34       </dependency>*/
35           //将 String 转换为 SensorReding
36       jsonString => JSON.parseObject(jsonString,classOf[SensorReding])
37     }
38 
39     //告知 watermark 和 evetTime如何提取
40     val ecommerceLogWithEventTimeDStream: DataStream[SensorReding] =ecommerceLogDstream.assignTimestampsAndWatermarks(
41           new BoundedOutOfOrdernessTimestampExtractor[SensorReding](Time.seconds(0)) {
42       override def extractTimestamp(t: SensorReding): Long = {
43         t.timestamp
44       }
45     })
46     //设置并行度
47     ecommerceLogDstream.setParallelism(1)
48 
49     //创建 Table 执行环境
50     val tableEnv: StreamTableEnvironment = TableEnvironment.getTableEnvironment(env)
51     var ecommerceTable: Table = tableEnv.fromTableSource(ecommerceLogWithEventTimeDStream ,'mid,'uid,'ch,'ts.rowtime)
52 
53     //通过 table api进行操作
54     //每10秒统计一次各个渠道的个数 table api解决
55     //groupby window=滚动式窗口 用 eventtime 来确定开窗时间
56     val resultTalbe: Table = ecommerceTable.window(Tumble over 10000.millis on 'ts as 'tt).groupBy('ch,'tt).select('ch,'ch.count)
57     var ecommerceTalbe: String = "xxx"
58     //通过 SQL 执行
59     val resultSQLTable: Table = tableEnv.sqlQuery("select ch,count(ch) from "+ ecommerceTalbe +"group by ch,Tumble(ts,interval '10' SECOND")
60 
61     //把 Table 转化成流输出
62     //val appstoreDStream: DataStream[(String,String,Long)] = appstoreTable.toAppendStream[(String,String,Long)]
63     val resultDStream: DataStream[(Boolean,(String,Long))] = resultSQLTable.toRetractStream[(String,Long)]
64     //过滤
65     resultDStream.filter(_._1)
66     env.execute()
67   }
68 }
69 object MyKafkaConsumer {
70   def getConsumer(sourceTopic: String): FlinkKafkaConsumer011[String] ={
71   val bootstrapServers = "hadoop1:9092"
72   // kafkaConsumer 需要的配置参数
73   val props = new Properties
74   // 定义kakfa 服务的地址，不需要将所有broker指定上
75   props.put("bootstrap.servers", bootstrapServers)
76   // 制定consumer group
77   props.put("group.id", "test")
78 
79   // 是否自动确认offset
80   props.put("enable.auto.commit", "true")
81   // 自动确认offset的时间间隔
82   props.put("auto.commit.interval.ms", "1000")
83   // key的序列化类
84   props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer")
85   // value的序列化类
86   props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer")
87   //从kafka读取数据,需要实现 SourceFunction 他给我们提供了一个
88   val consumer = new FlinkKafkaConsumer011[String](sourceTopic, new SimpleStringSchema, props)
89   consumer
90   }
91 }

关于时间窗口

【1】用到时间窗口，必须提前声明时间字段，如果是 processTime 直接在创建动态表时进行追加就可以。如下的ps.proctime。

1 val ecommerceLogTable: Table = tableEnv
2     .fromDataStream( ecommerceLogWithEtDstream,
3         `mid,`uid,`appid,`area,`os,`ps.proctime )

【2】如果是 EventTime 要在创建动态表时声明。如下的 ts.rowtime。

1 val ecommerceLogTable: Table = tableEnv
2     .fromDataStream( ecommerceLogWithEtDstream,
3         'mid,'uid,'appid,'area,'os,'ts.rowtime)

【3】滚动窗口可以使用 Tumble over 10000.millis on 来表示

1 val table: Table = ecommerceLogTable.filter("ch = 'appstore'")
2     .window(Tumble over 10000.millis on 'ts as 'tt)
3     .groupBy('ch,'tt)
4     .select("ch,ch.count")

如何查询一个 table

为了会有 GroupedTable等，为了增加限制，写出正确的API。

Table API 操作分类

1、与 sql 对齐的操作，select、as、filter等；
2、提升 Table API 易用性的操作；
——Columns Operation 易用性：假设有一张 100列的表，我们需要去掉一列，需要怎么操作？第三个API可以帮你完成。我们先获取表中的所有 Column，然后通过 dropColumn去掉不需要的列即可。主要是一个Table上的算子。

Operators	Examples
AddColumns	Table orders = tableEnv.scan("Orders"); Table result = orders.addColumns("concat(c,'sunny')as desc"); 添加新的列，要求是列名不能重复。
addOrReplaceColumns	Table orders = tableEnv.scan("Orders"); Table result = order.addOrReplaceColumns("concat(c,'sunny') as desc");添加列，如果存在则覆盖
DropColumns	Table orders = tableEnv.scan("Orders"); Table result = orders.dropColumns("b c");
RenameColumns	Table orders = tableEnv.scan("Orders"); able result = orders.RenameColumns("b as b2,c as c2);列重命名

——Columns Function 易用性：假设有一张表，我么需要获取第20-80列，该如何获取。类似一个函数，可以用在列选择的任何地方，例如：Table.select(withColumns(a,1 to 10)）、GroupBy等等。

语法	描述
withColumns(...)	选择你指定的列
withoutColumns(...)	反选你指定的列

列的操作语法（建议）：如下，它们都是上层包含下层的关系。

 1 columnOperation:
 2     withColumns(columnExprs) / withoutColumns(columnExprs) #可以接收多个参数 columnExpr
 3 columnExprs:
 4     columnExpr [, columnExpr]*  #可以分为如下三种情况
 5 columnExpr:
 6     columnRef | columnIndex to columnIndex | columnName to columnName #1 cloumn引用  2下标范围操作  3名字的范围操作
 7 columnRef:
 8     columnName(The field name that exists in the table) | columnIndex(a positive integer starting at 1)
 9 
10 Example: withColumns(a, b, 2 to 10, w to z)

Row based operation
—— Map operation 易用性：

 1 //方法签名： 接收一个 scalarFunction 参数，返回一个 Table
 2 def map(scalarFunction: Expression): Table
 3 
 4 class MyMap extends ScalarFunction {
 5     var param : String = ""
 6     
 7     //eval 方法接收一些输入
 8     def eval([user defined inputs]): Row = {
 9         val result = new Row(3)
10         // Business processing based on data and parameters
11         // 根据数据和参数进行业务处理，返回最终结果
12         result
13     }
14     //指定结果对应的类型，例如这里 Row的类型，Row有三列
15     override def getResultType(signature: Array[Class[_]]): 
16     TypeInformation[_] = {
17         Types.ROW(Types.STRING, Types.INT, Types.LONG)
18     }
19 }
20 
21 //使用 fun('e) 得到一个 Row 并定义名称 abc 然后获取 ac列
22 val res = tab
23 .map(fun('e)).as('a, 'b, 'c)
24 .select('a, 'c)
25 
26 //好处：当你的列很多的时候，并且每一类都需要返回一个结果的时候
27 table.select(udf1(), udf2(), udf3()….) 
28 VS 
29 table.map(udf())

Map是输入一条输出一条

——FlatMap operation 易用性：

 1 //方法签名：出入一个tableFunction 
 2 def flatMap(tableFunction: Expression): Table
 3 #tableFunction 实现的列子，返回一个 User类型，是一个 POJOs类型，Flink能够自动识别类型。
 4 case class User(name: String, age: Int)
 5 class MyFlatMap extends TableFunction[User] {
 6     def eval([user defined inputs]): Unit = {
 7         for(..){
 8             collect(User(name, age))
 9         }
10     }
11 }
12 
13 //使用
14 val res = tab
15 .flatMap(fun('e,'f)).as('name, 'age) 
16 .select('name, 'age)
17 Benefit
18 
19 //好处
20 table.joinLateral(udtf) VS table.flatMap(udtf())

FlatMap 是输入一行输出多行

——Aggregate operation 易用性：

 1 #方法签名：接收aggregateFunction
 2 def aggregate(aggregateFunction: Expression): AggregatedTable
 3 class AggregatedTable(table: Table, groupKeys: Seq[Expression], aggFunction: Expression)
 4 #输入参数，定义aggregateFunction
 5 class CountAccumulator extends JTuple1[Long] {
 6     f0 = 0L //count #刚开始初始化为0
 7 }
 8 #定义count的聚合函数
 9 class CountAgg extends AggregateFunction[JLong, CountAccumulator]{
10     def accumulate(acc: CountAccumulator): Unit = {
11     acc.f0 += 1L
12 }
13 //返回最终结果
14 override def getValue(acc: CountAccumulator): JLong = {
15     acc.f0
16 }
17 ... retract()/merge()
18 }
19 
20 //使用：
21 val res = tab
22 .groupBy('a)
23 .aggregate(agg('e,'f) as ('a, 'b, 'c))
24 .select('a, 'c)
25 
26 //好处：
27 table.select(agg1(), agg2(), agg3()….)
28 VS 
29 table.aggregate(agg())

Aggregate operation 输入多行输出一行

——FlatAggregate operation 功能性：

 1 #方法签名：输入 tableAggregateFunction 与 AggregateFunction 很相似
 2 def flatAggregate(tableAggregateFunction: Expression): FlatAggregateTable
 3 class FlatAggregateTable(table: Table, groupKey: Seq[Expression], tableAggFun: Expression)
 4 class TopNAcc {
 5     var data: MapView[JInt, JLong] = _ // (rank -> value)
 6         ...
 7     }
 8     class TopN(n: Int) extends TableAggregateFunction[(Int, Long), TopNAccum] {
 9         def accumulate(acc: TopNAcc, [user defined inputs]) {
10         ...
11     }
12         #可以那多 column，进行多个输出
13     def emitValue(acc: TopNAcc, out: Collector[(Int, Long)]): Unit = {
14         ...
15     }
16     ...retract/merge
17 }
18 
19 #用法
20 val res = tab
21 .groupBy(‘a)
22 .flatAggregate(
23 flatAggFunc(‘e,’f) as (‘a, ‘b, ‘c))
24 .select(‘a, ‘c)
25 
26 #好处
27 新增了一种agg，输出多行

FlatAggregate operation 输入多行输出多行

Aggregate 与 FlatAggregate 的区别：使用 Max 和 Top2的场景比较 Aggregate 和 FlatAggregate 之间的差别。如下有一张输入表，表有三列（ID、NAME、PRICE)，然后对Price 求最大指和Top2。
Max 操作是蓝线，首先创建累加器，然后在累加器上 accumulate操作，例如6过去是6，3过去没有6大还是6等等。得到最终得到8的结果。
TOP2操作时红线，首先创建累加器，然后在累加器上 accumulate操作，例如6过去是6，3过去因为是两个元素所以3也保存，当5过来时，和最小的比较，3就被淘汰了等等。得到最终得到8和6的结果。