在flink-connector-jdbc中增加对国产数据库达梦(V8)的支持

已于 2023-09-01 19:38:07 修改
阅读量2.6k 收藏 6
点赞数 1
分类专栏： Flink Java Dameng 文章标签： flink 数据库 大数据
于 2023-09-01 19:32:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010782920/article/details/132629644
版权
Flink 同时被 3 个专栏收录
7 篇文章 0 订阅
订阅专栏
Java
5 篇文章 0 订阅
订阅专栏
Dameng
1 篇文章 0 订阅
订阅专栏

在flink-connector-jdbc中增加对国产数据库达梦(V8)的支持

​ 本文将展示如何在flink-connector-jdbc中增加对国产数据库达梦(V8)的支持。演示基于Java语言，使用Maven。

1. 关于flink-connector-jdbc

​ flink-connector-jdbc是Apache Flink框架提供的一个用于与关系型数据库进行连接和交互的连接器。它提供了使用Flink进行批处理和流处理的功能，可以方便地将关系型数据库中的数据引入Flink进行分析和处理，或者将Flink计算结果写入关系型数据库。

​ flink-connector-jdbc可以实现以下核心功能：

  • 数据源连接：可以通过flink-connector-jdbc连接到各种支持JDBC标准的关系型数据库，如MySQL、PostgreSQL、Oracle等。
  • 数据写入：可以将Flink的计算结果写入关系型数据库中，实现数据的持久化。
  • 数据读取：可以从关系型数据库中读取数据，并将其作为Flink计算的输入数据。
  • 数据格式转换：可以将关系型数据库中的数据转换为适合Flink计算的数据格式。
  • 并行处理：可以根据数据源的并行度将数据进行分区和并行处理，以加速数据处理的速度。

​ flink-connector-jdbc为Flink提供了与关系型数据库集成的能力，可以方便地进行数据的导入、导出和处理，为开发人员提供了更强大和灵活的数据处理能力。

2. flink-connector-jdbc包含对哪些关系型数据库的支持

​ 截止目前，flink最新版到flink-1.17.1，但是不管是flink-1.17.0还是flink-1.17.1，都没有找到关于flink-connector-jdbc的实现，从flink-1.16.2中能相关实现找到；

在这里插入图片描述

​ 可以看到，flink-connector-jdbc目前只支持4种关系型数据库：derby、mysql、oracle、psql，

3. 在flink-1.17中添加对flink-connector-jdbc支持

​ 这个不难，直接把flink-1.16.2中flink-connector-jdbc的代码实现拷贝到flink-1.17.0中相应位置即可，但注意修改flink-connectors和flink-connector-jdbc下的pom.xml文件

在这里插入图片描述

4. 在flink-connector-jdbc中添加对国产数据库达梦(V8)的支持

4.1 新增DamengRowConverter

​ 在flink-connector-jdbc模块的org.apache.flink.connector.jdbc.internal.converter包下新增DamengRowConverter.java

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

import org.apache.flink.connector.jdbc.converter.AbstractJdbcRowConverter;
import org.apache.flink.table.data.DecimalData;
import org.apache.flink.table.data.StringData;
import org.apache.flink.table.data.TimestampData;
import org.apache.flink.table.types.logical.DecimalType;
import org.apache.flink.table.types.logical.LogicalType;
import org.apache.flink.table.types.logical.RowType;

import dm.jdbc.driver.DmdbBlob;
import dm.jdbc.driver.DmdbClob;

