Table API和Flink SQL

最新推荐文章于 2024-06-05 02:02:11 发布
最新推荐文章于 2024-06-05 02:02:11 发布
阅读量308 收藏
点赞数
分类专栏： Flink 文章标签： sql flink kafka
原文链接：https://ashiamd.github.io/
版权

概述

  • Flink 对批处理和流处理，提供了统一的上层 API
  • Table API 是一套内嵌在 Java 和 Scala 语言中的查询API，它允许以非常直观的方式组合来自一些关系运算符的查询
  • Flink 的 SQL 支持基于实现了 SQL 标准的 Apache Calcite

在这里插入图片描述

 使用样例

  • 导入pom依赖，1.11.X之后，推荐使用blink版本

    <!-- Table API 和 Flink SQL -->
<dependency>
  <groupId>org.apache.flink</groupId>
  <artifactId>flink-table-planner-blink_${scala.binary.version}</artifactId>
  <version>${flink.version}</version>
</dependency>

  • java样例代码

    package apitest.tableapi;

import apitest.beans.SensorReading;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.types.Row;

/**
 * @author : Ashiamd email: ashiamd@foxmail.com
 * @date : 2021/2/3 5:47 AM
 */
public class TableTest1_Example {
  public static void main(String[] args) throws Exception {
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    env.setParallelism(1);

    // 1. 读取数据
    DataStream<String> inputStream = env.readTextFile("/tmp/Flink_Tutorial/src/main/resources/sensor.txt");

    // 2. 转换成POJO
    DataStream<SensorReading> dataStream = inputStream.map(line -> {
      String[] fields = line.split(",");
      return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
    });

    // 3. 创建表环境
    StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

    // 4. 基于流创建一张表
    Table dataTable = tableEnv.fromDataStream(dataStream);

    // 5. 调用table API进行转换操作
    Table resultTable = dataTable.select("id, temperature")
      .where("id = 'sensor_1'");

    // 6. 执行SQL
    tableEnv.createTemporaryView("sensor", dataTable);
    String sql = "select id, temperature from sensor where id = 'sensor_1'";
    Table resultSqlTable = tableEnv.sqlQuery(sql);

    tableEnv.toAppendStream(resultTable, Row.class).print("result");
    tableEnv.toAppendStream(resultSqlTable, Row.class).print("sql");

    env.execute();
  }
}

  • Txt文件

    sensor_1,1547718199,35.8
sensor_6,1547718201,15.4
sensor_7,1547718202,6.7
sensor_10,1547718205,38.1
sensor_1,1547718207,36.3
sensor_1,1547718209,32.8
sensor_1,1547718212,37.1

基本程序结构

Table API和SQL的程序结构，与流式处理的程序结构十分类似

StreamTableEnvironment tableEnv = ... // 创建表的执行环境

// 创建一张表，用于读取数据
tableEnv.connect(...).createTemporaryTable("inputTable");

// 注册一张表，用于把计算结果输出
tableEnv.connect(...).createTemporaryTable("outputTable");

// 通过 Table API 查询算子，得到一张结果表
Table result = tableEnv.from("inputTable").select(...);

// 通过SQL查询语句，得到一张结果表
Table sqlResult = tableEnv.sqlQuery("SELECT ... FROM inputTable ...");

// 将结果表写入输出表中
result.insertInto("outputTable");

Table API批处理和流处理

新版本blink，真正把批处理、流处理都以DataStream实现。

创建环境-样例代码

package apitest.tableapi;


import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.EnvironmentSettings;
import org.apache.flink.table.api.TableEnvironment;
import org.apache.flink.table.api.bridge.java.BatchTableEnvironment;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.table.api.internal.TableEnvironmentImpl;

/**
 * @author : Ashiamd email: ashiamd@foxmail.com
 * @date : 2021/2/3 3:56 PM
 */
