flink 1.12 读写hive

问题解决

1. Caused by: org.apache.flink.runtime.messages.FlinkJobNotFoundException: Could not find Flink job

这是在sql-client中查询hive表遇到的问题，启动一下flink的Standlone集群即可。要把之前的启动的都关掉。

2. 从Kafka读数据写入hive，一直查不到数据？

打开路径/user/hive/warehouse/flink.db/user_behavior_hive_tbl 发现好多分区，原来是时间戳搞错了,吧ts/1000换成秒在转换

SQL client

1. 切换方言
Flink SQL> set table.sql-dialect=hive; -- to use hive dialect
[INFO] Session property has been set.

Flink SQL> set table.sql-dialect=default; -- to use default dialect
[INFO] Session property has been set.

Flink写入Hive表

Flink支持以**批处理(Batch)和流处理(Streaming)**的方式写入Hive表。当以批处理的方式写入Hive表时，只有当写入作业结束时，才可以看到写入的数据。批处理的方式写入支持append模式和overwrite模式。

1. 批处理模式写入

• 向非分区表写入数据

Flink SQL> use catalog myhive; -- 使用catalog
Flink SQL> insert into users select 'otis',1;
Flink SQL> set execution.type=batch; -- 使用批处理模式
Flink SQL> INSERT OVERWRITE users SELECT 'tom',2;

• 向分区表写入数据

java -jar json-data-generator-1.4.2-SNAPSHOT.jar test1Config.json

-- 建表语句
create table p_users(
name string,
age int
)partitioned by (my_date string,addr string);
-- 向静态分区表写入数据
Flink SQL> INSERT OVERWRITE p_users PARTITION (my_date='202001', addr='hebei') SELECT 'Tom', 25;

-- 建表语句
set hive.exec.dynamic.partition=true;
create table dp_users(
name string,
age int
)partitioned by (my_date string,addr string);
-- 向动态分区表写入数据
Flink SQL> INSERT OVERWRITE dp_users SELECT 'Tom', 25, '202001', 'hebei';

2. 流处理模式写入

流式写入Hive表，不支持**Insert overwrite **方式，否则报如下错误：

[ERROR] Could not execute SQL statement. Reason:
java.lang.IllegalStateException: Streaming mode not support overwrite.

练习将kafka的数据流式写入hive

-- 如果是已经存在的表，可以用这种方式增加属性
alter table user_behavior_hive_tbl set TBLPROPERTIES ( 'sink.partition-commit.delay'='60S'); 

-- 使用流处理模式
Flink SQL> set execution.type=streaming;
-- 使用Hive方言
Flink SQL> SET table.sql-dialect=hive; 
-- 创建一张Hive分区表
CREATE TABLE user_behavior_hive_tbl2 (
   `user_id` BIGINT, -- 用户id
    `item_id` BIGINT, -- 商品id
    `cat_id` BIGINT, -- 品类id
    `action` STRING, -- 用户行为
    `province` INT, -- 用户所在的省份
    `ts` BIGINT -- 用户行为发生的时间戳
) PARTITIONED BY (dt STRING,hr STRING,mi STRING) STORED AS parquet  TBLPROPERTIES (
  'partition.time-extractor.timestamp-pattern'='$dt $hr:$mi:00',
  'sink.partition-commit.trigger'='partition-time',
  'sink.partition-commit.delay'='60S',
  'sink.partition-commit.policy.kind'='metastore,success-file'
);
 
