paimon0.9记录

启动paimon

-- 本地模式演示
bin/start-cluster.sh

-- 启动sqlclient
bin/sql-client.sh

示例

-- 创建catalog，每次都要创建，创建一个已经存在的catalog相当于`使用`
CREATE CATALOG fs_catalog WITH (
	'type'='paimon',
	'warehouse'='file:/data/soft/paimon/catalog'
);
 
 -- 创建之后需要use
use catalog fs_catalog ;


-- 在paimon模式下，只能创建paimon表和TEMPORARY表。
CREATE TEMPORARY TABLE word_table (
    word STRING
) WITH (
    'connector' = 'datagen',
    'fields.word.length' = '1'
);

-- 控制批流操作，此处设置为流模式
SET 'execution.runtime-mode' = 'streaming';
-- 设置checkpoint间隔，这影响到数据写入的批次大小（100秒写一次），很重要
SET 'execution.checkpointing.interval' = '10 s';

-- 流式写入
INSERT INTO word_count SELECT word, COUNT(*) FROM word_table GROUP BY word;

-- 流式查询
SELECT word,cnt / 10000 AS `interval` FROM word_count;

-- 控制批流操作，此处设置为批模式
SET 'execution.runtime-mode' = 'batch';
-- 取消checkpoin设置
RESET 'execution.checkpointing.interval';
-- 设置结果展示形式，默认: table，能设为 : tableau、changelog
SET 'sql-client.execution.result-mode' = 'tableau';

-- 批式查询
SELECT word,cnt / 10000 AS `interval` FROM word_count;

CATALOG

本地+本地

• 元数据库在本地，数据在本地

 CREATE CATALOG fs_catalog WITH (
	'type'='paimon',
	'warehouse'='file:/data/soft/paimon/catalog'
 );

本地+hdfs

• 元数据库在本地，数据在hdfs

CREATE CATALOG hdfs_fs_catalog WITH (
	'type'='paimon',
	'warehouse' = 'hdfs://wsl01:8020/paimon/catalog'
);

hive+hdfs

• 元数据库在hive，数据在hdfs
• 通过hadoop配置找到hdfs相关信息
• hive 需要下载(根据flink版本)
  • https://repo.maven.apache.org/maven2/org/apache/flink/flink-sql-connector-hive-2.3.10_2.12/1.20.0/flink-sql-connector-hive-2.3.10_2.12-1.20.0.jar

CREATE CATALOG hive_catalog WITH (
    'type'='paimon',
    'metastore'='hive',
    'warehouse' = 'hdfs://wsl01:8020/paimon/hive',
    'hive-conf-dir'='/data/soft/hive/apache-hive-3.1.2-bin/conf',
 	'hadoop-conf-dir'='/data/soft/hadoop/hadoop-3.1.3/etc/hadoop'
 ); 

jdbc+hive

 CREATE CATALOG jdbc_catalog WITH (
    'type'='paimon',
    'metastore'='jdbc',
    'uri'='jdbc:mysql://wsl:3306/paimon?useUnicode=true&characterEncoding=UTF-8&user=root&password=root',
    'warehouse' = 'hdfs://wsl01:8020/paimon/hive'
 );

表目录

Schema

• 记录表结构的变化历史

Snapshot

• 快照表，paimon数据产生一次变化就会生成一个快照，有三种生成快照的方式
  • 批处理，每次sql更新操作就会形成一个快照
  • 流处理，每次checkpoint就会触发一次数据落地，形成一个快照
  • compaction，每次触发合并都会形成一个快照
    • compaction触发频率基于change-log模式
• 快照过期策略：默认只保留1小时，但是最少会保留10个版本，1小时到了，但是快照不足10个版本也不会删除，快照没了，但是数据还在，只不过不能通过snapshot-id来查询指定快照版本的数据了

选项	必需的	默认	类型	描述
snapshot.time-retained	No	1 h	Duration	已完成快照的最长时间保留。
snapshot.num-retained.min	No	10	Integer	要保留的已完成快照的最小数量。
snapshot.num-retained.max	No	Integer.MAX_VALUE	Integer	要保留的已完成快照的最大数量。

Manifest

• 清单：包括多个数据文件或更改日志文件。

Bucket

• 桶是最小的数据目录，每个桶就是一个lsm tree，如果有分区，在分区文件夹下建分桶文件夹
• 每个存储桶(文件夹)中的建议数据大小约为 200MB - 1GB
• 是数据存储的真正目录
• 有两种模式
  • 动态分桶：根据每个桶最大数据行数和最大数据量动态分桶
  • 固定分桶 ：根据主键的hash值进行分桶，没有主键就一个桶

Partition

• 分区文件夹，名称不固定，根据你的分区字段和值确定
• 来一条数据，首先要找到他的分区，然后找到他的分桶，而分区好不好找取决去，分区键和主键的关系，如果主键包含分区键，那通过主键可以直接找到分区，如果主键不包含分区键，就需要借助其他数据结构存储主键到分区的映射
  • 同分区更新表，主键包含所有分区字段，通过主键就可以确认分区
  • 跨分区更新表，主键不完整包含所有分区字段，需要借助索引
• 如果有分区，那么分桶文件夹会存在于对应分区文件夹下

主键表

• 主键表主键如果重复会根据策略进行更新操作，表中的数据主键是唯一的
• 由于数据是分区、分桶目录存放的，因此数据有一个寻址过程

CREATE TABLE my_table_pk (
    user_id BIGINT,
    item_id BIGINT,
    behavior STRING,
    dt STRING,
    hh STRING,
    PRIMARY KEY (dt, hh, user_id) NOT ENFORCED
);

分桶

动态分桶

• 每个桶的数据不应过大，因此当达到行数限制或者存储限制，就会自动创建一个新的桶。
• 由于动态分桶无法通过固定算法计算主键和分桶的关系，因此需要维护一个索引文件记录，在写入的时候要维护index，在读取的时候要读取index，但是影响都还可以接受

