Flink_java

二 、table API 的使用

2.1 、基本语法

2.1.1 、Scan

	与SQL中的FROM相似，对已注册的表执行扫描操作
	Table orders = tableEnv.scan("Orders");

				Table orders = tEnv.scan("Orders"); // schema (a, b, c, rowtime)
				Table counts = orders
				        .groupBy("a")
				        .select("a, b.count as cnt");
				
				// conversion to DataSet
				DataSet<Row> result = tEnv.toDataSet(counts, Row.class);
				result.print();

2.1.2、 Select

	与SQL的SELECT语义类似，执行一个select操作
	Table orders = tableEnv.scan("Orders");
	Table result = orders.select("a, c as d");
	你也可以使用(*)作为通配符，来查询表中所有字段的值
	Table result = orders.select("*");

2.1.3、 As

	重命名字段
	Table orders = tableEnv.scan("Orders");
	Table result = orders.as("x, y, z, t");

2.1.4 、Where / Filter

与SQL中的WHERE类似，过滤不通过过滤谓词的行
			Table orders = tableEnv.scan("Orders");
			Table result = orders.where("b === 'red'");
			
			Table orders = tableEnv.scan("Orders");
			Table result = orders.filter("a % 2 === 0");

2.1.5 AddColumns

	执行字段添加操作。 如果添加的字段已存在，它将抛出异常。
	Table orders = tableEnv.scan("Orders");
	Table result = orders.addColumns("concat(c, 'sunny')");

2.1.6 DropColumns

	执行字段放置操作。 字段表达式应该是字段引用表达式，并且只能删除现有字段.
	Table orders = tableEnv.scan("Orders"); Table result = orders.dropColumns("b, c");

2.1.7 RenameColumns

	执行字段重命名操作。 字段表达式应该是别名表达式，并且只能重命名现有字段。
		Table orders = tableEnv.scan("Orders");
		Table result = orders.renameColumns("b as b2, c as c2");

2.1.8 、Order By

2.1.9、案例

• 扫描Orders表格。它过滤空值，规范化aString类型的字段，并计算每小时和产品a的平均计费金额b

Table orders = tEnv.scan("Orders"); // schema (a, b, c, rowtime)

Table result = orders
        .filter("a.isNotNull && b.isNotNull && c.isNotNull")
        .select("a.lowerCase() as a, b, rowtime")
        .window(Tumble.over("1.hour").on("rowtime").as("hourlyWindow"))
        .groupBy("hourlyWindow, a")
        .select("a, hourlyWindow.end as hour, b.avg as avgBillingAmount");
        
// conversion to DataSet
	DataSet<Row> result = tEnv.toDataSet(result , Row.class);
	result.print();

2.1.10、 map

• 使用用户定义的标量函数或内置标量函数执行映射操作。如果输出类型是复合类型，则输出将被展平

	public class MyMapFunction extends ScalarFunction {
	    public Row eval(String a) {
	        return Row.of(a, "pre-" + a);
	    }
	
	    @Override
	    public TypeInformation<?> getResultType(Class<?>[] signature) {
	        return Types.ROW(Types.STRING(), Types.STRING());
	    }
	}
	
	ScalarFunction func = new MyMapFunction();
	tableEnv.registerFunction("func", func);
	
	Table table = input
	  .map(call("func", $("c")).as("a", "b"))

2.1.11、 FlatMap

• 使用表函数执行 flatMap 操作

	public class MyFlatMapFunction extends TableFunction<Row> {
	    public void eval(String str) {
	        if (str.contains("#")) {
	            String[] array = str.split("#");
	            for (int i = 0; i < array.length; ++i) {
	                collect(Row.of(array[i], array[i].length()));
	            }
	        }
	    }
	
	    @Override
	    public TypeInformation<Row> getResultType() {
	        return Types.ROW(Types.STRING(), Types.INT());
	    }
	}
	
	TableFunction func = new MyFlatMapFunction();
	tableEnv.registerFunction("func", func);
	
	Table table = input
	  .flatMap(call("func", $("c")).as("a", "b"))

2.1.12、Aggregate

