DataX 二次开发支持 Oracle 更新数据

最新推荐文章于 2024-10-13 14:29:07 发布
最新推荐文章于 2024-10-13 14:29:07 发布
阅读量4k 收藏 9
点赞数 8
分类专栏： DataX 文章标签： oracle datax
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xch_yang/article/details/128250190
版权

文章目录

前文回顾：
《DataX 及 DataX-Web 安装使用详解》
《DataX 源码调试及打包》
《DataX-Web 源码调试及打包》

目前很多主流数据库支持 on duplicate key update（当主键冲突update数据）模式，DataX 也支持通过配置 writeMode 来配置写入模式。但是目前Oracle只支持insert配置项。

如何适配 Oracle 数据库 on duplicate key update 模式，今天大佬超就来带你进行二次开发。


1、原理

writeMode 的 insert、replace、update 配置项底层采用 INSERT INTOREPLACE INTO/INSERT INTO … ON DUPLICATE KEY UPDATE 语句：

其中 insert into 当主键/唯一性索引冲突时会写不进去冲突的行；后两者没有遇到主键/唯一性索引冲突时与 insert into 行为一致，遇到冲突时会用新行替换原有行所有字段。

oracle 不支持类似 MySQL的 REPLACE INTO 和 INSERT … ON DUPLICATE KEY UPDATE，所以只支持 insert 配置项。要实现此功能，需要利用 Oracle 的 merge 语句，先来看下 merge 语法。

MERGE INTO [target-table] A USING [source-table sql] B 
ON([conditional expression] and [...]...) 
WHEN MATCHED THEN
 [UPDATE sql] 
WHEN NOT MATCHED THEN 
 [INSERT sql]

merge 语法其实就是存在就更新，不存在就插入。

示例：

MERGE INTO USERS A USING ( SELECT 18 AS "ID",'chaodev' AS "USER_ID" FROM DUAL ) TMP 
ON (TMP."ID" = A."ID" AND TMP."USER_ID" = A."USER_ID" ) 
WHEN MATCHED THEN 
UPDATE SET "USER_NAME" = '大佬超',"USER_PHONE" = '18000000000',"LASTUPDATETIME" = SYSDATE 
WHEN NOT MATCHED THEN 
INSERT ("ID","USER_ID","USER_NAME","USER_PHONE","LASTUPDATETIME") VALUES(18,'chaodev','大佬超','18000000000',SYSDATE)

所以最终实现原理就是：更改datax 的 oraclewriter 源码，通过 merge into 语句，实现 UPSERT 语义。


2、源码修改

涉及修改的类和方法如下：

oraclewriter包：

com.alibaba.datax.plugin.writer.oraclewriter.OracleWriter：修改允许用户配置 writeMode。

plugin-dbms-util包：

com.alibaba.datax.plugin.rdbms.writer.util.WriterUtil：增加oralce的逻辑代码。

com.alibaba.datax.plugin.rdbms.writer.CommonRdbmsWriter：CommonRdbmsWriter.Task类替换 startWriteWithConnection() 、doBatchInsert() 和fillPreparedStatement() 方法。


2.1 OracleWriter注释对writeMode的限制

在这里插入图片描述


2.2 WriterUtil，增加oracle逻辑

在这里插入图片描述

增加oracle的逻辑代码，如下