-- 使用默认SQL方言
Flink SQL> SET table.sql-dialect=default; 
-- 创建一张kafka数据源表
CREATE TABLE user_behavior ( 
    `user_id` BIGINT, -- 用户id
    `item_id` BIGINT, -- 商品id
    `cat_id` BIGINT, -- 品类id
    `action` STRING, -- 用户行为
    `province` INT, -- 用户所在的省份
    `ts` BIGINT, -- 用户行为发生的时间戳
    `proctime` AS PROCTIME(), -- 通过计算列产生一个处理时间列
    `eventTime` AS TO_TIMESTAMP(FROM_UNIXTIME(ts/1000, 'yyyy-MM-dd HH:mm:ss')), -- 事件时间
     WATERMARK FOR eventTime AS eventTime - INTERVAL '5' SECOND  -- 定义watermark
 ) WITH ( 
    'connector' = 'kafka', -- 使用 kafka connector
    'topic' = 'user_behaviors', -- kafka主题
    'scan.startup.mode' = 'latest-offset', -- 偏移量
    'properties.group.id' = 'dev_flink', -- 消费者组
    'properties.bootstrap.servers' = '10.1.30.8:9092', 
    'format' = 'json', -- 数据源格式为json
    'json.fail-on-missing-field' = 'true',
    'json.ignore-parse-errors' = 'false'
);

-- streaming sql 插入hive表
insert into user_behavior_hive_tbl2
select
    user_id,
    item_id,
    cat_id,
    action,
    province,
    ts,
    from_unixtime(ts/1000,'yyyy-MM-dd'),
    from_unixtime(ts/1000,'HH'),
    from_unixtime(ts/1000,'mm')
from user_behavior;

-- 查询hive表
select * from user_behavior_hive_tbl2 where dt='2021-02-20'
-- 问题：hive表中查不到数据？ 需要开启checkpoint才可以。
在flink-conf.yaml
state.backend: filesystem
state.checkpoints.dir: hdfs:///user/flink/qinghua/checkpoint
state.savepoints.dir: hdfs:///user/flink/qinghua/checkpoint
execution.checkpointing.interval: 60s
execution.checkpointing.mode: EXACTLY_ONCE
# 任务cancel 删除checkpoint 测试用
execution.checkpointing.externalized-checkpoint-retention: DELETE_ON_CANCELLATION

关于Hive表的一些属性解释：

• partition.time-extractor.timestamp-pattern

解释：分区时间抽取器，与 DDL 中的分区字段保持一致,如果是按天分区，则可以是$dt，如果是按年(year)月(month)日(day)时(hour)进行分区，则该属性值为：$year-$month-$day $hour:00:00，如果是按天时进行分区，则该属性值为：$day $hour:00:00;

• sink.partition-commit.trigger

默认值：process-time
process-time:
不需要时间提取器和水位线，当当前时间大于分区创建时间 + sink.partition-commit.delay 中定义的时间，提交分区；
partition-time:
需要 Source 表中定义 watermark，当 watermark > 提取到的分区创建时间 +sink.partition-commit.delay 中定义的时间，提交分区；

• sink.partition-commit.delay

默认值：0S
解释：分区提交的延时时间，如果是按天分区，则该属性的值为：1d，如果是按小时分区，则该属性值为1h;

• sink.partition-commit.policy.kind

默认值：(none)
metastore：添加分区的元数据信息，仅Hive表支持该值配置
success-file：在表的存储路径下添加一个_SUCCESS文件
解释：提交分区的策略，用于通知下游的应用该分区已经完成了写入，也就是说该分区的数据可以被访问读取。可选的值如下：
可以同时配置上面的两个值，比如metastore,success-file

Flink读取Hive表

Flink支持以批处理(Batch)和流处理(Streaming)的方式读取Hive中的表。批处理的方式与Hive的本身查询类似，即只在提交查询的时刻查询一次Hive表。流处理的方式将会持续地监控Hive表，并且会增量地提取新的数据。默认情况下，Flink是以批处理的方式读取Hive表。

关于流式读取Hive表，Flink既支持分区表又支持非分区表。对于分区表而言，Flink将会监控新产生的分区数据，并以增量的方式读取这些数据。对于非分区表，Flink会监控Hive表存储路径文件夹里面的新文件，并以增量的方式读取新的数据。

Flink读取Hive表可以配置一下参数：

• streaming-source.enable