import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;

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

    private static final long serialVersionUID = 1L;

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

    @Override
    public JdbcDeserializationConverter createInternalConverter(LogicalType type) {
        switch (type.getTypeRoot()) {
            case NULL:
                return val -> null;
            case BOOLEAN:
            case FLOAT:
            case DOUBLE:
            case INTERVAL_YEAR_MONTH:
            case INTERVAL_DAY_TIME:
            case INTEGER:
            case BIGINT:
                return val -> val;
            case TINYINT:
                return val -> {
                    if (val instanceof Byte) {
                        return (Byte) val;
                    } else if (val instanceof Short) {
                        return ((Short) val).byteValue();
                    } else {
                        return ((Integer) val).byteValue();
                    }
                };
            case SMALLINT:
                // Converter for small type that casts value to int and then return short value,
                // since
                // JDBC 1.0 use int type for small values.
                return val -> val instanceof Integer ? ((Integer) val).shortValue() : val;
            case DECIMAL:
                final int precision = ((DecimalType) type).getPrecision();
                final int scale = ((DecimalType) type).getScale();
                // using decimal(20, 0) to support db type bigint unsigned, user should define
                // decimal(20, 0) in SQL,
                // but other precision like decimal(30, 0) can work too from lenient consideration.
                return val ->
                        val instanceof BigInteger
                                ? DecimalData.fromBigDecimal(
                                new BigDecimal((BigInteger) val, 0), precision, scale)
                                : DecimalData.fromBigDecimal((BigDecimal) val, precision, scale);
            case DATE:
                return val ->
                        (int) ((Date.valueOf(String.valueOf(val))).toLocalDate().toEpochDay());
            case TIME_WITHOUT_TIME_ZONE:
                return val ->
                        (int)
                                ((Time.valueOf(String.valueOf(val))).toLocalTime().toNanoOfDay()
                                        / 1_000_000L);
            case TIMESTAMP_WITH_TIME_ZONE:
            case TIMESTAMP_WITHOUT_TIME_ZONE:
                return val -> TimestampData.fromTimestamp((Timestamp) val);
            case CHAR:
            case VARCHAR:
                return val -> {
                    // support text type
                    if (val instanceof DmdbClob) {
                        try {
                            return StringData.fromString(
                                    inputStream2String(((DmdbClob) val).getAsciiStream()));
                        } catch (Exception e) {
                            throw new UnsupportedOperationException(
                                    "failed to get length from text");
                        }
                    } else if (val instanceof DmdbBlob) {
                        try {
                            return StringData.fromString(
                                    inputStream2String(((DmdbBlob) val).getBinaryStream()));
                        } catch (Exception e) {
                            throw new UnsupportedOperationException(
                                    "failed to get length from text");
                        }
                    } else {
                        return StringData.fromString((String) val);
                    }
                };
            case BINARY:
            case VARBINARY:
                return val ->
                        val instanceof DmdbBlob
                                ? ((DmdbBlob) val).getBytes(1, (int) ((DmdbBlob) val).length())
                                : val.toString().getBytes();
            case ARRAY:
            case ROW:
            case MAP:
            case MULTISET:
            case RAW:
            default:
                return super.createInternalConverter(type);
        }
    }

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

    /**
     * get String from inputStream.
     *
     * @param input inputStream
     * @return String value
     * @throws IOException convert exception
     */
    private static String inputStream2String(InputStream input) throws IOException {
        StringBuilder stringBuffer = new StringBuilder();
        byte[] byt = new byte[1024];
        for (int i; (i = input.read(byt)) != -1; ) {
            stringBuffer.append(new String(byt, 0, i));
        }
        return stringBuffer.toString();
    }
}

​ 在Flink的flink-connector-jdbc中，createInternalConverter是一个方法，用于创建将JDBC ResultSet中的数据转换为Flink的内部数据结构的转换器。这个方法通常在JDBCInputFormat中被调用。

​ 在Flink中，使用JDBCInputFormat从关系型数据库中读取数据时，它会将JDBC的ResultSet对象作为输入，然后通过createInternalConverter方法将ResultSet中的每一行数据转换为Flink的内部数据结构（例如Tuple或Row），以便后续的处理和计算。

​ createInternalConverter方法接受参数ResultSetExtractor，它是一个接口，定义了将ResultSet中的数据转换为Flink内部数据结构的方法。实际上，Flink的flink-connector-jdbc提供了一些默认的ResultSetExtractor实现，可以根据数据的类型自动选择适当的转换规则。例如，对于数字类型的数据，可以使用JDBCTypeInformation来进行转换，对于字符串类型的数据，可以使用JDBCTypeUtils进行转换。

​ 除了默认的转换器之外，也可以根据具体的需求自定义createInternalConverter方法。这样可以根据数据的特定类型或格式，定义自己的转换规则，并将ResultSet中的数据转换为特定的数据类型。

4.2 新增Dameng的dialect

4.2.1 DamengDialectFactory

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

import org.apache.flink.annotation.Internal;
import org.apache.flink.connector.jdbc.dialect.JdbcDialect;
import org.apache.flink.connector.jdbc.dialect.JdbcDialectFactory;

@Internal
public class DamengDialectFactory implements JdbcDialectFactory {
    @Override
    public boolean acceptsURL(String url) {
        return url.startsWith("jdbc:dm:");
    }