固定分桶

• 在建表的时候就需要指定桶的数量，默认就会初始化出n个分桶文件夹
• 根据主键的hash%n，计算主键和分桶的关系，不需要额外维护索引表，效率高
• 固定分桶的数据应当不会经常变化，如果数据变化较大导致需要缩放分桶时是一个比较复杂的操作

桶的缩放

• ALTER TABLE 仅修改表的元数据，不会重新组织或重新格式化现有数据。必须通过 INSERT OVERWRITE 实现重新组织现有数

ALTER TABLE my_table SET ('bucket' = '4');

INSERT OVERWRITE my_table PARTITION (dt = '2022-01-01')
SELECT * FROM my_table where dt = '2022-01-01'

分区表

• 在进行更新的时候，需要根据这条数据的目录（分区/分桶），因此可以将分区表分为同分区更新表和跨分区更新表
• 同分区表在数据更新时只需要借助索引文件（index），将主键和桶进行绑定，不需要管主键和分区的关系，因为主键中包含分区，在数据写入是会将索引文件加载到内存，因此对于写入的效率影响几乎为0，但是需要一部分内存，不过在写入过程结束后，会释放这部分内存
• 跨分区表在数据更新时不光需要索引文件，将主键和桶进行绑定，还需要将主键和分区绑定，因此对于跨分区表，paimon采用rocksdb进行主键-分区-分桶的绑定，这样必然会导致数据写入过程的效率受到影响（1，rocksdb加载过程，2，key-value查询过程）

同分区

CREATE TABLE my_table_pt_tonfenqu (
    user_id BIGINT,
    item_id BIGINT,
    behavior STRING,
    dt STRING,
    hh STRING,
    PRIMARY KEY (dt, hh, user_id) NOT ENFORCED
) PARTITIONED BY (dt, hh);

跨分区

CREATE TABLE my_table_pt_kuafenqu(
    user_id BIGINT,
    item_id BIGINT,
    behavior STRING,
    dt STRING,
    hh STRING,
    PRIMARY KEY (dt, hh, user_id) NOT ENFORCED
) PARTITIONED BY (dt, item_id );

借用一张图：https://developer.aliyun.com/article/1424169

分区过期策略

• 按照分区值过期（需要分期字段能被parse成时间）
  • 分区值如果是多个，可以从中指定出时间字段 partition.timestamp-pattern = ‘$dt’
• 按照分区更新时间（分区数据写入时间，分区字段可以随意）

values-time策略
partition.expiration-strategy = values-time （默认值，可以不指定）
当前时间 - 分区时间 > partition.expiration-time 则删除
partition.expiration-check-interval，检查间隔仅在流处理中适用
批处理：end-input.check-partition-expire=true 开启后（默认false 关闭），在每次任务执行后触发一次检查。如果不开起，批处理写入会永远不触发过期检查，数据永远不会过期
插入一条已经过期的数据，会立即标记为过期，进行删除

CREATE TABLE t (...) PARTITIONED BY (dt) WITH (
    'partition.expiration-time' = '7 d',
    'partition.expiration-check-interval' = '1 d',
    'partition.timestamp-formatter' = 'yyyyMMdd'   -- this is required in `values-time` strategy.
);
-- Let's say now the date is 2024-07-09，so before the date of 2024-07-02 will expire.
insert into t values('pk', '2024-07-01');

-- An example for multiple partition fields
CREATE TABLE t (...) PARTITIONED BY (other_key, dt) WITH (
    'partition.expiration-time' = '7 d',
    'partition.expiration-check-interval' = '1 d',
    'partition.timestamp-formatter' = 'yyyyMMdd',
    'partition.timestamp-pattern' = '$dt'
);

update-time策略
partition.expiration-strategy = update-time （需要明确指定）
当前时间 - 分区最后更新时间 > partition.expiration-time 则删除
partition.expiration-check-interval，检查间隔仅在流处理中适用
批处理：end-input.check-partition-expire=true 开启后（默认false 关闭），在每次任务执行后触发一次检查。如果不开起，批处理写入会永远不触发过期检查，数据永远不会过期

CREATE TABLE t_expiration_time (
    id int,
    dt string
) PARTITIONED BY (dt) WITH (
    'partition.expiration-time' = '30 s',
    'partition.expiration-check-interval' = '1 s',
    'partition.expiration-strategy' = 'update-time',
    'end-input.check-partition-expire' = 'true'
);
-- dt1分区写入一条数据
insert into t_expiration_time values(1,'dt1');

等待 1分钟后检查，数据还存在，这是因为批处理过期检查在写入操作完成后立即进行，因此检查时肯定不过期

Flink SQL> select * from t_expiration_time;
+----+-----+
| id |  dt |
+----+-----+
|  1 | dt1 |
+----+-----+
1 row in set

所以需要再次写入一条数据重新触发一次检查操作

insert into t_expiration_time values(2,'dt1');

再次等待 1分钟后检查，之前的数据还存在，这是因为，第二次的写入操作也是操作的dt1分区，因此更新了dt1分区的过期时间，所以还不会删除

Flink SQL> select * from t_expiration_time;
+----+-----+
| id |  dt |
+----+-----+
|  1 | dt1 |
+----+-----+
|  2 | dt1 |
+----+-----+
1 row in set

再次写入一条其他分区的数据重新触发一次检查操作

insert into t_expiration_time values(3,'dt2');

此时dt1分区的两条数据就被识别为过期数据删除了

Flink SQL> select * from t_expiration_time;
+----+-----+
| id |  dt |
+----+-----+
|  3 | dt2 |
+----+-----+
1 row in set

根据快照查询，发现过期删除的数据还是能查出来，那是因为数据过期了，快照还没过期，看上边的快照过期策略。

