Pyflink教程(一)：table_api&sql

具体定义请参考官方文档： https://nightlies.apache.org/flink/flink-docs-release-1.16/zh/docs/dev/table/overview/
本文主要针对实际使用中比较常用的api进行整理，大多数例子都是官网，如有歧义可与官方对照。

一、 创建 TableEnvironment

TableEnvironment 是 Table API 和 SQL 的核心概念。它负责:

• 在内部的 catalog 中注册 Table

• 注册外部的 catalog

• 加载可插拔模块

• 执行 SQL 查询

• 注册自定义函数 （scalar、table 或 aggregation）

• DataStream 和 Table 之间的转换(面向 StreamTableEnvironment )

from pyflink.table import EnvironmentSettings, TableEnvironment

from pyflink.datastream import StreamExecutionEnvironment
from pyflink.table import StreamTableEnvironment
#创建流处理
env_settings = EnvironmentSettings.in_streaming_mode()
table_env = TableEnvironment.create(env_settings)
#创建批处理
env_settings = EnvironmentSettings.in_batch_mode()
table_env = TableEnvironment.create(env_settings)
#用户可以从现有的 StreamExecutionEnvironment 创建一个 StreamTableEnvironment 与 DataStream API 互操作。
s_env = StreamExecutionEnvironment.get_execution_environment()
t_env = StreamTableEnvironment.create(s_env)

TableEnvironment主要用来：

• Table 管理：创建表、列举表、Table 和 DataStream 互转等。

• 自定义函数管理：自定义函数的注册、删除、列举等。 关于 Python 自定义函数的更多细节，请参考普通自定义函数 和向量化自定义函数章节的介绍。

• 执行 SQL 语句：更多细节可查阅SQL 查询章节的介绍。

• 作业配置管理：更多细节可查阅Python 配置章节的介绍。

• Python 依赖管理：更多细节可查阅依赖管理章节的介绍。

• 作业提交：更多细节可查阅作业提交章节的介绍。

二、创建表

Table 是 Python Table API 的核心组件。Table 对象由一系列数据转换操作构成，但是它不包含数据本身。 相反，它描述了如何从数据源中读取数据，以及如何将最终结果写出到外部存储等。表可以被打印、优化并最终在集群中执行。 表也可以是有限流或无限流，以支持流式处理和批处理场景。

一个 Table 实例总是与一个特定的 TableEnvironment 相绑定。不支持在同一个查询中合并来自不同 TableEnvironments 的表，例如 join 或者 union 它们。

from pyflink.table import EnvironmentSettings, TableEnvironment

# 创建 批 TableEnvironment
env_settings = EnvironmentSettings.in_batch_mode()
table_env = TableEnvironment.create(env_settings)

首先在上面创建了一个批处理的TableEnvironment。然后创建一张表。

在pyflink中，可从不同的数据类型中形成创建表，下面介绍几个比较常用的方法

1、from_elements

从元素集合创建表，集合中的元素必须长度相等，类型顺序相同

from_elements(elements: Iterable, schema: Union[pyflink.table.types.DataType, List[str]] = None, verify_schema: bool = True) → pyflink.table.table.Table

参数：

elements- 创建表格的元素。

schema- 表的架构。

verify_schema- 是否根据架构验证元素。

例子如下：schema可以使用DataTypes 指定类型，也可以不指定，直接写列名，会自动识别。

#table = table_env.from_elements([(1, 'Hi'), (2, 'Hello')],["a","b"])
#table = table_env.from_elements([(1, 'Hi'), (2, 'Hello')],
                        DataTypes.ROW([DataTypes.FIELD("a", DataTypes.INT()),
                                       DataTypes.FIELD("b", DataTypes.STRING())]))
table.execute().print()

2、通过 pandas DataFrame 来创建表

from_pandas(pdf, schema=None, split_num=1)

参数：

• pdf- Pandas DataFrame 。

• schema- 转换后的表的架构。

• splits_num- 给定的 Pandas DataFrame 将被分割成的分割数。它决定了并行源任务的数量。如果未指定，将使用默认并行度。

pdf = pd.DataFrame(np.random.rand(10, 2))
table = table_env.from_pandas(pdf, ["a", "b"])
#table_env.from_pandas(pdf, [DataTypes.DOUBLE(), DataTypes.DOUBLE()])
# table_env.from_pandas(pdf, DataTypes.ROW(
#     [DataTypes.FIELD("a", DataTypes.DOUBLE()), DataTypes.FIELD("b", DataTypes.DOUBLE())]))
table.execute().print()

3、from_path

