This is an automated email from the ASF dual-hosted git repository.
jianbin pushed a commit to branch 2.x
in repository https://gitbox.apache.org/repos/asf/incubator-seata.git
The following commit(s) were added to refs/heads/2.x by this push:
new b27e6be8a7 bugfix: fix index type misjudgment in
Dm/KingbaseTableMetaCache (#7843)
b27e6be8a7 is described below
commit b27e6be8a74cc2634a31cba0152638a57ab16a90
Author: lokidundun <[email protected]>
AuthorDate: Wed Dec 17 11:30:28 2025 +0800
bugfix: fix index type misjudgment in Dm/KingbaseTableMetaCache (#7843)
---
changes/en-us/2.x.md | 1 +
changes/zh-cn/2.x.md | 1 +
.../sql/struct/cache/DmTableMetaCache.java | 19 +-
.../sql/struct/cache/KingbaseTableMetaCache.java | 19 +-
.../sql/struct/cache/DmTableMetaCacheTest.java | 284 ++++++++++++++++++++-
5 files changed, 303 insertions(+), 21 deletions(-)
diff --git a/changes/en-us/2.x.md b/changes/en-us/2.x.md
index 4394345d8f..70e60109d2 100644
--- a/changes/en-us/2.x.md
+++ b/changes/en-us/2.x.md
@@ -59,6 +59,7 @@ Add changes here for all PR submitted to the 2.x branch.
- [[#7785](https://github.com/apache/incubator-seata/pull/7785)] fix the
failure test
- [[#7796](https://github.com/apache/incubator-seata/pull/7796)] fix the NPE
on ConsulConfigurationTest method
- [[#7839](https://github.com/apache/incubator-seata/pull/7839)] resolve
TransactionAutoConfiguration compatibility with Spring Boot 4.x
+- [[#7843](https://github.com/apache/incubator-seata/pull/7843)] fix index
type misjudgment in Dm/KingbaseTableMetaCache
- [[#7855](https://github.com/apache/incubator-seata/pull/7855)] fix comma
missing in package.json/min-document
- [[#7860](https://github.com/apache/incubator-seata/pull/7860)] Fix the issue
where delayed messages in RocketMQ transactions were silently ignored, now
explicitly throwing an exception
diff --git a/changes/zh-cn/2.x.md b/changes/zh-cn/2.x.md
index a5f175544e..376f6b7425 100644
--- a/changes/zh-cn/2.x.md
+++ b/changes/zh-cn/2.x.md
@@ -58,6 +58,7 @@
- [[#7785](https://github.com/apache/incubator-seata/pull/7785)] 修复失败的测试方法
- [[#7796](https://github.com/apache/incubator-seata/pull/7796)] 修复 Consul
监听器空值 NPE 问题
- [[#7839](https://github.com/apache/incubator-seata/pull/7839)]
解决TransactionAutoConfiguration与Spring Boot 4.x的兼容性问题
+- [[#7843](https://github.com/apache/incubator-seata/pull/7843)] 修复
Dm/KingbaseTableMetaCache 中的索引类型误判问题
- [[#7855](https://github.com/apache/incubator-seata/pull/7855)]
修复package.json中min-document的逗号缺失
- [[#7860](https://github.com/apache/incubator-seata/pull/7860)] 修复 RocketMQ
事务中延迟消息静默失效的问题，改为显式抛出异常
diff --git
a/rm-datasource/src/main/java/org/apache/seata/rm/datasource/sql/struct/cache/DmTableMetaCache.java
b/rm-datasource/src/main/java/org/apache/seata/rm/datasource/sql/struct/cache/DmTableMetaCache.java
index 840c06c7fb..a9728e0b0f 100644
---
a/rm-datasource/src/main/java/org/apache/seata/rm/datasource/sql/struct/cache/DmTableMetaCache.java
+++
b/rm-datasource/src/main/java/org/apache/seata/rm/datasource/sql/struct/cache/DmTableMetaCache.java
@@ -28,6 +28,9 @@ import org.apache.seata.sqlparser.util.JdbcConstants;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
/**
* The type Table meta cache.
@@ -121,6 +124,7 @@ public class DmTableMetaCache extends OracleTableMetaCache {
}
protected void processPrimaries(TableMeta tableMeta, ResultSet rs) throws
SQLException {
+ List<String> primaryKeyColumns = new ArrayList<>();
while (rs.next()) {
String pkColName;
try {
@@ -128,12 +132,17 @@ public class DmTableMetaCache extends
OracleTableMetaCache {
} catch (Exception e) {
pkColName = rs.getString("PK_NAME");
}
+ primaryKeyColumns.add(pkColName);
+ }
+
+ for (IndexMeta index : tableMeta.getAllIndexes().values()) {
+ List<String> indexColumns = index.getValues().stream()
+ .filter(col -> col != null &&
StringUtils.isNotBlank(col.getColumnName()))
+ .map(ColumnMeta::getColumnName)
+ .collect(Collectors.toList());
- String finalPkColName = pkColName;
- for (IndexMeta i : tableMeta.getAllIndexes().values()) {
- i.getValues().stream()
- .filter(c -> finalPkColName.equals(c.getColumnName()))
- .forEach(c -> i.setIndextype(IndexType.PRIMARY));
+ if (indexColumns.equals(primaryKeyColumns)) {
+ index.setIndextype(IndexType.PRIMARY);
}
}
}
diff --git
a/rm-datasource/src/main/java/org/apache/seata/rm/datasource/sql/struct/cache/KingbaseTableMetaCache.java
b/rm-datasource/src/main/java/org/apache/seata/rm/datasource/sql/struct/cache/KingbaseTableMetaCache.java
index e38f275a69..31a41743d6 100644
---
a/rm-datasource/src/main/java/org/apache/seata/rm/datasource/sql/struct/cache/KingbaseTableMetaCache.java
+++
b/rm-datasource/src/main/java/org/apache/seata/rm/datasource/sql/struct/cache/KingbaseTableMetaCache.java
@@ -28,6 +28,9 @@ import org.apache.seata.sqlparser.util.JdbcConstants;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
/**
* The type Table meta cache.
@@ -120,6 +123,7 @@ public class KingbaseTableMetaCache extends
OracleTableMetaCache {
}
protected void processPrimaries(TableMeta tableMeta, ResultSet rs) throws
SQLException {
+ List<String> primaryKeyColumns = new ArrayList<>();
while (rs.next()) {
String pkColName;
try {
@@ -127,12 +131,17 @@ public class KingbaseTableMetaCache extends
OracleTableMetaCache {
} catch (Exception e) {
pkColName = rs.getString("PK_NAME");
}
+ primaryKeyColumns.add(pkColName);
+ }
+
+ for (IndexMeta index : tableMeta.getAllIndexes().values()) {
+ List<String> indexColumns = index.getValues().stream()
+ .filter(col -> col != null &&
StringUtils.isNotBlank(col.getColumnName()))
+ .map(ColumnMeta::getColumnName)
+ .collect(Collectors.toList());
- String finalPkColName = pkColName;
- for (IndexMeta i : tableMeta.getAllIndexes().values()) {
- i.getValues().stream()
- .filter(c -> finalPkColName.equals(c.getColumnName()))
- .forEach(c -> i.setIndextype(IndexType.PRIMARY));
+ if (indexColumns.equals(primaryKeyColumns)) {
+ index.setIndextype(IndexType.PRIMARY);
}
}
}
diff --git
a/rm-datasource/src/test/java/org/apache/seata/rm/datasource/sql/struct/cache/DmTableMetaCacheTest.java
b/rm-datasource/src/test/java/org/apache/seata/rm/datasource/sql/struct/cache/DmTableMetaCacheTest.java
index 6e63c8dafe..70d4987c64 100644
---
a/rm-datasource/src/test/java/org/apache/seata/rm/datasource/sql/struct/cache/DmTableMetaCacheTest.java
+++
b/rm-datasource/src/test/java/org/apache/seata/rm/datasource/sql/struct/cache/DmTableMetaCacheTest.java
@@ -17,10 +17,13 @@
package org.apache.seata.rm.datasource.sql.struct.cache;
import com.alibaba.druid.pool.DruidDataSource;
+import org.apache.seata.common.exception.ShouldNeverHappenException;
import org.apache.seata.rm.datasource.DataSourceProxy;
import org.apache.seata.rm.datasource.DataSourceProxyTest;
import org.apache.seata.rm.datasource.mock.MockDriver;
import org.apache.seata.rm.datasource.sql.struct.TableMetaCacheFactory;
+import org.apache.seata.sqlparser.struct.IndexMeta;
+import org.apache.seata.sqlparser.struct.IndexType;
import org.apache.seata.sqlparser.struct.TableMeta;
import org.apache.seata.sqlparser.struct.TableMetaCache;
import org.apache.seata.sqlparser.util.JdbcConstants;
@@ -32,42 +35,301 @@ import java.sql.Types;
public class DmTableMetaCacheTest {
- private static Object[][] columnMetas = new Object[][] {
+ private static final Object[][] columnMetas = new Object[][] {
new Object[] {"", "", "dt1", "id", Types.INTEGER, "INTEGER", 64, 0,
10, 1, "", "", 0, 0, 64, 1, "NO", "YES"},
new Object[] {"", "", "dt1", "name1", Types.VARCHAR, "VARCHAR", 64, 0,
10, 0, "", "", 0, 0, 64, 2, "YES", "NO"},
new Object[] {"", "", "dt1", "name2", Types.VARCHAR, "VARCHAR", 64, 0,
10, 0, "", "", 0, 0, 64, 3, "YES", "NO"},
new Object[] {"", "", "dt1", "name3", Types.VARCHAR, "VARCHAR", 64, 0,
10, 0, "", "", 0, 0, 64, 4, "YES", "NO"}
};
- private static Object[][] indexMetas = new Object[][] {
- new Object[] {"id", "id", false, "", 3, 0, "A", 34},
- new Object[] {"name1", "name1", false, "", 3, 1, "A", 34},
- new Object[] {"name2", "name2", true, "", 3, 2, "A", 34},
+ private static final Object[][] indexMetas = new Object[][] {
+ new Object[] {"IDX_ID", "id", false, "", 3, 0, "A", 34},
+ new Object[] {"IDX_NAME1", "name1", false, "", 3, 1, "A", 34},
+ new Object[] {"IDX_NAME2", "name2", true, "", 3, 2, "A", 34},
};
- private static Object[][] pkMetas = new Object[][] {new Object[] {"id"}};
+ private static final Object[][] pkMetas = new Object[][] {new Object[]
{"id"}};
- private static Object[][] tableMetas = new Object[][] {new Object[] {"",
"t", "dt1"}};
+ private static final Object[][] tableMetas = new Object[][] {new Object[]
{"", "t", "dt1"}};
@Test
- public void getTableMetaTest() throws SQLException {
+ public void testGetTableMetaBasic() throws SQLException {
MockDriver mockDriver = new MockDriver(columnMetas, indexMetas,
pkMetas, tableMetas);
DruidDataSource dataSource = new DruidDataSource();
- dataSource.setUrl("jdbc:mock:xxx");
+ dataSource.setUrl("jdbc:mock:dm");
dataSource.setDriver(mockDriver);
DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "t.dt1",
proxy.getResourceId());
+
+ Assertions.assertNotNull(tableMeta);
+ Assertions.assertEquals(4, tableMeta.getAllColumns().size());
+ Assertions.assertEquals(3, tableMeta.getAllIndexes().size());
+ }
+
+ @Test
+ public void testGetTableMetaWithSchemaPrefix() throws SQLException {
+ MockDriver mockDriver = new MockDriver(columnMetas, indexMetas,
pkMetas, tableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "t.dt1",
proxy.getResourceId());
+
+ Assertions.assertNotNull(tableMeta);
+ Assertions.assertEquals("DT1", tableMeta.getTableName());
+ Assertions.assertEquals("t.dt1", tableMeta.getOriginalTableName());
+ }
+
+ @Test
+ public void testGetTableMetaWithQuotedIdentifiers() throws SQLException {
+ Object[][] quotedTableMetas = new Object[][] {new Object[] {"", "t",
"MixedCase"}};
+ Object[][] quotedColumnMetas = new Object[][] {
+ new Object[] {
+ "", "", "MixedCase", "Id", Types.INTEGER, "INTEGER", 64, 0,
10, 1, "", "", 0, 0, 64, 1, "NO", "YES"
+ },
+ new Object[] {
+ "", "", "MixedCase", "Name", Types.VARCHAR, "VARCHAR", 64, 0,
10, 0, "", "", 0, 0, 64, 2, "YES", "NO"
+ }
+ };
+ Object[][] quotedIndexMetas = new Object[][] {new Object[] {"idx_id",
"Id", false, "", 3, 0, "A", 34}};
+ Object[][] quotedPKMetas = new Object[][] {new Object[] {"Id"}};
+
+ MockDriver mockDriver = new MockDriver(quotedColumnMetas,
quotedIndexMetas, quotedPKMetas, quotedTableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta =
+ tableMetaCache.getTableMeta(proxy.getPlainConnection(),
"t.\"MixedCase\"", proxy.getResourceId());
+
+ Assertions.assertNotNull(tableMeta);
+ Assertions.assertEquals("MixedCase", tableMeta.getTableName());
+ }
+
+ @Test
+ public void testGetTableMetaThrowsExceptionWhenNoIndex() throws
SQLException {
+ Object[][] emptyIndexMetas = new Object[][] {};
+ Object[][] emptyTableMetas = new Object[][] {new Object[] {"", "t",
"dt1"}};
+
+ MockDriver mockDriver = new MockDriver(columnMetas, emptyIndexMetas,
pkMetas, emptyTableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ Assertions.assertThrows(ShouldNeverHappenException.class, () -> {
+ tableMetaCache.getTableMeta(proxy.getPlainConnection(), "dt1",
proxy.getResourceId());
+ });
+ }
+
+ @Test
+ public void testGetTableMetaWithCompositeIndex() throws SQLException {
+ Object[][] compositeIndexMetas = new Object[][] {
+ new Object[] {"idx_pk", "id", false, "", 3, 1, "A", 34},
+ new Object[] {"idx_composite", "name1", false, "", 3, 1, "A", 34},
+ new Object[] {"idx_composite", "name2", false, "", 3, 2, "A", 34}
+ };
+
+ MockDriver mockDriver = new MockDriver(columnMetas,
compositeIndexMetas, pkMetas, tableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "t.dt1",
proxy.getResourceId());
+
+ Assertions.assertNotNull(tableMeta);
+ Assertions.assertTrue(tableMeta.getAllIndexes().size() >= 1);
+ Assertions.assertEquals(4, tableMeta.getAllColumns().size());
+ }
+
+ @Test
+ public void testGetTableMetaWithPrimaryKeyIndex() throws SQLException {
+ MockDriver mockDriver = new MockDriver(columnMetas, indexMetas,
pkMetas, tableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "t.dt1",
proxy.getResourceId());
+
+ Assertions.assertNotNull(tableMeta);
+ IndexMeta pkIndex = tableMeta.getAllIndexes().get("IDX_ID");
+ Assertions.assertNotNull(pkIndex);
+ Assertions.assertEquals(IndexType.PRIMARY, pkIndex.getIndextype());
+ }
+
+ @Test
+ public void testGetTableMetaWithUniqueIndex() throws SQLException {
+ MockDriver mockDriver = new MockDriver(columnMetas, indexMetas,
pkMetas, tableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "t.dt1",
proxy.getResourceId());
+
+ Assertions.assertNotNull(tableMeta);
+ IndexMeta uniqueIndex = tableMeta.getAllIndexes().get("IDX_NAME1");
+ Assertions.assertNotNull(uniqueIndex);
+ Assertions.assertEquals(IndexType.UNIQUE, uniqueIndex.getIndextype());
+ }
+
+ @Test
+ public void testGetTableMetaWithNormalIndex() throws SQLException {
+ MockDriver mockDriver = new MockDriver(columnMetas, indexMetas,
pkMetas, tableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "t.dt1",
proxy.getResourceId());
+
+ Assertions.assertNotNull(tableMeta);
+ IndexMeta normalIndex = tableMeta.getAllIndexes().get("IDX_NAME2");
+ Assertions.assertNotNull(normalIndex);
+ Assertions.assertEquals(IndexType.NORMAL, normalIndex.getIndextype());
+ }
+
+ @Test
+ public void testGetTableMetaWithNullIndexName() throws SQLException {
+ Object[][] nullIndexMetas = new Object[][] {
+ new Object[] {"idx_id", "id", false, "", 3, 0, "A", 34},
+ new Object[] {null, "name1", false, "", 3, 1, "A", 34}
+ };
+
+ MockDriver mockDriver = new MockDriver(columnMetas, nullIndexMetas,
pkMetas, tableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "t.dt1",
proxy.getResourceId());
+
+ Assertions.assertNotNull(tableMeta);
+ Assertions.assertTrue(tableMeta.getAllIndexes().containsKey("IDX_ID"));
+ Assertions.assertFalse(tableMeta.getAllIndexes().containsKey(null));
+ }
+ @Test
+ public void testGetTableMetaCaching() throws SQLException {
+ MockDriver mockDriver = new MockDriver(columnMetas, indexMetas,
pkMetas, tableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta1 =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "t.dt1",
proxy.getResourceId());
+ TableMeta tableMeta2 =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "T.DT1",
proxy.getResourceId());
+
+ Assertions.assertSame(tableMeta1, tableMeta2, "Cache should return
same instance");
+ }
+
+ @Test
+ public void testGetTableMetaWithoutSchemaPrefix() throws SQLException {
+ Object[][] singleTableMetas = new Object[][] {new Object[] {"",
"public", "dt1"}};
+
+ MockDriver mockDriver = new MockDriver(columnMetas, indexMetas,
pkMetas, singleTableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
TableMeta tableMeta =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "dt1",
proxy.getResourceId());
Assertions.assertNotNull(tableMeta);
Assertions.assertEquals("DT1", tableMeta.getTableName());
- Assertions.assertEquals("dt1", tableMeta.getOriginalTableName());
+ }
+
+ @Test
+ public void testGetTableMetaWithLowerCaseTable() throws SQLException {
+ Object[][] lowerCaseTableMetas = new Object[][] {new Object[] {"",
"t", "lowertable"}};
+ Object[][] lowerCaseColumnMetas = new Object[][] {
+ new Object[] {
+ "", "", "lowertable", "id", Types.INTEGER, "INTEGER", 64, 0,
10, 1, "", "", 0, 0, 64, 1, "NO", "YES"
+ }
+ };
+ Object[][] lowerCaseIndexMetas = new Object[][] {new Object[]
{"idx_id", "id", false, "", 3, 0, "A", 34}};
+ Object[][] lowerCasePKMetas = new Object[][] {new Object[] {"id"}};
+
+ MockDriver mockDriver =
+ new MockDriver(lowerCaseColumnMetas, lowerCaseIndexMetas,
lowerCasePKMetas, lowerCaseTableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta =
+ tableMetaCache.getTableMeta(proxy.getPlainConnection(),
"lowertable", proxy.getResourceId());
+
+ Assertions.assertNotNull(tableMeta);
+ }
+
+ @Test
+ public void testGetTableMetaWithMultiplePrimaryKeys() throws SQLException {
+ Object[][] multiPKMetas = new Object[][] {new Object[] {"id"}, new
Object[] {"name1"}};
+ Object[][] multiPKIndexMetas = new Object[][] {
+ new Object[] {"idx_composite_pk", "id", false, "", 3, 1, "A", 34},
+ new Object[] {"idx_composite_pk", "name1", false, "", 3, 2, "A",
34}
+ };
+
+ MockDriver mockDriver = new MockDriver(columnMetas, multiPKIndexMetas,
multiPKMetas, tableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
+
+ TableMeta tableMeta =
tableMetaCache.getTableMeta(proxy.getPlainConnection(), "t.dt1",
proxy.getResourceId());
+
+ Assertions.assertNotNull(tableMeta);
+ Assertions.assertTrue(tableMeta.getPrimaryKeyMap().size() >= 1);
+ Assertions.assertTrue(tableMeta.getAllIndexes().size() >= 1);
+ }
+
+ @Test
+ public void testGetTableMetaOriginalTableNamePreserved() throws
SQLException {
+ MockDriver mockDriver = new MockDriver(columnMetas, indexMetas,
pkMetas, tableMetas);
+ DruidDataSource dataSource = new DruidDataSource();
+ dataSource.setUrl("jdbc:mock:dm");
+ dataSource.setDriver(mockDriver);
+
+ DataSourceProxy proxy =
DataSourceProxyTest.getDataSourceProxy(dataSource);
+ TableMetaCache tableMetaCache =
TableMetaCacheFactory.getTableMetaCache(JdbcConstants.DM);
- tableMeta = tableMetaCache.getTableMeta(proxy.getPlainConnection(),
"dt1", proxy.getResourceId());
+ String originalName = "t.dt1";
+ TableMeta tableMeta =
+ tableMetaCache.getTableMeta(proxy.getPlainConnection(),
originalName, proxy.getResourceId());
Assertions.assertNotNull(tableMeta);
+ Assertions.assertEquals(originalName,
tableMeta.getOriginalTableName());
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