Flink SQL> select * from t_expiration_time /*+Options('scan.snapshot-id' = '1') */;
+----+-----+
| id |  dt |
+----+-----+
|  1 | dt1 |
+----+-----+
1 row in set

批处理中开启 'end-input.check-partition-expire' = 'true' 后，每次批处理操作后，触发一次过期检查
流处理中根据 'partition.expiration-check-interval' = '1 s' 周期触发过期检查
update-time模式，过期时间会一直更新，也就是一个分区在检查间隔内一直写入，这个分区的数据永远不会过期

changelog配置

CREATE TABLE my_table_pt_changelog(
    user_id BIGINT,
    item_id BIGINT,
    behavior STRING,
    dt STRING,
    hh STRING,
    PRIMARY KEY (dt, hh, user_id) NOT ENFORCED
) PARTITIONED BY (dt, item_id )
with(
	'change-log'='input'
);

none

• 批写，批读的表适用

input

• cdc采集表适用
• 有完整的修改逻辑适用

lookup

• 流式场景适用
• 没有完整的修改逻辑
• 数据时延要求高的场景适用

full-compaction

• 流式场景适用
• 没有完整的修改逻辑
• 数据时延要求低的场景适用

非主键表

INSERT/UPDATE/DELTE

覆盖

• 动态分区覆盖：select结果中包含的分区才会被影响，当查询结果为空时，没有查询到任何有效分区，因此不会做任何操作。
• 静态分区覆盖：不管你的查询结果，默认覆盖所有分区，当查询结果为空时，会将所有分区数据清空。静态分区覆盖写入相当于，先做truncate动作，然后再做写入操作

-- 动态分区（默认）覆盖写入
insert overwrite mytable as select ...
-- 或者
insert overwrite mytable/*+ OPTIONS('dynamic-partition-overwrite' = 'true') */ as select ...

-- 静态分区（dynamic-partition-overwrite = false）覆盖写入
insert overwrite mytable/*+ OPTIONS('dynamic-partition-overwrite' = 'false') */ as select ...

• 覆盖写入可以当作truncate来使用

insert overwrite mytable/*+ OPTIONS('dynamic-partition-overwrite' = 'false') */ as select * from mytable where 1=2;

• 指定分区：可以通过 PARTITION (key1 = value1, key2 = value2, …)指定分区， 当指定分区后，覆盖写入（上述操作）只影响当前分区，否则影响所有分区

-- 动态覆盖指定分区
INSERT OVERWRITE my_table PARTITION (key1 = value1, key2 = value2, ...) SELECT ...

-- 静态清空指定分区（指定分区后，查询值中不能包含分区列）
INSERT OVERWRITE my_table /*+ OPTIONS('dynamic-partition-overwrite'='false') */ 
PARTITION (k0 = 0) SELECT k1, v FROM my_table WHERE false;

更新

• 主键表，INSERT相同主键，会根据merge-engine策略，对指定主键的行数据进行更新操作
• 新版本也支持UPDATE语句进行更新
  • 1、必须是主键表
  • 2、聚合引擎必须是 deduplicate or partial-update
  • 3、flink版本必须1.7及以上版本
  • 4、只适用于批处理

删除

• 新版本支持DELETE语句
  • 1、必须是主键表
  • 2、聚合引擎必须是 deduplicate
  • 3、flink版本必须1.7及以上版本
  • 4、只适用于批处理

SELECT

批查询

• 指定快照版本，查询指定的快照，查询快照不会展示-D的数据

SET 'execution.runtime-mode' = 'batch';
RESET 'execution.checkpointing.interval';

-- 根据快照版本
SELECT * FROM t /*+ OPTIONS('scan.snapshot-id' = '1') */;
-- 根据快照时间
SELECT * FROM t /*+ OPTIONS('scan.timestamp' = '2023-12-09 23:09:12') */;
-- 根据tag
SELECT * FROM t /*+ OPTIONS('scan.tag-name' = 'my-tag') */;
-- 根据watermark
SELECT * FROM t /*+ OPTIONS('scan.watermark' = '1678883047356') */; 

• 根据快照范围查询

-- incremental between snapshot ids
SELECT * FROM t /*+ OPTIONS('incremental-between' = '12,20') */;

-- incremental between snapshot time mills
SELECT * FROM t /*+ OPTIONS('incremental-between-timestamp' = '1692169000000,1692169900000') */;

流查询

SET 'execution.runtime-mode' = 'streaming';

-- 只读取最新的数据
SELECT * FROM t /*+ OPTIONS('scan.mode' = 'latest') */;
-- 在当数据的基础上，只读取最新的数据
SELECT * FROM t /*+ OPTIONS('scan.mode' = 'latest-full') */;

-- 从指定快照开始读取最新数据(不包含指定快照)
SELECT * FROM t /*+ OPTIONS('scan.snapshot-id' = '1') */;
-- 从指定快照开始读取最新数据(包含指定快照)
SELECT * FROM t_partition /*+ OPTIONS('scan.mode'='from-snapshot-full','scan.snapshot-id' = '1') */;

-- 根据快照时间
SELECT * FROM t /*+ OPTIONS('scan.timestamp' = '2023-12-09 23:09:12') */;

-- 根据data文件产生时间
SELECT * FROM t /*+ OPTIONS('scan.file-creation-time-millis' = '1678883047356') */;

消费查询

• 当 stream 读取 Paimon 表时,当上一个作业停止时，新启动的作业可以从上一个进度继续消耗
• 读取策略有两种
  • ‘consumer.mode’ = ‘at-least-once’ 非对齐快照，至少一次语义，不丢，可能会重复，读取效率快
  • ‘consumer.mode’ = ‘exactly-once’ 对齐快照，精确一次语义，受限于checkpoint间隔，一次checkpoint出一次数据，效率慢

SET 'execution.checkpointing.interval'='60 s'
SELECT * FROM t /*+ OPTIONS('consumer-id' = 'myid', 'consumer.expiration-time' = '1 h', 'consumer.mode' = 'exactly-once') */;