通过指定路径下已注册的表来创建一个表。

from_path(path: str) → pyflink.table.table.Table

参数：

path- 要扫描的表 API 对象的路径。

例如通过 create_temporary_view 注册表

#通过DDL创建表，然后使用from_path来获取对象
table_env.execute_sql("""
    CREATE TABLE random_source (
        id BIGINT, 
        data TINYINT 
    ) WITH (
        'connector' = 'datagen',
        'fields.id.kind'='sequence',
        'fields.id.start'='1',
        'fields.id.end'='3',
        'fields.data.kind'='sequence',
        'fields.data.start'='4',
        'fields.data.end'='6'
    )
""")
table = table_env.from_path("random_source")
table.execute().print()

create_temporary_view ： 将一个 `Table` 对象注册为一张临时表，类似于 SQL 的临时表。

create_temporary_view(view_path, table)

参数：

• view_path - 注册视图的路径。

• table_or_data_stream ：用于创建视图的表或数据流。

#通过DDL创建sink表
table_env.execute_sql("""
    CREATE TABLE table_sink (
        id BIGINT, 
        data VARCHAR 
    ) WITH (
        'connector' = 'print'
    )
""")

# 将 Table API 表转换成 SQL 中的视图
table = table_env.from_elements([(1, 'Hi'), (2, 'Hello')], ['id', 'data'])
table_env.create_temporary_view('table_api_table', table)

# 将 Table API 表的数据写入结果表
table_env.execute_sql("INSERT INTO table_sink SELECT * FROM table_api_table").wait()

4、execute_sql

执行指定的语句并返回执行结果。 执行语句可以是 DDL/DML/DQL/SHOW/DESCRIBE/EXPLAIN/USE。

注意，对于 "INSERT INTO" 语句，这是一个异步操作，通常在向远程集群提交作业时才需要使用。

execute_sql(stmt str)	

参数：

str- sql 语句

table_env.execute_sql("INSERT INTO table_sink SELECT * FROM table_api_table").wait()

5、sql_query(query)

执行一条 SQL 查询，并将查询的结果作为一个 `Table` 对象.

sql_query(query)	

参数：

query- sql 语句

table_env.sql_query("SELECT * FROM %s" % table)

6、create_statemente_set

用来执行多条sql语句，可以通过该方法编写multi_sink的作业。

table = table_env.from_elements([(1, 'Hi'), (2, 'Hello')], ['id', 'data'])
table_env.create_temporary_view("simple_source", table)
table_env.execute_sql("""
    CREATE TABLE first_sink_table (
        id BIGINT, 
        data VARCHAR 
    ) WITH (
        'connector' = 'print'
    )
""")
table_env.execute_sql("""
    CREATE TABLE second_sink_table (
        id BIGINT, 
        data VARCHAR
    ) WITH (
        'connector' = 'print'
    )
""")

# 创建 statement set
statement_set = table_env.create_statement_set()

# 将 "table" 的数据写入 "first_sink_table"
statement_set.add_insert("first_sink_table", table)

# 通过一条 sql 插入语句将数据从 "simple_source" 写入到 "second_sink_table"
statement_set.add_insert_sql("INSERT INTO second_sink_table SELECT * FROM simple_source")

# 执行 statement set
statement_set.execute().wait()

7> +I(1,Hi)

7> +I(1,Hi)

7> +I(2,Hello)

7> +I(2,Hello)

7、get_schema

获取schema信息

table = table_env.from_elements([(1, 'Hi'), (2, 'Hello')], ['id', 'data'])
# 默认情况下，“id” 列的类型是 64 位整型
print('By default the type of the "id" column is %s.' % table.get_schema().get_field_data_type("id"))

from pyflink.table import DataTypes

table = table_env.from_elements([(1, 'Hi'), (2, 'Hello')],
                                DataTypes.ROW([DataTypes.FIELD("id", DataTypes.TINYINT()),
                                               DataTypes.FIELD("data", DataTypes.STRING())]))
# 现在 “id” 列的类型是 8 位整型
print(table.get_schema())

By default the type of the "id" column is BIGINT.

root

|-- id: TINYINT

|-- data: STRING

三、创建TableDescriptor

用来定义表的scheam

例子：

from pyflink.table import EnvironmentSettings, TableEnvironment, TableDescriptor, Schema, DataTypes

# create a stream TableEnvironment
env_settings = EnvironmentSettings.in_streaming_mode()
table_env = TableEnvironment.create(env_settings)

