Flink第八章:FlinkSQL

已于 2023-06-03 10:40:26 修改
阅读量574 收藏 1
点赞数
分类专栏： Flink 文章标签： flink scala 大数据
于 2023-06-02 11:10:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50835854/article/details/131002112
版权

系列文章目录

Flink第一章:环境搭建
Flink第二章:基本操作.
Flink第三章:基本操作(二)
Flink第四章:水位线和窗口
Flink第五章:处理函数
Flink第六章:多流操作
Flink第七章:状态编程
Flink第八章:FlinkSQL

文章目录

前言

这次博客我们记录以下FlinkSQL的学习内容
在这里插入图片描述
引入需要的依赖

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-scala-bridge_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner-loader</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-runtime</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-csv</artifactId>
            <version>${flink.version}</version>
        </dependency>

一、常用函数

1.快速上手案例

SimpleTableExample.scala

package com.atguigu.chapter07

import com.atguigu.chapter02.Source.Event
import org.apache.flink.streaming.api.scala._
import org.apache.flink.table.api.Expressions.$
import org.apache.flink.table.api.Table
import org.apache.flink.table.api.bridge.scala.StreamTableEnvironment

object SimpleTableExample {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    // 读取数据源
    val eventStream: DataStream[Event] = env.fromElements(
      Event("Alice", "./home", 1000L),
      Event("Bob", "./cart", 1000L),
      Event("Alice", "./prod?id=1", 5 * 1000L),
      Event("Cary", "./home", 60 * 1000L),
      Event("Bob", "./prod?id=3", 90 * 1000L),
      Event("Alice", "./prod?id=7", 105 * 1000L)
    )

    // 创建表环境
    val tableEnv: StreamTableEnvironment = StreamTableEnvironment.create(env)

    // 将DataStream装换成表
    val eventTable: Table = tableEnv.fromDataStream(eventStream)

    // 调用Table API 进行转换计算(不建议)
    val resultTable: Table = eventTable.select($("user"), $("url"))
      .where($("user").isEqual("Alice"))
    // 直接写SQL

    tableEnv.createTemporaryView("eventTable",eventTable)
    val resultSQLTable: Table = tableEnv.sqlQuery("select url,user from eventTable where user='Bob'")

    // 装换成流打印
    tableEnv.toDataStream(resultTable).print("1")
    tableEnv.toDataStream(resultSQLTable).print("2")

    env.execute()

  }
}

在这里插入图片描述

2.连接外部数据(csv)

CommonApiTest.scala

package com.atguigu.chapter07

import org.apache.flink.streaming.api.scala._
import org.apache.flink.table.api.{EnvironmentSettings, Table, TableEnvironment}
import org.apache.flink.table.api.bridge.scala.StreamTableEnvironment

object CommonApiTest {
  def main(args: Array[String]): Unit = {
    // 1创建表环境(2种方法)
    // 1.1直接基于流创建
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val tableEnv: StreamTableEnvironment = StreamTableEnvironment.create(env)

    // 1.2传入一个环境的配置参数创建
    val settings: EnvironmentSettings = EnvironmentSettings
      .newInstance()
      .inStreamingMode()
      .build()
    val tableEnvironment: TableEnvironment = TableEnvironment.create(settings)

    // 2.创建输入表
    tableEnv.executeSql(
      """
        | CREATE TABLE eventTable(
        |   uid STRING,
        |   url STRING,
        |   ts BIGINT
        | ) WITH(
        | 'connector' = 'filesystem',
        | 'path' = 'input/clicks.txt',
        | 'format' = 'csv'
        | )
        |""".stripMargin)


    // 3.表的查询转换
    val resultTable: Table = tableEnv.sqlQuery("select uid,url,ts from eventTable where uid= 'Alice' ")

    val urlCountTable: Table = tableEnv.sqlQuery("select uid,count(url) from eventTable group by uid")

    // 4.创建输出表
    tableEnv.executeSql(
      """
        |CREATE TABLE outTable(
        |  uid STRING,
        |  url STRING,
        |  ts BIGINT
        |) WITH(
        | 'connector' = 'filesystem',
        | 'path'='output',
        | 'format'='csv'
        |)
        |""".stripMargin)


    // 5.输出结果
    resultTable.executeInsert("outTable")

    tableEnv.toDataStream(resultTable).print("resultTable")
    tableEnv.toChangelogStream(urlCountTable).print("count")
    env.execute()
  }

}

