Flink SQL JDBC Oracle Connector自定义开发

已于 2022-06-15 09:10:51 修改
阅读量2.5k 收藏 5
点赞数 1
分类专栏： 大数据 文章标签： oracle flink sql
于 2022-06-14 14:59:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wanghuan524/article/details/125278266
版权

Flink SQL Connector

目录：

文章目录

环境版本

组件版本
oracle11.2.0.2
flink1.13.6
scala2.11

Flink源码下载打包

[root@taia-3 flink]# git clone https://github.com/apache/flink.git

mvn clean install -DskipTests -Dfast -Pskip-webui-build -T 1C

接口开发

新增如下三个类，包名需要与源码一致

  1. OracleSQLRowConverter：org.apache.flink.connector.jdbc.internal.converter
  2. OracleDialect：org.apache.flink.connector.jdbc.dialect
  3. JdbcDialects.class：org.apache.flink.connector.jdbc.dialect

JdbcDialects

添加oracle方言,源码如下

package org.apache.flink.connector.jdbc.dialect;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

/** Default JDBC dialects. */
public final class JdbcDialects {

    private static final List<JdbcDialect> DIALECTS =
            Arrays.asList(new DerbyDialect(), new MySQLDialect(), new PostgresDialect(),
                    new OracleDialect());

    /** Fetch the JdbcDialect class corresponding to a given database url. */
    public static Optional<JdbcDialect> get(String url) {
        for (JdbcDialect dialect : DIALECTS) {
            if (dialect.canHandle(url)) {
                return Optional.of(dialect);
            }
        }
        return Optional.empty();
    }
}

OracleRowConverter

package org.apache.flink.connector.jdbc.internal.converter;

import org.apache.flink.table.types.logical.RowType;


/**
 * Runtime converter that responsible to convert between JDBC object and Flink internal object for
 * Oracle.
 */
public class OracleRowConverter extends AbstractJdbcRowConverter {

    private static final long serialVersionUID = 1L;

    public OracleRowConverter(RowType rowType) {
        super(rowType);
    }

    @Override
    public String converterName() {
        return "Oracle";
    }
}

OracleDialect

定义oracle方言，源码如下：

package org.apache.flink.connector.jdbc.dialect;

import org.apache.flink.connector.jdbc.internal.converter.JdbcRowConverter;
import org.apache.flink.connector.jdbc.internal.converter.OracleRowConverter;
import org.apache.flink.table.types.logical.LogicalTypeRoot;
import org.apache.flink.table.types.logical.RowType;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

/** JDBC dialect for Oracle. */
class OracleDialect extends AbstractDialect {
    private static final long serialVersionUID = 1L;

    // Define MAX/MIN precision of TIMESTAMP type according to Oracle docs:
    // https://www.techonthenet.com/oracle/datatypes.php
    private static final int MAX_TIMESTAMP_PRECISION = 9;
    private static final int MIN_TIMESTAMP_PRECISION = 1;

    // Define MAX/MIN precision of DECIMAL type according to Oracle docs:
    // https://www.techonthenet.com/oracle/datatypes.php
    private static final int MAX_DECIMAL_PRECISION = 38;
    private static final int MIN_DECIMAL_PRECISION = 1;

    /**
     * Check if this dialect instance can handle a certain jdbc url.
     *
     * @param url the jdbc url.
     *
     * @return True if the dialect can be applied on the given jdbc url.
     */
    @Override
    public boolean canHandle(String url) {
        return url.startsWith("jdbc:oracle:");
    }

    /**
     * Get converter that convert jdbc object and Flink internal object each other.
     *
     * @param rowType the given row type
     *
     * @return a row converter for the database
     */
    @Override
    public JdbcRowConverter getRowConverter(RowType rowType) {
        return new OracleRowConverter(rowType);
    }

    /**
     * Get limit clause to limit the number of emitted row from the jdbc source.
     *
     * @param limit number of row to emit. The value of the parameter should be non-negative.
     *
     * @return the limit clause.
     */
    @Override
    public String getLimitClause(long limit) {
        return "FETCH FIRST " + limit + " ROWS ONLY";
    }

    @Override
    public Optional<String> defaultDriverName() {
        return Optional.of("oracle.jdbc.driver.OracleDriver");
    }

    /**
     * Get the name of jdbc dialect.
     *
     * @return the dialect name.
     */
    @Override
    public String dialectName() {
        return "Oracle";
    }