    @Override
    public JdbcDialect create() {
        return new DamengDialect();
    }
}

​ 在flink-connector-jdbc中，JdbcDialectFactory是一个工厂类，用于创建特定数据库的JdbcDialect实例。

​ JdbcDialectFactory的主要作用是根据用户提供的JDBC连接URL，确定要连接的数据库类型，并创建对应的JdbcDialect实例。JdbcDialect是一个接口，定义了与特定数据库相关的SQL语法和行为。不同类型的数据库可能具有一些特定的SQL方言，并且可能有不同的行为和限制。JdbcDialectFactory利用JDBC连接URL中所指定的数据库类型信息，根据配置中的各种数据库方言实现，创建适用于该数据库的JdbcDialect实例。

​ 通过JdbcDialect实例，flink-connector-jdbc可以为特定类型的数据库提供更高级的功能和最佳性能。例如，JdbcDialect可以优化生成的SQL查询，使用特定的语法和函数。它还可以检测数据库支持的特性，以避免不支持的操作。

​ 使用JdbcDialectFactory时，通常在flink-connector-jdbc的连接器配置中指定JDBC连接URL，以确定要连接的数据库类型。之后，会调用JdbcDialectFactory.create方法，提供JDBC连接URL，根据该URL创建并返回适当的JdbcDialect实例。然后，该JdbcDialect实例可以与JDBCInputFormat和JDBCOutputFormat等组件一起使用，以实现特定数据库的查询和操作。

4.2.2 DamengDialect

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

import org.apache.flink.connector.jdbc.converter.JdbcRowConverter;
import org.apache.flink.connector.jdbc.dialect.AbstractDialect;
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.EnumSet;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

/** JDBC dialect for Dameng. */
class DamengDialect extends AbstractDialect {

    private static final long serialVersionUID = 1L;

    private static final int MAX_TIMESTAMP_PRECISION = 9;
    private static final int MIN_TIMESTAMP_PRECISION = 1;

    private static final int MAX_DECIMAL_PRECISION = 38;
    private static final int MIN_DECIMAL_PRECISION = 1;

    @Override
    public JdbcRowConverter getRowConverter(RowType rowType) {
        return new OracleRowConverter(rowType);
    }

    @Override
    public String getLimitClause(long limit) {
        return "FETCH FIRST " + limit + " ROWS ONLY";
    }

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

    @Override
    public String dialectName() {
        return "Dameng";
    }

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

    @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 Optional<Range> decimalPrecisionRange() {
        return Optional.of(Range.of(MIN_DECIMAL_PRECISION, MAX_DECIMAL_PRECISION));
    }

    @Override
    public Optional<Range> timestampPrecisionRange() {
        return Optional.of(Range.of(MIN_TIMESTAMP_PRECISION, MAX_TIMESTAMP_PRECISION));
    }

    @Override
    public Set<LogicalTypeRoot> supportedTypes() {
        // The data types used in Dameng are list at:
        // https://www.techonthenet.com/oracle/datatypes.php

        return EnumSet.of(
                LogicalTypeRoot.CHAR,
                LogicalTypeRoot.VARCHAR,
                LogicalTypeRoot.BOOLEAN,
                LogicalTypeRoot.VARBINARY,
                LogicalTypeRoot.DECIMAL,
                LogicalTypeRoot.TINYINT,
                LogicalTypeRoot.SMALLINT,
                LogicalTypeRoot.INTEGER,
                LogicalTypeRoot.BIGINT,
                LogicalTypeRoot.FLOAT,
                LogicalTypeRoot.DOUBLE,
                LogicalTypeRoot.DATE,
                LogicalTypeRoot.TIME_WITHOUT_TIME_ZONE,
                LogicalTypeRoot.TIMESTAMP_WITHOUT_TIME_ZONE,
                LogicalTypeRoot.TIMESTAMP_WITH_LOCAL_TIME_ZONE,
                LogicalTypeRoot.ARRAY);
    }
}

​ 在flink-connector-jdbc中，JdbcDialect是一个接口，用于定义与特定数据库相关的SQL语法和行为。每种不同类型的数据库可能有一些特定的SQL方言和行为，JdbcDialect提供了一种方式来处理这些差异，以确保在不同类型的数据库上执行的SQL操作正确执行，并且能够提供最佳的性能。

