干货 | 五千字长文带你快速入门FlinkSQL

时间  2021-01-20
标签 java mysql web 面试 sql 数据库 apache json bootstrap api 栏目 Java 繁體版
原文   原文链接

1、前言

        最近几天由于工做比较忙，已经几天没有及时更新文章了，在这里先给小伙伴们说声抱歉…临近周末，再忙再累，我也要开始发力了。接下来的几天，菌哥将为你们带来关于FlinkSQL的教程，以后还会更新一些大数据实时数仓的内容，和一些热门的组件使用！但愿小伙伴们能点个关注，第一时间关注技术干货！java

在这里插入图片描述

2、FlinkSQL出现的背景

        Flink SQL 是 Flink 实时计算为简化计算模型，下降用户使用实时计算门槛而设计的一套符合标准 SQL 语义的开发语言。mysql

        自 2015 年开始，阿里巴巴开始调研开源流计算引擎，最终决定基于 Flink 打造新一代计算引擎，针对 Flink 存在的不足进行优化和改进，而且在 2019 年初将最终代码开源，也就是咱们熟知的 Blink。Blink 在原来的 Flink 基础上最显著的一个贡献就是 Flink SQL 的实现。web

        Flink SQL 是面向用户的 API 层，在咱们传统的流式计算领域，好比 Storm、Spark Streaming 都会提供一些 Function 或者 Datastream API，用户经过 Java 或 Scala 写业务逻辑，这种方式虽然灵活，但有一些不足，好比具有必定门槛且调优较难，随着版本的不断更新，API 也出现了不少不兼容的地方。面试

在这里插入图片描述
        在这个背景下，毫无疑问，SQL 就成了咱们最佳选择，之因此选择将 SQL 做为核心 API，是由于其具备几个很是重要的特色：sql

  • SQL 属于设定式语言，用户只要表达清楚需求便可，不须要了解具体作法；
  • SQL 可优化，内置多种查询优化器，这些查询优化器可为 SQL 翻译出最优执行计划；
  • SQL 易于理解，不一样行业和领域的人都懂，学习成本较低；
  • SQL 很是稳定，在数据库 30 多年的历史中，SQL 自己变化较少；
  • 流与批的统一，Flink 底层 Runtime 自己就是一个流与批统一的引擎，而 SQL 能够作到 API 层的流与批统一。

3、总体介绍

3.1 什么是 Table API 和 Flink SQL?

        Flink自己是批流统一的处理框架，因此Table API和SQL，就是批流统一的上层处理API。目前功能还没有完善，处于活跃的开发阶段。数据库

        Table API是一套内嵌在Java和Scala语言中的查询API，它容许咱们以很是直观的方式，组合来自一些关系运算符的查询（好比select、filter和join）。而对于Flink SQL，就是直接能够在代码中写SQL，来实现一些查询（Query）操做。Flink的SQL支持，基于实现了SQL标准的Apache Calcite（Apache开源SQL解析工具）。apache

        不管输入是批输入仍是流式输入，在这两套API中，指定的查询都具备相同的语义，获得相同的结果。json

3.2 须要引入的依赖

        Table API 和 SQL 须要引入的依赖有两个：planner 和 bridgebootstrap

<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-table-planner_2.11</artifactId>
    <version>1.10.0</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-table-api-scala-bridge_2.11</artifactId>
    <version>1.10.0</version>
</dependency>

        其中：api

        flink-table-planner：planner计划器，是table API最主要的部分，提供了运行时环境和生成程序执行计划的planner；

        flink-table-api-scala-bridge：bridge桥接器，主要负责table API和 DataStream/DataSet API的链接支持，按照语言分java和scala；

        这里的两个依赖，是IDE环境下运行须要添加的；若是是生产环境，lib目录下默认已经有了planner，就只须要有bridge就能够了。

        固然，若是想使用用户自定义函数，或是跟 kafka 作链接，须要有一个SQL client，这个包含在 flink-table-common 里。
        