table_env.create_temporary_table(
    'random_source',
    TableDescriptor.for_connector('datagen')
        .schema(Schema.new_builder()
                .column('id', DataTypes.BIGINT())
                .column('data', DataTypes.TINYINT())
                .build())
        .option('fields.id.kind', 'sequence')
        .option('fields.id.start', '1')
        .option('fields.id.end', '3')
        .option('fields.data.kind', 'sequence')
        .option('fields.data.start', '4')
        .option('fields.data.end', '6')
        .build())

table = table_env.from_path("random_source")
table.execute().print()

+----+----------------------+--------+
| op |                   id |   data |
+----+----------------------+--------+
| +I |                    1 |      4 |
| +I |                    2 |      5 |
| +I |                    3 |      6 |
+----+----------------------+--------+

for_connector：使用给定的连接器为表创建一个新的构建器

参数：

当前仅有部分 connector 的实现包含在 Flink 官方提供的发行包中，好比 FileSystem，DataGen、Print、BlackHole 等，大部分 connector 的实现当前没有包含在 Flink 官方提供的发行包中，好比 Kafka、ES 等。针对没有包含在 Flink 官方提供的发行包中的 connector，若是须要在 PyFlink 做业中使用，用户须要显式地指定相应 FAT JAR.

这里简单介绍如何连接kafka

具体直接看阿里云的flink文档：https://help.aliyun.com/document_detail/176688.html

四、在 Catalog 中创建表

表可以是临时的，并与单个 Flink 会话（session）的生命周期相关，也可以是永久的，并且在多个 Flink 会话和群集（cluster）中可见。

永久表需要 catalog（例如 Hive Metastore）以维护表的元数据。一旦永久表被创建，它将对任何连接到 catalog 的 Flink 会话可见且持续存在，直至被明确删除。

通过 SQL DDL 创建的表和视图， 例如 “create table …” 和 “create view …"，都存储在 catalog 中。

你可以通过 SQL 直接访问 catalog 中的表。

如果你要用 Table API 来使用 catalog 中的表，可以使用 “from_path” 方法来创建 Table API 对象：

# 准备 catalog
# 将 Table API 表注册到 catalog 中
table = table_env.from_elements([(1, 'Hi'), (2, 'Hello')], ['id', 'data'])
table_env.create_temporary_view('source_table', table)

# 从 catalog 中获取 Table API 表
new_table = table_env.from_path('source_table')
new_table.execute().print()

+----+----------------------+--------------------------------+
| op |                   id |                           data |
+----+----------------------+--------------------------------+
| +I |                    1 |                             Hi |
| +I |                    2 |                          Hello |
+----+----------------------+--------------------------------+

五、Table API-DML语法

from pyflink.table import EnvironmentSettings, TableEnvironment
from pyflink.table.expressions import col
from pyflink.table.expressions import concat

# 通过 batch table environment 来执行查询
env_settings = EnvironmentSettings.in_batch_mode()
table_env = TableEnvironment.create(env_settings)

orders = table_env.from_elements([('Jack', 'FRANCE', 10), ('Rose', 'ENGLAND', 30), ('Jack', 'FRANCE', 20)],
                                 ['name', 'country', 'revenue'])

1.查询-select

# 查询两列
revenue = orders.select(col("name"), col("country").alias('country')) 
# 查询全部列
revenue1 = orders .select(col("*")) 

revenue.execute().print()
table_result = revenue.execute()
print(type(table_result ))

+--------------------------------+--------------------------------+
|                           name |                        country |
+--------------------------------+--------------------------------+
|                           Jack |                         FRANCE |
|                           Rose |                        ENGLAND |
|                           Jack |                         FRANCE |
|                            Bob |                             CH |
|                            Bob |                             CH |
|                             YU |                             CH |
+--------------------------------+--------------------------------

说下返回值，通过打印可以知道revenue.execute()返回值类型是TableResult，这个类型不能直接通过for循环遍历。

需要调用collect()方法，然后在遍历。

for res_row in table_result.collect():
    for rr in res_row:
		print(rr)

对于 SELECT 操作，除非已收集所有结果数据，否则作业不会完成，所以除非是有界或是批处理，那么不建议使用for循环遍历数据。

#所以建立使用with循环
with table_result.collect() as results:
	for result in results:

2.过滤-where

等同filter，和 SQL 的 WHERE 子句类似。 过滤掉未验证通过过滤谓词的行。

--javascripttypescriptbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

result = orders.where(col("name") == 'Jack')
#或
result = orders.filter(col("name") == 'Jack')
#打印
result .execute().print()