public class TableTest2_CommonApi {
  public static void main(String[] args) {
    // 创建执行环境
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    // 设置并行度为1
    env.setParallelism(1);

    StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

    // 1.1 基于老版本planner的流处理
    EnvironmentSettings oldStreamSettings = EnvironmentSettings.newInstance()
      .useOldPlanner()
      .inStreamingMode()
      .build();
    StreamTableEnvironment oldStreamTableEnv = StreamTableEnvironment.create(env,oldStreamSettings);

    // 1.2 基于老版本planner的批处理
    ExecutionEnvironment batchEnv = ExecutionEnvironment.getExecutionEnvironment();
    BatchTableEnvironment oldBatchTableEnv = BatchTableEnvironment.create(batchEnv);

    // 1.3 基于Blink的流处理
    EnvironmentSettings blinkStreamSettings = EnvironmentSettings.newInstance()
      .useBlinkPlanner()
      .inStreamingMode()
      .build();
    StreamTableEnvironment blinkStreamTableEnv = StreamTableEnvironment.create(env,blinkStreamSettings);

    // 1.4 基于Blink的批处理
    EnvironmentSettings blinkBatchSettings = EnvironmentSettings.newInstance()
      .useBlinkPlanner()
      .inBatchMode()
      .build();
    TableEnvironment blinkBatchTableEnv = TableEnvironment.create(blinkBatchSettings);
  }
}

表(Table)

  • TableEnvironment可以注册目录Catalog，并可以基于Catalog注册表
  • 表(Table)是由一个"标示符"(identifier)来指定的，由3部分组成：Catalog名、数据库(database)名和对象名
  • 表可以是常规的，也可以是虚拟的(视图，View)
  • 常规表(Table)一般可以用来描述外部数据，比如文件、数据库表或消息队列的数据，也可以直接从DataStream转换而来
  • 视图(View)可以从现有的表中创建，通常是table API或者SQL查询的一个结果集

创建表

  • TableEnvironment可以调用connect()方法，连接外部系统，并调用.createTemporaryTable()方法，在Catalog中注册表

    tableEnv
  .connect(...)    //    定义表的数据来源，和外部系统建立连接
  .withFormat(...)    //    定义数据格式化方法
  .withSchema(...)    //    定义表结构
  .createTemporaryTable("MyTable");    //    创建临时表

 创建TableEnvironment

  • 创建表的执行环境，需要将flink流处理的执行环境传入

    StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

  • TableEnvironment是flink中集成Table API和SQL的核心概念，所有对表的操作都基于TableEnvironment

    • 注册Catalog
    • 在Catalog中注册表
    • 执行SQL查询
    • 注册用户自定义函数（UDF）

测试代码

  • pom依赖

    <!-- Table API 和 Flink SQL -->
<dependency>
  <groupId>org.apache.flink</groupId>
  <artifactId>flink-table-planner-blink_${scala.binary.version}</artifactId>
  <version>${flink.version}</version>
</dependency>

<!-- csv -->
<dependency>
  <groupId>org.apache.flink</groupId>
  <artifactId>flink-csv</artifactId>
  <version>${flink.version}</version>
</dependency>

  • java代码

    package apitest.tableapi;


import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.Csv;
import org.apache.flink.table.descriptors.FileSystem;
import org.apache.flink.table.descriptors.Schema;
import org.apache.flink.types.Row;

/**
 * @author : Ashiamd email: ashiamd@foxmail.com
 * @date : 2021/2/3 3:56 PM
 */
public class TableTest2_CommonApi {
  public static void main(String[] args) throws Exception {
    // 创建执行环境
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    // 设置并行度为1
    env.setParallelism(1);

    StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

    // 2. 表的创建：连接外部系统，读取数据
    // 2.1 读取文件
    String filePath = "/tmp/Flink_Tutorial/src/main/resources/sensor.txt";

    tableEnv.connect(new FileSystem().path(filePath)) // 定义到文件系统的连接
      .withFormat(new Csv()) // 定义以csv格式进行数据格式化
      .withSchema(new Schema()
                  .field("id", DataTypes.STRING())
                  .field("timestamp", DataTypes.BIGINT())
                  .field("temp", DataTypes.DOUBLE())
                 ) // 定义表结构
      .createTemporaryTable("inputTable"); // 创建临时表

    Table inputTable = tableEnv.from("inputTable");
    inputTable.printSchema();
    tableEnv.toAppendStream(inputTable, Row.class).print();

    env.execute();
  }
}

  • 输入文件

    sensor_1,1547718199,35.8
