若依以及flowbale达梦国产化数据库改造_全网最细

Springboot与flowable—达梦国产化改造

首先说明本实例包含了

1、达梦数据库迁移

2、SpringBoot与flowable工作流（flowable版本是6.7.0）替换达梦数据库

3、xml中的sql替换

这篇文章应该是全网最细的应该没错吧，收藏吧~

后面的东方通TongWeb的改造以及部署会写在我的另一篇文章。

1、相关软件下载

访问达梦官网：

达梦官网

1.1 下载可视化工具

首先注册一个账号

下载勾选指定版本的数据库管理工具 x86 、win64

解压压缩包

双击.iso文件，setup.exe傻瓜式安装。

注意：点击初始化

创建数据库实例

一直下一步，完成。

安装完会有这些软件，如下：一般用到的是数据库管理工具和迁移工具

ps: 数据库管理工具中管理员的用户名和密码都是 SYSDBA

注意达梦数据库名就对应创建的用户名 ，模式就对应数据库也即用户对象，但是一个用户也有可能会创建多个模式，这样就有可能需要在Springboot项目的配置文件里指定默认的模式（数据库）。

2 、源代码运行

先拿到要改造的项目的初始代码，运行起来，保证没改造之前是可行的。

2.1 导入sql

省略

2.2 打开项目，导入pom依赖

如果install有如下问题：

这个问题一般就是test下的测试类有问题，造成编译时失败，比如在控制台执行命令 mvn test

报错如下：

**解决办法：**编译install的时候先跳过test的执行，需要在pom.xml的里添加以下配置，使得测试出错不影响项目的编译。

pom中加入如下依赖

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
                <testFailureIgnore>true</testFailureIgnore>
            </configuration>
        </plugin>
    </plugins>
</build>
1
2
3
4
5
6
7
8
9
10
11

加完之后 clean install 然后重新编译 点击这个 m 图标 输入 mvn idea:idea

2.3 修改配置

2.3.1 修改数据库配置

2.3.2 修改redis配置

2.3.3 运行后端

直接运行

2.3.4 运行前端

首先打开前端控制台,下载依赖

npm install 
1

然后修改 vue.config.js配置文件中的代理配置（这里的代理地址就是访问后端接口的地址），连上后端

然后保存ctrl+s，一定要记得保存配置才生效

npm run dev
1

3、数据库迁移

把本地的mysql数据库迁移到达梦数据库。（首先这里迁移为了不影响之前的项目代码，我选择把源代码备份了一份，并新建备份了一个mysql数据库，修改了yml中的配置连接，下面会详细介绍）

迁移我选择了用上面安装的达梦数据库迁移工具

3.1 新建达梦数据库（用户）

上面提到过，达梦的数据库就对应用户对象，所以现在新建用户（数据库）

这里用户名就是数据库名，只能为大写，密码就是和mysql差不多的用户密码

3.1.1 用户授权

系统授权

点击确定，这里会提示失败，不用管，关闭后刷新用户，已经新建成功。

此时，用户和数据库已经建好了。模式就对应数据库。里面有对应的数据库表。

3.2 使用数据库迁移工具

SYSDBA密码默认就是SYSDBA

3.2.1 新建工程

3.2.2 新建迁移

点击下一步

选择mysql到dm,下一步.

连接源mysql数据库，首先指定驱动

本地先下载mysql驱动

mysql驱动

链接：https://pan.baidu.com/s/1nRELoWeRzcklpEtK8MNtYA
提取码：1111

填写完下一步

同理，指定达梦驱动，与数据库

达梦驱动链接：https://pan.baidu.com/s/1CDg2nMwY0s94Lp3gQ3j2cQ
提取码：1111

下一步

去掉使用默认数据类型映射关系的勾，然后点击右边配置类型映射关系按钮
点击右下角添加，原数据类型名VARCHAR，目的数据类型名VARCHAR，目的精度扩大倍数填入4，确定

选择需要迁移到的达梦数据库（模式），下一步

选择勾选指定的表，下一步

点击完成

这里有一个报错信息，记录超长

解决方案：先在达梦下执行设置表为记录超长脚本,删除数据再重新迁此表数据(在达梦数据库管理工具修改表)。

# 选择模式
set schema TRADING_CENTER_DM;
alter table SYS_OPER_LOG enable using long row;
truncate table SYS_OPER_LOG;
select * from SYS_OPER_LOG;
1
2
3
4
5

回到迁移工具，上一步，选择模式，选择表重新迁移这张失败的表即可。

这里数据库就迁移完了。

4、springboot替换为达梦数据库

4.1 安装达梦驱动jar包

jar包地址在上面迁移的时候有发过

把jar包安装到maven仓库

mvn install:install-file -Dfile=E:\Dameng\DmJdbcDriver18.jar -DgroupId=com.dm -DartifactId=DmJdbcDriver18 -Dversion=1.8 -Dpackaging=jar
1

4.2 POM添加达梦的驱动依赖

在admin模块添加达梦的驱动依赖

	<!-- DM8 jdbc -->
    <dependency>
        <groupId>com.dm</groupId>
        <artifactId>DmJdbcDriver18</artifactId>
        <version>1.8</version>
    </dependency>
1
2
3
4
5
6

此时重启项目会遇到编译报错，在没加pom依赖之前是可以启动的，加了之后启动编译build构建就会报错。所以先修改连接驱动yml配置。

4.3 修改yml的达梦连接驱动

# 数据源配置
spring:
    datasource:
        type: com.alibaba.druid.pool.DruidDataSource
#        driverClassName: com.mysql.cj.jdbc.Driver
        driverClassName: dm.jdbc.driver.DmDriver
        druid:
            # 主库数据源
#            master:
#                url: jdbc:mysql://121.43.234.114:3306/trading_center?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
#                username: root
#                password: gds12345678
             #主库数据源（本地mysql数据库）