--查询表的consumer情况
SELECT * FROM t$consumers;

/*
+-------------+------------------+
| consumer_id | next_snapshot_id |
+-------------+------------------+
|         myid|                1 |
+-------------+------------------+
2 rows in set
*/

• 您可以重置具有指定 Consumer ID 和下一个快照 ID 的 Consumer，并删除具有指定 Consumer ID 的 Consumer。首先，您需要使用此 Consumer ID 停止流式处理任务，然后执行重置 Consumer Action 作业。

-- 删除consumer
 bin/flink run \
 lib/paimon-flink-action-0.9.0.jar \
 reset-consumer \
 --warehouse file:///data/soft/paimon/catalog \
 --database default \ 
 --table t \
 --consumer_id myid

-- 不删除consumer，将consumer指针切换到指定snapshot，添加下边这行
--next_snapshot <next-snapshot-id>

Lookup Join

• lookup join 常用于关联维表、字典表，丰富主表的数据
• lookup join 有一个明显的问题，当关联的字典表，关联数据缺失的时候，主表数据也会丢失
• paimon也可以作为维表、字典表

CREATE CATALOG fs_catalog WITH (
	'type'='paimon',
	'warehouse'='file:/data/soft/paimon/catalog'
 );
 
use catalog fs_catalog;

-- Create a table in paimon catalog
CREATE TABLE customers (
    id INT PRIMARY KEY NOT ENFORCED,
    name STRING,
    country STRING,
    zip STRING
);

CREATE TEMPORARY TABLE orders (
    order_id INT,
    total INT,
    customer_id INT,
    proc_time AS PROCTIME()
) WITH (
  'connector' = 'kafka',
  'topic' = 'ws_test',
  'properties.bootstrap.servers' = '172.16.11.95:9092',
  'properties.group.id' = 'testGroup',
  'scan.startup.mode' = 'latest-offset',
  'format' = 'csv'
);

SET 'sql-client.execution.result-mode' = 'tableau'; 
SET 'execution.checkpointing.interval'='10 s';

SELECT o.order_id, o.total, c.country, c.zip
FROM orders AS o
-- lookup join  关联维表，一定要用左关联，否则维度信息不存在时，会导致主流丢失
LEFT JOIN customers
FOR SYSTEM_TIME AS OF o.proc_time AS c
ON o.customer_id = c.id;

重试lookup

• 除了使用left join 防止主流丢失外，还可以使用retry-strategy 需要flink 1.16+ ，会阻塞主流，重试600次后 才能接受下一条数据

SELECT /*+ LOOKUP('table'='c', 'retry-predicate'='lookup_miss', 'retry-strategy'='fixed_delay', 'fixed-delay'='1s', 'max-attempts'='600') */
o.order_id, o.total, c.country, c.zip
FROM orders AS o
LEFT  JOIN customers
FOR SYSTEM_TIME AS OF o.proc_time AS c
ON o.customer_id = c.id;

• 如果主表是cdc流，设置允许乱序不生效，异步重试不会异步，依然会阻塞
• 异步重试，但是得’output-mode’=‘allow_unordered’，允许乱序
• 通过audit_log系统表，将 CDC 流转换为 append 流即可

SELECT /*+ LOOKUP('table'='c', 'retry-predicate'='lookup_miss', 'output-mode'='allow_unordered', 'retry-strategy'='fixed_delay', 'fixed-delay'='1s', 'max-attempts'='600') */
o.order_id, o.total, c.country, c.zip
FROM orders AS o
LEFT  JOIN customers /*+ OPTIONS('lookup.async'='true', 'lookup.async-thread-number'='16') */
FOR SYSTEM_TIME AS OF o.proc_time AS c
ON o.customer_id = c.id;

lookup优化

• 针对于每个分区都是全量数据的情况(按天分区，每天都是全量字典数据)，lookup join 可以指定只扫描最新分区

SELECT o.order_id, o.total, c.country, c.zip
FROM orders AS o
LEFT JOIN customers /*+ OPTIONS('lookup.dynamic-partition'='max_pt()', 'lookup.dynamic-partition.refresh-interval'='1 h') */
FOR SYSTEM_TIME AS OF o.proc_time AS c
ON o.customer_id = c.id;

• 对于维表，可以开启query service，来优化lookup join效率，关联维表时会优先使用query service提供的服务

<FLINK_HOME>/bin/flink run \
    /path/to/paimon-flink-action-0.9.0.jar \
    query_service \
    --warehouse <warehouse-path> \
    --database <database-name> \
    --table <table-name> \
    [--parallelism <parallelism>] \
    [--catalog_conf <paimon-catalog-conf> [--catalog_conf <paimon-catalog-conf> ...]]

ALTER

修改表

-- 修改表属性
ALTER TABLE my_table SET (
    'write-buffer-size' = '256 MB'
);
ALTER TABLE my_table RESET ('write-buffer-size');

-- 修改表名
ALTER TABLE my_table RENAME TO my_table_new;

修改字段

-- 新增字段
ALTER TABLE my_table ADD (c1 INT, c2 STRING);
-- 新增字段，指定位置
ALTER TABLE my_table ADD c INT FIRST;
-- 新增字段，指定位置
ALTER TABLE my_table ADD c INT AFTER b;
-- 删除字段
ALTER TABLE my_table DROP (c1, c2);
-- 修改字段
ALTER TABLE my_table MODIFY buy_count BIGINT COMMENT 'buy count';
-- 字段改名
ALTER TABLE my_table RENAME c0 TO c1;

Watermark

-- 新增watermark
ALTER TABLE my_table ADD (
    ts AS TO_TIMESTAMP(log_ts) AFTER log_ts,
    WATERMARK FOR ts AS ts - INTERVAL '1' HOUR
);
-- 删除watermark
ALTER TABLE my_table DROP WATERMARK;
-- 修改watermark
ALTER TABLE my_table MODIFY WATERMARK FOR ts AS ts - INTERVAL '2' HOUR