csv文件
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
这里特别说明一下,我在创建输入表时出现了错误,代码没有报错,但是编译没有通过,最终从excel 导出一个csv文件传入,完成运行,之后在替换成符合格式要求的txt文件即可正常运行.(具体啥原因,我也不知道)

3.时间窗口案例

TimeAndWindowTest.scala

package com.atguigu.chapter07


import com.atguigu.chapter02.Source.Event
import org.apache.flink.api.common.eventtime.{SerializableTimestampAssigner, WatermarkStrategy}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.table.api.Expressions.$
import org.apache.flink.table.api.{DataTypes, Schema, Table}
import org.apache.flink.table.api.bridge.scala.StreamTableEnvironment

import java.time.Duration

object TimeAndWindowTest {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val tableEnv: StreamTableEnvironment = StreamTableEnvironment.create(env)

    // 1.在创建表的DDL中指定时间属性字段
    tableEnv.executeSql(
      """
        | CREATE TABLE eventTable(
        |   uid STRING,
        |   url STRING,
        |   ts BIGINT,
        |   et AS TO_TIMESTAMP( FROM_UNIXTIME(ts/1000)),
        |   WATERMARK FOR et AS et - INTERVAL '2' SECOND
        | ) WITH(
        |   'connector' = 'filesystem',
        |   'path' = 'input/clicks.txt',
        |   'format' = 'csv'
        | )
        |""".stripMargin)

    // 2. 在将流转换成表的时候指定时间属性字段

    val eventStream: DataStream[Event] = env.fromElements(
      Event("Alice", "./home", 1000L),
      Event("Bob", "./cart", 1000L),
      Event("Alice", "./prod?id=1", 25 * 60 * 1000L),
      Event("Alice", "./prod?id=4", 55 * 60 * 1000L),
      Event("Bob", "./prod?id=5", 3600 * 1000L + 60 * 1000L),
      Event("Cary", "./home", 3600 * 1000L + 30 * 60 * 1000L),
      Event("Cary", "./prod?id=7", 3600 * 1000L + 59 * 60 * 1000L)
    ).assignTimestampsAndWatermarks(WatermarkStrategy.forBoundedOutOfOrderness(Duration.ofSeconds(2))
      .withTimestampAssigner(new SerializableTimestampAssigner[Event] {
        override def extractTimestamp(t: Event, l: Long): Long = t.timestamp
      }))

    // 已经弃用
//        val eventTable: Table = tableEnv.fromDataStream(eventStream,$("url"),$("user").as("uid"),
//          $("timestamp").as("ts"),$("et").rowtime())

    // 修改后
    val eventTable: Table = tableEnv.fromDataStream(eventStream, Schema.newBuilder()
      .columnByExpression("et", "TO_TIMESTAMP(FROM_UNIXTIME(`timestamp`/1000))")
      .watermark("et", "SOURCE_WATERMARK()").build()).as("uid", "url","ts")


    eventTable.printSchema()

    tableEnv.createTemporaryView("eventTable", eventTable)

    // 测试累积窗口
    val resultTable: Table = tableEnv.sqlQuery(
      """
        |select
        |   uid, window_end AS endT ,COUNT(url) AS cnt
        |FROM TABLE(
        | CUMULATE(
        |   TABLE eventTable,
        |   DESCRIPTOR(et),
        |   INTERVAL '30' MINUTE,
        |   INTERVAL '1' HOUR
        | )
        |)
        |GROUP BY uid,window_start,window_end
        |""".stripMargin)

//    tableEnv.toDataStream(resultTable).print()


    // 测试开窗集合
    val overResultTable: Table = tableEnv.sqlQuery(
      """
        |SELECT uid,url,ts,AVG(ts) OVER (
        |  PARTITION BY uid
        |  ORDER BY et
        |  ROWS BETWEEN 3 PRECEDING AND CURRENT ROW
        |) AS vag_ts
        |FROM eventTable
        |""".stripMargin)

    tableEnv.toChangelogStream(overResultTable).print("over")


    env.execute()
  }
}

在这里插入图片描述

4.TopN案例1

TopNExample.scala

package com.atguigu.chapter07

import org.apache.flink.streaming.api.scala._
import org.apache.flink.table.api.Table
import org.apache.flink.table.api.bridge.scala.{StreamTableEnvironment, tableConversions}

object TopNExample {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val tableEnv: StreamTableEnvironment = StreamTableEnvironment.create(env)


