diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/DefaultSqlChecker.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/DefaultSqlChecker.java index b0b6808f12..5147f627fe 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/DefaultSqlChecker.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/DefaultSqlChecker.java @@ -18,10 +18,9 @@ import java.util.List; import java.util.stream.Collectors; -import org.springframework.jdbc.core.JdbcOperations; - import com.oceanbase.odc.core.session.ConnectionSession; import com.oceanbase.odc.core.session.ConnectionSessionConstants; +import com.oceanbase.odc.core.session.ConnectionSessionUtil; import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.core.sql.parser.AbstractSyntaxTreeFactories; import com.oceanbase.odc.core.sql.parser.AbstractSyntaxTreeFactory; @@ -52,11 +51,8 @@ public DefaultSqlChecker(@NonNull DialectType dialectType, public DefaultSqlChecker(@NonNull ConnectionSession session, String delimiter) { this(session.getDialectType(), delimiter, SqlCheckRules.getAllDefaultRules( - session.getSyncJdbcExecutor(ConnectionSessionConstants.CONSOLE_DS_KEY), session.getDialectType())); - } - - public DefaultSqlChecker(JdbcOperations jdbcOperations, @NonNull DialectType dialectType, String delimiter) { - this(dialectType, delimiter, SqlCheckRules.getAllDefaultRules(jdbcOperations, dialectType)); + session.getSyncJdbcExecutor(ConnectionSessionConstants.CONSOLE_DS_KEY), + () -> ConnectionSessionUtil.getVersion(session), session.getDialectType())); } @Override diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRuleContext.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRuleContext.java new file mode 100644 index 0000000000..5672c53fc2 --- /dev/null +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRuleContext.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2023 OceanBase. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.oceanbase.odc.service.sqlcheck; + +import java.util.Map; +import java.util.function.Supplier; + +import com.oceanbase.odc.core.shared.constant.DialectType; + +import lombok.Getter; + +/** + * @author longpeng.zlp + * @date 2025/1/10 10:22 + */ +@Getter +public class SqlCheckRuleContext { + private final Supplier dbVersionSupplier; + private final DialectType dialectType; + private final Map parameters; + + private SqlCheckRuleContext(Supplier dbVersionSupplier, DialectType dialectType, + Map parameters) { + this.dbVersionSupplier = dbVersionSupplier; + this.dialectType = dialectType; + this.parameters = parameters; + } + + public static SqlCheckRuleContext create(Supplier dbVersionSupplier, DialectType dialectType, + Map parameters) { + if (null == dialectType) { + throw new RuntimeException("dbVersion or dialectType should not be null"); + } + return new SqlCheckRuleContext(dbVersionSupplier, dialectType, parameters); + } +} diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRuleFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRuleFactory.java index 2464ffe281..a6fe51aa85 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRuleFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRuleFactory.java @@ -15,9 +15,6 @@ */ package com.oceanbase.odc.service.sqlcheck; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import lombok.NonNull; @@ -26,7 +23,7 @@ public interface SqlCheckRuleFactory { SqlCheckRuleType getSupportsType(); - SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters); + SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext); default String getParameterNameKey(String parameterName) { return "${com.oceanbase.odc.builtin-resource.regulation.rule.sql-check." diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckService.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckService.java index bf7be02bde..14a3d614ae 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckService.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckService.java @@ -22,6 +22,7 @@ import java.util.Map; import java.util.Objects; import java.util.function.Function; +import java.util.function.Supplier; import java.util.stream.Collectors; import javax.validation.Valid; @@ -146,7 +147,8 @@ public List check(@NotNull Long environmentId, @NonNull String d SqlCheckContext checkContext = new SqlCheckContext((long) sqls.size()); try (SingleConnectionDataSource dataSource = (SingleConnectionDataSource) factory.getDataSource()) { JdbcTemplate jdbc = new JdbcTemplate(dataSource); - List checkRules = getRules(rules, config.getDialectType(), jdbc); + List checkRules = getRules(rules, () -> SqlCheckUtil.getDbVersion(config, dataSource), + config.getDialectType(), jdbc); DefaultSqlChecker sqlChecker = new DefaultSqlChecker(config.getDialectType(), null, checkRules); List checkViolations = new ArrayList<>(); for (OffsetString sql : sqls) { @@ -159,11 +161,11 @@ public List check(@NotNull Long environmentId, @NonNull String d } public List getRules(List rules, @NonNull ConnectionSession session) { - return getRules(rules, session.getDialectType(), + return getRules(rules, () -> ConnectionSessionUtil.getVersion(session), session.getDialectType(), session.getSyncJdbcExecutor(ConnectionSessionConstants.CONSOLE_DS_KEY)); } - public List getRules(List rules, + public List getRules(List rules, Supplier dbVersionSupplier, @NonNull DialectType dialectType, @NonNull JdbcOperations jdbc) { if (CollectionUtils.isEmpty(rules)) { return Collections.emptyList(); @@ -177,7 +179,7 @@ public List getRules(List rules, return Objects.equals(metadata.getType(), RuleType.SQL_CHECK); }).map(rule -> { try { - return SqlCheckRules.createByRule(candidates, dialectType, rule); + return SqlCheckRules.createByRule(candidates, dbVersionSupplier, dialectType, rule); } catch (Exception e) { return null; } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckUtil.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckUtil.java index 2b10a4feff..b18f00d2d6 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckUtil.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/SqlCheckUtil.java @@ -25,6 +25,8 @@ import java.util.stream.Collectors; import java.util.stream.Stream; +import javax.sql.DataSource; + import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.Validate; @@ -32,6 +34,8 @@ import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.core.sql.parser.AbstractSyntaxTreeFactories; import com.oceanbase.odc.core.sql.parser.AbstractSyntaxTreeFactory; +import com.oceanbase.odc.service.connection.model.ConnectionConfig; +import com.oceanbase.odc.service.plugin.ConnectionPluginUtil; import com.oceanbase.odc.service.sqlcheck.model.CheckResult; import com.oceanbase.odc.service.sqlcheck.model.CheckViolation; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; @@ -240,4 +244,13 @@ public static Statement parseSingleSql(DialectType dialectType, String sql) { } } + public static String getDbVersion(ConnectionConfig config, DataSource dataSource) { + try { + return ConnectionPluginUtil.getInformationExtension(config.getDialectType()) + .getDBVersion(dataSource.getConnection()); + } catch (Throwable e) { + throw new RuntimeException(e); + } + } + } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCalculationFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCalculationFactory.java index 78f37bbf5c..3abcc50cf5 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCalculationFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCalculationFactory.java @@ -15,10 +15,9 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLColumnCalculation; @@ -34,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); return (dialectType.isMysql() || dialectType.isDoris()) ? new MySQLColumnCalculation() : new OracleColumnCalculation(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCharsetExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCharsetExistsFactory.java index 1c814fa5ae..aca619224d 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCharsetExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCharsetExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.ColumnCharsetExists; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new ColumnCharsetExists(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCollationExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCollationExistsFactory.java index 9fa5cc2f75..8a2ff9ee62 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCollationExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnCollationExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.ColumnCollationExists; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new ColumnCollationExists(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnNameInBlackListFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnNameInBlackListFactory.java index c89f6e4014..45bb397004 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnNameInBlackListFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ColumnNameInBlackListFactory.java @@ -19,8 +19,8 @@ import java.util.List; import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.ColumnNameInBlackList; @@ -36,8 +36,9 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { String key = getParameterNameKey("black-list"); + Map parameters = sqlCheckRuleContext.getParameters(); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new ColumnNameInBlackList(new HashSet<>()); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/CreateTableAsExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/CreateTableAsExistsFactory.java index 1f58504347..5360f3b7e9 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/CreateTableAsExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/CreateTableAsExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.CreateTableAsExists; @@ -38,7 +36,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new CreateTableAsExists(); } } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/CreateTableLikeExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/CreateTableLikeExistsFactory.java index 2a783209a6..50bce2e7f6 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/CreateTableLikeExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/CreateTableLikeExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.CreateTableLikeExists; @@ -38,7 +36,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new CreateTableLikeExists(); } } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ForeignConstraintExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ForeignConstraintExistsFactory.java index 2a9b6a3437..5f499328f0 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ForeignConstraintExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ForeignConstraintExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.ForeignConstraintExists; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new ForeignConstraintExists(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/LeftFuzzyMatchFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/LeftFuzzyMatchFactory.java index f41e54160e..9a63144088 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/LeftFuzzyMatchFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/LeftFuzzyMatchFactory.java @@ -15,10 +15,9 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLLeftFuzzyMatch; @@ -34,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); return (dialectType.isMysql() || dialectType.isDoris()) ? new MySQLLeftFuzzyMatch() : new OracleLeftFuzzyMatch(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/MissingRequiredColumnsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/MissingRequiredColumnsFactory.java index dba58a1614..00c55aa2f4 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/MissingRequiredColumnsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/MissingRequiredColumnsFactory.java @@ -22,6 +22,7 @@ import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLMissingRequiredColumns; @@ -38,7 +39,9 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("column-names"); Set cols; if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoColumnCommentExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoColumnCommentExistsFactory.java index 0e1fc3c933..cf8ede6d73 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoColumnCommentExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoColumnCommentExistsFactory.java @@ -15,11 +15,11 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; import java.util.function.Supplier; import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLNoColumnCommentExists; @@ -41,7 +41,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); return (dialectType.isMysql() || dialectType.isDoris()) ? new MySQLNoColumnCommentExists() : new OracleNoColumnCommentExists(schemaSupplier); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoDefaultValueExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoDefaultValueExistsFactory.java index fd7b4f2448..7bd3bf3cbd 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoDefaultValueExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoDefaultValueExistsFactory.java @@ -19,8 +19,8 @@ import java.util.List; import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.NoDefaultValueExists; @@ -36,7 +36,8 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("no-default-value-datatype-list"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new NoDefaultValueExists(new HashSet<>()); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoIndexNameExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoIndexNameExistsFactory.java index c04e8d14f5..e286e102b2 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoIndexNameExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoIndexNameExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.NoIndexNameExists; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new NoIndexNameExists(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoNotNullAtInExpressionFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoNotNullAtInExpressionFactory.java index 14dfafb8aa..f6784cbadc 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoNotNullAtInExpressionFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoNotNullAtInExpressionFactory.java @@ -15,10 +15,9 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLNoNotNullAtInExpression; @@ -34,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); return (dialectType.isMysql() || dialectType.isDoris()) ? new MySQLNoNotNullAtInExpression() : new OracleNoNotNullAtInExpression(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoPrimaryKeyExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoPrimaryKeyExistsFactory.java index e591824b63..0443aef0d1 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoPrimaryKeyExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoPrimaryKeyExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.NoPrimaryKeyExists; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new NoPrimaryKeyExists(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoPrimaryKeyNameExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoPrimaryKeyNameExistsFactory.java index 729dde489f..825db7e281 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoPrimaryKeyNameExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoPrimaryKeyNameExistsFactory.java @@ -16,10 +16,8 @@ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.NoPrimaryKeyNameExists; @@ -34,7 +32,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new NoPrimaryKeyNameExists(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoSpecificColumnExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoSpecificColumnExistsFactory.java index b0fa0b1668..c0258cf34b 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoSpecificColumnExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoSpecificColumnExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.NoSpecificColumnExists; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new NoSpecificColumnExists(); } } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoTableCommentExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoTableCommentExistsFactory.java index 82f244e510..7ad13045e5 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoTableCommentExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoTableCommentExistsFactory.java @@ -15,11 +15,11 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; import java.util.function.Supplier; import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLNoTableCommentExists; @@ -41,7 +41,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); return (dialectType.isMysql() || dialectType.isDoris()) ? new MySQLNoTableCommentExists() : new OracleNoTableCommentExists(schemaSupplier); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoValidWhereClauseFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoValidWhereClauseFactory.java index bee7485f66..1f3629b168 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoValidWhereClauseFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoValidWhereClauseFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.NoValidWhereClause; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new NoValidWhereClause(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoWhereClauseExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoWhereClauseExistsFactory.java index 6f505a87bc..6b5ee03dd0 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoWhereClauseExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NoWhereClauseExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.NoWhereClauseExists; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new NoWhereClauseExists(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NotNullColumnWithoutDefaultValueFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NotNullColumnWithoutDefaultValueFactory.java index 073e38fa09..3b55bc138c 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NotNullColumnWithoutDefaultValueFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/NotNullColumnWithoutDefaultValueFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.NotNullColumnWithoutDefaultValue; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new NotNullColumnWithoutDefaultValue(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ObjectNameUsingReservedWordsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ObjectNameUsingReservedWordsFactory.java index e6103bdfb3..66101e27f6 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ObjectNameUsingReservedWordsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ObjectNameUsingReservedWordsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLObjectNameUsingReservedWords; @@ -34,8 +32,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { - return dialectType.isMysql() + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + return sqlCheckRuleContext.getDialectType().isMysql() ? new MySQLObjectNameUsingReservedWords() : new OracleObjectNameUsingReservedWords(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/OfflineDdlExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/OfflineDdlExistsFactory.java index 388dd7aab2..ac56387e8f 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/OfflineDdlExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/OfflineDdlExistsFactory.java @@ -15,12 +15,10 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - import org.springframework.jdbc.core.JdbcOperations; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLOfflineDdlExists; @@ -42,8 +40,10 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { - return dialectType.isMysql() ? new MySQLOfflineDdlExists(this.jdbc) : new OracleOfflineDdlExists(this.jdbc); + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + return sqlCheckRuleContext.getDialectType().isMysql() ? new MySQLOfflineDdlExists( + sqlCheckRuleContext.getDbVersionSupplier(), this.jdbc) + : new OracleOfflineDdlExists(sqlCheckRuleContext.getDbVersionSupplier(), this.jdbc); } } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/PreferLocalOutOfLineIndexFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/PreferLocalOutOfLineIndexFactory.java index 2d444cf7d6..09fdc6994d 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/PreferLocalOutOfLineIndexFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/PreferLocalOutOfLineIndexFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.PreferLocalOutOfLineIndex; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new PreferLocalOutOfLineIndex(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ProhibitedDatatypeExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ProhibitedDatatypeExistsFactory.java index b18cfbd29a..2c22c5fd0d 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ProhibitedDatatypeExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ProhibitedDatatypeExistsFactory.java @@ -20,8 +20,8 @@ import java.util.Map; import java.util.Set; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.ProhibitedDatatypeExists; @@ -37,7 +37,8 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("datatype-names"); Set types; if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictAutoIncrementDataTypesFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictAutoIncrementDataTypesFactory.java index a4dc03c886..3d8b22bb2d 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictAutoIncrementDataTypesFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictAutoIncrementDataTypesFactory.java @@ -24,6 +24,7 @@ import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLRestrictAutoIncrementDataTypes; @@ -39,7 +40,9 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("allowed-datatypes"); Set types; if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictAutoIncrementUnsignedFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictAutoIncrementUnsignedFactory.java index d95ab418f3..52d4065cf9 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictAutoIncrementUnsignedFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictAutoIncrementUnsignedFactory.java @@ -15,10 +15,9 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLRestrictAutoIncrementUnsigned; @@ -33,7 +32,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); return (dialectType.isMysql() || dialectType.isDoris()) ? new MySQLRestrictAutoIncrementUnsigned() : null; } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictColumnNameCaseFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictColumnNameCaseFactory.java index ffcec07344..152c33ebd1 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictColumnNameCaseFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictColumnNameCaseFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.OracleRestrictColumnNameCase; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); Boolean lowercase = null; Boolean uppercase = null; if (parameters != null && !parameters.isEmpty()) { @@ -46,7 +47,8 @@ public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("nullable-datatype-list"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new RestrictColumnNotNull(new HashSet<>()); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictDropObjectTypesFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictDropObjectTypesFactory.java index c1e2b2eede..38a0c0c9a5 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictDropObjectTypesFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictDropObjectTypesFactory.java @@ -19,8 +19,8 @@ import java.util.List; import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.RestrictDropObjectTypes; @@ -36,7 +36,8 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("allowed-object-types"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new RestrictDropObjectTypes(new HashSet<>()); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictIndexDataTypesFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictIndexDataTypesFactory.java index d1dc459d4e..56c300e857 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictIndexDataTypesFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictIndexDataTypesFactory.java @@ -25,6 +25,7 @@ import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLRestrictIndexDataTypes; @@ -47,7 +48,9 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("allowed-datatypes"); Set types; if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictIndexNamingFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictIndexNamingFactory.java index d4b1683053..59720b4017 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictIndexNamingFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictIndexNamingFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.RestrictIndexNaming; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("name-pattern"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new RestrictIndexNaming(null); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKAutoIncrementFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKAutoIncrementFactory.java index dfef860672..4d4d5b5725 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKAutoIncrementFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKAutoIncrementFactory.java @@ -15,12 +15,11 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - import org.springframework.jdbc.core.JdbcOperations; import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLRestrictPKAutoIncrement; @@ -41,7 +40,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); return (dialectType.isMysql() || dialectType.isDoris()) ? new MySQLRestrictPKAutoIncrement(this.jdbc) : null; } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKDataTypesFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKDataTypesFactory.java index fd8dd30d16..f3f329897c 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKDataTypesFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKDataTypesFactory.java @@ -25,6 +25,7 @@ import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLRestrictPKDataTypes; @@ -47,7 +48,9 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("allowed-datatypes"); Set types; if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKNamingFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKNamingFactory.java index f71b4a7715..a400887f99 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKNamingFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictPKNamingFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.RestrictPKNaming; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("name-pattern"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new RestrictPKNaming(null); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableAutoIncrementFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableAutoIncrementFactory.java index cf249f7b32..9e61f602f1 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableAutoIncrementFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableAutoIncrementFactory.java @@ -19,6 +19,7 @@ import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLRestrictTableAutoIncrement; @@ -33,7 +34,9 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); + Map parameters = sqlCheckRuleContext.getParameters(); int initValue; String key = getParameterNameKey("init-value"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableCharsetFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableCharsetFactory.java index f8a08310ad..6b9bf6e973 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableCharsetFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableCharsetFactory.java @@ -22,6 +22,7 @@ import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLRestrictTableCharset; @@ -37,7 +38,9 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("allowed-charsets"); Set allowCharsets; if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableCollationFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableCollationFactory.java index efbf91cc75..d7f5844086 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableCollationFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableCollationFactory.java @@ -22,6 +22,7 @@ import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLRestrictTableCollation; @@ -37,7 +38,9 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("allowed-collations"); Set allowCollations; if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableNameCaseFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableNameCaseFactory.java index b9c598398a..673c47c206 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableNameCaseFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/RestrictTableNameCaseFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.OracleRestrictTableNameCase; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); Boolean lowercase = null; Boolean uppercase = null; if (parameters != null && !parameters.isEmpty()) { @@ -46,7 +47,8 @@ public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("name-pattern"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new RestrictUniqueIndexNaming(null); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SelectStarExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SelectStarExistsFactory.java index 66c9f077f3..f7900d4c41 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SelectStarExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SelectStarExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.SelectStarExists; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new SelectStarExists(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SqlAffectedRowsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SqlAffectedRowsFactory.java index abf5b4d2ad..bb61d12759 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SqlAffectedRowsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SqlAffectedRowsFactory.java @@ -21,6 +21,7 @@ import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLAffectedRowsExceedLimit; @@ -43,7 +44,9 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("allowed-max-sql-affected-count"); long maxSqlAffectedRows = DEFAULT_MAX_SQL_AFFECTED_ROWS; if (parameters != null && !parameters.isEmpty() && parameters.get(key) != null) { diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SyntaxErrorExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SyntaxErrorExistsFactory.java index e062d99382..291f00c321 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SyntaxErrorExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/SyntaxErrorExistsFactory.java @@ -16,10 +16,8 @@ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.SyntaxErrorExists; @@ -34,7 +32,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new SyntaxErrorExists(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TableNameInBlackListFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TableNameInBlackListFactory.java index db362a9e07..8f57e64011 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TableNameInBlackListFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TableNameInBlackListFactory.java @@ -19,8 +19,8 @@ import java.util.List; import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.TableNameInBlackList; @@ -36,7 +36,8 @@ public SqlCheckRuleType getSupportsType() { @Override @SuppressWarnings("all") - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("black-list"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new TableNameInBlackList(new HashSet<>()); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooLongCharLengthFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooLongCharLengthFactory.java index 12a9327ee3..2193c855b1 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooLongCharLengthFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooLongCharLengthFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.TooLongCharLength; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("max-char-length"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new TooLongCharLength(1000); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyAlterStatementFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyAlterStatementFactory.java index 01421d05aa..5559215219 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyAlterStatementFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyAlterStatementFactory.java @@ -19,6 +19,7 @@ import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLTooManyAlterStatement; @@ -34,7 +35,9 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); + Map parameters = sqlCheckRuleContext.getParameters(); int max; String key = getParameterNameKey("max-alter-count"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnDefinitionFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnDefinitionFactory.java index a7e7ffdbb8..45b4af0b4e 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnDefinitionFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnDefinitionFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.TooManyColumnDefinition; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("max-column-definition-count"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new TooManyColumnDefinition(100); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnRefInIndexFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnRefInIndexFactory.java index 94523e8960..124024320b 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnRefInIndexFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnRefInIndexFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.TooManyColumnRefInIndex; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("max-column-ref-count"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new TooManyColumnRefInIndex(100); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnRefInPrimaryKeyFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnRefInPrimaryKeyFactory.java index 474c15603b..341b6d4de0 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnRefInPrimaryKeyFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyColumnRefInPrimaryKeyFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.TooManyColumnRefInPrimaryKey; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("max-column-ref-count"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new TooManyColumnRefInPrimaryKey(100); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyInExpressionFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyInExpressionFactory.java index 6984320baa..7c9dcb04f4 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyInExpressionFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyInExpressionFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.TooManyInExpression; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("max-in-expr-count"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new TooManyInExpression(200); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyOutOfLineIndexFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyOutOfLineIndexFactory.java index 28c48e8e60..f55851bf17 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyOutOfLineIndexFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyOutOfLineIndexFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.TooManyOutOfLineIndex; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("max-index-count"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new TooManyOutOfLineIndex(10); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyTableJoinFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyTableJoinFactory.java index 36faba529a..c7215689a2 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyTableJoinFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TooManyTableJoinFactory.java @@ -17,8 +17,8 @@ import java.util.Map; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.TooManyTableJoin; @@ -33,7 +33,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + Map parameters = sqlCheckRuleContext.getParameters(); String key = getParameterNameKey("max-join-table-count"); if (parameters == null || parameters.isEmpty() || parameters.get(key) == null) { return new TooManyTableJoin(10); diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TruncateTableExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TruncateTableExistsFactory.java index 1caadad998..62d4afd48c 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TruncateTableExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/TruncateTableExistsFactory.java @@ -15,10 +15,8 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.TruncateTableExists; @@ -33,7 +31,7 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { return new TruncateTableExists(); } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/Unable2JudgeAffectedRowsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/Unable2JudgeAffectedRowsFactory.java index 434cea6246..121741d27e 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/Unable2JudgeAffectedRowsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/Unable2JudgeAffectedRowsFactory.java @@ -15,12 +15,10 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - import org.springframework.jdbc.core.JdbcOperations; -import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.BaseAffectedRowsExceedLimit; @@ -42,10 +40,10 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { SqlAffectedRowsFactory sqlAffectedRowsFactory = new SqlAffectedRowsFactory(this.jdbc); BaseAffectedRowsExceedLimit targetRule = (BaseAffectedRowsExceedLimit) sqlAffectedRowsFactory - .generate(dialectType, parameters); + .generate(sqlCheckRuleContext); return new Unable2JudgeAffectedRows(targetRule); } } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ZeroFillExistsFactory.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ZeroFillExistsFactory.java index 2f6e47ff34..e8ef8fc95f 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ZeroFillExistsFactory.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/factory/ZeroFillExistsFactory.java @@ -15,10 +15,9 @@ */ package com.oceanbase.odc.service.sqlcheck.factory; -import java.util.Map; - import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.model.SqlCheckRuleType; import com.oceanbase.odc.service.sqlcheck.rule.MySQLZeroFillExists; @@ -33,7 +32,8 @@ public SqlCheckRuleType getSupportsType() { } @Override - public SqlCheckRule generate(@NonNull DialectType dialectType, Map parameters) { + public SqlCheckRule generate(@NonNull SqlCheckRuleContext sqlCheckRuleContext) { + DialectType dialectType = sqlCheckRuleContext.getDialectType(); return (dialectType.isMysql() || dialectType.isDoris()) ? new MySQLZeroFillExists() : null; } diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/MySQLOfflineDdlExists.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/MySQLOfflineDdlExists.java index d2779d438d..85a912337f 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/MySQLOfflineDdlExists.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/MySQLOfflineDdlExists.java @@ -16,18 +16,25 @@ package com.oceanbase.odc.service.sqlcheck.rule; import java.io.StringReader; +import java.math.BigDecimal; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.function.Function; +import java.util.function.Supplier; import java.util.stream.Collectors; import java.util.stream.Stream; import org.apache.commons.collections4.CollectionUtils; import org.springframework.jdbc.core.JdbcOperations; +import com.oceanbase.odc.common.util.StringUtils; +import com.oceanbase.odc.common.util.VersionUtils; import com.oceanbase.odc.core.shared.constant.DialectType; import com.oceanbase.odc.service.sqlcheck.SqlCheckContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; @@ -38,11 +45,16 @@ import com.oceanbase.tools.sqlparser.statement.Statement; import com.oceanbase.tools.sqlparser.statement.alter.table.AlterTable; import com.oceanbase.tools.sqlparser.statement.alter.table.AlterTableAction; +import com.oceanbase.tools.sqlparser.statement.common.CharacterType; +import com.oceanbase.tools.sqlparser.statement.common.DataType; +import com.oceanbase.tools.sqlparser.statement.common.NumberType; +import com.oceanbase.tools.sqlparser.statement.createtable.ColumnAttributes; import com.oceanbase.tools.sqlparser.statement.createtable.ColumnDefinition; import com.oceanbase.tools.sqlparser.statement.createtable.CreateTable; import com.oceanbase.tools.sqlparser.statement.createtable.GenerateOption.Type; import com.oceanbase.tools.sqlparser.statement.createtable.InLineConstraint; import com.oceanbase.tools.sqlparser.statement.createtable.OutOfLineConstraint; +import com.oceanbase.tools.sqlparser.statement.createtable.TableOptions; import com.oceanbase.tools.sqlparser.statement.droptable.DropTable; import com.oceanbase.tools.sqlparser.statement.expression.ColumnReference; import com.oceanbase.tools.sqlparser.statement.truncate.TruncateTable; @@ -56,13 +68,41 @@ * @date 2024-03-05 21:12 * @since ODC_release_4.2.4 * @ref https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000000252799 + * @ref https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000002017083 */ public class MySQLOfflineDdlExists implements SqlCheckRule { + // compatible map + // array[0] represent ranking + // array[1] represent default precision + private static final Map INTEGER_RANKING_MAP = new HashMap() { + { + put("BOOL", new int[] {0, 1}); + put("BOOLEAN", new int[] {0, 1}); + put("TINYINT", new int[] {1, 4}); + put("SMALLINT", new int[] {2, 6}); + put("MEDIUMINT", new int[] {4, 9}); + put("INT", new int[] {4, 11}); + put("INTEGER", new int[] {4, 11}); + put("BIGINT", new int[] {5, 20}); + } + }; + + private static final int[] INVALID_INTEGER_RANKING_VALUE = new int[] {-1, 0}; + + private static final Map TEXT_RANKING_MAP = new HashMap() { + { + put("TEXT", 0); + put("MEDIUMTEXT", 1); + put("LONGTEXT", 2); + } + }; private final JdbcOperations jdbcOperations; + private final Supplier dbVersionSupplier; - public MySQLOfflineDdlExists(JdbcOperations jdbcOperations) { + public MySQLOfflineDdlExists(Supplier dbVersionSupplier, JdbcOperations jdbcOperations) { this.jdbcOperations = jdbcOperations; + this.dbVersionSupplier = dbVersionSupplier; } @Override @@ -75,13 +115,14 @@ public List check(@NonNull Statement statement, @NonNull SqlChec if (statement instanceof AlterTable) { AlterTable alterTable = (AlterTable) statement; CreateTable createTable = getTable(alterTable.getSchema(), alterTable.getTableName(), context); + String dbVersion = getDBVersion(); return alterTable.getAlterTableActions().stream().flatMap(action -> { List violations = new ArrayList<>(); violations.addAll(addColumnInLocation(statement, action)); violations.addAll(changeColumnInLocation(statement, action)); violations.addAll(addAutoIncrementColumn(statement, action)); violations.addAll(changeColumnToAutoIncrement(statement, createTable, action)); - violations.addAll(changeColumnDataType(statement, createTable, action)); + violations.addAll(changeColumnDataType(dbVersion, statement, createTable, action)); violations.addAll(changeColumnToPrimaryKey(createTable, statement, action)); violations.addAll(addOrDropStoredVirtualColumn(statement, action)); violations.addAll(dropColumn(statement, action)); @@ -102,6 +143,16 @@ public List check(@NonNull Statement statement, @NonNull SqlChec return Collections.emptyList(); } + protected String getDBVersion() { + String version = null; + try { + // get version failed, return null version + version = dbVersionSupplier == null ? null : dbVersionSupplier.get(); + } catch (Throwable e) { + } + return version; + } + protected List addColumnInLocation(Statement statement, AlterTableAction action) { return addColumn(action, definition -> { if (definition.getLocation() != null) { @@ -112,11 +163,17 @@ protected List addColumnInLocation(Statement statement, AlterTab }); } - protected List changeColumnDataType(Statement statement, CreateTable target, + protected List changeColumnDataType(String dbVersion, Statement statement, CreateTable target, AlterTableAction action) { + boolean isOb4x = VersionUtils.isGreaterThan(dbVersion, "4.0.0"); return changeColumn(action, changed -> { ColumnDefinition origin = extractColumnDefFrom(target, changed.getColumnReference()); - if (origin == null || Objects.equals(origin.getDataType(), changed.getDataType())) { + // only ob 4.x check online feature + if (isOb4x) { + if (isOnLineDDL(origin, changed, target.getTableOptions())) { + return null; + } + } else if (origin == null || Objects.equals(origin.getDataType(), changed.getDataType())) { return null; } return SqlCheckUtil.buildViolation(statement.getText(), action, getType(), @@ -124,6 +181,215 @@ protected List changeColumnDataType(Statement statement, CreateT }); } + + // check if data type change is online ddl + // 1. modify （add/remove/change）default value + // 2. change null flag null / not null + // 3. increase precision of char/varchar/text/number + protected boolean isOnLineDDL(ColumnDefinition origin, ColumnDefinition target, TableOptions tableOptions) { + // actually origin should not be bull + DataType originDataType = origin.getDataType(); + DataType targetDataType = target.getDataType(); + // check attribute + if (isAttributeChanged(origin, target)) { + return false; + } + // check foreign key constraint define, reference and be referenced + if (!objectEquals(origin.getForeignReference(), target.getForeignReference()) + || !objectEquals(origin.getGenerateOption(), target.getGenerateOption())) { + return false; + } + return isDataTypePrecisionExtend(originDataType, targetDataType, tableOptions) + || isDataTypeCompatible(originDataType, targetDataType); + } + + protected boolean isAttributeChanged(ColumnDefinition origin, ColumnDefinition target) { + ColumnAttributes originAttributes = origin.getColumnAttributes(); + ColumnAttributes targetAttributes = target.getColumnAttributes(); + if (!objectEquals(getField(originAttributes, ColumnAttributes::getAutoIncrement), + getField(targetAttributes, ColumnAttributes::getAutoIncrement))) { + // auto increment change not support + return true; + } else if (!objectEquals(getField(originAttributes, ColumnAttributes::getCollation), + getField(targetAttributes, ColumnAttributes::getCollation))) { + // collation change not support + return true; + } else if (!collectionEquals(getField(originAttributes, ColumnAttributes::getForeignConstraints), + getField(targetAttributes, ColumnAttributes::getForeignConstraints))) { + // inline constraint changed + return true; + } else { + // check constraint changed + return !collectionEquals(getField(originAttributes, ColumnAttributes::getCheckConstraints), + getField(targetAttributes, ColumnAttributes::getCheckConstraints)); + } + } + + private static > int compare(T origin, T target) { + if (null == origin && null == target) { + return 0; + } + // default precision not decided, always return 1 mean shrink + if (null == origin || null == target) { + return 1; + } + return origin.compareTo(target); + } + + private static boolean objectEquals(T origin, T target) { + if (null == origin && null == target) { + return true; + } + if (null == origin || null == target) { + return false; + } + return origin.equals(target); + } + + private static boolean collectionEquals(T origin, T target) { + boolean originEmpty = CollectionUtils.isEmpty(origin); + boolean targetEmpty = CollectionUtils.isEmpty(target); + if (originEmpty && targetEmpty) { + return true; + } + if (originEmpty || targetEmpty) { + return false; + } + return CollectionUtils.isEqualCollection(origin, target); + } + + private static T getField(ColumnAttributes attributes, Function valueSupplier) { + if (null == attributes) { + return null; + } + return valueSupplier.apply(attributes); + } + + /** + * only check number, varchar, char type + * + * @return + */ + protected boolean isDataTypePrecisionExtend(DataType origin, DataType target, TableOptions tableOptions) { + if (!StringUtils.equalsIgnoreCase(origin.getName(), target.getName()) + && !(isDecimalDataType(origin) && isDecimalDataType(target))) { + return false; + } + if (origin instanceof NumberType && target instanceof NumberType) { + // compare number type with same type name + return isNumberExtend((NumberType) origin, (NumberType) target); + } else if (origin instanceof CharacterType && target instanceof CharacterType) { + // compare character type + CharacterType originCharacter = (CharacterType) origin; + CharacterType targetCharacter = (CharacterType) target; + if (!isCharsetAndCollationCompatible(originCharacter, targetCharacter, tableOptions) + || !StringUtils.equalsIgnoreCase(originCharacter.getLengthOption(), + targetCharacter.getLengthOption())) { + return false; + } + return compare(originCharacter.getLength(), (targetCharacter.getLength())) <= 0; + } else { + return false; + } + } + + protected boolean isNumberExtend(NumberType originNumber, NumberType targetNumber) { + if (!objectEquals(originNumber.getSigned(), targetNumber.getSigned()) + || originNumber.isStarPresicion() != targetNumber.isStarPresicion() + || originNumber.isZeroFill() != targetNumber.isZeroFill()) { + return false; + } + // decimal(10, 4) -> decimal(10, 5) also a offline ddl + return compare(originNumber.getScale() == null ? new BigDecimal(0) : originNumber.getScale(), + targetNumber.getScale() == null ? new BigDecimal(0) : targetNumber.getScale()) == 0 + && compare(getDefaultPrecision(originNumber), getDefaultPrecision(targetNumber)) <= 0; + } + + protected BigDecimal getDefaultPrecision(NumberType number) { + if (number.getPrecision() != null) { + return number.getPrecision(); + } + int precision = + INTEGER_RANKING_MAP.getOrDefault(number.getName().toUpperCase(), INVALID_INTEGER_RANKING_VALUE)[1]; + return new BigDecimal(precision); + } + + + // assume table's default charset gbk, default collate gbk_bin. + // for create table column definition '`c6` varchar(60) COLLATE gbk_bin'. + // 'modify c6 varchar(80) charset gbk' is offline ddl. + // 'modify c6 varchar(80) charset gbk collate gbk_bin' is online ddl. + // 'modify c6 varchar(80) collate gbk_bin' is online ddl. + // 'modify c6 varchar(80)' is online ddl. + // for create table column definition '`c6` varchar(60) charset gbk'. + // 'modify c6 varchar(120) charset gbk' is online ddl. + // 'modify c6 varchar(120) charset gbk COLLATE gbk_bin' is offline ddl. + // 'modify c6 varchar(120) collate gbk_bin' is offline ddl. + // 'modify c6 varchar(120)' is offline ddl. + // so the point is collate change compare, if collate changed in ddl definition, it must be a + // offline ddl modify ddl charset. + // if collate can derived from table option depends on if charset is provided. + protected boolean isCharsetAndCollationCompatible(CharacterType origin, CharacterType target, + TableOptions tableOptions) { + // first check collation, collation should not be derived if charset provided + String originCollation = getCollationDependsOnCharset(origin, tableOptions.getCollation()); + String targetCollation = getCollationDependsOnCharset(target, tableOptions.getCollation()); + if (!StringUtils.equalsIgnoreCase(originCollation, targetCollation)) { + return false; + } + // check charset + String originCharset = getOrDefault(origin, CharacterType::getCharset, tableOptions.getCharset()); + String targetCharset = getOrDefault(target, CharacterType::getCharset, tableOptions.getCharset()); + return StringUtils.equalsIgnoreCase(originCharset, targetCharset); + } + + protected String getCollationDependsOnCharset(CharacterType characterType, String defaultCollation) { + String collation = null; + if (StringUtils.isEmpty(characterType.getCharset())) { + // if collation and charset not supplied, use given or default collation + collation = getOrDefault(characterType, CharacterType::getCollation, defaultCollation); + } else { + // charset provided, collation not derived from table option + collation = characterType.getCollation(); + } + return collation; + } + + protected String getOrDefault(CharacterType characterType, Function valueFunc, + String defaultValue) { + String value = valueFunc.apply(characterType); + if (StringUtils.isEmpty(value)) { + value = defaultValue; + } + return value; + } + + protected boolean isDecimalDataType(DataType dataType) { + return StringUtils.equalsIgnoreCase(dataType.getName(), "DECIMAL") + || StringUtils.equalsIgnoreCase(dataType.getName(), "DEC") + || StringUtils.equalsIgnoreCase(dataType.getName(), "NUMBER"); + } + + protected boolean isDataTypeCompatible(DataType origin, DataType target) { + if (origin instanceof NumberType && target instanceof NumberType) { + // check integer + int originRanking = + INTEGER_RANKING_MAP.getOrDefault(origin.getName().toUpperCase(), INVALID_INTEGER_RANKING_VALUE)[0]; + int targetRanking = + INTEGER_RANKING_MAP.getOrDefault(target.getName().toUpperCase(), INVALID_INTEGER_RANKING_VALUE)[0]; + // type, scale and precision should be extended as well + return originRanking >= 0 && targetRanking >= 0 && originRanking <= targetRanking + && isNumberExtend((NumberType) origin, (NumberType) target); + } else if (origin instanceof CharacterType && target instanceof CharacterType) { + // check integer + int originRanking = TEXT_RANKING_MAP.getOrDefault(origin.getName().toUpperCase(), -1); + int targetRanking = TEXT_RANKING_MAP.getOrDefault(target.getName().toUpperCase(), -1); + return originRanking >= 0 && targetRanking >= 0 && originRanking <= targetRanking; + } else { + return false; + } + } + protected List changePartition(Statement statement, AlterTableAction action) { if (action.getModifyPartition() != null) { return Collections.singletonList(SqlCheckUtil.buildViolation(statement.getText(), diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/OracleOfflineDdlExists.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/OracleOfflineDdlExists.java index 01d940d5f4..fb7dbfd485 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/OracleOfflineDdlExists.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/OracleOfflineDdlExists.java @@ -21,6 +21,7 @@ import java.util.Collections; import java.util.List; import java.util.Objects; +import java.util.function.Supplier; import java.util.stream.Collectors; import org.springframework.jdbc.core.JdbcOperations; @@ -50,8 +51,8 @@ */ public class OracleOfflineDdlExists extends MySQLOfflineDdlExists { - public OracleOfflineDdlExists(JdbcOperations jdbcOperations) { - super(jdbcOperations); + public OracleOfflineDdlExists(Supplier dbVersionSupplier, JdbcOperations jdbcOperations) { + super(dbVersionSupplier, jdbcOperations); } @Override diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/SqlCheckRules.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/SqlCheckRules.java index 03ab0de64a..ebc14ff50d 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/SqlCheckRules.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/SqlCheckRules.java @@ -34,6 +34,7 @@ import com.oceanbase.odc.service.regulation.ruleset.model.RuleMetadata; import com.oceanbase.odc.service.regulation.ruleset.model.RuleType; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; +import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; import com.oceanbase.odc.service.sqlcheck.factory.ColumnCalculationFactory; import com.oceanbase.odc.service.sqlcheck.factory.ColumnCharsetExistsFactory; @@ -162,17 +163,21 @@ public static List getAllFactories(DialectType dialectType, return rules; } - public static List getAllDefaultRules(JdbcOperations jdbc, @NonNull DialectType dialectType) { + public static List getAllDefaultRules(JdbcOperations jdbc, Supplier dbVersionSupplier, + @NonNull DialectType dialectType) { return SqlCheckRules.getAllFactories(dialectType, jdbc).stream() - .map(f -> f.generate(dialectType, null)).filter(Objects::nonNull).collect(Collectors.toList()); + .map(f -> f.generate(SqlCheckRuleContext.create(dbVersionSupplier, dialectType, null))) + .filter(Objects::nonNull) + .collect(Collectors.toList()); } - public static SqlCheckRule createByRule(JdbcOperations jdbc, + public static SqlCheckRule createByRule(JdbcOperations jdbc, Supplier dbVersionSupplier, @NonNull DialectType dialectType, @NonNull Rule rule) { - return createByRule(getAllFactories(dialectType, jdbc), dialectType, rule); + return createByRule(getAllFactories(dialectType, jdbc), dbVersionSupplier, dialectType, rule); } public static SqlCheckRule createByRule(@NonNull List candidates, + Supplier dbVersionSupplier, @NonNull DialectType dialectType, @NonNull Rule rule) { RuleMetadata metadata = rule.getMetadata(); Validate.notNull(metadata, "RuleMetadata can not be null"); @@ -197,7 +202,9 @@ public static SqlCheckRule createByRule(@NonNull List candi throw new UnsupportedOperationException("Not support yet, " + sqlCheckRuleType.getLocalizedName()); } try { - SqlCheckRule target = factory.get().generate(dialectType, rule.getProperties()); + SqlCheckRule target = + factory.get() + .generate(SqlCheckRuleContext.create(dbVersionSupplier, dialectType, rule.getProperties())); return target == null ? null : new SqlCheckRuleWrapper(target, rule.getAppliedDialectTypes()); } catch (Exception e) { return null; diff --git a/server/odc-service/src/main/java/com/oceanbase/odc/service/task/base/precheck/PreCheckTask.java b/server/odc-service/src/main/java/com/oceanbase/odc/service/task/base/precheck/PreCheckTask.java index 9f5a2ea994..32983af5ae 100644 --- a/server/odc-service/src/main/java/com/oceanbase/odc/service/task/base/precheck/PreCheckTask.java +++ b/server/odc-service/src/main/java/com/oceanbase/odc/service/task/base/precheck/PreCheckTask.java @@ -24,6 +24,7 @@ import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.function.Supplier; import java.util.stream.Collectors; import org.apache.commons.collections4.CollectionUtils; @@ -60,6 +61,7 @@ import com.oceanbase.odc.service.sqlcheck.SqlCheckContext; import com.oceanbase.odc.service.sqlcheck.SqlCheckRule; import com.oceanbase.odc.service.sqlcheck.SqlCheckRuleFactory; +import com.oceanbase.odc.service.sqlcheck.SqlCheckUtil; import com.oceanbase.odc.service.sqlcheck.model.CheckViolation; import com.oceanbase.odc.service.sqlcheck.rule.SqlCheckRules; import com.oceanbase.odc.service.task.base.TaskBase; @@ -250,7 +252,8 @@ private List checkViolations(List sqls) { SqlCheckContext checkContext = new SqlCheckContext((long) sqls.size()); try (SingleConnectionDataSource dataSource = (SingleConnectionDataSource) factory.getDataSource()) { JdbcTemplate jdbc = new JdbcTemplate(dataSource); - List checkRules = getRules(rules, config.getDialectType(), jdbc); + List checkRules = + getRules(rules, () -> SqlCheckUtil.getDbVersion(config, dataSource), config.getDialectType(), jdbc); DefaultSqlChecker sqlChecker = new DefaultSqlChecker(config.getDialectType(), null, checkRules); List checkViolations = new ArrayList<>(); for (OffsetString sql : sqls) { @@ -262,7 +265,8 @@ private List checkViolations(List sqls) { } } - private List getRules(List rules, @NonNull DialectType dialectType, + private List getRules(List rules, Supplier dbVersionSupplier, + @NonNull DialectType dialectType, @NonNull JdbcOperations jdbc) { if (CollectionUtils.isEmpty(rules)) { return Collections.emptyList(); @@ -276,7 +280,7 @@ private List getRules(List rules, @NonNull DialectType diale return Objects.equals(metadata.getType(), RuleType.SQL_CHECK); }).map(rule -> { try { - return SqlCheckRules.createByRule(candidates, dialectType, rule); + return SqlCheckRules.createByRule(candidates, dbVersionSupplier, dialectType, rule); } catch (Exception e) { return null; } diff --git a/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/MySQLCheckerTest.java b/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/MySQLCheckerTest.java index a42c7702a6..ca031bf413 100644 --- a/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/MySQLCheckerTest.java +++ b/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/MySQLCheckerTest.java @@ -19,6 +19,7 @@ import java.util.Collections; import java.util.HashSet; import java.util.List; +import java.util.function.Supplier; import java.util.stream.Collectors; import org.junit.Assert; @@ -92,6 +93,8 @@ */ public class MySQLCheckerTest { + private Supplier defaulDbVersionSupplier = () -> "4.2.5"; + @Rule public final ExpectedException exceptionRule = ExpectedException.none(); @@ -1152,7 +1155,7 @@ public void check_offlineDdl_violationGenerated() { Mockito.when(jdbcTemplate.queryForObject(Mockito.anyString(), Mockito.any(RowMapper.class))) .thenReturn(sqls[4]); DefaultSqlChecker sqlChecker = new DefaultSqlChecker(DialectType.OB_MYSQL, - null, Collections.singletonList(new MySQLOfflineDdlExists(jdbcTemplate))); + null, Collections.singletonList(new MySQLOfflineDdlExists(() -> "3.2.1", jdbcTemplate))); List actual = sqlChecker.check(toOffsetString(sqls), null); SqlCheckRuleType type = SqlCheckRuleType.OFFLINE_SCHEMA_CHANGE_EXISTS; @@ -1171,6 +1174,92 @@ public void check_offlineDdl_violationGenerated() { Assert.assertEquals(expect, actual); } + @Test + public void check_offlineDdl_Ob4xModifyDataType_violationGenerated() { + String createTableSql = "create table ddltest(id int not null primary key," + + "c1 int default 123," + + "c11 int GENERATED ALWAYS AS (c1 + 1)," + + "c2 bigint comment 'this is com' check (c2 > 10)," + + "c3 varchar(10) default null," + + "c33 varchar(10) collate utf8mb4_bin default null," + + "c333 varchar(10) charset utf8mb4 default null," + + "c4 text(20)," + + "c5 dec(10, 1) comment 'this is com'," + + " foreign key (c2) references test2(id)," + + " check(c1 > c2)" + + ") DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_bin"; + String[] sqls = { + // alarm section + "alter table ddltest modify c1 bigint(10) default 123", // shrink precision + "alter table ddltest modify c1 int(10) default 234", // shrink precision + "alter table ddltest modify c1 varchar(20) default '123'", // change type + "alter table ddltest modify c11 int GENERATED ALWAYS AS (c1 + 2)", // change generate option + "alter table ddltest modify c11 int", // remove generate option + "alter table ddltest modify c2 bigint comment 'this is com'", // remove check func + "alter table ddltest modify c3 varchar(10) charset gbk", // change charset + "alter table ddltest modify c3 varchar(10) collate gbk_bin", // change collate + "alter table ddltest modify c3 varchar(64) check (c3 is not null)", // add check + "alter table ddltest modify c5 decimal(5, 1) default 'this is com'", // shrink precision + "alter table ddltest modify c5 decimal(10, 2) default 'this is com'", // change scale + "alter table ddltest modify c333 varchar(10) charset utf8mb4 collate utf8mb4_bin", // collate change + "alter table ddltest modify c333 varchar(10) collate utf8mb4_bin", // collate change + "alter table ddltest modify c333 varchar(20)", // collate change + "alter table ddltest modify c33 varchar(10) charset utf8mb4", // collate change + + // not alarm section + "alter table ddltest modify c1 bigint default 123", // extend precision + "alter table ddltest modify c1 int default 234", // change default value + "alter table ddltest modify c1 int default 123 comment 'new com'", // add comment + "alter table ddltest modify c3 varchar(64)", // extend precision + "alter table ddltest modify c4 mediumtext", // extend precision + "alter table ddltest modify c33 varchar(10) charset utf8mb4 collate utf8mb4_bin", // collate not change + "alter table ddltest modify c33 varchar(10) collate utf8mb4_bin", // collate not change + "alter table ddltest modify c33 varchar(30)", // collate not change + "alter table ddltest modify c333 varchar(10) charset utf8mb4", // collate not change + }; + JdbcTemplate jdbcTemplate = Mockito.mock(JdbcTemplate.class); + Mockito.when(jdbcTemplate.queryForObject(Mockito.anyString(), Mockito.any(RowMapper.class))) + .thenReturn(createTableSql); + DefaultSqlChecker sqlChecker = new DefaultSqlChecker(DialectType.OB_MYSQL, + null, Collections.singletonList(new MySQLOfflineDdlExists(defaulDbVersionSupplier, jdbcTemplate))); + List actual = sqlChecker.check(toOffsetString(sqls), null); + + SqlCheckRuleType type = SqlCheckRuleType.OFFLINE_SCHEMA_CHANGE_EXISTS; + CheckViolation c1 = + new CheckViolation(sqls[0], 1, 20, 20, 51, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c2 = + new CheckViolation(sqls[1], 1, 20, 20, 48, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c3 = + new CheckViolation(sqls[2], 1, 20, 20, 54, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c4 = + new CheckViolation(sqls[3], 1, 20, 20, 62, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c5 = + new CheckViolation(sqls[4], 1, 20, 20, 33, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c6 = + new CheckViolation(sqls[5], 1, 20, 20, 57, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c7 = + new CheckViolation(sqls[6], 1, 20, 20, 52, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c8 = + new CheckViolation(sqls[7], 1, 20, 20, 56, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c9 = + new CheckViolation(sqls[8], 1, 20, 20, 63, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c10 = + new CheckViolation(sqls[9], 1, 20, 20, 64, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c11 = + new CheckViolation(sqls[10], 1, 20, 20, 65, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c12 = + new CheckViolation(sqls[11], 1, 20, 20, 78, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c13 = + new CheckViolation(sqls[12], 1, 20, 20, 62, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c14 = + new CheckViolation(sqls[13], 1, 20, 20, 42, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + CheckViolation c15 = + new CheckViolation(sqls[14], 1, 20, 20, 57, type, 0, new Object[] {"MODIFY COLUMN DATA TYPE"}); + + List expect = Arrays.asList(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15); + Assert.assertEquals(expect, actual); + } + @Test public void check_restrictIndexType_violationGenerated() { String[] sqls = new String[] { @@ -1349,7 +1438,7 @@ public void check_PlExists_noViolationGenerated() { + " tid;\n" + "end; $$"; DefaultSqlChecker sqlChecker = new DefaultSqlChecker(DialectType.OB_MYSQL, "$$", - SqlCheckRules.getAllDefaultRules(null, DialectType.OB_MYSQL)); + SqlCheckRules.getAllDefaultRules(null, defaulDbVersionSupplier, DialectType.OB_MYSQL)); Assert.assertTrue(sqlChecker.check(sql).isEmpty()); } @@ -1366,7 +1455,7 @@ public void check_wrongPlExists_violationGenerated() { + " tid;\n" + "end; $$"; DefaultSqlChecker sqlChecker = new DefaultSqlChecker(DialectType.OB_MYSQL, "$$", - SqlCheckRules.getAllDefaultRules(null, DialectType.OB_MYSQL)); + SqlCheckRules.getAllDefaultRules(null, defaulDbVersionSupplier, DialectType.OB_MYSQL)); List actual = sqlChecker.check(sql); SqlCheckRuleType type = SqlCheckRuleType.SYNTAX_ERROR; diff --git a/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/OracleSqlCheckerTest.java b/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/OracleSqlCheckerTest.java index ad5474ea9a..854d1d7b3e 100644 --- a/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/OracleSqlCheckerTest.java +++ b/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/OracleSqlCheckerTest.java @@ -19,6 +19,7 @@ import java.util.Collections; import java.util.HashSet; import java.util.List; +import java.util.function.Supplier; import java.util.stream.Collectors; import org.junit.Assert; @@ -84,6 +85,7 @@ * @since ODC_release_4.1.0 */ public class OracleSqlCheckerTest { + private Supplier defaultVersionSupplier = () -> "10.1"; @Test public void check_sqlWithColumnLeftCalculation_violationGenerated() { @@ -1193,7 +1195,7 @@ public void check_offlineDdl_violationGenerated() { Mockito.when(jdbcTemplate.queryForObject(Mockito.anyString(), Mockito.any(RowMapper.class))) .thenReturn(sqls[4]); DefaultSqlChecker sqlChecker = new DefaultSqlChecker(DialectType.OB_ORACLE, - null, Collections.singletonList(new OracleOfflineDdlExists(jdbcTemplate))); + null, Collections.singletonList(new OracleOfflineDdlExists(defaultVersionSupplier, jdbcTemplate))); List actual = sqlChecker.check(toOffsetString(sqls), null); SqlCheckRuleType type = SqlCheckRuleType.OFFLINE_SCHEMA_CHANGE_EXISTS; @@ -1236,7 +1238,7 @@ public void check_PlExists_noViolationGenerated() { + "return v1;\n" + "end; $$"; DefaultSqlChecker sqlChecker = new DefaultSqlChecker(DialectType.OB_ORACLE, "$$", - SqlCheckRules.getAllDefaultRules(null, DialectType.OB_ORACLE)); + SqlCheckRules.getAllDefaultRules(null, defaultVersionSupplier, DialectType.OB_ORACLE)); Assert.assertTrue(sqlChecker.check(sql).isEmpty()); } @@ -1248,7 +1250,7 @@ public void check_wrongPlExists_violationGenerated() { + "return v1;\n" + "end; $$"; DefaultSqlChecker sqlChecker = new DefaultSqlChecker(DialectType.OB_ORACLE, "$$", - SqlCheckRules.getAllDefaultRules(null, DialectType.OB_ORACLE)); + SqlCheckRules.getAllDefaultRules(null, defaultVersionSupplier, DialectType.OB_ORACLE)); List actual = sqlChecker.check(sql); SqlCheckRuleType type = SqlCheckRuleType.SYNTAX_ERROR; diff --git a/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRulesTest.java b/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRulesTest.java index 28acc809d3..48e1661f76 100644 --- a/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRulesTest.java +++ b/server/odc-service/src/test/java/com/oceanbase/odc/service/sqlcheck/SqlCheckRulesTest.java @@ -20,6 +20,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.function.Supplier; import org.junit.Assert; import org.junit.Test; @@ -43,11 +44,13 @@ * @since ODC_release_4.2.0 */ public class SqlCheckRulesTest { + private Supplier defaulDbVersionSupplier = () -> "4.2.5"; @Test public void createByRule_noParametersRule_createSucceed() { Rule rule = createRule(SqlCheckRuleType.INDEX_COLUMN_CALCULATION, null, null); - SqlCheckRule actual = SqlCheckRules.createByRule((JdbcOperations) null, DialectType.OB_ORACLE, rule); + SqlCheckRule actual = + SqlCheckRules.createByRule((JdbcOperations) null, () -> "4.2.5", DialectType.OB_ORACLE, rule); Assert.assertNotNull(actual); } @@ -57,7 +60,8 @@ public void createByRule_withParametersRule_createSucceed() { Map parameter = new HashMap<>(); parameter.put(factory.getParameterNameKey("max-in-expr-count"), 12345); Rule rule = createRule(SqlCheckRuleType.TOO_MANY_IN_EXPR, parameter, null); - SqlCheckRule actual = SqlCheckRules.createByRule((JdbcOperations) null, DialectType.OB_MYSQL, rule); + SqlCheckRule actual = + SqlCheckRules.createByRule((JdbcOperations) null, defaulDbVersionSupplier, DialectType.OB_MYSQL, rule); Assert.assertNotNull(actual); } @@ -67,7 +71,8 @@ public void createByRule_supportNonDialect_createSucceed() { Map parameter = new HashMap<>(); parameter.put(factory.getParameterNameKey("max-in-expr-count"), 12345); Rule rule = createRule(SqlCheckRuleType.TOO_MANY_IN_EXPR, parameter, null); - SqlCheckRule actual = SqlCheckRules.createByRule((JdbcOperations) null, DialectType.OB_ORACLE, rule); + SqlCheckRule actual = + SqlCheckRules.createByRule((JdbcOperations) null, defaulDbVersionSupplier, DialectType.OB_ORACLE, rule); assert actual != null; Assert.assertTrue(actual.getSupportsDialectTypes().isEmpty()); } @@ -83,7 +88,8 @@ public void createByRule_constructBySet_createSucceed() { Map parameter = new HashMap<>(); parameter.putIfAbsent(factory.getParameterNameKey("datatype-names"), Arrays.asList("varchar2", "blob")); rule.setProperties(JsonUtils.fromJsonMap(JsonUtils.toJson(parameter), String.class, Object.class)); - SqlCheckRule actual = SqlCheckRules.createByRule((JdbcOperations) null, DialectType.OB_ORACLE, rule); + SqlCheckRule actual = + SqlCheckRules.createByRule((JdbcOperations) null, defaulDbVersionSupplier, DialectType.OB_ORACLE, rule); assert actual != null; Assert.assertEquals(factory.getSupportsType(), actual.getType()); } @@ -95,7 +101,8 @@ public void createByRule_supportOBMySQL_createSucceed() { parameter.put(factory.getParameterNameKey("max-in-expr-count"), 12345); Rule rule = createRule(SqlCheckRuleType.TOO_MANY_IN_EXPR, parameter, Collections.singletonList(DialectType.OB_MYSQL)); - SqlCheckRule actual = SqlCheckRules.createByRule((JdbcOperations) null, DialectType.OB_MYSQL, rule); + SqlCheckRule actual = + SqlCheckRules.createByRule((JdbcOperations) null, defaulDbVersionSupplier, DialectType.OB_MYSQL, rule); assert actual != null; Assert.assertEquals(Collections.singletonList(DialectType.OB_MYSQL), actual.getSupportsDialectTypes()); }