CDC

• 支持表结构变更，但是支持的有限，
  • 不支持重命名表、删除字段，
  • 修改字段名会重新添加新字段
  • 修改字段类型时存储只能放大，不能缩小。varchar(30)->varch(20) ❌
• 支持添加计算列 --computed_column
• 字段类型对应
  • tinyint1-not-bool：强制tinyint(1) 转tinyint（默认转boolean）
  • to-string：所有字段类型 都变成string
• 如果不设置，默认checkpoint间隔3分钟
  • -Dexecution.checkpointing.interval=‘180 s’

MYSQL-CDC

flink-sql-connector-mysql-cdc-3.1.x.jar
mysql-connector-java-8.0.27.jar
放到lib目录下，重启cluster

同步表

• 支持多表接入同一张paimon表
• 针对于mysql物理分区表，table_name支持正则匹配多个
• 针对于mysql分库表，database_name支持正则匹配多个
• computed_column 添加计算字段
• metadata_column 元数据字段，来源表、库、操作
• mysql表必须含有主键
• paimon会自动映射mysql的主键作为自己的主键，也可以自己进行修改，但是必须保证paimon主键字段在mysql中不能为null，否则cdc任务会报错

mysql表主键id，paimon重新定义主键为id，name

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
mysql_sync_table \
--warehouse file:///data/soft/paimon/catalog \
--database mysql_cdc \
--primary_keys 'id,name' \
--table demo_1 \
--mysql_conf hostname=wsl \
--mysql_conf username=root \
--mysql_conf password=root \
--mysql_conf database-name=test \
--mysql_conf table-name='demo3'

mysql表主键id，paimon重新定义主键为id，name，paimon定义分区键为 name

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
mysql_sync_table \
--warehouse file:///data/soft/paimon/catalog \
--database mysql_cdc \
--primary_keys 'id,name' \
--partition_keys 'name' \
--table demo_2 \
--mysql_conf hostname=wsl \
--mysql_conf username=root \
--mysql_conf password=root \
--mysql_conf database-name=test \
--mysql_conf table-name='demo3'

mysql表主键id，paimon重新定义主键为id，partition_col（计算列），paimon定义分区键为 partition_col
这样每天新增的数据会进入新的分区，但是不能修改，因为修改的话会-D +I,不同分区会重复

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
mysql_sync_table \
--warehouse file:///data/soft/paimon/catalog \
--database mysql_cdc \
--primary_keys 'id,partition_col' \
--partition_keys 'partition_col' \
--computed_column 'partition_col=date_format(create_date,'yyyy-MM-dd')' \
--table demo_3 \
--mysql_conf hostname=wsl \
--mysql_conf username=root \
--mysql_conf password=root \
--mysql_conf database-name=test \
--mysql_conf table-name='demo3' \
--table_conf bucket=-1 \
--table_conf changelog-producer=input \
--table_conf sink.parallelism=1

同步库

• ignore_incompatible = true，自动忽略schema不兼容的表
• mode=combined，新增表自动添加同步任务，但是不支持自动分桶
• metadata_column 元数据信息

默认模式 mode=divided
此模式，每一个表都会生成一个task
因此新增的表，需要重启任务

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
mysql_sync_database \
--warehouse file:///data/soft/paimon/catalog \
--database mysql_cdc_all2 \
--metadata_column database_name \
--mysql_conf hostname=wsl \
--mysql_conf username=root \
--mysql_conf password=root \
--mysql_conf database-name=test \
--table_conf changelog-producer=input

combined模式 mode=combined
此模式，所有的表都会共用一个task
因此新增表后，不需要重启任务
但是不支持动态分桶，只能指定分桶数
java.lang.UnsupportedOperationException: Combine mode Sink only supports FIXED bucket mode, but ai_als_recommend_sample is HASH_DYNAMIC

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
mysql_sync_database \
--warehouse file:///data/soft/paimon/catalog \
--database mysql_cdc_all \
--mode combined \
--metadata_column database_name \
--mysql_conf hostname=wsl \
--mysql_conf username=root \
--mysql_conf password=root \
--mysql_conf database-name=test \
--table_conf bucket=2 \
--table_conf changelog-producer=input \
--table_conf sink.parallelism=2

KAFKA-CDC

Action

Merge Into action

• 只有主键表支持
• 不提供 -U 日志，因此不推荐对change-log=input的表进行merge into操作

CREATE CATALOG fs_catalog WITH (
	'type'='paimon',
	'warehouse'='file:/data/soft/paimon/catalog'
 );
 
use catalog fs_catalog;
create database paimon_action;
use paimon_action;
CREATE TABLE user1 (
    id INT,
    name STRING,
    age INT,
    PRIMARY KEY (id) NOT ENFORCED
);
INSERT INTO user1 VALUES(1,'张三',18),(2,'李四',29),(3,'张三',33);

CREATE TABLE user2 (
    id INT,
    name STRING,
    age INT,
    PRIMARY KEY (id) NOT ENFORCED
);
INSERT INTO user2 VALUES(2,'李四',29),(3,'张伞',39),(4,'王五',13);

user2，user1，关联条件为id，根据user2 更新 user1

• 关联上就更新（matched-upsert）
• user1有，user2没有的，删除（not-matched-by-source-delete）
• user2有，user1没有的，新增（not-matched-insert）
• --source_table 必须带着库名（要不然找不到user2）

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
merge_into \
--warehouse file:///data/soft/paimon/catalog \
--database paimon_action \
--table user1 \
--source_table paimon_action.user2 \
--on "user1.id = user2.id" \
--merge_actions matched-upsert,not-matched-by-source-delete,not-matched-insert \
--matched_upsert_condition '1=1' \
--matched_upsert_set 'name = user2.name,age = user2.age' \
--not-matched-by-source-delete-condition "true" \
--not_matched_insert_values '*'