    @Override
    public Optional<String> getUpsertStatement(
            String tableName, String[] fieldNames, String[] uniqueKeyFields) {

        String sourceFields =
                Arrays.stream(fieldNames)
                        .map(f -> ":" + f + " " + quoteIdentifier(f))
                        .collect(Collectors.joining(", "));

        String onClause =
                Arrays.stream(uniqueKeyFields)
                        .map(f -> "t." + quoteIdentifier(f) + "=s." + quoteIdentifier(f))
                        .collect(Collectors.joining(" and "));

        final Set<String> uniqueKeyFieldsSet =
                Arrays.stream(uniqueKeyFields).collect(Collectors.toSet());
        String updateClause =
                Arrays.stream(fieldNames)
                        .filter(f -> !uniqueKeyFieldsSet.contains(f))
                        .map(f -> "t." + quoteIdentifier(f) + "=s." + quoteIdentifier(f))
                        .collect(Collectors.joining(", "));

        String insertFields =
                Arrays.stream(fieldNames)
                        .map(this::quoteIdentifier)
                        .collect(Collectors.joining(", "));

        String valuesClause =
                Arrays.stream(fieldNames)
                        .map(f -> "s." + quoteIdentifier(f))
                        .collect(Collectors.joining(", "));

        // if we can't divide schema and table-name is risky to call quoteIdentifier(tableName)
        // for example [tbo].[sometable] is ok but [tbo.sometable] is not
        String mergeQuery =
                " MERGE INTO "
                        + tableName
                        + " t "
                        + " USING (SELECT "
                        + sourceFields
                        + " FROM DUAL) s "
                        + " ON ("
                        + onClause
                        + ") "
                        + " WHEN MATCHED THEN UPDATE SET "
                        + updateClause
                        + " WHEN NOT MATCHED THEN INSERT ("
                        + insertFields
                        + ")"
                        + " VALUES ("
                        + valuesClause
                        + ")";

        return Optional.of(mergeQuery);
    }

    @Override
    public String quoteIdentifier(String identifier) {
        return identifier;
    }

    @Override
    public int maxDecimalPrecision() {
        return MAX_DECIMAL_PRECISION;
    }

    @Override
    public int minDecimalPrecision() {
        return MIN_DECIMAL_PRECISION;
    }

    @Override
    public int maxTimestampPrecision() {
        return MAX_TIMESTAMP_PRECISION;
    }

    @Override
    public int minTimestampPrecision() {
        return MIN_TIMESTAMP_PRECISION;
    }

    /**
     * Defines the unsupported types for the dialect.
     *
     * @return a list of logical type roots.
     */
    @Override
    public List<LogicalTypeRoot> unsupportedTypes() {
        // The data types used in Oracle are list at:
        // https://www.techonthenet.com/oracle/datatypes.php
        return Arrays.asList(
                LogicalTypeRoot.BINARY,
                LogicalTypeRoot.TIMESTAMP_WITH_LOCAL_TIME_ZONE,
                LogicalTypeRoot.TIMESTAMP_WITH_TIME_ZONE,
                LogicalTypeRoot.INTERVAL_YEAR_MONTH,
                LogicalTypeRoot.INTERVAL_DAY_TIME,
                LogicalTypeRoot.ARRAY,
                LogicalTypeRoot.MULTISET,
                LogicalTypeRoot.MAP,
                LogicalTypeRoot.ROW,
                LogicalTypeRoot.DISTINCT_TYPE,
                LogicalTypeRoot.STRUCTURED_TYPE,
                LogicalTypeRoot.NULL,
                LogicalTypeRoot.RAW,
                LogicalTypeRoot.SYMBOL,
                LogicalTypeRoot.UNRESOLVED);
    }
}

打包

flink-connector-jdbc_2.11-1.13.6.jar 位于D:\sourcecode\Flink\flink-1.13.6\flink-connectors\flink-connector-jdbc\target\flink-connector-jdbc_2.11-1.13.6.jar

mvn clean install -DskipTests -Dfast -Pskip-webui-build -T 1C

测试

Junit
package org.apache.flink.connector.jdbc.table;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.EnvironmentSettings;
import org.apache.flink.table.api.TableEnvironment;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.types.Row;
import org.apache.flink.util.CollectionUtil;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static org.junit.Assert.assertEquals;

/**
 * ITCase for {@link JdbcDynamicTableSource}.
 */