sensor_6,1547718201,15.4
sensor_7,1547718202,6.7
sensor_10,1547718205,38.1
sensor_1,1547718207,36.3
sensor_1,1547718209,32.8
sensor_1,1547718212,37.1

  • 输出

    root
 |-- id: STRING
 |-- timestamp: BIGINT
 |-- temp: DOUBLE
 
sensor_1,1547718199,35.8
sensor_6,1547718201,15.4
sensor_7,1547718202,6.7
sensor_10,1547718205,38.1
sensor_1,1547718207,36.3
sensor_1,1547718209,32.8
sensor_1,1547718212,37.1

表的查询

  • Table API是集成在Scala和Java语言内的查询API

  • Table API基于代表"表"的Table类，并提供一整套操作处理的方法API；这些方法会返回一个新的Table对象，表示对输入表应用转换操作的结果

  • 有些关系型转换操作，可以由多个方法调用组成，构成链式调用结构

    Table sensorTable = tableEnv.from("inputTable");
Table resultTable = sensorTable
  .select("id","temperature")
  .filter("id = 'sensor_1'");

从文件获取数据

  • java代码

    package apitest.tableapi;


import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.Csv;
import org.apache.flink.table.descriptors.FileSystem;
import org.apache.flink.table.descriptors.Schema;
import org.apache.flink.types.Row;

/**
 * @author : Ashiamd email: ashiamd@foxmail.com
 * @date : 2021/2/3 3:56 PM
 */
public class TableTest2_CommonApi {
  public static void main(String[] args) throws Exception {
    // 创建执行环境
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    // 设置并行度为1
    env.setParallelism(1);

    StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

    // 2. 表的创建：连接外部系统，读取数据
    // 2.1 读取文件
    String filePath = "/tmp/Flink_Tutorial/src/main/resources/sensor.txt";

    tableEnv.connect(new FileSystem().path(filePath))
      .withFormat(new Csv())
      .withSchema(new Schema()
                  .field("id", DataTypes.STRING())
                  .field("timestamp", DataTypes.BIGINT())
                  .field("temp", DataTypes.DOUBLE())
                 )
      .createTemporaryTable("inputTable");

    Table inputTable = tableEnv.from("inputTable");
    //        inputTable.printSchema();
    //        tableEnv.toAppendStream(inputTable, Row.class).print();

    // 3. 查询转换
    // 3.1 Table API
    // 简单转换
    Table resultTable = inputTable.select("id, temp")
      .filter("id === 'sensor_6'");

    // 聚合统计
    Table aggTable = inputTable.groupBy("id")
      .select("id, id.count as count, temp.avg as avgTemp");

    // 3.2 SQL
    tableEnv.sqlQuery("select id, temp from inputTable where id = 'senosr_6'");
    Table sqlAggTable = tableEnv.sqlQuery("select id, count(id) as cnt, avg(temp) as avgTemp from inputTable group by id");

    // 打印输出
    tableEnv.toAppendStream(resultTable, Row.class).print("result");
    tableEnv.toRetractStream(aggTable, Row.class).print("agg");
    tableEnv.toRetractStream(sqlAggTable, Row.class).print("sqlagg");

    env.execute();
  }
}

  • 输出结果

    里面的false表示上一条保存的记录被删除，true则是新加入的数据

    所以Flink的Table API在更新数据时，实际是先删除原本的数据，再添加新数据。

    result> sensor_6,15.4