    // 2.创建输入表
    tableEnv.executeSql(
      """
        | CREATE TABLE eventTable(
        |   uid STRING,
        |   url STRING,
        |   ts BIGINT,
        |   et AS TO_TIMESTAMP( FROM_UNIXTIME(ts/1000)),
        |   WATERMARK FOR et AS et - INTERVAL '2' SECOND
        | ) WITH(
        | 'connector' = 'filesystem',
        | 'path' = 'input/clicks.txt',
        | 'format' = 'csv'
        | )
        |""".stripMargin)

    // TOP N 选取活跃度最大的两个用户
    // 1.进行分组聚合统计,计算每个用户访问量
    val urlCountTable: Table = tableEnv.sqlQuery("select uid,count(url) as cnt from eventTable group by uid")
    tableEnv.createTemporaryView("urlCountTable",urlCountTable)

    // 2.提取最大的两个用户
    val top2resultTable: Table = tableEnv.sqlQuery(
      """
        |SELECT uid,cnt,row_num
        |FROM (
        |   SELECT * ,ROW_NUMBER() OVER (
        |     ORDER BY cnt DESC
        |   )AS row_num
        |   FROM urlCountTable
        |)
        |WHERE row_num<=2
        |""".stripMargin)

    tableEnv.toChangelogStream(top2resultTable).print()

    env.execute()
  }

}

在这里插入图片描述

5.TopN案例2

TopNWindowExample.scala

package com.atguigu.chapter07

import com.atguigu.chapter02.Source.Event
import org.apache.flink.api.common.eventtime.{SerializableTimestampAssigner, WatermarkStrategy}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.table.api.{Schema, Table}
import org.apache.flink.table.api.bridge.scala.StreamTableEnvironment

import java.time.Duration

object TopNWindowExample {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val tableEnv: StreamTableEnvironment = StreamTableEnvironment.create(env)


    // 2.创建输入表
    val eventStream: DataStream[Event] = env.fromElements(
      Event("Alice", "./home", 1000L),
      Event("Bob", "./cart", 1000L),
      Event("Alice", "./prod?id=1", 25 * 60 * 1000L),
      Event("Alice", "./prod?id=4", 55 * 60 * 1000L),
      Event("Bob", "./prod?id=5", 3600 * 1000L + 60 * 1000L),
      Event("Cary", "./home", 3600 * 1000L + 30 * 60 * 1000L),
      Event("Cary", "./prod?id=7", 3600 * 1000L + 59 * 60 * 1000L)
    ).assignTimestampsAndWatermarks(WatermarkStrategy.forBoundedOutOfOrderness(Duration.ofSeconds(2))
      .withTimestampAssigner(new SerializableTimestampAssigner[Event] {
        override def extractTimestamp(t: Event, l: Long): Long = t.timestamp
      }))

    val eventTable: Table = tableEnv.fromDataStream(eventStream, Schema.newBuilder()
      .columnByExpression("et", "TO_TIMESTAMP(FROM_UNIXTIME(`timestamp`/1000))")
      .watermark("et", "SOURCE_WATERMARK()").build()).as("uid", "url")

    tableEnv.createTemporaryView("eventTable",eventTable)


    // TOP N 选取每小时内活跃度最大的两个用户
    // 1.进行窗口聚合统计,计算每个用户访问量
    val urlCountWindowTable: Table = tableEnv.sqlQuery(
      """
        |SELECT uid ,COUNT(url) AS cnt,window_start,window_end
        |FROM TABLE(
        |   TUMBLE(TABLE eventTable,DESCRIPTOR(et),INTERVAL '1' HOUR)
        |)
        |GROUP BY uid,window_start,window_end
        |""".stripMargin)

    tableEnv.createTemporaryView("urlCountWindowTable",urlCountWindowTable)

    // 2.提取最大的两个用户
    val top2resultTable: Table = tableEnv.sqlQuery(
      """
        |SELECT *
        |FROM (
        |   SELECT * ,ROW_NUMBER() OVER (
        |     PARTITION BY window_start,window_end
        |     ORDER BY cnt DESC
        |   )AS row_num
        |   FROM urlCountWindowTable
        |)
        |WHERE row_num<=2
        |""".stripMargin)

    tableEnv.toDataStream(top2resultTable).print()

    env.execute()

  }
}

在这里插入图片描述

二、UDF函数

1.Scalar Function(标量函数)

UdfTest_ScalaFunction.scala