+--------------------------------+--------------------------------+-------------+-------------------------+
|                           name |                        country |     revenue |                  r_time |
+--------------------------------+--------------------------------+-------------+-------------------------+
|                           Jack |                         FRANCE |          10 | 2023-02-23 11:11:33.081 |
|                           Jack |                         FRANCE |          20 | 2023-02-24 07:11:33.081 |
+--------------------------------+--------------------------------+-------------+-------------------------+

3.列操作

--javascripttypescriptbashsqljsonhtmlcssccppjavarubypythongorustmarkdown

#添加列，add_columns但是如果该列存在则直接报错
#concat 合并
result = orders.add_columns(concat(col("name"), 'sunny').alias('desc'))
result .execute().print()

+--------------------------------+--------------------------------+-------------+-------------------------+--------------------------------+
|                           name |                        country |     revenue |                  r_time |                           desc |
+--------------------------------+--------------------------------+-------------+-------------------------+--------------------------------+
|                           Jack |                         FRANCE |          10 | 2023-02-23 11:11:33.081 |                      Jacksunny |
|                           Rose |                        ENGLAND |          30 | 2023-02-23 21:11:33.081 |                      Rosesunny |
|                           Jack |                         FRANCE |          20 | 2023-02-24 07:11:33.081 |                      Jacksunny |
|                            Bob |                             CH |          40 | 2023-02-24 17:11:33.081 |                       Bobsunny |
|                            Bob |                             CH |          50 | 2023-02-24 17:11:33.081 |                       Bobsunny |
|                             YU |                             CH |         100 | 2023-02-23 14:11:33.081 |                        YUsunny |
+--------------------------------+--------------------------------+-------------+-------------------------+--------------------------------+

#add_or_replace_columns：执行字段添加操作。 如果添加的列名称和已存在的列名称相同，则已存在的字段将被替换。 此外，如果添加的字段里面有重复的字段名，则会使用最后一个字段。
result = orders.add_or_replace_columns(concat(col("name"), 'sunny').alias('desc')).select(col("name"),col("desc"))
result.execute().print()

+--------------------------------+--------------------------------+
|                           name |                           desc |
+--------------------------------+--------------------------------+
|                           Jack |                      Jacksunny |
|                           Rose |                      Rosesunny |
|                           Jack |                      Jacksunny |
|                            Bob |                       Bobsunny |
|                            Bob |                       Bobsunny |
|                             YU |                        YUsunny |
+--------------------------------+--------------------------------+

#删除列，如果删除多个，则用逗号隔开，drop_columns(col("a"),col("b"))
result = orders.drop_columns(col("name"))
result.execute().print()

+--------------------------------+-------------+-------------------------+
|                        country |     revenue |                  r_time |
+--------------------------------+-------------+-------------------------+
|                         FRANCE |          10 | 2023-02-23 11:11:33.081 |
|                        ENGLAND |          30 | 2023-02-23 21:11:33.081 |
|                         FRANCE |          20 | 2023-02-24 07:11:33.081 |
|                             CH |          40 | 2023-02-24 17:11:33.081 |
|                             CH |          50 | 2023-02-24 17:11:33.081 |
|                             CH |         100 | 2023-02-23 14:11:33.081 |
+--------------------------------+-------------+-------------------------+

#修改列名
result = orders.rename_columns(col("name").alias('name1'), col("country").alias('country2'))
result.execute().print()

+--------------------------------+--------------------------------+-------------+-------------------------+
|                          name1 |                       country2 |     revenue |                  r_time |
+--------------------------------+--------------------------------+-------------+-------------------------+
|                           Jack |                         FRANCE |          10 | 2023-02-23 11:11:33.081 |
|                           Rose |                        ENGLAND |          30 | 2023-02-23 21:11:33.081 |
|                           Jack |                         FRANCE |          20 | 2023-02-24 07:11:33.081 |
|                            Bob |                             CH |          40 | 2023-02-24 17:11:33.081 |
|                            Bob |                             CH |          50 | 2023-02-24 17:11:33.081 |
|                             YU |                             CH |         100 | 2023-02-23 14:11:33.081 |
+--------------------------------+--------------------------------+-------------+-------------------------+

4.聚合计算-Aggregations

4.1 group_by

# 计算所有来自法国客户的收入
# 使用group_by 来进行分组计算
#对于流失计算，因为数据是无界的，计算出的结果是可能是无限长的，取决查询或聚合的字段，所以当是流式时，请提供空闲状态保留时间。
revenue = orders \
    .select(col("name"), col("country"), col("revenue")) \
    .where(col("country") == 'FRANCE') \
    .group_by(col("name")) \
    .select(col("name"), orders.revenue.sum.alias('rev_sum'))