3.3 两种planner（old & blink）的区别

        一、批流统一：Blink将批处理做业，视为流式处理的特殊状况。因此，blink不支持表和DataSet之间的转换，批处理做业将不转换为DataSet应用程序，而是跟流处理同样，转换为DataStream程序来处理。

        二、由于批流统一，Blink planner也不支持BatchTableSource，而使用有界的StreamTableSource代替。

        三、Blink planner只支持全新的目录，不支持已弃用的ExternalCatalog。

        四、旧 planner 和 Blink planner 的FilterableTableSource实现不兼容。旧的planner会把PlannerExpressions下推到filterableTableSource中，而blink planner则会把Expressions下推。

        五、基于字符串的键值配置选项仅适用于Blink planner。

        六、PlannerConfig在两个planner中的实现不一样。

        七、Blink planner会将多个sink优化在一个DAG中（仅在TableEnvironment上受支持，而在StreamTableEnvironment上不受支持）。而旧 planner 的优化老是将每个sink放在一个新的DAG中，其中全部DAG彼此独立。

        八、旧的planner不支持目录统计，而Blink planner支持。

4、API 调用

4.1 基本程序结构

        Table API 和 SQL 的程序结构，与流式处理的程序结构相似；也能够近似地认为有这么几步：首先建立执行环境，而后定义source、transform和sink。

        具体操做流程以下：

val tableEnv = ...     // 建立表的执行环境

// 建立一张表，用于读取数据
tableEnv.connect(...).createTemporaryTable("inputTable")
// 注册一张表，用于把计算结果输出
tableEnv.connect(...).createTemporaryTable("outputTable")

// 经过 Table API 查询算子，获得一张结果表
val result = tableEnv.from("inputTable").select(...)
// 经过 SQL查询语句，获得一张结果表
val sqlResult  = tableEnv.sqlQuery("SELECT ... FROM inputTable ...")

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

4.2 建立表环境

        建立表环境最简单的方式，就是基于流处理执行环境，调create方法直接建立：

val tableEnv = StreamTableEnvironment.create(env)

        表环境（TableEnvironment）是flink中集成 Table API & SQL 的核心概念。它负责:

  • 注册catalog
  • 在内部 catalog 中注册表
  • 执行 SQL 查询
  • 注册用户自定义函数
  • 将 DataStream 或 DataSet 转换为表
  • 保存对 ExecutionEnvironment 或 StreamExecutionEnvironment 的引用

        在建立TableEnv的时候，能够多传入一个EnvironmentSettings 或者 TableConfig 参数，能够用来配置 TableEnvironment 的一些特性。

        好比，配置老版本的流式查询（Flink-Streaming-Query）：

val settings = EnvironmentSettings.newInstance()
  .useOldPlanner()      // 使用老版本planner
  .inStreamingMode()    // 流处理模式
  .build()
val tableEnv = StreamTableEnvironment.create(env, settings)

        基于老版本的批处理环境（Flink-Batch-Query）：

val batchEnv = ExecutionEnvironment.getExecutionEnvironment
val batchTableEnv = BatchTableEnvironment.create(batchEnv)

        基于 blink 版本的流处理环境（Blink-Streaming-Query）：

val bsSettings = EnvironmentSettings.newInstance()
.useBlinkPlanner()
.inStreamingMode().build()
val bsTableEnv = StreamTableEnvironment.create(env, bsSettings)

        基于blink版本的批处理环境（Blink-Batch-Query）：

val bbSettings = EnvironmentSettings.newInstance()
.useBlinkPlanner()
.inBatchMode().build()
val bbTableEnv = TableEnvironment.create(bbSettings)

4.3 在Catalog中注册表