package com.atguigu.chapter07

import org.apache.flink.streaming.api.scala._
import org.apache.flink.table.api.Table
import org.apache.flink.table.api.bridge.scala.StreamTableEnvironment
import org.apache.flink.table.functions.ScalarFunction

object UdfTest_ScalaFunction {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val tableEnv: StreamTableEnvironment = StreamTableEnvironment.create(env)


    // 2.创建输入表
    tableEnv.executeSql(
      """
        | CREATE TABLE eventTable(
        |   uid STRING,
        |   url STRING,
        |   ts BIGINT,
        |   et AS TO_TIMESTAMP( FROM_UNIXTIME(ts/1000)),
        |   WATERMARK FOR et AS et - INTERVAL '2' SECOND
        | ) WITH(
        | 'connector' = 'filesystem',
        | 'path' = 'input/clicks.txt',
        | 'format' = 'csv'
        | )
        |""".stripMargin)

    // 2.注册标量函数
    tableEnv.createTemporarySystemFunction("myHash",classOf[MyHash])

    // 3.调用函数
    val resultTable: Table = tableEnv.sqlQuery("select uid,myHash(uid) from eventTable")

    // 4.打印输出
    tableEnv.toDataStream(resultTable).print()

    env.execute()


  }
  // 实现自定义标量函数 哈希函数
  class MyHash extends ScalarFunction {
    def eval(str:String): Int ={
      str.hashCode
    }
  }

}

在这里插入图片描述

2.Table Function(表函数)

UdfTest_TableFunction.scala

package com.atguigu.chapter07

import com.atguigu.chapter07.UdfTest_ScalaFunction.MyHash
import org.apache.flink.api.common.typeutils.TypeSerializer
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.table.annotation.{DataTypeHint, ExtractionVersion, FunctionHint, HintFlag, InputGroup}
import org.apache.flink.table.api.Table
import org.apache.flink.table.api.bridge.scala.StreamTableEnvironment
import org.apache.flink.table.functions.TableFunction
import org.apache.flink.types.Row

import java.lang.annotation.Annotation

object UdfTest_TableFunction {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val tableEnv: StreamTableEnvironment = StreamTableEnvironment.create(env)


    // 1.创建输入表
    tableEnv.executeSql(
      """
        | CREATE TABLE eventTable(
        |   uid STRING,
        |   url STRING,
        |   ts BIGINT,
        |   et AS TO_TIMESTAMP( FROM_UNIXTIME(ts/1000)),
        |   WATERMARK FOR et AS et - INTERVAL '2' SECOND
        | ) WITH(
        | 'connector' = 'filesystem',
        | 'path' = 'input/clicks.txt',
        | 'format' = 'csv'
        | )
        |""".stripMargin)

    // 2.注册表函数
    tableEnv.createTemporarySystemFunction("MySplit", classOf[MySplit])

    // 3.调用函数
    val resultTable: Table = tableEnv.sqlQuery(
      """
        |select
        |   uid,url,word,len
        |from eventTable,lateral table(mySplit(url)) as T(word,len)
        |""".stripMargin)

    // 4.打印输出
    tableEnv.toDataStream(resultTable).print()

    env.execute()

  }

  // 实现自定义表函数 按照?分割url字段
  @FunctionHint(output = new DataTypeHint("ROW<word STRING,length INT>"))
  class MySplit extends TableFunction[Row] {
    def eval(str: String): Unit = {
      str.split("\\?").foreach(s => collect(Row.of(s, Int.box(s.length))))
    }
  }

}

在这里插入图片描述

3.Aggregate Function(聚合函数).

UdfTest_AggregateFunction.scala

package com.atguigu.chapter07

import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.table.api.Table
import org.apache.flink.table.api.bridge.scala.StreamTableEnvironment
import org.apache.flink.table.functions.AggregateFunction

object UdfTest_AggregateFunction {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val tableEnv: StreamTableEnvironment = StreamTableEnvironment.create(env)


    // 1.创建输入表
    tableEnv.executeSql(
      """
        | CREATE TABLE eventTable(
        |   uid STRING,
        |   url STRING,
        |   ts BIGINT,
        |   et AS TO_TIMESTAMP( FROM_UNIXTIME(ts/1000)),
        |   WATERMARK FOR et AS et - INTERVAL '2' SECOND
        | ) WITH(
        | 'connector' = 'filesystem',
        | 'path' = 'input/clicks.txt',
        | 'format' = 'csv'
        | )
        |""".stripMargin)