- 默认值：false
- 解释：是否开启流式读取 Hive 表，默认不开启。

• streaming-source.partition.include

- 默认值：all
- 解释：配置读取Hive的分区，包括两种方式：**all和latest**。all意味着读取所有分区的数据，latest表示只读取最新的分区数据。值得注意的是，latest方式只能用于开启了流式读取Hive表，并用于维表JOIN的场景。

• streaming-source.monitor-interval

- 默认值：None
- 解释：持续监控Hive表分区或者文件的时间间隔。值得注意的是，当以流的方式读取Hive表时，该参数的默认值是1m，即1分钟。当temporal join时，默认的值是60m，即1小时。另外，该参数配置不宜过短 ，最短是1 个小时，因为目前的实现是每个 task 都会查询 metastore，高频的查可能会对metastore 产生过大的压力。

• streaming-source.partition-order

- 默认值：partition-name
- 解释：streaming source的分区顺序。默认的是partition-name，表示使用默认分区名称顺序加载最新分区，也是推荐使用的方式。除此之外还有两种方式，分别为：create-time和partition-time。其中create-time表示使用分区文件创建时间顺序。partition-time表示使用分区时间顺序。指的注意的是，对于非分区表，该参数的默认值为：create-time。

• streaming-source.consume-start-offset

- 默认值：None
- 解释：流式读取Hive表的起始偏移量。

• partition.time-extractor.kind

- 默认值：default
- 分区时间提取器类型。用于从分区中提取时间，支持default和自定义。如果使用default，则需要通过参数`partition.time-extractor.timestamp-pattern`配置时间戳提取的正则表达式。

在 SQL Client 中需要显示地开启 SQL Hint 功能

Flink SQL> set table.dynamic-table-options.enabled= true;  
-- 流式的查询hive表
Flink SQL> SELECT * FROM user_behavior_hive_tbl2 /*+ OPTIONS('streaming-source.enable'='true', 'streaming-source.consume-start-offset'='2021-02-20') */;

SELECT * FROM user_behavior_hive_tbl2 /*+ OPTIONS('streaming-source.enable'='true') */;

create view view_0220 as select user_id,ts,et as from_unixtime(ts/1000),watermark for et as et - interval '1' second from user_behavior_hive_tbl2 /*+ OPTIONS('streaming-source.enable'='true') */;

select user_id,count(*) from user_behavior_hive_tbl2 /*+ OPTIONS('streaming-source.enable'='true') */ group by tumble(to_timestamp(from_unixtime(ts/1000)),interval '2' second),user_id;

select user_id,count(*) from user_behavior_hive_tbl2 /*+ OPTIONS('streaming-source.enable'='true') */ group by user_id;

Hive维表JOIN

Flink 1.12 支持了 Hive 最新的分区作为时态表的功能，可以通过 SQL 的方式直接关联 Hive 分区表的最新分区，并且会自动监听最新的 Hive 分区，当监控到新的分区后，会自动地做维表数据的全量替换。

Flink支持的是processing-time的temporal join，也就是说总是与最新版本的时态表进行JOIN。另外，Flink既支持非分区表的temporal join，又支持分区表的temporal join。对于分区表而言，Flink会监听Hive表的最新分区数据。值得注意的是，Flink尚不支持 event-time temporal join。

Temporal Join最新分区

注意：

Hive分区表的每个分区都包含全量的数据，那么每个分区将做为一个时态表的版本数据。
那如果新的分区不是全量的数据呢？
或者如何能实现新的分区包含全量的数据？

对于一张随着时间变化的Hive分区表，Flink可以读取该表的数据作为一个无界流。如果Hive分区表的每个分区都包含全量的数据，那么每个分区将做为一个时态表的版本数据，即将最新的分区数据作为一个全量维表数据。值得注意的是，该功能特点仅支持Flink的STREAMING模式。

使用 Hive 最新分区作为 Tempmoral table 之前，需要设置必要的两个参数：