根据mysql的表更新paimon

-- 只是展示一下不需要执行
CREATE TEMPORARY TABLE user3 (
  id INT,
  name STRING,
  age INT,
  PRIMARY KEY (id) NOT ENFORCED
) WITH (
   'connector' = 'jdbc',
   'url' = 'jdbc:mysql://wsl:3306/test',
   'username'='root',
   'password'='root',
   'table-name' = 'user3'
);

user3，user1，关联条件为id，根据user3 更新 user1

• 关联不上就更新（not-matched-by-source-upsert）
• 关联上就删除（matched-delete）
• --source_table 临时表不能不能不能带着库名（要不然找不到user3）

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
merge_into \
--warehouse file:///data/soft/paimon/catalog \
--database paimon_action \
--table user1 \
--source_sql "CREATE TEMPORARY TABLE user3 (id INT,name STRING,age INT,PRIMARY KEY (id) NOT ENFORCED) WITH ('connector' = 'jdbc','url' = 'jdbc:mysql://wsl:3306/test', 'username'='root',   'password'='root','table-name' = 'user3');" \
--source_table user3 \
--on "user1.id = user3.id" \
--merge_actions matched-delete,not-matched-by-source-upsert \
--matched_delete_condition "true" \
--not_matched_by_source_upsert_condition "true" \
--not_matched_by_source_upsert_set "name='匹配不上'" 

还可以引用其他catalog的表
–source_sql 可以添加若干个

-- A --source_sql example: 
-- Create a temporary view S in new catalog and use it as source table
./flink run \
    /path/to/paimon-flink-action-0.9.0.jar \
    merge_into \
    --warehouse <warehouse-path> \
    --database <database-name> \
    --table T \
    --source_sql "CREATE CATALOG test_cat WITH (...)" \
    --source_sql "CREATE TEMPORARY VIEW test_cat.`default`.S AS SELECT order_id, price, 'important' FROM important_order" \
    --source_table test_cat.default.S \
    --on "T.id = S.order_id" \
    --merge_actions not-matched-insert\
    --not_matched_insert_values *

Delete action

Flink SQL> select * from user1;
+----+----------+-----+
| id |     name | age |
+----+----------+-----+
|  2 | 匹配不上 |  29 |
|  3 | 匹配不上 |  33 |
+----+----------+-----+

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
delete \
--warehouse file:///data/soft/paimon/catalog \
--database paimon_action \
--table user1 \
--where "id >1 or name = '匹配不上' or age >10"


Flink SQL> select * from user1;
Empty set

drop partition action

CREATE TABLE t_partition(
    user_id BIGINT,
    item_id BIGINT,
    behavior STRING,
    dt STRING,
    hh STRING,
    PRIMARY KEY (user_id) NOT ENFORCED
) PARTITIONED BY (dt, hh );

insert into t_partition values
(1,1,'sing','2024-12-12','10'),
(2,1,'sing','2024-12-13','12'),
(3,1,'sing','2024-12-14','14'),
(4,1,'sing','2024-12-15','16');

-- 提交后没有报错，但是也没有返回jobid，dashboard发现job没有创建，但是语法看着是对的，感觉是个bug
bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
drop_partition \
--warehouse file:///data/soft/paimon/catalog \
--database paimon_action \
--table t_partition \
--partition "dt='2024-12-13',hh='12'" \
--partition "dt='2024-12-14',hh='14'"

compact action

• https://paimon.apache.org/docs/0.9/maintenance/dedicated-compaction/#for-databases
• 默认情况下，Paimon 写入器在写入记录时会根据需要进行 Compaction。这对于大多数使用案例来说已经足够了
• 对于有些场景下，默认写compaction会导致写入冲突，比如：固定分桶同分区多任务写入（动态分桶同分区只支持单任务写入），此时需要专业的合并任务，Dedicated Compaction Job
• 通常情况下，一个paimon数据流式写入任务包括两大任务，一个是新增，一个是异步合并，将表设置为write-only=true，并且使用专用的合并任务，能加速写入效率。
• 可以使用 -D execution.runtime-mode=batch OR -yD execution.runtime-mode=batch （对于 ON-YARN 方案）来控制批处理或流式处理模式。如果您提交批处理作业，则所有当前表文件都将被压缩。如果您提交流式处理作业，该作业将持续监控对表的新更改并根据需要执行压缩。

表的专业合并写入
指定排序聚合策略，能优化查询速度

–order_strategy
–order_by <col1,col2,…>

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
compact \
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_only_input

库的专业合并写入
–including_tables 指定库中的某些表

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
compact \
--warehouse file:///data/soft/paimon/catalog \
--including_databases only_input \
--mode combined

rollback_to action

• 回滚到指定的快照版本
• https://paimon.apache.org/docs/0.9/maintenance/manage-snapshots/#rollback-to-snapshot

<FLINK_HOME>/bin/flink run \
    /path/to/paimon-flink-action-0.9.0.jar \
    rollback_to \
    --warehouse <warehouse-path> \
    --database <database-name> \ 
    --table <table-name> \
    --version <snapshot-id> \
    [--catalog_conf <paimon-catalog-conf> [--catalog_conf <paimon-catalog-conf> ...]]

remove_orphan_files

• 删除垃圾文件
• https://paimon.apache.org/docs/0.9/maintenance/manage-snapshots/#remove-orphan-files

<FLINK_HOME>/bin/flink run \
    /path/to/paimon-flink-action-0.9.0.jar \
    remove_orphan_files \
    --warehouse <warehouse-path> \
    --database <database-name> \ 
    --table <table-name> \
    [--older_than <timestamp>] \
    [--dry_run <false/true>] 

TAG