sqlagg> (true,sensor_1,1,35.8)
sqlagg> (true,sensor_6,1,15.4)
sqlagg> (true,sensor_7,1,6.7)
sqlagg> (true,sensor_10,1,38.1)
agg> (true,sensor_1,1,35.8)
agg> (true,sensor_6,1,15.4)
sqlagg> (false,sensor_1,1,35.8)
sqlagg> (true,sensor_1,2,36.05)
agg> (true,sensor_7,1,6.7)
sqlagg> (false,sensor_1,2,36.05)
sqlagg> (true,sensor_1,3,34.96666666666666)
agg> (true,sensor_10,1,38.1)
sqlagg> (false,sensor_1,3,34.96666666666666)
sqlagg> (true,sensor_1,4,35.5)
agg> (false,sensor_1,1,35.8)
agg> (true,sensor_1,2,36.05)
agg> (false,sensor_1,2,36.05)
agg> (true,sensor_1,3,34.96666666666666)
agg> (false,sensor_1,3,34.96666666666666)
agg> (true,sensor_1,4,35.5)

读写Kafka

Kafka作为消息队列，和文件系统类似的，只能往里追加数据，不能修改数据。

  • 测试代码

    （我用的新版Flink和新版kafka连接器，所以version指定"universal"）

    package apitest.tableapi;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.Csv;
import org.apache.flink.table.descriptors.Kafka;
import org.apache.flink.table.descriptors.Schema;

/**
 * @author : Ashiamd email: ashiamd@foxmail.com
 * @date : 2021/2/3 6:33 PM
 */
public class TableTest4_KafkaPipeLine {
  public static void main(String[] args) throws Exception {
    // 1. 创建环境
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    env.setParallelism(1);

    StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

    // 2. 连接Kafka，读取数据
    tableEnv.connect(new Kafka()
                     .version("universal")
                     .topic("sensor")
                     .property("zookeeper.connect", "localhost:2181")
                     .property("bootstrap.servers", "localhost:9092")
                    )
      .withFormat(new Csv())
      .withSchema(new Schema()
                  .field("id", DataTypes.STRING())
                  .field("timestamp", DataTypes.BIGINT())
                  .field("temp", DataTypes.DOUBLE())
                 )
      .createTemporaryTable("inputTable");

    // 3. 查询转换
    // 简单转换
    Table sensorTable = tableEnv.from("inputTable");
    Table resultTable = sensorTable.select("id, temp")
      .filter("id === 'sensor_6'");

    // 聚合统计
    Table aggTable = sensorTable.groupBy("id")
      .select("id, id.count as count, temp.avg as avgTemp");

    // 4. 建立kafka连接，输出到不同的topic下
    tableEnv.connect(new Kafka()
                     .version("universal")
                     .topic("sinktest")
                     .property("zookeeper.connect", "localhost:2181")
                     .property("bootstrap.servers", "localhost:9092")
                    )
      .withFormat(new Csv())
      .withSchema(new Schema()
                  .field("id", DataTypes.STRING())
                  //                        .field("timestamp", DataTypes.BIGINT())
                  .field("temp", DataTypes.DOUBLE())
                 )
      .createTemporaryTable("outputTable");

    resultTable.insertInto("outputTable");

    tableEnv.execute("");
  }
}

  • 启动kafka目录里自带的zookeeper

    $ bin/zookeeper-server-start.sh config/zookeeper.properties

  • 启动kafka服务

    $ bin/kafka-server-start.sh config/server.properties

  • 新建kafka生产者和消费者

    $ bin/kafka-console-producer.sh --broker-list localhost:9092  --topic sensor

$ bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic sinktest

  • 启动Flink程序，在kafka生产者console中输入数据，查看输出

    • 输入（kafka-console-producer）

      >sensor_1,1547718199,35.8
>sensor_6,1547718201,15.4
>sensor_7,1547718202,6.7
>sensor_10,1547718205,38.1
>sensor_6,1547718209,34.5

    • 输出（kafka-console-consumer）

      代码中，只筛选id为sensor_6的，所以输出没有问题

      sensor_6,15.4           

sensor_6,34.5

更新模式

  • 对于流式查询，需要声明如何在表和外部连接器之间执行转换
  • 与外部系统交换的消息类型，由更新模式（Uadate Mode）指定
  • 追加（Append）模式
    • 表只做插入操作，和外部连接器只交换插入（Insert）消息
  • 撤回（Retract）模式
    • 表和外部连接器交换添加（Add）和撤回（Retract）消息
    • 插入操作（Insert）编码为Add消息；删除（Delete）编码为Retract消息；更新（Update）编码为上一条的Retract和下一条的Add消息
  • 更新插入（Upsert）模式
    • 更新和插入都被编码为Upsert消息；删除编码为Delete消息

