This is an automated email from the ASF dual-hosted git repository.
zhaojinchao 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 e436cb16e25 Improve swap yaml data to rule configuration in sharding
(#26197)
e436cb16e25 is described below
commit e436cb16e257b1ddbe54b82d55581f78557a0c8b
Author: ChenJiaHao <[email protected]>
AuthorDate: Thu Jun 8 18:33:35 2023 +0800
Improve swap yaml data to rule configuration in sharding (#26197)
* Improve swap yaml data to rule configuration in sharding
* Fix code style
---
.../NewYamlShadowRuleConfigurationSwapper.java | 16 +-
.../metadata/converter/ShardingNodeConverter.java | 342 ++++++++++++++++++---
.../NewYamlShardingRuleConfigurationSwapper.java | 47 ++-
...lShardingAuditStrategyConfigurationSwapper.java | 4 +-
.../converter/ShardingNodeConverterTest.java | 176 +++++++++++
...ewYamlShardingRuleConfigurationSwapperTest.java | 187 ++++++++++-
6 files changed, 703 insertions(+), 69 deletions(-)
diff --git
a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/yaml/swapper/NewYamlShadowRuleConfigurationSwapper.java
b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/yaml/swapper/NewYamlShadowRuleConfigurationSwapper.java
index 50ad3e52ce8..b6556725393 100644
---
a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/yaml/swapper/NewYamlShadowRuleConfigurationSwapper.java
+++
b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/yaml/swapper/NewYamlShadowRuleConfigurationSwapper.java
@@ -34,10 +34,7 @@ import
org.apache.shardingsphere.shadow.yaml.config.table.YamlShadowTableConfigu
import
org.apache.shardingsphere.shadow.yaml.swapper.table.YamlShadowTableConfigurationSwapper;
import java.util.Collection;
-import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
-import java.util.LinkedList;
-import java.util.Map;
import java.util.Map.Entry;
/**
@@ -77,27 +74,22 @@ public final class NewYamlShadowRuleConfigurationSwapper
implements NewYamlRuleC
@Override
public ShadowRuleConfiguration swapToObject(final Collection<YamlDataNode>
dataNodes) {
- Collection<ShadowDataSourceConfiguration> dataSources = new
LinkedList<>();
- Map<String, ShadowTableConfiguration> tables = new LinkedHashMap<>();
- Map<String, AlgorithmConfiguration> algorithms = new LinkedHashMap<>();
ShadowRuleConfiguration result = new ShadowRuleConfiguration();
for (YamlDataNode each : dataNodes) {
if (ShadowNodeConverter.isDataSourcePath(each.getKey())) {
ShadowNodeConverter.getDataSourceName(each.getKey())
- .ifPresent(dataSourceName ->
dataSources.add(swapDataSource(dataSourceName,
YamlEngine.unmarshal(each.getValue(),
YamlShadowDataSourceConfiguration.class))));
+ .ifPresent(dataSourceName ->
result.getDataSources().add(swapDataSource(dataSourceName,
YamlEngine.unmarshal(each.getValue(),
YamlShadowDataSourceConfiguration.class))));
} else if (ShadowNodeConverter.isTablePath(each.getKey())) {
ShadowNodeConverter.getTableName(each.getKey())
- .ifPresent(tableName -> tables.put(tableName,
tableSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlShadowTableConfiguration.class))));
+ .ifPresent(tableName ->
result.getTables().put(tableName,
tableSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlShadowTableConfiguration.class))));
} else if (ShadowNodeConverter.isAlgorithmPath(each.getKey())) {
ShadowNodeConverter.getAlgorithmName(each.getKey())
- .ifPresent(algorithmName ->
algorithms.put(algorithmName,
algorithmSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlAlgorithmConfiguration.class))));
+ .ifPresent(algorithmName ->
result.getShadowAlgorithms().put(algorithmName,
+
algorithmSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlAlgorithmConfiguration.class))));
} else if
(ShadowNodeConverter.isDefaultAlgorithmNamePath(each.getKey())) {
result.setDefaultShadowAlgorithmName(each.getValue());
}
}
- result.setDataSources(dataSources);
- result.setTables(tables);
- result.setShadowAlgorithms(algorithms);
return result;
}
diff --git
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/metadata/converter/ShardingNodeConverter.java
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/metadata/converter/ShardingNodeConverter.java
index 9b4cbcd2bb8..91e3eea9bfc 100644
---
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/metadata/converter/ShardingNodeConverter.java
+++
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/metadata/converter/ShardingNodeConverter.java
@@ -20,166 +20,422 @@ package
org.apache.shardingsphere.sharding.metadata.converter;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
/**
* Sharding node converter.
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class ShardingNodeConverter {
- private static final String TABLES = "tables";
+ private static final String ROOT_NODE = "sharding";
- private static final String AUTO_TABLES = "auto_tables";
+ private static final String TABLES_NODE = "tables";
- private static final String BINDING_TABLES = "binding_tables";
+ private static final String AUTO_TABLES_NODE = "auto_tables";
- private static final String BROADCAST_TABLES = "broadcast_tables";
+ private static final String BINDING_TABLES_NODE = "binding_tables";
- private static final String DEFAULT_STRATEGY = "default_strategy";
+ private static final String BROADCAST_TABLES_NODE = "broadcast_tables";
- private static final String DEFAULT_DATABASE_STRATEGY =
"default_database_strategy";
+ private static final String DEFAULT_STRATEGIES_NODE = "default_strategies";
- private static final String DEFAULT_TABLE_STRATEGY =
"default_table_strategy";
+ private static final String DEFAULT_DATABASE_STRATEGY_NODE =
"default_database_strategy";
- private static final String DEFAULT_KEY_GENERATE_STRATEGY =
"default_key_generate_strategy";
+ private static final String DEFAULT_TABLE_STRATEGY_NODE =
"default_table_strategy";
- private static final String DEFAULT_AUDIT_STRATEGY =
"default_audit_strategy";
+ private static final String DEFAULT_KEY_GENERATE_STRATEGY_NODE =
"default_key_generate_strategy";
- private static final String DEFAULT_SHARDING_COLUMN =
"default_sharding_column";
+ private static final String DEFAULT_AUDIT_STRATEGY_NODE =
"default_audit_strategy";
- private static final String SHARDING_ALGORITHMS = "sharding_algorithms";
+ private static final String DEFAULT_SHARDING_COLUMN_NODE =
"default_sharding_column";
- private static final String KEY_GENERATORS = "key_generators";
+ private static final String SHARDING_ALGORITHMS_NODE = "algorithms";
- private static final String AUDITORS = "auditors";
+ private static final String KEY_GENERATORS_NODE = "key_generators";
- private static final String SHARDING_CACHE = "sharding_cache";
+ private static final String AUDITORS_NODE = "auditors";
- private static final String TABLE_NAME = "table_%s";
+ private static final String SHARDING_CACHE_NODE = "sharding_cache";
- private static final String AUTO_TABLE_NAME = "auto_table_%s";
+ private static final String RULES_NODE_PREFIX =
"/([\\w\\-]+)/([\\w\\-]+)/rules/";
- private static final String BINDING_TABLE_NAME = "binding_table_%s";
+ private static final String RULE_NAME_PATTERN = "/([\\w\\-]+)?";
/**
* Get table name path.
- *
+ *
* @param tableName table name
* @return table name path
*/
public static String getTableNamePath(final String tableName) {
- return String.join("/", TABLES, String.format(TABLE_NAME, tableName));
+ return String.join("/", TABLES_NODE, tableName);
}
/**
* Get auto table name path.
- *
+ *
* @param tableName table name
* @return auto table name path
*/
public static String getAutoTableNamePath(final String tableName) {
- return String.join("/", AUTO_TABLES, String.format(AUTO_TABLE_NAME,
tableName));
+ return String.join("/", AUTO_TABLES_NODE, tableName);
}
/**
* Get binding table name path.
- *
+ *
* @param tableName table name
* @return binding table name path
*/
public static String getBindingTableNamePath(final String tableName) {
- return String.join("/", BINDING_TABLES,
String.format(BINDING_TABLE_NAME, tableName));
+ return String.join("/", BINDING_TABLES_NODE, tableName);
}
/**
* Get broadcast tables path.
- *
+ *
* @return broadcast tables path
*/
public static String getBroadcastTablesPath() {
- return String.join("/", BROADCAST_TABLES);
+ return String.join("/", BROADCAST_TABLES_NODE);
}
/**
* Get default database strategy path.
- *
+ *
* @return default database strategy path
*/
public static String getDefaultDatabaseStrategyPath() {
- return String.join("/", DEFAULT_STRATEGY, DEFAULT_DATABASE_STRATEGY);
+ return String.join("/", DEFAULT_STRATEGIES_NODE,
DEFAULT_DATABASE_STRATEGY_NODE);
}
/**
* Get default table strategy path.
- *
+ *
* @return default table strategy path
*/
public static String getDefaultTableStrategyPath() {
- return String.join("/", DEFAULT_STRATEGY, DEFAULT_TABLE_STRATEGY);
+ return String.join("/", DEFAULT_STRATEGIES_NODE,
DEFAULT_TABLE_STRATEGY_NODE);
}
/**
* Get default key generate strategy path.
- *
+ *
* @return default key generate path
*/
public static String getDefaultKeyGenerateStrategyPath() {
- return String.join("/", DEFAULT_STRATEGY,
DEFAULT_KEY_GENERATE_STRATEGY);
+ return String.join("/", DEFAULT_STRATEGIES_NODE,
DEFAULT_KEY_GENERATE_STRATEGY_NODE);
}
/**
* Get default audit strategy path.
- *
+ *
* @return default audit strategy path
*/
public static String getDefaultAuditStrategyPath() {
- return String.join("/", DEFAULT_STRATEGY, DEFAULT_AUDIT_STRATEGY);
+ return String.join("/", DEFAULT_STRATEGIES_NODE,
DEFAULT_AUDIT_STRATEGY_NODE);
}
/**
* Get default sharding column path.
- *
+ *
* @return default sharding column path
*/
public static String getDefaultShardingColumnPath() {
- return String.join("/", DEFAULT_STRATEGY, DEFAULT_SHARDING_COLUMN);
+ return String.join("/", DEFAULT_STRATEGIES_NODE,
DEFAULT_SHARDING_COLUMN_NODE);
}
/**
* Get sharding algorithm path.
- *
+ *
* @param shardingAlgorithmName sharding algorithm name
* @return sharding algorithm path
*/
public static String getShardingAlgorithmPath(final String
shardingAlgorithmName) {
- return String.join("/", SHARDING_ALGORITHMS, shardingAlgorithmName);
+ return String.join("/", SHARDING_ALGORITHMS_NODE,
shardingAlgorithmName);
}
/**
* Get key generator path.
- *
+ *
* @param keyGeneratorName key generator name
* @return key generator path
*/
public static String getKeyGeneratorPath(final String keyGeneratorName) {
- return String.join("/", KEY_GENERATORS, keyGeneratorName);
+ return String.join("/", KEY_GENERATORS_NODE, keyGeneratorName);
}
/**
* Get auditor path.
- *
+ *
* @param auditorName auditor name
* @return auditor path
*/
public static String getAuditorPath(final String auditorName) {
- return String.join("/", AUDITORS, auditorName);
+ return String.join("/", AUDITORS_NODE, auditorName);
}
/**
* Get sharding cache path.
- *
+ *
* @return sharding cache path
*/
public static String getShardingCachePath() {
- return String.join("/", SHARDING_CACHE);
+ return String.join("/", SHARDING_CACHE_NODE);
+ }
+
+ /**
+ * Is sharding path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isShardingPath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE +
"\\.*", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is sharding table path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isTablePath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ TABLES_NODE + "\\.*", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is sharding auto table path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isAutoTablePath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ AUTO_TABLES_NODE + "\\.*", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is binding table path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isBindingTablePath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ BINDING_TABLES_NODE + "\\.*", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is broadcast table path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isBroadcastTablePath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ BROADCAST_TABLES_NODE + "\\.*", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is default database strategy path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isDefaultDatabaseStrategyPath(final String rulePath)
{
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ DEFAULT_STRATEGIES_NODE + "/" + DEFAULT_DATABASE_STRATEGY_NODE + "$",
Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is default table strategy path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isDefaultTableStrategyPath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ DEFAULT_STRATEGIES_NODE + "/" + DEFAULT_TABLE_STRATEGY_NODE + "$",
Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is default key generate strategy path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isDefaultKeyGenerateStrategyPath(final String
rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ DEFAULT_STRATEGIES_NODE + "/" + DEFAULT_KEY_GENERATE_STRATEGY_NODE + "$",
Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is default audit strategy path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isDefaultAuditStrategyPath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ DEFAULT_STRATEGIES_NODE + "/" + DEFAULT_AUDIT_STRATEGY_NODE + "$",
Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is default sharding column path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isDefaultShardingColumnPath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ DEFAULT_STRATEGIES_NODE + "/" + DEFAULT_SHARDING_COLUMN_NODE + "$",
Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is sharding algorithm path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isShardingAlgorithmPath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ SHARDING_ALGORITHMS_NODE + "\\.*", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is key generator path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isKeyGeneratorPath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ KEY_GENERATORS_NODE + "\\.*", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is sharding auditor path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isAuditorPath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ AUDITORS_NODE + "\\.*", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Is sharding cache path.
+ *
+ * @param rulePath rule path
+ * @return true or false
+ */
+ public static boolean isShardingCachePath(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ SHARDING_CACHE_NODE + "$", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find();
+ }
+
+ /**
+ * Get sharding table name.
+ *
+ * @param rulePath rule path
+ * @return sharding table name
+ */
+ public static Optional<String> getTableName(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ TABLES_NODE + RULE_NAME_PATTERN, Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
+ }
+
+ /**
+ * Get auto table name.
+ *
+ * @param rulePath rule path
+ * @return auto table name
+ */
+ public static Optional<String> getAutoTableName(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ AUTO_TABLES_NODE + RULE_NAME_PATTERN, Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
+ }
+
+ /**
+ * Get binding table name.
+ *
+ * @param rulePath rule path
+ * @return binding table name
+ */
+ public static Optional<String> getBindingTableName(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ BINDING_TABLES_NODE + RULE_NAME_PATTERN, Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
+ }
+
+ /**
+ * Get broadcast name.
+ *
+ * @param rulePath rule path
+ * @return broadcast name
+ */
+ public static Optional<String> getBroadcastTableName(final String
rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ BROADCAST_TABLES_NODE + RULE_NAME_PATTERN, Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
+ }
+
+ /**
+ * Get sharding algorithm name.
+ *
+ * @param rulePath rule path
+ * @return sharding algorithm name
+ */
+ public static Optional<String> getShardingAlgorithmName(final String
rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ SHARDING_ALGORITHMS_NODE + RULE_NAME_PATTERN, Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
+ }
+
+ /**
+ * Get key generator name.
+ *
+ * @param rulePath rule path
+ * @return key generator name
+ */
+ public static Optional<String> getKeyGeneratorName(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ KEY_GENERATORS_NODE + RULE_NAME_PATTERN, Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
+ }
+
+ /**
+ * Get auditor name.
+ *
+ * @param rulePath rule path
+ * @return auditor name
+ */
+ public static Optional<String> getAuditorName(final String rulePath) {
+ Pattern pattern = Pattern.compile(RULES_NODE_PREFIX + ROOT_NODE + "/"
+ AUDITORS_NODE + RULE_NAME_PATTERN, Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(rulePath);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
}
}
diff --git
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/NewYamlShardingRuleConfigurationSwapper.java
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/NewYamlShardingRuleConfigurationSwapper.java
index b173c2e8e23..b24ef7242b5 100644
---
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/NewYamlShardingRuleConfigurationSwapper.java
+++
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/NewYamlShardingRuleConfigurationSwapper.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.sharding.yaml.swapper;
import org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import org.apache.shardingsphere.infra.util.yaml.datanode.YamlDataNode;
+import
org.apache.shardingsphere.infra.yaml.config.pojo.algorithm.YamlAlgorithmConfiguration;
import
org.apache.shardingsphere.infra.yaml.config.swapper.algorithm.YamlAlgorithmConfigurationSwapper;
import
org.apache.shardingsphere.infra.yaml.config.swapper.rule.NewYamlRuleConfigurationSwapper;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
@@ -28,6 +29,12 @@ import
org.apache.shardingsphere.sharding.api.config.rule.ShardingTableReference
import
org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
import org.apache.shardingsphere.sharding.constant.ShardingOrder;
import
org.apache.shardingsphere.sharding.metadata.converter.ShardingNodeConverter;
+import
org.apache.shardingsphere.sharding.yaml.config.cache.YamlShardingCacheConfiguration;
+import
org.apache.shardingsphere.sharding.yaml.config.rule.YamlShardingAutoTableRuleConfiguration;
+import
org.apache.shardingsphere.sharding.yaml.config.rule.YamlTableRuleConfiguration;
+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.cache.YamlShardingCacheConfigurationSwapper;
import
org.apache.shardingsphere.sharding.yaml.swapper.rule.YamlShardingAutoTableRuleConfigurationSwapper;
import
org.apache.shardingsphere.sharding.yaml.swapper.rule.YamlShardingTableReferenceRuleConfigurationConverter;
@@ -123,7 +130,45 @@ public final class NewYamlShardingRuleConfigurationSwapper
implements NewYamlRul
@Override
public ShardingRuleConfiguration swapToObject(final
Collection<YamlDataNode> dataNodes) {
- return new ShardingRuleConfiguration();
+ ShardingRuleConfiguration result = new ShardingRuleConfiguration();
+ for (YamlDataNode each : dataNodes) {
+ if (ShardingNodeConverter.isTablePath(each.getKey())) {
+ ShardingNodeConverter.getTableName(each.getKey())
+ .ifPresent(tableName ->
result.getTables().add(tableSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlTableRuleConfiguration.class))));
+ } else if (ShardingNodeConverter.isAutoTablePath(each.getKey())) {
+ ShardingNodeConverter.getAutoTableName(each.getKey())
+ .ifPresent(autoTableName ->
result.getAutoTables().add(autoTableYamlSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlShardingAutoTableRuleConfiguration.class))));
+ } else if
(ShardingNodeConverter.isBindingTablePath(each.getKey())) {
+ ShardingNodeConverter.getBindingTableName(each.getKey())
+ .ifPresent(bindingTableName ->
result.getBindingTableGroups().add(YamlShardingTableReferenceRuleConfigurationConverter.convertToObject(each.getValue())));
+ } else if
(ShardingNodeConverter.isBroadcastTablePath(each.getKey())) {
+
ShardingNodeConverter.getBroadcastTableName(each.getKey()).ifPresent(broadcastName
-> result.getBroadcastTables().add(each.getValue()));
+ } else if
(ShardingNodeConverter.isDefaultDatabaseStrategyPath(each.getKey())) {
+
result.setDefaultDatabaseShardingStrategy(shardingStrategySwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlShardingStrategyConfiguration.class)));
+ } else if
(ShardingNodeConverter.isDefaultTableStrategyPath(each.getKey())) {
+
result.setDefaultTableShardingStrategy(shardingStrategySwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlShardingStrategyConfiguration.class)));
+ } else if
(ShardingNodeConverter.isDefaultKeyGenerateStrategyPath(each.getKey())) {
+
result.setDefaultKeyGenerateStrategy(keyGenerateStrategySwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlKeyGenerateStrategyConfiguration.class)));
+ } else if
(ShardingNodeConverter.isDefaultAuditStrategyPath(each.getKey())) {
+
result.setDefaultAuditStrategy(auditStrategySwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlShardingAuditStrategyConfiguration.class)));
+ } else if
(ShardingNodeConverter.isDefaultShardingColumnPath(each.getKey())) {
+ result.setDefaultShardingColumn(each.getValue());
+ } else if
(ShardingNodeConverter.isShardingAlgorithmPath(each.getKey())) {
+ ShardingNodeConverter.getShardingAlgorithmName(each.getKey())
+ .ifPresent(algorithmName ->
result.getShardingAlgorithms().put(algorithmName,
+
algorithmSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlAlgorithmConfiguration.class))));
+ } else if
(ShardingNodeConverter.isKeyGeneratorPath(each.getKey())) {
+ ShardingNodeConverter.getKeyGeneratorName(each.getKey())
+ .ifPresent(keyGeneratorName ->
result.getKeyGenerators().put(keyGeneratorName,
+
algorithmSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlAlgorithmConfiguration.class))));
+ } else if (ShardingNodeConverter.isAuditorPath(each.getKey())) {
+ ShardingNodeConverter.getAuditorName(each.getKey())
+ .ifPresent(auditorName ->
result.getAuditors().put(auditorName,
algorithmSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlAlgorithmConfiguration.class))));
+ } else if
(ShardingNodeConverter.isShardingCachePath(each.getKey())) {
+
result.setShardingCache(shardingCacheYamlSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlShardingCacheConfiguration.class)));
+ }
+ }
+ return result;
}
@Override
diff --git
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/strategy/YamlShardingAuditStrategyConfigurationSwapper.java
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/strategy/YamlShardingAuditStrategyConfigurationSwapper.java
index 625a5d53399..3f774010e50 100644
---
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/strategy/YamlShardingAuditStrategyConfigurationSwapper.java
+++
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/yaml/swapper/strategy/YamlShardingAuditStrategyConfigurationSwapper.java
@@ -21,6 +21,8 @@ import
org.apache.shardingsphere.infra.util.yaml.swapper.YamlConfigurationSwappe
import
org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
import
org.apache.shardingsphere.sharding.yaml.config.strategy.audit.YamlShardingAuditStrategyConfiguration;
+import java.util.LinkedList;
+
/**
* YAML sharding audit strategy configuration swapper.
*/
@@ -29,7 +31,7 @@ public final class
YamlShardingAuditStrategyConfigurationSwapper implements Yaml
@Override
public YamlShardingAuditStrategyConfiguration
swapToYamlConfiguration(final ShardingAuditStrategyConfiguration data) {
YamlShardingAuditStrategyConfiguration result = new
YamlShardingAuditStrategyConfiguration();
- result.setAuditorNames(data.getAuditorNames());
+ result.setAuditorNames(new LinkedList<>(data.getAuditorNames()));
result.setAllowHintDisable(data.isAllowHintDisable());
return result;
}
diff --git
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/metadata/converter/ShardingNodeConverterTest.java
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/metadata/converter/ShardingNodeConverterTest.java
new file mode 100644
index 00000000000..7761d70a034
--- /dev/null
+++
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/metadata/converter/ShardingNodeConverterTest.java
@@ -0,0 +1,176 @@
+/*
+ * 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.metadata.converter;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ShardingNodeConverterTest {
+
+ @Test
+ void assertGetTableNamePath() {
+ assertThat(ShardingNodeConverter.getTableNamePath("foo_table"),
is("tables/foo_table"));
+ }
+
+ @Test
+ void assertGetAutoTableNamePath() {
+
assertThat(ShardingNodeConverter.getAutoTableNamePath("foo_auto_table"),
is("auto_tables/foo_auto_table"));
+ }
+
+ @Test
+ void assertGetBindingTableNamePath() {
+
assertThat(ShardingNodeConverter.getBindingTableNamePath("foo_binding_table"),
is("binding_tables/foo_binding_table"));
+ }
+
+ @Test
+ void assertGetBroadcastTableNamePath() {
+ assertThat(ShardingNodeConverter.getBroadcastTablesPath(),
is("broadcast_tables"));
+ }
+
+ @Test
+ void assertGetDefaultDatabaseStrategyPath() {
+ assertThat(ShardingNodeConverter.getDefaultDatabaseStrategyPath(),
is("default_strategies/default_database_strategy"));
+ }
+
+ @Test
+ void assertGetDefaultTableStrategyPath() {
+ assertThat(ShardingNodeConverter.getDefaultTableStrategyPath(),
is("default_strategies/default_table_strategy"));
+ }
+
+ @Test
+ void assertGetDefaultKeyGenerateStrategyPath() {
+ assertThat(ShardingNodeConverter.getDefaultKeyGenerateStrategyPath(),
is("default_strategies/default_key_generate_strategy"));
+ }
+
+ @Test
+ void assertGetDefaultAuditStrategyPath() {
+ assertThat(ShardingNodeConverter.getDefaultAuditStrategyPath(),
is("default_strategies/default_audit_strategy"));
+ }
+
+ @Test
+ void assertGetDefaultShardingColumnPath() {
+ assertThat(ShardingNodeConverter.getDefaultShardingColumnPath(),
is("default_strategies/default_sharding_column"));
+ }
+
+ @Test
+ void assertGetShardingAlgorithmPath() {
+ assertThat(ShardingNodeConverter.getShardingAlgorithmPath("MOD"),
is("algorithms/MOD"));
+ }
+
+ @Test
+ void assertGetKeyGeneratorPath() {
+ assertThat(ShardingNodeConverter.getKeyGeneratorPath("DEFAULT"),
is("key_generators/DEFAULT"));
+ }
+
+ @Test
+ void assertGetAuditorPath() {
+
assertThat(ShardingNodeConverter.getAuditorPath("DML_SHARDING_CONDITIONS"),
is("auditors/DML_SHARDING_CONDITIONS"));
+ }
+
+ @Test
+ void assertGetShardingCachePath() {
+ assertThat(ShardingNodeConverter.getShardingCachePath(),
is("sharding_cache"));
+ }
+
+ @Test
+ void assertCheckIsTargetRuleByRulePath() {
+
assertTrue(ShardingNodeConverter.isShardingPath("/metadata/foo_db/rules/sharding/tables/foo_table"));
+
assertFalse(ShardingNodeConverter.isShardingPath("/metadata/foo_db/rules/foo/tables/foo_table"));
+
assertTrue(ShardingNodeConverter.isTablePath("/metadata/foo_db/rules/sharding/tables/foo_table"));
+
assertFalse(ShardingNodeConverter.isTablePath("/metadata/foo_db/rules/sharding/algorithms/MD5"));
+
assertTrue(ShardingNodeConverter.isAutoTablePath("/metadata/foo_db/rules/sharding/auto_tables/foo_table"));
+
assertFalse(ShardingNodeConverter.isAutoTablePath("/metadata/foo_db/rules/sharding/algorithms/MD5"));
+
assertTrue(ShardingNodeConverter.isBindingTablePath("/metadata/foo_db/rules/sharding/binding_tables/foo_table"));
+
assertFalse(ShardingNodeConverter.isBindingTablePath("/metadata/foo_db/rules/sharding/algorithms/MD5"));
+
assertTrue(ShardingNodeConverter.isBroadcastTablePath("/metadata/foo_db/rules/sharding/broadcast_tables/foo_table"));
+
assertFalse(ShardingNodeConverter.isBroadcastTablePath("/metadata/foo_db/rules/sharding/algorithms/MD5"));
+
assertTrue(ShardingNodeConverter.isDefaultDatabaseStrategyPath("/metadata/foo_db/rules/sharding/default_strategies/default_database_strategy"));
+
assertFalse(ShardingNodeConverter.isDefaultDatabaseStrategyPath("/metadata/foo_db/rules/sharding/default_strategies/default_database_strategy/foo"));
+
assertTrue(ShardingNodeConverter.isDefaultTableStrategyPath("/metadata/foo_db/rules/sharding/default_strategies/default_table_strategy"));
+
assertFalse(ShardingNodeConverter.isDefaultTableStrategyPath("/metadata/foo_db/rules/sharding/default_strategies/default_table_strategy/foo"));
+
assertTrue(ShardingNodeConverter.isDefaultKeyGenerateStrategyPath("/metadata/foo_db/rules/sharding/default_strategies/default_key_generate_strategy"));
+
assertFalse(ShardingNodeConverter.isDefaultKeyGenerateStrategyPath("/metadata/foo_db/rules/sharding/default_strategies/default_key_generate_strategy/foo"));
+
assertTrue(ShardingNodeConverter.isDefaultAuditStrategyPath("/metadata/foo_db/rules/sharding/default_strategies/default_audit_strategy"));
+
assertFalse(ShardingNodeConverter.isDefaultAuditStrategyPath("/metadata/foo_db/rules/sharding/default_strategies/default_audit_strategy/foo"));
+
assertTrue(ShardingNodeConverter.isDefaultShardingColumnPath("/metadata/foo_db/rules/sharding/default_strategies/default_sharding_column"));
+
assertFalse(ShardingNodeConverter.isDefaultShardingColumnPath("/metadata/foo_db/rules/sharding/default_strategies/default_sharding_column/foo"));
+
assertTrue(ShardingNodeConverter.isShardingAlgorithmPath("/metadata/foo_db/rules/sharding/algorithms/foo_table"));
+
assertFalse(ShardingNodeConverter.isShardingAlgorithmPath("/metadata/foo_db/rules/sharding/key_generators/foo"));
+
assertTrue(ShardingNodeConverter.isKeyGeneratorPath("/metadata/foo_db/rules/sharding/key_generators/foo"));
+
assertFalse(ShardingNodeConverter.isKeyGeneratorPath("/metadata/foo_db/rules/sharding/algorithms/MD5"));
+
assertTrue(ShardingNodeConverter.isAuditorPath("/metadata/foo_db/rules/sharding/auditors/foo"));
+
assertFalse(ShardingNodeConverter.isAuditorPath("/metadata/foo_db/rules/sharding/algorithms/MD5"));
+
assertTrue(ShardingNodeConverter.isShardingCachePath("/metadata/foo_db/rules/sharding/sharding_cache"));
+
assertFalse(ShardingNodeConverter.isShardingCachePath("/metadata/foo_db/rules/sharding/sharding_cache/foo"));
+ }
+
+ @Test
+ void assertGetTableNameByRulePath() {
+ Optional<String> actual =
ShardingNodeConverter.getTableName("/metadata/foo_db/rules/sharding/tables/foo_table");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo_table"));
+ }
+
+ @Test
+ void assertGetAutoTableNameByRulePath() {
+ Optional<String> actual =
ShardingNodeConverter.getAutoTableName("/metadata/foo_db/rules/sharding/auto_tables/foo_table");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo_table"));
+ }
+
+ @Test
+ void assertGetBindingTableNameByRulePath() {
+ Optional<String> actual =
ShardingNodeConverter.getBindingTableName("/metadata/foo_db/rules/sharding/binding_tables/foo_table");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo_table"));
+ }
+
+ @Test
+ void assertGetBroadcastTableNameByRulePath() {
+ Optional<String> actual =
ShardingNodeConverter.getBroadcastTableName("/metadata/foo_db/rules/sharding/broadcast_tables/foo_table");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo_table"));
+ }
+
+ @Test
+ void assertGetAlgorithmNameByRulePath() {
+ Optional<String> actual =
ShardingNodeConverter.getShardingAlgorithmName("/metadata/foo_db/rules/sharding/algorithms/foo");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo"));
+ }
+
+ @Test
+ void assertGetKeyGeneratorNameByRulePath() {
+ Optional<String> actual =
ShardingNodeConverter.getKeyGeneratorName("/metadata/foo_db/rules/sharding/key_generators/foo");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo"));
+ }
+
+ @Test
+ void assertGetAuditorNameByRulePath() {
+ Optional<String> actual =
ShardingNodeConverter.getAuditorName("/metadata/foo_db/rules/sharding/auditors/foo");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo"));
+ }
+}
diff --git
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/swapper/NewYamlShardingRuleConfigurationSwapperTest.java
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/swapper/NewYamlShardingRuleConfigurationSwapperTest.java
index 16ae14d69f5..52531978e9f 100644
---
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/swapper/NewYamlShardingRuleConfigurationSwapperTest.java
+++
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/yaml/swapper/NewYamlShardingRuleConfigurationSwapperTest.java
@@ -20,20 +20,26 @@ package org.apache.shardingsphere.sharding.yaml.swapper;
import org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
import org.apache.shardingsphere.infra.util.yaml.datanode.YamlDataNode;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
import
org.apache.shardingsphere.sharding.api.config.rule.ShardingTableReferenceRuleConfiguration;
import
org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
import
org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
import
org.apache.shardingsphere.sharding.api.config.strategy.keygen.KeyGenerateStrategyConfiguration;
import
org.apache.shardingsphere.sharding.api.config.strategy.sharding.StandardShardingStrategyConfiguration;
+import org.apache.shardingsphere.test.util.PropertiesBuilder;
import org.junit.jupiter.api.Test;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
+import java.util.LinkedList;
import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
class NewYamlShardingRuleConfigurationSwapperTest {
@@ -47,35 +53,43 @@ class NewYamlShardingRuleConfigurationSwapperTest {
}
@Test
- void assertSwapFullConfigToDataNodesEmpty() {
+ void assertSwapFullConfigToDataNodes() {
ShardingRuleConfiguration config = createMaximumShardingRule();
Collection<YamlDataNode> result = swapper.swapToDataNodes(config);
- assertThat(result.size(), is(14));
+ assertThat(result.size(), is(16));
Iterator<YamlDataNode> iterator = result.iterator();
- assertThat(iterator.next().getKey(), is("tables/table_LOGIC_TABLE"));
- assertThat(iterator.next().getKey(),
is("tables/table_SUB_LOGIC_TABLE"));
- assertThat(iterator.next().getKey(),
is("binding_tables/binding_table_foo"));
+ assertThat(iterator.next().getKey(), is("tables/LOGIC_TABLE"));
+ assertThat(iterator.next().getKey(), is("tables/SUB_LOGIC_TABLE"));
+ assertThat(iterator.next().getKey(), is("auto_tables/auto_table"));
+ assertThat(iterator.next().getKey(), is("binding_tables/foo"));
assertThat(iterator.next().getKey(), is("broadcast_tables"));
- assertThat(iterator.next().getKey(),
is("default_strategy/default_database_strategy"));
- assertThat(iterator.next().getKey(),
is("default_strategy/default_table_strategy"));
- assertThat(iterator.next().getKey(),
is("default_strategy/default_key_generate_strategy"));
- assertThat(iterator.next().getKey(),
is("default_strategy/default_audit_strategy"));
- assertThat(iterator.next().getKey(),
is("sharding_algorithms/core_standard_fixture"));
+ assertThat(iterator.next().getKey(),
is("default_strategies/default_database_strategy"));
+ assertThat(iterator.next().getKey(),
is("default_strategies/default_table_strategy"));
+ assertThat(iterator.next().getKey(),
is("default_strategies/default_key_generate_strategy"));
+ assertThat(iterator.next().getKey(),
is("default_strategies/default_audit_strategy"));
+ assertThat(iterator.next().getKey(),
is("algorithms/core_standard_fixture"));
+ assertThat(iterator.next().getKey(), is("algorithms/hash_mod"));
assertThat(iterator.next().getKey(), is("key_generators/uuid"));
assertThat(iterator.next().getKey(), is("key_generators/default"));
assertThat(iterator.next().getKey(),
is("key_generators/auto_increment"));
assertThat(iterator.next().getKey(), is("auditors/audit_algorithm"));
- assertThat(iterator.next().getKey(),
is("default_strategy/default_sharding_column"));
+ assertThat(iterator.next().getKey(),
is("default_strategies/default_sharding_column"));
}
private ShardingRuleConfiguration createMaximumShardingRule() {
ShardingRuleConfiguration result = new ShardingRuleConfiguration();
ShardingTableRuleConfiguration shardingTableRuleConfig =
createTableRuleConfiguration("LOGIC_TABLE", "ds_${0..1}.table_${0..2}");
shardingTableRuleConfig.setKeyGenerateStrategy(new
KeyGenerateStrategyConfiguration("id", "uuid"));
+ shardingTableRuleConfig.setAuditStrategy(new
ShardingAuditStrategyConfiguration(Collections.singleton("audit_algorithm"),
false));
+ result.getTables().add(shardingTableRuleConfig);
ShardingTableRuleConfiguration subTableRuleConfig =
createTableRuleConfiguration("SUB_LOGIC_TABLE", "ds_${0..1}.sub_table_${0..2}");
subTableRuleConfig.setKeyGenerateStrategy(new
KeyGenerateStrategyConfiguration("id", "auto_increment"));
- result.getTables().add(shardingTableRuleConfig);
result.getTables().add(subTableRuleConfig);
+ ShardingAutoTableRuleConfiguration autoTableRuleConfiguration = new
ShardingAutoTableRuleConfiguration("auto_table", "ds_1,ds_2");
+ autoTableRuleConfiguration.setShardingStrategy(new
StandardShardingStrategyConfiguration("user_id", "hash_mod"));
+ autoTableRuleConfiguration.setKeyGenerateStrategy(new
KeyGenerateStrategyConfiguration("id", "auto_increment"));
+ autoTableRuleConfiguration.setAuditStrategy(new
ShardingAuditStrategyConfiguration(Collections.singleton("audit_algorithm"),
true));
+ result.getAutoTables().add(autoTableRuleConfiguration);
result.getBindingTableGroups().add(new
ShardingTableReferenceRuleConfiguration("foo",
shardingTableRuleConfig.getLogicTable() + "," +
subTableRuleConfig.getLogicTable()));
result.getBroadcastTables().add("BROADCAST_TABLE");
result.setDefaultDatabaseShardingStrategy(new
StandardShardingStrategyConfiguration("ds_id", "standard"));
@@ -84,6 +98,7 @@ class NewYamlShardingRuleConfigurationSwapperTest {
result.setDefaultKeyGenerateStrategy(new
KeyGenerateStrategyConfiguration("id", "default"));
result.setDefaultAuditStrategy(new
ShardingAuditStrategyConfiguration(Collections.singletonList("audit_algorithm"),
false));
result.getShardingAlgorithms().put("core_standard_fixture", new
AlgorithmConfiguration("CORE.STANDARD.FIXTURE", new Properties()));
+ result.getShardingAlgorithms().put("hash_mod", new
AlgorithmConfiguration("hash_mod", PropertiesBuilder.build(new
PropertiesBuilder.Property("sharding-count", "4"))));
result.getKeyGenerators().put("uuid", new
AlgorithmConfiguration("UUID", new Properties()));
result.getKeyGenerators().put("default", new
AlgorithmConfiguration("UUID", new Properties()));
result.getKeyGenerators().put("auto_increment", new
AlgorithmConfiguration("AUTO_INCREMENT.FIXTURE", new Properties()));
@@ -97,4 +112,152 @@ class NewYamlShardingRuleConfigurationSwapperTest {
result.setTableShardingStrategy(new
StandardShardingStrategyConfiguration("order_id", "table_inline"));
return result;
}
+
+ @Test
+ void assertSwapToObjectEmpty() {
+ Collection<YamlDataNode> config = new LinkedList<>();
+ ShardingRuleConfiguration result = swapper.swapToObject(config);
+ assertThat(result.getTables().size(), is(0));
+ assertThat(result.getAutoTables().size(), is(0));
+ assertThat(result.getBindingTableGroups().size(), is(0));
+ assertThat(result.getBroadcastTables().size(), is(0));
+ assertNull(result.getDefaultDatabaseShardingStrategy());
+ assertNull(result.getDefaultTableShardingStrategy());
+ assertNull(result.getDefaultKeyGenerateStrategy());
+ assertNull(result.getDefaultAuditStrategy());
+ assertNull(result.getDefaultShardingColumn());
+ assertThat(result.getShardingAlgorithms().size(), is(0));
+ assertThat(result.getKeyGenerators().size(), is(0));
+ assertThat(result.getAuditors().size(), is(0));
+ assertNull(result.getShardingCache());
+ }
+
+ @Test
+ void assertSwapToObject() {
+ Collection<YamlDataNode> config = new LinkedList<>();
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/tables/LOGIC_TABLE",
"actualDataNodes: ds_${0..1}.table_${0..2}\n"
+ + "auditStrategy:\n"
+ + " allowHintDisable: false\n"
+ + " auditorNames:\n"
+ + " - audit_algorithm\n"
+ + "databaseStrategy:\n"
+ + " standard:\n"
+ + " shardingAlgorithmName: database_inline\n"
+ + " shardingColumn: user_id\n"
+ + "keyGenerateStrategy:\n"
+ + " column: id\n"
+ + " keyGeneratorName: uuid\n"
+ + "logicTable: LOGIC_TABLE\n"
+ + "tableStrategy:\n"
+ + " standard:\n"
+ + " shardingAlgorithmName: table_inline\n"
+ + " shardingColumn: order_id\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/tables/SUB_LOGIC_TABLE",
"actualDataNodes: ds_${0..1}.sub_table_${0..2}\n"
+ + "databaseStrategy:\n"
+ + " standard:\n"
+ + " shardingAlgorithmName: database_inline\n"
+ + " shardingColumn: user_id\n"
+ + "keyGenerateStrategy:\n"
+ + " column: id\n"
+ + " keyGeneratorName: auto_increment\n"
+ + "logicTable: SUB_LOGIC_TABLE\n"
+ + "tableStrategy:\n"
+ + " standard:\n"
+ + " shardingAlgorithmName: table_inline\n"
+ + " shardingColumn: order_id\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/auto_tables/auto_table",
"actualDataSources: ds_1,ds_2\n"
+ + "auditStrategy:\n"
+ + " allowHintDisable: true\n"
+ + " auditorNames:\n"
+ + " - audit_algorithm\n"
+ + "keyGenerateStrategy:\n"
+ + " column: id\n"
+ + " keyGeneratorName: auto_increment\n"
+ + "logicTable: auto_table\n"
+ + "shardingStrategy:\n"
+ + " standard:\n"
+ + " shardingAlgorithmName: hash_mod\n"
+ + " shardingColumn: user_id\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/binding_tables/foo",
"foo:LOGIC_TABLE,SUB_LOGIC_TABLE"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/broadcast_tables", "-
BROADCAST_TABLE\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/default_strategies/default_database_strategy",
"standard:\n"
+ + " shardingAlgorithmName: standard\n"
+ + " shardingColumn: ds_id\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/default_strategies/default_table_strategy",
"standard:\n"
+ + " shardingAlgorithmName: standard\n"
+ + " shardingColumn: table_id\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/default_strategies/default_key_generate_strategy",
"column: id\n"
+ + "keyGeneratorName: default\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/default_strategies/default_audit_strategy",
"allowHintDisable: false\n"
+ + "auditorNames:\n"
+ + "- audit_algorithm\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/algorithms/core_standard_fixture",
"type: CORE.STANDARD.FIXTURE\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/algorithms/hash_mod", "props:\n"
+ + " sharding-count: '4'\n"
+ + "type: hash_mod\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/key_generators/uuid", "type:
UUID\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/key_generators/default", "type:
UUID\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/key_generators/auto_increment",
"type: AUTO_INCREMENT.FIXTURE\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/auditors/audit_algorithm", "type:
DML_SHARDING_CONDITIONS\n"));
+ config.add(new
YamlDataNode("/metadata/foo_db/rules/sharding/default_strategies/default_sharding_column",
"table_id"));
+ ShardingRuleConfiguration result = swapper.swapToObject(config);
+ assertThat(result.getTables().size(), is(2));
+ assertThat(result.getTables().iterator().next().getLogicTable(),
is("LOGIC_TABLE"));
+ assertThat(result.getTables().iterator().next().getActualDataNodes(),
is("ds_${0..1}.table_${0..2}"));
+
assertTrue(result.getTables().iterator().next().getDatabaseShardingStrategy()
instanceof StandardShardingStrategyConfiguration);
+ assertThat(((StandardShardingStrategyConfiguration)
result.getTables().iterator().next().getDatabaseShardingStrategy()).getShardingColumn(),
is("user_id"));
+
assertThat(result.getTables().iterator().next().getDatabaseShardingStrategy().getShardingAlgorithmName(),
is("database_inline"));
+
assertThat(result.getTables().iterator().next().getDatabaseShardingStrategy().getType(),
is("STANDARD"));
+
assertTrue(result.getTables().iterator().next().getTableShardingStrategy()
instanceof StandardShardingStrategyConfiguration);
+ assertThat(((StandardShardingStrategyConfiguration)
result.getTables().iterator().next().getTableShardingStrategy()).getShardingColumn(),
is("order_id"));
+
assertThat(result.getTables().iterator().next().getTableShardingStrategy().getShardingAlgorithmName(),
is("table_inline"));
+
assertThat(result.getTables().iterator().next().getTableShardingStrategy().getType(),
is("STANDARD"));
+
assertThat(result.getTables().iterator().next().getKeyGenerateStrategy().getColumn(),
is("id"));
+
assertThat(result.getTables().iterator().next().getKeyGenerateStrategy().getKeyGeneratorName(),
is("uuid"));
+
assertThat(result.getTables().iterator().next().getAuditStrategy().getAuditorNames().size(),
is(1));
+
assertThat(result.getTables().iterator().next().getAuditStrategy().getAuditorNames().iterator().next(),
is("audit_algorithm"));
+
assertFalse(result.getTables().iterator().next().getAuditStrategy().isAllowHintDisable());
+ assertThat(result.getAutoTables().size(), is(1));
+ assertThat(result.getAutoTables().iterator().next().getLogicTable(),
is("auto_table"));
+
assertThat(result.getAutoTables().iterator().next().getActualDataSources(),
is("ds_1,ds_2"));
+
assertTrue(result.getAutoTables().iterator().next().getShardingStrategy()
instanceof StandardShardingStrategyConfiguration);
+ assertThat(((StandardShardingStrategyConfiguration)
result.getAutoTables().iterator().next().getShardingStrategy()).getShardingColumn(),
is("user_id"));
+
assertThat(result.getAutoTables().iterator().next().getShardingStrategy().getShardingAlgorithmName(),
is("hash_mod"));
+
assertThat(result.getAutoTables().iterator().next().getShardingStrategy().getType(),
is("STANDARD"));
+
assertThat(result.getAutoTables().iterator().next().getKeyGenerateStrategy().getColumn(),
is("id"));
+
assertThat(result.getAutoTables().iterator().next().getKeyGenerateStrategy().getKeyGeneratorName(),
is("auto_increment"));
+
assertThat(result.getAutoTables().iterator().next().getAuditStrategy().getAuditorNames().size(),
is(1));
+
assertThat(result.getAutoTables().iterator().next().getAuditStrategy().getAuditorNames().iterator().next(),
is("audit_algorithm"));
+
assertTrue(result.getAutoTables().iterator().next().getAuditStrategy().isAllowHintDisable());
+ assertThat(result.getBindingTableGroups().size(), is(1));
+ assertThat(result.getBindingTableGroups().iterator().next().getName(),
is("foo"));
+
assertThat(result.getBindingTableGroups().iterator().next().getReference(),
is("LOGIC_TABLE,SUB_LOGIC_TABLE"));
+ assertTrue(result.getDefaultDatabaseShardingStrategy() instanceof
StandardShardingStrategyConfiguration);
+ assertThat(((StandardShardingStrategyConfiguration)
result.getDefaultDatabaseShardingStrategy()).getType(), is("STANDARD"));
+ assertThat(((StandardShardingStrategyConfiguration)
result.getDefaultDatabaseShardingStrategy()).getShardingColumn(), is("ds_id"));
+
assertThat(result.getDefaultDatabaseShardingStrategy().getShardingAlgorithmName(),
is("standard"));
+ assertTrue(result.getDefaultTableShardingStrategy() instanceof
StandardShardingStrategyConfiguration);
+ assertThat(((StandardShardingStrategyConfiguration)
result.getDefaultTableShardingStrategy()).getType(), is("STANDARD"));
+ assertThat(((StandardShardingStrategyConfiguration)
result.getDefaultTableShardingStrategy()).getShardingColumn(), is("table_id"));
+
assertThat(result.getDefaultTableShardingStrategy().getShardingAlgorithmName(),
is("standard"));
+ assertThat(result.getDefaultKeyGenerateStrategy().getColumn(),
is("id"));
+
assertThat(result.getDefaultKeyGenerateStrategy().getKeyGeneratorName(),
is("default"));
+ assertThat(result.getDefaultAuditStrategy().getAuditorNames().size(),
is(1));
+
assertThat(result.getDefaultAuditStrategy().getAuditorNames().iterator().next(),
is("audit_algorithm"));
+ assertFalse(result.getDefaultAuditStrategy().isAllowHintDisable());
+ assertThat(result.getDefaultShardingColumn(), is("table_id"));
+ assertThat(result.getShardingAlgorithms().size(), is(2));
+
assertThat(result.getShardingAlgorithms().get("core_standard_fixture").getType(),
is("CORE.STANDARD.FIXTURE"));
+ assertThat(result.getShardingAlgorithms().get("hash_mod").getType(),
is("hash_mod"));
+
assertThat(result.getShardingAlgorithms().get("hash_mod").getProps().size(),
is(1));
+
assertThat(result.getShardingAlgorithms().get("hash_mod").getProps().get("sharding-count"),
is("4"));
+ assertThat(result.getKeyGenerators().size(), is(3));
+ assertThat(result.getKeyGenerators().get("uuid").getType(),
is("UUID"));
+ assertThat(result.getKeyGenerators().get("uuid").getProps().size(),
is(0));
+ assertThat(result.getKeyGenerators().get("auto_increment").getType(),
is("AUTO_INCREMENT.FIXTURE"));
+ assertThat(result.getAuditors().size(), is(1));
+ assertThat(result.getAuditors().get("audit_algorithm").getType(),
is("DML_SHARDING_CONDITIONS"));
+
assertThat(result.getAuditors().get("audit_algorithm").getProps().size(),
is(0));
+ assertNull(result.getShardingCache());
+ }
}