在传统数仓场景中，从传统数据库中导入的事实表数据一般是全量导入，按天分区每天都存储一份全量数据，paimon对此提供了Tag机制，创建TAG时，会对当前数据做一份全量快照，在之后对表的数据进行更新也不会影响已经打完TAG的数据。

维护创建

https://paimon.apache.org/docs/0.9/maintenance/manage-tags/

-- 创建
bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
create_tag \
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_tags \
--tag_name first_tag

-- 删除
bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
delete_tag  \
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_tags \
--tag_name first_tag

-- 回滚到指定tag版本，还原当时的数据
bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
rollback_to \
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_tags \
--version first_tag

使用TAG

CREATE TABLE t_tags (
      age BIGINT,
      money BIGINT,
      id STRING,
      PRIMARY KEY (id) NOT ENFORCED
);
insert into t_tags values(10,1000,'1');

-- 创建第一个tag
bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
create_tag \
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_tags \
--tag_name first_tag

insert into t_tags values(20,2000,'2');

bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
create_tag \
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_tags \
--tag_name second_tag

select * from t_tags$tags;
Flink SQL> select * from t_tags$tags;
+------------+-------------+-----------+-------------------------+--------------+-------------+---------------+
|   tag_name | snapshot_id | schema_id |             commit_time | record_count | create_time | time_retained |
+------------+-------------+-----------+-------------------------+--------------+-------------+---------------+
|  first_tag |           1 |         0 | 2024-12-19 15:05:18.802 |            1 |      <NULL> |        <NULL> |
| second_tag |           2 |         0 | 2024-12-19 15:08:14.165 |            2 |      <NULL> |        <NULL> |
+------------+-------------+-----------+-------------------------+--------------+-------------+---------------+



Flink SQL> select * from t_tags;
+-----+-------+----+
| age | money | id |
+-----+-------+----+
|  10 |  1000 |  1 |
|  20 |  2000 |  2 |
+-----+-------+----+

Flink SQL> select * from t_tags/*+ OPTIONS('scan.tag-name' = 'first_tag') */;
+-----+-------+----+
| age | money | id |
+-----+-------+----+
|  10 |  1000 |  1 |
+-----+-------+----+
1 row in set


-- 修改tag中数据
insert into t_tags_auto values(20,1000,'1');

Flink SQL> select * from t_tags;
+-----+-------+----+
| age | money | id |
+-----+-------+----+
|  20 |  1000 |  1 |
|  20 |  2000 |  2 |
+-----+-------+----+
2 rows in set

-- 查询tag，发现没有影响
Flink SQL> select * from t_tags/*+ OPTIONS('scan.tag-name' = 'first_tag') */;
+-----+-------+----+
| age | money | id |
+-----+-------+----+
|  10 |  1000 |  1 |
+-----+-------+----+
1 row in set

Branch

给表创建分支，相当于在当前数据状态下复制出来了一张新的表，新建的表叫做分支表，原表称位主表，两表互不影响，而且能够从分支表上进行合并，将分支表的数据覆盖到主表

• 在不影响主表的情况下，新建分支表进行测试，测试成功后还可以进行合并
• 主副分支，优先读主表，主表没有再读分支表

维护Branch

-- 创建
bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
create_branch \
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_branch \
--branch_name slave

-- 删除
bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
delete_branch\
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_branch \
--branch_name slave
 
 -- 合并分分支到主分支
bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
fast_forward \
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_branch \
--branch_name stream

使用Branch

-- create Paimon table
CREATE TABLE t_branch (
    dt STRING NOT NULL,
    name STRING NOT NULL,
    amount BIGINT
) PARTITIONED BY (dt);


bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
create_branch \
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_branch \
--branch_name stream


Flink SQL> select * from t_branch$branches;
+-----------------+------------------+-----------------------+-------------------------+
|     branch_name | created_from_tag | created_from_snapshot |             create_time |
+-----------------+------------------+-----------------------+-------------------------+
| stream          |           <NULL> |                <NULL> | 2024-12-19 16:15:01.000 |
+-----------------+------------------+-----------------------+-------------------------+
1 row in set

-- 写入分支表
INSERT INTO `t_branch$branch_stream` VALUES ('20240725', 'apple', 4), ('20240725', 'peach', 10), ('20240726', 'cherry', 3), ('20240726', 'pear', 6);
-- 修改分支表
ALTER TABLE t_branch$branch_stream add new_col string;
-- 写入分支表
INSERT INTO `t_branch$branch_stream` VALUES ('20240725', 'apple', 4,'new');


Flink SQL>  select * from t_branch$branch_stream;
+----------+--------+--------+---------+
|       dt |   name | amount | new_col |
+----------+--------+--------+---------+
| 20240725 |  apple |      4 |  <NULL> |
| 20240725 |  peach |     10 |  <NULL> |
| 20240725 |  apple |      4 |     new |
| 20240726 | cherry |      3 |  <NULL> |
| 20240726 |   pear |      6 |  <NULL> |
+----------+--------+--------+---------+
5 rows in set

-- 只有分支表有数据，主表没有
Flink SQL> select * from t_branch;
Empty set

-- 合并分支表（Fast Forward），删除主表的一切数据，并将分支表的一切数据拷贝到主表
bin/flink run \
lib/paimon-flink-action-0.9.0.jar \
fast_forward \
--warehouse file:///data/soft/paimon/catalog \
--database default \
--table t_branch \
--branch_name stream

-- 合并完成后，我们拥有分支表的所有信息，包括新增的schema
Flink SQL> select * from t_branch;
+----------+--------+--------+---------+
|       dt |   name | amount | new_col |
+----------+--------+--------+---------+
| 20240725 |  apple |      4 |  <NULL> |
| 20240725 |  peach |     10 |  <NULL> |
| 20240725 |  apple |      4 |     new |
| 20240726 | cherry |      3 |  <NULL> |
| 20240726 |   pear |      6 |  <NULL> |
+----------+--------+--------+---------+

