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

@@ -6,6 +6,7 @@ import com.dbx.agent.DatabaseInfo;
import com.dbx.agent.ExecuteQueryOptions;
import com.dbx.agent.JdbcAgentProfile;
import com.dbx.agent.JsonRpcServer;
import com.dbx.agent.MetadataListConstraints;
import com.dbx.agent.QueryResult;
import com.dbx.agent.TableInfo;
import java.sql.Connection;
@@ -185,6 +186,60 @@ public final class Gbase8sAgent extends ConfiguredJdbcAgent {
}
}
@Override
public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
if (isUnconstrained(normalized)) {
return listTables(schema);
}
return queryConstrainedTables(schema, normalized);
}
private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
if (!constraints.includesTableLikeTypes()) {
return List.of();
}
try {
List<TableInfo> result = new ArrayList<>();
List<Object> args = new ArrayList<>();
String owner = trim(schema);
// GBase 8s follows Informix-style SKIP/FIRST pagination in the SELECT list.
StringBuilder sql = new StringBuilder("SELECT ");
if (constraints.hasOffset()) {
sql.append("SKIP ").append(constraints.getOffset()).append(' ');
}
if (constraints.hasLimit()) {
sql.append("FIRST ").append(constraints.getLimit()).append(' ');
}
sql.append("tabname, tabtype FROM systables WHERE tabid >= 100");
appendGbase8sTableTypePredicate(sql, constraints);
if (!owner.isEmpty()) {
sql.append(" AND owner = ?");
args.add(owner);
}
if (constraints.hasFilter()) {
sql.append(" AND UPPER(tabname) LIKE ? ESCAPE '\\\\'");
args.add(constraints.fuzzyLikePattern().toUpperCase(Locale.ROOT));
}
sql.append(" ORDER BY tabname");
try (PreparedStatement stmt = requireConnection().prepareStatement(sql.toString())) {
bind(stmt, args);
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
result.add(new TableInfo(
trim(rs.getString("tabname")),
tableType(rs.getString("tabtype"))
));
}
}
}
result.sort(Comparator.comparing(TableInfo::getName));
return constraints.withoutPaging().filterTables(result);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
new JsonRpcServer(new Gbase8sAgent()).run();
}
@@ -281,6 +336,38 @@ public final class Gbase8sAgent extends ConfiguredJdbcAgent {
return "V".equalsIgnoreCase(trim(tabtype)) ? "VIEW" : "TABLE";
}
private static void appendGbase8sTableTypePredicate(StringBuilder sql, MetadataListConstraints constraints) {
if (!constraints.hasObjectTypes()) {
sql.append(" AND tabtype IN ('T', 'V')");
return;
}
List<String> tabTypes = new ArrayList<>();
if (constraints.tableTypeAllowed("TABLE")) {
tabTypes.add("'T'");
}
if (constraints.tableTypeAllowed("VIEW")) {
tabTypes.add("'V'");
}
if (tabTypes.isEmpty()) {
sql.append(" AND 1 = 0");
return;
}
sql.append(" AND tabtype IN (").append(String.join(", ", tabTypes)).append(")");
}
private static void bind(PreparedStatement stmt, List<Object> args) throws Exception {
for (int index = 0; index < args.size(); index += 1) {
stmt.setString(index + 1, String.valueOf(args.get(index)));
}
}
private static boolean isUnconstrained(MetadataListConstraints constraints) {
return !constraints.hasFilter()
&& !constraints.hasLimit()
&& !constraints.hasOffset()
&& !constraints.hasObjectTypes();
}
private static String trim(String value) {
return value == null ? "" : value.trim();
}
@@ -1,9 +1,21 @@
package com.dbx.agent.gbase8s;
import com.dbx.agent.ConnectParams;
import com.dbx.agent.MetadataListConstraints;
import com.dbx.agent.TableInfo;
import com.dbx.agent.test.TestSupport;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
class Gbase8sAgentTest {
@Test
void declaresGbase8sProfile() {
@@ -95,4 +107,108 @@ class Gbase8sAgentTest {
Assertions.assertEquals("jdbc:gbasedbt-sqli://db.example.com:20013/app:GBASEDBTSERVER=gbase01", url);
}
@Test
void constrainedListTablesUsesGbase8sSystemTableQuery() {
List<String> sql = new ArrayList<>();
Gbase8sAgent agent = new Gbase8sAgent();
TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
new String[]{"tabname", "tabtype"},
new Object[][]{
{"user_order", "T"}
}
)));
List<TableInfo> tables = agent.listTables(
"app",
new MetadataListConstraints("user", 1, 1, List.of("TABLE"))
);
Assertions.assertEquals(1, tables.size());
Assertions.assertEquals("user_order", tables.get(0).getName());
Assertions.assertTrue(sql.get(0).contains("FROM systables"), sql.get(0));
Assertions.assertTrue(sql.get(0).contains("SELECT SKIP 1 FIRST 1"), sql.get(0));
Assertions.assertTrue(sql.get(0).contains("UPPER(tabname) LIKE ?"), sql.get(0));
}
private static Connection preparedConnection(List<String> sql, ResultSet resultSet) {
PreparedStatement statement = proxy(PreparedStatement.class, (method, args) -> {
if ("executeQuery".equals(method.getName())) {
return resultSet;
}
if ("setString".equals(method.getName()) || "close".equals(method.getName())) {
return null;
}
return defaultValue(method.getReturnType());
});
return proxy(Connection.class, (method, args) -> {
if ("getCatalog".equals(method.getName())) {
return "appdb";
}
if ("prepareStatement".equals(method.getName())) {
sql.add(String.valueOf(args[0]));
return statement;
}
if ("isClosed".equals(method.getName())) {
return false;
}
return defaultValue(method.getReturnType());
});
}
private static ResultSet resultSet(String[] columns, Object[][] rows) {
int[] index = {-1};
return proxy(ResultSet.class, (method, args) -> {
switch (method.getName()) {
case "next":
index[0] += 1;
return index[0] < rows.length;
case "getString":
Object value = columnValue(columns, rows[index[0]], args[0]);
return value == null ? null : String.valueOf(value);
case "close":
return null;
default:
return defaultValue(method.getReturnType());
}
});
}
private static Object columnValue(String[] columns, Object[] row, Object key) {
if (key instanceof Number) {
return row[((Number) key).intValue() - 1];
}
for (int i = 0; i < columns.length; i++) {
if (columns[i].equalsIgnoreCase(String.valueOf(key))) {
return row[i];
}
}
return null;
}
private static <T> T proxy(Class<T> type, MethodHandler handler) {
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return handler.handle(method, args == null ? new Object[0] : args);
}
};
return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
}
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 0d;
if (type == Character.TYPE) return (char) 0;
return null;
}
private interface MethodHandler {
Object handle(Method method, Object[] args) throws Throwable;
}
}