    // 2.注册表函数
    tableEnv.createTemporarySystemFunction("WeightedAvg", classOf[WeightedAvg])

    // 3.调用函数
    val resultTable: Table = tableEnv.sqlQuery(
      """
        |select
        |   uid,WeightedAvg(ts,1) as avg_ts
        |from eventTable
        |group by uid
        |""".stripMargin)

    // 4.打印输出
    tableEnv.toChangelogStream(resultTable).print()

    env.execute()

  }

  // 单独定义样例类
  case class WeightedAccumulator(var sum: Long = 0, var count: Int = 0)

  // 实现自定义聚合函数 计算加强平均数
  class WeightedAvg extends AggregateFunction[java.lang.Long, WeightedAccumulator] {
    override def getValue(accumulator: WeightedAccumulator): java.lang.Long = {
      if (accumulator.count == 0) {
        null
      } else {
        accumulator.sum / accumulator.count
      }
    }

    override def createAccumulator(): WeightedAccumulator = WeightedAccumulator() // 创建累加器

    // 每来一行数据,都会调用
    def accumulate(accumulator: WeightedAccumulator, iValue: java.lang.Long, iWeight: Int): Unit = {
      accumulator.sum += iValue
      accumulator.count += iWeight
    }
  }
}

在这里插入图片描述

4.Table Aggregate Function(表聚合函数 不建议)

package com.atguigu.chapter07

import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.table.api.Expressions.{$, call}
import org.apache.flink.table.api.Table
import org.apache.flink.table.api.bridge.scala.StreamTableEnvironment
import org.apache.flink.table.functions.TableAggregateFunction
import org.apache.flink.util.Collector

import java.sql.Timestamp


object UdfTest_TableAggFunction {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val tableEnv: StreamTableEnvironment = StreamTableEnvironment.create(env)


    // 1.创建输入表
    tableEnv.executeSql(
      """
        | CREATE TABLE eventTable(
        |   uid STRING,
        |   url STRING,
        |   ts BIGINT,
        |   et AS TO_TIMESTAMP( FROM_UNIXTIME(ts/1000)),
        |   WATERMARK FOR et AS et - INTERVAL '2' SECOND
        | ) WITH(
        | 'connector' = 'filesystem',
        | 'path' = 'input/clicks.txt',
        | 'format' = 'csv'
        | )
        |""".stripMargin)

    // 2.注册表聚合函数
    tableEnv.createTemporarySystemFunction("top2", classOf[Top2])

    // 3.调用函数
    // 首先进行窗口聚合得到cnt
    val urlCountWindowTable: Table = tableEnv.sqlQuery(
      """
        |SELECT uid ,COUNT(url) AS cnt,window_start as wstart ,window_end as wend
        |FROM TABLE(
        |   TUMBLE(TABLE eventTable,DESCRIPTOR(et),INTERVAL '1' HOUR)
        |)
        |GROUP BY uid,window_start,window_end
        |""".stripMargin)

    // 使用Table API调用表聚合函数
    val resultTable: Table = urlCountWindowTable.groupBy($("wend"))
      .flatAggregate(call("top2", $("uid"), $("cnt"), $("wstart"), $("wend")))
      .select($("uid"), $("rank"), $("cnt"), $("wend"))



    // 4.打印输出
    tableEnv.toChangelogStream(resultTable).print()

    env.execute()

  }

  // 定义输出结果和中间累加器的样例类
  case class Top2Result(uid: String, window_start: Timestamp, window_end: Timestamp, cnt: Long, rank: Int)

  case class Top2Acc(var maxCount: Long, var secondMaxCount: Long, var uid1: String, var uid2: String, var window_start: Timestamp, var window_end: Timestamp)

  // 实现表聚合自定义函数
  class Top2 extends TableAggregateFunction[Top2Result, Top2Acc] {
    override def createAccumulator(): Top2Acc = Top2Acc(Long.MinValue, Long.MinValue, null, null, null, null)

    // 每来一行数据,需要使用acc进行统计
    def accumulate(acc: Top2Acc, uid: String, cnt: Long, window_start: Timestamp, window_end: Timestamp): Unit = {
      acc.window_start = window_start
      acc.window_end = window_end
      // 判断当前count值是否排名前两位
      if (cnt > acc.maxCount) {
        // 名次向后顺延
        acc.secondMaxCount = acc.maxCount
        acc.uid2 = acc.uid1
        acc.maxCount = cnt
        acc.uid1 = uid
      } else if (cnt > acc.secondMaxCount) {
        acc.secondMaxCount = cnt
        acc.uid2 = uid
      }
    }

    // 输出结果数据
    def emitValue(acc: Top2Acc, out: Collector[Top2Result]): Unit = {
      // 判断cnt值是否为初始值
      if (acc.maxCount != Long.MinValue) {
        out.collect(Top2Result(acc.uid1, acc.window_start, acc.window_end, acc.maxCount, 1))
      }
      if (acc.secondMaxCount!=Long.MinValue){
        out.collect(Top2Result(acc.uid2,acc.window_start,acc.window_end,acc.secondMaxCount,2))
      }
    }
  }
}