​ JdbcDialect接口定义了以下几种方法：

  • String quoteIdentifier(String identifier): 将标识符（例如表名、列名）包装在适当的引号中，以在SQL语句中正确引用它。这是为了处理不同数据库对标识符的命名规则的差异。
  • JdbcRowConverter getRowConverter(RowTypeInfo rowTypeInfo): 根据给定的RowTypeInfo，创建一个JdbcRowConverter实例，用于将Flink的Row数据对象转换为适用于特定数据库的JDBC数据对象。这是为了处理不同数据库对数据类型的差异。
  • Optional defaultDriverName(): 获取JDBC驱动程序的默认名称，以在使用未指定驱动程序名称的情况下与数据库建立连接。
  • Optional getUpsertStatement(String tableName, String[] fieldNames, String[] uniqueKeyFields): 用于生成用于"upsert"（插入或更新）操作的SQL语句。"Upsert"操作是指当目标表中存在指定的记录时，执行更新操作；如果不存在，则执行插入操作；在具体的JdbcDialect的实现中，getUpsertStatement方法会根据特定数据库的语法和行为生成相应的SQL语句。不同数据库对于"upsert"操作的语法可能有所不同，因此JdbcDialect会根据数据库类型来生成适当的语句。

​ JdbcDialect的具体实现类会根据特定数据库的特性来实现这些方法，以确保flink-connector-jdbc在不同类型的数据库上能够正确工作。例如，MySQLDialect、PostgresDialect和OracleDialect等都是JdbcDialect的实现类，分别处理MySQL、PostgreSQL和Oracle数据库的特定语法和行为。

5. 实测

​ 编译打包不难，这里略过，我们测试一下；

​ 我这边第一次测试时，就遇到一个大坑，数据写入失败，日志如下：

2023-09-01 17:38:58,545 ERROR org.apache.flink.connector.jdbc.internal.JdbcOutputFormat    [] - JDBC executeBatch error, retry times = 0
dm.jdbc.driver.DMException: Unbinded parameter: 0
	at dm.jdbc.driver.DBError.throwz(DBError.java:727) ~[DmJdbcDriver18-8.1.2.79.jar:- 8.1.2.79 - Production]
	at dm.jdbc.driver.DmdbPreparedStatement.checkBindParameters(DmdbPreparedStatement.java:347) ~[DmJdbcDriver18-8.1.2.79.jar:- 8.1.2.79 - Production]
	at dm.jdbc.driver.DmdbPreparedStatement.beforeExectueWithParameters(DmdbPreparedStatement.java:372) ~[DmJdbcDriver18-8.1.2.79.jar:- 8.1.2.79 - Production]
	at dm.jdbc.driver.DmdbPreparedStatement.do_executeLargeBatch(DmdbPreparedStatement.java:535) ~[DmJdbcDriver18-8.1.2.79.jar:- 8.1.2.79 - Production]
	at dm.jdbc.driver.DmdbPreparedStatement.do_executeBatch(DmdbPreparedStatement.java:514) ~[DmJdbcDriver18-8.1.2.79.jar:- 8.1.2.79 - Production]
	at dm.jdbc.driver.DmdbPreparedStatement.executeBatch(DmdbPreparedStatement.java:1494) ~[DmJdbcDriver18-8.1.2.79.jar:- 8.1.2.79 - Production]
	at org.apache.flink.connector.jdbc.statement.FieldNamedPreparedStatementImpl.executeBatch(FieldNamedPreparedStatementImpl.java:65) ~[flink-connector-jdbc-1.17.0.jar:1.17.0]
	at org.apache.flink.connector.jdbc.internal.executor.TableInsertOrUpdateStatementExecutor.executeBatch(TableInsertOrUpdateStatementExecutor.java:104) ~[flink-connector-jdbc-1.17.0.jar:1.17.0]
	at org.apache.flink.connector.jdbc.internal.executor.TableBufferReducedStatementExecutor.executeBatch(TableBufferReducedStatementExecutor.java:101) ~[flink-connector-jdbc-1.17.0.jar:1.17.0]
	at org.apache.flink.connector.jdbc.internal.JdbcOutputFormat.attemptFlush(JdbcOutputFormat.java:246) ~[flink-connector-jdbc-1.17.0.jar:1.17.0]
	at org.apache.flink.connector.jdbc.internal.JdbcOutputFormat.flush(JdbcOutputFormat.java:216) ~[flink-connector-jdbc-1.17.0.jar:1.17.0]
	at org.apache.flink.connector.jdbc.internal.JdbcOutputFormat.lambda$open$0(JdbcOutputFormat.java:155) ~[flink-connector-jdbc-1.17.0.jar:1.17.0]
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511) [?:1.8.0_221]
	at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:308) [?:1.8.0_221]
	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:180) [?:1.8.0_221]
	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:294) [?:1.8.0_221]
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) [?:1.8.0_221]
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) [?:1.8.0_221]
	at java.lang.Thread.run(Thread.java:748) [?:1.8.0_221]