/**
* 新增oracle update模块
* @author 程序员大佬超
* @date 20221202
* @param columnHolders
* @param valueHolders
* @param writeMode
* @param dataBaseType
* @param forceUseUpdate
* @return
*/
public static String getWriteTemplate(List<String> columnHolders, List<String> valueHolders,
                                      String writeMode, DataBaseType dataBaseType, boolean forceUseUpdate)
{
    String mode = writeMode.trim().toLowerCase();
    boolean isWriteModeLegal = mode.startsWith("insert") || mode.startsWith("replace") || mode.startsWith("update");

    if (!isWriteModeLegal) {
        throw DataXException.asDataXException(DBUtilErrorCode.ILLEGAL_VALUE,
                                              String.format("您所配置的 writeMode:%s 错误. 因为DataX 目前仅支持replace,update 或 insert 方式. 请检查您的配置并作出修改.", writeMode));
    }
    String writeDataSqlTemplate;
    if (forceUseUpdate || mode.startsWith("update")) {
        if (dataBaseType == DataBaseType.MySql || dataBaseType == DataBaseType.Tddl) {
            writeDataSqlTemplate = new StringBuilder()
                .append("INSERT INTO %s (").append(StringUtils.join(columnHolders, ","))
                .append(") VALUES(").append(StringUtils.join(valueHolders, ","))
                .append(")")
                .append(onDuplicateKeyUpdateString(columnHolders))
                .toString();
        }
        else if (dataBaseType == DataBaseType.Oracle) {
            writeDataSqlTemplate = new StringBuilder().append(onMergeIntoDoString(writeMode, columnHolders, valueHolders)).append("INSERT (")
                .append(StringUtils.join(columnHolders, ","))
                .append(") VALUES(").append(StringUtils.join(valueHolders, ","))
                .append(")").toString();
        }
        else {
            throw DataXException.asDataXException(DBUtilErrorCode.ILLEGAL_VALUE,
                                                  String.format("当前数据库不支持 writeMode:%s 模式.", writeMode));
        }
    }
    else {
        //这里是保护,如果其他错误的使用了update,需要更换为replace
        if (writeMode.trim().toLowerCase().startsWith("update")) {
            writeMode = "replace";
        }
        writeDataSqlTemplate = new StringBuilder().append(writeMode)
            .append(" INTO %s (").append(StringUtils.join(columnHolders, ","))
            .append(") VALUES(").append(StringUtils.join(valueHolders, ","))
            .append(")").toString();
    }

    return writeDataSqlTemplate;
}

调用的方法新增如下，主要就是拼接merge语句：

public static String onMergeIntoDoString(String merge, List<String> columnHolders, List<String> valueHolders) {
    String[] sArray = getStrings(merge);
    StringBuilder sb = new StringBuilder();
    sb.append("MERGE INTO %s A USING ( SELECT ");

    boolean first = true;
    boolean first1 = true;
    StringBuilder str = new StringBuilder();
    StringBuilder update = new StringBuilder();
    for (String columnHolder : columnHolders) {
        if (Arrays.asList(sArray).contains(columnHolder)) {
            if (!first) {
                sb.append(",");
                str.append(" AND ");
            } else {
                first = false;
            }
            str.append("TMP.").append(columnHolder);
            sb.append("?");
            str.append(" = ");
            sb.append(" AS ");
            str.append("A.").append(columnHolder);
            sb.append(columnHolder);
        }
    }

    for (String columnHolder : columnHolders) {
        if (!Arrays.asList(sArray).contains(columnHolder)) {
            if (!first1) {
                update.append(",");
            } else {
                first1 = false;
            }
            update.append(columnHolder);
            update.append(" = ");
            update.append("?");
        }
    }

    sb.append(" FROM DUAL ) TMP ON (");
    sb.append(str);
    sb.append(" ) WHEN MATCHED THEN UPDATE SET ");
    sb.append(update);
    sb.append(" WHEN NOT MATCHED THEN ");
    return sb.toString();
}

public static String[] getStrings(String merge) {
    merge = merge.replace("update", "");
    merge = merge.replace("(", "");
    merge = merge.replace(")", "");
    merge = merge.replace(" ", "");
    return merge.split(",");
}

2.3 CommonRdbmsWriter.Task修改

修改 startWriteWithConnection() 方法

