opensource/Chat2DB
1
0
Fork 0
mirror of https://github.com/CodePhiliaX/Chat2DB.git synced 2025-08-02 21:50:43 +08:00
Code Issues Packages Projects Releases Wiki Activity

add

Browse Source
This commit is contained in:
jipengfei-jpf
2023-07-17 20:51:06 +08:00
parent de6fa3cb58
commit c81985e916
41 changed files with 294 additions and 795 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
chat2db-server/chat2db-plugins/chat2db-clickhouse/src/main/java/ai/chat2db/plugin/clickhouse/ClickHouseDBManage.java
View File

@ -1,47 +1,18 @@
package ai.chat2db.plugin.clickhouse;
import java.sql.Connection;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
import ai.chat2db.spi.sql.SQLExecutor;
public class ClickHouseDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
}
public class ClickHouseDBManage extends DefaultDBManage implements DBManage {
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
public void dropTable(Connection connection, String databaseName, String schemaName, String tableName) {
String sql = "DROP TABLE IF EXISTS " + databaseName + "." + tableName;
SQLExecutor.getInstance().executeSql(sql, resultSet -> null);
SQLExecutor.getInstance().executeSql(connection, sql, resultSet -> null);
}

43
chat2db-server/chat2db-plugins/chat2db-db2/src/main/java/ai/chat2db/plugin/db2/DB2DBManage.java
View File

@ -1,47 +1,16 @@
package ai.chat2db.plugin.db2;
import java.sql.Connection;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
import ai.chat2db.spi.sql.SQLExecutor;
public class DB2DBManage implements DBManage {
@Override
public void connectDatabase(String database) {
}
public class DB2DBManage extends DefaultDBManage implements DBManage {
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
public void dropTable(Connection connection, String databaseName, String schemaName, String tableName) {
String sql = "DROP TABLE " + tableName;
SQLExecutor.getInstance().executeSql(sql, resultSet -> null);
SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> null);
}
}

11
chat2db-server/chat2db-plugins/chat2db-db2/src/main/java/ai/chat2db/plugin/db2/DB2MetaData.java
View File

@ -1,11 +1,12 @@
package ai.chat2db.plugin.db2;
import java.sql.Connection;
import java.sql.SQLException;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
import ai.chat2db.spi.sql.SQLExecutor;
import java.sql.SQLException;
public class DB2MetaData extends DefaultMetaService implements MetaData {
private String functionSQL
= "CREATE FUNCTION tableSchema.ufn_GetCreateTableScript( @schema_name NVARCHAR(128), @table_name NVARCHAR"
@ -37,17 +38,17 @@ public class DB2MetaData extends DefaultMetaService implements MetaData {
@Override
public String tableDDL(String databaseName, String schemaName, String tableName) {
public String tableDDL(Connection connection, String databaseName, String schemaName, String tableName) {
try {
System.out.println(functionSQL);
SQLExecutor.getInstance().executeSql(functionSQL.replace("tableSchema", schemaName), resultSet -> null);
SQLExecutor.getInstance().executeSql(connection, functionSQL.replace("tableSchema", schemaName), resultSet -> null);
} catch (Exception e) {
//log.error("创建函数失败", e);
}
String ddlSql = "SELECT " + schemaName + ".ufn_GetCreateTableScript('" + schemaName + "', '" + tableName
+ "') AS sql";
return SQLExecutor.getInstance().executeSql(ddlSql, resultSet -> {
return SQLExecutor.getInstance().executeSql(connection, ddlSql, resultSet -> {
try {
if (resultSet.next()) {
return resultSet.getString("sql");

42
chat2db-server/chat2db-plugins/chat2db-dm/src/main/java/ai/chat2db/plugin/dm/DMDBManage.java
View File

@ -1,47 +1,17 @@
package ai.chat2db.plugin.dm;
import java.sql.Connection;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
import ai.chat2db.spi.sql.SQLExecutor;
public class DMDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public class DMDBManage extends DefaultDBManage implements DBManage {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
public void dropTable(Connection connection, String databaseName, String schemaName, String tableName) {
String sql = "DROP TABLE IF EXISTS " +tableName;
SQLExecutor.getInstance().executeSql(sql, resultSet -> null);
SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> null);
}
}

9
chat2db-server/chat2db-plugins/chat2db-dm/src/main/java/ai/chat2db/plugin/dm/DMMetaData.java
View File

@ -1,19 +1,20 @@
package ai.chat2db.plugin.dm;
import java.sql.Connection;
import java.sql.SQLException;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
import ai.chat2db.spi.sql.SQLExecutor;
import ai.chat2db.spi.util.SqlUtils;
import java.sql.SQLException;
public class DMMetaData extends DefaultMetaService implements MetaData {
public String tableDDL(String databaseName, String schemaName, String tableName) {
public String tableDDL(Connection connection, String databaseName, String schemaName, String tableName) {
String selectObjectDDLSQL = String.format(
"select dbms_metadata.get_ddl(%s, %s, %s) AS \"sql\" from dual",
SqlUtils.formatSQLString("TABLE"), SqlUtils.formatSQLString(tableName),
SqlUtils.formatSQLString(schemaName));
return SQLExecutor.getInstance().executeSql(selectObjectDDLSQL, resultSet -> {
return SQLExecutor.getInstance().executeSql(connection,selectObjectDDLSQL, resultSet -> {
try {
if (resultSet.next()) {
return resultSet.getString("sql");

42
chat2db-server/chat2db-plugins/chat2db-h2/src/main/java/ai/chat2db/plugin/h2/H2DBManage.java
View File

@ -1,47 +1,17 @@
package ai.chat2db.plugin.h2;
import java.sql.Connection;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
import ai.chat2db.spi.sql.SQLExecutor;
public class H2DBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public class H2DBManage extends DefaultDBManage implements DBManage {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
public void dropTable(Connection connection, String databaseName, String schemaName, String tableName) {
String sql = "DROP TABLE " +tableName;
SQLExecutor.getInstance().executeSql(sql, resultSet -> null);
SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> null);
}
}

16
chat2db-server/chat2db-plugins/chat2db-h2/src/main/java/ai/chat2db/plugin/h2/H2Meta.java
View File

@ -1,10 +1,5 @@
package ai.chat2db.plugin.h2;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
import ai.chat2db.spi.sql.SQLExecutor;
import jakarta.validation.constraints.NotEmpty;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
@ -13,16 +8,19 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
import jakarta.validation.constraints.NotEmpty;
public class H2Meta extends DefaultMetaService implements MetaData {
@Override
public String tableDDL(@NotEmpty String databaseName, String schemaName, @NotEmpty String tableName) {
return getDDL(databaseName, schemaName, tableName);
public String tableDDL(Connection connection, @NotEmpty String databaseName, String schemaName, @NotEmpty String tableName) {
return getDDL(connection,databaseName, schemaName, tableName);
}
private String getDDL(String databaseName, String schemaName, String tableName) {
private String getDDL(Connection connection, String databaseName, String schemaName, String tableName) {
try {
Connection connection = SQLExecutor.getInstance().getConnection();
// 查询表结构信息
ResultSet columns = connection.getMetaData().getColumns(databaseName, schemaName, tableName, null);
List<String> columnDefinitions = new ArrayList<>();

42
chat2db-server/chat2db-plugins/chat2db-hive/src/main/java/ai/chat2db/plugin/hive/HiveDBManage.java
View File

@ -1,47 +1,17 @@
package ai.chat2db.plugin.hive;
import java.sql.Connection;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
import ai.chat2db.spi.sql.SQLExecutor;
public class HiveDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public class HiveDBManage extends DefaultDBManage implements DBManage {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
public void dropTable(Connection connection, String databaseName, String schemaName, String tableName) {
String sql = "drop table if exists " +tableName;
SQLExecutor.getInstance().executeSql(sql, resultSet -> null);
SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> null);
}
}

43
chat2db-server/chat2db-plugins/chat2db-kingbase/src/main/java/ai/chat2db/plugin/kingbase/KingBaseDBManage.java
View File

@ -1,47 +1,16 @@
package ai.chat2db.plugin.kingbase;
import java.sql.Connection;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
import ai.chat2db.spi.sql.SQLExecutor;
public class KingBaseDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
}
public class KingBaseDBManage extends DefaultDBManage implements DBManage {
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
public void dropTable(Connection connection, String databaseName, String schemaName, String tableName) {
String sql = "drop table if exists " +tableName;
SQLExecutor.getInstance().executeSql(sql, resultSet -> null);
SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> null);
}
}

42
chat2db-server/chat2db-plugins/chat2db-mariadb/src/main/java/ai/chat2db/plugin/mariadb/MariaDBManage.java
View File

@ -1,47 +1,17 @@
package ai.chat2db.plugin.mariadb;
import java.sql.Connection;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
import ai.chat2db.spi.sql.SQLExecutor;
public class MariaDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public class MariaDBManage extends DefaultDBManage implements DBManage {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
public void dropTable(Connection connection, String databaseName, String schemaName, String tableName) {
String sql = "DROP TABLE " +tableName ;
SQLExecutor.getInstance().executeSql(sql, resultSet -> null);
SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> null);
}
}

41
chat2db-server/chat2db-plugins/chat2db-mongodb/src/main/java/ai/chat2db/plugin/mongodb/MongodbManage.java
View File

@ -1,45 +1,8 @@
package ai.chat2db.plugin.mongodb;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
public class MongodbManage implements DBManage {
@Override
public void connectDatabase(String database) {
public class MongodbManage extends DefaultDBManage implements DBManage {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
}
}

1
chat2db-server/chat2db-plugins/chat2db-mongodb/src/main/java/ai/chat2db/plugin/mongodb/MongodbMetaData.java
View File

@ -3,6 +3,7 @@ package ai.chat2db.plugin.mongodb;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
public class MongodbMetaData extends DefaultMetaService implements MetaData {
}

44
chat2db-server/chat2db-plugins/chat2db-mysql/src/main/java/ai/chat2db/plugin/mysql/MysqlDBManage.java
View File

@ -1,58 +1,32 @@
package ai.chat2db.plugin.mysql;
import java.sql.Connection;
import java.sql.SQLException;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
import ai.chat2db.spi.sql.SQLExecutor;
import org.springframework.util.StringUtils;
import java.sql.SQLException;
public class MysqlDBManage implements DBManage {
public class MysqlDBManage extends DefaultDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public void connectDatabase(Connection connection, String database) {
if (StringUtils.isEmpty(database)) {
return;
}
try {
SQLExecutor.getInstance().execute("use `" + database + "`;");
SQLExecutor.getInstance().execute(connection,"use `" + database + "`;");
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
public void dropTable(Connection connection, String databaseName, String schemaName, String tableName) {
String sql = "DROP TABLE "+ format(tableName);
SQLExecutor.getInstance().executeSql(sql, resultSet -> null);
SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> null);
}
public static String format(String tableName) {

9
chat2db-server/chat2db-plugins/chat2db-mysql/src/main/java/ai/chat2db/plugin/mysql/MysqlMetaData.java
View File

@ -1,18 +1,19 @@
package ai.chat2db.plugin.mysql;
import java.sql.Connection;
import java.sql.SQLException;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
import ai.chat2db.spi.sql.SQLExecutor;
import jakarta.validation.constraints.NotEmpty;
import java.sql.SQLException;
public class MysqlMetaData extends DefaultMetaService implements MetaData {
@Override
public String tableDDL(@NotEmpty String databaseName, String schemaName, @NotEmpty String tableName) {
public String tableDDL(Connection connection, @NotEmpty String databaseName, String schemaName, @NotEmpty String tableName) {
String sql = "SHOW CREATE TABLE " + format(databaseName) + "."
+ format( tableName);
return SQLExecutor.getInstance().executeSql(sql, resultSet -> {
return SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> {
try {
if (resultSet.next()) {
return resultSet.getString("Create Table");

41
chat2db-server/chat2db-plugins/chat2db-oceanbase/src/main/java/ai/chat2db/plugin/oceanbase/OceanBaseDBManage.java
View File

@ -1,45 +1,8 @@
package ai.chat2db.plugin.oceanbase;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
public class OceanBaseDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public class OceanBaseDBManage extends DefaultDBManage implements DBManage {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
}
}

41
chat2db-server/chat2db-plugins/chat2db-oracle/src/main/java/ai/chat2db/plugin/oracle/OracleDBManage.java
View File

@ -1,45 +1,8 @@
package ai.chat2db.plugin.oracle;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
public class OracleDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public class OracleDBManage extends DefaultDBManage implements DBManage {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
}
}

9
chat2db-server/chat2db-plugins/chat2db-oracle/src/main/java/ai/chat2db/plugin/oracle/OracleMetaData.java
View File

@ -1,17 +1,18 @@
package ai.chat2db.plugin.oracle;
import java.sql.Connection;
import java.sql.SQLException;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
import ai.chat2db.spi.sql.SQLExecutor;
import java.sql.SQLException;
public class OracleMetaData extends DefaultMetaService implements MetaData {
@Override
public String tableDDL(String databaseName, String schemaName, String tableName) {
public String tableDDL(Connection connection, String databaseName, String schemaName, String tableName) {
String sql = "select dbms_metadata.get_ddl('TABLE','"+tableName+"') as sql from dual,"
+ "user_tables where table_name = '" + tableName + "'";
return SQLExecutor.getInstance().executeSql(sql, resultSet -> {
return SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> {
try {
if (resultSet.next()) {
return resultSet.getString("sql");

51
chat2db-server/chat2db-plugins/chat2db-postgresql/src/main/java/ai/chat2db/plugin/postgresql/PostgreSQLDBManage.java
View File

@ -1,54 +1,19 @@
package ai.chat2db.plugin.postgresql;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.sql.Chat2DBContext;
import ai.chat2db.spi.sql.ConnectInfo;
import ai.chat2db.spi.sql.SQLExecutor;
import java.sql.Connection;
import java.sql.SQLException;
public class PostgreSQLDBManage implements DBManage {
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
import ai.chat2db.spi.sql.SQLExecutor;
public class PostgreSQLDBManage extends DefaultDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public void connectDatabase(Connection connection, String database) {
try {
SQLExecutor.getInstance().execute("SELECT pg_database_size('"+database+"');");
SQLExecutor.getInstance().execute(connection,"SELECT pg_database_size('"+database+"');");
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
}
}

11
chat2db-server/chat2db-plugins/chat2db-postgresql/src/main/java/ai/chat2db/plugin/postgresql/PostgreSQLMetaData.java
View File

@ -1,11 +1,12 @@
package ai.chat2db.plugin.postgresql;
import java.sql.Connection;
import java.sql.SQLException;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
import ai.chat2db.spi.sql.SQLExecutor;
import java.sql.SQLException;
public class PostgreSQLMetaData extends DefaultMetaService implements MetaData {
private String functionSQL =
" CREATE OR REPLACE FUNCTION showcreatetable(namespace character varying, tablename character "
@ -163,10 +164,10 @@ public class PostgreSQLMetaData extends DefaultMetaService implements MetaData {
+ " $BODY$ LANGUAGE plpgsql";
@Override
public String tableDDL(String databaseName, String schemaName, String tableName) {
SQLExecutor.getInstance().executeSql(functionSQL.replaceFirst("tableSchema", schemaName), resultSet -> null);
public String tableDDL(Connection connection, String databaseName, String schemaName, String tableName) {
SQLExecutor.getInstance().executeSql(connection,functionSQL.replaceFirst("tableSchema", schemaName), resultSet -> null);
String ddlSql = "select showcreatetable('" + schemaName + "','" + tableName + "') as sql";
return SQLExecutor.getInstance().executeSql(ddlSql, resultSet -> {
return SQLExecutor.getInstance().executeSql(connection,ddlSql, resultSet -> {
try {
if (resultSet.next()) {
return resultSet.getString("sql");

42
chat2db-server/chat2db-plugins/chat2db-presto/src/main/java/ai/chat2db/plugin/presto/PrestoDBManage.java
View File

@ -1,45 +1,7 @@
package ai.chat2db.plugin.presto;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
public class PrestoDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
}
public class PrestoDBManage extends DefaultDBManage implements DBManage {
}

41
chat2db-server/chat2db-plugins/chat2db-redis/src/main/java/ai/chat2db/plugin/redis/RedisDBManage.java
View File

@ -1,45 +1,8 @@
package ai.chat2db.plugin.redis;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
public class RedisDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public class RedisDBManage extends DefaultDBManage implements DBManage {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
}
}

23
chat2db-server/chat2db-plugins/chat2db-redis/src/main/java/ai/chat2db/plugin/redis/RedisMetaData.java
View File

@ -1,28 +1,23 @@
package ai.chat2db.plugin.redis;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
import ai.chat2db.spi.model.Database;
import ai.chat2db.spi.model.Table;
import ai.chat2db.spi.sql.SQLExecutor;
import jakarta.validation.constraints.NotEmpty;
import org.apache.commons.lang3.StringUtils;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class RedisMetaData extends DefaultMetaService implements MetaData {
@Override
public String tableDDL(@NotEmpty String databaseName, String schemaName, @NotEmpty String tableName) {
return "";
}
@Override
public List<Database> databases() {
public List<Database> databases(Connection connection) {
List<Database> databases = new ArrayList<>();
return SQLExecutor.getInstance().executeSql("config get databases", resultSet -> {
return SQLExecutor.getInstance().executeSql(connection,"config get databases", resultSet -> {
try {
if (resultSet.next()) {
Object count = resultSet.getObject(2);
@ -41,8 +36,8 @@ public class RedisMetaData extends DefaultMetaService implements MetaData {
}
@Override
public List<Table> tables(String databaseName, String schemaName, String tableName) {
return SQLExecutor.getInstance().executeSql("scan 0 MATCH * COUNT 1000", resultSet -> {
public List<Table> tables(Connection connection, String databaseName, String schemaName, String tableName) {
return SQLExecutor.getInstance().executeSql(connection,"scan 0 MATCH * COUNT 1000", resultSet -> {
List<Table> tables = new ArrayList<>();
try {
while (resultSet.next()) {

42
chat2db-server/chat2db-plugins/chat2db-sqlite/src/main/java/ai/chat2db/plugin/sqlite/SqliteDBManage.java
View File

@ -1,45 +1,7 @@
package ai.chat2db.plugin.sqlite;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
public class SqliteDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
}
public class SqliteDBManage extends DefaultDBManage implements DBManage {
}

15
chat2db-server/chat2db-plugins/chat2db-sqlite/src/main/java/ai/chat2db/plugin/sqlite/SqliteMetaData.java
View File

@ -1,5 +1,9 @@
package ai.chat2db.plugin.sqlite;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
import ai.chat2db.spi.model.Database;
@ -7,14 +11,11 @@ import ai.chat2db.spi.model.Schema;
import ai.chat2db.spi.sql.SQLExecutor;
import com.google.common.collect.Lists;
import java.sql.SQLException;
import java.util.List;
public class SqliteMetaData extends DefaultMetaService implements MetaData {
@Override
public String tableDDL(String databaseName, String schemaName, String tableName) {
public String tableDDL(Connection connection, String databaseName, String schemaName, String tableName) {
String sql = "SELECT sql FROM sqlite_master WHERE type='table' AND name='" + tableName + "'";
return SQLExecutor.getInstance().executeSql(sql, resultSet -> {
return SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> {
try {
if (resultSet.next()) {
return resultSet.getString("sql");
@ -26,12 +27,12 @@ public class SqliteMetaData extends DefaultMetaService implements MetaData {
});
}
@Override
public List<Database> databases() {
public List<Database> databases(Connection connection) {
return Lists.newArrayList(Database.builder().name("main").build());
}
@Override
public List<Schema> schemas(String databaseName) {
public List<Schema> schemas(Connection connection,String databaseName) {
return Lists.newArrayList();
}
}

43
chat2db-server/chat2db-plugins/chat2db-sqlserver/src/main/java/ai/chat2db/plugin/sqlserver/SqlServerDBManage.java
View File

@ -1,52 +1,19 @@
package ai.chat2db.plugin.sqlserver;
import java.sql.Connection;
import java.sql.SQLException;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.jdbc.DefaultDBManage;
import ai.chat2db.spi.sql.SQLExecutor;
public class SqlServerDBManage implements DBManage {
public class SqlServerDBManage extends DefaultDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public void connectDatabase(Connection connection, String database) {
try {
SQLExecutor.getInstance().execute("use [" + database + "];");
SQLExecutor.getInstance().execute(connection,"use [" + database + "];");
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
}
}

11
chat2db-server/chat2db-plugins/chat2db-sqlserver/src/main/java/ai/chat2db/plugin/sqlserver/SqlServerMetaData.java
View File

@ -1,11 +1,12 @@
package ai.chat2db.plugin.sqlserver;
import java.sql.Connection;
import java.sql.SQLException;
import ai.chat2db.spi.MetaData;
import ai.chat2db.spi.jdbc.DefaultMetaService;
import ai.chat2db.spi.sql.SQLExecutor;
import java.sql.SQLException;
public class SqlServerMetaData extends DefaultMetaService implements MetaData {
private String functionSQL
= "CREATE FUNCTION tableSchema.ufn_GetCreateTableScript( @schema_name NVARCHAR(128), @table_name NVARCHAR"
@ -37,17 +38,17 @@ public class SqlServerMetaData extends DefaultMetaService implements MetaData {
@Override
public String tableDDL(String databaseName, String schemaName, String tableName) {
public String tableDDL(Connection connection, String databaseName, String schemaName, String tableName) {
try {
System.out.println(functionSQL);
SQLExecutor.getInstance().executeSql(functionSQL.replace("tableSchema", schemaName), resultSet -> null);
SQLExecutor.getInstance().executeSql(connection,functionSQL.replace("tableSchema", schemaName), resultSet -> null);
} catch (Exception e) {
//log.error("创建函数失败", e);
}
String ddlSql = "SELECT " + schemaName + ".ufn_GetCreateTableScript('" + schemaName + "', '" + tableName
+ "') AS sql";
return SQLExecutor.getInstance().executeSql(ddlSql, resultSet -> {
return SQLExecutor.getInstance().executeSql(connection,ddlSql, resultSet -> {
try {
if (resultSet.next()) {
return resultSet.getString("sql");

2
chat2db-server/chat2db-server-domain/chat2db-server-domain-core/src/main/java/ai/chat2db/server/domain/core/impl/ConsoleServiceImpl.java
View File

@ -18,7 +18,7 @@ import org.springframework.stereotype.Service;
public class ConsoleServiceImpl implements ConsoleService {
@Override
public ActionResult createConsole(ConsoleConnectParam param) {
Chat2DBContext.getDBManage().connectDatabase(param.getDatabaseName());
Chat2DBContext.getDBManage().connectDatabase(Chat2DBContext.getConnection(),param.getDatabaseName());
return ActionResult.isSuccess();
}

12
chat2db-server/chat2db-server-domain/chat2db-server-domain-core/src/main/java/ai/chat2db/server/domain/core/impl/DataSourceServiceImpl.java
View File

@ -16,16 +16,14 @@ import ai.chat2db.server.domain.api.service.DataSourceService;
import ai.chat2db.server.domain.core.converter.DataSourceConverter;
import ai.chat2db.server.domain.repository.entity.DataSourceDO;
import ai.chat2db.server.domain.repository.mapper.DataSourceMapper;
import ai.chat2db.spi.config.DriverConfig;
import ai.chat2db.spi.model.DataSourceConnect;
import ai.chat2db.spi.model.Database;
import ai.chat2db.spi.model.KeyValue;
import ai.chat2db.server.tools.base.wrapper.result.ActionResult;
import ai.chat2db.server.tools.base.wrapper.result.DataResult;
import ai.chat2db.server.tools.base.wrapper.result.ListResult;
import ai.chat2db.server.tools.base.wrapper.result.PageResult;
import ai.chat2db.server.tools.common.util.EasyCollectionUtils;
import ai.chat2db.spi.config.DriverConfig;
import ai.chat2db.spi.model.DataSourceConnect;
import ai.chat2db.spi.model.Database;
import ai.chat2db.spi.model.KeyValue;
import ai.chat2db.spi.sql.Chat2DBContext;
import ai.chat2db.spi.sql.SQLExecutor;
import ai.chat2db.spi.util.JdbcUtils;
@ -137,7 +135,7 @@ public class DataSourceServiceImpl implements DataSourceService {
public ListResult<Database> connect(Long id) {
DatabaseQueryAllParam queryAllParam = new DatabaseQueryAllParam();
queryAllParam.setDataSourceId(id);
List<Database> databases = Chat2DBContext.getMetaData().databases();
List<Database> databases = Chat2DBContext.getMetaData().databases(Chat2DBContext.getConnection());
return ListResult.of(databases);
}

43
chat2db-server/chat2db-server-domain/chat2db-server-domain-core/src/main/java/ai/chat2db/server/domain/core/impl/DatabaseServiceImpl.java
View File

@ -1,5 +1,6 @@
package ai.chat2db.server.domain.core.impl;
import java.sql.Connection;
import java.util.List;
import java.util.concurrent.CountDownLatch;
@ -18,7 +19,6 @@ import ai.chat2db.spi.model.Database;
import ai.chat2db.spi.model.MetaSchema;
import ai.chat2db.spi.model.Schema;
import ai.chat2db.spi.sql.Chat2DBContext;
import ai.chat2db.spi.sql.ConnectInfo;
import cn.hutool.core.thread.ThreadUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@ -37,41 +37,44 @@ public class DatabaseServiceImpl implements DatabaseService {
@Override
public ListResult<Database> queryAll(DatabaseQueryAllParam param) {
return ListResult.of(Chat2DBContext.getMetaData().databases());
return ListResult.of(Chat2DBContext.getMetaData().databases(Chat2DBContext.getConnection()));
}
@Override
public ListResult<Schema> querySchema(SchemaQueryParam param) {
return ListResult.of(Chat2DBContext.getMetaData().schemas(param.getDataBaseName()));
return ListResult.of(
Chat2DBContext.getMetaData().schemas(Chat2DBContext.getConnection(), param.getDataBaseName()));
}
@Override
public DataResult<MetaSchema> queryDatabaseSchema(MetaDataQueryParam param) {
MetaSchema metaSchema = new MetaSchema();
MetaData metaData = Chat2DBContext.getMetaData();
ConnectInfo connectInfo = Chat2DBContext.getConnectInfo();
Connection connection = Chat2DBContext.getConnection();
MetaSchema ms = CacheManage.get(getDataSourceKey(param.getDataSourceId()), MetaSchema.class,
(key) -> param.isRefresh(), (key) -> {
List<Database> databases = metaData.databases();
List<Database> databases = metaData.databases(Chat2DBContext.getConnection());
if (!CollectionUtils.isEmpty(databases)) {
// CountDownLatch countDownLatch = ThreadUtil.newCountDownLatch(databases.size());
CountDownLatch countDownLatch = ThreadUtil.newCountDownLatch(databases.size());
for (Database database : databases) {
//ThreadUtil.execute(() -> {
ThreadUtil.execute(() -> {
try {
// Chat2DBContext.putContext(connectInfo);
database.setSchemas(metaData.schemas(database.getName()));
// countDownLatch.countDown();
database.setSchemas(metaData.schemas(connection, database.getName()));
countDownLatch.countDown();
} catch (Exception e) {
log.error("queryDatabaseSchema error", e);
} finally {
//Chat2DBContext.removeContext();
}
// });
});
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
log.error("queryDatabaseSchema error", e);
}
metaSchema.setDatabases(databases);
} else {
List<Schema> schemas = metaData.schemas(null);
List<Schema> schemas = metaData.schemas(Chat2DBContext.getConnection(), null);
metaSchema.setSchemas(schemas);
}
return metaSchema;
@ -82,37 +85,37 @@ public class DatabaseServiceImpl implements DatabaseService {
@Override
public ActionResult deleteDatabase(DatabaseOperationParam param) {
Chat2DBContext.getDBManage().dropDatabase(param.getDatabaseName());
Chat2DBContext.getDBManage().dropDatabase(Chat2DBContext.getConnection(),param.getDatabaseName());
return ActionResult.isSuccess();
}
@Override
public ActionResult createDatabase(DatabaseOperationParam param) {
Chat2DBContext.getDBManage().createDatabase(param.getDatabaseName());
Chat2DBContext.getDBManage().createDatabase(Chat2DBContext.getConnection(),param.getDatabaseName());
return ActionResult.isSuccess();
}
@Override
public ActionResult modifyDatabase(DatabaseOperationParam param) {
Chat2DBContext.getDBManage().modifyDatabase(param.getDatabaseName(), param.getNewDatabaseName());
Chat2DBContext.getDBManage().modifyDatabase(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getNewDatabaseName());
return ActionResult.isSuccess();
}
@Override
public ActionResult deleteSchema(SchemaOperationParam param) {
Chat2DBContext.getDBManage().dropSchema(param.getDatabaseName(), param.getSchemaName());
Chat2DBContext.getDBManage().dropSchema(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getSchemaName());
return ActionResult.isSuccess();
}
@Override
public ActionResult createSchema(SchemaOperationParam param) {
Chat2DBContext.getDBManage().createSchema(param.getDatabaseName(), param.getSchemaName());
Chat2DBContext.getDBManage().createSchema(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getSchemaName());
return ActionResult.isSuccess();
}
@Override
public ActionResult modifySchema(SchemaOperationParam param) {
Chat2DBContext.getDBManage().modifySchema(param.getDatabaseName(), param.getSchemaName(),
Chat2DBContext.getDBManage().modifySchema(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getSchemaName(),
param.getNewSchemaName());
return ActionResult.isSuccess();
}

2
chat2db-server/chat2db-server-domain/chat2db-server-domain-core/src/main/java/ai/chat2db/server/domain/core/impl/DlTemplateServiceImpl.java
View File

@ -155,7 +155,7 @@ public class DlTemplateServiceImpl implements DlTemplateService {
private ExecuteResult execute(String sql) {
ExecuteResult executeResult;
try {
executeResult = SQLExecutor.getInstance().execute(sql);
executeResult = SQLExecutor.getInstance().execute(Chat2DBContext.getConnection(),sql);
} catch (SQLException e) {
log.warn("执行sql:{}异常", sql, e);
executeResult = ExecuteResult.builder()

2
chat2db-server/chat2db-server-domain/chat2db-server-domain-core/src/main/java/ai/chat2db/server/domain/core/impl/FunctionServiceImpl.java
View File

@ -10,6 +10,6 @@ import org.springframework.stereotype.Service;
public class FunctionServiceImpl implements FunctionService {
@Override
public ListResult<Function> functions(String databaseName, String schemaName) {
return ListResult.of(Chat2DBContext.getMetaData().functions(databaseName, schemaName));
return ListResult.of(Chat2DBContext.getMetaData().functions(Chat2DBContext.getConnection(),databaseName, schemaName));
}
}

2
chat2db-server/chat2db-server-domain/chat2db-server-domain-core/src/main/java/ai/chat2db/server/domain/core/impl/ProcedureServiceImpl.java
View File

@ -11,6 +11,6 @@ public class ProcedureServiceImpl implements ProcedureService {
@Override
public ListResult<Procedure> procedures(String databaseName, String schemaName) {
return ListResult.of(Chat2DBContext.getMetaData().procedures(databaseName, schemaName));
return ListResult.of(Chat2DBContext.getMetaData().procedures(Chat2DBContext.getConnection(),databaseName, schemaName));
}
}

16
chat2db-server/chat2db-server-domain/chat2db-server-domain-core/src/main/java/ai/chat2db/server/domain/core/impl/TableServiceImpl.java
View File

@ -53,14 +53,14 @@ public class TableServiceImpl implements TableService {
@Override
public DataResult<String> showCreateTable(ShowCreateTableParam param) {
MetaData metaSchema = Chat2DBContext.getMetaData();
String ddl = metaSchema.tableDDL(param.getDatabaseName(), param.getSchemaName(), param.getTableName());
String ddl = metaSchema.tableDDL(Chat2DBContext.getConnection(), param.getDatabaseName(), param.getSchemaName(), param.getTableName());
return DataResult.of(ddl);
}
@Override
public ActionResult drop(DropParam param) {
DBManage metaSchema = Chat2DBContext.getDBManage();
metaSchema.dropTable(param.getDatabaseName(), param.getTableSchema(), param.getTableName());
metaSchema.dropTable(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getTableSchema(), param.getTableName());
return ActionResult.isSuccess();
}
@ -79,13 +79,13 @@ public class TableServiceImpl implements TableService {
@Override
public DataResult<Table> query(TableQueryParam param, TableSelector selector) {
MetaData metaSchema = Chat2DBContext.getMetaData();
List<Table> tables = metaSchema.tables(param.getDatabaseName(), param.getSchemaName(), param.getTableName());
List<Table> tables = metaSchema.tables(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getSchemaName(), param.getTableName());
if (!CollectionUtils.isEmpty(tables)) {
Table table = tables.get(0);
table.setIndexList(
metaSchema.indexes(param.getDatabaseName(), param.getSchemaName(), param.getTableName()));
metaSchema.indexes(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getSchemaName(), param.getTableName()));
table.setColumnList(
metaSchema.columns(param.getDatabaseName(), param.getSchemaName(), param.getTableName()));
metaSchema.columns(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getSchemaName(), param.getTableName()));
return DataResult.of(table);
}
return DataResult.of(null);
@ -104,7 +104,7 @@ public class TableServiceImpl implements TableService {
List<Table> list = CacheManage.getList(tableKey, Table.class,
(key) -> param.isRefresh(), (key) ->
metaSchema.tables(param.getDatabaseName(), param.getSchemaName(), param.getTableName()));
metaSchema.tables(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getSchemaName(), param.getTableName()));
list = pinTable(list, param);
if (CollectionUtils.isEmpty(list)) {
@ -144,13 +144,13 @@ public class TableServiceImpl implements TableService {
@Override
public List<TableColumn> queryColumns(TableQueryParam param) {
MetaData metaSchema = Chat2DBContext.getMetaData();
return metaSchema.columns(param.getDatabaseName(), param.getSchemaName(), param.getTableName(), null);
return metaSchema.columns(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getSchemaName(), param.getTableName(), null);
}
@Override
public List<TableIndex> queryIndexes(TableQueryParam param) {
MetaData metaSchema = Chat2DBContext.getMetaData();
return metaSchema.indexes(param.getDatabaseName(), param.getSchemaName(), param.getTableName());
return metaSchema.indexes(Chat2DBContext.getConnection(),param.getDatabaseName(), param.getSchemaName(), param.getTableName());
}
}

2
chat2db-server/chat2db-server-domain/chat2db-server-domain-core/src/main/java/ai/chat2db/server/domain/core/impl/TriggerServiceImpl.java
View File

@ -10,6 +10,6 @@ import org.springframework.stereotype.Service;
public class TriggerServiceImpl implements TriggerService {
@Override
public ListResult<Trigger> triggers(String databaseName, String schemaName) {
return ListResult.of(Chat2DBContext.getMetaData().triggers(databaseName, schemaName));
return ListResult.of(Chat2DBContext.getMetaData().triggers(Chat2DBContext.getConnection(),databaseName, schemaName));
}
}

2
chat2db-server/chat2db-server-domain/chat2db-server-domain-core/src/main/java/ai/chat2db/server/domain/core/impl/ViewServiceImpl.java
View File

@ -11,6 +11,6 @@ public class ViewServiceImpl implements ViewService {
@Override
public ListResult<Table> views(String databaseName, String schemaName) {
return ListResult.of(Chat2DBContext.getMetaData().views(databaseName, schemaName));
return ListResult.of(Chat2DBContext.getMetaData().views(Chat2DBContext.getConnection(),databaseName, schemaName));
}
}

19
chat2db-server/chat2db-spi/src/main/java/ai/chat2db/spi/DBManage.java
View File

@ -1,6 +1,7 @@
package ai.chat2db.spi;
import java.sql.Connection;
import jakarta.validation.constraints.NotEmpty;
/**
@ -12,28 +13,28 @@ public interface DBManage {
/**
* @param database
*/
void connectDatabase(String database);
void connectDatabase(Connection connection,String database);
/**
* 修改数据库名称
* @param databaseName
* @param newDatabaseName
*/
void modifyDatabase(String databaseName, String newDatabaseName);
void modifyDatabase(Connection connection,String databaseName, String newDatabaseName);
/**
* 创建数据库
* @param databaseName
*/
void createDatabase(String databaseName);
void createDatabase(Connection connection,String databaseName);
/**
* 删除数据库
* @param databaseName
*/
void dropDatabase(String databaseName);
void dropDatabase(Connection connection,String databaseName);
@ -42,14 +43,14 @@ public interface DBManage {
* @param databaseName
* @param schemaName
*/
void createSchema(String databaseName, String schemaName);
void createSchema(Connection connection,String databaseName, String schemaName);
/**
* 删除schema
* @param databaseName
* @param schemaName
*/
void dropSchema(String databaseName, String schemaName);
void dropSchema(Connection connection,String databaseName, String schemaName);
/**
* 修改schema
@ -57,7 +58,7 @@ public interface DBManage {
* @param schemaName
* @param newSchemaName
*/
void modifySchema(String databaseName, String schemaName, String newSchemaName);
void modifySchema(Connection connection,String databaseName, String schemaName, String newSchemaName);
/**
@ -67,5 +68,5 @@ public interface DBManage {
* @param tableName
* @return
*/
void dropTable(@NotEmpty String databaseName, String schemaName, @NotEmpty String tableName);
void dropTable(Connection connection,@NotEmpty String databaseName, String schemaName, @NotEmpty String tableName);
}

49
chat2db-server/chat2db-spi/src/main/java/ai/chat2db/spi/MetaData.java
View File

@ -1,6 +1,6 @@
package ai.chat2db.spi;
import java.sql.Connection;
import java.util.List;
import ai.chat2db.spi.model.*;
@ -15,92 +15,117 @@ import jakarta.validation.constraints.NotEmpty;
public interface MetaData {
/**
* Query all databases.
* @param connection
*
* @return
*/
List<Database> databases();
List<Database> databases(Connection connection);
/**
* Querying all schemas under a database
*
* @param connection
* @param databaseName
* @return
*/
List<Schema> schemas(String databaseName);
List<Schema> schemas(Connection connection, String databaseName);
/**
* Querying DDL information
*
* @param connection
* @param databaseName
* @param tableName
* @return
*/
String tableDDL(@NotEmpty String databaseName, String schemaName, @NotEmpty String tableName);
String tableDDL(Connection connection, @NotEmpty String databaseName, String schemaName,
@NotEmpty String tableName);
/**
* Querying all table under a schema.
*
* @param connection
* @param databaseName
* @param schemaName
* @param tableName
* @return
*/
List<Table> tables(@NotEmpty String databaseName, String schemaName, String tableName);
List<Table> tables(Connection connection, @NotEmpty String databaseName, String schemaName, String tableName);
/**
* Querying all views under a schema.
*
* @param connection
* @param databaseName
* @param schemaName
* @return
*/
List<Table> views(@NotEmpty String databaseName, String schemaName);
List<Table> views(Connection connection, @NotEmpty String databaseName, String schemaName);
/**
* Querying all functions under a schema.
*
* @param connection
* @param databaseName
* @param schemaName
* @return
*/
List<Function> functions(@NotEmpty String databaseName, String schemaName);
List<Function> functions(Connection connection, @NotEmpty String databaseName, String schemaName);
/**
* Querying all triggers under a schema.
*
* @param connection
* @param databaseName
* @param schemaName
* @return
*/
List<Trigger> triggers(@NotEmpty String databaseName, String schemaName);
List<Trigger> triggers(Connection connection, @NotEmpty String databaseName, String schemaName);
/**
* Querying all procedures under a schema.
*
* @param connection
* @param schemaName
* @param databaseName
* @return
*/
List<Procedure> procedures(@NotEmpty String databaseName, String schemaName);
List<Procedure> procedures(Connection connection, @NotEmpty String databaseName, String schemaName);
/**
* Querying all columns under a table.
*
* @param connection
* @param databaseName
* @param schemaName
* @param tableName
* @return
*/
List<TableColumn> columns(@NotEmpty String databaseName, String schemaName,
List<TableColumn> columns(Connection connection, @NotEmpty String databaseName, String schemaName,
@NotEmpty String tableName);
/**
* Querying all columns under a table.
*
* @param connection
* @param databaseName
* @param schemaName
* @param tableName
* @param columnName
* @return
*/
List<TableColumn> columns(@NotEmpty String databaseName, String schemaName, String tableName,
List<TableColumn> columns(Connection connection, @NotEmpty String databaseName, String schemaName, String tableName,
String columnName);
/**
* Querying all indexes under a table.
*
* @param connection
* @param databaseName
* @param databaseName
* @return
*/
List<TableIndex> indexes(@NotEmpty String databaseName, String schemaName, @NotEmpty String tableName);
List<TableIndex> indexes(Connection connection, @NotEmpty String databaseName, String schemaName,
@NotEmpty String tableName);
}

21
chat2db-server/chat2db-spi/src/main/java/ai/chat2db/spi/jdbc/DefaultDBManage.java
View File

@ -1,7 +1,6 @@
package ai.chat2db.spi.jdbc;
import java.sql.SQLException;
import java.sql.Connection;
import ai.chat2db.spi.DBManage;
import ai.chat2db.spi.sql.SQLExecutor;
@ -13,43 +12,43 @@ import ai.chat2db.spi.sql.SQLExecutor;
public class DefaultDBManage implements DBManage {
@Override
public void connectDatabase(String database) {
public void connectDatabase(Connection connection,String database) {
}
@Override
public void modifyDatabase(String databaseName, String newDatabaseName) {
public void modifyDatabase(Connection connection,String databaseName, String newDatabaseName) {
}
@Override
public void createDatabase(String databaseName) {
public void createDatabase(Connection connection,String databaseName) {
}
@Override
public void dropDatabase(String databaseName) {
public void dropDatabase(Connection connection,String databaseName) {
}
@Override
public void createSchema(String databaseName, String schemaName) {
public void createSchema(Connection connection,String databaseName, String schemaName) {
}
@Override
public void dropSchema(String databaseName, String schemaName) {
public void dropSchema(Connection connection,String databaseName, String schemaName) {
}
@Override
public void modifySchema(String databaseName, String schemaName, String newSchemaName) {
public void modifySchema(Connection connection,String databaseName, String schemaName, String newSchemaName) {
}
@Override
public void dropTable(String databaseName, String schemaName, String tableName) {
public void dropTable(Connection connection,String databaseName, String schemaName, String tableName) {
String sql = "DROP TABLE "+ tableName ;
SQLExecutor.getInstance().executeSql(sql, resultSet -> null);
SQLExecutor.getInstance().executeSql(connection,sql, resultSet -> null);
}
}

42
chat2db-server/chat2db-spi/src/main/java/ai/chat2db/spi/jdbc/DefaultMetaService.java
View File

@ -1,6 +1,6 @@
package ai.chat2db.spi.jdbc;
import java.sql.Connection;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@ -23,15 +23,15 @@ import org.apache.commons.beanutils.BeanUtils;
*/
public class DefaultMetaService implements MetaData {
@Override
public List<Database> databases() {
List<String> dataBases = SQLExecutor.getInstance().databases();
public List<Database> databases(Connection connection) {
List<String> dataBases = SQLExecutor.getInstance().databases(connection);
return dataBases.stream().map(str -> Database.builder().name(str).build()).collect(Collectors.toList());
}
@Override
public List<Schema> schemas(String databaseName) {
List<Map<String, String>> maps = SQLExecutor.getInstance().schemas(databaseName, null);
public List<Schema> schemas(Connection connection,String databaseName) {
List<Map<String, String>> maps = SQLExecutor.getInstance().schemas(connection, databaseName, null);
return maps.stream().map(map -> map2Schema(map)).collect(Collectors.toList());
}
@ -46,48 +46,48 @@ public class DefaultMetaService implements MetaData {
}
@Override
public String tableDDL(String databaseName, String schemaName, String tableName) {
public String tableDDL(Connection connection,String databaseName, String schemaName, String tableName) {
return null;
}
@Override
public List<Table> tables(String databaseName, String schemaName, String tableName) {
return SQLExecutor.getInstance().tables(databaseName, schemaName, tableName, new String[]{"TABLE"});
public List<Table> tables(Connection connection,String databaseName, String schemaName, String tableName) {
return SQLExecutor.getInstance().tables(connection,databaseName, schemaName, tableName, new String[]{"TABLE"});
}
@Override
public List<Table> views(String databaseName, String schemaName) {
return SQLExecutor.getInstance().tables(databaseName, schemaName, null, new String[]{"VIEW"});
public List<Table> views(Connection connection,String databaseName, String schemaName) {
return SQLExecutor.getInstance().tables(connection,databaseName, schemaName, null, new String[]{"VIEW"});
}
@Override
public List<Function> functions(String databaseName, String schemaName) {
return SQLExecutor.getInstance().functions(databaseName, schemaName);
public List<Function> functions(Connection connection,String databaseName, String schemaName) {
return SQLExecutor.getInstance().functions(connection,databaseName, schemaName);
}
@Override
public List<Trigger> triggers(String databaseName, String schemaName) {
public List<Trigger> triggers(Connection connection,String databaseName, String schemaName) {
return null;
}
@Override
public List<Procedure> procedures(String databaseName, String schemaName) {
return SQLExecutor.getInstance().procedures(databaseName, schemaName);
public List<Procedure> procedures(Connection connection,String databaseName, String schemaName) {
return SQLExecutor.getInstance().procedures(connection,databaseName, schemaName);
}
@Override
public List<TableColumn> columns(String databaseName, String schemaName, String tableName) {
return SQLExecutor.getInstance().columns(databaseName, schemaName, tableName, null);
public List<TableColumn> columns(Connection connection,String databaseName, String schemaName, String tableName) {
return SQLExecutor.getInstance().columns(connection,databaseName, schemaName, tableName, null);
}
@Override
public List<TableColumn> columns(String databaseName, String schemaName, String tableName,
public List<TableColumn> columns(Connection connection,String databaseName, String schemaName, String tableName,
String columnName) {
return SQLExecutor.getInstance().columns(databaseName, schemaName, tableName, columnName);
return SQLExecutor.getInstance().columns(connection,databaseName, schemaName, tableName, columnName);
}
@Override
public List<TableIndex> indexes(String databaseName, String schemaName, String tableName) {
return SQLExecutor.getInstance().indexes(databaseName, schemaName, tableName);
public List<TableIndex> indexes(Connection connection,String databaseName, String schemaName, String tableName) {
return SQLExecutor.getInstance().indexes(connection,databaseName, schemaName, tableName);
}
}

2
chat2db-server/chat2db-spi/src/main/java/ai/chat2db/spi/sql/Chat2DBContext.java
View File

@ -138,7 +138,7 @@ public class Chat2DBContext {
connectInfo.setSession(session);
connectInfo.setConnection(connection);
if (StringUtils.isNotBlank(connectInfo.getDatabaseName())) {
PLUGIN_MAP.get(getConnectInfo().getDbType()).getDBManage().connectDatabase(
PLUGIN_MAP.get(getConnectInfo().getDbType()).getDBManage().connectDatabase(connection,
connectInfo.getDatabaseName());
}
return connection;

61
chat2db-server/chat2db-spi/src/main/java/ai/chat2db/spi/sql/SQLExecutor.java
View File

@ -48,27 +48,27 @@ public class SQLExecutor {
return INSTANCE;
}
public Connection getConnection() throws SQLException {
return Chat2DBContext.getConnection();
}
//public Connection connection throws SQLException {
// return Chat2DBContext.connection;
//}
public void close() {
}
/**
* 执行sql
*
* @param connection
* @param sql
* @param function
* @return
*/
public <R> R executeSql(String sql, Function<ResultSet, R> function) {
public <R> R executeSql(Connection connection,String sql, Function<ResultSet, R> function) {
if (StringUtils.isEmpty(sql)) {
return null;
}
log.info("execute:{}", sql);
try (Statement stmt = getConnection().createStatement();) {
try (Statement stmt = connection.createStatement();) {
boolean query = stmt.execute(sql);
// 代表是查询
if (query) {
@ -148,22 +148,23 @@ public class SQLExecutor {
/**
* 执行sql
*
* @param connection
* @param sql
* @return
* @throws SQLException
*/
public ExecuteResult execute(String sql) throws SQLException {
return execute(sql, getConnection());
public ExecuteResult execute(Connection connection,String sql) throws SQLException {
return execute(sql, connection);
}
/**
* 获取所有的数据库
*
* @param connection
* @return
*/
public List<String> databases() {
public List<String> databases(Connection connection) {
List<String> tables = Lists.newArrayList();
try (ResultSet resultSet = getConnection().getMetaData().getCatalogs();) {
try (ResultSet resultSet = connection.getMetaData().getCatalogs();) {
if (resultSet != null) {
while (resultSet.next()) {
tables.add(resultSet.getString("TABLE_CAT"));
@ -177,15 +178,15 @@ public class SQLExecutor {
/**
* 获取所有的schema
*
* @param connection
* @param databaseName
* @param schemaName
* @return
*/
public List<Map<String, String>> schemas(String databaseName, String schemaName) {
public List<Map<String, String>> schemas(Connection connection,String databaseName, String schemaName) {
List<Map<String, String>> schemaList = Lists.newArrayList();
if (StringUtils.isEmpty(databaseName) && StringUtils.isEmpty(schemaName)) {
try (ResultSet resultSet = getConnection().getMetaData().getSchemas()) {
try (ResultSet resultSet = connection.getMetaData().getSchemas()) {
if (resultSet != null) {
while (resultSet.next()) {
Map<String, String> map = new HashMap<>();
@ -199,7 +200,7 @@ public class SQLExecutor {
}
return schemaList;
}
try (ResultSet resultSet = getConnection().getMetaData().getSchemas(databaseName, schemaName)) {
try (ResultSet resultSet = connection.getMetaData().getSchemas(databaseName, schemaName)) {
if (resultSet != null) {
while (resultSet.next()) {
Map<String, String> map = new HashMap<>();
@ -216,17 +217,17 @@ public class SQLExecutor {
/**
* 获取所有的数据库表
*
* @param connection
* @param databaseName
* @param schemaName
* @param tableName
* @param types
* @return
*/
public List<Table> tables(String databaseName, String schemaName, String tableName, String types[]) {
public List<Table> tables(Connection connection,String databaseName, String schemaName, String tableName, String types[]) {
List<Table> tables = Lists.newArrayList();
int n = 0;
try (ResultSet resultSet = getConnection().getMetaData().getTables(databaseName, schemaName, tableName,
try (ResultSet resultSet = connection.getMetaData().getTables(databaseName, schemaName, tableName,
types)) {
if (resultSet != null) {
while (resultSet.next()) {
@ -245,16 +246,16 @@ public class SQLExecutor {
/**
* 获取所有的数据库表列
*
* @param connection
* @param databaseName
* @param schemaName
* @param tableName
* @param columnName
* @return
*/
public List<TableColumn> columns(String databaseName, String schemaName, String tableName, String columnName) {
public List<TableColumn> columns(Connection connection,String databaseName, String schemaName, String tableName, String columnName) {
List<TableColumn> tableColumns = Lists.newArrayList();
try (ResultSet resultSet = getConnection().getMetaData().getColumns(databaseName, schemaName, tableName,
try (ResultSet resultSet = connection.getMetaData().getColumns(databaseName, schemaName, tableName,
columnName)) {
if (resultSet != null) {
while (resultSet.next()) {
@ -269,15 +270,15 @@ public class SQLExecutor {
/**
* 获取所有的数据库表索引
*
* @param connection
* @param databaseName
* @param schemaName
* @param tableName
* @return
*/
public List<TableIndex> indexes(String databaseName, String schemaName, String tableName) {
public List<TableIndex> indexes(Connection connection,String databaseName, String schemaName, String tableName) {
List<TableIndex> tableIndices = Lists.newArrayList();
try (ResultSet resultSet = getConnection().getMetaData().getIndexInfo(databaseName, schemaName, tableName,
try (ResultSet resultSet = connection.getMetaData().getIndexInfo(databaseName, schemaName, tableName,
false,
false)) {
List<TableIndexColumn> tableIndexColumns = Lists.newArrayList();
@ -307,15 +308,15 @@ public class SQLExecutor {
/**
* 获取所有的函数
*
* @param connection
* @param databaseName
* @param schemaName
* @return
*/
public List<ai.chat2db.spi.model.Function> functions(String databaseName,
public List<ai.chat2db.spi.model.Function> functions(Connection connection,String databaseName,
String schemaName) {
List<ai.chat2db.spi.model.Function> functions = Lists.newArrayList();
try (ResultSet resultSet = getConnection().getMetaData().getFunctions(databaseName, schemaName, null);) {
try (ResultSet resultSet = connection.getMetaData().getFunctions(databaseName, schemaName, null);) {
while (resultSet != null && resultSet.next()) {
functions.add(buildFunction(resultSet));
}
@ -327,14 +328,14 @@ public class SQLExecutor {
/**
* 获取所有的存储过程
*
* @param connection
* @param databaseName
* @param schemaName
* @return
*/
public List<Procedure> procedures(String databaseName, String schemaName) {
public List<Procedure> procedures(Connection connection,String databaseName, String schemaName) {
List<Procedure> procedures = Lists.newArrayList();
try (ResultSet resultSet = getConnection().getMetaData().getProcedures(databaseName, schemaName, null)) {
try (ResultSet resultSet = connection.getMetaData().getProcedures(databaseName, schemaName, null)) {
while (resultSet != null && resultSet.next()) {
procedures.add(buildProcedure(resultSet));
}