'streaming-source.enable' = 'true',  
'streaming-source.partition.include' = 'latest'

除此之外还有一些其他的参数，关于参数的解释见上面的分析。我们在使用Hive维表的时候，既可以在创建Hive表时指定具体的参数，也可以使用SQL Hint的方式动态指定参数。一个Hive维表的创建模板如下：

-- 使用Hive的sql方言
SET table.sql-dialect=hive;
CREATE TABLE user_dimension_table (
  user_id STRING,
  user_name STRING
) PARTITIONED BY (pt_year STRING, pt_month STRING, pt_day STRING) TBLPROPERTIES (
  -- 方式1：按照分区名排序来识别最新分区(推荐使用该种方式)
  'streaming-source.enable' = 'true', -- 开启Streaming source
  'streaming-source.partition.include' = 'latest',-- 选择最新分区
  'streaming-source.monitor-interval' = '1 m',-- 每12小时加载一次最新分区数据
  'streaming-source.partition-order' = 'partition-name',  -- 按照分区名排序
 
  -- 方式2:分区文件的创建时间排序来识别最新分区
  'streaming-source.enable' = 'true',
  'streaming-source.partition.include' = 'latest',
  'streaming-source.partition-order' = 'create-time',-- 分区文件的创建时间排序
  'streaming-source.monitor-interval' = '12 h'
 
  -- 方式3:按照分区时间排序来识别最新分区
  'streaming-source.enable' = 'true',
  'streaming-source.partition.include' = 'latest',
  'streaming-source.monitor-interval' = '12 h',
  'streaming-source.partition-order' = 'partition-time', -- 按照分区时间排序
  'partition.time-extractor.kind' = 'default',
  'partition.time-extractor.timestamp-pattern' = '$pt_year-$pt_month-$pt_day 00:00:00' 
);

除了在定义Hive维表时指定相关的参数，我们还可以通过SQL Hint的方式动态指定相关的参数，具体方式如下：

SELECT *
FROM orders_table AS orders
JOIN dimension_table
/*+ OPTIONS('streaming-source.enable'='true',             
    'streaming-source.partition.include' = 'latest',
    'streaming-source.monitor-interval' = '1 h',
    'streaming-source.partition-order' = 'partition-name') */
FOR SYSTEM_TIME AS OF orders.proctime AS dim -- 时态表(维表)
ON orders.product_id = dim.product_id;

Temporal Join最新表

对于Hive的非分区表，当使用temporal join时，整个Hive表会被缓存到Slot内存中，然后根据流中的数据对应的key与其进行匹配。使用最新的Hive表进行temporal join不需要进行额外的配置，我们只需要配置一个Hive表缓存的TTL时间，该时间的作用是：当缓存过期时，就会重新扫描Hive表并加载最新的数据。

• lookup.join.cache.ttl
  尖叫提示：
  当使用此种方式时，Hive表必须是有界的lookup表，即非Streaming Source的时态表，换句话说，该表的属性streaming-source.enable = false。
  如果要使用Streaming Source的时态表，记得配置streaming-source.monitor-interval的值，即数据更新的时间间隔。
• 默认值：60min
• 解释：表示缓存时间。由于 Hive 维表会把维表所有数据缓存在 TM 的内存中，当维表数据量很大时，很容易造成 OOM。当然TTL的时间也不能太短，因为会频繁地加载数据，从而影响性能。

-- Hive维表数据使用批处理的方式按天装载
SET table.sql-dialect=hive;
CREATE TABLE dimension_table (
  product_id STRING,
  product_name STRING,
  unit_price DECIMAL(10, 4),
  pv_count BIGINT,
  like_count BIGINT,
  comment_count BIGINT,
  update_time TIMESTAMP(3),
  update_user STRING,
  ...
) TBLPROPERTIES (
  'streaming-source.enable' = 'false', -- 关闭streaming source
  'streaming-source.partition.include' = 'all',  -- 读取所有数据
  'lookup.join.cache.ttl' = '12 h'
);
-- kafka事实表
SET table.sql-dialect=default;
CREATE TABLE orders_table (
  order_id STRING,
  order_amount DOUBLE,
  product_id STRING,
  log_ts TIMESTAMP(3),
  proctime as PROCTIME()
) WITH (...);
 
