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实战--flinksql连接器(jdbc-connector)添加对clickhouse的支持
阿华田的博客
02-04 3423
简介 在目前的所有的flink版本中，flinksql原生还不支持直接ddl的当时创建clickhouse表，进行业务开发。需要我们自己实现clickhouse的connector。本文将详细介绍通过改造原生flink-connector-jdbc添加对clickhouse的支持。 步骤 第一步：模仿MySQLDialect编写自己的ClickHouseDialect，代码如下： public class ClickHouseDialect extends.........
【源码改造】Flink-jdbc-connector源码简析+改造支持谓词下推
hiliang521的博客
07-10 2567
flink sql在维表关联时，会有一个场景：当右表的数据量比较大且有些数据虽然符合join条件，但其实对于下游来说数据可能没用，这样就浪费了flink的计算资源，且拉低了数据处理能力。如果在join前就把维表的数据进一步过滤，然后再join，这样就会使减轻“无用数据”对flink内存的占用，提高计算能力，进而优化数据处理的能力。...............
Flink系列六：Flink SQl 之常用的连接器（Connector）
最新发布
weixin_52134189的博客
06-04 1317
动态表 & 连续查询，连接器（Connector），数据格式
Flink JDBC Connector：Flink 与数据库集成最佳实践
Ververica的博客
09-29 7524
整理：陈政羽（Flink 社区志愿者）摘要：Flink 1.11 引入了 CDC，在此基础上， JDBC Connector 也发生比较大的变化，本文由Apache Flink Con...
Flink从入门到精通系列（九）
prefect_start的博客
03-16 647
Flink函数
flink-connector-jdbc_2.12 简介、中文文档、中英对照文档 下载
寒水馨
01-30 1426
flink-connector-jdbc_2.12 简介、中文文档、中英对照文档 下载；org.apache.flink、flink-connector-jdbc_2.12、中文文档、中英对照文档、下载、包含jar包、原API文档、源代码、Maven依赖信息文件、翻译后的API文档、apache、flink、connector、中英对照文档、jar包、java；Flink 的 jdbc 连接器。flink-connector-jdbc 连接器允许 flink 程序使用 JDBC 驱动连接到任意类型的关系型数
flink1.14扩展JDBC连接器，使其支持ORACLE和SqlServer数据源
zhizhi120的博客
05-05 943
flink1.14只支持Derby、mysql、postgresql 三种数据源，如果需要连接其他数据源就需要手工扩展。使用时还需要引入oracle驱动依赖,oracle需要注意不同版本的方法。
Flink JDBC Connector 支持Oracle
06-14
Flink JDBC Connector 支持Oracle ， Flink 1.13.6 支持Oracle 11.2.0.4
Flink1.14.4自定义flink-connector-jdbc连接SQLServer和SAP数据库
07-08
Flink1.14.4自定义flink-connector-jdbc连接SQLServer和SAP数据库
flink-sql-connector-oracle-cdc-2.5-SNAPSHOT.jar
08-15
flink-sql-connector-oracle-cdc 2.5-SNAPSHOT
flink-sql-connector-oracle-cdc-2.3.0.jar
08-23
flinkcdc oracle 2.3.0
flink-connector-debezium:此项目主要应用于数据中台或数据平台的数据总线，支持直接实时监听MySQL、MongoDB、PostgreSQL、Oracle、SQL Server、Db2和Cassandra等数据库的数据变更
05-31
Flink-connector-debezium 基于Red Hat开源的Debezium组件，和Flink结合，实现在Flink上直接监听各种数据库的Change Log，并且能够利用Flink的特性，输出到不同的位置上，以实现数据总线和实时数仓的构建。此项目主要应用于数据中台或数据平台中数据总线的基础底座。 目前Debezium支持了MySQL、MongoDB、PostgreSQL、Oracle、SQL Server、Db2和Cassandra。理论上此连接器也支援以上所有数据库。 Getting Started mvn clean package -DskipTests example 参考DebeziumSourceITCase
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 将 Oracle 数据库中的数据表插入到 Iceberg 中
smile6868的博客
03-29 500
通过遵循上述步骤，你可以使用 Flink SQL 将 Oracle 数据库中的数据表插入到 Iceberg 中。记得在生产环境中进行充分的测试和验证，以确保数据的准确性和系统的稳定性。在你的 Flink 项目中，添加 Oracle JDBC 驱动和 Iceberg Flink Connector 的依赖。使用 Flink SQL DDL 语句创建 Iceberg 表，这个表将用于存储从 Oracle 读取的数据。使用 Flink SQL DDL 语句创建一个临时表，映射到 Oracle 数据库中的数据表。
FLINK 读取ORACLE数据-通过JDBC方式
jzy1210的专栏
08-19 6027
package quickstart.batch; import org.apache.flink.api.common.typeinfo.BasicTypeInfo; import org.apache.flink.api.java.DataSet; import org.apache.flink.api.java.ExecutionEnvironment; import org.apache.flink.api.java.io.jdbc.JDBCInputFormat; import org.apa.
Flink CDC 基于Oracle log archiving 实时同步Oracle表到Mysql
qq_41875667的博客
06-26 3810
本地运行控制台是不会输出什么提示的，不像mysql cdc 还可以看到一些查看binlog日志信息。(2).注:必须为捕获的表或数据库启用补充日志记录，以便数据更改能够捕获已更改数据库行的之前状态。具体可用参数，可查官网，也可查阿里介绍，毕竟这是阿里大大的。下图是mysqlCDC的，可以看到有连接，有读取binlog日志，并且还可以打印，后续插表也正常。下图是有打印的，但是只能打印，后续插表动作就失效了。如果不打印，那就是什么都没有。具体对应数据类型，还需查看官网，最下面有列出所有对应的数据类型。
使用flink api把数据写到oracle
wuchongyong的博客
05-16 828
在上面的代码中，我们使用了一个简单的Map函数将Tuple2转换为Row。然后，我们使用JDBCOutputFormat将Row写入Oracle。注意，setQuery方法中的占位符应该与Row中的字段顺序匹配。setBatchInterval和setBatchSize方法用于控制批量写入的大小和频率。最后，我们将并行度设置为1，以确保所有数据都被写入同一个数据库连接。要使用Flink API将数据写入Oracle，需要使用Flink的JDBC连接器。
数据湖paimon连接flink、mysql和hive
weixin_42354436的博客
07-10 1064
新晋数据湖paimon连接flink，mysql和hive
flink sql connector
尤托匹亚的博客
01-18 2134
fileSystem https://nightlies.apache.org/flink/flink-docs-release-1.14/zh/docs/connectors/table/filesystem/ CREATE TABLE MyUserTable ( column_name1 INT, column_name2 STRING, ... part_name1 INT, part_name2 STRING ) PARTITIONED BY (part_name1, part_
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、付费专栏及课程。

余额充值