2023-09-01 17:38:58,679 ERROR org.apache.flink.connector.jdbc.internal.JdbcOutputFormat    [] - JDBC executeBatch error, retry times = 1
dm.jdbc.driver.DMException: Unbinded parameter: 0

​ 这个异常很奇怪：dm.jdbc.driver.DMException: Unbinded parameter: 0

​ 总之，代码看不出问题来，正百思不得其解的时候，决定升级DmJdbcDriver试试，从8.1.2.79升到了8.1.2.141，终于成功了！

​ 原始代码下载可以参考： https://gitee.com/flink_acme/flink-connector-jdbc.git

6. 附

​ 达梦数据库版本：

SQL> select *，id_code from v$version;

LINEID     BANNER                    id_code                                
---------- ------------------------- ---------------------------------------
1          DM Database Server 64 V8  1-2-38-21.07.09-143359-10018-ENT  Pack1
2          DB Version: 0x7000c       1-2-38-21.07.09-143359-10018-ENT  Pack1

used time: 00:00:07.719. Execute id is 2300.
SQL> 
SQL> select * from v$instance;

LINEID     NAME     INSTANCE_NAME INSTANCE_NUMBER HOST_NAME SVR_VERSION                DB_VERSION         
---------- -------- ------------- --------------- --------- -------------------------- -------------------
           START_TIME          STATUS$ MODE$  OGUID       DSC_SEQNO   DSC_ROLE
           ------------------- ------- ------ ----------- ----------- --------
1          DMSERVER DMSERVER      1               bd161     DM Database Server x64 V8  DB Version: 0x7000c
           2023-08-28 13:51:41 OPEN    NORMAL 0           0           NULL