输出到ES

  • 可以创建Table来描述ES中的数据，作为输出的TableSink

    tableEnv.connect(
  new Elasticsearch()
  .version("6")
  .host("localhost",9200,"http")
  .index("sensor")
  .documentType("temp")
)
  .inUpsertMode()
  .withFormat(new Json())
  .withSchema(new Schema()
              .field("id",DataTypes.STRING())
              .field("count",DataTypes.BIGINT())
             )
  .createTemporaryTable("esOutputTable");
aggResultTable.insertInto("esOutputTable");

输出到MySQL

  • 需要的pom依赖

    Flink专门为Table API的jdbc连接提供了flink-jdbc连接器，需要先引入依赖

    <!-- https://mvnrepository.com/artifact/org.apache.flink/flink-jdbc -->
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-jdbc_2.12</artifactId>
    <version>1.10.3</version>
    <scope>provided</scope>
</dependency>

  • 可以创建Table来描述MySql中的数据，作为输入和输出

    String sinkDDL = 
  "create table jdbcOutputTable (" +
  " id varchar(20) not null, " +
  " cnt bigint not null " +
  ") with (" +
  " 'connector.type' = 'jdbc', " +
  " 'connector.url' = 'jdbc:mysql://localhost:3306/test', " +
  " 'connector.table' = 'sensor_count', " +
  " 'connector.driver' = 'com.mysql.jdbc.Driver', " +
  " 'connector.username' = 'root', " +
  " 'connector.password' = '123456' )";
tableEnv.sqlUpdate(sinkDDL);    // 执行DDL创建表
aggResultSqlTable.insertInto("jdbcOutputTable");

表和流的转换

Flink- 将表转换成DataStream | 查看执行计划 | 流处理和关系代数的区别 | 动态表 | 流式持续查询的过程 | 将流转换成动态表 | 持续查询 | 将动态表转换成 DS

将Table转换成DataStream

  • 表可以转换为 DataStream 或 DataSet ，这样自定义流处理或批处理程序就可以继续在 Table API 或 SQL 查询的结果上运行了

  • 将表转换为 DataStream 或 DataSet 时，需要指定生成的数据类型，即要将表的每一行转换成的数据类型

  • 表作为流式查询的结果，是动态更新的

  • 转换有两种转换模式：追加（Appende）模式和撤回（Retract）模式

  • 追加模式

    • 用于表只会被插入（Insert）操作更改的场景
    DataStream<Row> resultStream = tableEnv.toAppendStream(resultTable,Row.class);

  • 撤回模式

    • 用于任何场景。有些类似于更新模式中Retract模式，它只有Insert和Delete两类操作。

    • 得到的数据会增加一个Boolean类型的标识位（返回的第一个字段），用它来表示到底是新增的数据（Insert），还是被删除的数据（Delete）。

      (更新数据，会先删除旧数据，再插入新数据)

将DataStream转换成表

  • 对于一个DataStream，可以直接转换成Table，进而方便地调用Table API做转换操作

    DataStream<SensorReading> dataStream = ...
Table sensorTable = tableEnv.fromDataStream(dataStream);

  • 默认转换后的Table schema和DataStream中的字段定义一一对应，也可以单独指定出来

    DataStream<SensorReading> dataStream = ...
Table sensorTable = tableEnv.fromDataStream(dataStream,
                                           "id, timestamp as ts, temperature");

创建临时视图(Temporary View)

  • 基于DataStream创建临时视图

    tableEnv.createTemporaryView("sensorView",dataStream);
tableEnv.createTemporaryView("sensorView",
                            dataStream, "id, timestamp as ts, temperature");

  • 基于Table创建临时视图

    tableEnv.createTemporaryView("sensorView", sensorTable);