revenue.execute().print()

+--------------------------------+-------------+
|                           name |     rev_sum |
+--------------------------------+-------------+
|                           Jack |          30 |
+--------------------------------+-------------+

4.2窗口函数 - Tumble

滚动窗口将行分配给固定长度的非重叠连续窗口。例如，一个 5 分钟的滚动窗口以 5 分钟的间隔对行进行分组。滚动窗口可以定义在事件时间、处理时间或行数上。

#生成测试数据
orders = table_env.from_elements(
[
('Jack', 'FRANCE', 10, datetime.now()+timedelta(hours=2)),
('Rose', 'ENGLAND', 30, datetime.now()+timedelta(hours=12)),
('Jack', 'FRANCE', 20, datetime.now()+timedelta(hours=22)),
('Bob', 'CH', 40, datetime.now()+timedelta(hours=32)),
('Bob', 'CH', 50, datetime.now()+timedelta(hours=32)),
('YU', 'CH', 100, datetime.now()+timedelta(hours=5))
],
DataTypes.ROW([DataTypes.FIELD("name", DataTypes.STRING()),
DataTypes.FIELD("country", DataTypes.STRING()),
DataTypes.FIELD("revenue", DataTypes.INT()),
DataTypes.FIELD("r_time", DataTypes.TIMESTAMP(3))]))

#设置窗口函数
win_fun= Tumble.over(lit(1).hours).on(col('r_time')).alias("w")

over	将窗口的长度定义为时间或行计数间隔。
on	要对数据进行分组（时间间隔）或排序（行计数）的时间属性。批处理查询支持任意 Long 或 Timestamp 类型的属性。流处理查询仅支持声明的事件时间或处理时间属性。
alias	指定窗口的别名。别名用于在 group_by() 子句中引用窗口，并可以在 select() 子句中选择如窗口开始、结束或行时间戳的窗口属性。

#使用窗口函数
result = orders.window(win_fun) \
               .group_by(col('name'), col('w')) \
               .select(col('name'), col('w').start, col('w').end, col('revenue').sum.alias('d')).order_by("d")
result.execute().print()

+--------------------------------+-------------------------+-------------------------+-------------+
|                           name |                  EXPR$0 |                  EXPR$1 |           d |
+--------------------------------+-------------------------+-------------------------+-------------+
|                           Jack | 2023-02-22 19:00:00.000 | 2023-02-22 20:00:00.000 |          10 |
|                           Jack | 2023-02-23 15:00:00.000 | 2023-02-23 16:00:00.000 |          20 |
|                           Rose | 2023-02-23 05:00:00.000 | 2023-02-23 06:00:00.000 |          30 |
|                            Bob | 2023-02-24 01:00:00.000 | 2023-02-24 02:00:00.000 |          90 |
|                             YU | 2023-02-22 22:00:00.000 | 2023-02-22 23:00:00.000 |         100 |
+--------------------------------+-------------------------+-------------------------+-------------+

4.3窗口函数 - Over Window

和 SQL 的 OVER 子句类似 PS：暂时没有测试数据，参考sql即可

Over.partition_by(col("a")) \ 
 .order_by(col("rowtime")) \ 
 .preceding(expr.UNBOUNDED_RANGE) \ 
 .alias("w")

order_by 需是time 属性才可以排序

4.4Distinct Aggregation

和 SQL DISTINCT 聚合子句类似，例如 COUNT(DISTINCT a)。

#去重后相加
group_by_distinct_result = orders.group_by(col("name")) \
                                 .select(col("name"), col("revenue").sum.distinct.alias('d'))
group_by_distinct_result .execute().print()

+--------------------------------+-------------+
|                           name |           d |
+--------------------------------+-------------+
|                           Jack |          30 |
|                            Bob |          90 |
|                             YU |         100 |
|                           Rose |          30 |
+--------------------------------+-------------+

也可以直接Distinct，筛选完全相同的行数据。

orders1 = table_env.from_elements(
    [
        ('Jack', 'FRANCE', 10),
        ('Jack', 'FRANCE', 10)
        
    ],
    DataTypes.ROW([DataTypes.FIELD("name", DataTypes.STRING()), 
                  DataTypes.FIELD("country", DataTypes.STRING()),
                  DataTypes.FIELD("revenue", DataTypes.INT())
                ]))
result = orders1.distinct()
result .execute().print()

+--------------------------------+--------------------------------+-------------+
|                           name |                        country |     revenue |
+--------------------------------+--------------------------------+-------------+
|                           Jack |                         FRANCE |          10 |
+--------------------------------+--------------------------------+-------------+