/**
* 更改适配oracle update
* @author 程序员大佬超
* @date 20221202
* @param recordReceiver
* @param taskPluginCollector
* @param connection
*/
public void startWriteWithConnection(RecordReceiver recordReceiver, TaskPluginCollector taskPluginCollector, Connection connection)
{
    this.taskPluginCollector = taskPluginCollector;
    List<String> mergeColumns = new ArrayList<>();

    if (this.dataBaseType == DataBaseType.Oracle && !"insert".equalsIgnoreCase(this.writeMode)) {
        LOG.info("write oracle using {} mode", this.writeMode);
        List<String> columnsOne = new ArrayList<>();
        List<String> columnsTwo = new ArrayList<>();
        String merge = this.writeMode;
        String[] sArray = WriterUtil.getStrings(merge);
        for (String s : this.columns) {
            if (Arrays.asList(sArray).contains(s)) {
                columnsOne.add(s);
            }
        }
        for (String s : this.columns) {
            if (!Arrays.asList(sArray).contains(s)) {
                columnsTwo.add(s);
            }
        }
        int i = 0;
        for (String column : columnsOne) {
            mergeColumns.add(i++, column);
        }
        for (String column : columnsTwo) {
            mergeColumns.add(i++, column);
        }
    }
    mergeColumns.addAll(this.columns);

    // 用于写入数据的时候的类型根据目的表字段类型转换
    this.resultSetMetaData = DBUtil.getColumnMetaData(connection,
                                                      this.table, StringUtils.join(mergeColumns, ","));
    // 写数据库的SQL语句
    calcWriteRecordSql();

    List<Record> writeBuffer = new ArrayList<>(this.batchSize);
    int bufferBytes = 0;
    try {
        Record record;
        while ((record = recordReceiver.getFromReader()) != null) {
            if (record.getColumnNumber() != this.columnNumber) {
                // 源头读取字段列数与目的表字段写入列数不相等，直接报错
                throw DataXException
                    .asDataXException(
                    DBUtilErrorCode.CONF_ERROR,
                    String.format(
                        "列配置信息有错误. 因为您配置的任务中，源头读取字段数:%s 与 目的表要写入的字段数:%s 不相等. 请检查您的配置并作出修改.",
                        record.getColumnNumber(),
                        this.columnNumber));
            }

            writeBuffer.add(record);
            bufferBytes += record.getMemorySize();

            if (writeBuffer.size() >= batchSize || bufferBytes >= batchByteSize) {
                doBatchInsert(connection, writeBuffer);
                writeBuffer.clear();
                bufferBytes = 0;
            }
        }
        if (!writeBuffer.isEmpty()) {
            doBatchInsert(connection, writeBuffer);
            writeBuffer.clear();
        }
    }
    catch (Exception e) {
        throw DataXException.asDataXException(
            DBUtilErrorCode.WRITE_DATA_ERROR, e);
    }
    finally {
        writeBuffer.clear();
        DBUtil.closeDBResources(null, null, connection);
    }
}

修改 doBatchInsert() 方法

/**
* 更改适配oracle update
* @author 程序员大佬超
* @date 20221202
* @param connection
* @param buffer
* @throws SQLException
*/
protected void doBatchInsert(Connection connection, List<Record> buffer)
    throws SQLException
{
    PreparedStatement preparedStatement = null;
    try {
        connection.setAutoCommit(false);
        preparedStatement = connection
            .prepareStatement(this.writeRecordSql);
        if (this.dataBaseType == DataBaseType.Oracle && !"insert".equalsIgnoreCase(this.writeMode)) {
            String merge = this.writeMode;
            String[] sArray = WriterUtil.getStrings(merge);
            for (Record record : buffer) {
                List<Column> recordOne = new ArrayList<>();
                for (int j = 0; j < this.columns.size(); j++) {
                    if (Arrays.asList(sArray).contains(this.columns.get(j))) {
                        recordOne.add(record.getColumn(j));
                    }
                }
                for (int j = 0; j < this.columns.size(); j++) {
                    if (!Arrays.asList(sArray).contains(this.columns.get(j))) {
                        recordOne.add(record.getColumn(j));
                    }
                }
                for (int j = 0; j < this.columns.size(); j++) {
                    recordOne.add(record.getColumn(j));
                }
                for (int j = 0; j < recordOne.size(); j++) {
                    record.setColumn(j, recordOne.get(j));
                }
                preparedStatement = fillPreparedStatement(
                    preparedStatement, record);
                preparedStatement.addBatch();
            }
        }
        else {
            for (Record record : buffer) {
                preparedStatement = fillPreparedStatement(
                    preparedStatement, record);
                preparedStatement.addBatch();
            }
        }
        preparedStatement.executeBatch();
        connection.commit();
    }
    catch (SQLException e) {
        LOG.warn("回滚此次写入, 采用每次写入一行方式提交. 因为: {}", e.getMessage());
        connection.rollback();
        doOneInsert(connection, buffer);
    }
    catch (Exception e) {
        throw DataXException.asDataXException(
            DBUtilErrorCode.WRITE_DATA_ERROR, e);
    }
    finally {
        DBUtil.closeDBResources(preparedStatement, null);
    }
}

