FlinkSQL 中上下文、表、视图解析

SQL 上下⽂:TableEnvironment

TableEnvironment 包含的功能如下:

Catalog 管理、表管理、SQL 查询、UDF 管理、UDF 扩展、DataStream\Table\SQL API 转换。

1.通过 EnvironmentSettings 创建 TableEnvironment
// 1. 设置环境信息
EnvironmentSettings settings = EnvironmentSettings
    .newInstance()
    .inStreamingMode() // 声明为流任务
    //.inBatchMode() // 声明为批任务
    .build();
                
// 2. 创建 TableEnvironment
TableEnvironment tEnv = TableEnvironment.create(settings);

EnvironmentSettings 的其它配置项

2.通过已有的 StreamExecutionEnvironment 创建 TableEnvironment
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
StreamTableEnvironment streamTableEnvironment = StreamTableEnvironment.create(env);

在 1.13 版本中,如果是 inStreamingMode ,创建的 TableEnvironment 实例为 StreamTableEnvironmentImpl 。

如果是 inBatchMode ,创建的 TableEnvironment 实例为 TableEnvironmentImpl 。

2)SQL 中表的概念

⼀个表的全名(标识)由三部分组成: Catalog 名称.数据库名称.表名称,如果 Catalog 名称 或者 数据库 名称 没有指明,会使⽤默认值 default。

表可以是常规的(外部表 TABLE),也可以是虚拟的(视图 VIEW)。

外部表 TABLE:描述的是外部数据,例如⽂件(HDFS)、消息队列(Kafka)等。

视图 VIEW:从已经存在的表中创建,视图⼀般是⼀个 SQL 逻辑的查询结果。

3)SQL 临时表、永久表

表(视图、外部表)可以是临时的,并与单个 Flink session(可以理解为 Flink 任务运⾏⼀次就是⼀个 session) 的⽣命周期绑定。

表(视图、外部表)也可以是永久的,并且对多个 Flink session 都⽣效。

临时表:通常保存于内存中并且仅在创建它们的 Flink session(可以理解为⼀次 Flink 任务的运⾏)持续期间存在。这些表对于其它 session(即其他 Flink 任务或⾮此次运⾏的 Flink 任务)是不可⻅的。因为这个表的元数据没有被持久化。

-- 临时外部表
CREATE TEMPORARY TABLE source_table (
 user_id BIGINT,
 `name` STRING
) WITH (
 'connector' = 'user_defined',
 'format' = 'json',
 'class.name' = 'flink.examples.sql._03.source_sink.table.user_defined.UserDefinedS
);

-- 临时视图
CREATE TEMPORARY VIEW query_view as
SELECT
 *
FROM source_table;

永久表:需要外部 Catalog(例如 Hive Metastore)来持久化表的元数据。⼀旦永久表被创建,它将对任何连接到这个 Catalog 的 Flink session 可⻅且持续存在,直⾄从 Catalog 中被明确删除。

-- 永久外部表。需要外部 Catalog 持久化!!!
CREATE TABLE source_table (
 user_id BIGINT,
 `name` STRING
) WITH (
 'connector' = 'user_defined',
 'format' = 'json',
 'class.name' = 'flink.examples.sql._03.source_sink.table.user_defined.UserDefinedS
);

-- 永久视图。需要外部 Catalog 持久化!!!
CREATE VIEW query_view as
SELECT
 *
FROM source_table;

如果临时表和永久表使⽤了相同的名称(Catalog名.数据库名.表名),那么在这个 Flink session 中,任务访问到这个表时,访问到的永远是临时表(即相同名称的表,临时表会屏蔽永久表)。

4)SQL 外部数据表

⽬前在实时数据的场景中多以消息队列作为数据表,此处以 Kafka 为例创建⼀个外部数据表。

Table API 创建外部表:

public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        EnvironmentSettings settings = EnvironmentSettings
                .newInstance()
                .useBlinkPlanner()
                .inStreamingMode()
                .build();

        StreamTableEnvironment tEnv = StreamTableEnvironment.create(env, settings);

        // kafka 数据源
        DataStream<Row> r = env.addSource(new FlinkKafkaConsumer<Row>(...));

        // 将 DataStream 转为⼀个 Table API 中的 Table 对象进⾏使⽤
        Table sourceTable = tEnv.fromDataStream(r
                , Schema
                        .newBuilder()
                        .column("f0", "string")
                        .column("f1", "string")
                        .column("f2", "bigint")
                        .columnByExpression("proctime", "PROCTIME()")
                        .build());

        tEnv.createTemporaryView("source_table", sourceTable);

        String selectWhereSql = "select f0 from source_table where f1 = 'b'";

        Table resultTable = tEnv.sqlQuery(selectWhereSql);

        tEnv.toRetractStream(resultTable, Row.class).print();

        env.execute();
    }