4.3.1 表(Table)的概念

        TableEnvironment 能够注册目录 Catalog ，并能够基于Catalog注册表。它会维护一个 Catalog-Table 表之间的map。

        表（Table）是由一个“标识符”来指定的，由3部分组成：Catalog名、数据库（database）名和对象名（表名）。若是没有指定目录或数据库，就使用当前的默认值。

        表能够是常规的（Table，表），或者虚拟的（View，视图）。常规表（Table）通常能够用来描述外部数据，好比文件、数据库表或消息队列的数据，也能够直接从 DataStream转换而来。视图能够从现有的表中建立，一般是 table API 或者SQL查询的一个结果。

4.3.2 链接到文件系统（Csv格式）

        链接外部系统在Catalog中注册表，直接调用 tableEnv.connect() 就能够，里面参数要传入一个 ConnectorDescriptor ，也就是connector描述器。对于文件系统的 connector 而言，flink内部已经提供了，就叫作FileSystem()。

        代码以下：

tableEnv
.connect( new FileSystem().path("sensor.txt"))  // 定义表数据来源，外部链接
  .withFormat(new OldCsv())    // 定义从外部系统读取数据以后的格式化方法
  .withSchema( new Schema()
    .field("id", DataTypes.STRING())
    .field("timestamp", DataTypes.BIGINT())
    .field("temperature", DataTypes.DOUBLE())
  )    // 定义表结构
  .createTemporaryTable("inputTable")    // 建立临时表

        这是旧版本的csv格式描述器。因为它是非标的，跟外部系统对接并不通用，因此将被弃用，之后会被一个符合RFC-4180标准的新format描述器取代。新的描述器就叫Csv()，但flink没有直接提供，须要引入依赖flink-csv：

<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-csv</artifactId>
    <version>1.10.0</version>
</dependency>

        代码很是相似，只须要把 withFormat 里的 OldCsv 改为Csv就能够了。

4.3.3 链接到Kafka

        kafka的链接器 flink-kafka-connector 中，1.10 版本的已经提供了 Table API 的支持。咱们能够在 connect方法中直接传入一个叫作Kafka的类，这就是kafka链接器的描述器ConnectorDescriptor。

tableEnv.connect(
  new Kafka()
    .version("0.11") // 定义kafka的版本
    .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("temperature", DataTypes.DOUBLE())
)
  .createTemporaryTable("kafkaInputTable")

        固然也能够链接到 ElasticSearch、MySql、HBase、Hive等外部系统，实现方式基本上是相似的。感兴趣的 小伙伴能够自行去研究，这里就不详细赘述了。

4.4 表的查询

        经过上面的学习，咱们已经利用外部系统的链接器connector，咱们能够读写数据，并在环境的Catalog中注册表。接下来就能够对表作查询转换了。

        Flink给咱们提供了两种查询方式：Table API和 SQL。

4.4.1 Table API的调用

        Table API是集成在Scala和Java语言内的查询API。与SQL不一样，Table API的查询不会用字符串表示，而是在宿主语言中一步一步调用完成的。

        Table API基于表明一张“表”的Table类，并提供一整套操做处理的方法API。这些方法会返回一个新的Table对象，这个对象就表示对输入表应用转换操做的结果。有些关系型转换操做，能够由多个方法调用组成，构成链式调用结构。例如table.select(…).filter(…)，其中 select（…）表示选择表中指定的字段，filter(…)表示筛选条件。

        代码中的实现以下：

val sensorTable: Table = tableEnv.from("inputTable")

val resultTable: Table = senorTable
.select("id, temperature")
.filter("id ='sensor_1'")

4.4.2 SQL查询

        Flink的SQL集成，基于的是ApacheCalcite，它实现了SQL标准。在Flink中，用常规字符串来定义SQL查询语句。SQL 查询的结果，是一个新的 Table。

        代码实现以下：

val resultSqlTable: Table = tableEnv.sqlQuery("select id, temperature from inputTable where id ='sensor_1'")

        或者：

val resultSqlTable: Table = tableEnv.sqlQuery(
  """ |select id, temperature |from inputTable |where id = 'sensor_1' """.stripMargin)

        固然，也能够加上聚合操做，好比咱们统计每一个sensor温度数据出现的个数，作个count统计：