used time: 565.918(ms). Execute id is 2301.
武舞悟
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
大数据Flink（十四）：流批一体API Connectors JDBC
Lansonli（蓝深李）的博客
04-28 1038
【代码】大数据Flink（十四）：流批一体API Connectors JDBC。
Flink JDBC Connector：Flink 与数据库集成最佳实践
SmartSi
08-26 2632
Dialect (方言)对各个数据库来说，Dialect 体现各个数据库的特性，比如语法、数据类型等。如果需要查看详细的差异，可以点击这里[6]查看详细差异。下面通过对比 MySQL 和 Postgres 的一些常见场景举例：在数据类型上面，Flink SQL 的数据类型目前映射规则如下：Flink 目前支持三种 Dialect: Derby、MySQL、PostgreSQL，Derby 主要用于测试，更多的类型映射可以点击下方链接前往官方文档查看。......
【源码改造】Flink-jdbc-connector源码简析+改造支持谓词下推
hiliang521的博客
07-10 2524
flink sql在维表关联时，会有一个场景：当右表的数据量比较大且有些数据虽然符合join条件，但其实对于下游来说数据可能没用，这样就浪费了flink的计算资源，且拉低了数据处理能力。如果在join前就把维表的数据进一步过滤，然后再join，这样就会使减轻“无用数据”对flink内存的占用，提高计算能力，进而优化数据处理的能力。...............
flink connector实现原理和自定义connector
最新发布
litlit023的专栏
04-25 70
flink connector实现原理和自定义实现connector
使用flink-connector-jdbc实现flink写入clickhouse、mysql等
weixin_43695091的博客
05-01 3090
使用flink-connector-jdbc实现flink写入clickhouse、mysql等 适用范围：flink1.11.0及之后版本，包名为flink-connector-jdbc 编辑pom.xml中的<dependencies />小节添加依赖。 <dependency> <groupId>org.apache.flink</groupId> <artifactId>fli
Flink从入门到精通系列（九）
prefect_start的博客
03-16 640
Flink函数
flink-connector-jdbc_2.12 简介、中文文档、中英对照文档 下载
寒水馨
01-30 1412
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 驱动连接到任意类型的关系型数
Flink 1.17教程：输出算子之输出到MySQL（JDBC）
学亮编程手记
09-07 364
（2）启动MySQL，在test库下建表ws。写入数据的MySQL的测试步骤如下。（3）编写输出到MySQL的示例代码。
flink cdc数据同步，DataStream方式和SQL方式的简单使用
xiaobug_zs的博客
05-08 3715
flink cdc能感知数据库的所有修改、新增、删除操作，并以流的形式，进行实时的触发和反馈。
flink-connector-jdbc-2.12-1.14.3-API文档-中英对照版.zip
06-06
赠送jar包：flink-connector-jdbc_2.12-1.14.3.jar； 赠送原API文档：flink-connector-jdbc_2.12-1.14.3-javadoc.jar； 赠送源代码：flink-connector-jdbc_2.12-1.14.3-sources.jar； 赠送Maven依赖信息文件：flink-...
flink-connector-jdbc_2.11-1.14.4.jar
07-13
flinkSQL包含clickhouse的jdbc的jar包
Flink1.14.4自定义flink-connector-jdbc连接SQLServer和SAP数据库
07-08
Flink1.14.4自定义flink-connector-jdbc连接SQLServer和SAP数据库
flink-connector-jdbc_2.12-1.14.5.jar 重新编译 支持连接clickhouse
08-10
在csdn上找了几个支持clickhouse的jar包都不能用，有的甚至jar包里都没有添加clickhouse，一气之下自己编译了一个，亲测可用，记得也要导入 clickhouse jdbc依赖
flink-connector-jdbc_2.11-1.12.1.jar
11-03
flink sql 连接clickhouse,需要修改flink -jdbc-connector 包,我已经编译完成,需要的自行下载
Flink 学习十 FlinkSQL
weixin_44244088的博客
06-20 9503
flinksql 从入门到入门...
flink数据源（自定义数据源mysql、kafka、hbase、mongo）
weixin_51981189的博客
01-09 878
Flink Job在提交执行计算时，需要首先建立和Flink框架之间的联系，也就指的是当前的flink运行环境，只有获取了环境信息，才能将task调度到不同的taskManager执行。先在idea中导入相应的依赖（这里我的scala是2.11 flink是1.9.1版本 可自行修改）先在kafka中创建主题，打开生产端生产数据，然后我们就可以。4.读取kafka数据（要加依赖 上面我们已经加过了！读取mongodb数据源数据。读取hbase数据源数据。读取mysql数据源。读取redis数据源。
JDBC如何访问达梦集群数据库？
weixin_41123586的博客
11-15 2194
JDBC如何访问达梦集群数据库？
flinkx使用指南
Naiverloser的博客
12-21 2354
下载代码 1.使用git工具把项目clone到本地 git clone https://github.com/DTStack/flinkx.git cd flinkx 2.直接下载源码 wget https://github.com/DTStack/flinkx/archive/1.8.5.zip unzip flinkx-1.8.5.zip cd flink-1.8.5 编译插件 mvn clean package -DskipTests 运行任务 首先准备要运行的任务json，这里以stream插
flink-connector-jdbc.jar下载
05-13
Flink-connector-jdbc.jar是Flink框架的一个外部扩展，适用于将Flink与关系型数据库进行集成。JDBC是Java数据库连接的缩写，使用该扩展可以使Flink能够在运行时连接数据库，并读取或写入数据。 下载flink-connector-jdbc.jar有两种方法： （一）通过Flink官网下载（建议使用此方法） 在Flink官网的下载页面中，可以找到完整的Flink程序包，其中包含了flink-connector-jdbc.jar文件。可以根据需求选择Flink的版本和下载链接，下载完整的Flink软件包后，即可在其中找到flink-connector-jdbc.jar文件。 （二）通过Maven下载 如果使用Maven构建Flink项目，则可以通过在pom.xml文件中添加如下依赖，自动下载所需的jar包。 ```xml <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-jdbc_${scala.binary.version}</artifactId> <version>${flink.version}</version> </dependency> ``` 以上两种方法均可以下载flink-connector-jdbc.jar文件。下载完成后，将该文件放置在Flink配置文件中指定的目录下，即可成功使用该扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值