查看执行计划

  • Table API 提供了一种机制来解释计算表的逻辑和优化查询计划

  • 查看执行计划，可以通过TableEnvironment.explain(table)方法或TableEnvironment.explain()方法完成，返回一个字符串，描述三个计划

    • 优化的逻辑查询计划
    • 优化后的逻辑查询计划
    • 实际执行计划
String explaination = tableEnv.explain(resultTable);
System.out.println(explaination);

流处理和关系代数的区别

Flink- 将表转换成DataStream | 查看执行计划 | 流处理和关系代数的区别 | 动态表 | 流式持续查询的过程 | 将流转换成动态表 | 持续查询 | 将动态表转换成 DS

​ Table API和SQL，本质上还是基于关系型表的操作方式；而关系型表、关系代数，以及SQL本身，一般是有界的，更适合批处理的场景。这就导致在进行流处理的过程中，理解会稍微复杂一些，需要引入一些特殊概念。

​ 可以看到，其实关系代数（主要就是指关系型数据库中的表）和SQL，主要就是针对批处理的，这和流处理有天生的隔阂。

关系代数(表)/SQL流处理
处理的数据对象字段元组的有界集合字段元组的无限序列
查询（Query）对数据的访问可以访问到完整的数据输入无法访问所有数据，必须持续"等待"流式输入
查询终止条件生成固定大小的结果集后终止永不停止，根据持续收到的数据不断更新查询结果

动态表(Dynamic Tables)

​ 我们可以随着新数据的到来，不停地在之前的基础上更新结果。这样得到的表，在Flink Table API概念里，就叫做“动态表”（Dynamic Tables）。

  • 动态表是 Flink 对流数据的 Table API 和 SQL 支持的核心概念
  • 与表示批处理数据的静态表不同，动态表是随时间变化的
  • 持续查询(Continuous Query)
    • 动态表可以像静态的批处理表一样进行查询，查询一个动态表会产生持续查询（Continuous Query）
    • 连续查询永远不会终止，并会生成另一个动态表
    • 查询（Query）会不断更新其动态结果表，以反映其动态输入表上的更改。

动态表和持续查询

在这里插入图片描述

流式表查询的处理过程：

  1. 流被转换为动态表

  2. 对动态表计算连续查询，生成新的动态表

  3. 生成的动态表被转换回流

将流转换成动态表

  • 为了处理带有关系查询的流，必须先将其转换为表
  • 从概念上讲，流的每个数据记录，都被解释为对结果表的插入（Insert）修改操作

本质上，我们其实是从一个、只有插入操作的changelog（更新日志）流，来构建一个表

来一条数据插入一条数据

在这里插入图片描述

持续查询

  • 持续查询，会在动态表上做计算处理，并作为结果生成新的动态表。

    与批处理查询不同，连续查询从不终止，并根据输入表上的更新更新其结果表。

    在任何时间点，连续查询的结果在语义上，等同于在输入表的快照上，以批处理模式执行的同一查询的结果。

​ 下图为一个点击事件流的持续查询，是一个分组聚合做count统计的查询。

在这里插入图片描述

将动态表转换成 DataStream

  • 与常规的数据库表一样，动态表可以通过插入（Insert）、更新（Update）和删除（Delete）更改，进行持续的修改
  • 将动态表转换为流或将其写入外部系统时，需要对这些更改进行编码

  • 仅追加（Append-only）流

    • 仅通过插入（Insert）更改来修改的动态表，可以直接转换为仅追加流

  • 撤回（Retract）流

    • 撤回流是包含两类消息的流：添加（Add）消息和撤回（Retract）消息

      动态表通过将INSERT 编码为add消息、DELETE 编码为retract消息、UPDATE编码为被更改行（前一行）的retract消息和更新后行（新行）的add消息，转换为retract流。

  • Upsert（更新插入流）

    • Upsert流也包含两种类型的消息：Upsert消息和删除（Delete）消息

      通过将INSERT和UPDATE更改编码为upsert消息，将DELETE更改编码为DELETE消息，就可以将具有唯一键（Unique Key）的动态表转换为流。

将动态表转换成DataStream

在这里插入图片描述

