Merge pull request #1436 from openai0229/fix-exportTableData

Chat2DB-Pro · web-flow · commit c8e5af33458e · 2024-06-21T18:59:26.000+08:00
fix-exportTableData
diff --git a/chat2db-server/chat2db-plugins/chat2db-clickhouse/src/main/java/ai/chat2db/plugin/clickhouse/ClickHouseDBManage.java b/chat2db-server/chat2db-plugins/chat2db-clickhouse/src/main/java/ai/chat2db/plugin/clickhouse/ClickHouseDBManage.java
@@ -55,7 +55,7 @@ private void exportTablesOrViewsOrDictionaries(Connection connection,String data
                             .append(";").append("\n").append(ddl).append(";").append("\n");
                     asyncContext.write(sqlBuilder.toString());
                     if (asyncContext.isContainsData() && dataFlag) {
-                        exportTableData(connection,schemaName, tableOrViewName, asyncContext);
+                        exportTableData(connection, databaseName,schemaName, tableOrViewName, asyncContext);
                     }
                 }
             }
diff --git a/chat2db-server/chat2db-plugins/chat2db-db2/src/main/java/ai/chat2db/plugin/db2/DB2DBManage.java b/chat2db-server/chat2db-plugins/chat2db-db2/src/main/java/ai/chat2db/plugin/db2/DB2DBManage.java
@@ -20,22 +20,22 @@ public class DB2DBManage extends DefaultDBManage implements DBManage {
 
     @Override
     public void exportDatabase(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {
-        exportTables(connection, schemaName, asyncContext);
+        exportTables(connection, databaseName, schemaName, asyncContext);
         exportViews(connection, schemaName, asyncContext);
         exportProceduresAndFunctions(connection, schemaName, asyncContext);
         exportTriggers(connection, schemaName, asyncContext);
     }
 
-    private void exportTables(Connection connection, String schemaName,  AsyncContext asyncContext) throws SQLException {
+    private void exportTables(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {
         try (ResultSet resultSet = connection.getMetaData().getTables(null, schemaName, null, new String[]{"TABLE", "SYSTEM TABLE"})) {
             while (resultSet.next()) {
-                exportTable(connection, schemaName, resultSet.getString("TABLE_NAME"), asyncContext);
+                exportTable(connection, databaseName, schemaName, resultSet.getString("TABLE_NAME"), asyncContext);
             }
         }
     }
 
 
-    private void exportTable(Connection connection, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {
+    private void exportTable(Connection connection, String databaseName, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {
         try {
             SQLExecutor.getInstance().execute(connection, SQLConstant.TABLE_DDL_FUNCTION_SQL, resultSet -> null);
         } catch (Exception e) {
@@ -48,7 +48,7 @@ private void exportTable(Connection connection, String schemaName, String tableN
                 sqlBuilder.append(resultSet.getString("sql")).append("\n");
                 asyncContext.write(sqlBuilder.toString());
                 if (asyncContext.isContainsData()) {
-                    exportTableData(connection, schemaName, tableName, asyncContext);
+                    exportTableData(connection, databaseName, schemaName, tableName, asyncContext);
                 }
             }
         }
diff --git a/chat2db-server/chat2db-plugins/chat2db-dm/src/main/java/ai/chat2db/plugin/dm/DMDBManage.java b/chat2db-server/chat2db-plugins/chat2db-dm/src/main/java/ai/chat2db/plugin/dm/DMDBManage.java
@@ -1,8 +1,5 @@
 package ai.chat2db.plugin.dm;
 
-import java.sql.*;
-import java.util.Objects;
-
 import ai.chat2db.spi.DBManage;
 import ai.chat2db.spi.jdbc.DefaultDBManage;
 import ai.chat2db.spi.model.AsyncContext;
@@ -13,6 +10,11 @@
 import org.apache.commons.lang3.ObjectUtils;
 import org.apache.commons.lang3.StringUtils;
 
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
 @Slf4j
 public class DMDBManage extends DefaultDBManage implements DBManage {
     private String format(String tableName) {
@@ -29,30 +31,30 @@ private String format(String tableName) {
 
     @Override
     public void exportDatabase(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {
-        exportTables(connection, schemaName, asyncContext);
+        exportTables(connection, databaseName, schemaName, asyncContext);
         exportViews(connection, schemaName, asyncContext);
         exportProcedures(connection, schemaName, asyncContext);
         exportTriggers(connection, schemaName, asyncContext);
     }
 
-    private void exportTables(Connection connection, String schemaName, AsyncContext asyncContext) throws SQLException {
+    private void exportTables(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {
         String sql = String.format("SELECT TABLE_NAME FROM ALL_TABLES where OWNER='%s' and TABLESPACE_NAME='MAIN'", schemaName);
         try (ResultSet resultSet = connection.createStatement().executeQuery(sql)) {
             while (resultSet.next()) {
                 String tableName = resultSet.getString("TABLE_NAME");
-                exportTable(connection, tableName, schemaName, asyncContext);
+                exportTable(connection, databaseName, tableName, schemaName, asyncContext);
             }
         }
     }
 
 
-    private void exportTable(Connection connection, String tableName, String schemaName, AsyncContext asyncContext) throws SQLException {
+    private void exportTable(Connection connection, String databaseName, String tableName, String schemaName, AsyncContext asyncContext) throws SQLException {
         String sql = """
-                SELECT
-                    (SELECT comments FROM user_tab_comments WHERE table_name = '%s') AS comments,
-                    (SELECT dbms_metadata.get_ddl('TABLE', '%s', '%s') FROM dual) AS ddl
-                FROM dual;
-                """;
+                     SELECT
+                         (SELECT comments FROM user_tab_comments WHERE table_name = '%s') AS comments,
+                         (SELECT dbms_metadata.get_ddl('TABLE', '%s', '%s') FROM dual) AS ddl
+                     FROM dual;
+                     """;
         try (Statement statement = connection.createStatement(); ResultSet resultSet = statement.executeQuery(String.format(sql, tableName, tableName, schemaName))) {
             String formatSchemaName = format(schemaName);
             String formatTableName = format(tableName);
@@ -70,14 +72,14 @@ private void exportTable(Connection connection, String tableName, String schemaN
                 exportTableColumnComment(connection, schemaName, tableName, asyncContext);
             }
             if (asyncContext.isContainsData()) {
-                exportTableData(connection, schemaName, tableName, asyncContext);
+                exportTableData(connection, databaseName, schemaName, tableName, asyncContext);
             }
         }
     }
 
     private void exportTableColumnComment(Connection connection, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {
         String sql = String.format("select COLNAME,COMMENT$ from SYS.SYSCOLUMNCOMMENTS\n" +
-                "where SCHNAME = '%s' and TVNAME = '%s'and TABLE_TYPE = 'TABLE';", schemaName, tableName);
+                                           "where SCHNAME = '%s' and TVNAME = '%s'and TABLE_TYPE = 'TABLE';", schemaName, tableName);
         try (ResultSet resultSet = connection.createStatement().executeQuery(sql)) {
             while (resultSet.next()) {
                 StringBuilder sqlBuilder = new StringBuilder();
diff --git a/chat2db-server/chat2db-plugins/chat2db-mysql/src/main/java/ai/chat2db/plugin/mysql/MysqlDBManage.java b/chat2db-server/chat2db-plugins/chat2db-mysql/src/main/java/ai/chat2db/plugin/mysql/MysqlDBManage.java
@@ -7,13 +7,14 @@
 import ai.chat2db.spi.sql.SQLExecutor;
 import org.springframework.util.StringUtils;
 
-import java.sql.*;
-import java.util.Objects;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 
 public class MysqlDBManage extends DefaultDBManage implements DBManage {
     @Override
     public void exportDatabase(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {
-        exportTables(connection, databaseName, asyncContext);
+        exportTables(connection, databaseName, schemaName, asyncContext);
         exportViews(connection, databaseName, asyncContext);
         exportProcedures(connection, asyncContext);
         exportTriggers(connection, asyncContext);
@@ -35,22 +36,22 @@ private void exportFunction(Connection connection, String functionName, AsyncCon
             if (resultSet.next()) {
                 StringBuilder sqlBuilder = new StringBuilder();
                 sqlBuilder.append("DROP FUNCTION IF EXISTS ").append(functionName).append(";").append("\n")
-                          .append(resultSet.getString("Create Function")).append(";").append("\n");
+                        .append(resultSet.getString("Create Function")).append(";").append("\n");
                 asyncContext.write(sqlBuilder.toString());
             }
         }
     }
 
-    private void exportTables(Connection connection, String databaseName, AsyncContext asyncContext) throws SQLException {
+    private void exportTables(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {
         try (ResultSet resultSet = connection.getMetaData().getTables(databaseName, null, null, new String[]{"TABLE", "SYSTEM TABLE"})) {
             while (resultSet.next()) {
-                exportTable(connection, resultSet.getString("TABLE_NAME"), asyncContext);
+                exportTable(connection, databaseName, schemaName, resultSet.getString("TABLE_NAME"), asyncContext);
             }
         }
     }
 
 
-    private void exportTable(Connection connection, String tableName, AsyncContext asyncContext) throws SQLException {
+    private void exportTable(Connection connection, String databaseName, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {
         String sql = String.format("show create table %s ", tableName);
         try (ResultSet resultSet = connection.createStatement().executeQuery(sql)) {
             if (resultSet.next()) {
@@ -59,7 +60,7 @@ private void exportTable(Connection connection, String tableName, AsyncContext a
                         .append(resultSet.getString("Create Table")).append(";").append("\n");
                 asyncContext.write(sqlBuilder.toString());
                 if (asyncContext.isContainsData()) {
-                    exportTableData(connection, null,tableName, asyncContext);
+                    exportTableData(connection, databaseName, schemaName, tableName, asyncContext);
                 }
             }
         }
@@ -143,7 +144,7 @@ public void updateProcedure(Connection connection, String databaseName, String s
         } catch (Exception e) {
             connection.rollback();
             throw new RuntimeException(e);
-        }finally {
+        } finally {
             connection.setAutoCommit(true);
         }
 
diff --git a/chat2db-server/chat2db-plugins/chat2db-oracle/src/main/java/ai/chat2db/plugin/oracle/OracleDBManage.java b/chat2db-server/chat2db-plugins/chat2db-oracle/src/main/java/ai/chat2db/plugin/oracle/OracleDBManage.java
@@ -30,29 +30,25 @@ public class OracleDBManage extends DefaultDBManage implements DBManage {
     private static String TRIGGER_DDL_SQL = "SELECT DBMS_METADATA.GET_DDL('TRIGGER', trigger_name) AS ddl FROM all_triggers WHERE owner = '%s' AND trigger_name = '%s'";
     private static String FUNCTION_DDL_SQL = "SELECT DBMS_METADATA.GET_DDL('FUNCTION', object_name) as ddl  FROM all_procedures WHERE owner = '%s' AND object_name = '%s'";
 
-    @Override
-    public void exportDatabaseData(Connection connection, String databaseName, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {
-        exportTableData(connection, tableName, asyncContext);
-    }
     public void exportDatabase(Connection connection, String databaseName, String schemaName,AsyncContext asyncContext) throws SQLException {
-        exportTables(connection, schemaName, asyncContext);
+        exportTables(connection,databaseName, schemaName, asyncContext);
         exportViews(connection, asyncContext, schemaName);
         exportProcedures(connection, schemaName, asyncContext);
         exportTriggers(connection, schemaName, asyncContext);
         exportFunctions(connection, schemaName, asyncContext);
     }
 
-    private void exportTables(Connection connection, String schemaName, AsyncContext asyncContext) throws SQLException {
+    private void exportTables(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {
         try (ResultSet resultSet = connection.getMetaData().getTables(null, schemaName, null, new String[]{"TABLE", "SYSTEM TABLE"})) {
             while (resultSet.next()) {
                 String tableName = resultSet.getString("TABLE_NAME");
-                exportTable(connection, schemaName, tableName, asyncContext);
+                exportTable(connection,databaseName, schemaName, tableName, asyncContext);
             }
         }
     }
 
 
-    private void exportTable(Connection connection, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {
+    private void exportTable(Connection connection, String databaseName, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {
         String sql = String.format(TABLE_DDL_SQL, schemaName, tableName);
         try (ResultSet resultSet = connection.createStatement().executeQuery(sql)) {
             if (resultSet.next()) {
@@ -64,7 +60,7 @@ private void exportTable(Connection connection, String schemaName, String tableN
             exportTableComments(connection, tableName, asyncContext);
             exportTableColumnsComments(connection, tableName, asyncContext);
             if (asyncContext.isContainsData()) {
-                exportTableData(connection, tableName, asyncContext);
+                exportTableData(connection,databaseName,schemaName, tableName, asyncContext);
             }
         }
     }
@@ -91,36 +87,6 @@ private void exportTableColumnsComments(Connection connection, String tableName,
         }
     }
 
-    private void exportTableData(Connection connection, String tableName, AsyncContext asyncContext) throws SQLException {
-        String sql = String.format("SELECT * FROM %s", tableName);
-        try (ResultSet resultSet = connection.createStatement().executeQuery(sql)) {
-            ResultSetMetaData metaData = resultSet.getMetaData();
-            int columnCount = metaData.getColumnCount();
-            while (resultSet.next()) {
-                StringBuilder sqlBuilder = new StringBuilder();
-                sqlBuilder.append("INSERT INTO ").append(tableName).append(" VALUES (");
-                for (int i = 1; i <= columnCount; i++) {
-                    String columnValue = resultSet.getString(i);
-                    if (Objects.isNull(columnValue)) {
-                        sqlBuilder.append("NULL");
-                    } else if (metaData.getColumnTypeName(i).equalsIgnoreCase("DATE")) {
-                        // 处理日期值格式
-                        columnValue = "TO_DATE('" + columnValue + "', 'YYYY-MM-DD HH24:MI:SS')";
-                        sqlBuilder.append(columnValue);
-                    } else {
-                        sqlBuilder.append("'").append(columnValue).append("'");
-                    }
-                    if (i < columnCount) {
-                        sqlBuilder.append(", ");
-                    }
-                }
-                sqlBuilder.append(");");
-                sqlBuilder.append("\n");
-                asyncContext.write(sqlBuilder.toString());
-            }
-        }
-    }
-
     private void exportViews(Connection connection, AsyncContext asyncContext, String schemaName) throws SQLException {
         try (ResultSet resultSet = connection.getMetaData().getTables(null, schemaName, null, new String[]{"VIEW"})) {
             while (resultSet.next()) {
diff --git a/chat2db-server/chat2db-plugins/chat2db-postgresql/src/main/java/ai/chat2db/plugin/postgresql/PostgreSQLDBManage.java b/chat2db-server/chat2db-plugins/chat2db-postgresql/src/main/java/ai/chat2db/plugin/postgresql/PostgreSQLDBManage.java
@@ -8,11 +8,13 @@
 import ai.chat2db.spi.sql.SQLExecutor;
 import org.apache.commons.lang3.StringUtils;
 
-import java.sql.*;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
 import java.util.ArrayList;
-import java.util.Objects;
 
-import static ai.chat2db.plugin.postgresql.consts.SQLConst.*;
+import static ai.chat2db.plugin.postgresql.consts.SQLConst.ENUM_TYPE_DDL_SQL;
 
 public class PostgreSQLDBManage extends DefaultDBManage implements DBManage {
 
@@ -25,17 +27,18 @@ public void exportDatabase(Connection connection, String databaseName, String sc
     }
 
     private void exportTypes(Connection connection, AsyncContext asyncContext) throws SQLException {
-            try (ResultSet resultSet = connection.createStatement().executeQuery(ENUM_TYPE_DDL_SQL)) {
-                while (resultSet.next()) {
-                    StringBuilder sqlBuilder = new StringBuilder();
-                    sqlBuilder.append(resultSet.getString("ddl")).append("\n");
-                    asyncContext.write(sqlBuilder.toString());
-                }
+        try (ResultSet resultSet = connection.createStatement().executeQuery(ENUM_TYPE_DDL_SQL)) {
+            while (resultSet.next()) {
+                StringBuilder sqlBuilder = new StringBuilder();
+                sqlBuilder.append(resultSet.getString("ddl")).append("\n");
+                asyncContext.write(sqlBuilder.toString());
+            }
         }
     }
+
     private void exportTables(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {
         try (ResultSet resultSet = connection.getMetaData().getTables(databaseName, schemaName, null,
-                                                                      new String[]{"TABLE", "SYSTEM TABLE","PARTITIONED TABLE"})) {
+                                                                      new String[]{"TABLE", "SYSTEM TABLE", "PARTITIONED TABLE"})) {
             ArrayList<String> tableNames = new ArrayList<>();
             while (resultSet.next()) {
                 String tableName = resultSet.getString("TABLE_NAME");
@@ -46,14 +49,14 @@ private void exportTables(Connection connection, String databaseName, String sch
             }
             if (asyncContext.isContainsData()) {
                 for (String tableName : tableNames) {
-                    exportTableData(connection, schemaName, tableName, asyncContext);
+                    exportTableData(connection, databaseName, schemaName, tableName, asyncContext);
                 }
             }
         }
     }
 
     private void exportTable(Connection connection, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {
-        String sql =String.format( "select pg_get_tabledef('%s','%s',true,'COMMENTS') as ddl;", schemaName,tableName);
+        String sql = String.format("select pg_get_tabledef('%s','%s',true,'COMMENTS') as ddl;", schemaName, tableName);
         try (ResultSet resultSet = connection.createStatement().executeQuery(sql)) {
             if (resultSet.next()) {
                 StringBuilder sqlBuilder = new StringBuilder();
@@ -65,10 +68,9 @@ private void exportTable(Connection connection, String schemaName, String tableN
     }
 
 
-
     private void exportViews(Connection connection, String schemaName, AsyncContext asyncContext) throws SQLException {
 
-        String sql = String.format("SELECT table_name, view_definition FROM information_schema.views WHERE table_schema = '%s'",schemaName);
+        String sql = String.format("SELECT table_name, view_definition FROM information_schema.views WHERE table_schema = '%s'", schemaName);
         try (ResultSet resultSet = connection.createStatement().executeQuery(sql)) {
             while (resultSet.next()) {
                 StringBuilder sqlBuilder = new StringBuilder();
@@ -82,7 +84,7 @@ private void exportViews(Connection connection, String schemaName, AsyncContext
 
     private void exportFunctions(Connection connection, String schemaName, AsyncContext asyncContext) throws SQLException {
         String sql = String.format("SELECT proname, pg_get_functiondef(oid) AS function_definition FROM pg_proc " +
-                                                "WHERE pronamespace = (SELECT oid FROM pg_namespace WHERE nspname = '%s')", schemaName);
+                                           "WHERE pronamespace = (SELECT oid FROM pg_namespace WHERE nspname = '%s')", schemaName);
         try (ResultSet resultSet = connection.createStatement().executeQuery(sql)) {
             while (resultSet.next()) {
                 StringBuilder sqlBuilder = new StringBuilder();
diff --git a/chat2db-server/chat2db-plugins/chat2db-sqlite/src/main/java/ai/chat2db/plugin/sqlite/SqliteDBManage.java b/chat2db-server/chat2db-plugins/chat2db-sqlite/src/main/java/ai/chat2db/plugin/sqlite/SqliteDBManage.java
diff --git a/chat2db-server/chat2db-plugins/chat2db-sqlserver/src/main/java/ai/chat2db/plugin/sqlserver/SqlServerDBManage.java b/chat2db-server/chat2db-plugins/chat2db-sqlserver/src/main/java/ai/chat2db/plugin/sqlserver/SqlServerDBManage.java
diff --git a/chat2db-server/chat2db-spi/src/main/java/ai/chat2db/spi/jdbc/DefaultDBManage.java b/chat2db-server/chat2db-spi/src/main/java/ai/chat2db/spi/jdbc/DefaultDBManage.java

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ private void exportTablesOrViewsOrDictionaries(Connection connection,String data`
`55`	`55`	`.append(";").append("\n").append(ddl).append(";").append("\n");`
`56`	`56`	`asyncContext.write(sqlBuilder.toString());`
`57`	`57`	`if (asyncContext.isContainsData() && dataFlag) {`
`58`		`- exportTableData(connection,schemaName, tableOrViewName, asyncContext);`
	`58`	`+ exportTableData(connection, databaseName,schemaName, tableOrViewName, asyncContext);`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,22 +20,22 @@ public class DB2DBManage extends DefaultDBManage implements DBManage {`
`20`	`20`
`21`	`21`	`@Override`
`22`	`22`	`public void exportDatabase(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {`
`23`		`- exportTables(connection, schemaName, asyncContext);`
	`23`	`+ exportTables(connection, databaseName, schemaName, asyncContext);`
`24`	`24`	`exportViews(connection, schemaName, asyncContext);`
`25`	`25`	`exportProceduresAndFunctions(connection, schemaName, asyncContext);`
`26`	`26`	`exportTriggers(connection, schemaName, asyncContext);`
`27`	`27`	`}`
`28`	`28`
`29`		`- private void exportTables(Connection connection, String schemaName, AsyncContext asyncContext) throws SQLException {`
	`29`	`+ private void exportTables(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {`
`30`	`30`	`try (ResultSet resultSet = connection.getMetaData().getTables(null, schemaName, null, new String[]{"TABLE", "SYSTEM TABLE"})) {`
`31`	`31`	`while (resultSet.next()) {`
`32`		`- exportTable(connection, schemaName, resultSet.getString("TABLE_NAME"), asyncContext);`
	`32`	`+ exportTable(connection, databaseName, schemaName, resultSet.getString("TABLE_NAME"), asyncContext);`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`	`37`
`38`		`- private void exportTable(Connection connection, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {`
	`38`	`+ private void exportTable(Connection connection, String databaseName, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {`
`39`	`39`	`try {`
`40`	`40`	`SQLExecutor.getInstance().execute(connection, SQLConstant.TABLE_DDL_FUNCTION_SQL, resultSet -> null);`
`41`	`41`	`} catch (Exception e) {`
`@@ -48,7 +48,7 @@ private void exportTable(Connection connection, String schemaName, String tableN`
`48`	`48`	`sqlBuilder.append(resultSet.getString("sql")).append("\n");`
`49`	`49`	`asyncContext.write(sqlBuilder.toString());`
`50`	`50`	`if (asyncContext.isContainsData()) {`
`51`		`- exportTableData(connection, schemaName, tableName, asyncContext);`
	`51`	`+ exportTableData(connection, databaseName, schemaName, tableName, asyncContext);`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,13 +7,14 @@`
`7`	`7`	`import ai.chat2db.spi.sql.SQLExecutor;`
`8`	`8`	`import org.springframework.util.StringUtils;`
`9`	`9`
`10`		`-import java.sql.*;`
`11`		`-import java.util.Objects;`
	`10`	`+import java.sql.Connection;`
	`11`	`+import java.sql.ResultSet;`
	`12`	`+import java.sql.SQLException;`
`12`	`13`
`13`	`14`	`public class MysqlDBManage extends DefaultDBManage implements DBManage {`
`14`	`15`	`@Override`
`15`	`16`	`public void exportDatabase(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {`
`16`		`- exportTables(connection, databaseName, asyncContext);`
	`17`	`+ exportTables(connection, databaseName, schemaName, asyncContext);`
`17`	`18`	`exportViews(connection, databaseName, asyncContext);`
`18`	`19`	`exportProcedures(connection, asyncContext);`
`19`	`20`	`exportTriggers(connection, asyncContext);`
`@@ -35,22 +36,22 @@ private void exportFunction(Connection connection, String functionName, AsyncCon`
`35`	`36`	`if (resultSet.next()) {`
`36`	`37`	`StringBuilder sqlBuilder = new StringBuilder();`
`37`	`38`	`sqlBuilder.append("DROP FUNCTION IF EXISTS ").append(functionName).append(";").append("\n")`
`38`		`- .append(resultSet.getString("Create Function")).append(";").append("\n");`
	`39`	`+ .append(resultSet.getString("Create Function")).append(";").append("\n");`
`39`	`40`	`asyncContext.write(sqlBuilder.toString());`
`40`	`41`	`}`
`41`	`42`	`}`
`42`	`43`	`}`
`43`	`44`
`44`		`- private void exportTables(Connection connection, String databaseName, AsyncContext asyncContext) throws SQLException {`
	`45`	`+ private void exportTables(Connection connection, String databaseName, String schemaName, AsyncContext asyncContext) throws SQLException {`
`45`	`46`	`try (ResultSet resultSet = connection.getMetaData().getTables(databaseName, null, null, new String[]{"TABLE", "SYSTEM TABLE"})) {`
`46`	`47`	`while (resultSet.next()) {`
`47`		`- exportTable(connection, resultSet.getString("TABLE_NAME"), asyncContext);`
	`48`	`+ exportTable(connection, databaseName, schemaName, resultSet.getString("TABLE_NAME"), asyncContext);`
`48`	`49`	`}`
`49`	`50`	`}`
`50`	`51`	`}`
`51`	`52`
`52`	`53`
`53`		`- private void exportTable(Connection connection, String tableName, AsyncContext asyncContext) throws SQLException {`
	`54`	`+ private void exportTable(Connection connection, String databaseName, String schemaName, String tableName, AsyncContext asyncContext) throws SQLException {`
`54`	`55`	`String sql = String.format("show create table %s ", tableName);`
`55`	`56`	`try (ResultSet resultSet = connection.createStatement().executeQuery(sql)) {`
`56`	`57`	`if (resultSet.next()) {`
`@@ -59,7 +60,7 @@ private void exportTable(Connection connection, String tableName, AsyncContext a`
`59`	`60`	`.append(resultSet.getString("Create Table")).append(";").append("\n");`
`60`	`61`	`asyncContext.write(sqlBuilder.toString());`
`61`	`62`	`if (asyncContext.isContainsData()) {`
`62`		`- exportTableData(connection, null,tableName, asyncContext);`
	`63`	`+ exportTableData(connection, databaseName, schemaName, tableName, asyncContext);`
`63`	`64`	`}`
`64`	`65`	`}`
`65`	`66`	`}`
`@@ -143,7 +144,7 @@ public void updateProcedure(Connection connection, String databaseName, String s`
`143`	`144`	`} catch (Exception e) {`
`144`	`145`	`connection.rollback();`
`145`	`146`	`throw new RuntimeException(e);`
`146`		`- }finally {`
	`147`	`+ } finally {`
`147`	`148`	`connection.setAutoCommit(true);`
`148`	`149`	`}`
`149`	`150`