Springboot与flowable—达梦国产化改造
文章目录
- Springboot与flowable—达梦国产化改造
-
- 1、相关软件下载
-
- 2 、源代码运行
-
- 2.1 导入sql
- 2.2 打开项目，导入pom依赖
- 2.3 修改配置
- 2.3.1 修改数据库配置
- 2.3.2 修改redis配置
- 2.3.3 运行后端
- 2.3.4 运行前端
- 3、数据库迁移
-
- 3.1 新建达梦数据库（用户）
-
- 3.2 使用数据库迁移工具
-
- 4、springboot替换为达梦数据库
-
- 4.1 安装达梦驱动jar包
- 4.2 POM添加达梦的驱动依赖
- 4.3 修改yml的达梦连接驱动
- 5、flowable工作流整合达梦数据库
-
- 5.1 修改 AbstractEngineConfiguration 文件
- 5.2 修改[liquibase](https://so.csdn.net/so/search?q=liquibase&spm=1001.2101.3001.7020)-core-4.3.5.jar中源码
- 5.3 修改 liquibase.datatype.core.BooleanType类
- 5.4 修改resources/META-INF.services/liquibase.database.Database
- 5.5 报错
- 6、替换修改项目中的sql
-
- 6.1 替换 find_in_set函数
- 6.2 替换case（）函数
- 6.3 根据达梦的主键自增修改SQL
- 6.4 修改替换date_format 函数
- 6.5 不支持 case-when-then-else
- 7 、附注
-
- 7.1 源码的修改方式
- 7.2 启动Maven项目 程序包不存在报错
- 7.3 mysql与达梦的部分sql函数差异
首先说明本实例包含了
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中加入如下依赖
org.apache.maven.plugins
maven-surefire-plugin
true
加完之后 clean install 然后重新编译 点击这个 m 图标 输入 mvn idea:idea
2.3 修改配置
2.3.1 修改数据库配置
2.3.2 修改redis配置
2.3.3 运行后端
直接运行
2.3.4 运行前端
首先打开前端控制台,下载依赖
npm install
然后修改 vue.config.js配置文件中的代理配置（这里的代理地址就是访问后端接口的地址），连上后端
然后保存ctrl+s，一定要记得保存配置才生效
npm run dev
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;
回到迁移工具，上一步，选择模式，选择表重新迁移这张失败的表即可。
这里数据库就迁移完了。
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
4.2 POM添加达梦的驱动依赖
在admin模块添加达梦的驱动依赖
com.dm
DmJdbcDriver18
1.8
此时重启项目会遇到编译报错，在没加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
参考上面的修改，记得达梦数据库名就是用户名。
注意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.(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)
然后由于本项目使用了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'
所以还得修改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;
}
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 reservedWords = new HashSet();
private Set userDefinedTypes;
private Map 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
![Flink 1.18.1 部署与配置[CentOS7]](/img/b0/e06e1abfbca04bbf9c19452edeb41f08.png)