public class JdbcDynamicOracleTableSourceITCase {

    public static final String DRIVER_CLASS = "oracle.jdbc.driver.OracleDriver";
    public static final String DB_URL = "jdbc:oracle:thin:@XXX.XXX.XXX.XXX:49161:XE";
    public static final String INPUT_TABLE = "SQLTEST";
    public static final String USER_NAME = "system";
    public static final String PASS_WORD = "oracle";

    public static StreamExecutionEnvironment env;
    public static TableEnvironment tEnv;

    @Before
    public void before() throws ClassNotFoundException, SQLException {
        env = StreamExecutionEnvironment.getExecutionEnvironment();
        EnvironmentSettings envSettings =
                EnvironmentSettings.newInstance().useBlinkPlanner().inStreamingMode().build();
        tEnv = StreamTableEnvironment.create(env, envSettings);
    }

    @After
    public void clearOutputTable() throws Exception {
    }

    @Test
    public void testSelectJdbcSource() throws Exception {
        tEnv.executeSql(
                "CREATE TABLE "
                        + INPUT_TABLE
                        + "("
                        + "id DECIMAL,"
                        + "name STRING,"
                        + "age DECIMAL"
                        + ") WITH ("
                        + "  'connector'='jdbc',"
                        + "  'url'='" + DB_URL
                        + "',"
                        + " 'username' = 'system', "
                        + " 'password' = 'oracle', "
                        + "  'table-name'='"
                        + INPUT_TABLE
                        + "'"
                        + ")");

        Iterator<Row> collected =
                tEnv.executeSql("SELECT id , name  FROM " + INPUT_TABLE)
                        .collect();
        List<String> result =
                CollectionUtil.iteratorToList(collected).stream()
                        .map(Row::toString)
                        .sorted()
                        .collect(Collectors.toList());
        List<String> expected =
                Stream.of(
                                "+I[1, fanfan]",
                                "+I[2, wangwu]",
                                "+I[3, zhaoliu]",
                                "+I[4, james]",
                                "+I[54, wangkobe]")
                        .sorted()
                        .collect(Collectors.toList());
        assertEquals(expected, result);
    }


    @Test
    public void testUpsert() throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.getConfig().enableObjectReuse();
        StreamTableEnvironment tEnv = StreamTableEnvironment.create(env);

        tEnv.executeSql(
                "CREATE TABLE "
                        + INPUT_TABLE
                        + "("
                        + "id DECIMAL,"
                        + "name STRING,"
                        + "age DECIMAL ,"
                        + "PRIMARY KEY(id) NOT ENFORCED"
                        + ") WITH ("
                        + "  'connector'='jdbc',"
                        + "  'url'='" + DB_URL
                        + "',"
                        + " 'username' = 'system', "
                        + " 'password' = 'oracle', "
                        + "  'table-name'='"
                        + INPUT_TABLE
                        + "'"
                        + ")");

//        tEnv.executeSql("INSERT INTO SQLTEST values(4,'curry',32)").print();
        tEnv.executeSql("INSERT INTO SQLTEST select 4,'james',32 ").print();

    }

    @Test
    public void testProject() throws Exception {
        tEnv.executeSql(
                "CREATE TABLE "
                        + INPUT_TABLE
                        + "("
                        + "id DECIMAL,"
                        + "name STRING,"
                        + "age DECIMAL"
                        + ") WITH ("
                        + "  'connector'='jdbc',"
                        + "  'url'='" + DB_URL
                        + "',"
                        + " 'username' = 'system', "
                        + " 'password' = 'oracle', "
                        + "  'table-name'='"
                        + INPUT_TABLE
                        + "',"
                        + "  'scan.partition.column'='id',"
                        + "  'scan.partition.num'='2',"
                        + "  'scan.partition.lower-bound'='0',"
                        + "  'scan.partition.upper-bound'='100'"
                        + ")");

        Iterator<Row> collected =
                tEnv.executeSql("SELECT id,name FROM " + INPUT_TABLE)
                        .collect();
        List<String> result =
                CollectionUtil.iteratorToList(collected).stream()
                        .map(Row::toString)
                        .sorted()
                        .collect(Collectors.toList());
        List<String> expected =
                Stream.of("+I[1, wanghuan]",
                                "+I[2, wangwu]",
                                "+I[3, zhaoliu]",
                                "+I[54, wangkobe]")
                        .sorted()
                        .collect(Collectors.toList());
        assertEquals(expected, result);
    }

}
上传jar到flink lib下

