Flink SQL & Table 编程和案例

• Flink Table & SQL 概述
  • 背景
    Flink SQL 是 Flink 实时计算为简化计算模型，降低用户使用实时计算门槛而设计的一套符合标准 SQL 语义的开发语言。
    DataStream 和 DataSet 两套 API，并没有做到事实上的批流统一，因为用户还是使用了2套API。正是​因为 Flink Table & SQL 的加入，可以说 Flink 在某种程度上做到了事实上的批流一体。
  • 原理
    
    1、上图是一张经典的 Flink Table & SQL 实现原理图，可以看到 Calcite 在整个架构中处于绝对核心地位。
    2、Flink和Hive一样都使用了Apache Calcite, 把SQL的解析、优化和执行交给了他​。
    3、从图中可以看到无论是批查询 SQL 还是流式查询 SQL，都会经过对应的转换器 Parser 转换成为节点树 SQLNode tree，然后生成逻辑执行计划 Logical Plan，逻辑执行计划在经过优化后生成真正可以执行的物理执行计划，交给 DataSet 或者 DataStream 的 API 去执行。​
  • 动态表
    1、与传统的表 SQL 查询相比，Flink Table & SQL 在处理流数据时会时时刻刻处于动态的数据变化中，所以便有了一个动态表的概念。
    2、动态表的查询与静态表一样，但是，在查询动态表的时候，SQL 会做连续查询，不会终止。
• Flink Table & SQL 算子和内置函数
  自0.9版本之后开始支持Flink Table&SQL，正在迭代中，并不能支持所有场景下的计算逻辑。
  开发时尽量选择场景明确、逻辑不是极其复杂的场景。​
  • 常用算子
  • SELECT/AS/WHERE
  • GROUP BY/DISTINCT/HAVING
  • JOIN
    目前 Flink 的 JOIN 只支持等值连接
  • WINDOW
    • 滚动窗口
      ​窗口数据有固定的大小，窗口中的数据不会叠加；
      ​
      举例说明：计算每个用户每天的订单数量：
      SELECT user, TUMBLE_START(timeLine, INTERVAL '1' DAY) as winStart, SUM(amount) FROM Orders GROUP BY TUMBLE(timeLine, INTERVAL '1' DAY), user;​​
      其中，TUMBLE_START 和 TUMBLE_END 代表窗口的开始时间和窗口的结束时间，TUMBLE (timeLine, INTERVAL '1' DAY) 中的 timeLine 代表时间字段所在的列，INTERVAL '1' DAY 表示时间间隔为一天。​
    • 滑动窗口
      窗口数据有固定大小，并且有生成间隔；
      ​
      例如，我们要每间隔一小时计算一次过去 24 小时内每个商品的销量：
      SELECT product, SUM(amount) FROM Orders GROUP BY HOP(rowtime, INTERVAL '1' HOUR, INTERVAL '1' DAY), product
      上述案例中的 INTERVAL '1' HOUR 代表滑动窗口生成的时间间隔。
    • 会话窗口
      窗口数据没有固定的大小，根据用户传入的参数进行划分，窗口数据无叠加；
      会话窗口定义了一个非活动时间，假如在指定的时间间隔内没有出现事件或消息，则会话窗口关闭。
      
      ​举例，我们需要计算每个用户过去 1 小时内的订单量：
      ​SELECT user, SESSION_START(rowtime, INTERVAL '1' HOUR) AS sStart, SESSION_ROWTIME(rowtime, INTERVAL '1' HOUR) AS sEnd, SUM(amount) FROM Orders GROUP BY SESSION(rowtime, INTERVAL '1' HOUR), user​​
    • 内置函数
      比较函数
      逻辑函数
      算术函数
      字符串处理函数
      时间函数
  • Flink Table & SQL 案例
    已提交到gitee
    问题记录：1、Item类必须是静态​​ 2、Tuple4类应该选择org.apache.flink.api.java.tuple.Tuple4;而不是scala包下的

package com.flink.demo.source;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.typeinfo.TypeHint;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.java.tuple.Tuple4;
import org.apache.flink.streaming.api.collector.selector.OutputSelector;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.EnvironmentSettings;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;

import java.util.ArrayList;

/**
 * 我们把实时的商品数据流进行分流，分成 even 和 odd 两个流进行 JOIN，条件是名称相同，
 * 最后，把两个流的 JOIN 结果输出。
 *
 * @author zsyoung@qq.com
 * 2020/7/9 0:52
 */
public class TableDemo {

    public static void main(String[] args) throws Exception {
        EnvironmentSettings bsSettings = EnvironmentSettings.newInstance().useBlinkPlanner().inStreamingMode().build();
        StreamExecutionEnvironment bsEnv = StreamExecutionEnvironment.getExecutionEnvironment();
        StreamTableEnvironment bsTableEnv = StreamTableEnvironment.create(bsEnv, bsSettings);

        SingleOutputStreamOperator<MyStreamingSource.Item> source = bsEnv.addSource(new MyStreamingSource()).map(new MapFunction<MyStreamingSource.Item, MyStreamingSource.Item>() {
            @Override
            public MyStreamingSource.Item map(MyStreamingSource.Item item) throws Exception {
                return item;
            }
        });

        DataStream<MyStreamingSource.Item> evenSelect = source.split(new OutputSelector<MyStreamingSource.Item>() {
            @Override
            public Iterable<String> select(MyStreamingSource.Item item) {
                ArrayList<String> output = new ArrayList<>();
                if (item.getId() % 2 == 0) {
                    output.add("even");
                } else {
                    output.add("odd");
                }
                return output;
            }
        }).select("even");

        DataStream<MyStreamingSource.Item> oddSelect = source.split(new OutputSelector<MyStreamingSource.Item>() {
            @Override
            public Iterable<String> select(MyStreamingSource.Item item) {
                ArrayList<String> output = new ArrayList<>();
                if (item.getId() % 2 == 0) {
                    output.add("even");
                } else {
                    output.add("odd");
                }
                return output;
            }
        }).select("odd");


        //创建临时视图
        bsTableEnv.createTemporaryView("evenTable", evenSelect, "name,id");
        bsTableEnv.createTemporaryView("oddTable", oddSelect, "name,id");

        Table queryTable = bsTableEnv.sqlQuery("select a.id,a.name,b.id,b.name from evenTable as a join oddTable as b on a.name= b.name");
        queryTable.printSchema();

        bsTableEnv.toRetractStream(queryTable, TypeInformation.of(new TypeHint<Tuple4<Integer, String, Integer, String>>() {
        })).print();

        bsEnv.execute("streaming sql job");
    }
}