taco詹詹
关注
专栏目录
大数据Flink（三十）：Flink ​​​​​​​Table API & SQL 介绍
Lansonli（蓝深李）的博客
05-01 2468
Flink的Table模块包括 Table API 和 SQL：Table API 是一种类SQL的API，通过Table API，用户可以像操作表一样操作数据，非常直观和方便SQL作为一种声明式语言，有着标准的语法和规范，用户可以不用关心底层实现即可进行数据的处理，非常易于上手Flink Table API 和 SQL 的实现上有80%左右的代码是公用的。作为一个流批统一的计算引擎，Flink 的 Runtime 层是统一的。
大数据_Flink_Java版_Table API 和 Flink SQL(18)_用户自定义函数_表函数---Flink工作笔记0098
添柴程序猿的专栏
04-06 237
然后我们再来看这个表函数,这里要注意上一节我们说的,scalarFunction这个类似于, 我们用的map方法,这个是一条输入,紧接着经过map以后会有一条数据对吧,这个scalarFunction 也是一条输入,会有一个输出. 但是这个TableFunction他是一条输入,会产生多条输出,就有点类似于我们之前用的 flatMap方法了. 我们写个案例去看一下 我们直接把上一节写的代码copy过来,修改比较快 这里可以看到,我们首先,创建执行环境,设置并行度,创建...
Flink 从 0 到 1 学习 —— 第十章 Table API 与 SQL
dwjf321的博客
10-15 636
文章目录1. 整体介绍1.1 什么是 Table API 和 Flink SQL1.2 需要引入的依赖2. API调用2.1 基本程序结构2.2 创建表环境2.3 在 Catalog 中注册表2.3.1 表 (Table) 的概念2.3.2 连接到文件系统（Csv格式）2.3.3 连接到 Kafka2.4 表的查询2.4.1 Table API 的调用2.4.2 SQL查询2.5 DataStream 转成表2.5.1 代码表达2.5.2 数据类型与 Table schema 的对应2.6 创建临时视图 (
【Flink】Table API和Flink SQL
HR的博客
02-26 567
Table API和Flink SQL简绍基本程序结构TableEnvironmetnt表（Table）输出表更新模式DataStream与表的相互转换查看执行计划时间 简绍 对于像DataFrame这样的关系型编程接口，因其强大且灵活的表达能力，能够让用户通过非常丰富的接口对数据进行处理，有效降低了用户的使用成本，近年来逐渐成为主流大数据处理框架主要接口形式之一。Flink也提供了关系型编程接口Table API以及基于TableAPI的SQL API，让用户能够通过使用结构化编程接口高效的构建Flin
Flink学习笔记（十一）：Table API和Flink sql
gentlewei的博客
02-13 198
详细介绍看这篇
Flink Table API和SQL的分析及使用（一）
s243471087的博客
02-27 1352
Flink针对标准的流处理和批处理提供了两种关系型API：Table API 和 SQL。Table API 可以直接进行select、filter、join等操作；Flink SQL则是基于Apache Calcite实现标准的SQL，和SQL语言一致，适合大部分开发人员。 Flink Table API和SQL 捆绑在Flink-Table依赖中，如果要使用需要添加一下依赖： 以Flink 1...
Flink基础系列32-Table API和Flink SQL之时间窗口
04-26
本文将详细探讨Flink的Table API和SQL中如何利用时间窗口进行数据处理。 时间窗口是一种将连续的数据流分割成离散时间段的方法，这对于统计特定时间范围内的数据特性至关重要。在Flink的Table API和SQL中，时间窗口...
19-flink-1.10.1-Table API 和 Flink SQL 的 函数
m0_37813354的博客
11-06 1659
89
【Flink】（十）Flink Table API 和 Flink SQL 入门_flinktable(1)
2401_84185224的博客
05-06 446
用一个单引放到字段前面来标识字段名, 如 ‘name , ‘mid ,’amount 等。
Flink-Table API 和 Flink SQL简介 | 新老版本Flink批流处理对比 | 读取文件和Kafka消费数据 | API 和 SQL查询表
SmallScorpion
05-31 1197
GitHub https://github.com/SmallScorpion/flink-tutorial.git Table API 和 Flink SQL 是什么 Flink 对批处理和流处理，提供了统一的上层 API Table API 是一套内嵌在 Java 和 Scala 语言中的查询API，它允许以非常直观的方式组合来自一些关系运算符的查询 Flink 的 SQL 支持基于实现了 SQL 标准的 Apache Calcite 基本程序结构 Table API 和 SQL 的程序结构，与流
Table API和SQL
SoulMan50的博客
07-30 391
Table API和SQL 前面我们介绍过，Flink的API是分层的，而Table API与SQL就位于最顶层。也就是说Table API和SQL是Flink中封装程度最高的API。 由于Flink 自从 0.9 版本开始支持 Table & SQL 功能一直处于完善开发中，且在不断进行迭代。所以我们可以看到Flink官网有这样一段话： Please note that the Table API and SQL are not yet feature complete and are bein
TableAPI和SQL
chbxw
06-08 610
返回总目录
Flink学习笔记之TableAPI
风景旧曾谙
09-19 8422
文章目录Flink中Table API & SQL简单介绍两个规划者之间的主要差异TableEnvironmetnt认识表API和SQL程序的结构创建一个TableEnvironment开发环境构建TableEnvironment基本操作内部CataLog注册内部Table注册TableSource注册表APIScan, Projection, and FilterColumn Opera...
Flink 基础 -- 应用开发(Table API & SQL) Table API
chinusyan的专栏
11-09 985
Flink 基础 -- 应用开发(Table API & SQL) Table API
Flink学习之Table API（python版本）
柳小葱的博客
02-18 2254
⛄️昨天学习完一些比较基础的Datastream的API后，让我们继续学习Datastream上一层的Table API和SQL，这两个API都是处理关系型数据的，可以降低flink的开发门槛。对往期内容感兴趣的同学可以参考如下内容????: hadoop专题: hadoop系列文章. spark专题: spark系列文章. flink专题: Flink系列文章. ????Table API和SQL可以通过一种更加直观的方式对数据流进行多种处理，比如选择、过滤、分组、求和以及多表连接，也支持窗口操作。
Flink Table Api详解（算子）
热门推荐
数据工匠记
03-05 1万+
该文章主要是对Flink官网相关内容进行翻译，原文地址：https://ci.apache.org/projects/flink/flink-docs-release-1.10/dev/table/tableApi.html#over-windows Table API是用于流和批处理的统一的关系API。Table API查询可以在批处理或流输入上运行而无需修改。Table API是SQL语言...
Table API和SQL 原理与代码实例讲解
最新发布
AI架构设计之禅
06-05 428
Table API和SQL 原理与代码实例讲解 1. 背景介绍 在现代数据处理和分析领域,表格数据结构无疑占据着重要地位。无论是关系型数据库中的表格,还是诸如CSV、Excel等文件格式,表格数据都是最常见和最直观的数据组织形式。因此,高效地处理和操作表格数据就成为了一个重要
1.18.Table API & SQL(概念、依赖图、Table程序依赖、扩展依赖)
涂作权的博客
04-11 898
1.18.Table API & SQL 1.18.1.概念 1.18.1.1.依赖图 1.18.1.2.Table程序依赖 1.18.1.3.扩展依赖 1.18.Table API & SQL 1.18.1.概念 Apache Flink 有两种关系型 API 来做流批统一处理：Table API 和 SQL。Table API 是用于 Scala 和 Java 语言的查询API，它可以用一种非常直观的方式来组合使用选取、过滤、join 等关系型算子。Flink SQL 是基于 Apach
【Flink系列】TableAPI和SQL详解
qq_42875020的博客
10-31 1372
【Flink系列】TableAPI和SQL详解
Flink Table API与SQL时间窗口详解
"本文主要探讨了Flink中的Table API和Flink SQL如何使用时间窗口进行数据处理，重点关注了GroupWindows和OverWindows这两种窗口类型。内容包括分组窗口的定义、用法，以及滚动窗口（Tumbling Windows）、滑动窗口...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值