在这里插入图片描述

总结

FlinkSQL的内容就记录到这里.

超哥--
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FlinkSQL 依赖的pom/api.Table
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
03-22 2045
<!--公共依赖版本号--> <properties> <flink.version>1.9.2</flink.version> <flink.scala.version>2.11</flink.scala.version> </properties> <!-- https://mvnrepository.com/artifact/org...
Flink-Sql执行所需依赖2.0v
weixin_47681855的博客
11-19 1440
哈哈哈，你永远不知道回踩多少坑啊！！！ 改天吧报错信息总结一下 这边这篇依赖相对挺全了，好歹能直接看出效果了 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://mav
Flink-Sql执行所需依赖1.0v
weixin_47681855的博客
11-09 1594
初步测试可行，后序开发过程是否有坑还在继续实践当中 <!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses
flink- sql开发项目框架
最新发布
qq_18494057的博客
05-09 199
自定义了一个format组件，通过外部的正则表达式，和建表ddl字段，对日志进行解析。建表ddl：with ('format' = 'pwrd_decode' ------自定义format 标记正则表达式配置：\\d+)"}, {},{\\d+)"}],根据ddl表名字，找到对应的配置文件，通过多个正则表达式，给ddl中的属性赋值。打包，上传。分别打包上传， sql调试完上线。
Flink SQL 项目通用模板一
编程者说的博客专栏
03-15 630
总结项目中的常用 flink sql 开发模板，供大家参考。 主要分三大步： 创建表执行环境。 创建输入表、输出表，并进行数据的逻辑处理。 任务执行。 其中第二部是重点，细分三小步（也就是三个 tabEnv.executeSql） tableEnv.executeSql(inputTableDDL) // 1) create inputTable tableEnv.executeSql(outputTableDDL) // 2) create outputTable tableEnv.exec
Flink:Flink-SQL开发
07-27 1万+
背景 Flink SQL 是 Flink 实时计算为简化计算模型，降低用户使用实时计算门槛而设计的一套符合标准 SQL 语义的开发语言。 自 2015 年开始，阿里巴巴开始调研开源流计算引擎，最终决定基于 Flink 打造新一代计算引擎，针对 Flink 存在的不足进行优化和改进，并且在 2019 年初将最终代码开源，也就是我们熟知的 Blink。Blink 在原来的 Flink 基础上最显著的一个贡献就是 Flink SQL 的实现。 Flink SQL 是面向用户的 API 层，在我们传统的流式计算领域
大数据之flink教程-TableAPI和SQL.pdf
07-27
1.1 什么是 Table API 和 Flink SQL 2 1.2 需要引入的依赖 2 1.3 两种 planner（old & blink）的区别 4 第二章 API 调用 5 2.1 基本程序结构 5 2.2 创建表环境 5 2.3 在 Catalog 中注册表 7 2.3.1 表（Table）的概念...
大数据技术之Flink教程
04-02
第一章 Flink简介 第二章 快速上手 第三章 Flink部署 第四章 Flink运行架构 第五章 Flink流处理API ...第八章 ProcessFunction API（底层API） 第九章 状态编程与容错机制 第十章 Table API 与 SQL
flink入门到精通视频教程
07-15
第一章 Flink简介 01.Flink的引入 02.什么是Flink 03.Flink流处理特性 04.Flink基石 05.批处理与流处理 第二章 Flink架构体系 01.Flink中重要角色 02.无界数据流与有界数据流 03.Flink数据流编程模型 04.Libraries...
Flink基础讲义.docx
08-19
第一章 Flink简介【了解】 1 ...第八章 Flink的状态管理 200 第九章 Flink的容错 226 第1种：全局调整 235 第2种：单任务调整 235 第十章 flink 扩展知识 261 第十一章 flink-SQL开发 277 第十二章 总结 292
大数据高级开发工程师自学资源
01-12
第8章 数据仓库hive 第9章 Hbase实战 第10章 大数据辅助框架 第11章 数据仓库 第12章 Zookeeper及Hadoop高可用（录播） 第13章 数据仓库项目（点播） 第14章 Scala函数式编程语言 第15章 spark 计算框架 第16章 ...
Flink从入门到放弃(入门篇2)-本地环境搭建&构建第一个Flink应用.md
04-27
Flink从入门到放弃(入门篇2)-本地环境搭建&构建第一个Flink应用.md
《十堂课学习 Flink》第三章：Flink SQL 环境搭建
Smileyan's blog
11-26 2377
Flink SQL 环境搭建相关内容。
flink（九）：Table&Sql环境搭建和程序结构
幻神舞的专栏
06-11 471
文章目录分享说明资料架构优势maven导包tabel API和SQL本地环境配置优化stream支持scala支持自定义格式或函数程序结构Blink(新)和flink(旧)计划器区别程序结构总结 分享 大数据博客列表 说明 Flink Table 相关知识是我一直感兴趣的部分，现决定跨过一些不必要的知识，直接学习 Flink Table ，本文主要介绍 flink table 架构和接口实现。 Apache Flink 有两种关系型 API 来做流批统一处理：Table API 和 SQL。Table
flink sql 知其所以然（六）| flink sql 约会 calcite（看这篇就够了）
qq_34608620的博客
09-04 1312
感谢您的小爱心（关注  +  点赞 + 再看），对博主的肯定，会督促博主持续的输出更多的优质实战内容！！！1.序篇-本文结构 大数据羊说 用数据提升美好事物发生的概率~
Flink Table API 和 SQL 需要引入的依赖
weixin_36630761的博客
10-21 528
两个 Bridge：flink-table-api-scala-bridge 和 flink-table-api-java-bridge，flink-table-api-scala：这里只是非常薄的一层，仅和 Table API 的 Expression 和 DSL 相关。两个 Planner：flink-table-planner 和 flink-table-planner-blink。flink-table-api-java：这部分是用户编程使用的 API，包含了大部分的 API。
Flink Table API& SQL编程指南-（概述、依赖结构、概念与常规API）
麦田里的守望者-蒋中洲【相信相信的力量】
07-17 347
概述 Flink具有两个关系型API- Table API和SQL，这两个API，这两个API统一了流处理和批处理。其中Table API是用Scala或者是Java的语言集成查询API。它允许以非常直观的方式从关系运算符（如select、filter和join）组成查询。Flink的SQL支持基于实现SQL标准的Apache Calcite.无论输入的是DataSet（批）还是DataStream（流）这两套接口中指定的查询具有相同的语义和相同的计算结果。 其中Table API和SQL的接口可以紧密的
flink基础篇-开发flink，必备的环境搭建
程序员ZZ的源码
04-04 685
flink的安装，以及第一个demo
Apache Flink SQL示例
热门推荐
lmalds的专栏
03-09 1万+
Flink SQL
flink received signal 15: sigterm含义
08-12
Flink接收到信号15：SIGTERM的含义是指Flink进程收到了一个终止信号。SIGTERM是Linux系统中的一个信号，用于请求进程正常终止，通常是由系统管理员或其他进程发送给目标进程。当Flink接收到SIGTERM信号时，它会先尝试进行一些清理工作，例如关闭和释放资源，保存检查点等。然后，它会优雅地停止当前正在执行的作业，并关闭Flink集群。这个过程是为了确保作业能够正常退出，保护数据完整性，并最大程度地减少影响。 通过捕捉SIGTERM信号并进行相应的处理，Flink可以在收到信号后进行优雅的停机，避免突然中断而导致的数据丢失或错误。在Flink接收到SIGTERM信号后，可以使用几种方式来处理：首先，Flink会尝试保存检查点，以便在恢复时能够保留作业的状态。其次，Flink会停止当前正在执行的作业，以确保任务能够正常结束，并释放相关资源。最后，Flink会关闭整个Flink集群，确保系统能够安全退出。 总而言之，Flink接收到信号15：SIGTERM意味着要求Flink进程正常退出，并在退出前进行必要的处理，以确保作业状态的完整性和系统的稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值