#            master:
#                url: jdbc:mysql://localhost:3306/trading_center_dm?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
#                username: root
#                password: 123
            # 主库数据源（本地达梦数据库）
            master:
                url: jdbc:dm://127.0.0.1:5236?TRADING_CENTER_DM&zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8
                username: SYSDBA
                password: SYSDBA
            # 从库数据源
            slave:
                # 从数据源开关/默认关闭
                enabled: false
                url:
                username:
                password:
            # 初始连接数
            initialSize: 5
            # 最小连接池数量
            minIdle: 10
            # 最大连接池数量
            maxActive: 20
            # 配置获取连接等待超时的时间
            maxWait: 60000
            # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
            timeBetweenEvictionRunsMillis: 60000
            # 配置一个连接在池中最小生存的时间，单位是毫秒
            minEvictableIdleTimeMillis: 300000
            # 配置一个连接在池中最大生存的时间，单位是毫秒
            maxEvictableIdleTimeMillis: 900000
            # 配置检测连接是否有效
            validationQuery: SELECT 1 FROM DUAL
            testWhileIdle: true
            testOnBorrow: false
            testOnReturn: false
            webStatFilter:
                enabled: true
            statViewServlet:
                enabled: true
                # 设置白名单，不填则允许所有访问
                allow:
                url-pattern: /druid/*
                # 控制台管理用户名和密码
                login-username: ruoyi
                login-password: 123456
            filter:
                stat:
                    enabled: true
                    # 慢SQL记录
                    log-slow-sql: true
                    slow-sql-millis: 1000
                    merge-sql: true
                wall:
                    config:
                        multi-statement-allow: true

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

参考上面的修改，记得达梦数据库名就是用户名。

注意url中数据库的格式 为 ？数据库名 和mysql的不一样，不然的话就会url有下面这种网络通信异常。

报错信息：

16:46:16.112 [restartedMain] ERROR c.a.d.p.DruidDataSource - [init,931] - init datasource error, url: jdbc:dm://127.0.0.1:5236/TRADING_CENTER_DM?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8
dm.jdbc.driver.DMException: 网络通信异常
	at dm.jdbc.driver.DBError.throwException(DBError.java:774)
	at dm.jdbc.a.a.init(DBAccess.java:185)
	at dm.jdbc.a.a.<init>(DBAccess.java:157)
	at dm.jdbc.driver.DmdbConnection.openConnection(DmdbConnection.java:638)
	at dm.jdbc.desc.EP.connect(EP.java:159)
	at dm.jdbc.desc.EPGroup$EPSelector.select(EPGroup.java:395)
	at dm.jdbc.desc.EPGroup.connect(EPGroup.java:278)
	at dm.jdbc.driver.DmDriver.do_connect(DmDriver.java:163)
	at dm.jdbc.driver.DmDriver.connect(DmDriver.java:449)
	at com.alibaba.druid.filter.FilterChainImpl.connection_connect(FilterChainImpl.java:156)
	at com.alibaba.druid.filter.stat.StatFilter.connection_connect(StatFilter.java:251)
	at com.alibaba.druid.filter.FilterChainImpl.connection_connect(FilterChainImpl.java:150)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

然后由于本项目使用了flowable，启动后会出现工作流找不到驱动类型的报错如下，、

Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'processEngine': FactoryBean threw exception on object creation; nested exception is org.flowable.common.engine.api.FlowableException: couldn't deduct database type from database product name 'DM DBMS'
1

所以还得修改flowable整合达梦的问题。

5、flowable工作流整合达梦数据库

pom依赖和修改达梦驱动参考上面的介绍。下面主要是介绍flowable整合达梦。（flowable的版本是6.7.0）

自动加载数据源时，flowable无法识别DM数据库类型，采用覆盖源码，(就是在java包路径下创建与源码类相同的的路径，把源代码全部复制到这个类里面，然后在修改达梦的代码)。设置成MySQL或者Oracle的数据库类型，需要修改文件：

5.1 修改 AbstractEngineConfiguration 文件

在项目中创建org.flowable.common.engine.impl.AbstractEngineConfiguration文件（这边路径必须一致，打包时会覆盖源文件），修改其中getDefaultDatabaseTypeMappings方法，将达梦数据库标识为mysql（value值设置为其他值会报错空指针。所以通用mysql），复制完源码后修改源码里面的这个方法，如下

public static final String DATABASE_TYPE_DM = "mysql"; //达梦 value值设置为其他值会报错空指针。所以通用mysql

public static Properties getDefaultDatabaseTypeMappings() {
        Properties databaseTypeMappings = new Properties();
        databaseTypeMappings.setProperty("H2", DATABASE_TYPE_H2);
        databaseTypeMappings.setProperty("HSQL Database Engine", DATABASE_TYPE_HSQL);
        databaseTypeMappings.setProperty("MySQL", DATABASE_TYPE_MYSQL);
        databaseTypeMappings.setProperty("MariaDB", DATABASE_TYPE_MYSQL);
        databaseTypeMappings.setProperty("Oracle", DATABASE_TYPE_ORACLE);
        databaseTypeMappings.setProperty(PRODUCT_NAME_POSTGRES, DATABASE_TYPE_POSTGRES);
        databaseTypeMappings.setProperty("Microsoft SQL Server", DATABASE_TYPE_MSSQL);
        databaseTypeMappings.setProperty(DATABASE_TYPE_DB2, DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/NT", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/NT64", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2 UDP", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/LINUX", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/LINUX390", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/LINUXX8664", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/LINUXZ64", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/LINUXPPC64", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/LINUXPPC64LE", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/400 SQL", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/6000", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2 UDB iSeries", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/AIX64", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/HPUX", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/HP64", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/SUN", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/SUN64", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/PTX", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2/2", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty("DB2 UDB AS400", DATABASE_TYPE_DB2);
        databaseTypeMappings.setProperty(PRODUCT_NAME_CRDB, DATABASE_TYPE_COCKROACHDB);
        databaseTypeMappings.setProperty("DM DBMS", DATABASE_TYPE_DM);// 加入达梦支持
        return databaseTypeMappings;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

5.2 修改liquibase-core-4.3.5.jar中源码

在java文件夹下创建DmDatabase类，全路径为liquibase.database.core.DmDatabase，参考了liquibase.database.core.OracleDatabase类，将下面代码直接粘进新创建的类。

在这个类中由作者介绍更改如下：

删除setConnection方法；
修改PRODUCT_NAME常量值为“DM DBMS”；
修改getDefaultPort方法，返回5236；
修改getShortName方法，返回dm；
修改getDefaultDriver方法，返回达梦的Driver；

下面这个代码可以直接复制我的，上面那个代码注意需要自己修改

package liquibase.database.core;

import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import liquibase.CatalogAndSchema;
import liquibase.Scope;
import liquibase.database.AbstractJdbcDatabase;
import liquibase.database.DatabaseConnection;
import liquibase.database.OfflineConnection;
import liquibase.database.jvm.JdbcConnection;
import liquibase.exception.DatabaseException;
import liquibase.exception.UnexpectedLiquibaseException;
import liquibase.exception.ValidationErrors;
import liquibase.executor.ExecutorService;
import liquibase.statement.DatabaseFunction;
import liquibase.statement.SequenceCurrentValueFunction;
import liquibase.statement.SequenceNextValueFunction;
import liquibase.statement.core.RawCallStatement;
import liquibase.statement.core.RawSqlStatement;
import liquibase.structure.DatabaseObject;
import liquibase.structure.core.Catalog;
import liquibase.structure.core.Index;
import liquibase.structure.core.PrimaryKey;
import liquibase.structure.core.Schema;
import liquibase.util.JdbcUtils;
import liquibase.util.StringUtil;

public class DmDatabase extends AbstractJdbcDatabase {
    private static final String PRODUCT_NAME = "DM DBMS";

    @Override
    protected String getDefaultDatabaseProductName() {
        return PRODUCT_NAME;
    }

    /**
     * Is this AbstractDatabase subclass the correct one to use for the given connection.
     *
     * @param conn
     */
    @Override
    public boolean isCorrectDatabaseImplementation(DatabaseConnection conn) throws DatabaseException {
        return PRODUCT_NAME.equalsIgnoreCase(conn.getDatabaseProductName());
    }

    /**
     * If this database understands the given url, return the default driver class name.  Otherwise return null.
     *
     * @param url
     */
    @Override
    public String getDefaultDriver(String url) {
        if (url.startsWith("jdbc:dm")) {
            return "dm.jdbc.driver.DmDriver";
        }

        return null;
    }

    /**
     * Returns an all-lower-case short name of the product.  Used for end-user selecting of database type
     * such as the DBMS precondition.
     */
    @Override
    public String getShortName() {
        return "dm";
    }

    @Override
    public Integer getDefaultPort() {
        return 5236;
    }

    /**
     * Returns whether this database support initially deferrable columns.
     */
    @Override
    public boolean supportsInitiallyDeferrableColumns() {
        return true;
    }

    @Override
    public boolean supportsTablespaces() {
        return true;
    }

    @Override
    public int getPriority() {
        return PRIORITY_DEFAULT;
    }

    private static final Pattern PROXY_USER = Pattern.compile(".*(?:thin|oci)\\:(.+)/@.*");

    protected final int SHORT_IDENTIFIERS_LENGTH = 30;
    protected final int LONG_IDENTIFIERS_LEGNTH = 128;
    public static final int ORACLE_12C_MAJOR_VERSION = 12;

    private Set<String> reservedWords = new HashSet<>();
    private Set<String> userDefinedTypes;
    private Map<String, String> savedSessionNlsSettings;

    private Boolean canAccessDbaRecycleBin;
    private Integer databaseMajorVersion;
    private Integer databaseMinorVersion;

    /**
     * Default constructor for an object that represents the Oracle Database DBMS.
     */
    public DmDatabase() {
        super.unquotedObjectsAreUppercased = true;
        //noinspection HardCodedStringLiteral
        super.setCurrentDateTimeFunction("SYSTIMESTAMP");
        // Setting list of Oracle's native functions
        //noinspection HardCodedStringLiteral
        dateFunctions.add(new DatabaseFunction("SYSDATE"));
        //noinspection HardCodedStringLiteral
        dateFunctions.add(new DatabaseFunction("SYSTIMESTAMP"));
        //noinspection HardCodedStringLiteral
        dateFunctions.add(new DatabaseFunction("CURRENT_TIMESTAMP"));
        //noinspection HardCodedStringLiteral
        super.sequenceNextValueFunction = "%s.nextval";
        //noinspection HardCodedStringLiteral
        super.sequenceCurrentValueFunction = "%s.currval";
    }

    private void tryProxySession(final String url, final Connection con) {
        Matcher m = PROXY_USER.matcher(url);
        if (m.matches()) {
            Properties props = new Properties();
            props.put("PROXY_USER_NAME", m.group(1));
            try {
                Method method = con.getClass().getMethod("openProxySession", int.class, Properties.class);
                method.setAccessible(true);
                method.invoke(con, 1, props);
            } catch (Exception e) {
                Scope.getCurrentScope().getLog(getClass()).info("Could not open proxy session on OracleDatabase: " + e.getCause().getMessage());
            }
        }
    }

    @Override
    public int getDatabaseMajorVersion() throws DatabaseException {
        if (databaseMajorVersion == null) {
            return super.getDatabaseMajorVersion();
        } else {
            return databaseMajorVersion;
        }
    }

    @Override
    public int getDatabaseMinorVersion() throws DatabaseException {
        if (databaseMinorVersion == null) {
            return super.getDatabaseMinorVersion();
        } else {
            return databaseMinorVersion;
        }
    }

    @Override
    public String getJdbcCatalogName(CatalogAndSchema schema) {
        return null;
    }

    @Override
    public String getJdbcSchemaName(CatalogAndSchema schema) {
        return correctObjectName((schema.getCatalogName() == null) ? schema.getSchemaName() : schema.getCatalogName(), Schema.class);
    }

    @Override
    protected String getAutoIncrementClause(final String generationType, final Boolean defaultOnNull) {
        if (StringUtil.isEmpty(generationType)) {
            return super.getAutoIncrementClause();
        }

        String autoIncrementClause = "GENERATED %s AS IDENTITY"; // %s -- [ ALWAYS | BY DEFAULT [ ON NULL ] ]
        String generationStrategy = generationType;
        if (Boolean.TRUE.equals(defaultOnNull) && generationType.toUpperCase().equals("BY DEFAULT")) {
            generationStrategy += " ON NULL";
        }
        return String.format(autoIncrementClause, generationStrategy);
    }

    @Override
    public String generatePrimaryKeyName(String tableName) {
        if (tableName.length() > 27) {
            //noinspection HardCodedStringLiteral
            return "PK_" + tableName.toUpperCase(Locale.US).substring(0, 27);
        } else {
            //noinspection HardCodedStringLiteral
            return "PK_" + tableName.toUpperCase(Locale.US);
        }
    }

    @Override
    public boolean isReservedWord(String objectName) {
        return reservedWords.contains(objectName.toUpperCase());
    }

    @Override
    public boolean supportsSequences() {
        return true;
    }

    /**
     * Oracle supports catalogs in liquibase terms
     *
     * @return false
     */
    @Override
    public boolean supportsSchemas() {
        return false;
    }

    @Override
    protected String getConnectionCatalogName() throws DatabaseException {
        if (getConnection() instanceof OfflineConnection) {
            return getConnection().getCatalog();
        }
        try {
            //noinspection HardCodedStringLiteral
            return Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", this).queryForObject(new RawCallStatement("select sys_context( 'userenv', 'current_schema' ) from dual"), String.class);
        } catch (Exception e) {
            //noinspection HardCodedStringLiteral
            Scope.getCurrentScope().getLog(getClass()).info("Error getting default schema", e);
        }
        return null;
    }

    @Override
    public String getDefaultCatalogName() {//NOPMD
        return (super.getDefaultCatalogName() == null) ? null : super.getDefaultCatalogName().toUpperCase(Locale.US);
    }

    /**
     * 
Returns an Oracle date literal with the same value as a string formatted using ISO 8601.
     *
     * 
Convert an ISO8601 date string to one of the following results:
     * to_date('1995-05-23', 'YYYY-MM-DD')
     * to_date('1995-05-23 09:23:59', 'YYYY-MM-DD HH24:MI:SS')
     * 

     * Implementation restriction:

     * Currently, only the following subsets of ISO8601 are supported:

     * 

     * 
YYYY-MM-DD
     * 
YYYY-MM-DDThh:mm:ss
     * 
     */
    @Override
    public String getDateLiteral(String isoDate) {
        String normalLiteral = super.getDateLiteral(isoDate);

        if (isDateOnly(isoDate)) {
            return "TO_DATE(" + normalLiteral + ", 'YYYY-MM-DD')";
        } else if (isTimeOnly(isoDate)) {
            return "TO_DATE(" + normalLiteral + ", 'HH24:MI:SS')";
        } else if (isTimestamp(isoDate)) {
            return "TO_TIMESTAMP(" + normalLiteral + ", 'YYYY-MM-DD HH24:MI:SS.FF')";
        } else if (isDateTime(isoDate)) {
            int seppos = normalLiteral.lastIndexOf('.');
            if (seppos != -1) {
                normalLiteral = normalLiteral.substring(0, seppos) + "'";
            }
            return "TO_DATE(" + normalLiteral + ", 'YYYY-MM-DD HH24:MI:SS')";
        }
        return "UNSUPPORTED:" + isoDate;
    }

    @Override
    public boolean isSystemObject(DatabaseObject example) {
        if (example == null) {
            return false;
        }

        if (this.isLiquibaseObject(example)) {
            return false;
        }

        if (example instanceof Schema) {
            //noinspection HardCodedStringLiteral,HardCodedStringLiteral,HardCodedStringLiteral,HardCodedStringLiteral
            if ("SYSTEM".equals(example.getName()) || "SYS".equals(example.getName()) || "CTXSYS".equals(example.getName()) || "XDB".equals(example.getName())) {
                return true;
            }
            //noinspection HardCodedStringLiteral,HardCodedStringLiteral,HardCodedStringLiteral,HardCodedStringLiteral
            if ("SYSTEM".equals(example.getSchema().getCatalogName()) || "SYS".equals(example.getSchema().getCatalogName()) || "CTXSYS".equals(example.getSchema().getCatalogName()) || "XDB".equals(example.getSchema().getCatalogName())) {
                return true;
            }
        } else if (isSystemObject(example.getSchema())) {
            return true;
        }
        if (example instanceof Catalog) {
            //noinspection HardCodedStringLiteral,HardCodedStringLiteral,HardCodedStringLiteral,HardCodedStringLiteral
            if (("SYSTEM".equals(example.getName()) || "SYS".equals(example.getName()) || "CTXSYS".equals(example.getName()) || "XDB".equals(example.getName()))) {
                return true;
            }
        } else if (example.getName() != null) {
            //noinspection HardCodedStringLiteral
            if (example.getName().startsWith("BIN$")) { //oracle deleted table
                boolean filteredInOriginalQuery = this.canAccessDbaRecycleBin();
                if (!filteredInOriginalQuery) {
                    filteredInOriginalQuery = StringUtil.trimToEmpty(example.getSchema().getName()).equalsIgnoreCase(this.getConnection().getConnectionUserName());
                }

                if (filteredInOriginalQuery) {
                    return !((example instanceof PrimaryKey) || (example instanceof Index) || (example instanceof
                            liquibase.statement.UniqueConstraint));
                } else {
                    return true;
                }
            } else //noinspection HardCodedStringLiteral
                if (example.getName().startsWith("AQ$")) { //oracle AQ tables
                    return true;
                } else //noinspection HardCodedStringLiteral
                    if (example.getName().startsWith("DR$")) { //oracle index tables
                        return true;
                    } else //noinspection HardCodedStringLiteral
                        if (example.getName().startsWith("SYS_IOT_OVER")) { //oracle system table
                            return true;
                        } else //noinspection HardCodedStringLiteral,HardCodedStringLiteral
                            if ((example.getName().startsWith("MDRT_") || example.getName().startsWith("MDRS_")) && example.getName().endsWith("$")) {
                                // CORE-1768 - Oracle creates these for spatial indices and will remove them when the index is removed.
                                return true;
                            } else //noinspection HardCodedStringLiteral
                                if (example.getName().startsWith("MLOG$_")) { //Created by materliaized view logs for every table that is part of a materialized view. Not available for DDL operations.
                                    return true;
                                } else //noinspection HardCodedStringLiteral
                                    if (example.getName().startsWith("RUPD$_")) { //Created by materialized view log tables using primary keys. Not available for DDL operations.
                                        return true;
                                    } else //noinspection HardCodedStringLiteral
                                        if (example.getName().startsWith("WM$_")) { //Workspace Manager backup tables.
                                            return true;
                                        } else //noinspection HardCodedStringLiteral
                                            if ("CREATE$JAVA$LOB$TABLE".equals(example.getName())) { //This table contains the name of the Java object, the date it was loaded, and has a BLOB column to store the Java object.
                                                return true;
                                            } else //noinspection HardCodedStringLiteral
                                                if ("JAVA$CLASS$MD5$TABLE".equals(example.getName())) { //This is a hash table that tracks the loading of Java objects into a schema.
                                                    return true;
                                                } else //noinspection HardCodedStringLiteral
                                                    if (example.getName().startsWith("ISEQ$$_")) { //System-generated sequence
                                                        return true;
                                                    } else //noinspection HardCodedStringLiteral
                                                        if (example.getName().startsWith("USLOG$")) { //for update materialized view
                                                            return true;
                                                        } else if (example.getName().startsWith("SYS_FBA")) { //for Flashback tables
                                                            return true;
                                                        }
        }

        return super.isSystemObject(example);
    }

    @Override
    public boolean supportsAutoIncrement() {
        // Oracle supports Identity beginning with version 12c
        boolean isAutoIncrementSupported = false;

        try {
            if (getDatabaseMajorVersion() >= 12) {
                isAutoIncrementSupported = true;
            }

            // Returning true will generate create table command with 'IDENTITY' clause, example:
            // CREATE TABLE AutoIncTest (IDPrimaryKey NUMBER(19) GENERATED BY DEFAULT AS IDENTITY NOT NULL, TypeID NUMBER(3) NOT NULL, Description NVARCHAR2(50), CONSTRAINT PK_AutoIncTest PRIMARY KEY (IDPrimaryKey));

            // While returning false will continue to generate create table command without 'IDENTITY' clause, example:
            // CREATE TABLE AutoIncTest (IDPrimaryKey NUMBER(19) NOT NULL, TypeID NUMBER(3) NOT NULL, Description NVARCHAR2(50), CONSTRAINT PK_AutoIncTest PRIMARY KEY (IDPrimaryKey));

        } catch (DatabaseException ex) {
            isAutoIncrementSupported = false;
        }

        return isAutoIncrementSupported;
    }


