feat(agents): move agents into dbx repo

This commit is contained in:
t8y2 committed 2026-06-23 11:38:16 +08:00
1 parent ab35fda299
commit 3a25487dea
215 files changed
+29740 -15

No files matched your search

@@ -0,0 +1,515 @@
package com.dbx.agent.oracle10g;
import com.dbx.agent.BaseDatabaseAgent;
import com.dbx.agent.ColumnInfo;
import com.dbx.agent.ConnectParams;
import com.dbx.agent.DatabaseInfo;
import com.dbx.agent.ExecuteQueryOptions;
import com.dbx.agent.ForeignKeyInfo;
import com.dbx.agent.IndexInfo;
import com.dbx.agent.JdbcExecutor;
import com.dbx.agent.JdbcIdentifiers;
import com.dbx.agent.JsonRpcServer;
import com.dbx.agent.ObjectInfo;
import com.dbx.agent.ObjectSource;
import com.dbx.agent.QueryPageOptions;
import com.dbx.agent.QueryPageResult;
import com.dbx.agent.QueryResult;
import com.dbx.agent.TableInfo;
import com.dbx.agent.TriggerInfo;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public final class Oracle10gAgent extends BaseDatabaseAgent {
private static final List<String> SYSTEM_SCHEMAS = Arrays.asList(
"SYS", "SYSTEM", "SYSMAN", "DBSNMP", "SYSBACKUP", "SYSDG", "SYSKM", "OUTLN",
"AUDSYS", "LBACSYS", "DVF", "DVSYS", "APPQOSSYS", "CTXSYS", "MDSYS", "MDDATA",
"ORDSYS", "ORDDATA", "ORDPLUGINS", "XDB", "ANONYMOUS", "DIP", "EXFSYS",
"GSMADMIN_INTERNAL", "GSMCATUSER", "GSMUSER", "OJVMSYS", "OLAPSYS",
"ORACLE_OCM", "SI_INFORMTN_SCHEMA", "WMSYS", "XS$NULL", "DBSFWUSER",
"REMOTE_SCHEDULER_AGENT", "PDBADMIN", "DGPDB_INT", "OPS$ORACLE",
"GGSYS", "FLOWS_FILES", "APEX_PUBLIC_USER"
);
private static final Pattern OFFSET_FETCH_RE = Pattern.compile(
"(.+?)\\s+OFFSET\\s+(\\d+)\\s+ROWS?\\s+FETCH\\s+(FIRST|NEXT)\\s+(\\d+)\\s+ROWS?\\s+ONLY",
Pattern.CASE_INSENSITIVE
);
private static final Pattern FETCH_ONLY_RE = Pattern.compile(
"(.+?)\\s+FETCH\\s+(FIRST|NEXT)\\s+(\\d+)\\s+ROWS?\\s+ONLY",
Pattern.CASE_INSENSITIVE
);
private static final Pattern PLSQL_OBJECT_DDL_RE = Pattern.compile(
"^\\s*CREATE\\s+(?:OR\\s+REPLACE\\s+)?(?:(?:NON)?EDITIONABLE\\s+)?(?:PROCEDURE|FUNCTION|PACKAGE(?:\\s+BODY)?|TRIGGER|TYPE(?:\\s+BODY)?)\\b",
Pattern.CASE_INSENSITIVE
);
private Connection connection;
@Override
public Connection getConnection() {
return connection;
}
public static String rewriteFetchFirst(String sql) {
Matcher offsetFetch = OFFSET_FETCH_RE.matcher(sql);
if (offsetFetch.matches()) {
String innerSql = offsetFetch.group(1);
long offset = Long.parseLong(offsetFetch.group(2));
long limit = Long.parseLong(offsetFetch.group(4));
long upper = offset + limit;
return "SELECT * FROM (SELECT a.*, ROWNUM rn__ FROM (" + innerSql + ") a WHERE ROWNUM <= " + upper + ") WHERE rn__ > " + offset;
}
Matcher fetchOnly = FETCH_ONLY_RE.matcher(sql);
if (fetchOnly.matches()) {
String innerSql = fetchOnly.group(1);
long limit = Long.parseLong(fetchOnly.group(3));
return "SELECT * FROM (" + innerSql + ") WHERE ROWNUM <= " + limit;
}
return sql;
}
@Override
public String setSchemaSQL(String schema) {
return "ALTER SESSION SET CURRENT_SCHEMA = " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
}
@Override
public void connect(ConnectParams params) {
uncheckedVoid(() -> {
Class.forName("oracle.jdbc.OracleDriver");
connection = DriverManager.getConnection(buildUrl(params), connectionProperties(params));
});
}
@Override
public boolean testConnection(ConnectParams params) {
return unchecked(() -> {
Class.forName("oracle.jdbc.OracleDriver");
try (Connection conn = DriverManager.getConnection(buildUrl(params), connectionProperties(params))) {
return conn.isValid(5);
}
});
}
@Override
public List<DatabaseInfo> listDatabases() {
return unchecked(() -> {
List<DatabaseInfo> result = new ArrayList<>();
String placeholders = quotedSystemSchemas();
String sql = "SELECT owner FROM ("
+ " SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') AS owner FROM DUAL"
+ " UNION"
+ " SELECT DISTINCT owner FROM all_tables"
+ " UNION"
+ " SELECT DISTINCT owner FROM all_views"
+ " )"
+ " WHERE owner IS NOT NULL"
+ " AND owner NOT IN (" + placeholders + ")"
+ " AND owner NOT LIKE 'APEX_%'"
+ " AND owner NOT LIKE 'FLOWS_%'"
+ " ORDER BY owner";
try (Statement stmt = requireConnected().createStatement();
ResultSet rs = stmt.executeQuery(sql)) {
while (rs.next()) {
result.add(new DatabaseInfo(rs.getString(1)));
}
}
return result;
});
}
@Override
public List<String> listSchemas() {
return unchecked(() -> {
List<String> result = new ArrayList<>();
for (DatabaseInfo database : listDatabases()) {
result.add(database.getName());
}
return result;
});
}
@Override
public List<TableInfo> listTables(String schema) {
return unchecked(() -> {
List<TableInfo> result = new ArrayList<>();
String sql = "SELECT o.OBJECT_NAME,"
+ " CASE o.OBJECT_TYPE WHEN 'VIEW' THEN 'VIEW' ELSE 'TABLE' END AS TABLE_TYPE,"
+ " c.COMMENTS"
+ " FROM ALL_OBJECTS o"
+ " LEFT JOIN ALL_TAB_COMMENTS c ON c.OWNER = o.OWNER AND c.TABLE_NAME = o.OBJECT_NAME"
+ " WHERE o.OWNER = ? AND o.OBJECT_TYPE IN ('TABLE','VIEW')"
+ " ORDER BY o.OBJECT_NAME";
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
stmt.setString(1, schema);
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
result.add(new TableInfo(rs.getString(1), rs.getString(2), rs.getString(3)));
}
}
}
return result;
});
}
@Override
public List<ObjectInfo> listObjects(String schema) {
return unchecked(() -> {
List<ObjectInfo> result = new ArrayList<>();
String sql = "SELECT OBJECT_NAME, OBJECT_TYPE FROM ALL_OBJECTS"
+ " WHERE OWNER = ? AND OBJECT_TYPE IN ('TABLE', 'VIEW', 'PROCEDURE', 'FUNCTION')"
+ " ORDER BY CASE OBJECT_TYPE WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'PROCEDURE' THEN 2 ELSE 3 END, OBJECT_NAME";
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
stmt.setString(1, schema);
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
result.add(new ObjectInfo(rs.getString(1), rs.getString(2), schema, null));
}
}
}
return result;
});
}
@Override
public ObjectSource getObjectSource(String schema, String name, String objectType) {
return unchecked(() -> {
String upperType = objectType.toUpperCase(Locale.ROOT);
String source;
if ("VIEW".equals(upperType)) {
// ALL_VIEWS is more reliable than DBMS_METADATA.GET_DDL,
// which fails on XE editions where XSL stylesheets are missing.
String sql = "SELECT TEXT FROM ALL_VIEWS WHERE OWNER = ? AND VIEW_NAME = ?";
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
stmt.setString(1, schema);
stmt.setString(2, name);
try (ResultSet rs = stmt.executeQuery()) {
source = rs.next() ? coalesce(rs.getString(1)) : "";
}
}
} else {
String dbmsType;
switch (upperType) {
case "PROCEDURE":
dbmsType = "PROCEDURE";
break;
case "FUNCTION":
dbmsType = "FUNCTION";
break;
default:
throw new IllegalArgumentException("Unsupported object type: " + objectType);
}
String sql = "SELECT DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL";
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
stmt.setString(1, dbmsType);
stmt.setString(2, name);
stmt.setString(3, schema);
try (ResultSet rs = stmt.executeQuery()) {
source = rs.next() ? coalesce(rs.getString(1)) : "";
}
}
}
return new ObjectSource(name, objectType, schema, source);
});
}
@Override
public String getTableDdl(String schema, String table) {
return unchecked(() -> {
String sql = "SELECT DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL";
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
stmt.setString(1, "TABLE");
stmt.setString(2, table);
stmt.setString(3, schema);
try (ResultSet rs = stmt.executeQuery()) {
if (rs.next()) {
return coalesce(rs.getString(1));
}
}
}
throw new IllegalArgumentException("Table not found: " + schema + "." + table);
});
}
@Override
public List<ColumnInfo> getColumns(String schema, String table) {
return unchecked(() -> {
List<ColumnInfo> result = new ArrayList<>();
String sql = "SELECT c.COLUMN_NAME, c.DATA_TYPE, c.NULLABLE, c.DATA_PRECISION, c.DATA_SCALE,"
+ " c.DATA_LENGTH, c.CHAR_LENGTH, cc.COMMENTS,"
+ " CASE WHEN pk.COLUMN_NAME IS NULL THEN 0 ELSE 1 END AS IS_PK"
+ " FROM ALL_TAB_COLUMNS c"
+ " LEFT JOIN ALL_COL_COMMENTS cc"
+ " ON cc.OWNER = c.OWNER AND cc.TABLE_NAME = c.TABLE_NAME AND cc.COLUMN_NAME = c.COLUMN_NAME"
+ " LEFT JOIN ("
+ " SELECT cols.COLUMN_NAME FROM ALL_CONS_COLUMNS cols"
+ " JOIN ALL_CONSTRAINTS cons"
+ " ON cols.CONSTRAINT_NAME = cons.CONSTRAINT_NAME AND cols.OWNER = cons.OWNER"
+ " WHERE cons.CONSTRAINT_TYPE = 'P' AND cons.OWNER = ? AND cons.TABLE_NAME = ?"
+ " ) pk ON pk.COLUMN_NAME = c.COLUMN_NAME"
+ " WHERE c.OWNER = ? AND c.TABLE_NAME = ?"
+ " ORDER BY c.COLUMN_ID";
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
stmt.setString(1, schema);
stmt.setString(2, table);
stmt.setString(3, schema);
stmt.setString(4, table);
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
String name = rs.getString("COLUMN_NAME");
String baseType = rs.getString("DATA_TYPE");
Integer numPrec = intObject(rs, "DATA_PRECISION");
Integer numScale = intObject(rs, "DATA_SCALE");
Integer dataLen = intObject(rs, "DATA_LENGTH");
Integer charLen = intObject(rs, "CHAR_LENGTH");
String dataType = formatDataType(baseType, numPrec, numScale, dataLen, charLen);
result.add(new ColumnInfo(
name,
dataType,
"Y".equals(rs.getString("NULLABLE")),
null,
rs.getInt("IS_PK") == 1,
null,
rs.getString("COMMENTS"),
numPrec,
numScale,
charLen
));
}
}
}
return result;
});
}
@Override
public List<IndexInfo> listIndexes(String schema, String table) {
return unchecked(() -> {
List<IndexInfo> result = new ArrayList<>();
String sql = "SELECT i.INDEX_NAME,"
+ " RTRIM(XMLAGG(XMLELEMENT(e, ic.COLUMN_NAME || ',') ORDER BY ic.COLUMN_POSITION).EXTRACT('//text()').GETSTRINGVAL(), ',') AS COLUMNS,"
+ " i.UNIQUENESS,"
+ " CASE WHEN c.CONSTRAINT_TYPE = 'P' THEN 1 ELSE 0 END AS IS_PK,"
+ " i.INDEX_TYPE"
+ " FROM ALL_INDEXES i"
+ " JOIN ALL_IND_COLUMNS ic ON i.INDEX_NAME = ic.INDEX_NAME AND i.OWNER = ic.INDEX_OWNER AND i.TABLE_OWNER = ic.TABLE_OWNER"
+ " LEFT JOIN ALL_CONSTRAINTS c ON i.INDEX_NAME = c.INDEX_NAME AND i.TABLE_OWNER = c.OWNER"
+ " AND c.CONSTRAINT_TYPE = 'P'"
+ " WHERE i.TABLE_OWNER = ? AND i.TABLE_NAME = ?"
+ " GROUP BY i.INDEX_NAME, i.UNIQUENESS, c.CONSTRAINT_TYPE, i.INDEX_TYPE"
+ " ORDER BY i.INDEX_NAME";
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
stmt.setString(1, schema);
stmt.setString(2, table);
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
result.add(new IndexInfo(
rs.getString(1),
splitNonEmpty(coalesce(rs.getString(2)), ","),
"UNIQUE".equals(rs.getString(3)),
"1".equals(rs.getString(4)),
null,
rs.getString(5),
null,
null
));
}
}
}
return result;
});
}
@Override
public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
return unchecked(() -> {
List<ForeignKeyInfo> result = new ArrayList<>();
String sql = "SELECT c.CONSTRAINT_NAME, cc.COLUMN_NAME, rc.TABLE_NAME, rcc.COLUMN_NAME"
+ " FROM ALL_CONSTRAINTS c"
+ " JOIN ALL_CONS_COLUMNS cc ON c.CONSTRAINT_NAME = cc.CONSTRAINT_NAME AND c.OWNER = cc.OWNER"
+ " JOIN ALL_CONSTRAINTS rc ON c.R_CONSTRAINT_NAME = rc.CONSTRAINT_NAME AND c.R_OWNER = rc.OWNER"
+ " JOIN ALL_CONS_COLUMNS rcc ON rc.CONSTRAINT_NAME = rcc.CONSTRAINT_NAME AND rc.OWNER = rcc.OWNER"
+ " WHERE c.CONSTRAINT_TYPE = 'R' AND c.OWNER = ? AND c.TABLE_NAME = ?"
+ " ORDER BY c.CONSTRAINT_NAME";
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
stmt.setString(1, schema);
stmt.setString(2, table);
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
result.add(new ForeignKeyInfo(rs.getString(1), rs.getString(2), rs.getString(3), rs.getString(4)));
}
}
}
return result;
});
}
@Override
public List<TriggerInfo> listTriggers(String schema, String table) {
return unchecked(() -> {
List<TriggerInfo> result = new ArrayList<>();
String sql = "SELECT TRIGGER_NAME, TRIGGERING_EVENT, TRIGGER_TYPE"
+ " FROM ALL_TRIGGERS"
+ " WHERE OWNER = ? AND TABLE_NAME = ?"
+ " ORDER BY TRIGGER_NAME";
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
stmt.setString(1, schema);
stmt.setString(2, table);
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
result.add(new TriggerInfo(rs.getString(1), rs.getString(2), rs.getString(3)));
}
}
}
return result;
});
}
@Override
public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
return JdbcExecutor.INSTANCE.execute(
requireConnected(),
prepareExecutableSql(sql),
schema,
this::setSchemaSQL,
options.getMaxRows(),
options.getFetchSize(),
options.getTimeoutSecs(),
this::stringResultValue
);
}
@Override
public QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
return JdbcExecutor.INSTANCE.executePage(
requireConnected(),
prepareExecutableSql(sql),
schema,
this::setSchemaSQL,
options,
this::stringResultValue
);
}
@Override
public void disconnect() {
uncheckedVoid(() -> {
if (connection != null) {
connection.close();
}
connection = null;
});
}
private Object stringResultValue(ResultSet rs, int index, int sqlType) {
return unchecked(() -> {
return JdbcExecutor.stringResultValue(rs, index, sqlType);
});
}
static String buildUrl(ConnectParams params) {
String connectionString = params.getConnection_string();
if (connectionString != null && !connectionString.trim().isEmpty()) {
return connectionString;
}
return "jdbc:oracle:thin:@" + params.getHost() + ":" + params.getPort() + "/" + serviceName(params);
}
private static Properties connectionProperties(ConnectParams params) {
Properties props = new Properties();
props.put("user", params.getUsername());
props.put("password", params.getPassword());
if (params.getDatabase().toUpperCase(Locale.ROOT).startsWith("SYSDBA:")) {
props.put("internal_logon", "SYSDBA");
}
return props;
}
private static String serviceName(ConnectParams params) {
String serviceName = params.getDatabase();
if (serviceName.toUpperCase(Locale.ROOT).startsWith("SYSDBA:")) {
return serviceName.substring(7);
}
return serviceName;
}
private static String quotedSystemSchemas() {
List<String> quoted = new ArrayList<>();
for (String schema : SYSTEM_SCHEMAS) {
quoted.add("'" + schema + "'");
}
return String.join(",", quoted);
}
private static String trimTrailingSemicolons(String sql) {
String trimmed = sql;
while (trimmed.endsWith(";")) {
trimmed = trimmed.substring(0, trimmed.length() - 1);
}
return trimmed;
}
static String prepareExecutableSql(String sql) {
String trimmed = sql.trim();
if (PLSQL_OBJECT_DDL_RE.matcher(trimmed).find()) {
return trimmed;
}
return rewriteFetchFirst(trimTrailingSemicolons(trimmed));
}
private static String formatDataType(String base, Integer numPrec, Integer numScale, Integer dataLen, Integer charLen) {
switch (base.toUpperCase(Locale.ROOT)) {
case "VARCHAR2":
case "NVARCHAR2":
case "CHAR":
case "NCHAR":
Integer length = charLen != null ? charLen : dataLen;
return length != null ? base + "(" + length + ")" : base;
case "NUMBER":
if (numPrec != null && numScale != null && numScale > 0) {
return base + "(" + numPrec + "," + numScale + ")";
}
return numPrec != null && numPrec > 0 ? base + "(" + numPrec + ")" : base;
case "RAW":
return dataLen != null ? "RAW(" + dataLen + ")" : "RAW";
default:
return base;
}
}
private static Integer intObject(ResultSet rs, String column) throws Exception {
Object value = rs.getObject(column);
return value == null ? null : ((Number) value).intValue();
}
private static List<String> splitNonEmpty(String value, String delimiter) {
List<String> result = new ArrayList<>();
for (String part : value.split(delimiter)) {
if (!part.isEmpty()) {
result.add(part);
}
}
return result;
}
private static String coalesce(String value) {
return value == null ? "" : value;
}
public static void main(String[] args) {
new JsonRpcServer(new Oracle10gAgent()).run();
}
}
@@ -0,0 +1,205 @@
package com.dbx.agent.oracle10g;
import com.dbx.agent.test.TestSupport;
import com.dbx.agent.BaseDatabaseAgent;
import com.dbx.agent.ConnectParams;
import com.dbx.agent.DatabaseAgent;
import com.dbx.agent.ObjectInfo;
import com.dbx.agent.ObjectSource;
import com.dbx.agent.test.JdbcAgentFake;
import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
class Oracle10gAgentTest extends JdbcFakeExecutionBehaviorTest {
@Override
protected DatabaseAgent createAgent() {
return new Oracle10gAgent();
}
@Override
protected String resultSetSql() {
return "CALL DBMS_XPLAN.DISPLAY_CURSOR()";
}
@Test
void agentInheritsBaseDatabaseAgent() {
Assertions.assertTrue(createAgent() instanceof BaseDatabaseAgent);
}
@Test
void buildUrlUsesExplicitConnectionString() {
ConnectParams params = new ConnectParams(
"oracle.example.com",
1521,
"ORCL",
"scott",
"tiger",
"",
"jdbc:oracle:thin:@oracle.example.com:1521:ORCL",
false
);
Assertions.assertEquals("jdbc:oracle:thin:@oracle.example.com:1521:ORCL", Oracle10gAgent.buildUrl(params));
}
@Test
void prepareExecutableSqlKeepsPlsqlObjectTerminator() {
String sql = "CREATE OR REPLACE PROCEDURE APP_PROC AS BEGIN NULL; END;";
Assertions.assertEquals(sql, Oracle10gAgent.prepareExecutableSql(sql));
}
@Test
void prepareExecutableSqlTrimsPlainStatementTerminator() {
Assertions.assertEquals("SELECT 1 FROM DUAL", Oracle10gAgent.prepareExecutableSql("SELECT 1 FROM DUAL;"));
}
@Test
void prepareExecutableSqlStillRewritesFetchFirst() {
Assertions.assertEquals(
"SELECT * FROM (SELECT * FROM EMP) WHERE ROWNUM <= 10",
Oracle10gAgent.prepareExecutableSql("SELECT * FROM EMP FETCH FIRST 10 ROWS ONLY;")
);
}
@Test
void listsTablesViewsProceduresAndFunctions() {
Oracle10gAgent agent = new Oracle10gAgent();
TestSupport.setPrivateConnection(agent, objectListConnection());
List<ObjectInfo> objects = agent.listObjects("APP");
Assertions.assertEquals(
Arrays.asList("TABLE", "VIEW", "PROCEDURE", "FUNCTION"),
objects.stream().map(ObjectInfo::getObject_type).collect(Collectors.toList())
);
Assertions.assertEquals(
Arrays.asList("APP_TABLE", "APP_VIEW", "APP_PROC", "APP_FUNC"),
objects.stream().map(ObjectInfo::getName).collect(Collectors.toList())
);
}
@Test
void loadsRoutineSourceFromDbmsMetadata() {
Oracle10gAgent agent = new Oracle10gAgent();
TestSupport.setPrivateConnection(
agent,
metadataConnection(sql -> Arrays.asList(
Arrays.asList("CREATE OR REPLACE PROCEDURE APP_PROC AS BEGIN NULL; END;")
))
);
ObjectSource source = agent.getObjectSource("APP", "APP_PROC", "PROCEDURE");
Assertions.assertEquals("APP_PROC", source.getName());
Assertions.assertEquals("PROCEDURE", source.getObject_type());
Assertions.assertEquals("APP", source.getSchema());
Assertions.assertEquals("CREATE OR REPLACE PROCEDURE APP_PROC AS BEGIN NULL; END;", source.getSource());
}
private static Connection objectListConnection() {
return metadataConnection(sql -> {
if (sql.contains("'PROCEDURE'")) {
return Arrays.asList(
Arrays.asList("APP_TABLE", "TABLE"),
Arrays.asList("APP_VIEW", "VIEW"),
Arrays.asList("APP_PROC", "PROCEDURE"),
Arrays.asList("APP_FUNC", "FUNCTION")
);
}
return Arrays.asList(
Arrays.asList("APP_TABLE", "TABLE", ""),
Arrays.asList("APP_VIEW", "VIEW", "")
);
});
}
private static Connection metadataConnection(Function<String, List<List<String>>> rowsForSql) {
return proxy(Connection.class, (unused, method, args) -> {
switch (method.getName()) {
case "prepareStatement":
return metadataStatement(rowsForSql.apply((String) args[0]));
case "close":
return null;
case "isClosed":
return false;
default:
return defaultValue(method.getReturnType());
}
});
}
private static PreparedStatement metadataStatement(List<List<String>> rows) {
return proxy(PreparedStatement.class, (unused, method, args) -> {
switch (method.getName()) {
case "executeQuery":
return metadataResultSet(rows);
case "setString":
case "close":
return null;
default:
return defaultValue(method.getReturnType());
}
});
}
private static ResultSet metadataResultSet(List<List<String>> rows) {
int[] index = {-1};
return proxy(ResultSet.class, (unused, method, args) -> {
switch (method.getName()) {
case "next":
index[0] += 1;
return index[0] < rows.size();
case "getString":
return rows.get(index[0]).get(((Integer) args[0]) - 1);
case "close":
return null;
default:
return defaultValue(method.getReturnType());
}
});
}
@SuppressWarnings("unchecked")
private static <T> T proxy(Class<T> type, InvocationHandler handler) {
return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, handler);
}
private static Object defaultValue(Class<?> type) {
if (type == Boolean.TYPE) {
return false;
}
if (type == Byte.TYPE) {
return (byte) 0;
}
if (type == Short.TYPE) {
return (short) 0;
}
if (type == Integer.TYPE) {
return 0;
}
if (type == Long.TYPE) {
return 0L;
}
if (type == Float.TYPE) {
return 0F;
}
if (type == Double.TYPE) {
return 0.0D;
}
if (type == Character.TYPE) {
return '\0';
}
return null;
}
}