You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by zh...@apache.org on 2025/03/04 14:45:41 UTC
(shardingsphere) branch master updated: Rename RuleRepositoryTuple to RuleNodeTuple (#34872)
This is an automated email from the ASF dual-hosted git repository.
zhangliang 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 ae19702f947 Rename RuleRepositoryTuple to RuleNodeTuple (#34872)
ae19702f947 is described below
commit ae19702f94756d3a80e698794e2b677f4adb0c56
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Tue Mar 4 22:45:35 2025 +0800
Rename RuleRepositoryTuple to RuleNodeTuple (#34872)
---
.../config/YamlBroadcastRuleConfiguration.java | 10 +--
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 12 ++--
.../yaml/config/YamlEncryptRuleConfiguration.java | 12 ++--
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 16 ++---
.../yaml/config/YamlMaskRuleConfiguration.java | 12 ++--
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 16 ++---
.../YamlReadwriteSplittingRuleConfiguration.java | 12 ++--
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 18 +++---
.../yaml/config/YamlShadowRuleConfiguration.java | 16 ++---
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 30 ++++-----
.../yaml/config/YamlShardingRuleConfiguration.java | 38 +++++------
...ingTableRuleNodeTupleKeyListNameGenerator.java} | 6 +-
...figurationYamlRuleNodeTupleSwapperEngineIT.java | 64 +++++++++++++++++++
...tionYamlRuleRepositoryTupleSwapperEngineIT.java | 64 -------------------
.../database/type/DropDatabaseRuleOperator.java | 4 +-
.../config/YamlAuthorityRuleConfiguration.java | 4 +-
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 12 ++--
.../config/YamlGlobalClockRuleConfiguration.java | 4 +-
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 12 ++--
.../yaml/config/YamlLoggingRuleConfiguration.java | 4 +-
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 12 ++--
.../yaml/config/YamlSingleRuleConfiguration.java | 10 +--
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 14 ++--
.../config/YamlSQLFederationRuleConfiguration.java | 4 +-
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 12 ++--
.../config/YamlSQLParserRuleConfiguration.java | 4 +-
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 12 ++--
.../config/YamlSQLTranslatorRuleConfiguration.java | 4 +-
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 12 ++--
.../config/YamlTransactionRuleConfiguration.java | 4 +-
...igurationYamlRuleNodeTupleSwapperEngineIT.java} | 12 ++--
.../manager/rule/GlobalConfigurationManager.java | 4 +-
.../database/DatabaseRulePersistService.java | 20 +++---
.../config/global/GlobalRulePersistService.java | 10 +--
.../node/rule/node/DatabaseRuleNodeGenerator.java | 16 ++---
...RuleRepositoryTuple.java => RuleNodeTuple.java} | 4 +-
.../rule/tuple/YamlRuleConfigurationFieldUtil.java | 6 +-
...ne.java => YamlRuleNodeTupleSwapperEngine.java} | 74 +++++++++++-----------
...ryTupleEntity.java => RuleNodeTupleEntity.java} | 4 +-
...toryTupleField.java => RuleNodeTupleField.java} | 4 +-
...java => RuleNodeTupleKeyListNameGenerator.java} | 8 +--
...ava => YamlRuleNodeTupleSwapperEngineTest.java} | 34 +++++-----
.../fixture/leaf/YamlLeafRuleConfiguration.java | 4 +-
... RuleNodeTupleKeyListNameGeneratorFixture.java} | 4 +-
.../fixture/node/YamlNodeRuleConfiguration.java | 34 +++++-----
.../infra/yaml/MockedYamlRuleConfiguration.java | 12 ++--
.../global/MockedYamlGlobalRuleConfiguration.java | 4 +-
....java => YamlRuleNodeTupleSwapperEngineIT.java} | 24 +++----
48 files changed, 366 insertions(+), 366 deletions(-)
diff --git a/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/yaml/config/YamlBroadcastRuleConfiguration.java b/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/yaml/config/YamlBroadcastRuleConfiguration.java
index a97b6851df4..b2d597882e0 100644
--- a/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/yaml/config/YamlBroadcastRuleConfiguration.java
+++ b/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/yaml/config/YamlBroadcastRuleConfiguration.java
@@ -22,9 +22,9 @@ import lombok.Setter;
import org.apache.shardingsphere.broadcast.config.BroadcastRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField.Type;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField.Type;
import java.util.Collection;
import java.util.LinkedList;
@@ -32,12 +32,12 @@ import java.util.LinkedList;
/**
* Broadcast rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity("broadcast")
+@RuleNodeTupleEntity("broadcast")
@Getter
@Setter
public final class YamlBroadcastRuleConfiguration implements YamlRuleConfiguration {
- @RuleRepositoryTupleField(type = Type.TABLE)
+ @RuleNodeTupleField(type = Type.TABLE)
private Collection<String> tables = new LinkedList<>();
@Override
diff --git a/features/broadcast/core/src/test/java/org/apache/shardingsphere/broadcast/yaml/BroadcastRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/features/broadcast/core/src/test/java/org/apache/shardingsphere/broadcast/yaml/BroadcastRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 66%
rename from features/broadcast/core/src/test/java/org/apache/shardingsphere/broadcast/yaml/BroadcastRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to features/broadcast/core/src/test/java/org/apache/shardingsphere/broadcast/yaml/BroadcastRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index f7878571b62..d347b728bb2 100644
--- a/features/broadcast/core/src/test/java/org/apache/shardingsphere/broadcast/yaml/BroadcastRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/features/broadcast/core/src/test/java/org/apache/shardingsphere/broadcast/yaml/BroadcastRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -18,24 +18,24 @@
package org.apache.shardingsphere.broadcast.yaml;
import org.apache.shardingsphere.broadcast.yaml.config.YamlBroadcastRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class BroadcastRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class BroadcastRuleConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- BroadcastRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ BroadcastRuleConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/broadcast-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(1));
- assertRepositoryTuple(actualTuples.get(0), "tables", ((YamlBroadcastRuleConfiguration) expectedYamlRuleConfig).getTables());
+ assertRuleNodeTuple(actualTuples.get(0), "tables", ((YamlBroadcastRuleConfiguration) expectedYamlRuleConfig).getTables());
}
}
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/yaml/config/YamlEncryptRuleConfiguration.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/yaml/config/YamlEncryptRuleConfiguration.java
index cfb11044cee..28c358d2d61 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/yaml/config/YamlEncryptRuleConfiguration.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/yaml/config/YamlEncryptRuleConfiguration.java
@@ -23,9 +23,9 @@ import org.apache.shardingsphere.encrypt.config.EncryptRuleConfiguration;
import org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptTableRuleConfiguration;
import org.apache.shardingsphere.infra.algorithm.core.yaml.YamlAlgorithmConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField.Type;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField.Type;
import java.util.LinkedHashMap;
import java.util.Map;
@@ -33,15 +33,15 @@ import java.util.Map;
/**
* Encrypt rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity("encrypt")
+@RuleNodeTupleEntity("encrypt")
@Getter
@Setter
public final class YamlEncryptRuleConfiguration implements YamlRuleConfiguration {
- @RuleRepositoryTupleField(type = Type.TABLE)
+ @RuleNodeTupleField(type = Type.TABLE)
private Map<String, YamlEncryptTableRuleConfiguration> tables = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.ALGORITHM)
+ @RuleNodeTupleField(type = Type.ALGORITHM)
private Map<String, YamlAlgorithmConfiguration> encryptors = new LinkedHashMap<>();
@Override
diff --git a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/yaml/EncryptConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/yaml/EncryptConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 56%
rename from features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/yaml/EncryptConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/yaml/EncryptConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index 69bd00fbfd2..9e7b224de49 100644
--- a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/yaml/EncryptConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/yaml/EncryptConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -18,26 +18,26 @@
package org.apache.shardingsphere.encrypt.yaml;
import org.apache.shardingsphere.encrypt.yaml.config.YamlEncryptRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class EncryptConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class EncryptConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- EncryptConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ EncryptConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/encrypt-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(3));
- assertRepositoryTuple(actualTuples.get(0), "encryptors/aes_encryptor", ((YamlEncryptRuleConfiguration) expectedYamlRuleConfig).getEncryptors().get("aes_encryptor"));
- assertRepositoryTuple(actualTuples.get(1), "encryptors/assisted_encryptor", ((YamlEncryptRuleConfiguration) expectedYamlRuleConfig).getEncryptors().get("assisted_encryptor"));
- assertRepositoryTuple(actualTuples.get(2), "tables/t_user", ((YamlEncryptRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_user"));
+ assertRuleNodeTuple(actualTuples.get(0), "encryptors/aes_encryptor", ((YamlEncryptRuleConfiguration) expectedYamlRuleConfig).getEncryptors().get("aes_encryptor"));
+ assertRuleNodeTuple(actualTuples.get(1), "encryptors/assisted_encryptor", ((YamlEncryptRuleConfiguration) expectedYamlRuleConfig).getEncryptors().get("assisted_encryptor"));
+ assertRuleNodeTuple(actualTuples.get(2), "tables/t_user", ((YamlEncryptRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_user"));
}
}
diff --git a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/yaml/config/YamlMaskRuleConfiguration.java b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/yaml/config/YamlMaskRuleConfiguration.java
index 4778defe19b..b93ef2b5849 100644
--- a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/yaml/config/YamlMaskRuleConfiguration.java
+++ b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/yaml/config/YamlMaskRuleConfiguration.java
@@ -21,9 +21,9 @@ import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.algorithm.core.yaml.YamlAlgorithmConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField.Type;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField.Type;
import org.apache.shardingsphere.mask.config.MaskRuleConfiguration;
import org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskTableRuleConfiguration;
@@ -33,15 +33,15 @@ import java.util.Map;
/**
* Mask rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity("mask")
+@RuleNodeTupleEntity("mask")
@Getter
@Setter
public final class YamlMaskRuleConfiguration implements YamlRuleConfiguration {
- @RuleRepositoryTupleField(type = Type.TABLE)
+ @RuleNodeTupleField(type = Type.TABLE)
private Map<String, YamlMaskTableRuleConfiguration> tables = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.ALGORITHM)
+ @RuleNodeTupleField(type = Type.ALGORITHM)
private Map<String, YamlAlgorithmConfiguration> maskAlgorithms = new LinkedHashMap<>();
@Override
diff --git a/features/mask/core/src/test/java/org/apache/shardingsphere/mask/yaml/MaskConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/features/mask/core/src/test/java/org/apache/shardingsphere/mask/yaml/MaskConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 62%
rename from features/mask/core/src/test/java/org/apache/shardingsphere/mask/yaml/MaskConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to features/mask/core/src/test/java/org/apache/shardingsphere/mask/yaml/MaskConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index f9ed0e7f59c..b56dcb57fab 100644
--- a/features/mask/core/src/test/java/org/apache/shardingsphere/mask/yaml/MaskConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/features/mask/core/src/test/java/org/apache/shardingsphere/mask/yaml/MaskConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,28 +17,28 @@
package org.apache.shardingsphere.mask.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
import org.apache.shardingsphere.mask.yaml.config.YamlMaskRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class MaskConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class MaskConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- MaskConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ MaskConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/mask-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(3));
- assertRepositoryTuple(actualTuples.get(0),
+ assertRuleNodeTuple(actualTuples.get(0),
"mask_algorithms/keep_first_n_last_m_mask", ((YamlMaskRuleConfiguration) expectedYamlRuleConfig).getMaskAlgorithms().get("keep_first_n_last_m_mask"));
- assertRepositoryTuple(actualTuples.get(1), "mask_algorithms/md5_mask", ((YamlMaskRuleConfiguration) expectedYamlRuleConfig).getMaskAlgorithms().get("md5_mask"));
- assertRepositoryTuple(actualTuples.get(2), "tables/t_user", ((YamlMaskRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_user"));
+ assertRuleNodeTuple(actualTuples.get(1), "mask_algorithms/md5_mask", ((YamlMaskRuleConfiguration) expectedYamlRuleConfig).getMaskAlgorithms().get("md5_mask"));
+ assertRuleNodeTuple(actualTuples.get(2), "tables/t_user", ((YamlMaskRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_user"));
}
}
diff --git a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/config/YamlReadwriteSplittingRuleConfiguration.java b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/config/YamlReadwriteSplittingRuleConfiguration.java
index 75a0fdf02d3..94730d88077 100644
--- a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/config/YamlReadwriteSplittingRuleConfiguration.java
+++ b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/config/YamlReadwriteSplittingRuleConfiguration.java
@@ -21,9 +21,9 @@ import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.algorithm.core.yaml.YamlAlgorithmConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField.Type;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField.Type;
import org.apache.shardingsphere.readwritesplitting.config.ReadwriteSplittingRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.yaml.config.rule.YamlReadwriteSplittingDataSourceGroupRuleConfiguration;
@@ -33,15 +33,15 @@ import java.util.Map;
/**
* Readwrite-splitting rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity("readwrite_splitting")
+@RuleNodeTupleEntity("readwrite_splitting")
@Getter
@Setter
public final class YamlReadwriteSplittingRuleConfiguration implements YamlRuleConfiguration {
- @RuleRepositoryTupleField(type = Type.DATA_SOURCE)
+ @RuleNodeTupleField(type = Type.DATA_SOURCE)
private Map<String, YamlReadwriteSplittingDataSourceGroupRuleConfiguration> dataSourceGroups = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.ALGORITHM)
+ @RuleNodeTupleField(type = Type.ALGORITHM)
private Map<String, YamlAlgorithmConfiguration> loadBalancers = new LinkedHashMap<>();
@Override
diff --git a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/ReadwriteSplittingConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/ReadwriteSplittingConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 51%
rename from features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/ReadwriteSplittingConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/ReadwriteSplittingConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index 70246700c24..f95757d1b0f 100644
--- a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/ReadwriteSplittingConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/ReadwriteSplittingConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,28 +17,28 @@
package org.apache.shardingsphere.readwritesplitting.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.yaml.config.YamlReadwriteSplittingRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class ReadwriteSplittingConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class ReadwriteSplittingConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- ReadwriteSplittingConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ ReadwriteSplittingConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/readwrite-splitting-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(4));
- assertRepositoryTuple(actualTuples.get(0), "load_balancers/random", ((YamlReadwriteSplittingRuleConfiguration) expectedYamlRuleConfig).getLoadBalancers().get("random"));
- assertRepositoryTuple(actualTuples.get(1), "load_balancers/roundRobin", ((YamlReadwriteSplittingRuleConfiguration) expectedYamlRuleConfig).getLoadBalancers().get("roundRobin"));
- assertRepositoryTuple(actualTuples.get(2), "data_source_groups/ds_0", ((YamlReadwriteSplittingRuleConfiguration) expectedYamlRuleConfig).getDataSourceGroups().get("ds_0"));
- assertRepositoryTuple(actualTuples.get(3), "data_source_groups/ds_1", ((YamlReadwriteSplittingRuleConfiguration) expectedYamlRuleConfig).getDataSourceGroups().get("ds_1"));
+ assertRuleNodeTuple(actualTuples.get(0), "load_balancers/random", ((YamlReadwriteSplittingRuleConfiguration) expectedYamlRuleConfig).getLoadBalancers().get("random"));
+ assertRuleNodeTuple(actualTuples.get(1), "load_balancers/roundRobin", ((YamlReadwriteSplittingRuleConfiguration) expectedYamlRuleConfig).getLoadBalancers().get("roundRobin"));
+ assertRuleNodeTuple(actualTuples.get(2), "data_source_groups/ds_0", ((YamlReadwriteSplittingRuleConfiguration) expectedYamlRuleConfig).getDataSourceGroups().get("ds_0"));
+ assertRuleNodeTuple(actualTuples.get(3), "data_source_groups/ds_1", ((YamlReadwriteSplittingRuleConfiguration) expectedYamlRuleConfig).getDataSourceGroups().get("ds_1"));
}
}
diff --git a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/yaml/config/YamlShadowRuleConfiguration.java b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/yaml/config/YamlShadowRuleConfiguration.java
index 71716947ab5..6c578046d6a 100644
--- a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/yaml/config/YamlShadowRuleConfiguration.java
+++ b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/yaml/config/YamlShadowRuleConfiguration.java
@@ -21,9 +21,9 @@ import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.algorithm.core.yaml.YamlAlgorithmConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField.Type;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField.Type;
import org.apache.shardingsphere.shadow.config.ShadowRuleConfiguration;
import org.apache.shardingsphere.shadow.yaml.config.datasource.YamlShadowDataSourceConfiguration;
import org.apache.shardingsphere.shadow.yaml.config.table.YamlShadowTableConfiguration;
@@ -34,21 +34,21 @@ import java.util.Map;
/**
* Shadow rule configuration.
*/
-@RuleRepositoryTupleEntity("shadow")
+@RuleNodeTupleEntity("shadow")
@Getter
@Setter
public final class YamlShadowRuleConfiguration implements YamlRuleConfiguration {
- @RuleRepositoryTupleField(type = Type.DATA_SOURCE)
+ @RuleNodeTupleField(type = Type.DATA_SOURCE)
private Map<String, YamlShadowDataSourceConfiguration> dataSources = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.TABLE)
+ @RuleNodeTupleField(type = Type.TABLE)
private Map<String, YamlShadowTableConfiguration> tables = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.ALGORITHM)
+ @RuleNodeTupleField(type = Type.ALGORITHM)
private Map<String, YamlAlgorithmConfiguration> shadowAlgorithms = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.DEFAULT_ALGORITHM)
+ @RuleNodeTupleField(type = Type.DEFAULT_ALGORITHM)
private String defaultShadowAlgorithmName;
@Override
diff --git a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/yaml/ShadowRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/yaml/ShadowRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 54%
rename from features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/yaml/ShadowRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/yaml/ShadowRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index f576ac2c4fc..fca00e6f1fa 100644
--- a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/yaml/ShadowRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/yaml/ShadowRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,10 +17,10 @@
package org.apache.shardingsphere.shadow.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
import org.apache.shardingsphere.shadow.yaml.config.YamlShadowRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.ArrayList;
import java.util.List;
@@ -28,27 +28,27 @@ import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class ShadowRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class ShadowRuleConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- ShadowRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ ShadowRuleConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/shadow-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(9));
- List<RuleRepositoryTuple> actual = new ArrayList<>(actualTuples);
- assertRepositoryTuple(actual.get(0),
+ List<RuleNodeTuple> actual = new ArrayList<>(actualTuples);
+ assertRuleNodeTuple(actual.get(0),
"shadow_algorithms/user-id-insert-match-algorithm", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getShadowAlgorithms().get("user-id-insert-match-algorithm"));
- assertRepositoryTuple(actual.get(1),
+ assertRuleNodeTuple(actual.get(1),
"shadow_algorithms/user-id-update-match-algorithm", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getShadowAlgorithms().get("user-id-update-match-algorithm"));
- assertRepositoryTuple(actual.get(2),
+ assertRuleNodeTuple(actual.get(2),
"shadow_algorithms/user-id-select-match-algorithm", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getShadowAlgorithms().get("user-id-select-match-algorithm"));
- assertRepositoryTuple(actual.get(3), "shadow_algorithms/sql-hint-algorithm", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getShadowAlgorithms().get("sql-hint-algorithm"));
- assertRepositoryTuple(actual.get(4), "default_shadow_algorithm_name", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getDefaultShadowAlgorithmName());
- assertRepositoryTuple(actual.get(5), "data_sources/shadowDataSource", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getDataSources().get("shadowDataSource"));
- assertRepositoryTuple(actual.get(6), "tables/t_order", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_order"));
- assertRepositoryTuple(actual.get(7), "tables/t_order_item", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_order_item"));
- assertRepositoryTuple(actual.get(8), "tables/t_address", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_address"));
+ assertRuleNodeTuple(actual.get(3), "shadow_algorithms/sql-hint-algorithm", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getShadowAlgorithms().get("sql-hint-algorithm"));
+ assertRuleNodeTuple(actual.get(4), "default_shadow_algorithm_name", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getDefaultShadowAlgorithmName());
+ assertRuleNodeTuple(actual.get(5), "data_sources/shadowDataSource", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getDataSources().get("shadowDataSource"));
+ assertRuleNodeTuple(actual.get(6), "tables/t_order", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_order"));
+ assertRuleNodeTuple(actual.get(7), "tables/t_order_item", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_order_item"));
+ assertRuleNodeTuple(actual.get(8), "tables/t_address", ((YamlShadowRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_address"));
}
}
diff --git a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/config/YamlShardingRuleConfiguration.java b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/config/YamlShardingRuleConfiguration.java
index db2566a5cf7..873b67250ce 100644
--- a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/config/YamlShardingRuleConfiguration.java
+++ b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/config/YamlShardingRuleConfiguration.java
@@ -21,10 +21,10 @@ import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.algorithm.core.yaml.YamlAlgorithmConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField.Type;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleKeyListNameGenerator;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField.Type;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleKeyListNameGenerator;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
import org.apache.shardingsphere.sharding.yaml.config.cache.YamlShardingCacheConfiguration;
import org.apache.shardingsphere.sharding.yaml.config.rule.YamlShardingAutoTableRuleConfiguration;
@@ -32,7 +32,7 @@ import org.apache.shardingsphere.sharding.yaml.config.rule.YamlTableRuleConfigur
import org.apache.shardingsphere.sharding.yaml.config.strategy.audit.YamlShardingAuditStrategyConfiguration;
import org.apache.shardingsphere.sharding.yaml.config.strategy.keygen.YamlKeyGenerateStrategyConfiguration;
import org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlShardingStrategyConfiguration;
-import org.apache.shardingsphere.sharding.yaml.swapper.ShardingBindingTableRepositoryTupleKeyListNameGenerator;
+import org.apache.shardingsphere.sharding.yaml.swapper.ShardingBindingTableRuleNodeTupleKeyListNameGenerator;
import java.util.Collection;
import java.util.LinkedHashMap;
@@ -42,46 +42,46 @@ import java.util.Map;
/**
* Sharding rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity("sharding")
+@RuleNodeTupleEntity("sharding")
@Getter
@Setter
public final class YamlShardingRuleConfiguration implements YamlRuleConfiguration {
- @RuleRepositoryTupleField(type = Type.TABLE)
+ @RuleNodeTupleField(type = Type.TABLE)
private Map<String, YamlTableRuleConfiguration> tables = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.TABLE)
+ @RuleNodeTupleField(type = Type.TABLE)
private Map<String, YamlShardingAutoTableRuleConfiguration> autoTables = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.TABLE)
- @RuleRepositoryTupleKeyListNameGenerator(ShardingBindingTableRepositoryTupleKeyListNameGenerator.class)
+ @RuleNodeTupleField(type = Type.TABLE)
+ @RuleNodeTupleKeyListNameGenerator(ShardingBindingTableRuleNodeTupleKeyListNameGenerator.class)
private Collection<String> bindingTables = new LinkedList<>();
- @RuleRepositoryTupleField(type = Type.DEFAULT_STRATEGY)
+ @RuleNodeTupleField(type = Type.DEFAULT_STRATEGY)
private YamlShardingStrategyConfiguration defaultDatabaseStrategy;
- @RuleRepositoryTupleField(type = Type.DEFAULT_STRATEGY)
+ @RuleNodeTupleField(type = Type.DEFAULT_STRATEGY)
private YamlShardingStrategyConfiguration defaultTableStrategy;
- @RuleRepositoryTupleField(type = Type.DEFAULT_STRATEGY)
+ @RuleNodeTupleField(type = Type.DEFAULT_STRATEGY)
private YamlKeyGenerateStrategyConfiguration defaultKeyGenerateStrategy;
- @RuleRepositoryTupleField(type = Type.DEFAULT_STRATEGY)
+ @RuleNodeTupleField(type = Type.DEFAULT_STRATEGY)
private YamlShardingAuditStrategyConfiguration defaultAuditStrategy;
- @RuleRepositoryTupleField(type = Type.ALGORITHM)
+ @RuleNodeTupleField(type = Type.ALGORITHM)
private Map<String, YamlAlgorithmConfiguration> shardingAlgorithms = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.ALGORITHM)
+ @RuleNodeTupleField(type = Type.ALGORITHM)
private Map<String, YamlAlgorithmConfiguration> keyGenerators = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.ALGORITHM)
+ @RuleNodeTupleField(type = Type.ALGORITHM)
private Map<String, YamlAlgorithmConfiguration> auditors = new LinkedHashMap<>();
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private String defaultShardingColumn;
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private YamlShardingCacheConfiguration shardingCache;
@Override
diff --git a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/ShardingBindingTableRepositoryTupleKeyListNameGenerator.java b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/ShardingBindingTableRuleNodeTupleKeyListNameGenerator.java
similarity index 83%
rename from features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/ShardingBindingTableRepositoryTupleKeyListNameGenerator.java
rename to features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/ShardingBindingTableRuleNodeTupleKeyListNameGenerator.java
index 6d736765256..2376df7f031 100644
--- a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/ShardingBindingTableRepositoryTupleKeyListNameGenerator.java
+++ b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/ShardingBindingTableRuleNodeTupleKeyListNameGenerator.java
@@ -17,13 +17,13 @@
package org.apache.shardingsphere.sharding.yaml.swapper;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleKeyListNameGenerator;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleKeyListNameGenerator;
import org.apache.shardingsphere.sharding.yaml.swapper.rule.YamlShardingTableReferenceRuleConfigurationConverter;
/**
- * Sharding binding table repository tuple key list name generator.
+ * Sharding binding table rule node tuple key list name generator.
*/
-public final class ShardingBindingTableRepositoryTupleKeyListNameGenerator implements RuleRepositoryTupleKeyListNameGenerator.Generator {
+public final class ShardingBindingTableRuleNodeTupleKeyListNameGenerator implements RuleNodeTupleKeyListNameGenerator.Generator {
@Override
public String generate(final Object tupleValue) {
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/ShardingConfigurationYamlRuleNodeTupleSwapperEngineIT.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/ShardingConfigurationYamlRuleNodeTupleSwapperEngineIT.java
new file mode 100644
index 00000000000..3466a7c77d5
--- /dev/null
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/ShardingConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.sharding.yaml;
+
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
+import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
+import org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfiguration;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+class ShardingConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
+
+ ShardingConfigurationYamlRuleNodeTupleSwapperEngineIT() {
+ super("yaml/sharding-rule-for-tuple.yaml");
+ }
+
+ @Override
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ assertThat(actualTuples.size(), is(19));
+ assertRuleNodeTuple(actualTuples.get(0),
+ "sharding_algorithms/core_standard_fixture", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("core_standard_fixture"));
+ assertRuleNodeTuple(actualTuples.get(1),
+ "sharding_algorithms/core_complex_fixture", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("core_complex_fixture"));
+ assertRuleNodeTuple(actualTuples.get(2), "sharding_algorithms/core_hint_fixture", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("core_hint_fixture"));
+ assertRuleNodeTuple(actualTuples.get(3), "sharding_algorithms/database_inline", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("database_inline"));
+ assertRuleNodeTuple(actualTuples.get(4), "sharding_algorithms/table_inline", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("table_inline"));
+ assertRuleNodeTuple(actualTuples.get(5), "key_generators/snowflake", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getKeyGenerators().get("snowflake"));
+ assertRuleNodeTuple(actualTuples.get(6),
+ "auditors/sharding_key_required_auditor", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getAuditors().get("sharding_key_required_auditor"));
+ assertRuleNodeTuple(actualTuples.get(7), "default_database_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultDatabaseStrategy());
+ assertRuleNodeTuple(actualTuples.get(8), "default_table_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultTableStrategy());
+ assertRuleNodeTuple(actualTuples.get(9), "default_key_generate_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultKeyGenerateStrategy());
+ assertRuleNodeTuple(actualTuples.get(10), "default_audit_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultAuditStrategy());
+ assertRuleNodeTuple(actualTuples.get(11), "tables/t_user", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_user"));
+ assertRuleNodeTuple(actualTuples.get(12), "tables/t_stock", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_stock"));
+ assertRuleNodeTuple(actualTuples.get(13), "tables/t_order", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_order"));
+ assertRuleNodeTuple(actualTuples.get(14), "tables/t_order_item", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_order_item"));
+ assertRuleNodeTuple(actualTuples.get(15), "binding_tables" + actualTuples.get(15).getPath().substring(actualTuples.get(15).getPath().lastIndexOf("/")),
+ new ArrayList<>(((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getBindingTables()).get(0));
+ assertRuleNodeTuple(actualTuples.get(16), "binding_tables/foo", new ArrayList<>(((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getBindingTables()).get(1));
+ assertRuleNodeTuple(actualTuples.get(17), "default_sharding_column", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultShardingColumn());
+ assertRuleNodeTuple(actualTuples.get(18), "sharding_cache", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingCache());
+ }
+}
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/ShardingConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/ShardingConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
deleted file mode 100644
index 249a53fbc1c..00000000000
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/ShardingConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.shardingsphere.sharding.yaml;
-
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
-import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
-class ShardingConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
-
- ShardingConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
- super("yaml/sharding-rule-for-tuple.yaml");
- }
-
- @Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
- assertThat(actualTuples.size(), is(19));
- assertRepositoryTuple(actualTuples.get(0),
- "sharding_algorithms/core_standard_fixture", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("core_standard_fixture"));
- assertRepositoryTuple(actualTuples.get(1),
- "sharding_algorithms/core_complex_fixture", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("core_complex_fixture"));
- assertRepositoryTuple(actualTuples.get(2), "sharding_algorithms/core_hint_fixture", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("core_hint_fixture"));
- assertRepositoryTuple(actualTuples.get(3), "sharding_algorithms/database_inline", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("database_inline"));
- assertRepositoryTuple(actualTuples.get(4), "sharding_algorithms/table_inline", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingAlgorithms().get("table_inline"));
- assertRepositoryTuple(actualTuples.get(5), "key_generators/snowflake", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getKeyGenerators().get("snowflake"));
- assertRepositoryTuple(actualTuples.get(6),
- "auditors/sharding_key_required_auditor", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getAuditors().get("sharding_key_required_auditor"));
- assertRepositoryTuple(actualTuples.get(7), "default_database_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultDatabaseStrategy());
- assertRepositoryTuple(actualTuples.get(8), "default_table_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultTableStrategy());
- assertRepositoryTuple(actualTuples.get(9), "default_key_generate_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultKeyGenerateStrategy());
- assertRepositoryTuple(actualTuples.get(10), "default_audit_strategy", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultAuditStrategy());
- assertRepositoryTuple(actualTuples.get(11), "tables/t_user", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_user"));
- assertRepositoryTuple(actualTuples.get(12), "tables/t_stock", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_stock"));
- assertRepositoryTuple(actualTuples.get(13), "tables/t_order", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_order"));
- assertRepositoryTuple(actualTuples.get(14), "tables/t_order_item", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getTables().get("t_order_item"));
- assertRepositoryTuple(actualTuples.get(15), "binding_tables" + actualTuples.get(15).getPath().substring(actualTuples.get(15).getPath().lastIndexOf("/")),
- new ArrayList<>(((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getBindingTables()).get(0));
- assertRepositoryTuple(actualTuples.get(16), "binding_tables/foo", new ArrayList<>(((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getBindingTables()).get(1));
- assertRepositoryTuple(actualTuples.get(17), "default_sharding_column", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getDefaultShardingColumn());
- assertRepositoryTuple(actualTuples.get(18), "sharding_cache", ((YamlShardingRuleConfiguration) expectedYamlRuleConfig).getShardingCache());
- }
-}
diff --git a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/DropDatabaseRuleOperator.java b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/DropDatabaseRuleOperator.java
index 17a35c6d864..d03f052b3e8 100644
--- a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/DropDatabaseRuleOperator.java
+++ b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/DropDatabaseRuleOperator.java
@@ -32,7 +32,7 @@ import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfigurati
import org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapperEngine;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.mode.persist.service.MetaDataManagerPersistService;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import java.sql.SQLException;
import java.util.Objects;
@@ -67,7 +67,7 @@ public final class DropDatabaseRuleOperator implements DatabaseRuleOperator {
if (null != toBeAlteredRuleConfig
&& TypedSPILoader.getService(DatabaseRuleConfigurationEmptyChecker.class, toBeAlteredRuleConfig.getClass()).isEmpty((DatabaseRuleConfiguration) toBeAlteredRuleConfig)) {
YamlRuleConfiguration yamlRuleConfig = new YamlRuleConfigurationSwapperEngine().swapToYamlRuleConfiguration(currentRuleConfig);
- metaDataManagerPersistService.removeRuleConfiguration(database, Objects.requireNonNull(yamlRuleConfig.getClass().getAnnotation(RuleRepositoryTupleEntity.class)).value());
+ metaDataManagerPersistService.removeRuleConfiguration(database, Objects.requireNonNull(yamlRuleConfig.getClass().getAnnotation(RuleNodeTupleEntity.class)).value());
} else {
metaDataManagerPersistService.alterRuleConfiguration(database, toBeAlteredRuleConfig);
}
diff --git a/kernel/authority/core/src/main/java/org/apache/shardingsphere/authority/yaml/config/YamlAuthorityRuleConfiguration.java b/kernel/authority/core/src/main/java/org/apache/shardingsphere/authority/yaml/config/YamlAuthorityRuleConfiguration.java
index df4dbcbecd3..e99837a63cc 100644
--- a/kernel/authority/core/src/main/java/org/apache/shardingsphere/authority/yaml/config/YamlAuthorityRuleConfiguration.java
+++ b/kernel/authority/core/src/main/java/org/apache/shardingsphere/authority/yaml/config/YamlAuthorityRuleConfiguration.java
@@ -22,7 +22,7 @@ import lombok.Setter;
import org.apache.shardingsphere.authority.config.AuthorityRuleConfiguration;
import org.apache.shardingsphere.infra.algorithm.core.yaml.YamlAlgorithmConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import java.util.Collection;
import java.util.LinkedHashMap;
@@ -32,7 +32,7 @@ import java.util.Map;
/**
* Authority rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity(value = "authority", leaf = true)
+@RuleNodeTupleEntity(value = "authority", leaf = true)
@Getter
@Setter
public final class YamlAuthorityRuleConfiguration implements YamlGlobalRuleConfiguration {
diff --git a/kernel/authority/core/src/test/java/org/apache/shardingsphere/authority/yaml/AuthorityRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/kernel/authority/core/src/test/java/org/apache/shardingsphere/authority/yaml/AuthorityRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 67%
rename from kernel/authority/core/src/test/java/org/apache/shardingsphere/authority/yaml/AuthorityRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to kernel/authority/core/src/test/java/org/apache/shardingsphere/authority/yaml/AuthorityRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index 86eab06c0f2..f5c62842768 100644
--- a/kernel/authority/core/src/test/java/org/apache/shardingsphere/authority/yaml/AuthorityRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/kernel/authority/core/src/test/java/org/apache/shardingsphere/authority/yaml/AuthorityRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,24 +17,24 @@
package org.apache.shardingsphere.authority.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class AuthorityRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class AuthorityRuleConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- AuthorityRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ AuthorityRuleConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/authority-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(1));
- assertRepositoryTuple(actualTuples.get(0), "authority", expectedYamlRuleConfig);
+ assertRuleNodeTuple(actualTuples.get(0), "authority", expectedYamlRuleConfig);
}
}
diff --git a/kernel/global-clock/core/src/main/java/org/apache/shardingsphere/globalclock/yaml/config/YamlGlobalClockRuleConfiguration.java b/kernel/global-clock/core/src/main/java/org/apache/shardingsphere/globalclock/yaml/config/YamlGlobalClockRuleConfiguration.java
index c0d58bcbd8b..134d2ee18fb 100644
--- a/kernel/global-clock/core/src/main/java/org/apache/shardingsphere/globalclock/yaml/config/YamlGlobalClockRuleConfiguration.java
+++ b/kernel/global-clock/core/src/main/java/org/apache/shardingsphere/globalclock/yaml/config/YamlGlobalClockRuleConfiguration.java
@@ -21,14 +21,14 @@ import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.globalclock.config.GlobalClockRuleConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import java.util.Properties;
/**
* Global clock rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity(value = "global_clock", leaf = true)
+@RuleNodeTupleEntity(value = "global_clock", leaf = true)
@Getter
@Setter
public final class YamlGlobalClockRuleConfiguration implements YamlGlobalRuleConfiguration {
diff --git a/kernel/global-clock/core/src/test/java/org/apache/shardingsphere/globalclock/yaml/GlobalClockRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/kernel/global-clock/core/src/test/java/org/apache/shardingsphere/globalclock/yaml/GlobalClockRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 66%
rename from kernel/global-clock/core/src/test/java/org/apache/shardingsphere/globalclock/yaml/GlobalClockRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to kernel/global-clock/core/src/test/java/org/apache/shardingsphere/globalclock/yaml/GlobalClockRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index 6c9b2d2ec56..80a4e38a479 100644
--- a/kernel/global-clock/core/src/test/java/org/apache/shardingsphere/globalclock/yaml/GlobalClockRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/kernel/global-clock/core/src/test/java/org/apache/shardingsphere/globalclock/yaml/GlobalClockRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,24 +17,24 @@
package org.apache.shardingsphere.globalclock.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class GlobalClockRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class GlobalClockRuleConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- GlobalClockRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ GlobalClockRuleConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/global-clock-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(1));
- assertRepositoryTuple(actualTuples.get(0), "global_clock", expectedYamlRuleConfig);
+ assertRuleNodeTuple(actualTuples.get(0), "global_clock", expectedYamlRuleConfig);
}
}
diff --git a/kernel/logging/core/src/main/java/org/apache/shardingsphere/logging/yaml/config/YamlLoggingRuleConfiguration.java b/kernel/logging/core/src/main/java/org/apache/shardingsphere/logging/yaml/config/YamlLoggingRuleConfiguration.java
index 0bc7e702852..b9a06e591ed 100644
--- a/kernel/logging/core/src/main/java/org/apache/shardingsphere/logging/yaml/config/YamlLoggingRuleConfiguration.java
+++ b/kernel/logging/core/src/main/java/org/apache/shardingsphere/logging/yaml/config/YamlLoggingRuleConfiguration.java
@@ -21,7 +21,7 @@ import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
import org.apache.shardingsphere.logging.config.LoggingRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import java.util.Collection;
import java.util.LinkedList;
@@ -29,7 +29,7 @@ import java.util.LinkedList;
/**
* Logging rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity(value = "logging", leaf = true)
+@RuleNodeTupleEntity(value = "logging", leaf = true)
@Getter
@Setter
public final class YamlLoggingRuleConfiguration implements YamlGlobalRuleConfiguration {
diff --git a/kernel/logging/core/src/test/java/org/apache/shardingsphere/logging/yaml/LoggingRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/kernel/logging/core/src/test/java/org/apache/shardingsphere/logging/yaml/LoggingRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 67%
rename from kernel/logging/core/src/test/java/org/apache/shardingsphere/logging/yaml/LoggingRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to kernel/logging/core/src/test/java/org/apache/shardingsphere/logging/yaml/LoggingRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index 853866581a8..acb1bbe5b44 100644
--- a/kernel/logging/core/src/test/java/org/apache/shardingsphere/logging/yaml/LoggingRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/kernel/logging/core/src/test/java/org/apache/shardingsphere/logging/yaml/LoggingRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,24 +17,24 @@
package org.apache.shardingsphere.logging.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class LoggingRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class LoggingRuleConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- LoggingRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ LoggingRuleConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/logging-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(1));
- assertRepositoryTuple(actualTuples.get(0), "logging", expectedYamlRuleConfig);
+ assertRuleNodeTuple(actualTuples.get(0), "logging", expectedYamlRuleConfig);
}
}
diff --git a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/yaml/config/YamlSingleRuleConfiguration.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/yaml/config/YamlSingleRuleConfiguration.java
index 31960d1e39d..84c013be2f5 100644
--- a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/yaml/config/YamlSingleRuleConfiguration.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/yaml/config/YamlSingleRuleConfiguration.java
@@ -20,8 +20,8 @@ package org.apache.shardingsphere.single.yaml.config;
import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
import org.apache.shardingsphere.single.config.SingleRuleConfiguration;
import java.util.Collection;
@@ -30,15 +30,15 @@ import java.util.LinkedList;
/**
* Single rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity("single")
+@RuleNodeTupleEntity("single")
@Getter
@Setter
public final class YamlSingleRuleConfiguration implements YamlRuleConfiguration {
- @RuleRepositoryTupleField(type = RuleRepositoryTupleField.Type.TABLE)
+ @RuleNodeTupleField(type = RuleNodeTupleField.Type.TABLE)
private Collection<String> tables = new LinkedList<>();
- @RuleRepositoryTupleField(type = RuleRepositoryTupleField.Type.OTHER)
+ @RuleNodeTupleField(type = RuleNodeTupleField.Type.OTHER)
private String defaultDataSource;
@Override
diff --git a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/yaml/SingleRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/yaml/SingleRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 62%
rename from kernel/single/core/src/test/java/org/apache/shardingsphere/single/yaml/SingleRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/yaml/SingleRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index f9ffb5c9d87..9270078789d 100644
--- a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/yaml/SingleRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/yaml/SingleRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,26 +17,26 @@
package org.apache.shardingsphere.single.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
import org.apache.shardingsphere.single.yaml.config.YamlSingleRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class SingleRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class SingleRuleConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- SingleRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ SingleRuleConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/single-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(2));
- assertRepositoryTuple(actualTuples.get(0), "tables", ((YamlSingleRuleConfiguration) expectedYamlRuleConfig).getTables());
- assertRepositoryTuple(actualTuples.get(1), "default_data_source", ((YamlSingleRuleConfiguration) expectedYamlRuleConfig).getDefaultDataSource());
+ assertRuleNodeTuple(actualTuples.get(0), "tables", ((YamlSingleRuleConfiguration) expectedYamlRuleConfig).getTables());
+ assertRuleNodeTuple(actualTuples.get(1), "default_data_source", ((YamlSingleRuleConfiguration) expectedYamlRuleConfig).getDefaultDataSource());
}
}
diff --git a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/yaml/config/YamlSQLFederationRuleConfiguration.java b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/yaml/config/YamlSQLFederationRuleConfiguration.java
index 820d18cd338..1106a694222 100644
--- a/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/yaml/config/YamlSQLFederationRuleConfiguration.java
+++ b/kernel/sql-federation/core/src/main/java/org/apache/shardingsphere/sqlfederation/yaml/config/YamlSQLFederationRuleConfiguration.java
@@ -20,13 +20,13 @@ package org.apache.shardingsphere.sqlfederation.yaml.config;
import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import org.apache.shardingsphere.sqlfederation.config.SQLFederationRuleConfiguration;
/**
* SQL federation rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity(value = "sql_federation", leaf = true)
+@RuleNodeTupleEntity(value = "sql_federation", leaf = true)
@Getter
@Setter
public final class YamlSQLFederationRuleConfiguration implements YamlGlobalRuleConfiguration {
diff --git a/kernel/sql-federation/core/src/test/java/org/apache/shardingsphere/sqlfederation/yaml/SQLFederationRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/kernel/sql-federation/core/src/test/java/org/apache/shardingsphere/sqlfederation/yaml/SQLFederationRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 66%
rename from kernel/sql-federation/core/src/test/java/org/apache/shardingsphere/sqlfederation/yaml/SQLFederationRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to kernel/sql-federation/core/src/test/java/org/apache/shardingsphere/sqlfederation/yaml/SQLFederationRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index bd3c326bedc..a2b1787b3c4 100644
--- a/kernel/sql-federation/core/src/test/java/org/apache/shardingsphere/sqlfederation/yaml/SQLFederationRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/kernel/sql-federation/core/src/test/java/org/apache/shardingsphere/sqlfederation/yaml/SQLFederationRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,24 +17,24 @@
package org.apache.shardingsphere.sqlfederation.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class SQLFederationRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class SQLFederationRuleConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- SQLFederationRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ SQLFederationRuleConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/sql-federation-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(1));
- assertRepositoryTuple(actualTuples.get(0), "sql_federation", expectedYamlRuleConfig);
+ assertRuleNodeTuple(actualTuples.get(0), "sql_federation", expectedYamlRuleConfig);
}
}
diff --git a/kernel/sql-parser/core/src/main/java/org/apache/shardingsphere/parser/yaml/config/YamlSQLParserRuleConfiguration.java b/kernel/sql-parser/core/src/main/java/org/apache/shardingsphere/parser/yaml/config/YamlSQLParserRuleConfiguration.java
index df055659538..098a870c1da 100644
--- a/kernel/sql-parser/core/src/main/java/org/apache/shardingsphere/parser/yaml/config/YamlSQLParserRuleConfiguration.java
+++ b/kernel/sql-parser/core/src/main/java/org/apache/shardingsphere/parser/yaml/config/YamlSQLParserRuleConfiguration.java
@@ -20,13 +20,13 @@ package org.apache.shardingsphere.parser.yaml.config;
import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import org.apache.shardingsphere.parser.config.SQLParserRuleConfiguration;
/**
* SQL parser configuration for YAML.
*/
-@RuleRepositoryTupleEntity(value = "sql_parser", leaf = true)
+@RuleNodeTupleEntity(value = "sql_parser", leaf = true)
@Getter
@Setter
public final class YamlSQLParserRuleConfiguration implements YamlGlobalRuleConfiguration {
diff --git a/kernel/sql-parser/core/src/test/java/org/apache/shardingsphere/parser/yaml/SQLParserRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/kernel/sql-parser/core/src/test/java/org/apache/shardingsphere/parser/yaml/SQLParserRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 66%
rename from kernel/sql-parser/core/src/test/java/org/apache/shardingsphere/parser/yaml/SQLParserRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to kernel/sql-parser/core/src/test/java/org/apache/shardingsphere/parser/yaml/SQLParserRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index 2151ef85b03..bc494e07031 100644
--- a/kernel/sql-parser/core/src/test/java/org/apache/shardingsphere/parser/yaml/SQLParserRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/kernel/sql-parser/core/src/test/java/org/apache/shardingsphere/parser/yaml/SQLParserRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,24 +17,24 @@
package org.apache.shardingsphere.parser.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class SQLParserRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class SQLParserRuleConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- SQLParserRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ SQLParserRuleConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/sql-parser-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(1));
- assertRepositoryTuple(actualTuples.get(0), "sql_parser", expectedYamlRuleConfig);
+ assertRuleNodeTuple(actualTuples.get(0), "sql_parser", expectedYamlRuleConfig);
}
}
diff --git a/kernel/sql-translator/core/src/main/java/org/apache/shardingsphere/sqltranslator/yaml/config/YamlSQLTranslatorRuleConfiguration.java b/kernel/sql-translator/core/src/main/java/org/apache/shardingsphere/sqltranslator/yaml/config/YamlSQLTranslatorRuleConfiguration.java
index 49266c84ffc..43d28d4effe 100644
--- a/kernel/sql-translator/core/src/main/java/org/apache/shardingsphere/sqltranslator/yaml/config/YamlSQLTranslatorRuleConfiguration.java
+++ b/kernel/sql-translator/core/src/main/java/org/apache/shardingsphere/sqltranslator/yaml/config/YamlSQLTranslatorRuleConfiguration.java
@@ -20,7 +20,7 @@ package org.apache.shardingsphere.sqltranslator.yaml.config;
import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import org.apache.shardingsphere.sqltranslator.config.SQLTranslatorRuleConfiguration;
import java.util.Properties;
@@ -28,7 +28,7 @@ import java.util.Properties;
/**
* SQL translator configuration for YAML.
*/
-@RuleRepositoryTupleEntity(value = "sql_translator", leaf = true)
+@RuleNodeTupleEntity(value = "sql_translator", leaf = true)
@Getter
@Setter
public final class YamlSQLTranslatorRuleConfiguration implements YamlGlobalRuleConfiguration {
diff --git a/kernel/sql-translator/core/src/test/java/org/apache/shardingsphere/sqltranslator/yaml/SQLTranslatorRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/kernel/sql-translator/core/src/test/java/org/apache/shardingsphere/sqltranslator/yaml/SQLTranslatorRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 66%
rename from kernel/sql-translator/core/src/test/java/org/apache/shardingsphere/sqltranslator/yaml/SQLTranslatorRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to kernel/sql-translator/core/src/test/java/org/apache/shardingsphere/sqltranslator/yaml/SQLTranslatorRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index e01a6d29888..bb9c4270355 100644
--- a/kernel/sql-translator/core/src/test/java/org/apache/shardingsphere/sqltranslator/yaml/SQLTranslatorRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/kernel/sql-translator/core/src/test/java/org/apache/shardingsphere/sqltranslator/yaml/SQLTranslatorRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,24 +17,24 @@
package org.apache.shardingsphere.sqltranslator.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class SQLTranslatorRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class SQLTranslatorRuleConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- SQLTranslatorRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ SQLTranslatorRuleConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/sql-translator-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(1));
- assertRepositoryTuple(actualTuples.get(0), "sql_translator", expectedYamlRuleConfig);
+ assertRuleNodeTuple(actualTuples.get(0), "sql_translator", expectedYamlRuleConfig);
}
}
diff --git a/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/yaml/config/YamlTransactionRuleConfiguration.java b/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/yaml/config/YamlTransactionRuleConfiguration.java
index ba2495d3641..4dce58e8076 100644
--- a/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/yaml/config/YamlTransactionRuleConfiguration.java
+++ b/kernel/transaction/core/src/main/java/org/apache/shardingsphere/transaction/yaml/config/YamlTransactionRuleConfiguration.java
@@ -20,7 +20,7 @@ package org.apache.shardingsphere.transaction.yaml.config;
import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import org.apache.shardingsphere.transaction.config.TransactionRuleConfiguration;
import java.util.Properties;
@@ -28,7 +28,7 @@ import java.util.Properties;
/**
* Transaction rule configuration for YAML.
*/
-@RuleRepositoryTupleEntity(value = "transaction", leaf = true)
+@RuleNodeTupleEntity(value = "transaction", leaf = true)
@Getter
@Setter
public final class YamlTransactionRuleConfiguration implements YamlGlobalRuleConfiguration {
diff --git a/kernel/transaction/core/src/test/java/org/apache/shardingsphere/transaction/yaml/TransactionRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java b/kernel/transaction/core/src/test/java/org/apache/shardingsphere/transaction/yaml/TransactionRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
similarity index 66%
rename from kernel/transaction/core/src/test/java/org/apache/shardingsphere/transaction/yaml/TransactionRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
rename to kernel/transaction/core/src/test/java/org/apache/shardingsphere/transaction/yaml/TransactionRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
index 469d6d595ed..22e632b2880 100644
--- a/kernel/transaction/core/src/test/java/org/apache/shardingsphere/transaction/yaml/TransactionRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/kernel/transaction/core/src/test/java/org/apache/shardingsphere/transaction/yaml/TransactionRuleConfigurationYamlRuleNodeTupleSwapperEngineIT.java
@@ -17,24 +17,24 @@
package org.apache.shardingsphere.transaction.yaml;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.test.it.yaml.YamlRuleRepositoryTupleSwapperEngineIT;
+import org.apache.shardingsphere.test.it.yaml.YamlRuleNodeTupleSwapperEngineIT;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-class TransactionRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT extends YamlRuleRepositoryTupleSwapperEngineIT {
+class TransactionRuleConfigurationYamlRuleNodeTupleSwapperEngineIT extends YamlRuleNodeTupleSwapperEngineIT {
- TransactionRuleConfigurationYamlRuleRepositoryTupleSwapperEngineIT() {
+ TransactionRuleConfigurationYamlRuleNodeTupleSwapperEngineIT() {
super("yaml/transaction-rule.yaml");
}
@Override
- protected void assertRepositoryTuples(final List<RuleRepositoryTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
+ protected void assertRuleNodeTuples(final List<RuleNodeTuple> actualTuples, final YamlRuleConfiguration expectedYamlRuleConfig) {
assertThat(actualTuples.size(), is(1));
- assertRepositoryTuple(actualTuples.get(0), "transaction", expectedYamlRuleConfig);
+ assertRuleNodeTuple(actualTuples.get(0), "transaction", expectedYamlRuleConfig);
}
}
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/GlobalConfigurationManager.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/GlobalConfigurationManager.java
index 095d2a4d225..19e402c4321 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/GlobalConfigurationManager.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/rule/GlobalConfigurationManager.java
@@ -29,7 +29,7 @@ import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfigurati
import org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapperEngine;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistFacade;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import org.apache.shardingsphere.transaction.rule.TransactionRule;
import java.util.Collection;
@@ -71,7 +71,7 @@ public final class GlobalConfigurationManager {
@SneakyThrows(Exception.class)
private void closeStaleTransactionRule(final RuleConfiguration ruleConfig) {
YamlRuleConfiguration yamlRuleConfig = new YamlRuleConfigurationSwapperEngine().swapToYamlRuleConfiguration(ruleConfig);
- if (!"transaction".equals(Objects.requireNonNull(yamlRuleConfig.getClass().getAnnotation(RuleRepositoryTupleEntity.class)).value())) {
+ if (!"transaction".equals(Objects.requireNonNull(yamlRuleConfig.getClass().getAnnotation(RuleNodeTupleEntity.class)).value())) {
return;
}
metaDataContexts.getMetaData().getGlobalRuleMetaData().findSingleRule(TransactionRule.class).ifPresent(TransactionRule::close);
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/database/DatabaseRulePersistService.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/database/DatabaseRulePersistService.java
index a2422ea852b..26659b72e42 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/database/DatabaseRulePersistService.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/database/DatabaseRulePersistService.java
@@ -28,8 +28,8 @@ import org.apache.shardingsphere.mode.node.path.type.metadata.rule.DatabaseRuleN
import org.apache.shardingsphere.mode.node.path.type.version.VersionNodePath;
import org.apache.shardingsphere.mode.node.rule.node.DatabaseRuleNode;
import org.apache.shardingsphere.mode.node.rule.node.DatabaseRuleNodeGenerator;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
-import org.apache.shardingsphere.mode.node.rule.tuple.YamlRuleRepositoryTupleSwapperEngine;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.YamlRuleNodeTupleSwapperEngine;
import org.apache.shardingsphere.mode.spi.repository.PersistRepository;
import java.util.Collection;
@@ -50,13 +50,13 @@ public final class DatabaseRulePersistService {
private final YamlRuleConfigurationSwapperEngine yamlSwapperEngine;
- private final YamlRuleRepositoryTupleSwapperEngine tupleSwapperEngine;
+ private final YamlRuleNodeTupleSwapperEngine tupleSwapperEngine;
public DatabaseRulePersistService(final PersistRepository repository) {
this.repository = repository;
versionPersistService = new VersionPersistService(repository);
yamlSwapperEngine = new YamlRuleConfigurationSwapperEngine();
- tupleSwapperEngine = new YamlRuleRepositoryTupleSwapperEngine();
+ tupleSwapperEngine = new YamlRuleNodeTupleSwapperEngine();
}
/**
@@ -75,12 +75,12 @@ public final class DatabaseRulePersistService {
tupleSwapperEngine.swapToYamlDatabaseRuleConfiguration(databaseName, ruleType, load(databaseName, DatabaseRuleNodeGenerator.generate(ruleType))));
}
- private Collection<RuleRepositoryTuple> load(final String databaseName, final DatabaseRuleNode databaseRuleNode) {
+ private Collection<RuleNodeTuple> load(final String databaseName, final DatabaseRuleNode databaseRuleNode) {
Collection<DatabaseRuleNodePath> nodePaths = new LinkedList<>();
nodePaths.addAll(getUniqueItemNodePaths(databaseName, databaseRuleNode.getRuleType(), databaseRuleNode.getUniqueItems()));
nodePaths.addAll(getNamedItemNodePaths(databaseName, databaseRuleNode.getRuleType(), databaseRuleNode.getNamedItems()));
return nodePaths.stream()
- .map(each -> new RuleRepositoryTuple(each, versionPersistService.loadContent(new VersionNodePath(each)))).filter(Objects::nonNull)
+ .map(each -> new RuleNodeTuple(each, versionPersistService.loadContent(new VersionNodePath(each)))).filter(Objects::nonNull)
.collect(Collectors.toList());
}
@@ -112,7 +112,7 @@ public final class DatabaseRulePersistService {
return result;
}
- private Collection<MetaDataVersion> persistTuples(final Collection<RuleRepositoryTuple> tuples) {
+ private Collection<MetaDataVersion> persistTuples(final Collection<RuleNodeTuple> tuples) {
return tuples.stream().map(each -> new MetaDataVersion(
each.getPath(), Math.max(MetaDataVersion.INIT_VERSION, versionPersistService.persist(new VersionNodePath(each.getNodePath()), each.getContent()) - 1))).collect(Collectors.toList());
}
@@ -137,16 +137,16 @@ public final class DatabaseRulePersistService {
public Collection<MetaDataVersion> delete(final String databaseName, final Collection<RuleConfiguration> configs) {
Collection<MetaDataVersion> result = new LinkedList<>();
for (YamlRuleConfiguration each : yamlSwapperEngine.swapToYamlRuleConfigurations(configs)) {
- List<RuleRepositoryTuple> tuples = new LinkedList<>(tupleSwapperEngine.swapToTuples(databaseName, each));
+ List<RuleNodeTuple> tuples = new LinkedList<>(tupleSwapperEngine.swapToTuples(databaseName, each));
Collections.reverse(tuples);
result.addAll(deleteTuples(tuples));
}
return result;
}
- private Collection<MetaDataVersion> deleteTuples(final Collection<RuleRepositoryTuple> tuples) {
+ private Collection<MetaDataVersion> deleteTuples(final Collection<RuleNodeTuple> tuples) {
Collection<MetaDataVersion> result = new LinkedList<>();
- for (RuleRepositoryTuple each : tuples) {
+ for (RuleNodeTuple each : tuples) {
String path = each.getPath();
repository.delete(path);
result.add(new MetaDataVersion(path));
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/global/GlobalRulePersistService.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/global/GlobalRulePersistService.java
index b491eba9cda..3b0ab60fa10 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/global/GlobalRulePersistService.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/config/global/GlobalRulePersistService.java
@@ -25,8 +25,8 @@ import org.apache.shardingsphere.mode.metadata.persist.version.VersionPersistSer
import org.apache.shardingsphere.mode.node.path.engine.generator.NodePathGenerator;
import org.apache.shardingsphere.mode.node.path.type.global.GlobalRuleNodePath;
import org.apache.shardingsphere.mode.node.path.type.version.VersionNodePath;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
-import org.apache.shardingsphere.mode.node.rule.tuple.YamlRuleRepositoryTupleSwapperEngine;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.YamlRuleNodeTupleSwapperEngine;
import org.apache.shardingsphere.mode.spi.repository.PersistRepository;
import java.util.Collection;
@@ -43,13 +43,13 @@ public final class GlobalRulePersistService {
private final YamlRuleConfigurationSwapperEngine yamlSwapperEngine;
- private final YamlRuleRepositoryTupleSwapperEngine tupleSwapperEngine;
+ private final YamlRuleNodeTupleSwapperEngine tupleSwapperEngine;
public GlobalRulePersistService(final PersistRepository repository, final VersionPersistService versionPersistService) {
this.repository = repository;
this.versionPersistService = versionPersistService;
yamlSwapperEngine = new YamlRuleConfigurationSwapperEngine();
- tupleSwapperEngine = new YamlRuleRepositoryTupleSwapperEngine();
+ tupleSwapperEngine = new YamlRuleNodeTupleSwapperEngine();
}
/**
@@ -83,7 +83,7 @@ public final class GlobalRulePersistService {
}
}
- private void persistTuple(final RuleRepositoryTuple tuple) {
+ private void persistTuple(final RuleNodeTuple tuple) {
versionPersistService.persist(new VersionNodePath(tuple.getNodePath()), tuple.getContent());
}
}
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/node/DatabaseRuleNodeGenerator.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/node/DatabaseRuleNodeGenerator.java
index 9c205b1f7c8..1067d865153 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/node/DatabaseRuleNodeGenerator.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/node/DatabaseRuleNodeGenerator.java
@@ -24,9 +24,9 @@ import org.apache.shardingsphere.infra.spi.ShardingSphereServiceLoader;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
import org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper;
import org.apache.shardingsphere.mode.node.rule.tuple.YamlRuleConfigurationFieldUtil;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleKeyListNameGenerator;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleKeyListNameGenerator;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
@@ -49,16 +49,16 @@ public final class DatabaseRuleNodeGenerator {
* @return generated database rule node
*/
public static DatabaseRuleNode generate(final Class<? extends YamlRuleConfiguration> yamlRuleConfigurationClass) {
- RuleRepositoryTupleEntity tupleEntity = yamlRuleConfigurationClass.getAnnotation(RuleRepositoryTupleEntity.class);
- Preconditions.checkNotNull(tupleEntity, "Can not find @RuleRepositoryTupleEntity on class: ", yamlRuleConfigurationClass.getName());
+ RuleNodeTupleEntity tupleEntity = yamlRuleConfigurationClass.getAnnotation(RuleNodeTupleEntity.class);
+ Preconditions.checkNotNull(tupleEntity, "Can not find @RuleNodeTupleEntity on class: ", yamlRuleConfigurationClass.getName());
Collection<String> namedItems = new LinkedList<>();
Collection<String> uniqueItems = new LinkedList<>();
for (Field each : YamlRuleConfigurationFieldUtil.getFields(yamlRuleConfigurationClass)) {
- if (null == each.getAnnotation(RuleRepositoryTupleField.class)) {
+ if (null == each.getAnnotation(RuleNodeTupleField.class)) {
continue;
}
String tupleName = YamlRuleConfigurationFieldUtil.getTupleItemName(each);
- if (each.getType().equals(Map.class) || each.getType().equals(Collection.class) && null != each.getAnnotation(RuleRepositoryTupleKeyListNameGenerator.class)) {
+ if (each.getType().equals(Map.class) || each.getType().equals(Collection.class) && null != each.getAnnotation(RuleNodeTupleKeyListNameGenerator.class)) {
namedItems.add(tupleName);
} else {
uniqueItems.add(tupleName);
@@ -83,7 +83,7 @@ public final class DatabaseRuleNodeGenerator {
if (!yamlRuleConfigurationClass.isPresent()) {
continue;
}
- RuleRepositoryTupleEntity entity = yamlRuleConfigurationClass.get().getAnnotation(RuleRepositoryTupleEntity.class);
+ RuleNodeTupleEntity entity = yamlRuleConfigurationClass.get().getAnnotation(RuleNodeTupleEntity.class);
if (null != entity && entity.value().equals(ruleType)) {
return yamlRuleConfigurationClass;
}
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/RuleRepositoryTuple.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/RuleNodeTuple.java
similarity index 95%
rename from mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/RuleRepositoryTuple.java
rename to mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/RuleNodeTuple.java
index 62cd26ebaeb..e4106076d57 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/RuleRepositoryTuple.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/RuleNodeTuple.java
@@ -23,11 +23,11 @@ import org.apache.shardingsphere.mode.node.path.NodePath;
import org.apache.shardingsphere.mode.node.path.engine.generator.NodePathGenerator;
/**
- * Rule repository tuple.
+ * Rule node tuple.
*/
@RequiredArgsConstructor
@Getter
-public final class RuleRepositoryTuple {
+public final class RuleNodeTuple {
private final NodePath nodePath;
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleConfigurationFieldUtil.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleConfigurationFieldUtil.java
index 26164d853e9..3d06b95bb15 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleConfigurationFieldUtil.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleConfigurationFieldUtil.java
@@ -21,7 +21,7 @@ import com.google.common.base.CaseFormat;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
import java.lang.reflect.Field;
import java.util.Arrays;
@@ -43,8 +43,8 @@ public final class YamlRuleConfigurationFieldUtil {
*/
public static Collection<Field> getFields(final Class<? extends YamlRuleConfiguration> yamlRuleConfigurationClass) {
return Arrays.stream(yamlRuleConfigurationClass.getDeclaredFields())
- .filter(each -> null != each.getAnnotation(RuleRepositoryTupleField.class))
- .sorted(Comparator.comparingInt(o -> o.getAnnotation(RuleRepositoryTupleField.class).type().ordinal())).collect(Collectors.toList());
+ .filter(each -> null != each.getAnnotation(RuleNodeTupleField.class))
+ .sorted(Comparator.comparingInt(o -> o.getAnnotation(RuleNodeTupleField.class).type().ordinal())).collect(Collectors.toList());
}
/**
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngine.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleNodeTupleSwapperEngine.java
similarity index 77%
rename from mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngine.java
rename to mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleNodeTupleSwapperEngine.java
index 77a6e87db33..45bba6df9b4 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngine.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleNodeTupleSwapperEngine.java
@@ -33,8 +33,8 @@ import org.apache.shardingsphere.mode.node.path.type.metadata.rule.DatabaseRuleI
import org.apache.shardingsphere.mode.node.path.type.metadata.rule.DatabaseRuleNodePath;
import org.apache.shardingsphere.mode.node.rule.node.DatabaseRuleNode;
import org.apache.shardingsphere.mode.node.rule.node.DatabaseRuleNodeGenerator;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleKeyListNameGenerator;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleKeyListNameGenerator;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
@@ -48,36 +48,36 @@ import java.util.Map.Entry;
import java.util.Optional;
/**
- * YAML rule repository tuple swapper engine.
+ * YAML rule node tuple swapper engine.
*/
-public final class YamlRuleRepositoryTupleSwapperEngine {
+public final class YamlRuleNodeTupleSwapperEngine {
/**
- * Swap to rule repository tuple.
+ * Swap to rule node tuple.
*
* @param yamlGlobalRuleConfig global YAML rule configuration to be swapped
- * @return rule repository tuple
+ * @return rule node tuple
*/
- public RuleRepositoryTuple swapToTuple(final YamlGlobalRuleConfiguration yamlGlobalRuleConfig) {
- RuleRepositoryTupleEntity entity = yamlGlobalRuleConfig.getClass().getAnnotation(RuleRepositoryTupleEntity.class);
+ public RuleNodeTuple swapToTuple(final YamlGlobalRuleConfiguration yamlGlobalRuleConfig) {
+ RuleNodeTupleEntity entity = yamlGlobalRuleConfig.getClass().getAnnotation(RuleNodeTupleEntity.class);
Preconditions.checkNotNull(entity);
Preconditions.checkArgument(entity.leaf());
- return new RuleRepositoryTuple(new GlobalRuleNodePath(entity.value()), YamlEngine.marshal(yamlGlobalRuleConfig));
+ return new RuleNodeTuple(new GlobalRuleNodePath(entity.value()), YamlEngine.marshal(yamlGlobalRuleConfig));
}
/**
- * Swap to rule repository tuples.
+ * Swap to rule node tuples.
*
* @param databaseName database name
* @param yamlRuleConfig YAML rule configuration to be swapped
- * @return rule repository tuples
+ * @return rule node tuples
*/
- public Collection<RuleRepositoryTuple> swapToTuples(final String databaseName, final YamlRuleConfiguration yamlRuleConfig) {
- RuleRepositoryTupleEntity entity = yamlRuleConfig.getClass().getAnnotation(RuleRepositoryTupleEntity.class);
+ public Collection<RuleNodeTuple> swapToTuples(final String databaseName, final YamlRuleConfiguration yamlRuleConfig) {
+ RuleNodeTupleEntity entity = yamlRuleConfig.getClass().getAnnotation(RuleNodeTupleEntity.class);
Preconditions.checkNotNull(entity);
Preconditions.checkArgument(!entity.leaf());
String ruleType = entity.value();
- Collection<RuleRepositoryTuple> result = new LinkedList<>();
+ Collection<RuleNodeTuple> result = new LinkedList<>();
for (Field each : YamlRuleConfigurationFieldUtil.getFields(yamlRuleConfig.getClass())) {
boolean isAccessible = each.isAccessible();
each.setAccessible(true);
@@ -88,7 +88,7 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
}
@SneakyThrows(ReflectiveOperationException.class)
- private Collection<RuleRepositoryTuple> swapToTuples(final String databaseName, final String ruleType, final YamlRuleConfiguration yamlRuleConfig, final Field field) {
+ private Collection<RuleNodeTuple> swapToTuples(final String databaseName, final String ruleType, final YamlRuleConfiguration yamlRuleConfig, final Field field) {
Object fieldValue = field.get(yamlRuleConfig);
if (null == fieldValue) {
return Collections.emptyList();
@@ -101,39 +101,39 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
@SneakyThrows(ReflectiveOperationException.class)
@SuppressWarnings("rawtypes")
- private Collection<RuleRepositoryTuple> swapToNamedTuples(final String databaseName, final String ruleType, final String ruleItemType, final Field field, final Object fieldValue) {
- Collection<RuleRepositoryTuple> result = new LinkedList<>();
+ private Collection<RuleNodeTuple> swapToNamedTuples(final String databaseName, final String ruleType, final String ruleItemType, final Field field, final Object fieldValue) {
+ Collection<RuleNodeTuple> result = new LinkedList<>();
if (fieldValue instanceof Map) {
for (Object entry : ((Map) fieldValue).entrySet()) {
String ruleItemName = ((Entry) entry).getKey().toString();
result.add(
- new RuleRepositoryTuple(new DatabaseRuleNodePath(databaseName, ruleType, new DatabaseRuleItem(ruleItemType, ruleItemName)), YamlEngine.marshal(((Entry) entry).getValue())));
+ new RuleNodeTuple(new DatabaseRuleNodePath(databaseName, ruleType, new DatabaseRuleItem(ruleItemType, ruleItemName)), YamlEngine.marshal(((Entry) entry).getValue())));
}
} else {
for (Object each : (Collection) fieldValue) {
- String ruleItemName = field.getAnnotation(RuleRepositoryTupleKeyListNameGenerator.class).value().getConstructor().newInstance().generate(each);
- result.add(new RuleRepositoryTuple(new DatabaseRuleNodePath(databaseName, ruleType, new DatabaseRuleItem(ruleItemType, ruleItemName)), each.toString()));
+ String ruleItemName = field.getAnnotation(RuleNodeTupleKeyListNameGenerator.class).value().getConstructor().newInstance().generate(each);
+ result.add(new RuleNodeTuple(new DatabaseRuleNodePath(databaseName, ruleType, new DatabaseRuleItem(ruleItemType, ruleItemName)), each.toString()));
}
}
return result;
}
@SuppressWarnings("rawtypes")
- private Optional<RuleRepositoryTuple> swapToUniqueTuple(final String databaseName, final String ruleType, final String ruleItemType, final Object fieldValue) {
+ private Optional<RuleNodeTuple> swapToUniqueTuple(final String databaseName, final String ruleType, final String ruleItemType, final Object fieldValue) {
DatabaseRuleNodePath databaseRuleNodePath = new DatabaseRuleNodePath(databaseName, ruleType, new DatabaseRuleItem(ruleItemType));
if (fieldValue instanceof Collection) {
- return ((Collection) fieldValue).isEmpty() ? Optional.empty() : Optional.of(new RuleRepositoryTuple(databaseRuleNodePath, YamlEngine.marshal(fieldValue)));
+ return ((Collection) fieldValue).isEmpty() ? Optional.empty() : Optional.of(new RuleNodeTuple(databaseRuleNodePath, YamlEngine.marshal(fieldValue)));
}
if (fieldValue instanceof String) {
- return ((String) fieldValue).isEmpty() ? Optional.empty() : Optional.of(new RuleRepositoryTuple(databaseRuleNodePath, fieldValue.toString()));
+ return ((String) fieldValue).isEmpty() ? Optional.empty() : Optional.of(new RuleNodeTuple(databaseRuleNodePath, fieldValue.toString()));
}
if (fieldValue instanceof Boolean || fieldValue instanceof Integer || fieldValue instanceof Long) {
- return Optional.of(new RuleRepositoryTuple(databaseRuleNodePath, fieldValue.toString()));
+ return Optional.of(new RuleNodeTuple(databaseRuleNodePath, fieldValue.toString()));
}
if (fieldValue instanceof Enum) {
- return Optional.of(new RuleRepositoryTuple(databaseRuleNodePath, ((Enum) fieldValue).name()));
+ return Optional.of(new RuleNodeTuple(databaseRuleNodePath, ((Enum) fieldValue).name()));
}
- return Optional.of(new RuleRepositoryTuple(databaseRuleNodePath, YamlEngine.marshal(fieldValue)));
+ return Optional.of(new RuleNodeTuple(databaseRuleNodePath, YamlEngine.marshal(fieldValue)));
}
/**
@@ -148,7 +148,7 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
public YamlRuleConfiguration swapToYamlGlobalRuleConfiguration(final String ruleType, final String ruleContent) {
for (YamlRuleConfigurationSwapper each : OrderedSPILoader.getServices(YamlRuleConfigurationSwapper.class)) {
Class<? extends YamlRuleConfiguration> yamlRuleConfigClass = getYamlRuleConfigurationClass(each);
- RuleRepositoryTupleEntity entity = yamlRuleConfigClass.getAnnotation(RuleRepositoryTupleEntity.class);
+ RuleNodeTupleEntity entity = yamlRuleConfigClass.getAnnotation(RuleNodeTupleEntity.class);
if (null != entity && ruleType.equals(entity.value())) {
return YamlEngine.unmarshal(ruleContent, yamlRuleConfigClass);
}
@@ -161,15 +161,15 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
*
* @param databaseName database name
* @param ruleType rule type
- * @param tuples rule repository tuples
+ * @param tuples rule node tuples
* @return database rule configuration
* @throws IllegalArgumentException throw if rule configuration not found
*/
@SuppressWarnings("rawtypes")
- public YamlRuleConfiguration swapToYamlDatabaseRuleConfiguration(final String databaseName, final String ruleType, final Collection<RuleRepositoryTuple> tuples) {
+ public YamlRuleConfiguration swapToYamlDatabaseRuleConfiguration(final String databaseName, final String ruleType, final Collection<RuleNodeTuple> tuples) {
for (YamlRuleConfigurationSwapper each : OrderedSPILoader.getServices(YamlRuleConfigurationSwapper.class)) {
Class<? extends YamlRuleConfiguration> yamlRuleConfigClass = getYamlRuleConfigurationClass(each);
- RuleRepositoryTupleEntity entity = yamlRuleConfigClass.getAnnotation(RuleRepositoryTupleEntity.class);
+ RuleNodeTupleEntity entity = yamlRuleConfigClass.getAnnotation(RuleNodeTupleEntity.class);
if (null != entity && entity.value().equals(ruleType)) {
return swapToYamlDatabaseRuleConfiguration(databaseName, yamlRuleConfigClass, tuples)
.orElseThrow(() -> new IllegalArgumentException(String.format("Can not find rule configuration with type: %s", ruleType)));
@@ -180,11 +180,11 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
@SneakyThrows(ReflectiveOperationException.class)
private Optional<YamlRuleConfiguration> swapToYamlDatabaseRuleConfiguration(final String databaseName,
- final Class<? extends YamlRuleConfiguration> toBeSwappedType, final Collection<RuleRepositoryTuple> tuples) {
+ final Class<? extends YamlRuleConfiguration> toBeSwappedType, final Collection<RuleNodeTuple> tuples) {
Collection<Field> fields = YamlRuleConfigurationFieldUtil.getFields(toBeSwappedType);
YamlRuleConfiguration yamlRuleConfig = toBeSwappedType.getConstructor().newInstance();
DatabaseRuleNode databaseRuleNode = DatabaseRuleNodeGenerator.generate(toBeSwappedType);
- for (RuleRepositoryTuple each : tuples) {
+ for (RuleNodeTuple each : tuples) {
if (!Strings.isNullOrEmpty(each.getContent())) {
setFieldValue(databaseName, yamlRuleConfig, fields, databaseRuleNode.getRuleType(), each);
}
@@ -192,7 +192,7 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
return Optional.of(yamlRuleConfig);
}
- private void setFieldValue(final String databaseName, final YamlRuleConfiguration yamlRuleConfig, final Collection<Field> fields, final String ruleType, final RuleRepositoryTuple tuple) {
+ private void setFieldValue(final String databaseName, final YamlRuleConfiguration yamlRuleConfig, final Collection<Field> fields, final String ruleType, final RuleNodeTuple tuple) {
for (Field each : fields) {
boolean isAccessible = each.isAccessible();
each.setAccessible(true);
@@ -202,7 +202,7 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
}
private void setFieldValue(final String databaseName, final YamlRuleConfiguration yamlRuleConfig,
- final Field field, final String ruleType, final RuleRepositoryTuple tuple) {
+ final Field field, final String ruleType, final RuleNodeTuple tuple) {
String itemType = YamlRuleConfigurationFieldUtil.getTupleItemName(field);
if (isNamedItem(field)) {
setNamedItemFieldValue(databaseName, yamlRuleConfig, ruleType, tuple, itemType, field);
@@ -212,13 +212,13 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
}
private boolean isNamedItem(final Field field) {
- return field.getType().equals(Map.class) || null != field.getAnnotation(RuleRepositoryTupleKeyListNameGenerator.class) && field.getType().equals(Collection.class);
+ return field.getType().equals(Map.class) || null != field.getAnnotation(RuleNodeTupleKeyListNameGenerator.class) && field.getType().equals(Collection.class);
}
@SneakyThrows(ReflectiveOperationException.class)
@SuppressWarnings({"unchecked", "rawtypes"})
private void setNamedItemFieldValue(final String databaseName, final YamlRuleConfiguration yamlRuleConfig,
- final String ruleType, final RuleRepositoryTuple tuple, final String itemType, final Field field) {
+ final String ruleType, final RuleNodeTuple tuple, final String itemType, final Field field) {
DatabaseRuleNodePath databaseRuleNodePath = new DatabaseRuleNodePath(databaseName, ruleType, new DatabaseRuleItem(itemType, NodePathPattern.QUALIFIED_IDENTIFIER));
Optional<String> itemValue = NodePathSearcher.find(tuple.getPath(), new NodePathSearchCriteria(databaseRuleNodePath, false, true, 1));
if (!itemValue.isPresent()) {
@@ -243,7 +243,7 @@ public final class YamlRuleRepositoryTupleSwapperEngine {
@SneakyThrows(ReflectiveOperationException.class)
private void setUniqueItemFieldValue(final String databaseName, final YamlRuleConfiguration yamlRuleConfig,
- final String ruleType, final RuleRepositoryTuple tuple, final String itemType, final Field field) {
+ final String ruleType, final RuleNodeTuple tuple, final String itemType, final Field field) {
DatabaseRuleNodePath databaseRuleNodePath = new DatabaseRuleNodePath(databaseName, ruleType, new DatabaseRuleItem(itemType));
if (!NodePathSearcher.isMatchedPath(tuple.getPath(), new NodePathSearchCriteria(databaseRuleNodePath, false, true, 1))) {
return;
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleRepositoryTupleEntity.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleNodeTupleEntity.java
similarity index 94%
rename from mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleRepositoryTupleEntity.java
rename to mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleNodeTupleEntity.java
index 66f680300ba..33698dcdd53 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleRepositoryTupleEntity.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleNodeTupleEntity.java
@@ -23,11 +23,11 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
- * Rule repository tuple entity.
+ * Rule node tuple entity.
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
-public @interface RuleRepositoryTupleEntity {
+public @interface RuleNodeTupleEntity {
/**
* Get rule type name.
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleRepositoryTupleField.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleNodeTupleField.java
similarity index 94%
rename from mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleRepositoryTupleField.java
rename to mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleNodeTupleField.java
index 2dc84e39be4..cff05e7a11b 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleRepositoryTupleField.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleNodeTupleField.java
@@ -25,11 +25,11 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
- * Rule repository tuple field.
+ * Rule node tuple field.
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
-public @interface RuleRepositoryTupleField {
+public @interface RuleNodeTupleField {
/**
* Get type.
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleRepositoryTupleKeyListNameGenerator.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleNodeTupleKeyListNameGenerator.java
similarity index 85%
rename from mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleRepositoryTupleKeyListNameGenerator.java
rename to mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleNodeTupleKeyListNameGenerator.java
index 98194ef8895..fe3ebed87fc 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleRepositoryTupleKeyListNameGenerator.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/rule/tuple/annotation/RuleNodeTupleKeyListNameGenerator.java
@@ -23,16 +23,16 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
- * Rule repository tuple key list name generator.
+ * Rule node tuple key list name generator.
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
-public @interface RuleRepositoryTupleKeyListNameGenerator {
+public @interface RuleNodeTupleKeyListNameGenerator {
/**
- * Get repository tuple key list name generator class.
+ * Get node tuple key list name generator class.
*
- * @return repository tuple key list name generator class
+ * @return node tuple key list name generator class
*/
Class<? extends Generator> value();
diff --git a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngineTest.java b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleNodeTupleSwapperEngineTest.java
similarity index 74%
rename from mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngineTest.java
rename to mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleNodeTupleSwapperEngineTest.java
index 563e0bf2840..318758af561 100644
--- a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleRepositoryTupleSwapperEngineTest.java
+++ b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/YamlRuleNodeTupleSwapperEngineTest.java
@@ -35,18 +35,18 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
-class YamlRuleRepositoryTupleSwapperEngineTest {
+class YamlRuleNodeTupleSwapperEngineTest {
@Test
void assertSwapToTuple() {
- RuleRepositoryTuple actual = new YamlRuleRepositoryTupleSwapperEngine().swapToTuple(new YamlLeafRuleConfiguration("foo"));
+ RuleNodeTuple actual = new YamlRuleNodeTupleSwapperEngine().swapToTuple(new YamlLeafRuleConfiguration("foo"));
assertThat(actual.getPath(), is("/rules/leaf"));
assertThat(actual.getContent(), is("value: foo" + System.lineSeparator()));
}
@Test
void assertSwapToTuplesWithEmptyNodeYamlRuleConfiguration() {
- assertTrue(new YamlRuleRepositoryTupleSwapperEngine().swapToTuples("foo_db", new YamlNodeRuleConfiguration()).isEmpty());
+ assertTrue(new YamlRuleNodeTupleSwapperEngine().swapToTuples("foo_db", new YamlNodeRuleConfiguration()).isEmpty());
}
@Test
@@ -64,7 +64,7 @@ class YamlRuleRepositoryTupleSwapperEngineTest {
yamlRuleConfig.setLeaf(leaf);
yamlRuleConfig.setGens(Collections.singleton("value"));
yamlRuleConfig.setGen("single_gen");
- List<RuleRepositoryTuple> actual = new ArrayList<>(new YamlRuleRepositoryTupleSwapperEngine().swapToTuples("foo_db", yamlRuleConfig));
+ List<RuleNodeTuple> actual = new ArrayList<>(new YamlRuleNodeTupleSwapperEngine().swapToTuples("foo_db", yamlRuleConfig));
assertThat(actual.size(), is(10));
assertThat(actual.get(0).getPath(), is("/metadata/foo_db/rules/node/map_value/k"));
assertThat(actual.get(0).getContent(), is("value: v" + System.lineSeparator()));
@@ -91,22 +91,22 @@ class YamlRuleRepositoryTupleSwapperEngineTest {
@Test
void assertSwapToYamlRuleConfigurationWithEmptyNodeYamlRuleConfiguration() {
DatabaseRuleNodePath databaseRuleNodePath = new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("string_value"));
- YamlNodeRuleConfiguration actual = (YamlNodeRuleConfiguration) new YamlRuleRepositoryTupleSwapperEngine().swapToYamlDatabaseRuleConfiguration("foo_db", "node",
- Collections.singleton(new RuleRepositoryTuple(databaseRuleNodePath, "")));
+ YamlNodeRuleConfiguration actual = (YamlNodeRuleConfiguration) new YamlRuleNodeTupleSwapperEngine().swapToYamlDatabaseRuleConfiguration("foo_db", "node",
+ Collections.singleton(new RuleNodeTuple(databaseRuleNodePath, "")));
assertThat(actual.getStringValue(), is(""));
}
@Test
void assertSwapToYamlRuleConfigurationWithNodeYamlRuleConfiguration() {
- YamlNodeRuleConfiguration actual = (YamlNodeRuleConfiguration) new YamlRuleRepositoryTupleSwapperEngine().swapToYamlDatabaseRuleConfiguration("foo_db", "node", Arrays.asList(
- new RuleRepositoryTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("map_value/k")), "v"),
- new RuleRepositoryTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("map_value/k:qualified")), "k:qualified"),
- new RuleRepositoryTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("collection_value")), "- !LEAF" + System.lineSeparator() + " value: foo"),
- new RuleRepositoryTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("string_value")), "str"),
- new RuleRepositoryTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("boolean_value")), "true"),
- new RuleRepositoryTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("integer_value")), "1"),
- new RuleRepositoryTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("long_value")), "10"),
- new RuleRepositoryTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("enum_value")), "FOO")));
+ YamlNodeRuleConfiguration actual = (YamlNodeRuleConfiguration) new YamlRuleNodeTupleSwapperEngine().swapToYamlDatabaseRuleConfiguration("foo_db", "node", Arrays.asList(
+ new RuleNodeTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("map_value/k")), "v"),
+ new RuleNodeTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("map_value/k:qualified")), "k:qualified"),
+ new RuleNodeTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("collection_value")), "- !LEAF" + System.lineSeparator() + " value: foo"),
+ new RuleNodeTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("string_value")), "str"),
+ new RuleNodeTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("boolean_value")), "true"),
+ new RuleNodeTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("integer_value")), "1"),
+ new RuleNodeTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("long_value")), "10"),
+ new RuleNodeTuple(new DatabaseRuleNodePath("foo_db", "node", new DatabaseRuleItem("enum_value")), "FOO")));
assertThat(actual.getMapValue().size(), is(2));
assertThat(actual.getMapValue().get("k").getValue(), is("v"));
assertThat(actual.getMapValue().get("k:qualified").getValue(), is("k:qualified"));
@@ -121,12 +121,12 @@ class YamlRuleRepositoryTupleSwapperEngineTest {
@Test
void assertSwapToNotFoundYamlGlobalRuleConfiguration() {
- assertThrows(IllegalArgumentException.class, () -> new YamlRuleRepositoryTupleSwapperEngine().swapToYamlGlobalRuleConfiguration("invalid", "value: foo"));
+ assertThrows(IllegalArgumentException.class, () -> new YamlRuleNodeTupleSwapperEngine().swapToYamlGlobalRuleConfiguration("invalid", "value: foo"));
}
@Test
void assertSwapToYamlGlobalRuleConfiguration() {
- YamlRuleConfiguration actual = new YamlRuleRepositoryTupleSwapperEngine().swapToYamlGlobalRuleConfiguration("leaf", "value: foo");
+ YamlRuleConfiguration actual = new YamlRuleNodeTupleSwapperEngine().swapToYamlGlobalRuleConfiguration("leaf", "value: foo");
assertThat(((YamlLeafRuleConfiguration) actual).getValue(), is("foo"));
}
}
diff --git a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/leaf/YamlLeafRuleConfiguration.java b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/leaf/YamlLeafRuleConfiguration.java
index 34dd04a52db..a8767766cac 100644
--- a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/leaf/YamlLeafRuleConfiguration.java
+++ b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/leaf/YamlLeafRuleConfiguration.java
@@ -23,9 +23,9 @@ import lombok.NoArgsConstructor;
import lombok.Setter;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
-@RuleRepositoryTupleEntity(value = "leaf", leaf = true)
+@RuleNodeTupleEntity(value = "leaf", leaf = true)
@AllArgsConstructor
@NoArgsConstructor
@Getter
diff --git a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/node/RepositoryTupleKeyListNameGeneratorFixture.java b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/node/RuleNodeTupleKeyListNameGeneratorFixture.java
similarity index 86%
rename from mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/node/RepositoryTupleKeyListNameGeneratorFixture.java
rename to mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/node/RuleNodeTupleKeyListNameGeneratorFixture.java
index 6f93b4ae431..a95ece46721 100644
--- a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/node/RepositoryTupleKeyListNameGeneratorFixture.java
+++ b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/node/RuleNodeTupleKeyListNameGeneratorFixture.java
@@ -17,9 +17,9 @@
package org.apache.shardingsphere.mode.node.rule.tuple.fixture.node;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleKeyListNameGenerator;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleKeyListNameGenerator;
-public final class RepositoryTupleKeyListNameGeneratorFixture implements RuleRepositoryTupleKeyListNameGenerator.Generator {
+public final class RuleNodeTupleKeyListNameGeneratorFixture implements RuleNodeTupleKeyListNameGenerator.Generator {
@Override
public String generate(final Object tupleValue) {
diff --git a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/node/YamlNodeRuleConfiguration.java b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/node/YamlNodeRuleConfiguration.java
index 1f3bb50d42b..32560a4015e 100644
--- a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/node/YamlNodeRuleConfiguration.java
+++ b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/rule/tuple/fixture/node/YamlNodeRuleConfiguration.java
@@ -21,10 +21,10 @@ import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField.Type;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleKeyListNameGenerator;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField.Type;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleKeyListNameGenerator;
import org.apache.shardingsphere.mode.node.rule.tuple.fixture.leaf.YamlLeafRuleConfiguration;
import java.util.Collection;
@@ -32,41 +32,41 @@ import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
-@RuleRepositoryTupleEntity(value = "node")
+@RuleNodeTupleEntity(value = "node")
@Getter
@Setter
public final class YamlNodeRuleConfiguration implements YamlRuleConfiguration {
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private Map<String, YamlLeafRuleConfiguration> mapValue = new HashMap<>();
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private Collection<YamlLeafRuleConfiguration> collectionValue = new LinkedList<>();
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private String stringValue = "";
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private Boolean booleanValue;
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private Integer integerValue;
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private Long longValue;
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private YamlNodeRuleConfigurationEnum enumValue;
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private YamlLeafRuleConfiguration leaf;
- @RuleRepositoryTupleField(type = Type.OTHER)
- @RuleRepositoryTupleKeyListNameGenerator(RepositoryTupleKeyListNameGeneratorFixture.class)
+ @RuleNodeTupleField(type = Type.OTHER)
+ @RuleNodeTupleKeyListNameGenerator(RuleNodeTupleKeyListNameGeneratorFixture.class)
private Collection<String> gens = new LinkedList<>();
- @RuleRepositoryTupleField(type = Type.OTHER)
- @RuleRepositoryTupleKeyListNameGenerator(RepositoryTupleKeyListNameGeneratorFixture.class)
+ @RuleNodeTupleField(type = Type.OTHER)
+ @RuleNodeTupleKeyListNameGenerator(RuleNodeTupleKeyListNameGeneratorFixture.class)
private String gen;
@Override
diff --git a/test/fixture/infra/src/main/java/org/apache/shardingsphere/test/fixture/infra/yaml/MockedYamlRuleConfiguration.java b/test/fixture/infra/src/main/java/org/apache/shardingsphere/test/fixture/infra/yaml/MockedYamlRuleConfiguration.java
index a282fa1fe65..c87bbd9d9b5 100644
--- a/test/fixture/infra/src/main/java/org/apache/shardingsphere/test/fixture/infra/yaml/MockedYamlRuleConfiguration.java
+++ b/test/fixture/infra/src/main/java/org/apache/shardingsphere/test/fixture/infra/yaml/MockedYamlRuleConfiguration.java
@@ -21,9 +21,9 @@ import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleField.Type;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleField.Type;
import org.apache.shardingsphere.test.fixture.infra.rule.MockedRuleConfiguration;
import java.util.Map;
@@ -31,15 +31,15 @@ import java.util.Map;
/**
* Mocked YAML rule configuration.
*/
-@RuleRepositoryTupleEntity("fixture")
+@RuleNodeTupleEntity("fixture")
@Getter
@Setter
public final class MockedYamlRuleConfiguration implements YamlRuleConfiguration {
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private String unique;
- @RuleRepositoryTupleField(type = Type.OTHER)
+ @RuleNodeTupleField(type = Type.OTHER)
private Map<String, String> named;
@Override
diff --git a/test/fixture/infra/src/main/java/org/apache/shardingsphere/test/fixture/infra/yaml/global/MockedYamlGlobalRuleConfiguration.java b/test/fixture/infra/src/main/java/org/apache/shardingsphere/test/fixture/infra/yaml/global/MockedYamlGlobalRuleConfiguration.java
index dc950b1234b..a28bc05f240 100644
--- a/test/fixture/infra/src/main/java/org/apache/shardingsphere/test/fixture/infra/yaml/global/MockedYamlGlobalRuleConfiguration.java
+++ b/test/fixture/infra/src/main/java/org/apache/shardingsphere/test/fixture/infra/yaml/global/MockedYamlGlobalRuleConfiguration.java
@@ -21,13 +21,13 @@ import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import org.apache.shardingsphere.test.fixture.infra.rule.global.MockedGlobalRuleConfiguration;
/**
* Mocked YAML rule configuration.
*/
-@RuleRepositoryTupleEntity(value = "global_fixture", leaf = true)
+@RuleNodeTupleEntity(value = "global_fixture", leaf = true)
@Getter
@Setter
public final class MockedYamlGlobalRuleConfiguration implements YamlGlobalRuleConfiguration {
diff --git a/test/it/yaml/src/main/java/org/apache/shardingsphere/test/it/yaml/YamlRuleRepositoryTupleSwapperEngineIT.java b/test/it/yaml/src/main/java/org/apache/shardingsphere/test/it/yaml/YamlRuleNodeTupleSwapperEngineIT.java
similarity index 83%
rename from test/it/yaml/src/main/java/org/apache/shardingsphere/test/it/yaml/YamlRuleRepositoryTupleSwapperEngineIT.java
rename to test/it/yaml/src/main/java/org/apache/shardingsphere/test/it/yaml/YamlRuleNodeTupleSwapperEngineIT.java
index 59f6dc57faa..4311a0aa105 100644
--- a/test/it/yaml/src/main/java/org/apache/shardingsphere/test/it/yaml/YamlRuleRepositoryTupleSwapperEngineIT.java
+++ b/test/it/yaml/src/main/java/org/apache/shardingsphere/test/it/yaml/YamlRuleNodeTupleSwapperEngineIT.java
@@ -22,9 +22,9 @@ import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import org.apache.shardingsphere.infra.yaml.config.pojo.YamlRootConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlGlobalRuleConfiguration;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.mode.node.rule.tuple.RuleRepositoryTuple;
-import org.apache.shardingsphere.mode.node.rule.tuple.YamlRuleRepositoryTupleSwapperEngine;
-import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleRepositoryTupleEntity;
+import org.apache.shardingsphere.mode.node.rule.tuple.RuleNodeTuple;
+import org.apache.shardingsphere.mode.node.rule.tuple.YamlRuleNodeTupleSwapperEngine;
+import org.apache.shardingsphere.mode.node.rule.tuple.annotation.RuleNodeTupleEntity;
import org.junit.jupiter.api.Test;
import java.io.File;
@@ -44,29 +44,29 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertNotNull;
@Slf4j
-public abstract class YamlRuleRepositoryTupleSwapperEngineIT {
+public abstract class YamlRuleNodeTupleSwapperEngineIT {
private final File yamlFile;
- private final YamlRuleRepositoryTupleSwapperEngine engine;
+ private final YamlRuleNodeTupleSwapperEngine engine;
private final String databaseName;
- protected YamlRuleRepositoryTupleSwapperEngineIT(final String yamlFileName) {
+ protected YamlRuleNodeTupleSwapperEngineIT(final String yamlFileName) {
URL url = Thread.currentThread().getContextClassLoader().getResource(yamlFileName);
assertNotNull(url);
yamlFile = new File(url.getFile());
- engine = new YamlRuleRepositoryTupleSwapperEngine();
+ engine = new YamlRuleNodeTupleSwapperEngine();
databaseName = "foo_db";
}
@Test
void assertSwapToTuples() throws IOException {
YamlRuleConfiguration yamlRuleConfig = loadYamlRuleConfiguration();
- List<RuleRepositoryTuple> tuples = yamlRuleConfig instanceof YamlGlobalRuleConfiguration
+ List<RuleNodeTuple> tuples = yamlRuleConfig instanceof YamlGlobalRuleConfiguration
? Collections.singletonList(engine.swapToTuple((YamlGlobalRuleConfiguration) yamlRuleConfig))
: new ArrayList<>(engine.swapToTuples(databaseName, yamlRuleConfig));
- assertRepositoryTuples(tuples, yamlRuleConfig);
+ assertRuleNodeTuples(tuples, yamlRuleConfig);
}
private YamlRuleConfiguration loadYamlRuleConfiguration() throws IOException {
@@ -75,9 +75,9 @@ public abstract class YamlRuleRepositoryTupleSwapperEngineIT {
return yamlRootConfig.getRules().iterator().next();
}
- protected abstract void assertRepositoryTuples(List<RuleRepositoryTuple> actualTuples, YamlRuleConfiguration expectedYamlRuleConfig);
+ protected abstract void assertRuleNodeTuples(List<RuleNodeTuple> actualTuples, YamlRuleConfiguration expectedYamlRuleConfig);
- protected void assertRepositoryTuple(final RuleRepositoryTuple actual, final String expectedKey, final Object expectedValue) {
+ protected void assertRuleNodeTuple(final RuleNodeTuple actual, final String expectedKey, final Object expectedValue) {
assertThat(actual.getPath(), containsString(expectedKey));
assertThat(actual.getContent(), is(isSimpleObject(expectedValue) ? expectedValue : YamlEngine.marshal(expectedValue)));
}
@@ -97,7 +97,7 @@ public abstract class YamlRuleRepositoryTupleSwapperEngineIT {
private String getActualYamlContent() throws IOException {
YamlRuleConfiguration yamlRuleConfig = loadYamlRuleConfiguration();
- RuleRepositoryTupleEntity entity = yamlRuleConfig.getClass().getAnnotation(RuleRepositoryTupleEntity.class);
+ RuleNodeTupleEntity entity = yamlRuleConfig.getClass().getAnnotation(RuleNodeTupleEntity.class);
String ruleType = entity.value();
YamlRuleConfiguration actualYamlRuleConfig = entity.leaf()
? engine.swapToYamlGlobalRuleConfiguration(ruleType, engine.swapToTuple((YamlGlobalRuleConfiguration) yamlRuleConfig).getContent())