• 使用聚合函数执行聚合操作。您必须使用 select 语句关闭“聚合”，并且 select 语句不支持聚合函数。如果输出类型是复合类型，则聚合的输出将被展平。

	public class MyMinMaxAcc {
	    public int min = 0;
	    public int max = 0;
	}
	
	public class MyMinMax extends AggregateFunction<Row, MyMinMaxAcc> {
	
	    public void accumulate(MyMinMaxAcc acc, int value) {
	        if (value < acc.min) {
	            acc.min = value;
	        }
	        if (value > acc.max) {
	            acc.max = value;
	        }
	    }
	
	    @Override
	    public MyMinMaxAcc createAccumulator() {
	        return new MyMinMaxAcc();
	    }
	
	    public void resetAccumulator(MyMinMaxAcc acc) {
	        acc.min = 0;
	        acc.max = 0;
	    }
	
	    @Override
	    public Row getValue(MyMinMaxAcc acc) {
	        return Row.of(acc.min, acc.max);
	    }
	
	    @Override
	    public TypeInformation<Row> getResultType() {
	        return new RowTypeInfo(Types.INT, Types.INT);
	    }
	}
	
	AggregateFunction myAggFunc = new MyMinMax();
	tableEnv.registerFunction("myAggFunc", myAggFunc);
	Table table = input
	  .groupBy($("key"))
	  .aggregate(call("myAggFunc", $("a")).as("x", "y"))
	  .select($("key"), $("x"), $("y"))

2.1.13\Group Window Aggregate

• 在组窗口上对表进行分组和聚合，可能还有一个或多个分组键。您必须使用 select 语句关闭“聚合”。并且 select 语句不支持“*”或聚合函数。

			AggregateFunction myAggFunc = new MyMinMax();
	tableEnv.registerFunction("myAggFunc", myAggFunc);
	
	Table table = input
	    .window(Tumble.over(lit(5).minutes())
	                  .on($("rowtime"))
	                  .as("w")) // define window
	    .groupBy($("key"), $("w")) // group by key and window
	    .aggregate(call("myAggFunc", $("a")).as("x", "y"))
	    .select($("key"), $("x"), $("y"), $("w").start(), $("w").end()); // access 


//window properties and aggregate results

2.2、聚合

2.2.1 、GroupBy 聚合

	与SQL的GROUP BY类似，使用以下运行的聚合运算符对分组键上的行进行分组，从而以组方式聚合行。
	Table orders = tableEnv.scan("Orders");
	Table result = orders.groupBy("a").select("a, b.sum as d");

2.2.2 、GroupBy Window 聚合

对分组窗口上的表，进行分组和聚合，可能会按一个或者多个key进行分组
Table orders = tableEnv.scan("Orders");
Table orders = tableEnv.scan("Orders");
Table result = orders .window(Tumble.over("5.minutes").on("rowtime").as("w")) // define window
　　.groupBy("a, w") // group by key and window
　　.select("a, w.start, w.end, b.sum as d"); // access window properties and aggregate

2.2.3、Over Window 聚合

