feat(metadata): optimize agent metadata loading

This commit is contained in:
t8y2 committed 2026-07-05 12:09:24 +08:00
1 parent 8883a6b3b7
commit e74782f651
65 files changed
+6192 -571

No files matched your search

@@ -9,6 +9,8 @@ import com.dbx.agent.IndexInfo;
import com.dbx.agent.JdbcExecutor;
import com.dbx.agent.JdbcIdentifiers;
import com.dbx.agent.JsonRpcServer;
import com.dbx.agent.MetadataListConstraints;
import com.dbx.agent.MetadataSqlSupport;
import com.dbx.agent.ObjectInfo;
import com.dbx.agent.ObjectSource;
import com.dbx.agent.TableInfo;
@@ -93,6 +95,45 @@ public final class H2Agent extends AbstractJdbcAgent {
});
}
@Override
public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
if (isUnconstrained(normalized)) {
return listTables(schema);
}
if (!normalized.includesTableLikeTypes()) {
return List.of();
}
try {
return queryConstrainedTables(schema, normalized);
} catch (RuntimeException e) {
return normalized.filterTables(listTables(schema));
}
}
private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
return unchecked(() -> {
String effectiveSchema = resolveSchema(schema);
List<TableInfo> result = new ArrayList<>();
List<Object> args = new ArrayList<>();
StringBuilder sql = new StringBuilder("SELECT TABLE_NAME, TABLE_TYPE FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ?");
args.add(effectiveSchema);
appendH2TableTypePredicate(sql, args, constraints);
MetadataSqlSupport.appendNameFilter(sql, args, "TABLE_NAME", constraints);
sql.append(" ORDER BY TABLE_NAME");
MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
try (var stmt = requireConnected().prepareStatement(sql.toString())) {
MetadataSqlSupport.bind(stmt, args);
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
result.add(new TableInfo(rs.getString("TABLE_NAME"), normalizeTableType(rs.getString("TABLE_TYPE")), null));
}
}
}
return constraints.withoutPaging().filterTables(result);
});
}
@Override
public List<ObjectInfo> listObjects(String schema) {
return unchecked(() -> {
@@ -116,6 +157,61 @@ public final class H2Agent extends AbstractJdbcAgent {
});
}
@Override
public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
if (isUnconstrained(normalized)) {
return listObjects(schema);
}
if (!includesSupportedObjects(normalized)) {
return List.of();
}
try {
return queryConstrainedObjects(schema, normalized);
} catch (RuntimeException e) {
return normalized.filterObjects(listObjects(schema));
}
}
private List<ObjectInfo> queryConstrainedObjects(String schema, MetadataListConstraints constraints) {
return unchecked(() -> {
String effectiveSchema = resolveSchema(schema);
List<ObjectInfo> result = new ArrayList<>();
List<String> branches = new ArrayList<>();
List<Object> args = new ArrayList<>();
if (constraints.includesTableLikeTypes()) {
StringBuilder tableSql = new StringBuilder("SELECT TABLE_NAME AS OBJECT_NAME, TABLE_TYPE AS OBJECT_TYPE FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ?");
args.add(effectiveSchema);
appendH2TableTypePredicate(tableSql, args, constraints);
MetadataSqlSupport.appendNameFilter(tableSql, args, "TABLE_NAME", constraints);
branches.add(tableSql.toString());
}
if (constraints.objectTypeAllowed("PROCEDURE") || constraints.objectTypeAllowed("FUNCTION")) {
StringBuilder routineSql = new StringBuilder("SELECT ROUTINE_NAME AS OBJECT_NAME, ROUTINE_TYPE AS OBJECT_TYPE FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA = ?");
args.add(effectiveSchema);
appendRoutineTypePredicate(routineSql, args, constraints);
MetadataSqlSupport.appendNameFilter(routineSql, args, "ROUTINE_NAME", constraints);
branches.add(routineSql.toString());
}
if (branches.isEmpty()) {
return List.of();
}
StringBuilder sql = new StringBuilder("SELECT OBJECT_NAME, OBJECT_TYPE FROM (")
.append(String.join(" UNION ALL ", branches))
.append(") metadata_objects ORDER BY CASE OBJECT_TYPE WHEN 'BASE TABLE' THEN 0 WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'PROCEDURE' THEN 2 WHEN 'FUNCTION' THEN 3 ELSE 9 END, OBJECT_NAME");
MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
try (var stmt = requireConnected().prepareStatement(sql.toString())) {
MetadataSqlSupport.bind(stmt, args);
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
result.add(new ObjectInfo(rs.getString(1), normalizeTableType(rs.getString(2)), schema, null));
}
}
}
return constraints.withoutPaging().filterObjects(result);
});
}
@Override
public ObjectSource getObjectSource(String schema, String name, String objectType) {
return unchecked(() -> {
@@ -346,6 +442,58 @@ public final class H2Agent extends AbstractJdbcAgent {
return "jdbc:h2:tcp://" + params.getHost() + ":" + params.getPort() + "/" + params.getDatabase();
}
private static boolean isUnconstrained(MetadataListConstraints constraints) {
return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
}
private static boolean includesSupportedObjects(MetadataListConstraints constraints) {
return constraints.includesTableLikeTypes()
|| constraints.objectTypeAllowed("PROCEDURE")
|| constraints.objectTypeAllowed("FUNCTION");
}
private static void appendH2TableTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
if (!constraints.hasObjectTypes()) {
return;
}
List<String> types = new ArrayList<>();
if (constraints.tableTypeAllowed("TABLE")) {
types.add("BASE TABLE");
}
if (constraints.tableTypeAllowed("VIEW")) {
types.add("VIEW");
}
if (types.isEmpty()) {
sql.append(" AND 1 = 0");
return;
}
sql.append(" AND TABLE_TYPE IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
args.addAll(types);
}
private static void appendRoutineTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
if (!constraints.hasObjectTypes()) {
return;
}
List<String> types = new ArrayList<>();
if (constraints.objectTypeAllowed("PROCEDURE")) {
types.add("PROCEDURE");
}
if (constraints.objectTypeAllowed("FUNCTION")) {
types.add("FUNCTION");
}
if (types.isEmpty()) {
sql.append(" AND 1 = 0");
return;
}
sql.append(" AND ROUTINE_TYPE IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
args.addAll(types);
}
private static String normalizeTableType(String tableType) {
return "BASE TABLE".equals(tableType) ? "TABLE" : tableType;
}
private static String resolveSchema(String schema) {
if ("PUBLIC".equalsIgnoreCase(schema) || "INFORMATION_SCHEMA".equalsIgnoreCase(schema)) {
return schema.toUpperCase(Locale.ROOT);
@@ -4,7 +4,9 @@ import com.dbx.agent.BaseDatabaseAgent;
import com.dbx.agent.ConnectParams;
import com.dbx.agent.DatabaseAgent;
import com.dbx.agent.ExecuteQueryOptions;
import com.dbx.agent.MetadataListConstraints;
import com.dbx.agent.QueryResult;
import com.dbx.agent.TableInfo;
import com.dbx.agent.test.JdbcExecutionBehaviorTest;
import com.dbx.agent.test.JdbcMetadataBehaviorTest;
import java.util.List;
@@ -132,6 +134,23 @@ class H2MetadataBehaviorTest extends JdbcMetadataBehaviorTest {
protected List<String> expectedColumnsInOrder() {
return List.of("ID", "NAME", "CREATED_AT");
}
@Test
void constrainedTableMetadataFiltersTypesAndPages() {
withAgent("dbx-agent-h2-constrained-metadata", agent -> {
for (String sql : metadataFixtureSql()) {
agent.executeQuery(sql, null, new ExecuteQueryOptions());
}
List<TableInfo> tables = agent.listTables(
metadataSchema(),
new MetadataListConstraints("table", 1, 1, List.of("TABLE"))
);
Assertions.assertEquals(1, tables.size());
Assertions.assertEquals("BETA_TABLE", tables.get(0).getName());
});
}
}
final class H2AgentTestSupport {