4

Author: zijiacj

server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/MySQLCheckRationalityForDBObjects.java

@@ -22,9 +22,13 @@
 import java.util.Set;
 import java.util.function.Supplier;
 
+import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.jdbc.core.ConnectionCallback;
 import org.springframework.jdbc.core.JdbcOperations;
 
+import com.oceanbase.odc.common.util.StringUtils;
 import com.oceanbase.odc.core.shared.constant.DialectType;
+import com.oceanbase.odc.service.plugin.SchemaPluginUtil;
 import com.oceanbase.odc.service.sqlcheck.SqlCheckContext;
 import com.oceanbase.odc.service.sqlcheck.SqlCheckRule;
 import com.oceanbase.odc.service.sqlcheck.SqlCheckUtil;
@@ -36,6 +40,14 @@
 import com.oceanbase.tools.dbbrowser.model.DBObjectIdentity;
 import com.oceanbase.tools.dbbrowser.model.DBObjectType;
 import com.oceanbase.tools.sqlparser.statement.Statement;
+import com.oceanbase.tools.sqlparser.statement.common.BraceBlock;
+import com.oceanbase.tools.sqlparser.statement.createtable.CreateTable;
+import com.oceanbase.tools.sqlparser.statement.select.ExpressionReference;
+import com.oceanbase.tools.sqlparser.statement.select.FromReference;
+import com.oceanbase.tools.sqlparser.statement.select.JoinReference;
+import com.oceanbase.tools.sqlparser.statement.select.NameReference;
+import com.oceanbase.tools.sqlparser.statement.select.Select;
+import com.oceanbase.tools.sqlparser.statement.select.SelectBody;
 
 import lombok.NonNull;
 