上述案例中,Table API 将⼀个 DataStream 的结果集通过 StreamTableEnvironment::fromDataStream 转为⼀个 Table 对象来使⽤。

SQL API 创建外部数据表

EnvironmentSettings settings = EnvironmentSettings
                .newInstance()
                .useBlinkPlanner()
                .inStreamingMode()
                .build();

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        StreamTableEnvironment tEnv = StreamTableEnvironment.create(env, settings);
        
        // SQL API 执⾏ create table 创建表
        tEnv.executeSql(
                "CREATE TABLE KafkaSourceTable (\n"
                        + " `f0` STRING,\n"
                        + " `f1` STRING\n"
                        + ") WITH (\n"
                        + " 'connector' = 'kafka',\n"
                        + " 'topic' = 'topic',\n"
                        + " 'properties.bootstrap.servers' = 'localhost:9092',\n"
                        + " 'properties.group.id' = 'testGroup',\n"
                        + " 'format' = 'json'\n"
                        + ")"
        );
        
        Table t = tEnv.sqlQuery("SELECT * FROM KafkaSourceTable");

创建⽅式:使⽤ Create Table xxx DDL 定义⼀个 Kafka 数据源(输⼊)表(也可以是 Kafka 数据 汇(输出)表)。

5)SQL 视图 VIEW

VIEW 就是⼀段 SQL 逻辑的查询结果,视图 VIEW 在 Table API 中的体现就是:⼀个 Table 的 Java 对象,封装了⼀段查询逻辑。

Table API 创建 VIEW

EnvironmentSettings settings = EnvironmentSettings
                .newInstance()
                .inStreamingMode() // 声明为流任务
                .build();
        
        TableEnvironment tEnv = TableEnvironment.create(settings);
        
        // Table API 中的⼀个 Table 对象
        Table projTable = tEnv.from("X").select(...);
        
        // 将 projTable 创建为⼀个叫做 projectedTable 的 VIEW
        tEnv.createTemporaryView("projectedTable", projTable);

Table API 使⽤了 TableEnvironment::createTemporaryView 接⼝将⼀个 Table 对象创建为⼀个 VIEW。

SQL API 创建 VIEW:

EnvironmentSettings settings = EnvironmentSettings
                .newInstance()
                .inStreamingMode() // 声明为流任务
                .build();
        
        TableEnvironment tEnv = TableEnvironment.create(settings);
        
        String sql = "CREATE TABLE source_table (\n"
                + " user_id BIGINT,\n"
                + " `name` STRING\n"
                + ") WITH (\n"
                + " 'connector' = 'user_defined',\n"
                + " 'format' = 'json',\n"
                + " 'class.name' = 'flink.examples.sql._03.source_sink.table.user_defined.User',\n"
                + ");\n"
                + "\n"
                + "CREATE TABLE sink_table (\n"
                + " user_id BIGINT,\n"
                + " name STRING\n"
                + ") WITH (\n"
                + " 'connector' = 'print'\n"
                + ");\n"
                + "CREATE VIEW query_view as\n" // 创建 VIEW
                + "SELECT\n"
                + " *\n"
                + "FROM source_table\n"
                + ";\n"
                + "INSERT INTO sink_table\n"
                + "SELECT\n"
                + " *\n"
                + "FROM query_view;";
        
        Arrays.stream(sql.split(";"))
                .forEach(tEnv::executeSql);

SQL API 通过⼀段 CREATE VIEW query_view as select * from source_table 来创建的 VIEW。

在 Table API 中的⼀个 Table 对象被后续的多个查询使⽤的场景下:

Table 对象不会真的产⽣⼀个中间表供下游多个查询去引⽤,即多个查询不共享这个 Table 的结果,可以理解为是⼀种中间表的简化写法,不会先产出⼀个中间表结果,然后将这个结果在下游多个查询中复⽤,后续的多个查询会将这个 Table 的逻辑执⾏多次,类似于 with tmp as (DML) 的语法。