修改 fillPreparedStatement() 方法

/**
* 更改适配oracle update
* @author 程序员大佬超
* @date 20221202
* @param preparedStatement
* @param record
* @return
* @throws SQLException
*/
protected PreparedStatement fillPreparedStatement(PreparedStatement preparedStatement, Record record)
    throws SQLException
{
    for (int i = 0; i < record.getColumnNumber(); i++) {
        int columnSqltype = this.resultSetMetaData.getMiddle().get(i);
        preparedStatement = fillPreparedStatementColumnType(preparedStatement, i,
                                                            columnSqltype, record.getColumn(i));
    }
    return preparedStatement;
}

2.4 测试

重新打包后，测试job

{
  "job": {
    "setting": {
      "speed": {
        "channel": 3,
        "byte": 1048576
      },
      "errorLimit": {
        "record": 0,
        "percentage": 0.02
      }
    },
    "content": [
      {
        "reader": {
          "name": "mysqlreader",
          "parameter": {
            "username": "root",
            "password": "123456",
            "column": [
              "`id`",
              "`user_id`",
              "`user_password`",
              "`user_name`",
              "`user_phone`",
              "`email`",
              "`nick_name`",
              "`head_url`",
              "`sex`",
              "`state`",
              "`create_time`",
              "`create_user`",
              "`lastUpdateTime`"
            ],
            "splitPk": "",
            "connection": [
              {
                "table": [
                  "users"
                ],
                "jdbcUrl": [
                  "jdbc:mysql://127.0.0.1:3306/im"
                ]
              }
            ]
          }
        },
        "writer": {
          "name": "oraclewriter",
          "parameter": {
            "username": "yxc",
            "password": "123456",
            "column": [
              "\"ID\"",
              "\"USER_ID\"",
              "\"USER_PASSWORD\"",
              "\"USER_NAME\"",
              "\"USER_PHONE\"",
              "\"EMAIL\"",
              "\"NICK_NAME\"",
              "\"HEAD_URL\"",
              "\"SEX\"",
              "\"STATE\"",
              "\"CREATE_TIME\"",
              "\"CREATE_USER\"",
              "\"LASTUPDATETIME\""
            ],
            "writeMode": "update(\"ID\",\"USER_ID\")",
            "connection": [
              {
                "table": [
                  "USERS"
                ],
                "jdbcUrl": "jdbc:oracle:thin:@//192.168.157.142:1521/orcl"
              }
            ]
          }
        }
      }
    ]
  }
}

注：writeMode的update括号里字段要加上\"

查看运行日志，可以看到已经正确拼接了MERGE语句：
在这里插入图片描述

在这里插入图片描述

任务执行成功。切换 insert 和 update 模式检验，无异常。


更多技术干货，请持续关注程序员大佬超。
原创不易，转载请注明出处。