需要将ojdbc6-11.2.0.4.jar 放在$FLINK_HOME/lib下

需要将包含Oracle Connec 的flink-connector-jdbc_2.11-1.13.6.jar 放在$FLINK_HOME/lib下 ， 替换掉旧的flink-connector-jdbc_2.11-1.13.6.jar

Sink Oracle

需要提前手动创建oracle表结构

注意事项：Oracle表区分大小写， 字段名也区分大小写。

Flink SQL

CREATE TABLE users (
  `id` BIGINT,
  `name` STRING,
  `ts` STRING
) WITH (
  'connector' = 'kafka',
  'topic' = 'user',
  'properties.bootstrap.servers' = 'XXX.XXX.XXX.XXX:9092',
  'properties.group.id' = 'testGroup',
  'scan.startup.mode' = 'earliest-offset',
  'format' = 'json'
);

CREATE TABLE kafka_sink_oracle (
  id BIGINT , 
  name STRING,
  ts STRING ,
  PRIMARY KEY(id) NOT ENFORCED
) WITH (
  'connector' = 'jdbc',
  'url' = 'jdbc:oracle:thin:@XXX.XXX.XXX.XXX:49161:XE',
  'driver' = 'oracle.jdbc.driver.OracleDriver', 
  'username' = 'system',
  'password' = 'oracle',
  'table-name' = 'JDBC_SINK_ORACLE'
);

INSERT INTO kafka_sink_oracle select id,upper(name) as name ,ts from users;

验证

注意针对表名大小写不同，需要加双引号

SELECT * FROM JDBC_SINK_ORACLE ;

Jar包下载
https://download.csdn.net/download/wanghuan524/85638875

