You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by pa...@apache.org on 2023/03/12 00:06:21 UTC
[shardingsphere] branch master updated: Upgrade junit 5 ParameterizedTest for ITs (#24556)
This is an automated email from the ASF dual-hosted git repository.
panjuan pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 6bc59ba1b98 Upgrade junit 5 ParameterizedTest for ITs (#24556)
6bc59ba1b98 is described below
commit 6bc59ba1b98725cbdd979d83995d6a8124196534
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Sun Mar 12 08:06:11 2023 +0800
Upgrade junit 5 ParameterizedTest for ITs (#24556)
---
...0_The_Ideal_Database_Management_Ecosystem.en.md | 4 +-
.../content/dev-manual/configuration.cn.md | 8 +-
.../content/dev-manual/configuration.en.md | 6 +-
docs/document/content/dev-manual/kernel.cn.md | 4 +-
docs/document/content/dev-manual/kernel.en.md | 4 +-
docs/document/content/faq/_index.cn.md | 4 +-
docs/document/content/faq/_index.en.md | 4 +-
.../unregister-storage-unit.cn.md | 2 +-
.../unregister-storage-unit.en.md | 4 +-
.../single-table/count-single-table.en.md | 2 +-
.../rule/identifier/type/MutableDataNodeRule.java | 4 +-
.../infra/datanode/DataNodesTest.java | 4 +-
.../route/engine/SingleStandardRouteEngine.java | 2 +-
.../route/validator/SingleMetaDataValidator.java | 2 +-
.../decider/SingleSQLFederationDeciderTest.java | 10 +-
.../shardingsphere/single/rule/SingleRuleTest.java | 98 ++++----
.../optimizer/it/SQLOptimizeEngineIT.java | 40 +--
.../UnregisterStorageUnitBackendHandlerTest.java | 14 +-
.../distsql/rql/CountSingleTableExecutorTest.java | 4 +-
.../distsql/rql/ShowSingleTableExecutorTest.java | 6 +-
.../createtable/CreateTableSQLGeneratorIT.java | 110 ++++-----
.../mysql/create-table-sql-generator.xml | 0
.../opengauss/create-table-sql-generator.xml | 0
.../postgresql/create-table-sql-generator.xml | 0
.../test/it/optimize/SQLNodeConverterEngineIT.java | 268 ++++++++++-----------
...stractSQLRewriterIT.java => SQLRewriterIT.java} | 65 ++---
.../it/rewrite/engine/SQLRewriterITSettings.java | 25 +-
.../parameter/SQLRewriteEngineTestParameters.java | 5 +
.../SQLRewriteEngineTestParametersBuilder.java | 12 +-
.../scenario/EncryptSQLRewriterIT.java | 39 ++-
.../{ => engine}/scenario/MixSQLRewriterIT.java | 27 +--
.../scenario/ShardingSQLRewriterIT.java | 35 +--
32 files changed, 392 insertions(+), 420 deletions(-)
diff --git a/docs/blog/content/material/Jan_28_Blog_X_Kernel_Optimizations_&_Upgrade_Guide_for_Apache_ShardingSphere_5.0.0_The_Ideal_Database_Management_Ecosystem.en.md b/docs/blog/content/material/Jan_28_Blog_X_Kernel_Optimizations_&_Upgrade_Guide_for_Apache_ShardingSphere_5.0.0_The_Ideal_Database_Management_Ecosystem.en.md
index 360d0f33d96..2bbbed70834 100644
--- a/docs/blog/content/material/Jan_28_Blog_X_Kernel_Optimizations_&_Upgrade_Guide_for_Apache_ShardingSphere_5.0.0_The_Ideal_Database_Management_Ecosystem.en.md
+++ b/docs/blog/content/material/Jan_28_Blog_X_Kernel_Optimizations_&_Upgrade_Guide_for_Apache_ShardingSphere_5.0.0_The_Ideal_Database_Management_Ecosystem.en.md
@@ -252,7 +252,7 @@ To implement transparent data sharding, we add Automated Sharding Strategy into
Automated Sharding Strategy must be configured under `autoTables` attribute. Users only need to specify the data source for data storage as well as the number of shards via Automated Sharding Algorithm. They no longer need to manually set data distribution through `actualDataNodes`, or to pay extra attention to setting database sharding strategy and table sharding strategy, as Apache ShardingSphere automatically helps users manage data sharding.
-We also remove `defaultDataSourceName` from Data Sharding API. We have repeatedly highlighted that Apache ShardingSphere is a distributed database ecosystem now. The message we want to send to users is that you can directly use the services provided by Apache ShardingSphere but when you use the services, you’ll probably feel like you are just using a traditional database. You don’t have to perceive underlying database storage. Apache ShardingSphere’s built-in `SingleTableRule` can manage [...]
+We also remove `defaultDataSourceName` from Data Sharding API. We have repeatedly highlighted that Apache ShardingSphere is a distributed database ecosystem now. The message we want to send to users is that you can directly use the services provided by Apache ShardingSphere but when you use the services, you’ll probably feel like you are just using a traditional database. You don’t have to perceive underlying database storage. Apache ShardingSphere’s built-in `SingleRule` can manage sing [...]
Additionally, to further simplify configuration, in conjunction with the `defaultDatabaseStrategy` and `defaultTableStrategy` sharding strategies in Data Sharding API, `defaultShardingColumn` as the default sharding key is added as well.
@@ -526,7 +526,7 @@ SELECT * FROM t_user WHERE user_id = 1;
# Actual SQL: ds_0 ::: SELECT user_id, telephone_plain, telephone_cipher FROM t_user WHERE user_id = 1
```
-**The 5.0.0 GA version adopts a pluggable architecture and an upgraded kernel, to allow users to combine these functions without any restrictions. Additionally, in the new version, we delete `defaultDataSourceName`so users don’t need additional configuration anymore. Now ShardingSphere implements single-table metadata loading and routing through `SingleTableRule`by default.** Let’s take a look at how to configure and use the function in the 5.0.0 GA version. The configuration code is sho [...]
+**The 5.0.0 GA version adopts a pluggable architecture and an upgraded kernel, to allow users to combine these functions without any restrictions. Additionally, in the new version, we delete `defaultDataSourceName`so users don’t need additional configuration anymore. Now ShardingSphere implements single-table metadata loading and routing through `SingleRule`by default.** Let’s take a look at how to configure and use the function in the 5.0.0 GA version. The configuration code is shown below:
```
rules:
- !SHARDING
diff --git a/docs/document/content/dev-manual/configuration.cn.md b/docs/document/content/dev-manual/configuration.cn.md
index 8e3fb6d610c..a8ac6d534f8 100644
--- a/docs/document/content/dev-manual/configuration.cn.md
+++ b/docs/document/content/dev-manual/configuration.cn.md
@@ -17,12 +17,12 @@ chapter = true
### 已知实现
-| *配置标识* | *详细说明* | *全限定类名* |
-| ----------------------------------- | ---------------------------------------- | ---------- |
+| *配置标识* | *详细说明* | *全限定类名* |
+|-------------------------------------| --------------------------------------- | ---------- |
| AuthorityRuleConfiguration | 用于将权限用户配置转化为权限规则对象 | [`org.apache.shardingsphere.authority.rule.builder.AuthorityRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/kernel/authority/core/src/main/java/org/apache/shardingsphere/authority/rule/builder/AuthorityRuleBuilder.java) |
| SQLParserRuleConfiguration | 用于将 SQL 解析用户配置转化为 SQL 解析规则对象 | [`org.apache.shardingsphere.parser.rule.builder.SQLParserRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/kernel/parser/core/src/main/java/org/apache/shardingsphere/parser/rule/builder/SQLParserRuleBuilder.java) |
| TransactionRuleConfiguration | 用于将事务用户配置转化为事务规则对象 | [`org.apache.shardingsphere.transaction.rule.builder.TransactionRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/rule/builder/TransactionRuleBuilder.java) |
-| SingleTableRuleConfiguration | 用于将单表用户配置转化为单表规则对象 | [`org.apache.shardingsphere.singletable.rule.builder.SingleTableRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/builder/SingleTableRuleBuilder.java) |
+| SingleRuleConfiguration | 用于将单表用户配置转化为单表规则对象 | [`org.apache.shardingsphere.singletable.rule.builder.SingleRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/builder/SingleRuleBuilder.java) |
| ShardingRuleConfiguration | 用于将分片用户配置转化为分片规则对象 | [`org.apache.shardingsphere.sharding.rule.builder.ShardingRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/builder/ShardingRuleBuilder.java) |
| ReadwriteSplittingRuleConfiguration | 用于将读写分离用户配置转化为读写分离规则对象 | [`org.apache.shardingsphere.readwritesplitting.rule.builder.ReadwriteSplittingRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilder.java) |
| DatabaseDiscoveryRuleConfiguration | 用于将数据库发现用户配置转化为数据库发现规则对象 | [`org.apache.shardingsphere.dbdiscovery.rule.builder.DatabaseDiscoveryRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/features/db-discovery/core/src/main/java/org/apache/shardingsphere/dbdiscovery/rule/builder/DatabaseDiscoveryRuleBuilder.java) |
@@ -46,7 +46,7 @@ chapter = true
| AUTHORITY | 用于将权限规则的 YAML 配置转化为权限规则标准配置 | [`org.apache.shardingsphere.authority.yaml.swapper.YamlAuthorityRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/kernel/authority/core/src/main/java/org/apache/shardingsphere/authority/yaml/swapper/YamlAuthorityRuleConfigurationSwapper.java) |
| SQL_PARSER | 用于将 SQL 解析的 YAML 配置转化为 SQL 解析标准配置 | [`org.apache.shardingsphere.parser.yaml.swapper.YamlSQLParserRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/kernel/parser/core/src/main/java/org/apache/shardingsphere/parser/yaml/swapper/YamlSQLParserRuleConfigurationSwapper.java) |
| TRANSACTION | 用于将事务的 YAML 配置转化为事务标准配置 | [`org.apache.shardingsphere.transaction.yaml.swapper.YamlTransactionRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/yaml/swapper/YamlTransactionRuleConfigurationSwapper.java) |
-| SINGLE | 用于将单表的 YAML 配置转化为单表标准配置 | [`org.apache.shardingsphere.singletable.yaml.config.swapper.YamlSingleTableRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/yaml/config/swapper/YamlSingleTableRuleConfigurationSwapper.java) |
+| SINGLE | 用于将单表的 YAML 配置转化为单表标准配置 | [`org.apache.shardingsphere.singletable.yaml.config.swapper.YamlSingleRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/yaml/config/swapper/YamlSingleRuleConfigurationSwapper.java) |
| SHARDING | 用于将分片的 YAML 配置转化为分片标准配置 | [`org.apache.shardingsphere.sharding.yaml.swapper.YamlShardingRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/YamlShardingRuleConfigurationSwapper.java) |
| READWRITE_SPLITTING | 用于将读写分离的 YAML 配置转化为读写分离标准配置 | [`org.apache.shardingsphere.readwritesplitting.yaml.swapper.YamlReadwriteSplittingRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingRuleConfigurationSwapper.java) |
| DB_DISCOVERY | 用于将数据库发现的 YAML 配置转化为数据库发现标准配置 | [`org.apache.shardingsphere.dbdiscovery.yaml.swapper.YamlDatabaseDiscoveryRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/features/db-discovery/core/src/main/java/org/apache/shardingsphere/dbdiscovery/yaml/swapper/YamlDatabaseDiscoveryRuleConfigurationSwapper.java) |
diff --git a/docs/document/content/dev-manual/configuration.en.md b/docs/document/content/dev-manual/configuration.en.md
index 43ee62aefe8..d3e8fd68aee 100644
--- a/docs/document/content/dev-manual/configuration.en.md
+++ b/docs/document/content/dev-manual/configuration.en.md
@@ -18,11 +18,11 @@ Used to convert user configurations into rule objects
### Implementation classes
| *Configuration Type* | *Description* | *Fully-qualified class name* |
-| ----------------------------------- | ---------------------------------------------------------------------------------------------- |------------------------------|
+|-------------------------------------| ---------------------------------------------------------------------------------------------- |------------------------------|
| AuthorityRuleConfiguration | Used to convert authority user configuration into authority rule objects | [`org.apache.shardingsphere.authority.rule.builder.AuthorityRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/kernel/authority/core/src/main/java/org/apache/shardingsphere/authority/rule/builder/AuthorityRuleBuilder.java) |
| SQLParserRuleConfiguration | Used to convert SQL parser user configuration into SQL parser rule objects | [`org.apache.shardingsphere.parser.rule.builder.SQLParserRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/kernel/parser/core/src/main/java/org/apache/shardingsphere/parser/rule/builder/SQLParserRuleBuilder.java) |
| TransactionRuleConfiguration | Used to convert transaction user configuration into transaction rule objects | [`org.apache.shardingsphere.transaction.rule.builder.TransactionRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/rule/builder/TransactionRuleBuilder.java) |
-| SingleTableRuleConfiguration | Used to convert single-table user configuration into a single-table rule objects | [`org.apache.shardingsphere.singletable.rule.builder.SingleTableRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/builder/SingleTableRuleBuilder.java) |
+| SingleRuleConfiguration | Used to convert single-table user configuration into a single-table rule objects | [`org.apache.shardingsphere.singletable.rule.builder.SingleRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/builder/SingleRuleBuilder.java) |
| ShardingRuleConfiguration | Used to convert sharding user configuration into sharding rule objects | [`org.apache.shardingsphere.sharding.rule.builder.ShardingRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/builder/ShardingRuleBuilder.java) |
| ReadwriteSplittingRuleConfiguration | Used to convert read-write splitting user configuration into read-write splitting rule objects | [`org.apache.shardingsphere.readwritesplitting.rule.builder.ReadwriteSplittingRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilder.java) |
| DatabaseDiscoveryRuleConfiguration | Used to convert database discovery user configuration into database discovery rule objects | [`org.apache.shardingsphere.dbdiscovery.rule.builder.DatabaseDiscoveryRuleBuilder`](https://github.com/apache/shardingsphere/blob/master/features/db-discovery/core/src/main/java/org/apache/shardingsphere/dbdiscovery/rule/builder/DatabaseDiscoveryRuleBuilder.java) |
@@ -46,7 +46,7 @@ Used to convert YAML configuration to standard user configuration
| AUTHORITY | Used to convert the YAML configuration of authority rules into standard configuration of authority rules | [`org.apache.shardingsphere.authority.yaml.swapper.YamlAuthorityRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/kernel/authority/core/src/main/java/org/apache/shardingsphere/authority/yaml/swapper/YamlAuthorityRuleConfigurationSwapper.java) |
| SQL_PARSER | Used to convert the YAML configuration of the SQL parser into the standard configuration of the SQL parser | [`org.apache.shardingsphere.parser.yaml.swapper.YamlSQLParserRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/kernel/parser/core/src/main/java/org/apache/shardingsphere/parser/yaml/swapper/YamlSQLParserRuleConfigurationSwapper.java) |
| TRANSACTION | Used to convert the YAML configuration of the transaction into the standard configuration of the transaction | [`org.apache.shardingsphere.transaction.yaml.swapper.YamlTransactionRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/yaml/swapper/YamlTransactionRuleConfigurationSwapper.java) |
-| SINGLE | Used to convert the YAML configuration of the single table into the standard configuration of the single table | [`org.apache.shardingsphere.singletable.yaml.config.swapper.YamlSingleTableRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/yaml/config/swapper/YamlSingleTableRuleConfigurationSwapper.java) |
+| SINGLE | Used to convert the YAML configuration of the single table into the standard configuration of the single table | [`org.apache.shardingsphere.singletable.yaml.config.swapper.YamlSingleRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/yaml/config/swapper/YamlSingleRuleConfigurationSwapper.java) |
| SHARDING | Used to convert the YAML configuration of the sharding into the standard configuration of the sharding | [`org.apache.shardingsphere.sharding.yaml.swapper.YamlShardingRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/YamlShardingRuleConfigurationSwapper.java) |
| READWRITE_SPLITTING | Used to convert the YAML configuration of read-write splitting into the standard configuration of read-write splitting | [`org.apache.shardingsphere.readwritesplitting.yaml.swapper.YamlReadwriteSplittingRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingRuleConfigurationSwapper.java) |
| DB_DISCOVERY | Used to convert the YAML configuration of database discovery into the standard configuration of database discovery | [`org.apache.shardingsphere.dbdiscovery.yaml.swapper.YamlDatabaseDiscoveryRuleConfigurationSwapper`](https://github.com/apache/shardingsphere/blob/master/features/db-discovery/core/src/main/java/org/apache/shardingsphere/dbdiscovery/yaml/swapper/YamlDatabaseDiscoveryRuleConfigurationSwapper.java) |
diff --git a/docs/document/content/dev-manual/kernel.cn.md b/docs/document/content/dev-manual/kernel.cn.md
index 08adc951bcc..35543febd65 100644
--- a/docs/document/content/dev-manual/kernel.cn.md
+++ b/docs/document/content/dev-manual/kernel.cn.md
@@ -18,8 +18,8 @@ chapter = true
### 已知实现
| *配置标识* | *详细说明* | *全限定类名* |
-| ---------------------- | --------------------- | ---------- |
-| SingleTableRule | 用于处理单表路由结果 | [`org.apache.shardingsphere.singletable.route.SingleTableSQLRouter`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableSQLRouter.java) |
+|------------------------| --------------------- | ---------- |
+| SingleRule | 用于处理单表路由结果 | [`org.apache.shardingsphere.singletable.route.SingleTableSQLRouter`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableSQLRouter.java) |
| ShardingRule | 用于处理分片路由结果 | [`org.apache.shardingsphere.sharding.route.engine.ShardingSQLRouter`](https://github.com/apache/shardingsphere/blob/master/infra/route/src/main/java/org/apache/shardingsphere/infra/route/SQLRouter.java) |
| ReadwriteSplittingRule | 用于处理读写分离路由结果 | [`org.apache.shardingsphere.readwritesplitting.route.ReadwriteSplittingSQLRouter`](https://github.com/apache/shardingsphere/blob/master/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingSQLRouter.java) |
| DatabaseDiscoveryRule | 用于处理数据库发现路由结果 | [`org.apache.shardingsphere.dbdiscovery.route.DatabaseDiscoverySQLRouter`](https://github.com/apache/shardingsphere/blob/master/features/db-discovery/core/src/main/java/org/apache/shardingsphere/dbdiscovery/route/DatabaseDiscoverySQLRouter.java) |
diff --git a/docs/document/content/dev-manual/kernel.en.md b/docs/document/content/dev-manual/kernel.en.md
index e49a2fa991d..0d747c2e17c 100644
--- a/docs/document/content/dev-manual/kernel.en.md
+++ b/docs/document/content/dev-manual/kernel.en.md
@@ -18,8 +18,8 @@ Used to process routing results
### Implementation classes
| *Configuration type* | *Description* | *Fully-qualified class name* |
-| ---------------------------- | ---------------------------------------------------- | ---------------------------- |
-| SingleTableRule.class | Used to process single-table routing results | [`org.apache.shardingsphere.singletable.route.SingleTableSQLRouter`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableSQLRouter.java) |
+|------------------------------| ---------------------------------------------------- | ---------------------------- |
+| SingleRule.class | Used to process single-table routing results | [`org.apache.shardingsphere.singletable.route.SingleTableSQLRouter`](https://github.com/apache/shardingsphere/blob/master/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableSQLRouter.java) |
| ShardingRule.class | Used to process sharding routing results | [`org.apache.shardingsphere.sharding.route.engine.ShardingSQLRouter`](https://github.com/apache/shardingsphere/blob/master/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/route/engine/ShardingSQLRouter.java) |
| ReadwriteSplittingRule.class | Used to process read-write splitting routing results | [`org.apache.shardingsphere.readwritesplitting.route.ReadwriteSplittingSQLRouter`](https://github.com/apache/shardingsphere/blob/master/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingSQLRouter.java) |
| DatabaseDiscoveryRule.class | Used to process database discovery routing results | [`org.apache.shardingsphere.dbdiscovery.route.DatabaseDiscoverySQLRouter`](https://github.com/apache/shardingsphere/blob/master/features/db-discovery/core/src/main/java/org/apache/shardingsphere/dbdiscovery/route/DatabaseDiscoverySQLRouter.java) |
diff --git a/docs/document/content/faq/_index.cn.md b/docs/document/content/faq/_index.cn.md
index 7c241ea824b..f32c4305675 100644
--- a/docs/document/content/faq/_index.cn.md
+++ b/docs/document/content/faq/_index.cn.md
@@ -169,12 +169,12 @@ ShardingSphere 采用 snowflake 算法作为默认的分布式自增主键策略
2. ShardingSphere 预置了必要的连接池参数，如 `maxPoolSize`、`idleTimeout` 等。如需增加或覆盖参数配置，请在 `dataSource` 中通过 `PROPERTIES` 指定。
3. 以上规则请参考 [相关介绍](/cn/user-manual/shardingsphere-proxy/distsql/syntax/rdl/storage-unit-definition/)。
-### [DistSQL] 使用 `DistSQL` 删除 `storage unit` 时，出现 `Storage unit [xxx] is still used by [SingleTableRule]`。
+### [DistSQL] 使用 `DistSQL` 删除 `storage unit` 时，出现 `Storage unit [xxx] is still used by [SingleRule]`。
回答：
1. 被规则引用的 `storage unit` 将无法被删除。
-2. 若 `storage unit` 只被 `single table rule` 引用，且用户确认可以忽略该限制，则可以添加可选参数 ignore single tables 进行强制删除。
+2. 若 `storage unit` 只被 `single rule` 引用，且用户确认可以忽略该限制，则可以添加可选参数 ignore single tables 进行强制删除。
### [DistSQL] 使用 `DistSQL` 添加数据源时，出现 `Failed to get driver instance for jdbcURL=xxx`。
diff --git a/docs/document/content/faq/_index.en.md b/docs/document/content/faq/_index.en.md
index b36d0b3d900..e30415cc739 100644
--- a/docs/document/content/faq/_index.en.md
+++ b/docs/document/content/faq/_index.en.md
@@ -172,12 +172,12 @@ Answer:
2. ShardingSphere presets necessary connection pool properties, such as `maxPoolSize`, `idleTimeout`, etc. If you need to add or overwrite the properties, please specify it with `PROPERTIES` in the `dataSource`.
3. Please refer to [Related introduction](/en/user-manual/shardingsphere-proxy/distsql/syntax/rdl/storage-unit-definition/) for above rules.
-### [DistSQL] How to solve ` Storage unit [xxx] is still used by [SingleTableRule].` exception when dropping a data source using DistSQL?
+### [DistSQL] How to solve ` Storage unit [xxx] is still used by [SingleRule].` exception when dropping a data source using DistSQL?
Answer：
1. Storage units referenced by rules cannot be deleted
-2. If the storage unit is only referenced by single table rule, and the user confirms that the restriction can be ignored, the optional parameter ignore single tables can be added to perform forced deletion
+2. If the storage unit is only referenced by single rule, and the user confirms that the restriction can be ignored, the optional parameter ignore single tables can be added to perform forced deletion
```
UNREGISTER STORAGE UNIT storageUnitName [, storageUnitName] ... [ignore single tables]
```
diff --git a/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rdl/storage-unit-definition/unregister-storage-unit.cn.md b/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rdl/storage-unit-definition/unregister-storage-unit.cn.md
index 70d7448b60a..425e6cc5042 100644
--- a/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rdl/storage-unit-definition/unregister-storage-unit.cn.md
+++ b/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rdl/storage-unit-definition/unregister-storage-unit.cn.md
@@ -31,7 +31,7 @@ storageUnitName ::=
- `UNREGISTER STORAGE UNIT` 只会移除 Proxy 中的存储单元，不会删除与存储单元对应的真实数据源；
- 无法移除已经被规则使用的存储单元。移除被规则使用的存储单元时会提示 `Storage unit are still in used`；
-- 将要移除的存储单元中仅包含 `SINGLE TABLE RULE`，且用户确认可以忽略该限制时，可添加 `IGNORE SINGLE TABLES` 关键字移除存储单元；
+- 将要移除的存储单元中仅包含 `SINGLE RULE`，且用户确认可以忽略该限制时，可添加 `IGNORE SINGLE TABLES` 关键字移除存储单元；
- `ifExists` 子句用于避免 `Storage unit not exists` 错误。
### 示例
diff --git a/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rdl/storage-unit-definition/unregister-storage-unit.en.md b/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rdl/storage-unit-definition/unregister-storage-unit.en.md
index ee9ee97f14c..3a8c970cd9c 100644
--- a/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rdl/storage-unit-definition/unregister-storage-unit.en.md
+++ b/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rdl/storage-unit-definition/unregister-storage-unit.en.md
@@ -33,7 +33,7 @@ storageUnitName ::=
unregistered;
- Unable to unregister storage unit already used by rules. `Storage unit are still in used.` will be prompted when removing
storage units used by rules;
-- The storage unit need to be removed only contains `SINGLE TABLE RULE`, and when the user confirms that this restriction
+- The storage unit need to be removed only contains `SINGLE RULE`, and when the user confirms that this restriction
can be ignored, the `IGNORE SINGLE TABLES` keyword can be added to remove the storage unit;
- `ifExists` clause is used for avoid `Storage unit not exists` error.
@@ -51,7 +51,7 @@ UNREGISTER STORAGE UNIT ds_0;
UNREGISTER STORAGE UNIT ds_0, ds_1;
```
-- Ignore single table rule remove storage unit
+- Ignore single rule remove storage unit
```sql
UNREGISTER STORAGE UNIT ds_0 IGNORE SINGLE TABLES;
diff --git a/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rql/rule-query/single-table/count-single-table.en.md b/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rql/rule-query/single-table/count-single-table.en.md
index fceadc4f9b8..f840a03a484 100644
--- a/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rql/rule-query/single-table/count-single-table.en.md
+++ b/docs/document/content/user-manual/shardingsphere-proxy/distsql/syntax/rql/rule-query/single-table/count-single-table.en.md
@@ -37,7 +37,7 @@ databaseName ::=
### Example
-- Query the number of single table rules for specified database.
+- Query the number of single rules for specified database.
```sql
COUNT SINGLE TABLE
diff --git a/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/identifier/type/MutableDataNodeRule.java b/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/identifier/type/MutableDataNodeRule.java
index 71c9831c768..f5a9fa8592b 100644
--- a/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/identifier/type/MutableDataNodeRule.java
+++ b/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/identifier/type/MutableDataNodeRule.java
@@ -66,13 +66,13 @@ public interface MutableDataNodeRule extends ShardingSphereRule {
Optional<DataNode> findSingleTableDataNode(String schemaName, String tableName);
/**
- * Reload single table rule.
+ * Reload single rule.
*
* @param config rule configuration
* @param databaseName database name
* @param dataSourceMap data source map
* @param builtRules built rules
- * @return single table rule
+ * @return single rule
*/
ShardingSphereRule reloadRule(RuleConfiguration config, String databaseName, Map<String, DataSource> dataSourceMap, Collection<ShardingSphereRule> builtRules);
}
diff --git a/infra/common/src/test/java/org/apache/shardingsphere/infra/datanode/DataNodesTest.java b/infra/common/src/test/java/org/apache/shardingsphere/infra/datanode/DataNodesTest.java
index 0f29e9b3adc..02d99e5075c 100644
--- a/infra/common/src/test/java/org/apache/shardingsphere/infra/datanode/DataNodesTest.java
+++ b/infra/common/src/test/java/org/apache/shardingsphere/infra/datanode/DataNodesTest.java
@@ -141,12 +141,12 @@ public final class DataNodesTest {
private Collection<ShardingSphereRule> mockDataNodeContainedRules() {
Collection<ShardingSphereRule> result = new LinkedList<>();
- result.add(mockSingleTableRule());
+ result.add(mockSingleRule());
result.add(mockShardingRule());
return result;
}
- private ShardingSphereRule mockSingleTableRule() {
+ private ShardingSphereRule mockSingleRule() {
DataNodeContainedRule result = mock(DataNodeContainedRule.class);
when(result.getDataNodesByTableName("t_single")).thenReturn(Collections.singletonList(new DataNode("readwrite_ds", "t_single")));
return result;
diff --git a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngine.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngine.java
index 48c957ffa18..2d47668c229 100644
--- a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngine.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngine.java
@@ -55,7 +55,7 @@ public final class SingleStandardRouteEngine implements SingleRouteEngine {
* Route for single table.
*
* @param routeContext route context
- * @param singleRule single table rule
+ * @param singleRule single rule
*/
public void route(final RouteContext routeContext, final SingleRule singleRule) {
if (routeContext.getRouteUnits().isEmpty() || sqlStatement instanceof SelectStatement) {
diff --git a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidator.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidator.java
index 8e347c97fad..bb1df3c89ff 100644
--- a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidator.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidator.java
@@ -32,7 +32,7 @@ public interface SingleMetaDataValidator<T extends SQLStatement> {
/**
* Validate single table meta data.
*
- * @param rule single table rule
+ * @param rule single rule
* @param sqlStatementContext SQL statement context
* @param database database
*/
diff --git a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/decider/SingleSQLFederationDeciderTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/decider/SingleSQLFederationDeciderTest.java
index 840b8cd49a9..43898a1bb21 100644
--- a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/decider/SingleSQLFederationDeciderTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/decider/SingleSQLFederationDeciderTest.java
@@ -62,7 +62,7 @@ public final class SingleSQLFederationDeciderTest {
@Test
public void assertDecideWhenAllSingleTablesInSameDataSource() {
Collection<QualifiedTable> qualifiedTables = Arrays.asList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order"), new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order_item"));
- SingleRule rule = createSingleTableRule(qualifiedTables);
+ SingleRule rule = createSingleRule(qualifiedTables);
when(rule.isSingleTablesInSameDataSource(qualifiedTables)).thenReturn(true);
SelectStatementContext select = createStatementContext();
QueryContext queryContext = new QueryContext(select, "", Collections.emptyList());
@@ -76,7 +76,7 @@ public final class SingleSQLFederationDeciderTest {
@Test
public void assertDecideWhenAllSingleTablesNotInSameDataSource() {
Collection<QualifiedTable> qualifiedTables = Arrays.asList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order"), new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order_item"));
- SingleRule rule = createSingleTableRule(qualifiedTables);
+ SingleRule rule = createSingleRule(qualifiedTables);
when(rule.isSingleTablesInSameDataSource(qualifiedTables)).thenReturn(false);
SelectStatementContext select = createStatementContext();
QueryContext queryContext = new QueryContext(select, "", Collections.emptyList());
@@ -90,7 +90,7 @@ public final class SingleSQLFederationDeciderTest {
@Test
public void assertDecideWhenAllTablesInSameDataSource() {
Collection<QualifiedTable> qualifiedTables = Arrays.asList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order"), new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order_item"));
- SingleRule rule = createSingleTableRule(qualifiedTables);
+ SingleRule rule = createSingleRule(qualifiedTables);
when(rule.isSingleTablesInSameDataSource(qualifiedTables)).thenReturn(true);
SelectStatementContext select = createStatementContext();
QueryContext queryContext = new QueryContext(select, "", Collections.emptyList());
@@ -105,7 +105,7 @@ public final class SingleSQLFederationDeciderTest {
@Test
public void assertDecideWhenAllTablesNotInSameDataSource() {
Collection<QualifiedTable> qualifiedTables = Arrays.asList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order"), new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order_item"));
- SingleRule rule = createSingleTableRule(qualifiedTables);
+ SingleRule rule = createSingleRule(qualifiedTables);
when(rule.isSingleTablesInSameDataSource(qualifiedTables)).thenReturn(true);
SelectStatementContext select = createStatementContext();
QueryContext queryContext = new QueryContext(select, "", Collections.emptyList());
@@ -117,7 +117,7 @@ public final class SingleSQLFederationDeciderTest {
assertTrue(actual.isUseSQLFederation());
}
- private static SingleRule createSingleTableRule(final Collection<QualifiedTable> qualifiedTables) {
+ private static SingleRule createSingleRule(final Collection<QualifiedTable> qualifiedTables) {
SingleRule result = mock(SingleRule.class);
when(result.getSingleTableNames(any())).thenReturn(qualifiedTables);
when(result.findSingleTableDataNode(DefaultDatabase.LOGIC_NAME, "t_order")).thenReturn(Optional.of(new DataNode("ds_0", "t_order")));
diff --git a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java
index eb71a843856..2314075ecf9 100644
--- a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java
@@ -92,8 +92,8 @@ public final class SingleRuleTest {
public void assertGetSingleTableDataNodes() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
when(dataNodeContainedRule.getAllTables()).thenReturn(Arrays.asList("t_order", "t_order_0", "t_order_1"));
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
- Map<String, Collection<DataNode>> actual = singleTableRule.getSingleTableDataNodes();
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ Map<String, Collection<DataNode>> actual = singleRule.getSingleTableDataNodes();
assertThat(actual.size(), is(2));
assertTrue(actual.containsKey("employee"));
assertTrue(actual.containsKey("student"));
@@ -103,8 +103,8 @@ public final class SingleRuleTest {
public void assertGetSingleTableDataNodesWithUpperCase() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
when(dataNodeContainedRule.getAllTables()).thenReturn(Arrays.asList("T_ORDER", "T_ORDER_0", "T_ORDER_1"));
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
- Map<String, Collection<DataNode>> actual = singleTableRule.getSingleTableDataNodes();
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ Map<String, Collection<DataNode>> actual = singleRule.getSingleTableDataNodes();
assertThat(actual.size(), is(2));
assertTrue(actual.containsKey("employee"));
assertTrue(actual.containsKey("student"));
@@ -113,8 +113,8 @@ public final class SingleRuleTest {
@Test
public void assertFindSingleTableDataNode() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
- Optional<DataNode> actual = singleTableRule.findSingleTableDataNode(DefaultDatabase.LOGIC_NAME, "employee");
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ Optional<DataNode> actual = singleRule.findSingleTableDataNode(DefaultDatabase.LOGIC_NAME, "employee");
assertTrue(actual.isPresent());
assertThat(actual.get().getDataSourceName(), is("foo_ds"));
assertThat(actual.get().getTableName(), is("employee"));
@@ -123,8 +123,8 @@ public final class SingleRuleTest {
@Test
public void assertFindSingleTableDataNodeWithUpperCase() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
- Optional<DataNode> actual = singleTableRule.findSingleTableDataNode(DefaultDatabase.LOGIC_NAME, "EMPLOYEE");
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ Optional<DataNode> actual = singleRule.findSingleTableDataNode(DefaultDatabase.LOGIC_NAME, "EMPLOYEE");
assertTrue(actual.isPresent());
assertThat(actual.get().getDataSourceName(), is("foo_ds"));
assertThat(actual.get().getTableName(), is("employee"));
@@ -133,10 +133,10 @@ public final class SingleRuleTest {
@Test
public void assertIsSingleTablesInSameDataSource() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
Collection<QualifiedTable> singleTableNames = new LinkedList<>();
singleTableNames.add(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "employee"));
- assertTrue(singleTableRule.isSingleTablesInSameDataSource(singleTableNames));
+ assertTrue(singleRule.isSingleTablesInSameDataSource(singleTableNames));
}
@Test
@@ -149,76 +149,76 @@ public final class SingleRuleTest {
RouteContext routeContext = new RouteContext();
routeContext.putRouteUnit(dataSourceMapper, tableMappers);
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
- assertTrue(singleTableRule.isAllTablesInSameDataSource(routeContext, singleTableNames));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ assertTrue(singleRule.isAllTablesInSameDataSource(routeContext, singleTableNames));
}
@Test
public void assertAssignNewDataSourceName() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRuleConfiguration singleTableRuleConfig = new SingleRuleConfiguration();
- singleTableRuleConfig.setDefaultDataSource("foo_ds");
- SingleRule singleTableRule = new SingleRule(singleTableRuleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
- assertThat(singleTableRule.assignNewDataSourceName(), is("foo_ds"));
+ SingleRuleConfiguration singleRuleConfig = new SingleRuleConfiguration();
+ singleRuleConfig.setDefaultDataSource("foo_ds");
+ SingleRule singleRule = new SingleRule(singleRuleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ assertThat(singleRule.assignNewDataSourceName(), is("foo_ds"));
}
@Test
public void assertGetSingleTableNames() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
Collection<QualifiedTable> tableNames = new LinkedList<>();
tableNames.add(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "employee"));
- assertThat(singleTableRule.getSingleTableNames(tableNames).iterator().next().getSchemaName(), is(DefaultDatabase.LOGIC_NAME));
- assertThat(singleTableRule.getSingleTableNames(tableNames).iterator().next().getTableName(), is("employee"));
+ assertThat(singleRule.getSingleTableNames(tableNames).iterator().next().getSchemaName(), is(DefaultDatabase.LOGIC_NAME));
+ assertThat(singleRule.getSingleTableNames(tableNames).iterator().next().getTableName(), is("employee"));
}
@Test
public void assertPut() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
String tableName = "teacher";
String dataSourceName = "foo_ds";
- singleTableRule.put(dataSourceName, DefaultDatabase.LOGIC_NAME, tableName);
+ singleRule.put(dataSourceName, DefaultDatabase.LOGIC_NAME, tableName);
Collection<QualifiedTable> tableNames = new LinkedList<>();
tableNames.add(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "teacher"));
- assertThat(singleTableRule.getSingleTableNames(tableNames).iterator().next().getSchemaName(), is(DefaultDatabase.LOGIC_NAME));
- assertThat(singleTableRule.getSingleTableNames(tableNames).iterator().next().getTableName(), is("teacher"));
- assertTrue(singleTableRule.getAllTables().contains("employee"));
- assertTrue(singleTableRule.getAllTables().contains("student"));
- assertTrue(singleTableRule.getAllTables().contains("t_order_0"));
- assertTrue(singleTableRule.getAllTables().contains("t_order_1"));
- assertTrue(singleTableRule.getAllTables().contains("teacher"));
+ assertThat(singleRule.getSingleTableNames(tableNames).iterator().next().getSchemaName(), is(DefaultDatabase.LOGIC_NAME));
+ assertThat(singleRule.getSingleTableNames(tableNames).iterator().next().getTableName(), is("teacher"));
+ assertTrue(singleRule.getAllTables().contains("employee"));
+ assertTrue(singleRule.getAllTables().contains("student"));
+ assertTrue(singleRule.getAllTables().contains("t_order_0"));
+ assertTrue(singleRule.getAllTables().contains("t_order_1"));
+ assertTrue(singleRule.getAllTables().contains("teacher"));
}
@Test
public void assertRemove() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
String tableName = "employee";
- singleTableRule.remove(DefaultDatabase.LOGIC_NAME, tableName);
+ singleRule.remove(DefaultDatabase.LOGIC_NAME, tableName);
Collection<QualifiedTable> tableNames = new LinkedList<>();
tableNames.add(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "employee"));
- assertTrue(singleTableRule.getSingleTableNames(tableNames).isEmpty());
- assertTrue(singleTableRule.getAllTables().contains("student"));
- assertTrue(singleTableRule.getAllTables().contains("t_order_0"));
- assertTrue(singleTableRule.getAllTables().contains("t_order_1"));
+ assertTrue(singleRule.getSingleTableNames(tableNames).isEmpty());
+ assertTrue(singleRule.getAllTables().contains("student"));
+ assertTrue(singleRule.getAllTables().contains("t_order_0"));
+ assertTrue(singleRule.getAllTables().contains("t_order_1"));
}
@Test
public void assertGetAllDataNodes() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
- assertTrue(singleTableRule.getAllDataNodes().containsKey("employee"));
- assertTrue(singleTableRule.getAllDataNodes().containsKey("student"));
- assertTrue(singleTableRule.getAllDataNodes().containsKey("t_order_0"));
- assertTrue(singleTableRule.getAllDataNodes().containsKey("t_order_1"));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ assertTrue(singleRule.getAllDataNodes().containsKey("employee"));
+ assertTrue(singleRule.getAllDataNodes().containsKey("student"));
+ assertTrue(singleRule.getAllDataNodes().containsKey("t_order_0"));
+ assertTrue(singleRule.getAllDataNodes().containsKey("t_order_1"));
}
@Test
public void assertGetDataNodesByTableName() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
- Collection<DataNode> actual = singleTableRule.getDataNodesByTableName("EMPLOYEE");
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ Collection<DataNode> actual = singleRule.getDataNodesByTableName("EMPLOYEE");
assertThat(actual.size(), is(1));
DataNode dataNode = actual.iterator().next();
assertThat(dataNode.getDataSourceName(), is("foo_ds"));
@@ -228,32 +228,32 @@ public final class SingleRuleTest {
@Test
public void assertFindFirstActualTable() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
String logicTable = "employee";
- assertFalse(singleTableRule.findFirstActualTable(logicTable).isPresent());
+ assertFalse(singleRule.findFirstActualTable(logicTable).isPresent());
}
@Test
public void assertIsNeedAccumulate() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
- assertFalse(singleTableRule.isNeedAccumulate(Collections.emptyList()));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ assertFalse(singleRule.isNeedAccumulate(Collections.emptyList()));
}
@Test
public void assertFindLogicTableByActualTable() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
String actualTable = "student";
- assertFalse(singleTableRule.findLogicTableByActualTable(actualTable).isPresent());
+ assertFalse(singleRule.findLogicTableByActualTable(actualTable).isPresent());
}
@Test
public void assertFindActualTableByCatalog() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
String catalog = "employee";
String logicTable = "t_order_0";
- assertFalse(singleTableRule.findActualTableByCatalog(catalog, logicTable).isPresent());
+ assertFalse(singleRule.findActualTableByCatalog(catalog, logicTable).isPresent());
}
}
diff --git a/kernel/sql-federation/optimizer/src/test/java/org/apache/shardingsphere/sqlfederation/optimizer/it/SQLOptimizeEngineIT.java b/kernel/sql-federation/optimizer/src/test/java/org/apache/shardingsphere/sqlfederation/optimizer/it/SQLOptimizeEngineIT.java
index d3b3552861b..b408046af29 100644
--- a/kernel/sql-federation/optimizer/src/test/java/org/apache/shardingsphere/sqlfederation/optimizer/it/SQLOptimizeEngineIT.java
+++ b/kernel/sql-federation/optimizer/src/test/java/org/apache/shardingsphere/sqlfederation/optimizer/it/SQLOptimizeEngineIT.java
@@ -17,7 +17,6 @@
package org.apache.shardingsphere.sqlfederation.optimizer.it;
-import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import org.apache.calcite.config.CalciteConnectionConfig;
import org.apache.calcite.config.CalciteConnectionConfigImpl;
@@ -40,45 +39,36 @@ import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sqlfederation.optimizer.SQLOptimizeEngine;
import org.apache.shardingsphere.sqlfederation.optimizer.metadata.translatable.TranslatableSchema;
import org.apache.shardingsphere.sqlfederation.optimizer.util.SQLFederationPlannerUtil;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
import javax.xml.bind.JAXBException;
import java.io.IOException;
import java.sql.Types;
import java.util.Arrays;
-import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
+import java.util.stream.Stream;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.mock;
-@RunWith(Parameterized.class)
-@RequiredArgsConstructor
public final class SQLOptimizeEngineIT {
private static final String SCHEMA_NAME = "federate_jdbc";
private final SQLParserRule sqlParserRule = new SQLParserRule(new DefaultSQLParserRuleConfigurationBuilder().build());
- private final TestCase testcase;
-
private SQLOptimizeEngine optimizeEngine;
- @SneakyThrows({IOException.class, JAXBException.class})
- @Parameters(name = "{0}")
- public static Collection<TestCase> data() {
- return TestCasesLoader.getInstance().generate();
- }
-
- @Before
+ @BeforeEach
public void init() {
Map<String, ShardingSphereTable> tables = new HashMap<>();
tables.put("t_order_federate", createOrderFederationTableMetaData());
@@ -253,10 +243,20 @@ public final class SQLOptimizeEngineIT {
return SQLFederationPlannerUtil.createSqlToRelConverter(catalogReader, validator, cluster, mock(SQLParserRule.class), databaseType, false);
}
- @Test
- public void assertOptimize() {
+ @ParameterizedTest(name = "{0}")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertOptimize(final TestCase testcase) {
SQLStatement sqlStatement = sqlParserRule.getSQLParserEngine(DatabaseTypeEngine.getTrunkDatabaseTypeName(new H2DatabaseType())).parse(testcase.getSql(), false);
String actual = optimizeEngine.optimize(sqlStatement).getBestPlan().explain().replaceAll("[\r\n]", "");
assertThat(actual, is(testcase.getAssertion().getExpectedResult()));
}
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @SneakyThrows({IOException.class, JAXBException.class})
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return TestCasesLoader.getInstance().generate().stream().map(Arguments::of);
+ }
+ }
}
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandlerTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandlerTest.java
index 28143f9da83..3099a90b6bb 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandlerTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandlerTest.java
@@ -77,7 +77,7 @@ public final class UnregisterStorageUnitBackendHandlerTest {
private ShadowRule shadowRule;
@Mock
- private SingleRule singleTableRule;
+ private SingleRule singleRule;
private ContextManager contextManager;
@@ -138,11 +138,11 @@ public final class UnregisterStorageUnitBackendHandlerTest {
@Test
public void assertStorageUnitNameInUseWithoutIgnoreSingleTables() {
- when(ruleMetaData.findRules(DataNodeContainedRule.class)).thenReturn(Collections.singleton(singleTableRule));
- when(singleTableRule.getType()).thenReturn("SingleTableRule");
+ when(ruleMetaData.findRules(DataNodeContainedRule.class)).thenReturn(Collections.singleton(singleRule));
+ when(singleRule.getType()).thenReturn("SingleRule");
DataNode dataNode = mock(DataNode.class);
when(dataNode.getDataSourceName()).thenReturn("foo_ds");
- when(singleTableRule.getAllDataNodes()).thenReturn(Collections.singletonMap("", Collections.singleton(dataNode)));
+ when(singleRule.getAllDataNodes()).thenReturn(Collections.singletonMap("", Collections.singleton(dataNode)));
when(resourceMetaData.getDataSources()).thenReturn(Collections.singletonMap("foo_ds", dataSource));
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db")).thenReturn(database);
@@ -152,11 +152,11 @@ public final class UnregisterStorageUnitBackendHandlerTest {
@Test
public void assertStorageUnitNameInUseIgnoreSingleTables() throws SQLException {
- when(ruleMetaData.findRules(DataNodeContainedRule.class)).thenReturn(Collections.singleton(singleTableRule));
- when(singleTableRule.getType()).thenReturn("SingleRule");
+ when(ruleMetaData.findRules(DataNodeContainedRule.class)).thenReturn(Collections.singleton(singleRule));
+ when(singleRule.getType()).thenReturn("SingleRule");
DataNode dataNode = mock(DataNode.class);
when(dataNode.getDataSourceName()).thenReturn("foo_ds");
- when(singleTableRule.getAllDataNodes()).thenReturn(Collections.singletonMap("", Collections.singleton(dataNode)));
+ when(singleRule.getAllDataNodes()).thenReturn(Collections.singletonMap("", Collections.singleton(dataNode)));
when(resourceMetaData.getDataSources()).thenReturn(Collections.singletonMap("foo_ds", dataSource));
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db")).thenReturn(database);
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/CountSingleTableExecutorTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/CountSingleTableExecutorTest.java
index 051026e69b2..2f3eb380450 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/CountSingleTableExecutorTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/CountSingleTableExecutorTest.java
@@ -63,12 +63,12 @@ public final class CountSingleTableExecutorTest {
private ShardingSphereDatabase mockDatabase() {
ShardingSphereDatabase result = mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
when(result.getName()).thenReturn("db_1");
- ShardingSphereRuleMetaData ruleMetaData = new ShardingSphereRuleMetaData(Collections.singleton(mockSingleTableRule()));
+ ShardingSphereRuleMetaData ruleMetaData = new ShardingSphereRuleMetaData(Collections.singleton(mockSingleRule()));
when(result.getRuleMetaData()).thenReturn(ruleMetaData);
return result;
}
- private SingleRule mockSingleTableRule() {
+ private SingleRule mockSingleRule() {
SingleRule result = mock(SingleRule.class);
when(result.getAllTables()).thenReturn(Arrays.asList("single_table_1", "single_table_2"));
return result;
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/ShowSingleTableExecutorTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/ShowSingleTableExecutorTest.java
index 7aff99d05e1..4e794a0d38c 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/ShowSingleTableExecutorTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/ShowSingleTableExecutorTest.java
@@ -61,7 +61,7 @@ public final class ShowSingleTableExecutorTest {
Map<String, Collection<DataNode>> singleTableDataNodeMap = new HashMap<>();
singleTableDataNodeMap.put("t_order", Collections.singletonList(new DataNode("ds_1", "t_order")));
singleTableDataNodeMap.put("t_order_item", Collections.singletonList(new DataNode("ds_2", "t_order_item")));
- ShardingSphereRuleMetaData ruleMetaData = new ShardingSphereRuleMetaData(new LinkedList<>(Collections.singleton(mockSingleTableRule(singleTableDataNodeMap))));
+ ShardingSphereRuleMetaData ruleMetaData = new ShardingSphereRuleMetaData(new LinkedList<>(Collections.singleton(mockSingleRule(singleTableDataNodeMap))));
when(database.getRuleMetaData()).thenReturn(ruleMetaData);
}
@@ -84,7 +84,7 @@ public final class ShowSingleTableExecutorTest {
Map<String, Collection<DataNode>> singleTableDataNodeMap = new HashMap<>();
singleTableDataNodeMap.put("t_order_multiple", Collections.singletonList(new DataNode("ds_1_multiple", "t_order_multiple")));
singleTableDataNodeMap.put("t_order_item_multiple", Collections.singletonList(new DataNode("ds_2_multiple", "t_order_item_multiple")));
- addShardingSphereRule(mockSingleTableRule(singleTableDataNodeMap));
+ addShardingSphereRule(mockSingleRule(singleTableDataNodeMap));
RQLExecutor<ShowSingleTableStatement> executor = new ShowSingleTableExecutor();
Collection<LocalDataQueryResultRow> actual = executor.getRows(database, mock(ShowSingleTableStatement.class));
assertThat(actual.size(), is(4));
@@ -140,7 +140,7 @@ public final class ShowSingleTableExecutorTest {
assertThat(iterator.next(), is("storage_unit_name"));
}
- private SingleRule mockSingleTableRule(final Map<String, Collection<DataNode>> singleTableDataNodeMap) {
+ private SingleRule mockSingleRule(final Map<String, Collection<DataNode>> singleTableDataNodeMap) {
SingleRule result = mock(SingleRule.class);
when(result.getSingleTableDataNodes()).thenReturn(singleTableDataNodeMap);
return result;
diff --git a/test/e2e/pipeline/src/test/java/org/apache/shardingsphere/test/e2e/data/pipeline/cases/createtable/CreateTableSQLGeneratorIT.java b/test/e2e/pipeline/src/test/java/org/apache/shardingsphere/test/e2e/data/pipeline/cases/createtable/CreateTableSQLGeneratorIT.java
index 722dae50189..b878e009b1a 100644
--- a/test/e2e/pipeline/src/test/java/org/apache/shardingsphere/test/e2e/data/pipeline/cases/createtable/CreateTableSQLGeneratorIT.java
+++ b/test/e2e/pipeline/src/test/java/org/apache/shardingsphere/test/e2e/data/pipeline/cases/createtable/CreateTableSQLGeneratorIT.java
@@ -17,7 +17,6 @@
package org.apache.shardingsphere.test.e2e.data.pipeline.cases.createtable;
-import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.data.pipeline.spi.ddlgenerator.CreateTableSQLGenerator;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
import org.apache.shardingsphere.infra.database.type.dialect.MySQLDatabaseType;
@@ -38,11 +37,13 @@ import org.apache.shardingsphere.test.e2e.env.container.atomic.storage.config.im
import org.apache.shardingsphere.test.e2e.env.container.atomic.storage.config.impl.mysql.MySQLContainerConfigurationFactory;
import org.apache.shardingsphere.test.e2e.env.container.atomic.storage.impl.MySQLContainer;
import org.apache.shardingsphere.test.e2e.env.container.atomic.util.DatabaseTypeUtil;
-import org.junit.After;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.condition.EnabledIf;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
import javax.sql.DataSource;
import javax.xml.bind.JAXB;
@@ -56,12 +57,11 @@ import java.util.LinkedList;
import java.util.Map;
import java.util.Objects;
import java.util.regex.Pattern;
+import java.util.stream.Stream;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-@RunWith(Parameterized.class)
-@Slf4j
public final class CreateTableSQLGeneratorIT {
private static final String POSTGRES_CASE_FILE_PATH = "postgresql/create-table-sql-generator.xml";
@@ -70,7 +70,7 @@ public final class CreateTableSQLGeneratorIT {
private static final String OPEN_GAUSS_CASE_FILE_PATH = "opengauss/create-table-sql-generator.xml";
- private static final String PARENT_PATH = "env/scenario/createtablegenerator";
+ private static final String PARENT_PATH = "env/scenario/create-table-generator";
private static final String DEFAULT_SCHEMA = "public";
@@ -80,51 +80,20 @@ public final class CreateTableSQLGeneratorIT {
private static final PipelineE2EEnvironment ENV = PipelineE2EEnvironment.getInstance();
- private final DockerStorageContainer storageContainer;
+ private DockerStorageContainer storageContainer;
- private final PipelineTestParameter testParam;
-
- private final CreateTableSQLGeneratorAssertionsRootEntity rootEntity;
-
- public CreateTableSQLGeneratorIT(final PipelineTestParameter testParam) {
- this.testParam = testParam;
- rootEntity = JAXB.unmarshal(
- Objects.requireNonNull(CreateTableSQLGeneratorIT.class.getClassLoader().getResource(testParam.getScenario())), CreateTableSQLGeneratorAssertionsRootEntity.class);
- DatabaseType databaseType = testParam.getDatabaseType();
- StorageContainerConfiguration storageContainerConfig;
- if (DatabaseTypeUtil.isMySQL(databaseType)) {
- int majorVersion = new DockerImageVersion(testParam.getStorageContainerImage()).getMajorVersion();
- Map<String, String> mountedResources = Collections.singletonMap(String.format("/env/mysql/mysql%s/my.cnf", majorVersion), MySQLContainer.MYSQL_CONF_IN_CONTAINER);
- storageContainerConfig = MySQLContainerConfigurationFactory.newInstance(null, null, mountedResources);
- } else {
- storageContainerConfig = StorageContainerConfigurationFactory.newInstance(databaseType);
- }
- storageContainer = (DockerStorageContainer) StorageContainerFactory.newInstance(databaseType, testParam.getStorageContainerImage(), "",
- storageContainerConfig);
- storageContainer.start();
- }
-
- @Parameters(name = "{0}")
- public static Collection<PipelineTestParameter> getTestParameters() {
- Collection<PipelineTestParameter> result = new LinkedList<>();
- if (ENV.getItEnvType() == PipelineEnvTypeEnum.NONE) {
- return result;
- }
- for (String each : ENV.getPostgresqlVersions()) {
- result.add(new PipelineTestParameter(new PostgreSQLDatabaseType(), each, String.join("/", PARENT_PATH, POSTGRES_CASE_FILE_PATH)));
- }
- for (String each : ENV.getMysqlVersions()) {
- result.add(new PipelineTestParameter(new MySQLDatabaseType(), each, String.join("/", PARENT_PATH, MYSQL_CASE_FILE_PATH)));
- }
- for (String each : ENV.getOpenGaussVersions()) {
- result.add(new PipelineTestParameter(new OpenGaussDatabaseType(), each, String.join("/", PARENT_PATH, OPEN_GAUSS_CASE_FILE_PATH)));
- }
- return result;
+ @AfterEach
+ public void stopContainer() {
+ storageContainer.stop();
}
- @Test
- public void assertGenerateCreateTableSQL() throws SQLException {
- log.info("generate create table sql, test parameter: {}", testParam);
+ @ParameterizedTest(name = "{0}")
+ @EnabledIf("isEnabled")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertGenerateCreateTableSQL(final PipelineTestParameter testParam) throws SQLException {
+ startStorageContainer(testParam.getDatabaseType(), testParam.getStorageContainerImage());
+ CreateTableSQLGeneratorAssertionsRootEntity rootEntity = JAXB.unmarshal(
+ Objects.requireNonNull(CreateTableSQLGeneratorIT.class.getClassLoader().getResource(testParam.getScenario())), CreateTableSQLGeneratorAssertionsRootEntity.class);
DataSource dataSource = storageContainer.createAccessDataSource(DEFAULT_DATABASE);
try (
Connection connection = dataSource.getConnection();
@@ -137,7 +106,21 @@ public final class CreateTableSQLGeneratorIT {
assertSQL(actualDDLs, getVersionOutput(each.getOutputs(), majorVersion));
}
}
- log.info("{} E2E IT finished, database type={}, docker image={}", this.getClass().getName(), testParam.getDatabaseType(), testParam.getStorageContainerImage());
+ }
+
+ private void startStorageContainer(final DatabaseType databaseType, final String storageContainerImage) {
+ StorageContainerConfiguration storageContainerConfig = createStorageContainerConfiguration(databaseType, storageContainerImage);
+ storageContainer = (DockerStorageContainer) StorageContainerFactory.newInstance(databaseType, storageContainerImage, "", storageContainerConfig);
+ storageContainer.start();
+ }
+
+ private StorageContainerConfiguration createStorageContainerConfiguration(final DatabaseType databaseType, final String storageContainerImage) {
+ if (DatabaseTypeUtil.isMySQL(databaseType)) {
+ int majorVersion = new DockerImageVersion(storageContainerImage).getMajorVersion();
+ Map<String, String> mountedResources = Collections.singletonMap(String.format("/env/mysql/mysql%s/my.cnf", majorVersion), MySQLContainer.MYSQL_CONF_IN_CONTAINER);
+ return MySQLContainerConfigurationFactory.newInstance(null, null, mountedResources);
+ }
+ return StorageContainerConfigurationFactory.newInstance(databaseType);
}
private void assertSQL(final Collection<String> actualSQL, final Collection<String> expectedSQL) {
@@ -160,8 +143,25 @@ public final class CreateTableSQLGeneratorIT {
return result;
}
- @After
- public void stopContainer() {
- storageContainer.stop();
+ private static boolean isEnabled() {
+ return ENV.getItEnvType() != PipelineEnvTypeEnum.NONE && (!ENV.getMysqlVersions().isEmpty() || !ENV.getPostgresqlVersions().isEmpty() || !ENV.getOpenGaussVersions().isEmpty());
+ }
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ Collection<PipelineTestParameter> result = new LinkedList<>();
+ for (String each : ENV.getMysqlVersions()) {
+ result.add(new PipelineTestParameter(new MySQLDatabaseType(), each, String.join("/", PARENT_PATH, MYSQL_CASE_FILE_PATH)));
+ }
+ for (String each : ENV.getPostgresqlVersions()) {
+ result.add(new PipelineTestParameter(new PostgreSQLDatabaseType(), each, String.join("/", PARENT_PATH, POSTGRES_CASE_FILE_PATH)));
+ }
+ for (String each : ENV.getOpenGaussVersions()) {
+ result.add(new PipelineTestParameter(new OpenGaussDatabaseType(), each, String.join("/", PARENT_PATH, OPEN_GAUSS_CASE_FILE_PATH)));
+ }
+ return result.stream().map(Arguments::of);
+ }
}
}
diff --git a/test/e2e/pipeline/src/test/resources/env/scenario/createtablegenerator/mysql/create-table-sql-generator.xml b/test/e2e/pipeline/src/test/resources/env/scenario/create-table-generator/mysql/create-table-sql-generator.xml
similarity index 100%
rename from test/e2e/pipeline/src/test/resources/env/scenario/createtablegenerator/mysql/create-table-sql-generator.xml
rename to test/e2e/pipeline/src/test/resources/env/scenario/create-table-generator/mysql/create-table-sql-generator.xml
diff --git a/test/e2e/pipeline/src/test/resources/env/scenario/createtablegenerator/opengauss/create-table-sql-generator.xml b/test/e2e/pipeline/src/test/resources/env/scenario/create-table-generator/opengauss/create-table-sql-generator.xml
similarity index 100%
rename from test/e2e/pipeline/src/test/resources/env/scenario/createtablegenerator/opengauss/create-table-sql-generator.xml
rename to test/e2e/pipeline/src/test/resources/env/scenario/create-table-generator/opengauss/create-table-sql-generator.xml
diff --git a/test/e2e/pipeline/src/test/resources/env/scenario/createtablegenerator/postgresql/create-table-sql-generator.xml b/test/e2e/pipeline/src/test/resources/env/scenario/create-table-generator/postgresql/create-table-sql-generator.xml
similarity index 100%
rename from test/e2e/pipeline/src/test/resources/env/scenario/createtablegenerator/postgresql/create-table-sql-generator.xml
rename to test/e2e/pipeline/src/test/resources/env/scenario/create-table-generator/postgresql/create-table-sql-generator.xml
diff --git a/test/it/optimizer/src/test/java/org/apache/shardingsphere/test/it/optimize/SQLNodeConverterEngineIT.java b/test/it/optimizer/src/test/java/org/apache/shardingsphere/test/it/optimize/SQLNodeConverterEngineIT.java
index c9ac148eb02..aa7d21fefa0 100644
--- a/test/it/optimizer/src/test/java/org/apache/shardingsphere/test/it/optimize/SQLNodeConverterEngineIT.java
+++ b/test/it/optimizer/src/test/java/org/apache/shardingsphere/test/it/optimize/SQLNodeConverterEngineIT.java
@@ -41,10 +41,11 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.regist
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.sql.SQLCases;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.sql.registry.SQLCasesRegistry;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.sql.type.SQLCaseType;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
import java.util.Arrays;
import java.util.Collection;
@@ -53,10 +54,10 @@ import java.util.LinkedList;
import java.util.Properties;
import java.util.Set;
import java.util.stream.Collectors;
+import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertTrue;
-@RunWith(Parameterized.class)
public final class SQLNodeConverterEngineIT {
private static final SQLCases SQL_CASES = SQLCasesRegistry.getInstance().getCases();
@@ -65,138 +66,9 @@ public final class SQLNodeConverterEngineIT {
private static final String SELECT_STATEMENT_PREFIX = "SELECT";
- private static final Set<String> SUPPORTED_SQL_CASE_IDS = new HashSet<>();
-
- // TODO remove SUPPORTED_SQL_CASE_IDS when all SQL statement support convert to SQL node
- // CHECKSTYLE:OFF
- static {
- SUPPORTED_SQL_CASE_IDS.add("select_with_join_table_subquery");
- SUPPORTED_SQL_CASE_IDS.add("select_with_projection_subquery");
- SUPPORTED_SQL_CASE_IDS.add("select_with_in_subquery_condition");
- SUPPORTED_SQL_CASE_IDS.add("select_with_between_and_subquery_condition");
- SUPPORTED_SQL_CASE_IDS.add("select_with_exist_subquery_condition");
- SUPPORTED_SQL_CASE_IDS.add("select_with_not_exist_subquery_condition");
- SUPPORTED_SQL_CASE_IDS.add("select_with_simple_table");
- SUPPORTED_SQL_CASE_IDS.add("select_group_by_with_limit");
- SUPPORTED_SQL_CASE_IDS.add("select_left_outer_join_related_with_alias");
- SUPPORTED_SQL_CASE_IDS.add("select_right_outer_join_related_with_alias");
- SUPPORTED_SQL_CASE_IDS.add("select_alias_as_keyword");
- SUPPORTED_SQL_CASE_IDS.add("select_avg");
- SUPPORTED_SQL_CASE_IDS.add("select_between_with_single_table");
- SUPPORTED_SQL_CASE_IDS.add("select_distinct_with_single_count_group_by");
- SUPPORTED_SQL_CASE_IDS.add("select_bit_xor");
- SUPPORTED_SQL_CASE_IDS.add("select_with_schema");
- SUPPORTED_SQL_CASE_IDS.add("select_with_same_table_name_and_alias");
- SUPPORTED_SQL_CASE_IDS.add("select_count_like_concat");
- SUPPORTED_SQL_CASE_IDS.add("select_order_by_asc_and_index_desc");
- SUPPORTED_SQL_CASE_IDS.add("select_group_by_with_having_count");
- SUPPORTED_SQL_CASE_IDS.add("select_constant_without_table");
- SUPPORTED_SQL_CASE_IDS.add("select_count_with_binding_tables_with_join");
- SUPPORTED_SQL_CASE_IDS.add("select_join_using");
- SUPPORTED_SQL_CASE_IDS.add("select_count_with_escape_character");
- SUPPORTED_SQL_CASE_IDS.add("select_group_by_with_order_by_and_limit");
- SUPPORTED_SQL_CASE_IDS.add("select_count_with_sub");
- SUPPORTED_SQL_CASE_IDS.add("select_current_user");
- SUPPORTED_SQL_CASE_IDS.add("select_database");
- SUPPORTED_SQL_CASE_IDS.add("select_distinct_with_count_calculation");
- SUPPORTED_SQL_CASE_IDS.add("select_count_like_escape");
- SUPPORTED_SQL_CASE_IDS.add("select_with_projection_subquery_and_multiple_parameters");
- SUPPORTED_SQL_CASE_IDS.add("select_group_concat");
- SUPPORTED_SQL_CASE_IDS.add("select_cast_function");
- SUPPORTED_SQL_CASE_IDS.add("select_position");
- SUPPORTED_SQL_CASE_IDS.add("select_mod_function");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_offset");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_row_count");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_top");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_top_percent_with_ties");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_row_number");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_limit_with_back_quotes");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_limit_and_offset_keyword");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_offset_and_limit");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_offset_and_limit_all");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_top_for_greater_than");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_top_percent_with_ties_for_greater_than");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_top_for_greater_than_and_equal");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_top_percent_with_ties_for_greater_than_and_equal");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_row_number_for_greater_than");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_row_number_for_greater_than_and_equal");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_row_number_not_at_end");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_fetch_first_with_row_number");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_offset_fetch");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_limit_offset_and_row_count");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_limit_row_count");
- SUPPORTED_SQL_CASE_IDS.add("select_pagination_with_limit_fetch_count");
- SUPPORTED_SQL_CASE_IDS.add("select_with_null_keyword_in_projection");
- SUPPORTED_SQL_CASE_IDS.add("select_union");
- SUPPORTED_SQL_CASE_IDS.add("select_union_all");
- SUPPORTED_SQL_CASE_IDS.add("select_union_all_order_by");
- SUPPORTED_SQL_CASE_IDS.add("select_union_all_order_by_limit");
- SUPPORTED_SQL_CASE_IDS.add("select_intersect");
- SUPPORTED_SQL_CASE_IDS.add("select_intersect_order_by");
- SUPPORTED_SQL_CASE_IDS.add("select_intersect_order_by_limit");
- SUPPORTED_SQL_CASE_IDS.add("select_except");
- SUPPORTED_SQL_CASE_IDS.add("select_except_order_by");
- SUPPORTED_SQL_CASE_IDS.add("select_except_order_by_limit");
- SUPPORTED_SQL_CASE_IDS.add("select_minus");
- SUPPORTED_SQL_CASE_IDS.add("select_minus_order_by");
- SUPPORTED_SQL_CASE_IDS.add("select_minus_order_by_limit");
- SUPPORTED_SQL_CASE_IDS.add("select_union_intersect");
- SUPPORTED_SQL_CASE_IDS.add("select_union_except");
- SUPPORTED_SQL_CASE_IDS.add("select_union_intersect_except");
- SUPPORTED_SQL_CASE_IDS.add("select_except_union");
- SUPPORTED_SQL_CASE_IDS.add("select_except_intersect");
- SUPPORTED_SQL_CASE_IDS.add("select_except_intersect_union");
- SUPPORTED_SQL_CASE_IDS.add("select_sub_union");
- SUPPORTED_SQL_CASE_IDS.add("select_projections_with_expr");
- SUPPORTED_SQL_CASE_IDS.add("select_projections_with_only_expr");
- SUPPORTED_SQL_CASE_IDS.add("select_natural_join");
- SUPPORTED_SQL_CASE_IDS.add("select_natural_inner_join");
- SUPPORTED_SQL_CASE_IDS.add("select_natural_left_join");
- SUPPORTED_SQL_CASE_IDS.add("select_natural_right_join");
- SUPPORTED_SQL_CASE_IDS.add("select_natural_full_join");
- SUPPORTED_SQL_CASE_IDS.add("select_order_by_for_nulls_first");
- SUPPORTED_SQL_CASE_IDS.add("select_order_by_for_nulls_last");
- }
- // CHECKSTYLE:ON
-
- private final String sqlCaseId;
-
- private final String databaseType;
-
- private final SQLCaseType sqlCaseType;
-
- public SQLNodeConverterEngineIT(final InternalSQLParserTestParameter testParam) {
- sqlCaseId = testParam.getSqlCaseId();
- databaseType = testParam.getDatabaseType();
- sqlCaseType = testParam.getSqlCaseType();
- }
-
- @Parameters(name = "{0}")
- public static Collection<InternalSQLParserTestParameter> getTestParameters() {
- return getTestParameters("MySQL", "PostgreSQL", "openGauss");
- }
-
- private static Collection<InternalSQLParserTestParameter> getTestParameters(final String... databaseTypes) {
- Collection<InternalSQLParserTestParameter> result = new LinkedList<>();
- for (InternalSQLParserTestParameter each : SQL_CASES.generateTestParameters(Arrays.stream(databaseTypes).collect(Collectors.toSet()))) {
- if (!isPlaceholderWithoutParameter(each) && isSupportedSQLCase(each)) {
- result.add(each);
- }
- }
- return result;
- }
-
- private static boolean isPlaceholderWithoutParameter(final InternalSQLParserTestParameter testParam) {
- return SQLCaseType.Placeholder == testParam.getSqlCaseType() && SQL_PARSER_TEST_CASES.get(testParam.getSqlCaseId()).getParameters().isEmpty();
- }
-
- private static boolean isSupportedSQLCase(final InternalSQLParserTestParameter testParam) {
- return testParam.getSqlCaseId().toUpperCase().startsWith(SELECT_STATEMENT_PREFIX) && SUPPORTED_SQL_CASE_IDS.contains(testParam.getSqlCaseId());
- }
-
- @Test
- public void assertConvert() {
- String databaseType = "H2".equals(this.databaseType) ? "MySQL" : this.databaseType;
+ @ParameterizedTest(name = "{0}")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public void assertConvert(final String sqlCaseId, final SQLCaseType sqlCaseType, final String databaseType) {
String sql = SQL_CASES.getSQL(sqlCaseId, sqlCaseType, SQL_PARSER_TEST_CASES.get(sqlCaseId).getParameters());
SqlNode actual = SQLNodeConverterEngine.convert(parseSQLStatement(databaseType, sql));
SqlNode expected = parseSQLNode(databaseType, sql);
@@ -224,4 +96,126 @@ public final class SQLNodeConverterEngineIT {
result.putAll(TypedSPILoader.getService(OptimizerSQLDialectBuilder.class, databaseType).build());
return result;
}
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ private final Collection<String> supportedSQLCaseIDs = getSupportedSQLCaseIDs();
+
+ // TODO remove the method when all SQL statement support convert to SQL node
+ // CHECKSTYLE:OFF
+ private Set<String> getSupportedSQLCaseIDs() {
+ Set<String> result = new HashSet<>();
+ result.add("select_with_join_table_subquery");
+ result.add("select_with_projection_subquery");
+ result.add("select_with_in_subquery_condition");
+ result.add("select_with_between_and_subquery_condition");
+ result.add("select_with_exist_subquery_condition");
+ result.add("select_with_not_exist_subquery_condition");
+ result.add("select_with_simple_table");
+ result.add("select_group_by_with_limit");
+ result.add("select_left_outer_join_related_with_alias");
+ result.add("select_right_outer_join_related_with_alias");
+ result.add("select_alias_as_keyword");
+ result.add("select_avg");
+ result.add("select_between_with_single_table");
+ result.add("select_distinct_with_single_count_group_by");
+ result.add("select_bit_xor");
+ result.add("select_with_schema");
+ result.add("select_with_same_table_name_and_alias");
+ result.add("select_count_like_concat");
+ result.add("select_order_by_asc_and_index_desc");
+ result.add("select_group_by_with_having_count");
+ result.add("select_constant_without_table");
+ result.add("select_count_with_binding_tables_with_join");
+ result.add("select_join_using");
+ result.add("select_count_with_escape_character");
+ result.add("select_group_by_with_order_by_and_limit");
+ result.add("select_count_with_sub");
+ result.add("select_current_user");
+ result.add("select_database");
+ result.add("select_distinct_with_count_calculation");
+ result.add("select_count_like_escape");
+ result.add("select_with_projection_subquery_and_multiple_parameters");
+ result.add("select_group_concat");
+ result.add("select_cast_function");
+ result.add("select_position");
+ result.add("select_mod_function");
+ result.add("select_pagination_with_offset");
+ result.add("select_pagination_with_row_count");
+ result.add("select_pagination_with_top");
+ result.add("select_pagination_with_top_percent_with_ties");
+ result.add("select_pagination_with_row_number");
+ result.add("select_pagination_with_limit_with_back_quotes");
+ result.add("select_pagination_with_limit_and_offset_keyword");
+ result.add("select_pagination_with_offset_and_limit");
+ result.add("select_pagination_with_offset_and_limit_all");
+ result.add("select_pagination_with_top_for_greater_than");
+ result.add("select_pagination_with_top_percent_with_ties_for_greater_than");
+ result.add("select_pagination_with_top_for_greater_than_and_equal");
+ result.add("select_pagination_with_top_percent_with_ties_for_greater_than_and_equal");
+ result.add("select_pagination_with_row_number_for_greater_than");
+ result.add("select_pagination_with_row_number_for_greater_than_and_equal");
+ result.add("select_pagination_with_row_number_not_at_end");
+ result.add("select_pagination_with_fetch_first_with_row_number");
+ result.add("select_pagination_with_offset_fetch");
+ result.add("select_pagination_with_limit_offset_and_row_count");
+ result.add("select_pagination_with_limit_row_count");
+ result.add("select_pagination_with_limit_fetch_count");
+ result.add("select_with_null_keyword_in_projection");
+ result.add("select_union");
+ result.add("select_union_all");
+ result.add("select_union_all_order_by");
+ result.add("select_union_all_order_by_limit");
+ result.add("select_intersect");
+ result.add("select_intersect_order_by");
+ result.add("select_intersect_order_by_limit");
+ result.add("select_except");
+ result.add("select_except_order_by");
+ result.add("select_except_order_by_limit");
+ result.add("select_minus");
+ result.add("select_minus_order_by");
+ result.add("select_minus_order_by_limit");
+ result.add("select_union_intersect");
+ result.add("select_union_except");
+ result.add("select_union_intersect_except");
+ result.add("select_except_union");
+ result.add("select_except_intersect");
+ result.add("select_except_intersect_union");
+ result.add("select_sub_union");
+ result.add("select_projections_with_expr");
+ result.add("select_projections_with_only_expr");
+ result.add("select_natural_join");
+ result.add("select_natural_inner_join");
+ result.add("select_natural_left_join");
+ result.add("select_natural_right_join");
+ result.add("select_natural_full_join");
+ result.add("select_order_by_for_nulls_first");
+ result.add("select_order_by_for_nulls_last");
+ return result;
+ }
+ // CHECKSTYLE:ON
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ return getTestParameters("MySQL", "PostgreSQL", "openGauss").stream();
+ }
+
+ private Collection<Arguments> getTestParameters(final String... databaseTypes) {
+ Collection<Arguments> result = new LinkedList<>();
+ for (InternalSQLParserTestParameter each : SQL_CASES.generateTestParameters(Arrays.stream(databaseTypes).collect(Collectors.toSet()))) {
+ if (!isPlaceholderWithoutParameter(each) && isSupportedSQLCase(each)) {
+ result.add(Arguments.of(each.getSqlCaseId(), each.getSqlCaseType(), "H2".equals(each.getDatabaseType()) ? "MySQL" : each.getDatabaseType()));
+ }
+ }
+ return result;
+ }
+
+ private boolean isPlaceholderWithoutParameter(final InternalSQLParserTestParameter testParam) {
+ return SQLCaseType.Placeholder == testParam.getSqlCaseType() && SQL_PARSER_TEST_CASES.get(testParam.getSqlCaseId()).getParameters().isEmpty();
+ }
+
+ private boolean isSupportedSQLCase(final InternalSQLParserTestParameter testParam) {
+ return testParam.getSqlCaseId().toUpperCase().startsWith(SELECT_STATEMENT_PREFIX) && supportedSQLCaseIDs.contains(testParam.getSqlCaseId());
+ }
+ }
}
diff --git a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/AbstractSQLRewriterIT.java b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/SQLRewriterIT.java
similarity index 81%
rename from test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/AbstractSQLRewriterIT.java
rename to test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/SQLRewriterIT.java
index 5e3013e0893..939d7b18c52 100644
--- a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/AbstractSQLRewriterIT.java
+++ b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/SQLRewriterIT.java
@@ -17,8 +17,7 @@
package org.apache.shardingsphere.test.it.rewrite.engine;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import com.google.common.base.Preconditions;
import org.apache.shardingsphere.infra.binder.QueryContext;
import org.apache.shardingsphere.infra.binder.SQLStatementContextFactory;
import org.apache.shardingsphere.infra.binder.aware.CursorDefinitionAware;
@@ -60,11 +59,14 @@ import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sqltranslator.api.config.SQLTranslatorRuleConfiguration;
import org.apache.shardingsphere.sqltranslator.rule.SQLTranslatorRule;
import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParameters;
+import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParametersBuilder;
import org.apache.shardingsphere.timeservice.api.config.TimeServiceRuleConfiguration;
import org.apache.shardingsphere.timeservice.core.rule.TimeServiceRule;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
import javax.sql.DataSource;
import java.io.IOException;
@@ -76,53 +78,50 @@ import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
+import java.util.stream.Stream;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-@RunWith(Parameterized.class)
-@RequiredArgsConstructor
-@Getter
-public abstract class AbstractSQLRewriterIT {
-
- private final SQLRewriteEngineTestParameters testParameters;
+public abstract class SQLRewriterIT {
private final SQLParserRule sqlParserRule = new SQLParserRule(new SQLParserRuleConfiguration(true,
DefaultSQLParserRuleConfigurationBuilder.PARSE_TREE_CACHE_OPTION, DefaultSQLParserRuleConfigurationBuilder.SQL_STATEMENT_CACHE_OPTION));
private final TimeServiceRule timeServiceRule = new TimeServiceRule(new TimeServiceRuleConfiguration("System", new Properties()));
- @Test
- public final void assertRewrite() throws IOException, SQLException {
- Collection<SQLRewriteUnit> actual = createSQLRewriteUnits();
- assertThat(actual.size(), is(testParameters.getOutputSQLs().size()));
+ @ParameterizedTest(name = "{0}")
+ @ArgumentsSource(TestCaseArgumentsProvider.class)
+ public final void assertRewrite(final SQLRewriteEngineTestParameters testParams) throws IOException, SQLException {
+ Collection<SQLRewriteUnit> actual = createSQLRewriteUnits(testParams);
+ assertThat(actual.size(), is(testParams.getOutputSQLs().size()));
int count = 0;
for (SQLRewriteUnit each : actual) {
- assertThat(each.getSql(), is(testParameters.getOutputSQLs().get(count)));
- assertThat(each.getParameters().size(), is(testParameters.getOutputGroupedParameters().get(count).size()));
+ assertThat(each.getSql(), is(testParams.getOutputSQLs().get(count)));
+ assertThat(each.getParameters().size(), is(testParams.getOutputGroupedParameters().get(count).size()));
for (int i = 0; i < each.getParameters().size(); i++) {
- assertThat(String.valueOf(each.getParameters().get(i)), is(String.valueOf(testParameters.getOutputGroupedParameters().get(count).get(i))));
+ assertThat(String.valueOf(each.getParameters().get(i)), is(String.valueOf(testParams.getOutputGroupedParameters().get(count).get(i))));
}
count++;
}
}
- private Collection<SQLRewriteUnit> createSQLRewriteUnits() throws IOException, SQLException {
- YamlRootConfiguration rootConfig = createRootConfiguration();
+ private Collection<SQLRewriteUnit> createSQLRewriteUnits(final SQLRewriteEngineTestParameters testParams) throws IOException, SQLException {
+ YamlRootConfiguration rootConfig = createRootConfiguration(testParams);
DatabaseConfiguration databaseConfig = new DataSourceProvidedDatabaseConfiguration(
new YamlDataSourceConfigurationSwapper().swapToDataSources(rootConfig.getDataSources()), new YamlRuleConfigurationSwapperEngine().swapToRuleConfigurations(rootConfig.getRules()));
mockDataSource(databaseConfig.getDataSources());
ShardingSphereResourceMetaData resourceMetaData = mock(ShardingSphereResourceMetaData.class);
- DatabaseType databaseType = TypedSPILoader.getService(DatabaseType.class, getTestParameters().getDatabaseType());
+ DatabaseType databaseType = TypedSPILoader.getService(DatabaseType.class, testParams.getDatabaseType());
Map<String, DatabaseType> storageTypes = createStorageTypes(databaseConfig, databaseType);
when(resourceMetaData.getStorageTypes()).thenReturn(storageTypes);
String schemaName = DatabaseTypeEngine.getDefaultSchemaName(databaseType, DefaultDatabase.LOGIC_NAME);
Collection<ShardingSphereRule> databaseRules = DatabaseRulesBuilder.build(DefaultDatabase.LOGIC_NAME, databaseConfig, mock(InstanceContext.class));
- SQLStatementParserEngine sqlStatementParserEngine = new SQLStatementParserEngine(getTestParameters().getDatabaseType(),
+ SQLStatementParserEngine sqlStatementParserEngine = new SQLStatementParserEngine(testParams.getDatabaseType(),
sqlParserRule.getSqlStatementCache(), sqlParserRule.getParseTreeCache(), sqlParserRule.isSqlCommentParseEnabled());
- SQLStatement sqlStatement = sqlStatementParserEngine.parse(getTestParameters().getInputSQL(), false);
+ SQLStatement sqlStatement = sqlStatementParserEngine.parse(testParams.getInputSQL(), false);
mockRules(databaseRules, schemaName, sqlStatement);
databaseRules.add(sqlParserRule);
databaseRules.add(timeServiceRule);
@@ -131,20 +130,20 @@ public abstract class AbstractSQLRewriterIT {
databases.put(schemaName, database);
SQLStatementContext<?> sqlStatementContext = SQLStatementContextFactory.newInstance(createShardingSphereMetaData(databases), sqlStatement, schemaName);
if (sqlStatementContext instanceof ParameterAware) {
- ((ParameterAware) sqlStatementContext).setUpParameters(getTestParameters().getInputParameters());
+ ((ParameterAware) sqlStatementContext).setUpParameters(testParams.getInputParameters());
}
if (sqlStatementContext instanceof CursorDefinitionAware) {
((CursorDefinitionAware) sqlStatementContext).setUpCursorDefinition(createCursorDefinition(schemaName, databases, sqlStatementParserEngine));
}
- QueryContext queryContext = new QueryContext(sqlStatementContext, getTestParameters().getInputSQL(), getTestParameters().getInputParameters());
+ QueryContext queryContext = new QueryContext(sqlStatementContext, testParams.getInputSQL(), testParams.getInputParameters());
ConfigurationProperties props = new ConfigurationProperties(rootConfig.getProps());
RouteContext routeContext = new SQLRouteEngine(databaseRules, props).route(new ConnectionContext(), queryContext, mock(ShardingSphereRuleMetaData.class), database);
SQLRewriteEntry sqlRewriteEntry = new SQLRewriteEntry(database, new ShardingSphereRuleMetaData(Collections.singleton(new SQLTranslatorRule(new SQLTranslatorRuleConfiguration()))), props);
ConnectionContext connectionContext = mock(ConnectionContext.class);
when(connectionContext.getCursorConnectionContext()).thenReturn(new CursorConnectionContext());
- SQLRewriteResult sqlRewriteResult = sqlRewriteEntry.rewrite(getTestParameters().getInputSQL(), getTestParameters().getInputParameters(), sqlStatementContext, routeContext, connectionContext);
+ SQLRewriteResult sqlRewriteResult = sqlRewriteEntry.rewrite(testParams.getInputSQL(), testParams.getInputParameters(), sqlStatementContext, routeContext, connectionContext);
return sqlRewriteResult instanceof GenericSQLRewriteResult
- ? Collections.singletonList(((GenericSQLRewriteResult) sqlRewriteResult).getSqlRewriteUnit())
+ ? Collections.singleton(((GenericSQLRewriteResult) sqlRewriteResult).getSqlRewriteUnit())
: (((RouteSQLRewriteResult) sqlRewriteResult).getSqlRewriteUnits()).values();
}
@@ -167,9 +166,19 @@ public abstract class AbstractSQLRewriterIT {
protected abstract void mockDataSource(Map<String, DataSource> dataSources) throws SQLException;
- protected abstract YamlRootConfiguration createRootConfiguration() throws IOException;
+ protected abstract YamlRootConfiguration createRootConfiguration(SQLRewriteEngineTestParameters testParams) throws IOException;
protected abstract Map<String, ShardingSphereSchema> mockSchemas(String schemaName);
protected abstract void mockRules(Collection<ShardingSphereRule> rules, String schemaName, SQLStatement sqlStatement);
+
+ private static class TestCaseArgumentsProvider implements ArgumentsProvider {
+
+ @Override
+ public Stream<? extends Arguments> provideArguments(final ExtensionContext extensionContext) {
+ SQLRewriterITSettings settings = extensionContext.getRequiredTestClass().getAnnotation(SQLRewriterITSettings.class);
+ Preconditions.checkNotNull(settings, "Annotation ExternalSQLParserITSettings is required.");
+ return SQLRewriteEngineTestParametersBuilder.loadTestParameters(settings.value().toUpperCase(), settings.value(), SQLRewriterIT.class).stream().map(Arguments::of);
+ }
+ }
}
diff --git a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidator.java b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/SQLRewriterITSettings.java
similarity index 52%
copy from kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidator.java
copy to test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/SQLRewriterITSettings.java
index 8e347c97fad..de66049dd0e 100644
--- a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidator.java
+++ b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/SQLRewriterITSettings.java
@@ -15,26 +15,23 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.single.route.validator;
+package org.apache.shardingsphere.test.it.rewrite.engine;
-import org.apache.shardingsphere.infra.binder.statement.SQLStatementContext;
-import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import org.apache.shardingsphere.single.rule.SingleRule;
-import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
/**
- * Single meta data validator.
- *
- * @param <T> type of SQL statement
+ * SQL rewriter IT settings.
*/
-public interface SingleMetaDataValidator<T extends SQLStatement> {
+@Inherited
+@Retention(RetentionPolicy.RUNTIME)
+public @interface SQLRewriterITSettings {
/**
- * Validate single table meta data.
+ * Get scenario case path.
*
- * @param rule single table rule
- * @param sqlStatementContext SQL statement context
- * @param database database
+ * @return scenario case path
*/
- void validate(SingleRule rule, SQLStatementContext<T> sqlStatementContext, ShardingSphereDatabase database);
+ String value();
}
diff --git a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/parameter/SQLRewriteEngineTestParameters.java b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/parameter/SQLRewriteEngineTestParameters.java
index 3769ca741a2..ef2f6061d1f 100644
--- a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/parameter/SQLRewriteEngineTestParameters.java
+++ b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/parameter/SQLRewriteEngineTestParameters.java
@@ -61,4 +61,9 @@ public final class SQLRewriteEngineTestParameters {
result[4] = this;
return result;
}
+
+ @Override
+ public String toString() {
+ return String.format("{%s}: {%s} ({%s}) -> {%s}", type, name, databaseType, fileName);
+ }
}
diff --git a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/parameter/SQLRewriteEngineTestParametersBuilder.java b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/parameter/SQLRewriteEngineTestParametersBuilder.java
index 1a560bf479d..455cc79950b 100644
--- a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/parameter/SQLRewriteEngineTestParametersBuilder.java
+++ b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/parameter/SQLRewriteEngineTestParametersBuilder.java
@@ -53,10 +53,10 @@ public final class SQLRewriteEngineTestParametersBuilder {
* @param type type
* @param path path
* @param targetClass target class
- * @return Test parameters list for SQL rewrite engine
+ * @return test parameters list for SQL rewrite engine
*/
- public static Collection<Object[]> loadTestParameters(final String type, final String path, final Class<?> targetClass) {
- Collection<Object[]> result = new LinkedList<>();
+ public static Collection<SQLRewriteEngineTestParameters> loadTestParameters(final String type, final String path, final Class<?> targetClass) {
+ Collection<SQLRewriteEngineTestParameters> result = new LinkedList<>();
for (Entry<String, RewriteAssertionsRootEntity> entry : loadAllRewriteAssertionsRootEntities(type, path, targetClass).entrySet()) {
result.addAll(createTestParameters(type, entry.getKey(), entry.getValue()));
}
@@ -93,12 +93,12 @@ public final class SQLRewriteEngineTestParametersBuilder {
}
}
- private static Collection<Object[]> createTestParameters(final String type, final String fileName, final RewriteAssertionsRootEntity rootAssertions) {
- Collection<Object[]> result = new LinkedList<>();
+ private static Collection<SQLRewriteEngineTestParameters> createTestParameters(final String type, final String fileName, final RewriteAssertionsRootEntity rootAssertions) {
+ Collection<SQLRewriteEngineTestParameters> result = new LinkedList<>();
for (RewriteAssertionEntity each : rootAssertions.getAssertions()) {
for (String databaseType : getDatabaseTypes(each.getDatabaseTypes())) {
result.add(new SQLRewriteEngineTestParameters(type, each.getId(), fileName, rootAssertions.getYamlRule(), each.getInput().getSql(),
- createParameters(each.getInput().getParameters()), createOutputSQLs(each.getOutputs()), createOutputGroupedParameters(each.getOutputs()), databaseType).toArray());
+ createParameters(each.getInput().getParameters()), createOutputSQLs(each.getOutputs()), createOutputGroupedParameters(each.getOutputs()), databaseType));
}
}
return result;
diff --git a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/EncryptSQLRewriterIT.java b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/scenario/EncryptSQLRewriterIT.java
similarity index 76%
rename from test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/EncryptSQLRewriterIT.java
rename to test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/scenario/EncryptSQLRewriterIT.java
index 4d33cd6f171..9b2415c74cf 100644
--- a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/EncryptSQLRewriterIT.java
+++ b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/scenario/EncryptSQLRewriterIT.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.test.it.rewrite.scenario;
+package org.apache.shardingsphere.test.it.rewrite.engine.scenario;
import com.google.common.base.Preconditions;
import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
@@ -23,14 +23,13 @@ import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSp
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import org.apache.shardingsphere.infra.yaml.config.pojo.YamlRootConfiguration;
-import org.apache.shardingsphere.test.it.rewrite.engine.AbstractSQLRewriterIT;
-import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParametersBuilder;
-import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParameters;
import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.CreateTableStatement;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
-import org.junit.runners.Parameterized.Parameters;
+import org.apache.shardingsphere.test.it.rewrite.engine.SQLRewriterIT;
+import org.apache.shardingsphere.test.it.rewrite.engine.SQLRewriterITSettings;
+import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParameters;
import javax.sql.DataSource;
import java.io.File;
@@ -52,22 +51,12 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-public final class EncryptSQLRewriterIT extends AbstractSQLRewriterIT {
-
- private static final String CASE_PATH = "scenario/encrypt/case";
-
- public EncryptSQLRewriterIT(final String type, final String name, final String fileName, final String databaseType, final SQLRewriteEngineTestParameters testParams) {
- super(testParams);
- }
-
- @Parameters(name = "{0}: {1} ({3}) -> {2}")
- public static Collection<Object[]> loadTestParameters() {
- return SQLRewriteEngineTestParametersBuilder.loadTestParameters(CASE_PATH.toUpperCase(), CASE_PATH, EncryptSQLRewriterIT.class);
- }
+@SQLRewriterITSettings("scenario/encrypt/case")
+public final class EncryptSQLRewriterIT extends SQLRewriterIT {
@Override
- protected YamlRootConfiguration createRootConfiguration() throws IOException {
- URL url = EncryptSQLRewriterIT.class.getClassLoader().getResource(getTestParameters().getRuleFile());
+ protected YamlRootConfiguration createRootConfiguration(final SQLRewriteEngineTestParameters testParams) throws IOException {
+ URL url = EncryptSQLRewriterIT.class.getClassLoader().getResource(testParams.getRuleFile());
Preconditions.checkNotNull(url, "Can not find rewrite rule yaml configuration");
return YamlEngine.unmarshal(new File(url.getFile()), YamlRootConfiguration.class);
}
@@ -89,12 +78,12 @@ public final class EncryptSQLRewriterIT extends AbstractSQLRewriterIT {
@Override
protected void mockRules(final Collection<ShardingSphereRule> rules, final String schemaName, final SQLStatement sqlStatement) {
- Optional<SingleRule> singleTableRule = rules.stream().filter(each -> each instanceof SingleRule).map(each -> (SingleRule) each).findFirst();
- if (singleTableRule.isPresent() && !(sqlStatement instanceof CreateTableStatement)) {
- singleTableRule.get().put("encrypt_ds", schemaName, "t_account");
- singleTableRule.get().put("encrypt_ds", schemaName, "t_account_bak");
- singleTableRule.get().put("encrypt_ds", schemaName, "t_account_detail");
- singleTableRule.get().put("encrypt_ds", schemaName, "t_order");
+ Optional<SingleRule> singleRule = rules.stream().filter(each -> each instanceof SingleRule).map(each -> (SingleRule) each).findFirst();
+ if (singleRule.isPresent() && !(sqlStatement instanceof CreateTableStatement)) {
+ singleRule.get().put("encrypt_ds", schemaName, "t_account");
+ singleRule.get().put("encrypt_ds", schemaName, "t_account_bak");
+ singleRule.get().put("encrypt_ds", schemaName, "t_account_detail");
+ singleRule.get().put("encrypt_ds", schemaName, "t_order");
}
}
diff --git a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/MixSQLRewriterIT.java b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/scenario/MixSQLRewriterIT.java
similarity index 81%
rename from test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/MixSQLRewriterIT.java
rename to test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/scenario/MixSQLRewriterIT.java
index eff8dc7da91..52ea31d8512 100644
--- a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/MixSQLRewriterIT.java
+++ b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/scenario/MixSQLRewriterIT.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.test.it.rewrite.scenario;
+package org.apache.shardingsphere.test.it.rewrite.engine.scenario;
import com.google.common.base.Preconditions;
import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereColumn;
@@ -25,11 +25,10 @@ import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSp
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import org.apache.shardingsphere.infra.yaml.config.pojo.YamlRootConfiguration;
-import org.apache.shardingsphere.test.it.rewrite.engine.AbstractSQLRewriterIT;
-import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParametersBuilder;
-import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParameters;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
-import org.junit.runners.Parameterized.Parameters;
+import org.apache.shardingsphere.test.it.rewrite.engine.SQLRewriterIT;
+import org.apache.shardingsphere.test.it.rewrite.engine.SQLRewriterITSettings;
+import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParameters;
import javax.sql.DataSource;
import java.io.File;
@@ -45,22 +44,12 @@ import java.util.Map;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-public final class MixSQLRewriterIT extends AbstractSQLRewriterIT {
-
- private static final String CASE_PATH = "scenario/mix/case";
-
- public MixSQLRewriterIT(final String type, final String name, final String fileName, final String databaseType, final SQLRewriteEngineTestParameters testParams) {
- super(testParams);
- }
-
- @Parameters(name = "{0}: {1} ({3}) -> {2}")
- public static Collection<Object[]> loadTestParameters() {
- return SQLRewriteEngineTestParametersBuilder.loadTestParameters(CASE_PATH.toUpperCase(), CASE_PATH, MixSQLRewriterIT.class);
- }
+@SQLRewriterITSettings("scenario/mix/case")
+public final class MixSQLRewriterIT extends SQLRewriterIT {
@Override
- protected YamlRootConfiguration createRootConfiguration() throws IOException {
- URL url = MixSQLRewriterIT.class.getClassLoader().getResource(getTestParameters().getRuleFile());
+ protected YamlRootConfiguration createRootConfiguration(final SQLRewriteEngineTestParameters testParams) throws IOException {
+ URL url = MixSQLRewriterIT.class.getClassLoader().getResource(testParams.getRuleFile());
Preconditions.checkNotNull(url, "Can not find rewrite rule yaml configurations");
return YamlEngine.unmarshal(new File(url.getFile()), YamlRootConfiguration.class);
}
diff --git a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/ShardingSQLRewriterIT.java b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/scenario/ShardingSQLRewriterIT.java
similarity index 77%
rename from test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/ShardingSQLRewriterIT.java
rename to test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/scenario/ShardingSQLRewriterIT.java
index be632ad2b13..d597c62c8c8 100644
--- a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/ShardingSQLRewriterIT.java
+++ b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/scenario/ShardingSQLRewriterIT.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.test.it.rewrite.scenario;
+package org.apache.shardingsphere.test.it.rewrite.engine.scenario;
import com.google.common.base.Preconditions;
import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereColumn;
@@ -25,13 +25,12 @@ import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSp
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import org.apache.shardingsphere.infra.yaml.config.pojo.YamlRootConfiguration;
-import org.apache.shardingsphere.test.it.rewrite.engine.AbstractSQLRewriterIT;
-import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParametersBuilder;
-import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParameters;
import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.CreateTableStatement;
-import org.junit.runners.Parameterized.Parameters;
+import org.apache.shardingsphere.test.it.rewrite.engine.SQLRewriterIT;
+import org.apache.shardingsphere.test.it.rewrite.engine.SQLRewriterITSettings;
+import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParameters;
import javax.sql.DataSource;
import java.io.File;
@@ -49,32 +48,22 @@ import java.util.Optional;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-public final class ShardingSQLRewriterIT extends AbstractSQLRewriterIT {
-
- private static final String CASE_PATH = "scenario/sharding/case";
-
- public ShardingSQLRewriterIT(final String type, final String name, final String fileName, final String databaseType, final SQLRewriteEngineTestParameters testParams) {
- super(testParams);
- }
-
- @Parameters(name = "{0}: {1} ({3}) -> {2}")
- public static Collection<Object[]> loadTestParameters() {
- return SQLRewriteEngineTestParametersBuilder.loadTestParameters(CASE_PATH.toUpperCase(), CASE_PATH, ShardingSQLRewriterIT.class);
- }
+@SQLRewriterITSettings("scenario/sharding/case")
+public final class ShardingSQLRewriterIT extends SQLRewriterIT {
@Override
- protected YamlRootConfiguration createRootConfiguration() throws IOException {
- URL url = ShardingSQLRewriterIT.class.getClassLoader().getResource(getTestParameters().getRuleFile());
+ protected YamlRootConfiguration createRootConfiguration(final SQLRewriteEngineTestParameters testParams) throws IOException {
+ URL url = ShardingSQLRewriterIT.class.getClassLoader().getResource(testParams.getRuleFile());
Preconditions.checkNotNull(url, "Can not find rewrite rule yaml configuration");
return YamlEngine.unmarshal(new File(url.getFile()), YamlRootConfiguration.class);
}
@Override
protected void mockRules(final Collection<ShardingSphereRule> rules, final String schemaName, final SQLStatement sqlStatement) {
- Optional<SingleRule> singleTableRule = rules.stream().filter(each -> each instanceof SingleRule).map(each -> (SingleRule) each).findFirst();
- if (singleTableRule.isPresent() && !(sqlStatement instanceof CreateTableStatement)) {
- singleTableRule.get().put("db", schemaName, "t_single");
- singleTableRule.get().put("db", schemaName, "t_single_extend");
+ Optional<SingleRule> singleRule = rules.stream().filter(each -> each instanceof SingleRule).map(each -> (SingleRule) each).findFirst();
+ if (singleRule.isPresent() && !(sqlStatement instanceof CreateTableStatement)) {
+ singleRule.get().put("db", schemaName, "t_single");
+ singleRule.get().put("db", schemaName, "t_single_extend");
}
}