程序员大佬超
关注
专栏目录
DataX篇—Oracle支持Update模式
qq_33451695的博客
04-04 3351
参考资料：https://blog.csdn.net/qq_27915891/article/details/107746629 Oracle支持Update模式前言源码下载源码目录结构源码分析源码修改测试应用 前言 最近在做离线网络环境下数据同步，根据我们自己的业务改造阿里的开源框架DataX，发现其中遗留问题挺多的，其中就包括oracle的update模式它是不支持的，在我们beta1.0版本中，我们采用的是preSQL和postSQL来曲线Update数据的，这样虽然解决了问题，但是配置相对繁琐，由此
python增量更新数据_datax增量更新
weixin_39747755的博客
12-30 1411
前言：最近一直在做datax的增量更新，算是对datax有了一点新的认识吧。因为公司需要以greenplum为核心来搭建自己的数仓平台，以满足业务上的多维快速查询(以前多维查询用到是kylin，但随着数据量的增加，kylin越来越难以满足我们的需求了)。然而，greenplum的数据导入方面并不是很友好，通常，需要使用copy或者是gpfdist才能快速的往GP里面导入数据。我们试了kettle来...
DataX-Oracle新增writeMode支持update
小码蚁
03-28 2587
目前 DataX更新到datax_v202309版本还不能支持Oracle写入的update，只通过DataX只能修改源码。原理：oracle 不支持类似 MySQL的和，所以只支持 insert 配置项。要实现此功能，需要利用 Oracle 的 merge 语句，先来看下 merge 语法。
[转载]DataX迁移oracle数据到PostgreSQL
最新发布
SOFT2030的专栏
10-13 103
我们当前使用ogg软件来实现异构数据源同步的问题，从左图可见其链路及其复杂，这给后续运维工作带来了很多不可控因素，一旦数据库多起来，对维护人员来说不仅仅是工作量的增加，错综复杂的逻辑关系都是潜在的天坑。我们仔细观察，可以发现每个TaskGroup开启了channel数量不太一样，有的开启了5个，有的开启了4个，但是他们的任务都是23个。Framework：Framework用于连接reader和writer，作为两者的数据传输通道，并处理缓冲，流控，并发，数据转换等核心技术问题。表上没有主键，也没有索引。
DataX oracle同步mysql(全量和增量)
热门推荐
zhuyu19911016520
04-13 1万+
datax sync oracle to mysql
DataX 二次开发支持 Oracle 更新
didididipi123123的博客
03-23 201
https://blog.csdn.net/xch_yang/article/details/128250190?spm=1001.2101.3001.6650.2&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-2-128250190-blog-115425549.235%5Ev26%5Epc_relevant_3mothn_strategy_and_data_recovery&depth_1-ut
Datax 同步数据到Postgres 增量更新
guojiuguo的博客
05-19 1815
Datax-同步数据到Postgresql中，增量更新解决
大数据bug-datax（一：主键update）
weixin_43446246的博客
03-24 8792
一：datax的writeMode参数。 insert 这个参数可以设置为insert，这样子就是对于同步的主键进行设置。主要主键存在，那么在更新的时候，就不会将结果表中的数据进行修改。只会增加新的数据。 update 在同步到时候，设置主键，那么会查看表中主键内容的数据，如果有变动，就会直接进行替换。 ...
datax到hive数据全部为空_datax二次开发
weixin_39670267的博客
12-20 803
一、datax插件hbase12xwriter开发查看datax源码，发现有hbase094xwriter和hbase11xwriter源码，说明datax支持hbase写入，再查看测试和生产环境使用的hbase版本是：hbase-1.2.0-cdh5.8.4自己写一个hbase12xwriter插件包开发流程：1、搭建项目模块moduledatax-all项目上右击->New->ot...
cloudin-datax是基于DataX开发的分布式数据同步工具，提供简单易用的操作界面，可视化定时任务配置监控和增量同步功能
06-03
开发者可以通过源代码了解其内部实现机制，进行二次开发或定制化需求。 **5. 应用场景** Cloudin-DataX适用于各种数据集成需求，如： - 数据仓库建设：将分散在不同系统的数据整合到统一的数据仓库中。 - 数据分析...
DataX
05-10
DataX DataX 是阿里巴巴集团内被广泛使用的离线数据同步工具/平台，实现包括 MySQL、Oracle、SqlServer、Postgre、HDFS、Hive、ADS、HBase、TableStore(OTS)、MaxCompute(ODPS)、DRDS 等各种异构数据源之间高效的数据同步功能。 DataX 商业版本 阿里云DataWorks数据集成是DataX团队在阿里云上的商业化产品，致力于提供复杂网络环境下、丰富的异构数据源之间高速稳定的数据移动能力，以及繁杂业务背景下的数据同步解决方案。目前已经支持云上近3000家客户，单日同步数据超过3万亿条。DataWorks数据集成目前支持离线50+种数据源，可以进行整库迁移、批量上云、增量同步、分库分表等各类同步解决方案。2020年更新实时同步能力，2020年更新实时同步能力，支持10+种数据源的读写任意组合。提供MySQL，Ora
DataX数据交换软件
01-29
win版本的数据交换工具，暂时支持oracle、mysql两种数据源，后续会扩展，增加sqlite、sqlserver等数据源。使用过程中有任何问题请反馈给670590744@qq.com。
数据同步工具datax
10-11
linux datax 同步工具离线数据同步工具，实现包括 MySQL、Oracle、SqlServer、Postgre、HDFS、Hive、ADS、HBase、TableStore(OTS)、MaxCompute(ODPS)、DRDS 等各种异构数据源之间高效的数据同步功能。Github地址：https://github.com/alibaba/DataX
datax数据迁移插件-db2writer
01-16
DataX作为一款跨平台的数据同步工具，支持多种数据源之间的数据迁移，包括关系型数据库、非关系型数据库、文件系统等。其设计理念是“一切皆为数据源”，因此能够灵活适应各种复杂的数据环境。DataX采用插件化架构，...
数据同步工具datax-web可视化工具
05-09
- DataX-Web作为开源项目，其源码可供开发者研究和定制，可以根据组织需求进行二次开发和扩展。 7. **版本信息** - 压缩包中的"datax-web-2.1.2"表示这是DataX-Web的2.1.2版本，可能包含该版本的修复、优化和新...
DataX安装部署-Reader插件二次开发
sinat_32651363的博客
11-14 7033
  DataX DataX 是阿里巴巴集团内被广泛使用的离线数据同步工具/平台，实现包括 MySQL、Oracle、SqlServer、Postgre、HDFS、Hive、ADS、HBase、TableStore(OTS)、MaxCompute(ODPS)、DRDS 等各种异构数据源之间高效的数据同步功能。 DataX详细介绍 请参考：DataX-Introduction DataX是什...