//    public Set findUniqueConstraints(String schema) throws DatabaseException {
//        Set returnSet = new HashSet();
//
//        List
//
//        UniqueConstraint constraint = null;
//        for (Map map : maps) {
//            if (constraint == null || !constraint.getName().equals(constraint.getName())) {
//                returnSet.add(constraint);
//                Table table = new Table((String) map.get("TABLE_NAME"));
//                constraint = new UniqueConstraint(map.get("CONSTRAINT_NAME").toString(), table);
//            }
//        }
//        if (constraint != null) {
//            returnSet.add(constraint);
//        }
//
//        return returnSet;
//    }

    @Override
    public boolean supportsRestrictForeignKeys() {
        return false;
    }

    @Override
    public int getDataTypeMaxParameters(String dataTypeName) {
        //noinspection HardCodedStringLiteral
        if ("BINARY_FLOAT".equals(dataTypeName.toUpperCase())) {
            return 0;
        }
        //noinspection HardCodedStringLiteral
        if ("BINARY_DOUBLE".equals(dataTypeName.toUpperCase())) {
            return 0;
        }
        return super.getDataTypeMaxParameters(dataTypeName);
    }

    public String getSystemTableWhereClause(String tableNameColumn) {
        List<String> clauses = new ArrayList<String>(Arrays.asList("BIN$",
                "AQ$",
                "DR$",
                "SYS_IOT_OVER",
                "MLOG$_",
                "RUPD$_",
                "WM$_",
                "ISEQ$$_",
                "USLOG$",
                "SYS_FBA"));

        for (int i = 0; i < clauses.size(); i++) {
            clauses.set(i, tableNameColumn + " NOT LIKE '" + clauses.get(i) + "%'");
        }
        return "(" + StringUtil.join(clauses, " AND ") + ")";
    }

    @Override
    public boolean jdbcCallsCatalogsSchemas() {
        return true;
    }

    public Set<String> getUserDefinedTypes() {
        if (userDefinedTypes == null) {
            userDefinedTypes = new HashSet<>();
            if ((getConnection() != null) && !(getConnection() instanceof OfflineConnection)) {
                try {
                    try {
                        //noinspection HardCodedStringLiteral
                        userDefinedTypes.addAll(Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", this).queryForList(new RawSqlStatement("SELECT DISTINCT TYPE_NAME FROM ALL_TYPES"), String.class));
                    } catch (DatabaseException e) { //fall back to USER_TYPES if the user cannot see ALL_TYPES
                        //noinspection HardCodedStringLiteral
                        userDefinedTypes.addAll(Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", this).queryForList(new RawSqlStatement("SELECT TYPE_NAME FROM USER_TYPES"), String.class));
                    }
                } catch (DatabaseException e) {
                    //ignore error
                }
            }
        }

        return userDefinedTypes;
    }

    @Override
    public String generateDatabaseFunctionValue(DatabaseFunction databaseFunction) {
        //noinspection HardCodedStringLiteral
        if ((databaseFunction != null) && "current_timestamp".equalsIgnoreCase(databaseFunction.toString())) {
            return databaseFunction.toString();
        }
        if ((databaseFunction instanceof SequenceNextValueFunction) || (databaseFunction instanceof
                SequenceCurrentValueFunction)) {
            String quotedSeq = super.generateDatabaseFunctionValue(databaseFunction);
            // replace "myschema.my_seq".nextval with "myschema"."my_seq".nextval
            return quotedSeq.replaceFirst("\"([^\\.\"]+)\\.([^\\.\"]+)\"", "\"$1\".\"$2\"");

        }

        return super.generateDatabaseFunctionValue(databaseFunction);
    }

    @Override
    public ValidationErrors validate() {
        ValidationErrors errors = super.validate();
        DatabaseConnection connection = getConnection();
        if ((connection == null) || (connection instanceof OfflineConnection)) {
            //noinspection HardCodedStringLiteral
            Scope.getCurrentScope().getLog(getClass()).info("Cannot validate offline database");
            return errors;
        }

        if (!canAccessDbaRecycleBin()) {
            errors.addWarning(getDbaRecycleBinWarning());
        }

        return errors;

    }

    public String getDbaRecycleBinWarning() {
        //noinspection HardCodedStringLiteral,HardCodedStringLiteral,HardCodedStringLiteral,HardCodedStringLiteral,
        // HardCodedStringLiteral
        //noinspection HardCodedStringLiteral,HardCodedStringLiteral,HardCodedStringLiteral
        return "Liquibase needs to access the DBA_RECYCLEBIN table so we can automatically handle the case where " +
                "constraints are deleted and restored. Since Oracle doesn't properly restore the original table names " +
                "referenced in the constraint, we use the information from the DBA_RECYCLEBIN to automatically correct this" +
                " issue.\n" +
                "\n" +
                "The user you used to connect to the database (" + getConnection().getConnectionUserName() +
                ") needs to have \"SELECT ON SYS.DBA_RECYCLEBIN\" permissions set before we can perform this operation. " +
                "Please run the following SQL to set the appropriate permissions, and try running the command again.\n" +
                "\n" +
                "     GRANT SELECT ON SYS.DBA_RECYCLEBIN TO " + getConnection().getConnectionUserName() + ";";
    }

    public boolean canAccessDbaRecycleBin() {
        if (canAccessDbaRecycleBin == null) {
            DatabaseConnection connection = getConnection();
            if ((connection == null) || (connection instanceof OfflineConnection)) {
                return false;
            }

            Statement statement = null;
            try {
                statement = ((JdbcConnection) connection).createStatement();
                @SuppressWarnings("HardCodedStringLiteral") ResultSet resultSet = statement.executeQuery("select 1 from dba_recyclebin where 0=1");
                resultSet.close(); //don't need to do anything with the result set, just make sure statement ran.
                this.canAccessDbaRecycleBin = true;
            } catch (Exception e) {
                //noinspection HardCodedStringLiteral
                if ((e instanceof SQLException) && e.getMessage().startsWith("ORA-00942")) { //ORA-00942: table or view does not exist
                    this.canAccessDbaRecycleBin = false;
                } else {
                    //noinspection HardCodedStringLiteral
                    Scope.getCurrentScope().getLog(getClass()).warning("Cannot check dba_recyclebin access", e);
                    this.canAccessDbaRecycleBin = false;
                }
            } finally {
                JdbcUtils.close(null, statement);
            }
        }

        return canAccessDbaRecycleBin;
    }

    @Override
    public boolean supportsNotNullConstraintNames() {
        return true;
    }

    /**
     * Tests if the given String would be a valid identifier in Oracle DBMS. In Oracle, a valid identifier has
     * the following form (case-insensitive comparison):
     * 1st character: A-Z
     * 2..n characters: A-Z0-9$_#
     * The maximum length of an identifier differs by Oracle version and object type.
     */
    public boolean isValidOracleIdentifier(String identifier, Class<? extends DatabaseObject> type) {
        if ((identifier == null) || (identifier.length() < 1))
            return false;

        if (!identifier.matches("^(i?)[A-Z][A-Z0-9\\$\\_\\#]*$"))
            return false;

        /*
         * @todo It seems we currently do not have a class for tablespace identifiers, and all other classes
         * we do know seem to be supported as 12cR2 long identifiers, so:
         */
        return (identifier.length() <= LONG_IDENTIFIERS_LEGNTH);
    }

    /**
     * Returns the maximum number of bytes (NOT: characters) for an identifier. For Oracle <=12c Release 20, this
     * is 30 bytes, and starting from 12cR2, up to 128 (except for tablespaces, PDB names and some other rather rare
     * object types).
     *
     * @return the maximum length of an object identifier, in bytes
     */
    public int getIdentifierMaximumLength() {
        try {
            if (getDatabaseMajorVersion() < ORACLE_12C_MAJOR_VERSION) {
                return SHORT_IDENTIFIERS_LENGTH;
            } else if ((getDatabaseMajorVersion() == ORACLE_12C_MAJOR_VERSION) && (getDatabaseMinorVersion() <= 1)) {
                return SHORT_IDENTIFIERS_LENGTH;
            } else {
                return LONG_IDENTIFIERS_LEGNTH;
            }
        } catch (DatabaseException ex) {
            throw new UnexpectedLiquibaseException("Cannot determine the Oracle database version number", ex);
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598

5.3 修改 liquibase.datatype.core.BooleanType类

同理复制源码，覆盖修改。

在toDatabaseDataType方法中添加DmDatabase的支持
在isNumericBoolean方法中添加DmDatabase类型
具体代码如下：可以直接复制

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package liquibase.datatype.core;

import java.util.Locale;

import liquibase.change.core.LoadDataChange;
import liquibase.change.core.LoadDataChange.LOAD_DATA_TYPE;
import liquibase.database.Database;
import liquibase.database.core.*;
import liquibase.datatype.DataTypeInfo;
import liquibase.datatype.DatabaseDataType;
import liquibase.datatype.LiquibaseDataType;
import liquibase.exception.UnexpectedLiquibaseException;
import liquibase.statement.DatabaseFunction;
import liquibase.util.StringUtil;

@DataTypeInfo(
        name = "boolean",
        aliases = {"java.sql.Types.BOOLEAN", "java.lang.Boolean", "bit", "bool"},
        minParameters = 0,
        maxParameters = 0,
        priority = 1
)
public class BooleanType extends LiquibaseDataType {
    public BooleanType() {
    }

    @Override
    public DatabaseDataType toDatabaseDataType(Database database) {
        String originalDefinition = StringUtil.trimToEmpty(getRawDefinition());
        if ((database instanceof Firebird3Database)) {
            return new DatabaseDataType("BOOLEAN");
        }

        if ((database instanceof AbstractDb2Database) || (database instanceof FirebirdDatabase)) {
            return new DatabaseDataType("SMALLINT");
        } else if (database instanceof MSSQLDatabase) {
            return new DatabaseDataType(database.escapeDataTypeName("bit"));
        } else if (database instanceof MySQLDatabase) {
            if (originalDefinition.toLowerCase(Locale.US).startsWith("bit")) {
                return new DatabaseDataType("BIT", getParameters());
            }
            return new DatabaseDataType("BIT", 1);
        } else if (database instanceof OracleDatabase) {
            return new DatabaseDataType("NUMBER", 1);
        } else if ((database instanceof SybaseASADatabase) || (database instanceof SybaseDatabase)) {
            return new DatabaseDataType("BIT");
        } else if (database instanceof DerbyDatabase) {
            if (((DerbyDatabase) database).supportsBooleanDataType()) {
                return new DatabaseDataType("BOOLEAN");
            } else {
                return new DatabaseDataType("SMALLINT");
            }
        } else if (database.getClass().isAssignableFrom(DB2Database.class)) {
            if (((DB2Database) database).supportsBooleanDataType())
                return new DatabaseDataType("BOOLEAN");
            else
                return new DatabaseDataType("SMALLINT");
        } else if (database instanceof HsqlDatabase) {
            return new DatabaseDataType("BOOLEAN");
        } else if (database instanceof PostgresDatabase) {
            if (originalDefinition.toLowerCase(Locale.US).startsWith("bit")) {
                return new DatabaseDataType("BIT", getParameters());
            }
        } else if(database instanceof DmDatabase) {
            return new DatabaseDataType("bit");
        }

        return super.toDatabaseDataType(database);
    }

    @Override
    public String objectToSql(Object value, Database database) {
        if ((value == null) || "null".equals(value.toString().toLowerCase(Locale.US))) {
            return null;
        }

        String returnValue;
        if (value instanceof String) {
            value = ((String) value).replaceAll("'", "");
            if ("true".equals(((String) value).toLowerCase(Locale.US)) || "1".equals(value) || "b'1'".equals(((String) value).toLowerCase(Locale.US)) || "t".equals(((String) value).toLowerCase(Locale.US)) || ((String) value).toLowerCase(Locale.US).equals(this.getTrueBooleanValue(database).toLowerCase(Locale.US))) {
                returnValue = this.getTrueBooleanValue(database);
            } else if ("false".equals(((String) value).toLowerCase(Locale.US)) || "0".equals(value) || "b'0'".equals(
                    ((String) value).toLowerCase(Locale.US)) || "f".equals(((String) value).toLowerCase(Locale.US)) || ((String) value).toLowerCase(Locale.US).equals(this.getFalseBooleanValue(database).toLowerCase(Locale.US))) {
                returnValue = this.getFalseBooleanValue(database);
            } else {
                throw new UnexpectedLiquibaseException("Unknown boolean value: " + value);
            }
        } else if (value instanceof Long) {
            if (Long.valueOf(1).equals(value)) {
                returnValue = this.getTrueBooleanValue(database);
            } else {
                returnValue = this.getFalseBooleanValue(database);
            }
        } else if (value instanceof Number) {
            if (value.equals(1) || "1".equals(value.toString()) || "1.0".equals(value.toString())) {
                returnValue = this.getTrueBooleanValue(database);
            } else {
                returnValue = this.getFalseBooleanValue(database);
            }
        } else if (value instanceof DatabaseFunction) {
            return value.toString();
        } else if (value instanceof Boolean) {
            if (((Boolean) value)) {
                returnValue = this.getTrueBooleanValue(database);
            } else {
                returnValue = this.getFalseBooleanValue(database);
            }
        } else {
            throw new UnexpectedLiquibaseException("Cannot convert type " + value.getClass() + " to a boolean value");
        }

        return returnValue;
    }

    protected boolean isNumericBoolean(Database database) {
        if (database instanceof DerbyDatabase) {
            return !((DerbyDatabase) database).supportsBooleanDataType();
        } else if (database.getClass().isAssignableFrom(DB2Database.class)) {
            return !((DB2Database) database).supportsBooleanDataType();
        }
        return (database instanceof Db2zDatabase) || (database instanceof DB2Database) || (database instanceof FirebirdDatabase) || (database instanceof
                MSSQLDatabase) || (database instanceof MySQLDatabase) || (database instanceof OracleDatabase) ||
                (database instanceof SQLiteDatabase) || (database instanceof SybaseASADatabase) || (database instanceof
                SybaseDatabase) || (database instanceof DmDatabase);
    }

    /**
     * The database-specific value to use for "false" "boolean" columns.
     */
    public String getFalseBooleanValue(Database database) {
        if (isNumericBoolean(database)) {
            return "0";
        }
        if (database instanceof InformixDatabase) {
            return "'f'";
        }
        return "FALSE";
    }


    /**
     * The database-specific value to use for "true" "boolean" columns.
     */
    public String getTrueBooleanValue(Database database) {
        if (isNumericBoolean(database)) {
            return "1";
        }
        if (database instanceof InformixDatabase) {
            return "'t'";
        }
        return "TRUE";
    }


    @Override
    public LoadDataChange.LOAD_DATA_TYPE getLoadTypeName() {
        return LoadDataChange.LOAD_DATA_TYPE.BOOLEAN;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

5.4 修改resources/META-INF.services/liquibase.database.Database

添加DmDatabase支持。修改后的文件内如下，注意找不到源码的时候直接ctrl+shift+f 全局搜索即可。（也是在这个目录下建相同的文件，不能忘记，否者项目跑不起来！！！）

liquibase.database.core.CockroachDatabase
liquibase.database.core.DB2Database
liquibase.database.core.Db2zDatabase
liquibase.database.core.DerbyDatabase
liquibase.database.core.Firebird3Database
liquibase.database.core.FirebirdDatabase
liquibase.database.core.H2Database
liquibase.database.core.HsqlDatabase
liquibase.database.core.InformixDatabase
liquibase.database.core.Ingres9Database
liquibase.database.core.MSSQLDatabase
liquibase.database.core.MariaDBDatabase
liquibase.database.core.MockDatabase
liquibase.database.core.MySQLDatabase
liquibase.database.core.OracleDatabase
liquibase.database.core.PostgresDatabase
liquibase.database.core.SQLiteDatabase
liquibase.database.core.SybaseASADatabase
liquibase.database.core.SybaseDatabase
liquibase.database.core.DmDatabase
liquibase.database.core.UnsupportedDatabase
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5.5 报错

00:04:55.338 [restartedMain] ERROR o.f.c.e.i.d.CommonDbSchemaManager - [getProperty,198] - Could not get property from table ACT_GE_PROPERTY
dm.jdbc.driver.DMException: 第1 行附近出现错误:
无效的表或视图名[ACT_GE_PROPERTY]

在网上找的报错解决方案

配置mysql连接时加上：nullCatalogMeansCurrent=true。最终配置如下

# 数据源配置
spring:
    datasource:
        type: com.alibaba.druid.pool.DruidDataSource
#        driverClassName: com.mysql.cj.jdbc.Driver
        driverClassName: dm.jdbc.driver.DmDriver
        druid:
            # 主库数据源
#            master:
#                url: jdbc:mysql://121.43.234.114:3306/trading_center?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
#                username: root
#                password: gds12345678
             #主库数据源（本地mysql数据库）
#            master:
#                url: jdbc:mysql://localhost:3306/trading_center_dm?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
#                username: root
#                password: 123
            # 主库数据源（本地达梦数据库）
            master:
                url: jdbc:dm://127.0.0.1:5236?TRADING_CENTER_DM&zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&nullCatalogMeansCurrent=true
                username: TRADING_CENTER_DM
                password: TRADING_CENTER_DM
            # 从库数据源
            slave:
                # 从数据源开关/默认关闭
                enabled: false
                url:
                username:
                password:
            # 初始连接数
            initialSize: 5
            # 最小连接池数量
            minIdle: 10
            # 最大连接池数量
            maxActive: 20
            # 配置获取连接等待超时的时间
            maxWait: 60000
            # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
            timeBetweenEvictionRunsMillis: 60000
            # 配置一个连接在池中最小生存的时间，单位是毫秒
            minEvictableIdleTimeMillis: 300000
            # 配置一个连接在池中最大生存的时间，单位是毫秒
            maxEvictableIdleTimeMillis: 900000
            # 配置检测连接是否有效
            validationQuery: SELECT 1 FROM DUAL
            testWhileIdle: true
            testOnBorrow: false
            testOnReturn: false
            webStatFilter:
                enabled: true
            statViewServlet:
                enabled: true
                # 设置白名单，不填则允许所有访问
                allow:
                url-pattern: /druid/*
                # 控制台管理用户名和密码
                login-username: ruoyi
                login-password: 123456
            filter:
                stat:
                    enabled: true
                    # 慢SQL记录
                    log-slow-sql: true
                    slow-sql-millis: 1000
                    merge-sql: true
                wall:
                    config:
                        multi-statement-allow: true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

6、替换修改项目中的sql

mysql中的有些函数方式是达梦不支持的，所以要把部分sql替换为达梦支持的方式。（更多函数差别可以看官网文档或者本文章下面的附注）

本项目中主要修改的xml的sql如下

修改过sql的xml：

• SysNoticeMapper.xml （case函数修改）
• GenTableColumnMapper.xml (修改gen_table_column 表的插入语句的主键自增)
• SysDeptMapper.xml (修改sys_dept 表的插入语句的主键自增)
• SysJobMapper.xml (修改sys_job表的插入语句的主键自增)
• SysJobLogMapper.xml(修改sys_job_log表的插入语句的主键自增)
• SysMenuMapper.xml(修改sys_menu表的插入语句的主键自增)
• SysPostMapper.xml(修改sys_post表的插入语句的主键自增)
• SysUserMapper.xml(修改sys_user表的插入语句的主键自增)
• SysJobLogMapper.xml（修改替换date_format 函数）
• SysOperLogMapper.xml（修改替换date_format 函数）
• GenTableColumnMapper.xml(代码生成的sql修改为达梦写法)

6.1 替换 find_in_set函数

由于达梦数据库没有内置find_in_set函数，但项目中有用到，所以需要自定义函数，方便后续程序调用。

先切换模式

set schema TRADING_CENTER_DM;
1

再创建函数FIND_IN_SET

CREATE OR REPLACE FUNCTION FIND_IN_SET
                (
                        piv_str1 varchar2,
                        piv_str2 varchar2,
                        p_sep    varchar2 := ',')
                RETURN NUMBER
                            IS
                l_idx     number:=0;                 -- 用于计算piv_str2中分隔符的位置
                str       varchar2(500);             -- 根据分隔符截取的子字符串
                piv_str   varchar2(500) := piv_str2; -- 将piv_str2赋值给piv_str
                res       number        :=0;         -- 返回结果
                loopIndex number        :=0;
        BEGIN
                -- 如果piv_str中没有分割符，直接判断piv_str1和piv_str是否相等，相等 res=1
                IF instr(piv_str, p_sep, 1) = 0 THEN
                        IF piv_str          = piv_str1 THEN
                                res        := 1;
                        END IF;
                ELSE
                        -- 循环按分隔符截取piv_str
                        LOOP
                                l_idx    := instr(piv_str, p_sep);
                                loopIndex:=loopIndex+1;
                                -- 当piv_str中还有分隔符时
                                IF l_idx > 0 THEN
                                        -- 截取第一个分隔符前的字段str
                                        str:= substr(piv_str, 1, l_idx-1);
                                        -- 判断 str 和piv_str1 是否相等，相等 res=1 并结束循环判断
                                        IF str      = piv_str1 THEN
                                                res:= loopIndex;
                                                EXIT;
                                        END IF;
                                        piv_str := substr(piv_str, l_idx+length(p_sep));
                                ELSE
                                        -- 当截取后的piv_str 中不存在分割符时，判断piv_str和piv_str1是否相等，相等 res=1
                                        IF piv_str  = piv_str1 THEN
                                                res:= loopIndex;
                                        END IF;
                                        -- 无论最后是否相等，都跳出循环
                                        EXIT;
                                END IF;
                        END LOOP;
                        -- 结束循环
                END IF;
                -- 返回res
                RETURN res;
        END FIND_IN_SET;
commit;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

6.2 替换case（）函数

cast()，mysq有，达梦没有。

cast(xxx as SIGNED INTEGER) -- mysql函数

替换为

to_number(xxx) -- 达梦函数

cast(notice_content as char)  --mysql函数 notice_content是longblob类型 转为了char
替换为
CONVERT(notice_content, SQL_CHAR)  --达梦函数 notice_content是blob类型 转为了char
1
2
3
4
5
6
7
8
9

6.3 根据达梦的主键自增修改SQL

达梦的主键自增是不允许INSERT INTO语句中出现那个字段名的。就算赋值为null也会报错。

错误

INSERT INTO sys_logs_method ( Id, ActionTime, ActionBy, Type, IsDelete, Remark, Ip, ActionByName, ProjectNo, actionByAccount ) VALUES ( 0, ?, ?, ?, ?, ?, ?, ?, ?, ? ) 
1

错误

INSERT INTO sys_logs_method ( Id, ActionTime, ActionBy, Type, IsDelete, Remark, Ip, ActionByName, ProjectNo, actionByAccount ) VALUES ( null, ?, ?, ?, ?, ?, ?, ?, ?, ? ) 
1

正确

INSERT INTO sys_logs_method ( ActionTime, ActionBy, Type, IsDelete, Remark, Ip, ActionByName, ProjectNo, actionByAccount ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ? ) 
1

修改过xml语句的详细情况见 目录6。

6.4 修改替换date_format 函数

达梦不支持 date_sub 函数，使用 dateadd(datepart,n,date) 代替，其中，datepart可以为：year(yy,yyyy)，quarter(qq,q)，month(mm,m)，dayofyear(dy,y)，day(dd,d)，week(wk,ww)，weekday(dw)，hour(hh)， minute(mi,n)， second(ss,s)， millisecond(ms)，

select dateadd(month, -6, now());  --dameng
select dateadd(month, 2, now());   --dameng
1
2

替换例子：

 date_format(create_time,'%y%m%d')   --mysql
 替换为达梦
to_char(create_time, 'YYMMDD')       --dameng
1
2
3

6.5 不支持 case-when-then-else

不支持 case-when-then-else

这里有一个若依框架中代码生成的case—when的例子

mysql写法

    
		select column_name, (case when (is_nullable = 'no'  column_key != 'PRI') then '1' else null end) as is_required, (case when column_key = 'PRI' then '1' else '0' end) as is_pk, ordinal_position as sort, column_comment, (case when extra = 'auto_increment' then '1' else '0' end) as is_increment, column_type
		from information_schema.columns where table_schema = (select database()) and table_name = (#{tableName})
		order by ordinal_position
	
1
2
3
4
5

改达梦

    select t3.COLUMN_NAME                     as column_name,
           (CASE
                WHEN (t3.NULLABLE = 'N' and t4.CONSTRAINT_TYPE !='P') THEN '1'
                ELSE NULL END)
                                              as is_required,
           IF(t4.CONSTRAINT_TYPE = 'P', 1, 0) as is_pk,
           t3.COLUMN_ID                       as sort,
           t5.COMMENTS                        as column_comment,
           (  CASE
                  WHEN (t3.TYPE = 'INT' OR t3.TYPE = 'INTEGER' OR t3.TYPE = 'BIGINT' OR t3.TYPE = 'TINYINT' OR
                        t3.TYPE = 'SMALLINT') and t4.CONSTRAINT_TYPE = 'P' THEN '1'
                  ELSE '0' END  )                 AS is_increment,
           DATA_TYPE as DATA_TYPE
    from ((select COLUMN_NAME,
                  COLUMN_ID,
                  concat(DATA_TYPE, '(', DATA_LENGTH, ')') as DATA_TYPE,
                  DATA_TYPE                                as TYPE,
                  TABLE_NAME,
                  NULLABLE
           from SYS.USER_TAB_COLUMNS
           WHERE table_name = (#{tableName})) t3
             left join (select COMMENTS, COLUMN_NAME, TABLE_NAME from SYS.USER_COL_COMMENTS) t5
                       ON (t3.COLUMN_NAME = t5.COLUMN_NAME and t3.TABLE_NAME = t5.TABLE_NAME)
             left join
         (select t1.CONSTRAINT_TYPE, t1.OWNER, t1.TABLE_NAME, t2.CONSTRAINT_NAME, t2.COLUMN_NAME
          from (select CONSTRAINT_NAME, CONSTRAINT_TYPE, OWNER, TABLE_NAME from SYS.USER_CONSTRAINTS) t1
                   inner join (select CONSTRAINT_NAME, OWNER, TABLE_NAME, COLUMN_NAME from SYS.USER_CONS_COLUMNS) t2
                              ON (t1.TABLE_NAME = t2.TABLE_NAME and t1.CONSTRAINT_NAME = t2.CONSTRAINT_NAME)
          where t1.CONSTRAINT_TYPE = 'P') t4 ON (t3.COLUMN_NAME = t4.COLUMN_NAME and t3.TABLE_NAME = t4.TABLE_NAME))
    order by t3.COLUMN_ID

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

若依框架的代码生成还有几个xml的方法也需要替换，如下：

  
        select t1.TABLE_NAME as table_name, t2.COMMENTS as table_comment, NULL as create_time, NULL as update_time
        from SYS.USER_TABLES t1
        inner join SYS.USER_TAB_COMMENTS t2 ON t1.TABLE_NAME = t2.TABLE_NAME
        WHERE t1.TABLE_NAME NOT LIKE 'qrtz_%'
        AND t1.TABLE_NAME NOT LIKE 'gen_%'
        AND t1.TABLE_NAME NOT IN (select table_name as TABLE_NAME from gen_table)
        
            AND lower(t1.TABLE_NAME) like lower(concat('%', #{tableName}, '%'))
        
        
            AND lower(t1.TABLE_NAME) like lower(concat('%', #{tableName}, '%'))
        
    

 
        select t1.TABLE_NAME as table_name, t2.COMMENTS as table_comment, NULL as create_time, NULL as update_time
        from SYS.USER_TABLES t1
        inner join SYS.USER_TAB_COMMENTS t2 ON t1.TABLE_NAME = t2.TABLE_NAME
        WHERE t1.TABLE_NAME NOT LIKE 'qrtz_%'
        AND t1.TABLE_NAME NOT LIKE 'gen_%'
        and t1.TABLE_NAME in
        
            #{name}
        
    
                                                       

    select t1.TABLE_NAME as table_name, t2.COMMENTS as table_comment, NULL as create_time, NULL as update_time
    from SYS.USER_TABLES t1
             inner join SYS.USER_TAB_COMMENTS t2 ON t1.TABLE_NAME = t2.TABLE_NAME
    where t2.COMMENTS  ]]> ''
      and t1.TABLE_NAME = #{tableName}
                                         
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

7 、附注

7.1 源码的修改方式

根据源文件路径，在java包下新建java class文件，将源文件中代码粘贴到新创建的文件中，修改相关代码后保存，编译。

在target中找到编译后的class文件

找对源文件所在jar包，右键在文件管理中打开。

解压jar包，将修改后并编译的target中的class文件粘贴到jar包对应位置，然后重新打包成zip压缩包后修改后缀为.jar

批注：jar包中的源码修改后能用git提交吗

当你修改了一个 JAR 包中的源码后，你实际上修改了该 JAR 包的一个副本。这个修改并不会影响到原始的 JAR 包，因此无法直接使用 Git 提交这些修改。

7.2 启动Maven项目 程序包不存在报错

如果依赖什么都没问题的话这个一般就是项目编译问题，把项目重新编译

点击Maven中的 M 按钮，然后输入下面的命令 把项目重新编译就可以运行了

mvn idea:idea
1

7.3 mysql与达梦的部分sql函数差异

这里只提供常见的差异，详情还得根据改造后的功能进行测试，或者参考官方文档。

（1）创建表的时候，不支持在列的后面直接加comment注释，使用 COMMENT ON IS 代替，如：

COMMENT ON TABLE xxx IS xxx
COMMENT ON COLUMN xxx IS xxx
1
2

（2）不支持 date_sub 函数，使用 dateadd(datepart,n,date) 代替，其中，datepart可以为：year(yy,yyyy)，quarter(qq,q)，month(mm,m)，dayofyear(dy,y)，day(dd,d)，week(wk,ww)，weekday(dw)，hour(hh)， minute(mi,n)， second(ss,s)， millisecond(ms)，例子：

select dateadd(month, -6, now());
select dateadd(month, 2, now());
1
2

（3）不支持 date_format 函数，它有三种代替方法：
A: 使用 datepart 代替：语法：datepart(datepart, date)，返回代表日期的指定部分的整数，datepart可以为：year(yy,yyyy)，quarter(qq,q)，month(mm,m)，dayofyear(dy,y)，day(dd,d)，week(wk,ww)，weekday(dw)，hour(hh)， minute(mi,n)，second(ss,s)， millisecond(ms)，例子：

select datepart(year, '2023-04-13 08:45:00'); --2023
select datepart(month, '2022-12-13 08:45:00'); --12
1
2

B: 使用 date_part 代替，功能和 datepart 一样，写法不同，参数顺序颠倒，且都要加引号，例子：

select date_part('2023-12-13 08:45:00', 'year');--2023
select date_part('2022-12-13 08:45:00', 'mm'); -- 12
1
2

C: 使用 extract 代替，语法：extract(dtfield from date)，从日期类型date中抽取dtfield对应的值，dtfield 可以是 year，month，day，hour，minute，second，例子：

select extract(year from  '2023-12-13 08:45:00'); --2023
select extract(month from  '2022-12-13 08:45:00'); --12
1
2

（4）不支持 substring_index 函数， 使用 substr / substring 代替，语法：

substr(char[,m[,n]])
substring(char[from m[ for n]])
1
2

（5）不支持 group_concat 函数，使用 wm_concat 代替，例子：

select wm_concat(id) as idstr from persion ORDER BY id ;
1

（6）不支持 from_unixtime 函数，使用 round 代替，语法：

round(date[,format])
1

（7）不支持 case-when-then-else ，例如：

select case  when id = 2 then "aaa" when id = 3 then "bbb" else "ccc" end as test from (select id from person) tt;
1

（8）current_timestamp 的返回值带有时区，例子：

select current_timestamp();
2023-04-37 14:34:18.433839 +08:00
1
2

r(yy,yyyy)，quarter(qq,q)，month(mm,m)，dayofyear(dy,y)，day(dd,d)，week(wk,ww)，weekday(dw)，hour(hh)， minute(mi,n)， second(ss,s)， millisecond(ms)，例子：

select dateadd(month, -6, now());
select dateadd(month, 2, now());
1
2

（3）不支持 date_format 函数，它有三种代替方法：
A: 使用 datepart 代替：语法：datepart(datepart, date)，返回代表日期的指定部分的整数，datepart可以为：year(yy,yyyy)，quarter(qq,q)，month(mm,m)，dayofyear(dy,y)，day(dd,d)，week(wk,ww)，weekday(dw)，hour(hh)， minute(mi,n)，second(ss,s)， millisecond(ms)，例子：

select datepart(year, '2023-04-13 08:45:00'); --2023
select datepart(month, '2022-12-13 08:45:00'); --12
1
2

B: 使用 date_part 代替，功能和 datepart 一样，写法不同，参数顺序颠倒，且都要加引号，例子：

select date_part('2023-12-13 08:45:00', 'year');--2023
select date_part('2022-12-13 08:45:00', 'mm'); -- 12
1
2

C: 使用 extract 代替，语法：extract(dtfield from date)，从日期类型date中抽取dtfield对应的值，dtfield 可以是 year，month，day，hour，minute，second，例子：

select extract(year from  '2023-12-13 08:45:00'); --2023
select extract(month from  '2022-12-13 08:45:00'); --12
1
2

（4）不支持 substring_index 函数， 使用 substr / substring 代替，语法：

substr(char[,m[,n]])
substring(char[from m[ for n]])
1
2

（5）不支持 group_concat 函数，使用 wm_concat 代替，例子：

select wm_concat(id) as idstr from persion ORDER BY id ;
1

（6）不支持 from_unixtime 函数，使用 round 代替，语法：

round(date[,format])
1

（7）不支持 case-when-then-else ，例如：

select case  when id = 2 then "aaa" when id = 3 then "bbb" else "ccc" end as test from (select id from person) tt;
1

（8）current_timestamp 的返回值带有时区，例子：

select current_timestamp();
2023-04-37 14:34:18.433839 +08:00
1
2