与SQL的OVER类似，根据前一行和后续行的窗口（范围）为每行计算窗口聚合，参看over window获取更多信息。
	Table orders = tableEnv.scan("Orders");
	Table result = orders
	.window(Over）
	.partitionBy("a")
	.orderBy("rowtime")
	.preceding("UNBOUNDED_RANGE")
	.following("CURRENT_RANGE")
	.as("w")
	.select("a, b.avg over w, b.max over w, b.min over w") // sliding aggregate

2.2.4、Distinct

	与SQL的DISTINCT类似，返回不重合的记录。
		Table orders = tableEnv.scan("Orders");
		Table result = orders.distinct();

三、Joins操作

3.1、Inner Join

与SQL的JOIN 类似，连接两张表，两张表必须具有不同的字段名称，并且必须至少具有一个相等的连接谓词，必须通过连接运算符或使用where或filter运算符来定义。
　　Table left = tableEnv.fromDataSet(ds1, "a, b, c");
　　Table right = tableEnv.fromDataSet(ds2, "d, e, f");
　　Table result = left.join(right).where("a = d").select("a, b, e");

3.2、 Left Outer Join

	与SQL的LEFT OUTER JOIN类似，

3.3、Right Outer Join

	与SQL的RIGHT OUTER JOIN类似，

3.4、Full Outer Join

	与SQL的TableFunction Join类似

四、内部CataLog注册

4.1 内部Table注册

• 在获取TableEnvironment对象后，可以使用TableEnvironment提供的方法来注册相应的数据源和数据表信息。所有对数据库和数据表的元数据信息存放在Flink CataLog内部目录中，其存放了Flink内部所有与Table相关的元数据信息，包括表的结构信息，数据源信息等。

	Table nameSumDeptid = tableEnvironment.scan("emp").select("name,deptid,email");
	// 将 nameSumDeptid 在CataLog中注册成内部表 nameTable
	tableEnvironment.registerTable("nameTable" , nameSumDeptid)

4.2 TableSource注册

• 在使用Table API，可以将外部数据源直接注册成Table数据结构。

	// 批处理环境
	ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
	// 获取表操作环境对象
	BatchTableEnvironment tableEnvironment = BatchTableEnvironment.create(env);
	// 创建csv文件类型的TableSource
	TableSource csvSource = new CsvTable("/file.csv" , ",");
	// 将创建好的TableSource注册到BatchTableEnvironment
	tableEnvironment.registerTableSource("CsvTable" , csvSource);

五、窗口函数

5.1 Tumbling windows (滚动)

// Tumbling Event-time Window
.window(Tumble.over(lit(10).minutes()).on($("rowtime")).as("w"));

// Tumbling Processing-time Window (assuming a processing-time attribute "proctime")
.window(Tumble.over(lit(10).minutes()).on($("proctime")).as("w"));

// Tumbling Row-count Window (assuming a processing-time attribute "proctime")
.window(Tumble.over(rowInterval(10)).on($("proctime")).as("w"));

	over：将窗口的长度定义为时间
	on：要对其进行分组（时间间隔）或排序（行计数）的时间属性。对于批处理查询，
这可能是任何 Long 或 Timestamp 属性。对于流查询，这必须是声明的事件时间或处理
时间时间属性。
	as：为窗口分配别名。别名用于在以下groupBy()子句中引用窗口，并可选择在子句
中选择窗口属性，例如窗口开始、结束或行时间时间戳select()。

5.2 Sliding Windows

// Sliding Event-time Window
.window(Slide.over(lit(10).minutes())
            .every(lit(5).minutes())
            .on($("rowtime"))
            .as("w"));

// Sliding Processing-time window 
 (assuming a processing-time attribute "proctime")
.window(Slide.over(lit(10).minutes())
            .every(lit(5).minutes())
            .on($("proctime"))
            .as("w"));

// Sliding Row-count window (assuming a processing-time attribute "proctime")
	.window(Slide.over(rowInterval(10))
	.every(rowInterval(5))
	.on($("proctime"))
	.as("w"));

over:窗口的长度定义为时间
every:滑动间隔
on:要对其进行分组
as:为窗口分配别名。别名用于在以下groupBy()子句中引用窗口，并可选择在子句中选择窗口属性，例如窗口开始、结束或行时间时间戳select()。

六、DataStream->

6.1、DataStream->table

• 注册Table的几种方式

	// kafka source
	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
	env.setParallelism(10); 
	env.enableCheckpointing(60000L, CheckpointingMode.EXACTLY_ONCE);
	
	Properties properties = new Properties();
	properties.setProperty("bootstrap.servers", broker);
	properties.setProperty("group.id", groupId);
	properties.setProperty("max.partition.fetch.bytes", "10485760");
	properties.setProperty("request.timeout.ms", "120000");
	properties.setProperty("session.timeout.ms", "60000");
	properties.setProperty("heartbeat.interval.ms", "10000");
	
	FlinkKafkaConsumer09<String> myConsumer =
	 new FlinkKafkaConsumer09<String>(topic, new SimpleStringSchema(), properties);
	DataStream<String> sourceStream = env.addSource(myConsumer);

	//1、
	tableEnv.registerDataStreamInternal(“tableName”, sourceStream);
	Table table = tableEnv.scan("tableName");

	//2、
	tableEnv.registerDataStream("tableName", sourceStream);
	Table table = tableEnv.scan("tableName");
	//3、
	tableEnv.registerDataStream("tableName", sourceStream, "fieldName");
	Table table = tableEnv.scan("tableName");

	//4、
	Table table = tableEnv.fromDataStream(sourceStream, "fieldName");
	//5、
	Table table = tableEnv.fromDataStream(sourceStream);

//DataStream<String>数据类型为String，注册table时，fieldName只有一个。
//若DataStream数据类型为POJO，有多个字段，传入fieldName之间以逗号间隔

七、Table–>

7.1、Table->Datastream

//Table转换为DataStream<String>
DataStream<String> sinkStream = tableEnv.toAppendStream(table, String.class);

//Table转换为带flag的DataStream（flag=true表示该条数据为新增，flag=false表示撤回该条数据）
DataStream<Tuple2<Boolean, String>> sinkStream = tableEnv.toRetractStream(table, String.class);

7.1、Table->DataSet

	// 指定表程序
	Table orders = tEnv.from("Orders"); // schema (a, b, c, rowtime)
	Table counts = orders
	        .groupBy($("a"))
	        .select($("a"), $("b").count().as("cnt"));
	        
	// 转换为数据集
	DataSet<Row> result = tEnv.toDataSet(counts, Row.class);
	result.print()