feature: support get table trigger from oracle (#191)

vran-dev · web-flow · commit 502214909427 · 2022-05-17T17:22:36.000+08:00
* feat:support get table trigger from oracle

* fix: trigger diff failed
diff --git a/core/src/main/java/com/databasir/core/domain/document/converter/DatabaseMetaConverter.java b/core/src/main/java/com/databasir/core/domain/document/converter/DatabaseMetaConverter.java
@@ -2,10 +2,7 @@
 
 import com.databasir.core.domain.document.data.TableDocumentResponse;
 import com.databasir.core.infrastructure.converter.JsonConverter;
-import com.databasir.core.meta.data.ColumnMeta;
-import com.databasir.core.meta.data.DatabaseMeta;
-import com.databasir.core.meta.data.IndexMeta;
-import com.databasir.core.meta.data.TableMeta;
+import com.databasir.core.meta.data.*;
 import com.databasir.dao.tables.pojos.*;
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
@@ -65,6 +62,9 @@ TableMeta of(TableDocumentPojo table,
     @Mapping(target = "columnNames", source = "pojo.columnNameArray")
     IndexMeta of(TableIndexDocumentPojo pojo);
 
+    @Mapping(target = "createAt", source = "pojo.triggerCreateAt")
+    TriggerMeta of(TableTriggerDocumentPojo pojo);
+
     List<TableMeta> of(List<TableDocumentResponse> table);
 
     TableMeta of(TableDocumentResponse table);
diff --git a/meta/src/main/java/com/databasir/core/meta/provider/MetaProviders.java b/meta/src/main/java/com/databasir/core/meta/provider/MetaProviders.java
@@ -3,6 +3,7 @@
 import com.databasir.core.meta.provider.jdbc.*;
 import com.databasir.core.meta.provider.maria.MariaTriggerMetaProvider;
 import com.databasir.core.meta.provider.mysql.MysqlTableTriggerMetaProvider;
+import com.databasir.core.meta.provider.oracle.OracleTriggerMetaProvider;
 import com.databasir.core.meta.provider.postgresql.PostgresqlTriggerMetaProvider;
 import com.databasir.core.meta.provider.sqlserver.SqlServerColumnMetaProvider;
 import com.databasir.core.meta.provider.sqlserver.SqlServerTableMetaProvider;
@@ -51,6 +52,9 @@ public static DatabaseMetaProvider of(Connection connection) {
         if (url.contains(":mariadb:")) {
             return mariaDB();
         }
+        if (url.contains(":oracle:")) {
+            return oracle();
+        }
         return jdbc();
     }
 
@@ -109,4 +113,18 @@ private static DatabaseMetaProvider mariaDB() {
         );
         return new JdbcDatabaseMetaProvider(tableMetaProvider);
     }
+
+    private static DatabaseMetaProvider oracle() {
+        var columnMetaProvider = new JdbcColumnMetaProvider();
+        var foreignKeyMetaProvider = new JdbcForeignKeyMetaProvider();
+        var indexMetaProvider = new JdbcIndexMetaProvider();
+        var triggerMetaProvider = new OracleTriggerMetaProvider();
+        var tableMetaProvider = new JdbcTableMetaProvider(
+                columnMetaProvider,
+                indexMetaProvider,
+                triggerMetaProvider,
+                foreignKeyMetaProvider
+        );
+        return new JdbcDatabaseMetaProvider(tableMetaProvider);
+    }
 }
diff --git a/meta/src/main/java/com/databasir/core/meta/provider/jdbc/JdbcIndexMetaProvider.java b/meta/src/main/java/com/databasir/core/meta/provider/jdbc/JdbcIndexMetaProvider.java
@@ -35,14 +35,17 @@ private List<IndexMeta> doCreateIndexDocs(Connection connection, TableCondition
             return indexMetas;
         }
 
-        Map<String, IndexMeta> pojoGroupByName = new HashMap<>();
+        Map<String, IndexMeta> metaGroupByName = new HashMap<>();
         try {
             while (indexResults.next()) {
                 Boolean nonUnique = indexResults.getBoolean("NON_UNIQUE");
                 String indexName = indexResults.getString("INDEX_NAME");
                 String columnName = indexResults.getString("COLUMN_NAME");
-                if (pojoGroupByName.containsKey(indexName)) {
-                    pojoGroupByName.get(indexName).getColumnNames().add(columnName);
+                if (indexName == null) {
+                    continue;
+                }
+                if (metaGroupByName.containsKey(indexName)) {
+                    metaGroupByName.get(indexName).getColumnNames().add(columnName);
                 } else {
                     List<String> columns = new ArrayList<>();
                     columns.add(columnName);
@@ -51,13 +54,13 @@ private List<IndexMeta> doCreateIndexDocs(Connection connection, TableCondition
                             .columnNames(columns)
                             .isUniqueKey(Objects.equals(nonUnique, false))
                             .build();
-                    pojoGroupByName.put(indexName, indexMeta);
+                    metaGroupByName.put(indexName, indexMeta);
                 }
             }
         } finally {
             indexResults.close();
         }
-        return new ArrayList<>(pojoGroupByName.values());
+        return new ArrayList<>(metaGroupByName.values());
     }
 
 }
