fix(tdengine): group subtables under super tables

This commit is contained in:
zipg authored and GitHub committed 2026-07-11 00:12:45 +08:00
1 parent dd8f4a0f87
commit 9cf62a1c71
15 files changed
+521 -39

No files matched your search

@@ -9,6 +9,8 @@ import com.dbx.agent.ForeignKeyInfo;
import com.dbx.agent.IndexInfo;
import com.dbx.agent.JdbcExecutor;
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.QueryPageOptions;
@@ -25,7 +27,6 @@ import java.sql.Types;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
@@ -98,6 +99,24 @@ public final class TDengineAgent extends BaseDatabaseAgent {
@Override
public List<TableInfo> listTables(String schema) {
return listTables(schema, MetadataListConstraints.NONE);
}
@Override
public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
if (!normalized.tableTypeAllowed("TABLE")) {
return Collections.emptyList();
}
try {
return queryConstrainedTables(schema, normalized);
} catch (RuntimeException ignored) {
// TDengine 2.x does not expose information_schema.ins_stables/ins_tables.
return normalized.filterTables(listTablesLegacy(schema));
}
}
private List<TableInfo> listTablesLegacy(String schema) {
return unchecked(() -> {
List<TableInfo> result = new ArrayList<>();
result.addAll(queryTables("SHOW " + quoteQualifiedPrefix(schema) + "STABLES", "STABLE"));
@@ -108,7 +127,7 @@ public final class TDengineAgent extends BaseDatabaseAgent {
distinct.putIfAbsent(table.getTable_type() + ":" + table.getName(), table);
}
List<TableInfo> sorted = new ArrayList<>(distinct.values());
sorted.sort(Comparator.comparing(table -> table.getName().toLowerCase(Locale.ROOT)));
sortTablesForHierarchy(sorted);
return sorted;
});
}
@@ -232,6 +251,110 @@ public final class TDengineAgent extends BaseDatabaseAgent {
return result;
}
private List<TableInfo> queryConstrainedTables(String database, MetadataListConstraints constraints) {
return unchecked(() -> {
TableMetadataQuery query = buildTableMetadataQuery(database, constraints);
List<TableInfo> result = new ArrayList<>();
try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(query.sql())) {
MetadataSqlSupport.bind(stmt, query.args());
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
result.add(new TableInfo(
rs.getString(1),
rs.getString(2),
optionalString(rs, 3),
null,
optionalString(rs, 4)
));
}
}
}
MetadataListConstraints postFilter = constraints.hasLimit() ? constraints.withoutPaging() : constraints;
return postFilter.filterTables(result);
});
}
static TableMetadataQuery buildTableMetadataQuery(String database, MetadataListConstraints constraints) {
MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
List<Object> args = new ArrayList<>();
StringBuilder sql = new StringBuilder("""
SELECT table_name, table_type, table_comment, parent_name
FROM (
SELECT stable_name AS table_name,
'STABLE' AS table_type,
table_comment,
CAST(NULL AS VARCHAR(192)) AS parent_name,
stable_name AS hierarchy_name,
0 AS hierarchy_rank
FROM information_schema.ins_stables
WHERE db_name = ?
UNION ALL
SELECT table_name,
'TABLE' AS table_type,
table_comment,
stable_name AS parent_name,
CASE WHEN stable_name IS NULL THEN table_name ELSE stable_name END AS hierarchy_name,
1 AS hierarchy_rank
FROM information_schema.ins_tables
WHERE db_name = ?
) metadata
WHERE 1 = 1
""".stripIndent().trim());
args.add(database);
args.add(database);
if (normalized.hasFilter()) {
String pattern = normalized.fuzzyLikePattern();
sql.append(" AND (table_name LIKE ? OR table_comment LIKE ?)");
args.add(pattern);
args.add(pattern);
}
sql.append(" ORDER BY hierarchy_name, hierarchy_rank, table_name");
MetadataSqlSupport.appendLiteralLimitOffset(sql, normalized);
return new TableMetadataQuery(sql.toString(), args);
}
static final class TableMetadataQuery {
private final String sql;
private final List<Object> args;
TableMetadataQuery(String sql, List<Object> args) {
this.sql = sql;
this.args = args;
}
String sql() {
return sql;
}
List<Object> args() {
return args;
}
}
static void sortTablesForHierarchy(List<TableInfo> tables) {
tables.sort((left, right) -> {
String leftGroup = hierarchyGroupName(left);
String rightGroup = hierarchyGroupName(right);
int groupCompared = leftGroup.compareTo(rightGroup);
if (groupCompared != 0) {
return groupCompared;
}
boolean leftIsParent = left.getParent_name() == null;
boolean rightIsParent = right.getParent_name() == null;
if (leftIsParent != rightIsParent) {
return leftIsParent ? -1 : 1;
}
return left.getName().toLowerCase(Locale.ROOT).compareTo(right.getName().toLowerCase(Locale.ROOT));
});
}
private static String hierarchyGroupName(TableInfo table) {
String parentName = table.getParent_name();
String groupName = parentName == null || parentName.trim().isEmpty() ? table.getName() : parentName;
return groupName.toLowerCase(Locale.ROOT);
}
private static List<ColumnInfo> readDescribeColumns(ResultSet rs) throws Exception {
List<ColumnInfo> result = new ArrayList<>();
int ordinal = 0;
@@ -4,12 +4,25 @@ import com.dbx.agent.test.TestSupport;
import com.dbx.agent.ConnectParams;
import com.dbx.agent.DatabaseAgent;
import com.dbx.agent.ExecuteQueryOptions;
import com.dbx.agent.MetadataListConstraints;
import com.dbx.agent.TableInfo;
import com.dbx.agent.test.JdbcAgentFake;
import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
import com.dbx.agent.test.JdbcMetadataSqlFake;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.nio.charset.StandardCharsets;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
@@ -71,15 +84,85 @@ class TDengineAgentMetadataTest {
agent.listTables("power");
agent.getColumns("power", "meters");
Assertions.assertEquals(
Arrays.asList(
"SHOW DATABASES",
"SHOW `power`.STABLES",
"SHOW `power`.TABLES",
"DESCRIBE `power`.`meters`"
),
JdbcMetadataSqlFake.statements
Assertions.assertEquals("SHOW DATABASES", JdbcMetadataSqlFake.statements.get(0));
Assertions.assertTrue(JdbcMetadataSqlFake.statements.get(1).contains("FROM information_schema.ins_stables"));
Assertions.assertTrue(JdbcMetadataSqlFake.statements.get(1).contains("FROM information_schema.ins_tables"));
Assertions.assertEquals("param:1=power", JdbcMetadataSqlFake.statements.get(2));
Assertions.assertEquals("param:2=power", JdbcMetadataSqlFake.statements.get(3));
Assertions.assertEquals("DESCRIBE `power`.`meters`", JdbcMetadataSqlFake.statements.get(4));
}
@Test
void constrainedMetadataUsesRequestedDatabaseAndPushesFilterAndPaging() {
TDengineAgent agent = new TDengineAgent();
TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
agent.listTables(
"dbx_alpha",
new MetadataListConstraints("ord", 25, 50, List.of("TABLE"))
);
String sql = JdbcMetadataSqlFake.statements.get(0);
Assertions.assertFalse(sql.contains("DATABASE()"), sql);
Assertions.assertTrue(sql.contains("FROM information_schema.ins_stables"), sql);
Assertions.assertTrue(sql.contains("FROM information_schema.ins_tables"), sql);
Assertions.assertTrue(sql.contains("WHERE db_name = ?"), sql);
Assertions.assertTrue(sql.contains("table_name LIKE ? OR table_comment LIKE ?"), sql);
Assertions.assertTrue(sql.contains("ORDER BY hierarchy_name, hierarchy_rank, table_name"), sql);
Assertions.assertTrue(sql.endsWith("LIMIT 25 OFFSET 50"), sql);
Assertions.assertEquals(
List.of(
"param:1=dbx_alpha",
"param:2=dbx_alpha",
"param:3=%o%r%d%",
"param:4=%o%r%d%"
),
JdbcMetadataSqlFake.statements.subList(1, 5)
);
}
@Test
void constrainedMetadataPagesDoNotRepeatOrSkipTables() {
List<TableInfo> metadata = List.of(
new TableInfo("meters", "STABLE", null),
new TableInfo("device_a", "TABLE", null, null, "meters"),
new TableInfo("device_b", "TABLE", null, null, "meters"),
new TableInfo("standalone", "TABLE", null),
new TableInfo("weather", "STABLE", null)
);
List<String> statements = new ArrayList<>();
TDengineAgent agent = new TDengineAgent();
TestSupport.setPrivateConnection(agent, pagedMetadataConnection(metadata, statements));
List<TableInfo> combined = new ArrayList<>();
combined.addAll(agent.listTables("dbx_alpha", new MetadataListConstraints(null, 2, null, List.of("TABLE"))));
combined.addAll(agent.listTables("dbx_alpha", new MetadataListConstraints(null, 2, 2, List.of("TABLE"))));
combined.addAll(agent.listTables("dbx_alpha", new MetadataListConstraints(null, 2, 4, List.of("TABLE"))));
Assertions.assertEquals(metadata.stream().map(TableInfo::getName).toList(), combined.stream().map(TableInfo::getName).toList());
Set<String> distinctNames = new HashSet<>(combined.stream().map(TableInfo::getName).toList());
Assertions.assertEquals(metadata.size(), distinctNames.size());
Assertions.assertTrue(statements.get(0).endsWith("LIMIT 2"), statements.get(0));
Assertions.assertTrue(statements.get(1).endsWith("LIMIT 2 OFFSET 2"), statements.get(1));
Assertions.assertTrue(statements.get(2).endsWith("LIMIT 2 OFFSET 4"), statements.get(2));
}
@Test
void sortsSupertablesBeforeTheirChildTables() {
List<TableInfo> tables = new ArrayList<>(Arrays.asList(
new TableInfo("device_b", "TABLE", null, null, "meters"),
new TableInfo("standalone", "TABLE", null),
new TableInfo("meters", "STABLE", null),
new TableInfo("device_a", "TABLE", null, null, "meters")
));
TDengineAgent.sortTablesForHierarchy(tables);
Assertions.assertEquals(
Arrays.asList("meters", "device_a", "device_b", "standalone"),
tables.stream().map(TableInfo::getName).toList()
);
Assertions.assertEquals("meters", tables.get(1).getParent_name());
}
@Test
@@ -91,6 +174,77 @@ class TDengineAgentMetadataTest {
Assertions.assertTrue(JdbcMetadataSqlFake.statements.isEmpty());
}
private static Connection pagedMetadataConnection(List<TableInfo> metadata, List<String> statements) {
return proxy(Connection.class, (proxy, method, args) -> {
String name = method.getName();
if ("prepareStatement".equals(name)) {
String sql = (String) args[0];
statements.add(sql);
return pagedMetadataStatement(sql, metadata);
}
if ("isClosed".equals(name)) return false;
if ("close".equals(name)) return null;
return defaultValue(method.getReturnType());
});
}
private static PreparedStatement pagedMetadataStatement(String sql, List<TableInfo> metadata) {
return proxy(PreparedStatement.class, (proxy, method, args) -> {
String name = method.getName();
if ("executeQuery".equals(name)) {
int limit = sqlClauseValue(sql, "LIMIT", metadata.size());
int offset = sqlClauseValue(sql, "OFFSET", 0);
int from = Math.min(offset, metadata.size());
int to = Math.min(from + limit, metadata.size());
return tableInfoResultSet(metadata.subList(from, to));
}
if ("setString".equals(name) || "setInt".equals(name) || "setObject".equals(name) || "close".equals(name)) return null;
return defaultValue(method.getReturnType());
});
}
private static ResultSet tableInfoResultSet(List<TableInfo> tables) {
int[] index = {-1};
return proxy(ResultSet.class, (proxy, method, args) -> {
String name = method.getName();
if ("next".equals(name)) {
index[0] += 1;
return index[0] < tables.size();
}
if ("getString".equals(name)) {
TableInfo table = tables.get(index[0]);
int column = (Integer) args[0];
if (column == 1) return table.getName();
if (column == 2) return table.getTable_type();
if (column == 3) return table.getComment();
if (column == 4) return table.getParent_name();
}
if ("close".equals(name)) return null;
return defaultValue(method.getReturnType());
});
}
private static int sqlClauseValue(String sql, String clause, int fallback) {
Matcher matcher = Pattern.compile("\\b" + clause + "\\s+(\\d+)").matcher(sql);
return matcher.find() ? Integer.parseInt(matcher.group(1)) : fallback;
}
private static <T> T proxy(Class<T> type, InvocationHandler handler) {
return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, handler));
}
private static Object defaultValue(Class<?> type) {
if (Boolean.TYPE.equals(type)) return false;
if (Integer.TYPE.equals(type)) return 0;
if (Long.TYPE.equals(type)) return 0L;
if (Double.TYPE.equals(type)) return 0.0d;
if (Float.TYPE.equals(type)) return 0.0f;
if (Short.TYPE.equals(type)) return (short) 0;
if (Byte.TYPE.equals(type)) return (byte) 0;
if (Character.TYPE.equals(type)) return '\0';
return null;
}
@Test
void setsDatabaseBeforeExecutionWhenSchemaIsProvided() {
TDengineAgent agent = new TDengineAgent();