feat(agents): move agents into dbx repo
This commit is contained in:
1 parent
ab35fda299
commit
3a25487dea
215 files changed
+29740
-15
No files matched your search
@@ -0,0 +1,11 @@
|
||||
dependencies {
|
||||
implementation fileTree(dir: 'libs', include: ['*.jar'])
|
||||
implementation 'com.oracle.database.jdbc:ojdbc17:23.26.2.0.0'
|
||||
implementation 'com.oracle.database.nls:orai18n:23.26.2.0.0'
|
||||
}
|
||||
|
||||
tasks.named('shadowJar') {
|
||||
manifest {
|
||||
attributes('Agent-Label': 'Oracle', 'Main-Class': 'com.dbx.agent.oracle.OracleAgent')
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,616 @@
|
||||
package com.dbx.agent.oracle;
|
||||
|
||||
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.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.Properties;
|
||||
import java.util.Set;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class OracleAgent extends BaseDatabaseAgent {
|
||||
private static final Set<String> SYSTEM_SCHEMAS = Set.of(
|
||||
"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", "GSMROOTUSER", "SYSRAC"
|
||||
);
|
||||
|
||||
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 offsetMatcher = OFFSET_FETCH_RE.matcher(sql);
|
||||
if (offsetMatcher.matches()) {
|
||||
String innerSql = offsetMatcher.group(1);
|
||||
long offset = Long.parseLong(offsetMatcher.group(2));
|
||||
long limit = Long.parseLong(offsetMatcher.group(4));
|
||||
long upper = offset + limit;
|
||||
return "SELECT * FROM (SELECT a.*, ROWNUM rn__ FROM (" + innerSql + ") a WHERE ROWNUM <= " + upper
|
||||
+ ") WHERE rn__ > " + offset;
|
||||
}
|
||||
|
||||
Matcher fetchMatcher = FETCH_ONLY_RE.matcher(sql);
|
||||
if (fetchMatcher.matches()) {
|
||||
String innerSql = fetchMatcher.group(1);
|
||||
long limit = Long.parseLong(fetchMatcher.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");
|
||||
String serviceName = params.getDatabase();
|
||||
Properties props = connectionProperties(params);
|
||||
|
||||
if (serviceName.toUpperCase(Locale.ROOT).startsWith("SYSDBA:")) {
|
||||
serviceName = serviceName.substring(7);
|
||||
props.setProperty("internal_logon", "SYSDBA");
|
||||
}
|
||||
|
||||
connection = DriverManager.getConnection(buildUrl(params, serviceName), props);
|
||||
try (var stmt = connection.createStatement()) {
|
||||
stmt.execute("ALTER SESSION SET NLS_LANGUAGE='AMERICAN'");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean testConnection(ConnectParams params) {
|
||||
return unchecked(() -> {
|
||||
Class.forName("oracle.jdbc.OracleDriver");
|
||||
String serviceName = params.getDatabase();
|
||||
Properties props = connectionProperties(params);
|
||||
|
||||
if (serviceName.toUpperCase(Locale.ROOT).startsWith("SYSDBA:")) {
|
||||
serviceName = serviceName.substring(7);
|
||||
props.setProperty("internal_logon", "SYSDBA");
|
||||
}
|
||||
|
||||
try (Connection conn = DriverManager.getConnection(buildUrl(params, serviceName), props)) {
|
||||
return conn.isValid(5);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<DatabaseInfo> listDatabases() {
|
||||
return unchecked(() -> {
|
||||
try {
|
||||
return queryDatabaseInfos(listDatabasesSql());
|
||||
} catch (SQLException e) {
|
||||
if (isPgaLimitError(e)) {
|
||||
return currentSchemaDatabase();
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
static String listDatabasesSql() {
|
||||
String placeholders = SYSTEM_SCHEMAS.stream()
|
||||
.map(schema -> "'" + schema + "'")
|
||||
.collect(Collectors.joining(","));
|
||||
return """
|
||||
SELECT username AS owner
|
||||
FROM all_users
|
||||
WHERE username IS NOT NULL
|
||||
AND username NOT IN (%s)
|
||||
AND username NOT LIKE 'APEX_%%'
|
||||
AND username NOT LIKE 'FLOWS_%%'
|
||||
AND username NOT LIKE '%%$%%'
|
||||
ORDER BY CASE
|
||||
WHEN username = SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') THEN 0
|
||||
WHEN username = SYS_CONTEXT('USERENV', 'SESSION_USER') THEN 1
|
||||
ELSE 2
|
||||
END, username
|
||||
""".formatted(placeholders).stripIndent().trim();
|
||||
}
|
||||
|
||||
static boolean isPgaLimitError(SQLException error) {
|
||||
for (Throwable current = error; current != null; current = current.getCause()) {
|
||||
if (current instanceof SQLException sqlException) {
|
||||
if (sqlException.getErrorCode() == 4036 || String.valueOf(sqlException.getMessage()).contains("ORA-04036")) {
|
||||
return true;
|
||||
}
|
||||
SQLException next = sqlException.getNextException();
|
||||
while (next != null) {
|
||||
if (next.getErrorCode() == 4036 || String.valueOf(next.getMessage()).contains("ORA-04036")) {
|
||||
return true;
|
||||
}
|
||||
next = next.getNextException();
|
||||
}
|
||||
} else if (String.valueOf(current.getMessage()).contains("ORA-04036")) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private List<DatabaseInfo> queryDatabaseInfos(String sql) throws SQLException {
|
||||
List<DatabaseInfo> result = new ArrayList<>();
|
||||
try (var stmt = requireConnected().createStatement();
|
||||
ResultSet rs = stmt.executeQuery(sql)) {
|
||||
while (rs.next()) {
|
||||
result.add(new DatabaseInfo(rs.getString(1)));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private List<DatabaseInfo> currentSchemaDatabase() throws SQLException {
|
||||
try (var stmt = requireConnected().createStatement();
|
||||
ResultSet rs = stmt.executeQuery("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL")) {
|
||||
if (rs.next()) {
|
||||
String schema = rs.getString(1);
|
||||
if (schema != null && !schema.isBlank()) {
|
||||
return List.of(new DatabaseInfo(schema));
|
||||
}
|
||||
}
|
||||
}
|
||||
return List.of();
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> listSchemas() {
|
||||
List<String> result = new ArrayList<>();
|
||||
for (DatabaseInfo database : listDatabases()) {
|
||||
result.add(database.getName());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<TableInfo> listTables(String schema) {
|
||||
return unchecked(() -> {
|
||||
try {
|
||||
String sql = """
|
||||
SELECT /*+ NO_QUERY_TRANSFORMATION */ 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
|
||||
""".stripIndent().trim();
|
||||
|
||||
List<TableInfo> result = new ArrayList<>();
|
||||
try (var 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;
|
||||
} catch (SQLException e) {
|
||||
if (isPgaLimitError(e)) {
|
||||
return List.of();
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<ObjectInfo> listObjects(String schema) {
|
||||
return unchecked(() -> {
|
||||
try {
|
||||
String sql = """
|
||||
SELECT /*+ NO_QUERY_TRANSFORMATION */ 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
|
||||
""".stripIndent().trim();
|
||||
|
||||
List<ObjectInfo> result = new ArrayList<>();
|
||||
try (var 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;
|
||||
} catch (SQLException e) {
|
||||
if (isPgaLimitError(e)) {
|
||||
return List.of();
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@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.
|
||||
try (var stmt = requireConnected().prepareStatement(
|
||||
"SELECT TEXT FROM ALL_VIEWS WHERE OWNER = ? AND VIEW_NAME = ?")) {
|
||||
stmt.setString(1, schema);
|
||||
stmt.setString(2, name);
|
||||
try (ResultSet rs = stmt.executeQuery()) {
|
||||
if (rs.next()) {
|
||||
String value = rs.getString(1);
|
||||
source = value == null ? "" : value;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
String dbmsType = switch (upperType) {
|
||||
case "PROCEDURE" -> "PROCEDURE";
|
||||
case "FUNCTION" -> "FUNCTION";
|
||||
default -> throw new IllegalArgumentException("Unsupported object type: " + objectType);
|
||||
};
|
||||
try (var stmt = requireConnected().prepareStatement(
|
||||
"SELECT DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL")) {
|
||||
stmt.setString(1, dbmsType);
|
||||
stmt.setString(2, name);
|
||||
stmt.setString(3, schema);
|
||||
try (ResultSet rs = stmt.executeQuery()) {
|
||||
if (rs.next()) {
|
||||
String value = rs.getString(1);
|
||||
source = value == null ? "" : value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return new ObjectSource(name, objectType, schema, source);
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getTableDdl(String schema, String table) {
|
||||
return unchecked(() -> {
|
||||
try (var stmt = requireConnected().prepareStatement("SELECT DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL")) {
|
||||
stmt.setString(1, "TABLE");
|
||||
stmt.setString(2, table);
|
||||
stmt.setString(3, schema);
|
||||
try (ResultSet rs = stmt.executeQuery()) {
|
||||
if (rs.next()) {
|
||||
String value = rs.getString(1);
|
||||
return value == null ? "" : value;
|
||||
}
|
||||
}
|
||||
}
|
||||
throw new IllegalArgumentException("Table not found: " + schema + "." + table);
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<ColumnInfo> getColumns(String schema, String table) {
|
||||
return unchecked(() -> {
|
||||
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
|
||||
""".stripIndent().trim();
|
||||
|
||||
List<ColumnInfo> result = new ArrayList<>();
|
||||
try (var 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 = intOrNull(rs, "DATA_PRECISION");
|
||||
Integer numScale = intOrNull(rs, "DATA_SCALE");
|
||||
Integer dataLen = intOrNull(rs, "DATA_LENGTH");
|
||||
Integer charLen = intOrNull(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(() -> {
|
||||
String sql = """
|
||||
SELECT i.INDEX_NAME,
|
||||
LISTAGG(ic.COLUMN_NAME, ',') WITHIN GROUP (ORDER BY ic.COLUMN_POSITION) 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
|
||||
""".stripIndent().trim();
|
||||
|
||||
List<IndexInfo> result = new ArrayList<>();
|
||||
try (var stmt = requireConnected().prepareStatement(sql)) {
|
||||
stmt.setString(1, schema);
|
||||
stmt.setString(2, table);
|
||||
try (ResultSet rs = stmt.executeQuery()) {
|
||||
while (rs.next()) {
|
||||
String colsStr = rs.getString(2);
|
||||
List<String> columns = new ArrayList<>();
|
||||
if (colsStr != null && !colsStr.isEmpty()) {
|
||||
columns.addAll(List.of(colsStr.split(",")));
|
||||
}
|
||||
result.add(new IndexInfo(
|
||||
rs.getString(1),
|
||||
columns,
|
||||
"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(() -> {
|
||||
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
|
||||
""".stripIndent().trim();
|
||||
|
||||
List<ForeignKeyInfo> result = new ArrayList<>();
|
||||
try (var 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(() -> {
|
||||
String sql = """
|
||||
SELECT TRIGGER_NAME, TRIGGERING_EVENT, TRIGGER_TYPE
|
||||
FROM ALL_TRIGGERS
|
||||
WHERE OWNER = ? AND TABLE_NAME = ?
|
||||
ORDER BY TRIGGER_NAME
|
||||
""".stripIndent().trim();
|
||||
|
||||
List<TriggerInfo> result = new ArrayList<>();
|
||||
try (var 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(),
|
||||
OracleAgent::stringResultValue
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
|
||||
return JdbcExecutor.INSTANCE.executePage(
|
||||
requireConnected(),
|
||||
prepareExecutableSql(sql),
|
||||
schema,
|
||||
this::setSchemaSQL,
|
||||
options,
|
||||
OracleAgent::stringResultValue
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void disconnect() {
|
||||
uncheckedVoid(() -> {
|
||||
if (connection != null) {
|
||||
connection.close();
|
||||
}
|
||||
connection = null;
|
||||
});
|
||||
}
|
||||
|
||||
private static Properties connectionProperties(ConnectParams params) {
|
||||
Properties props = new Properties();
|
||||
props.setProperty("user", params.getUsername());
|
||||
props.setProperty("password", params.getPassword());
|
||||
props.setProperty("oracle.jdbc.defaultNChar", "true");
|
||||
return props;
|
||||
}
|
||||
|
||||
static String buildUrl(ConnectParams params) {
|
||||
return buildUrl(params, serviceName(params));
|
||||
}
|
||||
|
||||
private static String buildUrl(ConnectParams params, String serviceName) {
|
||||
String connectionString = params.getConnection_string();
|
||||
if (connectionString != null && !connectionString.trim().isEmpty()) {
|
||||
return connectionString;
|
||||
}
|
||||
return "jdbc:oracle:thin:@" + params.getHost() + ":" + params.getPort() + "/" + serviceName;
|
||||
}
|
||||
|
||||
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 formatDataType(
|
||||
String base,
|
||||
Integer numPrec,
|
||||
Integer numScale,
|
||||
Integer dataLen,
|
||||
Integer charLen
|
||||
) {
|
||||
return switch (base.toUpperCase(Locale.ROOT)) {
|
||||
case "VARCHAR2", "NVARCHAR2", "CHAR", "NCHAR" -> {
|
||||
Integer len = charLen == null ? dataLen : charLen;
|
||||
yield len == null ? base : base + "(" + len + ")";
|
||||
}
|
||||
case "NUMBER" -> {
|
||||
if (numPrec != null && numScale != null && numScale > 0) {
|
||||
yield base + "(" + numPrec + "," + numScale + ")";
|
||||
}
|
||||
if (numPrec != null && numPrec > 0) {
|
||||
yield base + "(" + numPrec + ")";
|
||||
}
|
||||
yield base;
|
||||
}
|
||||
case "RAW" -> dataLen == null ? "RAW" : "RAW(" + dataLen + ")";
|
||||
default -> base;
|
||||
};
|
||||
}
|
||||
|
||||
private static Object stringResultValue(ResultSet rs, int index, int sqlType) {
|
||||
try {
|
||||
return JdbcExecutor.stringResultValue(rs, index, sqlType);
|
||||
} catch (SQLException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
private static Integer intOrNull(ResultSet rs, String column) throws Exception {
|
||||
Object value = rs.getObject(column);
|
||||
return value instanceof Number ? ((Number) value).intValue() : null;
|
||||
}
|
||||
|
||||
private static String trimEndSemicolons(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(trimEndSemicolons(trimmed));
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
new JsonRpcServer(new OracleAgent()).run();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
package com.dbx.agent.oracle;
|
||||
|
||||
import com.dbx.agent.DatabaseAgent;
|
||||
import com.dbx.agent.ConnectParams;
|
||||
import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.sql.SQLException;
|
||||
import java.util.Locale;
|
||||
|
||||
class OracleAgentTest extends JdbcFakeExecutionBehaviorTest {
|
||||
@Override
|
||||
protected DatabaseAgent createAgent() {
|
||||
return new OracleAgent();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String resultSetSql() {
|
||||
return "CALL DBMS_XPLAN.DISPLAY_CURSOR()";
|
||||
}
|
||||
|
||||
@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", OracleAgent.buildUrl(params));
|
||||
}
|
||||
|
||||
@Test
|
||||
void prepareExecutableSqlKeepsPlsqlObjectTerminator() {
|
||||
String sql = "CREATE OR REPLACE PROCEDURE APP_PROC AS BEGIN NULL; END;";
|
||||
|
||||
Assertions.assertEquals(sql, OracleAgent.prepareExecutableSql(sql));
|
||||
}
|
||||
|
||||
@Test
|
||||
void prepareExecutableSqlTrimsPlainStatementTerminator() {
|
||||
Assertions.assertEquals("SELECT 1 FROM DUAL", OracleAgent.prepareExecutableSql("SELECT 1 FROM DUAL;"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void prepareExecutableSqlStillRewritesFetchFirst() {
|
||||
Assertions.assertEquals(
|
||||
"SELECT * FROM (SELECT * FROM EMP) WHERE ROWNUM <= 10",
|
||||
OracleAgent.prepareExecutableSql("SELECT * FROM EMP FETCH FIRST 10 ROWS ONLY;")
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
void listDatabasesSqlUsesUserDictionaryInsteadOfObjectDictionary() {
|
||||
String sql = OracleAgent.listDatabasesSql().toUpperCase(Locale.ROOT);
|
||||
|
||||
Assertions.assertTrue(sql.contains("ALL_USERS"));
|
||||
Assertions.assertFalse(sql.contains("ALL_TABLES"));
|
||||
Assertions.assertFalse(sql.contains("ALL_VIEWS"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void detectsPgaLimitError() {
|
||||
Assertions.assertTrue(OracleAgent.isPgaLimitError(new SQLException(
|
||||
"ORA-04036: PGA memory used by the instance exceeds PGA_AGGREGATE_LIMIT",
|
||||
"72000",
|
||||
4036
|
||||
)));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user