fix(tdengine): group subtables under super tables
This commit is contained in:
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;
|
||||
|
||||
+162
-8
@@ -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();
|
||||
|
||||
Reference in new issue
Block a user