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 2023/06/08 10:33:42 UTC
[shardingsphere] branch master updated: Improve swap yaml data to rule configuration in sharding (#26197)
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 <Pa...@163.com>
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());
+ }
}