wanghuan524
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Flink JDBC Connector：Flink 与数据库集成最佳实践
SmartSi
08-26 2667
Dialect (方言)对各个数据库来说，Dialect 体现各个数据库的特性，比如语法、数据类型等。如果需要查看详细的差异，可以点击这里[6]查看详细差异。下面通过对比 MySQL 和 Postgres 的一些常见场景举例：在数据类型上面，Flink SQL 的数据类型目前映射规则如下：Flink 目前支持三种 Dialect: Derby、MySQL、PostgreSQL，Derby 主要用于测试，更多的类型映射可以点击下方链接前往官方文档查看。......
Flink1.14.4自定义flink-connector-jdbc连接SQLServer和SAP数据库
07-08
Flink1.14.4自定义flink-connector-jdbc连接SQLServer和SAP数据库
Flink JDBC Connector 支持Oracle
06-14
Flink JDBC Connector 支持Oracle ， Flink 1.13.6 支持Oracle 11.2.0.4
Flink中的JDBC SQL Connector
liuwei0376的专栏
05-23 9221
Flink中的JDBC SQL Connector JDBC 连接器允许使用 JDBC 驱动程序从任何关系数据库读取数据并将数据写入数据。 本文档介绍如何设置 JDBC 连接器以针对关系数据库运行 SQL 查询。 如果在 DDL 上定义了主键，则 JDBC sink 以 upsert 模式与外部系统交换 UPDATE/DELETE 消息，否则，它以 append 模式运行，不支持消费 UPDATE/DELETE 消息。 引入依赖 为了使用 JDBC 连接器，使用构建自动化工具（例如 Maven 或 SBT）
Flink系列六：Flink SQl 之常用的连接器（Connector）
最新发布
weixin_52134189的博客
06-04 1446
动态表 & 连续查询，连接器（Connector），数据格式
【源码改造】Flink-jdbc-connector源码简析+改造支持谓词下推
hiliang521的博客
07-10 2608
flink sql在维表关联时，会有一个场景：当右表的数据量比较大且有些数据虽然符合join条件，但其实对于下游来说数据可能没用，这样就浪费了flink的计算资源，且拉低了数据处理能力。如果在join前就把维表的数据进一步过滤，然后再join，这样就会使减轻“无用数据”对flink内存的占用，提高计算能力，进而优化数据处理的能力。...............
FlinkCDC第三部分-同步mysql到mysql，ctrl就完事~（flink版本1.16.2）
qq_43511677的博客
07-06 7195
需要注意的是，BEGIN STATEMENT SET 和 COMMIT 语句是 Flink SQL 的扩展语法，它们可能在某些特定的 Flink 版本或环境中才可用。通过设置适当的检查点间隔，可以在容忍一定故障的同时，控制检查点的频率和资源使用。如果在 BEGIN STATEMENT SET 和 COMMIT 之间的任何一条语句执行失败，整个事务将回滚，即已经执行的语句会被撤销。使用这个语句的好处是可以根据作业的需求和资源情况调整这些属性，以获得最佳的性能和资源利用率。
flink-sql-connector-oracle-cdc-2.5-SNAPSHOT.jar
08-15
flink-sql-connector-oracle-cdc 2.5-SNAPSHOT
flink-sql-connector-kafka-2.12-1.13.1.jar
03-15
flink-sql-connector-kafka_2.12-1.13.1.jar 是 Apache Flink 的一个 Kafka SQL Connector 的 JAR 包，用于在 Flink SQL 环境中与 Apache Kafka 集成。这里面的数字 2.12 和 1.13.1 分别表示了这个 JAR 包所依赖的 ...
flink-sql-connector-oracle-cdc-2.3.0.jar
08-23
flinkcdc oracle 2.3.0
在flink-connector-jdbc中增加对国产数据库达梦(V8)的支持
u010782920的博客
09-01 2962
本文将展示如何在flink-connector-jdbc中增加对国产数据库达梦(V8)的支持。演示基于Java语言，使用Maven。
Flink-Connectors(连接器)（1）JDBC
胖虎儿的博客
04-12 8034
什么是连接器 预定义的源和接收器 ​ Flink内置了一些基本数据源和接收器，这些数据源和接收器始终可用。该预定义的数据源包括文件、Mysql、RabbitMq、Kafka、ES 等，同时也支持数据输出到文件、Mysql、RabbitMq、Kafka、ES等。 ​ 简单的说：flink连接器就是将某些数据源加载与数据输出做了封装（连接器），我们只要引入对应的连接器依赖，即可快速的完成对数据源的加载以及数据的输出。 ​ 例如我们使用JDBC 连接器，即可快速的使用JDBC从数据库中加载数据源并支持数据通
Flink SQL --JDBC connector
chbxw
08-07 4380
一、Table API & SQL 二、SQL Client 2.1、配置 1、添加依赖jar flink-connector-jdbc_2.11-1.12.3.jar mysql-connector-java-5.1.48.jar 2、重启flink stop-cluster.sh start-cluster.sh 注意： 如果不重启的话，无法加载到上面的依赖jar java.lang.ClassNotFoundException: org.apache.flink.connector.j
Flink 将数据写入MySQL(JDBC)
文文x的博客
10-26 2741
在实际的生产环境中，我们经常会把Flink处理的数据写入MySQL、Doris等数据库中，下面以MySQL为例，使用JDBC的方式将Flink的数据实时数据写入MySQL。
Flink1.14 connector-jdbc插入更新(Upsert)模式的源码解析
weixin_44552728的博客
09-16 4082
基于flink jdbc方言(dialect)里不同Statement何时、如何被调用的思考。前言：在修改flink-connector-jdbc源码时，观察到jdbc有方言的实现，在 JdbcDialect.class 里存在insert/update和upsert两种更新语义，所以研究下何种情况执行insert/update，何种情况执行upsert。如有任何错误，欢迎大家指正。
2.3 如何使用FlinkSQL读取&写入到JDBC(MySQL)
向热爱自己一样，热爱这个世界。
10-18 4361
使用FlinkSQL读取&写入到JDBC(MySQL)
Flink1.12 SQL连接器之JDBC Connector介绍与使用总结
俩只猴的博客
02-08 5149
前言 与DataStream同样，官方在Flink SQL上也提供了很多连接器，今天来学习总结一下JDBC连接器 环境准备 如果使用编码，需要引入两个依赖包，Flink提供的jdbc连接器依赖和和对应的mysql驱动包， 以下为1.12.0 提供的jdbc连接器依赖 <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-jdbc_2.11</art
Flink从入门到精通系列（九）
prefect_start的博客
03-16 658
Flink函数
flink jdbc connector 支持oracle
07-14
总之，Flink JDBC Connector 是支持连接和操作 Oracle 数据库的，它为 Flink 应用程序提供了与 Oracle 数据库交互的便利性和灵活性，使得我们可以方便地在大数据处理中使用 Oracle 数据库。 ### 回答3： 是的，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值