基于DataX完成数据导入-新增及更新导入,全量同步
t_813的博客
02-01 990
以shop_order(商城订单表)
Datax oracle 支持增量并且支持全量更新
weixin_41250031的博客
01-21 3060
Datax oracle 支持增量并且支持全量更新
datax二次开发Elasticsearch读插件
08-02
DataX是一个用于数据同步的开源工具，它提供了丰富的插件来支持不同的数据源和目标。根据引用[2]，DataX插件的开发模式是基于Record的抽象，各个插件只需要按照规范进行开发即可。引用[3]中提到，DataX的打包成功后的包结构中包含了插件目录。 对于Elasticsearch读插件的二次开发，你可以参考DataX的插件开发规范和文档。首先，你需要了解Elasticsearch的数据结构和API，以便在插件中进行数据读取操作。然后，你可以在DataX的插件目录中创建一个新的插件目录，并按照规范进行插件的开发。在插件的配置文件中，你需要指定Elasticsearch的连接信息和查询条件等参数。 在插件的开发过程中，你可以使用DataX提供的各种工具和接口来简化开发和测试。例如，你可以使用DataX的RecordReader接口来读取Elasticsearch中的数据，并将其转换为DataX的Record对象。你还可以使用DataX的各种工具类来处理数据转换和批量写入等操作。 最后，你可以使用DataX的命令行工具来运行你开发的插件，并通过配置文件指定插件的参数和数据源信息。例如，你可以使用类似于引用[1]的命令来运行你的Elasticsearch读插件，并指定数据源的路径和插件的配置文件。 总结起来，要进行DataX的Elasticsearch读插件的二次开发，你需要了解Elasticsearch的数据结构和API，按照DataX的插件开发规范进行插件的开发，使用DataX的工具和接口简化开发和测试，最后使用DataX的命令行工具来运行你开发的插件。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员大佬超

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值