系统表

查快照

SELECT * FROM my_table$snapshots;

查分区

SELECT * FROM my_table$partitions;

查标签

SELECT * FROM my_table$tags;

表配置

SELECT * FROM sys.all_table_options;
+---------------+--------------------------------+--------------------------------+-----------------+
| database_name |                     table_name |                            key |           value |
+---------------+--------------------------------+--------------------------------+-----------------+
| mysql_cdc_all |                          demo2 |                         bucket |               2 |
| mysql_cdc_all |                          demo2 |             changelog-producer |           input |
| mysql_cdc_all |                          demo2 |               sink.parallelism |               2 |
+---------------+--------------------------------+--------------------------------+-----------------+
82 rows in set

调优

写入调优

流式写入检查点间隔

• ck检查点间隔在允许的情况下调大，ck过于频繁会导致写入性能下降
• 或者使用批处理模式
• 并发checkpoints改成3 (‘execution.checkpointing.max-concurrent-checkpoints’)

写入缓冲区

• 写入缓冲区缓存大小（write-buffer-size）大小调大，默认256M，默认先放到缓冲区，缓冲区满了之后再写sorted-run
• 开始缓冲区溢出策略（write-buffer-spillable）=true，默认不设置

并行度

• 一个桶1g的数据量，写入并行度（sink.parallelism）要小于等于桶的数量，最好等于，默认等于上游节点并行度

本地合并

开启本地合并，用于解决频繁更新，数据倾斜问题，local-merge-buffer-size=64mb

合并策略

• paimon是lsm tree架构，每一个sorted-run 就是一个小的Stable，当sorted-run 数量过多时，就会触发compaction，compaction 是一个资源密集型的过程为了防止sorted-run数量无限增长，当sorted-run数量达到写入停止阈值（num.sorted-run.stop-trigger）的时候就会暂停写入，默认值为达到compaction阈值+1（num-sorted-run.compaction-trigger+1），因此提高写入停止阈值就能保证停止写入不那么频繁，但是compaction的频率就会降低，会导致查询需要更多的merge on read，会影响查询的效率
  

文件格式

• avro文件类型（行存储）可以提高写入吞吐量，但会降低压缩性能
• 缺点:查询分析会变慢，如果该表有100列，但只查询了几列，则不能忽略行存储的IO。此外，压缩效率将降低，存储成本将增加。
• 行存储的统计信息的收集有点贵，建议也关闭统计信息。
• 如果您不想将所有文件都修改为Avro格式，至少可以考虑将前几层的文件修改为Avro格式。您可以使用 ‘file.format.per.level’ = ‘0:avro，1:avro’ 将前两层中的文件指定为Avro格式。

file.format = avro
metadata.stats-mode = none
file.format.per.level = 0:avro,1:avro

压缩比

默认情况下，Paimon 使用 1 级的 zstd，你可以修改压缩算法：
‘file.compression.zstd-level’：默认 zstd 级别为 1。对于更高的压缩率，可以配置为 9，但读写速度会明显降低。
file.compression.zstd-level = 1

压缩稳定性

如果存储桶或资源太少，完全压缩可能会导致 checkpoint 超时，这是 Flink 的默认 检查点超时为 10 分钟。
如果希望在这种情况下也能保持稳定，则可以调高检查点超时，例如：
execution.checkpointing.timeout = 60 min

内存

在 Paimon writer 中，有三个主要地方会占用内存：

• Writer 的内存缓冲区，由单个任务的所有 writer 共享和抢占。此内存值可通过 table 属性进行调整。write-buffer-size
• 合并多个排序运行以进行压缩时消耗的内存。可以通过选项进行调整，以更改要合并的已排序运行数。num-sorted-run.compaction-trigger
• 如果行非常大，在进行 Compaction 时，一次读取过多的数据行会消耗大量内存。减少选项可以减轻此案例的影响。read.batch-size
• 写入列式 ORC 文件所消耗的内存。减少该选项可以减少 ORC 格式的内存消耗。orc.write.batch-size
• 如果文件在写入任务中自动压缩，则某些大列的字典在压缩期间可能会显著消耗内存。
• 要禁用 Parquet 格式的所有字段的字典编码，请将 .‘parquet.enable.dictionary’= ‘false’
  要禁用 ORC 格式的所有字段的字典编码 orc.dictionary.key.threshold=‘0’，请将 .此外，设置为禁用特定列的字典编码。orc.column.encoding.direct=‘field1,field2’
• 如果您的 Flink 作业不依赖于状态，请避免使用托管内存，您可以使用以下 Flink 参数来控制托管内存：

taskmanager.memory.managed.size=1m

• 或者，您可以将 Flink 托管内存用于写入缓冲区以避免 OOM，请设置 table 属性：

sink.use-managed-memory-allocator=true

• 如果写入表的数据量特别大，Committer 节点可能会占用较大的内存，这可能会导致 OOM 如果内存太小。在这种情况下，您需要增加 Committer 堆内存，但您可能不想这样做 统一增加 Flink 的 TaskManager 的内存，这可能会导致内存浪费。

• 配置 Flink 配置 。（这是 Flink 1.18 之后的默认设置）cluster.fine-grained-resource-management.enabled: true

• 配置 Paimon Table 选项：，例如 300 MB，具体取决于您的 。 （也支持 ）sink.committer-memoryTaskManagersink.committer-cpu

最大写入吞吐量场景

• 如果希望某种模式具有最大写入吞吐量，则可以缓慢而不是匆忙地进行Compaction。可以对表使用以下策略，适合写入过程没有过多查询请求的场景，太多Sorted Run将导致查询性能较差，甚至内存不足
  num-sorted-run.stop-trigger = 2147483647
  sort-spill-threshold = 10
  lookup-wait=false
  file.format = avro
  metadata.stats-mode = none
• 或者开启write-only+专用压缩写入