6)⼀个 SQL 查询案例

案例场景:计算每⼀种商品(sku_id 唯⼀标识)的售出个数、总销售额、平均销售额、最低价、最⾼价

数据准备:数据源为商品的销售流⽔(sku_id:商品,price:销售价格),然后写⼊到 Kafka 的指定 topic(sku_id:商品,count_result:售出个数、sum_result:总销售额、avg_result:平均销售额、 min_result:最低价、max_result:最⾼价)

EnvironmentSettings settings = EnvironmentSettings
                .newInstance()
                .inStreamingMode() // 声明为流任务
                //.inBatchMode() // 声明为批任务
                .build();
        
        TableEnvironment tEnv = TableEnvironment.create(settings);
        
        // 1. 创建⼀个数据源(输⼊)表,这⾥的数据源是 flink ⾃带的⼀个随机 mock 数据的数据源。
        String sourceSql = "CREATE TABLE source_table (\n"
                + " sku_id STRING,\n"
                + " price BIGINT\n"
                + ") WITH (\n"
                + " 'connector' = 'datagen',\n"
                + " 'rows-per-second' = '1',\n"
                + " 'fields.sku_id.length' = '1',\n"
                + " 'fields.price.min' = '1',\n"
                + " 'fields.price.max' = '1000000'\n"
                + ")";
        
        // 2. 创建⼀个数据汇(输出)表,输出到 kafka 中
        String sinkSql = "CREATE TABLE sink_table (\n"
                + " sku_id STRING,\n"
                + " count_result BIGINT,\n"
                + " sum_result BIGINT,\n"
                + " avg_result DOUBLE,\n"
                + " min_result BIGINT,\n"
                + " max_result BIGINT,\n"
                + " PRIMARY KEY (`sku_id`) NOT ENFORCED\n"
                + ") WITH (\n"
                + " 'connector' = 'upsert-kafka',\n"
                + " 'topic' = 'test',\n"
                + " 'properties.bootstrap.servers' = 'localhost:9092',\n"
                + " 'key.format' = 'json',\n"
                + " 'value.format' = 'json'\n"
                + ")";
        
        // 3. 执⾏⼀段 group by 的聚合 SQL 查询
        String selectWhereSql = "insert into sink_table\n"
                + "select sku_id,\n"
                + " count(*) as count_result,\n"
                + " sum(price) as sum_result,\n"
                + " avg(price) as avg_result,\n"
                + " min(price) as min_result,\n"
                + " max(price) as max_result\n"
                + "from source_table\n"
                + "group by sku_id";
        
        tEnv.executeSql(sourceSql);
        tEnv.executeSql(sinkSql);
        tEnv.executeSql(selectWhereSql);
7)SQL 与 DataStream API 的转换

1.13 版本,只有流任务⽀持 Table 和 DataStream 之间的转换。

1.14 版本,流和批任务均⽀持 Table 和 DataStream 之间的转换。

StreamTableEnvironment::toDataStream
StreamTableEnvironment::fromDataStream
相关推荐
皓7417 分钟前
服饰电商行业知识管理的创新实践与知识中台的重要性
大数据·人工智能·科技·数据分析·零售
Mephisto.java9 分钟前
【大数据学习 | kafka高级部分】kafka的kraft集群
大数据·sql·oracle·kafka·json·hbase
Mephisto.java11 分钟前
【大数据学习 | kafka高级部分】kafka的文件存储原理
大数据·sql·oracle·kafka·json
W Y1 小时前
【架构-37】Spark和Flink
架构·flink·spark
ycsdn101 小时前
Caused by: org.apache.flink.api.common.io.ParseException: Row too short:
大数据·flink
DolphinScheduler社区2 小时前
Apache DolphinScheduler + OceanBase,搭建分布式大数据调度平台的实践
大数据
时差9533 小时前
MapReduce 的 Shuffle 过程
大数据·mapreduce
kakwooi4 小时前
Hadoop---MapReduce(3)
大数据·hadoop·mapreduce
数新网络4 小时前
《深入浅出Apache Spark》系列②:Spark SQL原理精髓全解析
大数据·sql·spark
师太,答应老衲吧6 小时前
SQL实战训练之,力扣:2020. 无流量的帐户数(递归)
数据库·sql·leetcode