val aggResultTable = sensorTable
.groupBy('id)
.select('id, 'id.count as 'count)

        SQL的实现：

val aggResultSqlTable = tableEnv.sqlQuery("select id, count(id) as cnt from inputTable group by id")

        这里Table API里指定的字段，前面加了一个单引号’，这是Table API中定义的Expression类型的写法，能够很方便地表示一个表中的字段。

        字段能够直接所有用双引号引发来，也能够用半边单引号+字段名的方式。之后的代码中，通常都用后一种形式。

4.5 将DataStream 转换成表

        Flink容许咱们把Table和DataStream作转换：咱们能够基于一个DataStream，先流式地读取数据源，而后map成样例类，再把它转成Table。Table的列字段（column fields），就是样例类里的字段，这样就不用再麻烦地定义schema了。

4.5.1 代码表达

        代码中实现很是简单，直接用 tableEnv.fromDataStream() 就能够了。默认转换后的 Table schema 和 DataStream 中的字段定义一一对应，也能够单独指定出来。

        这就容许咱们更换字段的顺序、重命名，或者只选取某些字段出来，至关于作了一次map操做（或者Table API的 select操做）。

        代码具体以下：

val inputStream: DataStream[String] = env.readTextFile("sensor.txt")
val dataStream: DataStream[SensorReading] = inputStream
  .map(data => { 
 
   
    val dataArray = data.split(",")
    SensorReading(dataArray(0), dataArray(1).toLong, dataArray(2).toDouble)
  })

val sensorTable: Table = tableEnv.fromDataStreama(datStream)

val sensorTable2 = tableEnv.fromDataStream(dataStream, 'id, 'timestamp as 'ts)

4.5.2 数据类型与 Table schema的对应

        在上节的例子中，DataStream 中的数据类型，与表的 Schema 之间的对应关系，是按照样例类中的字段名来对应的（name-based mapping），因此还能够用as作重命名。

        另一种对应方式是，直接按照字段的位置来对应（position-based mapping），对应的过程当中，就能够直接指定新的字段名了。

        基于名称的对应：

val sensorTable = tableEnv.fromDataStream(dataStream, 'timestamp as 'ts, 'id as 'myId, 'temperature)

        基于位置的对应：

val sensorTable = tableEnv.fromDataStream(dataStream, 'myId, 'ts)

        Flink的 DataStream 和 DataSet API 支持多种类型。

        组合类型，好比元组（内置Scala和Java元组）、POJO、Scala case类和Flink的Row类型等，容许具备多个字段的嵌套数据结构，这些字段能够在Table的表达式中访问。其余类型，则被视为原子类型。

        元组类型和原子类型，通常用位置对应会好一些；若是非要用名称对应，也是能够的：元组类型，默认的名称是 “_1”, “_2”；而原子类型，默认名称是 ”f0”。

4.6 建立临时视图（Temporary View）

        建立临时视图的第一种方式，就是直接从DataStream转换而来。一样，能够直接对应字段转换；也能够在转换的时候，指定相应的字段。

        代码以下：

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

        另外，固然还能够基于Table建立视图：

tableEnv.createTemporaryView("sensorView", sensorTable)

        View和Table的Schema彻底相同。事实上，在Table API中，能够认为View 和 Table 是等价的。

4.7 输出表

        表的输出，是经过将数据写入 TableSink 来实现的。TableSink 是一个通用接口，能够支持不一样的文件格式、存储数据库和消息队列。

        具体实现，输出表最直接的方法，就是经过 Table.insertInto() 方法将一个 Table 写入注册过的 TableSink 中。

4.7.1 输出到文件

        代码以下：

// 注册输出表
tableEnv.connect(
  new FileSystem().path("…\\resources\\out.txt")
) // 定义到文件系统的链接
  .withFormat(new Csv()) // 定义格式化方法，Csv格式
  .withSchema(new Schema()
  .field("id", DataTypes.STRING())
  .field("temp", DataTypes.DOUBLE())
) // 定义表结构
  .createTemporaryTable("outputTable") // 建立临时表

resultSqlTable.insertInto("outputTable")

4.7.2 更新模式（Update Mode）

        在流处理过程当中，表的处理并不像传统定义的那样简单。

        对于流式查询（Streaming Queries），须要声明如何在（动态）表和外部链接器之间执行转换。与外部系统交换的消息类型，由更新模式（update mode）指定。

        Flink Table API中的更新模式有如下三种：

  • 追加模式（Append Mode）

        在追加模式下，表（动态表）和外部链接器只交换插入（Insert）消息。

  • 撤回模式（Retract Mode）

        在撤回模式下，表和外部链接器交换的是：添加（Add）和撤回（Retract）消息。

        其中：

  • 插入（Insert）会被编码为添加消息；
  • 删除（Delete）则编码为撤回消息；
  • 更新（Update）则会编码为，已更新行（上一行）的撤回消息，和更新行（新行）的添加消息。

        在此模式下，不能定义key，这一点跟upsert模式彻底不一样。

  • Upsert（更新插入）模式

        在Upsert模式下，动态表和外部链接器交换Upsert和Delete消息。

        这个模式须要一个惟一的key，经过这个key能够传递更新消息。为了正确应用消息，外部链接器须要知道这个惟一key的属性。

  • 插入（Insert）和更新（Update）都被编码为Upsert消息；
  • 删除（Delete）编码为Delete信息

        这种模式和 Retract 模式的主要区别在于，Update操做是用单个消息编码的，因此效率会更高。

4.7.3 输出到Kafka

        除了输出到文件，也能够输出到Kafka。咱们能够结合前面Kafka做为输入数据，构建数据管道，kafka进，kafka出。

        代码以下：

// 输出到 kafka
tableEnv.connect(
  new Kafka()
    .version("0.11")
    .topic("sinkTest")
    .property("zookeeper.connect", "localhost:2181")
    .property("bootstrap.servers", "localhost:9092")
)
  .withFormat( new Csv() )
  .withSchema( new Schema()
    .field("id", DataTypes.STRING())
    .field("temp", DataTypes.DOUBLE())
  )
  .createTemporaryTable("kafkaOutputTable")

resultTable.insertInto("kafkaOutputTable")

4.7.4 输出到ElasticSearch

        ElasticSearch的connector能够在upsert（update+insert，更新插入）模式下操做，这样就可使用Query定义的键（key）与外部系统交换UPSERT/DELETE消息。

        另外，对于“仅追加”（append-only）的查询，connector还能够在 append 模式下操做，这样就能够与外部系统只交换 insert 消息。

        es目前支持的数据格式，只有Json，而 flink 自己并无对应的支持，因此还须要引入依赖：

<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-json</artifactId>
    <version>1.10.0</version>
</dependency>

        代码实现以下：

// 输出到es
tableEnv.connect(
  new Elasticsearch()
    .version("6")
    .host("localhost", 9200, "http")
    .index("sensor")
    .documentType("temp")
)
  .inUpsertMode()           // 指定是 Upsert 模式
  .withFormat(new Json())
  .withSchema( new Schema()
    .field("id", DataTypes.STRING())
    .field("count", DataTypes.BIGINT())
  )
  .createTemporaryTable("esOutputTable")

aggResultTable.insertInto("esOutputTable")

4.7.5 输出到MySql

        Flink专门为Table API的jdbc链接提供了flink-jdbc链接器，咱们须要先引入依赖：

<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-jdbc_2.11</artifactId>
    <version>1.10.0</version>
</dependency>

        jdbc链接的代码实现比较特殊，由于没有对应的java/scala类实现 ConnectorDescriptor，因此不能直接 tableEnv.connect()。不过Flink SQL留下了执行DDL的接口：tableEnv.sqlUpdate()

        对于jdbc的建立表操做，天生就适合直接写DDL来实现，因此咱们的代码能够这样写：

// 输出到 Mysql
val sinkDDL: String =
  """ |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' |) """.stripMargin

tableEnv.sqlUpdate(sinkDDL)
aggResultSqlTable.insertInto("jdbcOutputTable")

4.7.6 将表转换成DataStream

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

        将表转换为DataStream或DataSet时，须要指定生成的数据类型，即要将表的每一行转换成的数据类型。一般，最方便的转换类型就是Row。固然，由于结果的全部字段类型都是明确的，咱们也常常会用元组类型来表示。

        表做为流式查询的结果，是动态更新的。因此，将这种动态查询转换成的数据流，一样须要对表的更新操做进行编码，进而有不一样的转换模式。

        Table API 中表到 DataStream 有两种模式：

  • 追加模式（Append Mode）

        用于表只会被插入（Insert）操做更改的场景

  • 撤回模式（Retract Mode）

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

        获得的数据会增长一个Boolean类型的标识位（返回的第一个字段），用它来表示究竟是新增的数据（Insert），仍是被删除的数据（老数据， Delete）。

        代码实现以下：

val resultStream: DataStream[Row] = tableEnv.toAppendStream[Row](resultTable)

val aggResultStream: DataStream[(Boolean, (String, Long))] = 
tableEnv.toRetractStream[(String, Long)](aggResultTable)

resultStream.print("result")
aggResultStream.print("aggResult")

        因此，没有通过groupby之类聚合操做，能够直接用 toAppendStream 来转换；而若是通过了聚合，有更新操做，通常就必须用 toRetractDstream。

4.7.7 Query的解释和执行

        Table API提供了一种机制来解释（Explain）计算表的逻辑和优化查询计划。这是经过TableEnvironment.explain（table）方法或TableEnvironment.explain（）方法完成的。

        explain方法会返回一个字符串，描述三个计划：

  • 未优化的逻辑查询计划
  • 优化后的逻辑查询计划
  • 实际执行计划

        咱们能够在代码中查看执行计划：

val explaination: String = tableEnv.explain(resultTable)
println(explaination)

        Query的解释和执行过程，老planner和 blink planner 大致是一致的，又有所不一样。总体来说，Query都会表示成一个逻辑查询计划，而后分两步解释：

  1. 优化查询计划
  2. 解释成 DataStream 或者 DataSet程序

        而 Blink 版本是批流统一的，因此全部的Query，只会被解释成DataStream程序；另外在批处理环境 TableEnvironment 下，Blink版本要到 tableEnv.execute() 执行调用才开始解释。
        

在这里插入图片描述

巨人的肩膀

一、http://www.atguigu.com/
二、https://www.bilibili.com/video/BV12k4y1z7LM?from=search&seid=953051020130358915
三、https://blog.csdn.net/u013411339/article/details/93267838

小结

        本篇文章主要用五千多字，为你们带来迅速入门并掌握 FlinkSQL 的技巧，包含FlinkSQL出现的背景介绍以及与 Table API 的区别，API调用方式更是介绍的很是详细全面，但愿小伙伴们在看了以后可以及时复习总结，尤为是初学者。好了，本篇文章 over，你们看了以后有任何的疑惑均可以私信做者，我看到都会一一解答。下一篇我会在本篇的基础上为你们介绍一些流处理中的特殊概念，敬请期待|ू･ω･` )，你知道的越多，你不知道的也越多，我是Alice，咱们下一期见！
        
        

文章持续更新，能够微信搜一搜「 猿人菌 」第一时间阅读，思惟导图，大数据书籍，大数据高频面试题，海量一线大厂面经…关注这个在大数据领域冉冉升起的新星！

        
在这里插入图片描述

本文同步分享在 博客“Alice菌”（CSDN）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程