diff --git a/meta/src/main/java/com/databasir/core/meta/provider/oracle/OracleTriggerMetaProvider.java b/meta/src/main/java/com/databasir/core/meta/provider/oracle/OracleTriggerMetaProvider.java
@@ -0,0 +1,64 @@
+package com.databasir.core.meta.provider.oracle;
+
+import com.databasir.core.meta.data.TriggerMeta;
+import com.databasir.core.meta.provider.TriggerMetaProvider;
+import com.databasir.core.meta.provider.condition.TableCondition;
+import lombok.extern.slf4j.Slf4j;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+@Slf4j
+public class OracleTriggerMetaProvider implements TriggerMetaProvider {
+    @Override
+    public List<TriggerMeta> selectTriggers(Connection connection, TableCondition condition) {
+        String sql = "SELECT trig.table_owner AS schema_name,\n"
+                + "       trig.table_name,\n"
+                + "       trig.owner AS trigger_schema_name,\n"
+                + "       trig.trigger_name,\n"
+                + "       trig.trigger_type,\n"
+                + "       trig.triggering_event,\n"
+                + "       trig.status,\n"
+                + "       trig.trigger_body AS script\n"
+                + "FROM sys.all_triggers trig\n"
+                + "         INNER JOIN sys.all_tables tab ON trig.table_owner = tab.owner\n"
+                + "    AND trig.table_name = tab.table_name\n"
+                + "WHERE trig.base_object_type = 'TABLE' AND trig.owner = ? AND trig.TABLE_NAME = ?";
+        try {
+            PreparedStatement preparedStatement = connection.prepareStatement(sql);
+            preparedStatement.setObject(1, condition.getSchemaName());
+            preparedStatement.setObject(2, condition.getTableName());
+            ResultSet results = preparedStatement.executeQuery();
+            List<TriggerMeta> triggers = new ArrayList<>();
+            while (results.next()) {
+                String status = results.getString("status");
+                String name = Objects.requireNonNullElse(results.getString("trigger_name"), "")
+                        + " ("
+                        + status
+                        + ")";
+                String statement = results.getString("script");
+                String timing = results.getString("trigger_type");
+                String manipulation = results.getString("triggering_event");
+                String created = "unknown";
+                TriggerMeta meta = TriggerMeta.builder()
+                        .name(name)
+                        .manipulation(manipulation)
+                        .timing(timing)
+                        .statement(statement)
+                        .createAt(created)
+                        .build();
+                triggers.add(meta);
+            }
+            return triggers;
+        } catch (SQLException e) {
+            log.warn("get trigger meta failed", e);
+            return Collections.emptyList();
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -35,14 +35,17 @@ private List<IndexMeta> doCreateIndexDocs(Connection connection, TableCondition`
`35`	`35`	`return indexMetas;`
`36`	`36`	`}`
`37`	`37`
`38`		`- Map<String, IndexMeta> pojoGroupByName = new HashMap<>();`
	`38`	`+ Map<String, IndexMeta> metaGroupByName = new HashMap<>();`
`39`	`39`	`try {`
`40`	`40`	`while (indexResults.next()) {`
`41`	`41`	`Boolean nonUnique = indexResults.getBoolean("NON_UNIQUE");`
`42`	`42`	`String indexName = indexResults.getString("INDEX_NAME");`
`43`	`43`	`String columnName = indexResults.getString("COLUMN_NAME");`
`44`		`- if (pojoGroupByName.containsKey(indexName)) {`
`45`		`- pojoGroupByName.get(indexName).getColumnNames().add(columnName);`
	`44`	`+ if (indexName == null) {`
	`45`	`+ continue;`
	`46`	`+ }`
	`47`	`+ if (metaGroupByName.containsKey(indexName)) {`
	`48`	`+ metaGroupByName.get(indexName).getColumnNames().add(columnName);`
`46`	`49`	`} else {`
`47`	`50`	`List<String> columns = new ArrayList<>();`
`48`	`51`	`columns.add(columnName);`
`@@ -51,13 +54,13 @@ private List<IndexMeta> doCreateIndexDocs(Connection connection, TableCondition`
`51`	`54`	`.columnNames(columns)`
`52`	`55`	`.isUniqueKey(Objects.equals(nonUnique, false))`
`53`	`56`	`.build();`
`54`		`- pojoGroupByName.put(indexName, indexMeta);`
	`57`	`+ metaGroupByName.put(indexName, indexMeta);`
`55`	`58`	`}`
`56`	`59`	`}`
`57`	`60`	`} finally {`
`58`	`61`	`indexResults.close();`
`59`	`62`	`}`
`60`		`- return new ArrayList<>(pojoGroupByName.values());`
	`63`	`+ return new ArrayList<>(metaGroupByName.values());`
`61`	`64`	`}`
`62`	`65`
`63`	`66`	`}`