-- Hive维表join，Flink会加载该维表的所有数据到内存中
SELECT *
FROM orders_table AS orders
JOIN dimension_table FOR SYSTEM_TIME AS OF orders.proctime AS dim
ON orders.product_id = dim.product_id;

尖叫提示：
1.每一个子任务都需要缓存一份维表的全量数据，一定要确保TM的task Slot 大小能够容纳维表的数据量；
2.推荐将streaming-source.monitor-interval和lookup.join.cache.ttl的值设为一个较大的数，因为频繁的更新和加载数据会影响性能。
3.当缓存的维表数据需要重新刷新时，目前的做法是将整个表进行加载，因此不能够将新数据与旧数据区分开来。

Hive维表JOIN示例

• 创建一张kafka数据源表,实时流

SET table.sql-dialect=default;
CREATE TABLE fact_user_behavior ( 
    `user_id` BIGINT, -- 用户id
    `item_id` BIGINT, -- 商品id
    `action` STRING, -- 用户行为
    `province` INT, -- 用户所在的省份
    `ts` BIGINT, -- 用户行为发生的时间戳
    `proctime` AS PROCTIME(), -- 通过计算列产生一个处理时间列
    `eventTime` AS TO_TIMESTAMP(FROM_UNIXTIME(ts, 'yyyy-MM-dd HH:mm:ss')), -- 事件时间
     WATERMARK FOR eventTime AS eventTime - INTERVAL '5' SECOND  -- 定义watermark
 ) WITH ( 
    'connector' = 'kafka', -- 使用 kafka connector
    'topic' = 'user_behaviors', -- kafka主题
    'scan.startup.mode' = 'earliest-offset', -- 偏移量
    'properties.group.id' = 'group1', -- 消费者组
    'properties.bootstrap.servers' = 'kms-2:9092,kms-3:9092,kms-4:9092', 
    'format' = 'json', -- 数据源格式为json
    'json.fail-on-missing-field' = 'true',
    'json.ignore-parse-errors' = 'false'
);

• 创建一张Hive维表

SET table.sql-dialect=hive;
CREATE TABLE dim_item (
  item_id BIGINT,
  item_name STRING,
  unit_price DECIMAL(10, 4)
) PARTITIONED BY (dt STRING) TBLPROPERTIES (
  'streaming-source.enable' = 'true',
  'streaming-source.partition.include' = 'latest',
  'streaming-source.monitor-interval' = '12 h',
  'streaming-source.partition-order' = 'partition-name'
);

• 关联Hive维表的最新数据

SELECT 
    fact.item_id,
    dim.item_name,
    count(*) AS buy_cnt
FROM fact_user_behavior AS fact
LEFT JOIN dim_item FOR SYSTEM_TIME AS OF fact.proctime AS dim
ON fact.item_id = dim.item_id
WHERE fact.action = 'buy'
GROUP BY fact.item_id,dim.item_name;

使用SQL Hint方式，关联非分区的Hive维表：

set table.dynamic-table-options.enabled= true; 
SELECT 
    fact.item_id,
    dim.item_name,
    count(*) AS buy_cnt
FROM fact_user_behavior AS fact
LEFT JOIN dim_item1
/*+ OPTIONS('streaming-source.enable'='false',             
    'streaming-source.partition.include' = 'all',
    'lookup.join.cache.ttl' = '12 h') */
FOR SYSTEM_TIME AS OF fact.proctime AS dim
ON fact.item_id = dim.item_id
WHERE fact.action = 'buy'
GROUP BY fact.item_id,dim.item_name;