@@ -78,24 +90,66 @@ public List<CheckViolation> check(@NonNull Statement statement, @NonNull SqlChec
         if (allowedDBObjectTypes.contains(DBObjectType.TABLE.name())) {
             DBTableCheckRationalityChecker dbTableCheckRationalityChecker = new DBTableCheckRationalityChecker();
             // todo 获取需要校验存在的表对象
-            List<DBObjectIdentity> shouldExistedTable =
-                    dbTableCheckRationalityChecker.ExtractShouldExistedDBObjects(schemaSupplier, statement);
+            List<DBObjectIdentity> shouldExistedTables = new ArrayList<>();
+            if (statement.getClass() == Select.class) {
+                // todo 这里校验表对象存在的合理性
+                Select select = (Select) statement;
+                SelectBody selectBody = select.getSelectBody();
+                List<FromReference> froms = selectBody.getFroms();
+                // todo 获取需要校验存在的表对象
+                if (CollectionUtils.isNotEmpty(froms)) {
+                    for (FromReference from : froms) {
+                        if (null != from) {
+                            if (from.getClass() == NameReference.class) {
+                                NameReference nameReference = (NameReference) from;
+                                if (null != nameReference.getSchema()) {
+                                    shouldExistedTables
+                                        .add(DBObjectIdentity.of(nameReference.getSchema(), DBObjectType.TABLE,
+                                            StringUtils.unquoteMySqlIdentifier(nameReference.getRelation())));
+                                } else {
+                                    shouldExistedTables.add(DBObjectIdentity.of(schemaSupplier.get(), DBObjectType.TABLE,
+                                        StringUtils.unquoteMySqlIdentifier(nameReference.getRelation())));
+                                }
+                            } else if (from.getClass() == JoinReference.class) {
+
+                            } else if (from.getClass() == BraceBlock.class) {
+
+                            } else if (from.getClass() == ExpressionReference.class) {
+
+                            }
+                        }
+                    }
+                }
+            } else if (statement.getClass() == CreateTable.class) {
+
+            }
             // todo 校验表对象是否存在
-            for (DBObjectIdentity dbObjectIdentity : shouldExistedTable) {
-                Boolean existed = dbTableCheckRationalityChecker.checkObjectExistence(dbObjectIdentity, jdbcOperations);
+            for (DBObjectIdentity dbObjectIdentity : shouldExistedTables) {
+                Boolean existed = jdbcOperations
+                    .execute((ConnectionCallback<Boolean>) con -> SchemaPluginUtil.getTableExtension(
+                            DialectType.OB_MYSQL)
+                        .list(con,
+                            dbObjectIdentity.getSchemaName(), DBObjectType.TABLE)
+                        .stream().anyMatch(
+                            table -> table.getName().equals(dbObjectIdentity.getName())));
                 if (Boolean.FALSE.equals(existed)) {
                     checkViolationlist.add(
                             SqlCheckUtil.buildViolation(statement.getText(), statement, getType(),
                                     new Object[] {}));
                 }
             }
             // todo 获取需要检验不存在的表对象
-            List<DBObjectIdentity> shouldNotExistedTables =
-                    dbTableCheckRationalityChecker.ExtractShouldExistedDBObjects(schemaSupplier, statement);
+            List<DBObjectIdentity> shouldNotExistedTables = null;
+
             // todo 执行校验表对象不存在逻辑
-            for (DBObjectIdentity shouldNotExistedTable : shouldNotExistedTables) {
-                Boolean existed =
-                        dbTableCheckRationalityChecker.checkObjectNonExistence(shouldNotExistedTable, jdbcOperations);
+            for (DBObjectIdentity dbObjectIdentity : shouldNotExistedTables) {
+                Boolean existed = !jdbcOperations
+                    .execute((ConnectionCallback<Boolean>) con -> SchemaPluginUtil.getTableExtension(
+                            DialectType.OB_MYSQL)
+                        .list(con,
+                            dbObjectIdentity.getSchemaName(), DBObjectType.TABLE)
+                        .stream().anyMatch(
+                            table -> table.getName().equals(dbObjectIdentity.getName())));
                 if (Boolean.FALSE.equals(existed)) {
                     checkViolationlist.add(
                             SqlCheckUtil.buildViolation(statement.getText(), statement, getType(),

server/odc-service/src/main/java/com/oceanbase/odc/service/sqlcheck/rule/MySQLCheckRationalityForDBObjects1.java

@@ -54,8 +54,6 @@ public class MySQLCheckRationalityForDBObjects1 implements SqlCheckRule {
 
     private final JdbcOperations jdbcOperations;
 
-    List<DBObjectType> supportedDBObjectType = Arrays.asList(DBObjectType.TABLE, DBObjectType.COLUMN);
-
     public MySQLCheckRationalityForDBObjects1(Boolean supportedSimulation, Set<String> allowedDBObjectTypes, Supplier<String> schemaSupplier, JdbcOperations jdbcOperations) {
         this.supportedSimulation = supportedSimulation;
         this.allowedDBObjectTypes = allowedDBObjectTypes;
@@ -103,7 +101,7 @@ public List<CheckViolation> check(@NonNull Statement statement, @NonNull SqlChec
             }
         }
         // todo 这里校验列对象存在的合理性
-        else if (supportedDBObjectType.contains(DBObjectType.COLUMN)) {
+        else if (allowedDBObjectTypes.contains(DBObjectType.COLUMN)) {
             DBColumnCheckRationalityChecker dbColumnCheckRationalityChecker = new DBColumnCheckRationalityChecker();
             // todo 获取需要校验存在的表对象
             List<DBObjectIdentity> shouldExistedColumn =
@@ -131,7 +129,7 @@ else if (supportedDBObjectType.contains(DBObjectType.COLUMN)) {
                                     new Object[] {}));
                 }
             }
-        } else if (supportedDBObjectType.contains(DBObjectType.INDEX)) {
+        } else if (allowedDBObjectTypes.contains(DBObjectType.INDEX)) {
             // todo 这里校验索引对象存在的合理性
         }
         return checkViolationlist;