This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang 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 ad4ac701d01 Add inline sharding algorithms match actual data nodes
check (#30917)
ad4ac701d01 is described below
commit ad4ac701d0118eb6f53c58581311051af7d70da4
Author: ZhangCheng <[email protected]>
AuthorDate: Tue Apr 16 18:48:15 2024 +0800
Add inline sharding algorithms match actual data nodes check (#30917)
---
.../shardingsphere/sharding/rule/ShardingRule.java | 87 +---------
.../sharding/rule/checker/ShardingRuleChecker.java | 185 +++++++++++++++++++++
.../checker/ShardingRouteCacheableCheckerTest.java | 4 +-
.../sharding/rule/ShardingRuleTest.java | 38 +++++
4 files changed, 230 insertions(+), 84 deletions(-)
diff --git
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/ShardingRule.java
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/ShardingRule.java
index 1ded6e4ba4e..a51e40b2da6 100644
---
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/ShardingRule.java
+++
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/ShardingRule.java
@@ -49,11 +49,10 @@ import
org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingS
import
org.apache.shardingsphere.sharding.api.config.strategy.sharding.StandardShardingStrategyConfiguration;
import
org.apache.shardingsphere.sharding.api.sharding.ShardingAutoTableAlgorithm;
import org.apache.shardingsphere.sharding.cache.ShardingCache;
-import
org.apache.shardingsphere.sharding.exception.metadata.DuplicateSharingActualDataNodeException;
-import
org.apache.shardingsphere.sharding.exception.metadata.InvalidBindingTablesException;
import
org.apache.shardingsphere.sharding.exception.metadata.ShardingTableRuleNotFoundException;
import
org.apache.shardingsphere.sharding.rule.attribute.ShardingDataNodeRuleAttribute;
import
org.apache.shardingsphere.sharding.rule.attribute.ShardingTableNamesRuleAttribute;
+import org.apache.shardingsphere.sharding.rule.checker.ShardingRuleChecker;
import org.apache.shardingsphere.sharding.spi.ShardingAlgorithm;
import org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm;
import
org.apache.shardingsphere.sql.parser.sql.common.segment.dml.column.ColumnSegment;
@@ -68,7 +67,6 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
@@ -76,7 +74,6 @@ import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
-import java.util.Set;
import java.util.TreeSet;
import java.util.function.Function;
import java.util.stream.Collectors;
@@ -117,6 +114,8 @@ public final class ShardingRule implements DatabaseRule {
private final RuleAttributes attributes;
+ private final ShardingRuleChecker shardingRuleChecker = new
ShardingRuleChecker(this);
+
public ShardingRule(final ShardingRuleConfiguration ruleConfig, final
Map<String, DataSource> dataSources, final InstanceContext instanceContext) {
configuration = ruleConfig;
this.dataSourceNames = getDataSourceNames(ruleConfig.getTables(),
ruleConfig.getAutoTables(), dataSources.keySet());
@@ -125,7 +124,6 @@ public final class ShardingRule implements DatabaseRule {
ruleConfig.getAuditors().forEach((key, value) -> auditors.put(key,
TypedSPILoader.getService(ShardingAuditAlgorithm.class, value.getType(),
value.getProps())));
shardingTables.putAll(createShardingTables(ruleConfig.getTables(),
ruleConfig.getDefaultKeyGenerateStrategy()));
shardingTables.putAll(createShardingAutoTables(ruleConfig.getAutoTables(),
ruleConfig.getDefaultKeyGenerateStrategy()));
- validateUniqueActualDataNodesInTableRules();
bindingTableRules.putAll(createBindingTableRules(ruleConfig.getBindingTableGroups()));
defaultDatabaseShardingStrategyConfig =
createDefaultDatabaseShardingStrategyConfiguration(ruleConfig);
defaultTableShardingStrategyConfig =
createDefaultTableShardingStrategyConfiguration(ruleConfig);
@@ -134,25 +132,13 @@ public final class ShardingRule implements DatabaseRule {
? TypedSPILoader.getService(KeyGenerateAlgorithm.class, null)
:
keyGenerators.get(ruleConfig.getDefaultKeyGenerateStrategy().getKeyGeneratorName());
defaultShardingColumn = ruleConfig.getDefaultShardingColumn();
-
ShardingSpherePreconditions.checkState(isValidBindingTableConfiguration(shardingTables,
new BindingTableCheckedConfiguration(this.dataSourceNames, shardingAlgorithms,
- ruleConfig.getBindingTableGroups(),
defaultDatabaseShardingStrategyConfig, defaultTableShardingStrategyConfig,
defaultShardingColumn)),
- InvalidBindingTablesException::new);
keyGenerators.values().stream().filter(InstanceContextAware.class::isInstance).forEach(each
-> ((InstanceContextAware) each).setInstanceContext(instanceContext));
if (defaultKeyGenerateAlgorithm instanceof InstanceContextAware && -1
== instanceContext.getWorkerId()) {
((InstanceContextAware)
defaultKeyGenerateAlgorithm).setInstanceContext(instanceContext);
}
shardingCache = null == ruleConfig.getShardingCache() ? null : new
ShardingCache(ruleConfig.getShardingCache(), this);
attributes = new RuleAttributes(new
ShardingDataNodeRuleAttribute(shardingTables), new
ShardingTableNamesRuleAttribute(shardingTables.values()));
- }
-
- private void validateUniqueActualDataNodesInTableRules() {
- Set<DataNode> uniqueActualDataNodes = new
HashSet<>(shardingTables.size(), 1L);
- shardingTables.forEach((key, value) -> {
- DataNode sampleActualDataNode =
value.getActualDataNodes().iterator().next();
-
ShardingSpherePreconditions.checkState(!uniqueActualDataNodes.contains(sampleActualDataNode),
- () -> new DuplicateSharingActualDataNodeException(key,
sampleActualDataNode.getDataSourceName(), sampleActualDataNode.getTableName()));
- uniqueActualDataNodes.add(sampleActualDataNode);
- });
+ shardingRuleChecker.check(ruleConfig);
}
private ShardingStrategyConfiguration
createDefaultDatabaseShardingStrategyConfiguration(final
ShardingRuleConfiguration ruleConfig) {
@@ -248,71 +234,6 @@ public final class ShardingRule implements DatabaseRule {
return result;
}
- private boolean isValidBindingTableConfiguration(final Map<String,
ShardingTable> shardingTables, final BindingTableCheckedConfiguration
checkedConfig) {
- for (ShardingTableReferenceRuleConfiguration each :
checkedConfig.getBindingTableGroups()) {
- Collection<String> bindingTables =
Splitter.on(",").trimResults().splitToList(each.getReference());
- if (bindingTables.size() <= 1) {
- continue;
- }
- Iterator<String> iterator = bindingTables.iterator();
- ShardingTable sampleShardingTable =
getShardingTable(iterator.next(), shardingTables);
- while (iterator.hasNext()) {
- ShardingTable shardingTable =
getShardingTable(iterator.next(), shardingTables);
- if (!isValidActualDataSourceName(sampleShardingTable,
shardingTable) || !isValidActualTableName(sampleShardingTable, shardingTable)) {
- return false;
- }
- if (!isBindingShardingAlgorithm(sampleShardingTable,
shardingTable, true, checkedConfig) ||
!isBindingShardingAlgorithm(sampleShardingTable, shardingTable, false,
checkedConfig)) {
- return false;
- }
- }
- }
- return true;
- }
-
- private boolean isValidActualDataSourceName(final ShardingTable
sampleShardingTable, final ShardingTable shardingTable) {
- return
sampleShardingTable.getActualDataSourceNames().equals(shardingTable.getActualDataSourceNames());
- }
-
- private boolean isValidActualTableName(final ShardingTable
sampleShardingTable, final ShardingTable shardingTable) {
- for (String each : sampleShardingTable.getActualDataSourceNames()) {
- Collection<String> sampleActualTableNames =
-
sampleShardingTable.getActualTableNames(each).stream().map(actualTableName ->
actualTableName.replace(sampleShardingTable.getTableDataNode().getPrefix(), ""))
- .collect(Collectors.toSet());
- Collection<String> actualTableNames =
-
shardingTable.getActualTableNames(each).stream().map(optional ->
optional.replace(shardingTable.getTableDataNode().getPrefix(),
"")).collect(Collectors.toSet());
- if (!sampleActualTableNames.equals(actualTableNames)) {
- return false;
- }
- }
- return true;
- }
-
- private boolean isBindingShardingAlgorithm(final ShardingTable
sampleShardingTable, final ShardingTable shardingTable, final boolean
databaseAlgorithm,
- final
BindingTableCheckedConfiguration checkedConfig) {
- return getAlgorithmExpression(sampleShardingTable, databaseAlgorithm,
checkedConfig).equals(getAlgorithmExpression(shardingTable, databaseAlgorithm,
checkedConfig));
- }
-
- private Optional<String> getAlgorithmExpression(final ShardingTable
shardingTable, final boolean databaseAlgorithm, final
BindingTableCheckedConfiguration checkedConfig) {
- ShardingStrategyConfiguration shardingStrategyConfig =
databaseAlgorithm
- ? getDatabaseShardingStrategyConfiguration(shardingTable,
checkedConfig.getDefaultDatabaseShardingStrategyConfig())
- : getTableShardingStrategyConfiguration(shardingTable,
checkedConfig.getDefaultTableShardingStrategyConfig());
- ShardingAlgorithm shardingAlgorithm =
checkedConfig.getShardingAlgorithms().get(shardingStrategyConfig.getShardingAlgorithmName());
- String dataNodePrefix = databaseAlgorithm ?
shardingTable.getDataSourceDataNode().getPrefix() :
shardingTable.getTableDataNode().getPrefix();
- String shardingColumn = getShardingColumn(shardingStrategyConfig,
checkedConfig.getDefaultShardingColumn());
- return null == shardingAlgorithm ? Optional.empty() :
shardingAlgorithm.getAlgorithmStructure(dataNodePrefix, shardingColumn);
- }
-
- private String getShardingColumn(final ShardingStrategyConfiguration
shardingStrategyConfig, final String defaultShardingColumn) {
- String shardingColumn = defaultShardingColumn;
- if (shardingStrategyConfig instanceof
ComplexShardingStrategyConfiguration) {
- shardingColumn = ((ComplexShardingStrategyConfiguration)
shardingStrategyConfig).getShardingColumns();
- }
- if (shardingStrategyConfig instanceof
StandardShardingStrategyConfiguration) {
- shardingColumn = ((StandardShardingStrategyConfiguration)
shardingStrategyConfig).getShardingColumn();
- }
- return null == shardingColumn ? "" : shardingColumn;
- }
-
/**
* Get database sharding strategy configuration.
*
diff --git
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/checker/ShardingRuleChecker.java
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/checker/ShardingRuleChecker.java
new file mode 100644
index 00000000000..0cf3433246f
--- /dev/null
+++
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/checker/ShardingRuleChecker.java
@@ -0,0 +1,185 @@
+/*
+ * 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.rule.checker;
+
+import com.google.common.base.Splitter;
+import lombok.RequiredArgsConstructor;
+import
org.apache.shardingsphere.infra.algorithm.core.exception.AlgorithmInitializationException;
+import org.apache.shardingsphere.infra.datanode.DataNode;
+import org.apache.shardingsphere.infra.datanode.DataNodeInfo;
+import
org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
+import
org.apache.shardingsphere.sharding.algorithm.sharding.inline.InlineShardingAlgorithm;
+import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.rule.ShardingTableReferenceRuleConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.strategy.sharding.ComplexShardingStrategyConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingStrategyConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.strategy.sharding.StandardShardingStrategyConfiguration;
+import
org.apache.shardingsphere.sharding.api.sharding.standard.PreciseShardingValue;
+import
org.apache.shardingsphere.sharding.exception.metadata.DuplicateSharingActualDataNodeException;
+import
org.apache.shardingsphere.sharding.exception.metadata.InvalidBindingTablesException;
+import
org.apache.shardingsphere.sharding.exception.metadata.ShardingTableRuleNotFoundException;
+import
org.apache.shardingsphere.sharding.rule.BindingTableCheckedConfiguration;
+import org.apache.shardingsphere.sharding.rule.ShardingRule;
+import org.apache.shardingsphere.sharding.rule.ShardingTable;
+import org.apache.shardingsphere.sharding.spi.ShardingAlgorithm;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@RequiredArgsConstructor
+public class ShardingRuleChecker {
+
+ private final ShardingRule shardingRule;
+
+ /**
+ * Check sharding rule.
+ *
+ * @param ruleConfig sharding rule configuration
+ */
+ public void check(final ShardingRuleConfiguration ruleConfig) {
+ checkUniqueActualDataNodesInTableRules();
+ checkBindingTableConfiguration(ruleConfig);
+ checkInlineShardingAlgorithmsInTableRules();
+ }
+
+ private void checkUniqueActualDataNodesInTableRules() {
+ Set<DataNode> uniqueActualDataNodes = new
HashSet<>(shardingRule.getShardingTables().size(), 1L);
+ shardingRule.getShardingTables().forEach((key, value) -> {
+ DataNode sampleActualDataNode =
value.getActualDataNodes().iterator().next();
+
ShardingSpherePreconditions.checkState(!uniqueActualDataNodes.contains(sampleActualDataNode),
+ () -> new DuplicateSharingActualDataNodeException(key,
sampleActualDataNode.getDataSourceName(), sampleActualDataNode.getTableName()));
+ uniqueActualDataNodes.add(sampleActualDataNode);
+ });
+ }
+
+ private void checkBindingTableConfiguration(final
ShardingRuleConfiguration ruleConfig) {
+ ShardingSpherePreconditions.checkState(
+
isValidBindingTableConfiguration(shardingRule.getShardingTables(), new
BindingTableCheckedConfiguration(shardingRule.getDataSourceNames(),
shardingRule.getShardingAlgorithms(),
+ ruleConfig.getBindingTableGroups(),
shardingRule.getDefaultDatabaseShardingStrategyConfig(),
shardingRule.getDefaultTableShardingStrategyConfig(),
+ shardingRule.getDefaultShardingColumn())),
+ InvalidBindingTablesException::new);
+ }
+
+ private boolean isValidBindingTableConfiguration(final Map<String,
ShardingTable> shardingTables, final BindingTableCheckedConfiguration
checkedConfig) {
+ for (ShardingTableReferenceRuleConfiguration each :
checkedConfig.getBindingTableGroups()) {
+ Collection<String> bindingTables =
Splitter.on(",").trimResults().splitToList(each.getReference());
+ if (bindingTables.size() <= 1) {
+ continue;
+ }
+ Iterator<String> iterator = bindingTables.iterator();
+ ShardingTable sampleShardingTable =
getShardingTable(iterator.next(), shardingTables);
+ while (iterator.hasNext()) {
+ ShardingTable shardingTable =
getShardingTable(iterator.next(), shardingTables);
+ if (!isValidActualDataSourceName(sampleShardingTable,
shardingTable) || !isValidActualTableName(sampleShardingTable, shardingTable)) {
+ return false;
+ }
+ if (!isBindingShardingAlgorithm(sampleShardingTable,
shardingTable, true, checkedConfig) ||
!isBindingShardingAlgorithm(sampleShardingTable, shardingTable, false,
checkedConfig)) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ private ShardingTable getShardingTable(final String logicTableName, final
Map<String, ShardingTable> shardingTables) {
+ ShardingTable result = shardingTables.get(logicTableName);
+ if (null != result) {
+ return result;
+ }
+ throw new
ShardingTableRuleNotFoundException(Collections.singleton(logicTableName));
+ }
+
+ private boolean isValidActualDataSourceName(final ShardingTable
sampleShardingTable, final ShardingTable shardingTable) {
+ return
sampleShardingTable.getActualDataSourceNames().equals(shardingTable.getActualDataSourceNames());
+ }
+
+ private boolean isValidActualTableName(final ShardingTable
sampleShardingTable, final ShardingTable shardingTable) {
+ for (String each : sampleShardingTable.getActualDataSourceNames()) {
+ Collection<String> sampleActualTableNames =
+
sampleShardingTable.getActualTableNames(each).stream().map(actualTableName ->
actualTableName.replace(sampleShardingTable.getTableDataNode().getPrefix(), ""))
+ .collect(Collectors.toSet());
+ Collection<String> actualTableNames =
+
shardingTable.getActualTableNames(each).stream().map(optional ->
optional.replace(shardingTable.getTableDataNode().getPrefix(),
"")).collect(Collectors.toSet());
+ if (!sampleActualTableNames.equals(actualTableNames)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private boolean isBindingShardingAlgorithm(final ShardingTable
sampleShardingTable, final ShardingTable shardingTable, final boolean
databaseAlgorithm,
+ final
BindingTableCheckedConfiguration checkedConfig) {
+ return getAlgorithmExpression(sampleShardingTable, databaseAlgorithm,
checkedConfig).equals(getAlgorithmExpression(shardingTable, databaseAlgorithm,
checkedConfig));
+ }
+
+ private Optional<String> getAlgorithmExpression(final ShardingTable
shardingTable, final boolean databaseAlgorithm, final
BindingTableCheckedConfiguration checkedConfig) {
+ ShardingStrategyConfiguration shardingStrategyConfig =
databaseAlgorithm
+ ?
shardingRule.getDatabaseShardingStrategyConfiguration(shardingTable)
+ :
shardingRule.getTableShardingStrategyConfiguration(shardingTable);
+ ShardingAlgorithm shardingAlgorithm =
checkedConfig.getShardingAlgorithms().get(shardingStrategyConfig.getShardingAlgorithmName());
+ String dataNodePrefix = databaseAlgorithm ?
shardingTable.getDataSourceDataNode().getPrefix() :
shardingTable.getTableDataNode().getPrefix();
+ String shardingColumn = getShardingColumn(shardingStrategyConfig,
shardingRule.getDefaultShardingColumn());
+ return null == shardingAlgorithm ? Optional.empty() :
shardingAlgorithm.getAlgorithmStructure(dataNodePrefix, shardingColumn);
+ }
+
+ private String getShardingColumn(final ShardingStrategyConfiguration
shardingStrategyConfig, final String defaultShardingColumn) {
+ String shardingColumn = defaultShardingColumn;
+ if (shardingStrategyConfig instanceof
ComplexShardingStrategyConfiguration) {
+ shardingColumn = ((ComplexShardingStrategyConfiguration)
shardingStrategyConfig).getShardingColumns();
+ }
+ if (shardingStrategyConfig instanceof
StandardShardingStrategyConfiguration) {
+ shardingColumn = ((StandardShardingStrategyConfiguration)
shardingStrategyConfig).getShardingColumn();
+ }
+ return null == shardingColumn ? "" : shardingColumn;
+ }
+
+ private void checkInlineShardingAlgorithmsInTableRules() {
+ shardingRule.getShardingTables().forEach((key, value) -> {
+ validateInlineShardingAlgorithm(value,
shardingRule.getTableShardingStrategyConfiguration(value),
value.getTableDataNode());
+ validateInlineShardingAlgorithm(value,
shardingRule.getDatabaseShardingStrategyConfiguration(value),
value.getDataSourceDataNode());
+ });
+ }
+
+ private void validateInlineShardingAlgorithm(final ShardingTable
shardingTable, final ShardingStrategyConfiguration shardingStrategy, final
DataNodeInfo dataNodeInfo) {
+ if (null == shardingStrategy) {
+ return;
+ }
+ ShardingAlgorithm shardingAlgorithm =
shardingRule.getShardingAlgorithms().get(shardingStrategy.getShardingAlgorithmName());
+ if (shardingAlgorithm instanceof InlineShardingAlgorithm) {
+ String shardingColumn = null ==
((StandardShardingStrategyConfiguration) shardingStrategy).getShardingColumn()
? shardingRule.getDefaultShardingColumn()
+ : ((StandardShardingStrategyConfiguration)
shardingStrategy).getShardingColumn();
+ String result = null;
+ try {
+ result = ((InlineShardingAlgorithm)
shardingAlgorithm).doSharding(Collections.emptySet(),
+ new
PreciseShardingValue<Comparable<?>>(shardingTable.getLogicTable(),
shardingColumn, dataNodeInfo, 1));
+ // CHECKSTYLE:OFF
+ } catch (final Exception ignored) {
+ // CHECKSTYLE:ON
+ }
+ ShardingSpherePreconditions.checkState(null == result ||
result.startsWith(dataNodeInfo.getPrefix()),
+ () -> new
AlgorithmInitializationException(shardingAlgorithm, "`%s` sharding algorithm
configuration of `%s` does not match the actual data nodes",
+ shardingStrategy.getShardingAlgorithmName(),
shardingTable.getLogicTable()));
+ }
+ }
+}
diff --git
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/cache/checker/ShardingRouteCacheableCheckerTest.java
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/cache/checker/ShardingRouteCacheableCheckerTest.java
index 1807c5b28b5..8a8dd05f4c3 100644
---
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/cache/checker/ShardingRouteCacheableCheckerTest.java
+++
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/cache/checker/ShardingRouteCacheableCheckerTest.java
@@ -92,6 +92,8 @@ class ShardingRouteCacheableCheckerTest {
ruleConfig.getBindingTableGroups().add(new
ShardingTableReferenceRuleConfiguration("foo", "t_order,t_order_item"));
ruleConfig.getShardingAlgorithms().put("mod", new
AlgorithmConfiguration("MOD", PropertiesBuilder.build(new
Property("sharding-count", "2"))));
ruleConfig.getShardingAlgorithms().put("inline", new
AlgorithmConfiguration("INLINE", PropertiesBuilder.build(new
Property("algorithm-expression", "ds_${id % 2}"))));
+ ruleConfig.getShardingAlgorithms().put("table-inline",
+ new AlgorithmConfiguration("INLINE",
PropertiesBuilder.build(new Property("algorithm-expression",
"t_non_cacheable_table_sharding_${id % 2}"))));
ruleConfig.setDefaultDatabaseShardingStrategy(new
StandardShardingStrategyConfiguration("warehouse_id", "inline"));
ShardingAutoTableRuleConfiguration warehouse = new
ShardingAutoTableRuleConfiguration("t_warehouse", "ds_${0..1}");
warehouse.setShardingStrategy(new
StandardShardingStrategyConfiguration("id", "mod"));
@@ -102,7 +104,7 @@ class ShardingRouteCacheableCheckerTest {
nonCacheableDatabaseSharding.setDatabaseShardingStrategy(new
StandardShardingStrategyConfiguration("id", "inline"));
ruleConfig.getTables().add(nonCacheableDatabaseSharding);
ShardingTableRuleConfiguration nonCacheableTableSharding = new
ShardingTableRuleConfiguration("t_non_cacheable_table_sharding",
"ds_0.t_non_cacheable_table_sharding_${0..1}");
- nonCacheableTableSharding.setTableShardingStrategy(new
StandardShardingStrategyConfiguration("id", "inline"));
+ nonCacheableTableSharding.setTableShardingStrategy(new
StandardShardingStrategyConfiguration("id", "table-inline"));
ruleConfig.getTables().add(nonCacheableTableSharding);
ruleConfig.setShardingCache(new ShardingCacheConfiguration(100, new
ShardingCacheOptionsConfiguration(true, 0, 0)));
return new ShardingRule(ruleConfig, Maps.of("ds_0", new
MockedDataSource(), "ds_1", new MockedDataSource()),
diff --git
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/rule/ShardingRuleTest.java
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/rule/ShardingRuleTest.java
index 32f22b4bad1..8723fa8cd24 100644
---
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/rule/ShardingRuleTest.java
+++
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/rule/ShardingRuleTest.java
@@ -174,6 +174,44 @@ class ShardingRuleTest {
assertThrows(DuplicateSharingActualDataNodeException.class, () -> new
ShardingRule(ruleConfig, Collections.emptyMap(), mock(InstanceContext.class)));
}
+ @Test
+ void assertValidateWrongInlineShardingAlgorithmsInTableRules() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ShardingTableRuleConfiguration tableRuleConfig = new
ShardingTableRuleConfiguration("t_order", "ds_${0..1}.t_order_tmp_${0..1}");
+ tableRuleConfig.setTableShardingStrategy(new
StandardShardingStrategyConfiguration("order_id", "order_id_inline"));
+ ruleConfig.getTables().add(tableRuleConfig);
+ ruleConfig.getShardingAlgorithms().put("order_id_inline", new
AlgorithmConfiguration("INLINE", PropertiesBuilder.build(new
Property("algorithm-expression", "t_order_${order_id % 2}"))));
+ assertThrows(AlgorithmInitializationException.class, () -> new
ShardingRule(ruleConfig, Collections.emptyMap(), mock(InstanceContext.class)));
+ }
+
+ @Test
+ void assertValidateInlineShardingAlgorithmsInTableRules() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ShardingTableRuleConfiguration tableRuleConfig = new
ShardingTableRuleConfiguration("t_order", "ds_${0..1}.t_order_${0..1}");
+ tableRuleConfig.setTableShardingStrategy(new
StandardShardingStrategyConfiguration("order_id", "order_id_inline"));
+ tableRuleConfig.setDatabaseShardingStrategy(new
StandardShardingStrategyConfiguration("user_id", "user_id_inline"));
+ ruleConfig.getTables().add(tableRuleConfig);
+ ShardingTableRuleConfiguration versionTableRuleConfig = new
ShardingTableRuleConfiguration("t_order", "ds_${0..1}.v2_t_order_${0..1}");
+ versionTableRuleConfig.setTableShardingStrategy(new
StandardShardingStrategyConfiguration("order_id", "order_id_inline"));
+ versionTableRuleConfig.setDatabaseShardingStrategy(new
StandardShardingStrategyConfiguration("user_id", "user_id_inline"));
+ ruleConfig.getTables().add(versionTableRuleConfig);
+ ruleConfig.getShardingAlgorithms().put("order_id_inline", new
AlgorithmConfiguration("INLINE", PropertiesBuilder.build(new
Property("algorithm-expression", "t_order_${order_id % 2}"))));
+ ruleConfig.getShardingAlgorithms().put("user_id_inline", new
AlgorithmConfiguration("INLINE", PropertiesBuilder.build(new
Property("algorithm-expression", "ds_${user_id % 2}"))));
+ new ShardingRule(ruleConfig, Collections.emptyMap(),
mock(InstanceContext.class, RETURNS_DEEP_STUBS));
+ }
+
+ @Test
+ void assertValidateInlineShardingAlgorithmsIgnoreExceptionInTableRules() {
+ ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
+ ShardingTableRuleConfiguration tableRuleConfig =
+ new ShardingTableRuleConfiguration("t_order_interval",
"ds_${0..1}.t_order_interval_${(2018..2050)}${(01..12).collect{m
->m.toString().padLeft(2, '0')}}");
+ tableRuleConfig.setTableShardingStrategy(new
StandardShardingStrategyConfiguration("order_id", "t_order_interval_inline"));
+ ruleConfig.getTables().add(tableRuleConfig);
+ ruleConfig.getShardingAlgorithms().put("t_order_interval_inline",
+ new AlgorithmConfiguration("INLINE",
PropertiesBuilder.build(new Property("algorithm-expression",
"t_order_interval_${order_id.substring(0, 6)}"))));
+ new ShardingRule(ruleConfig, Collections.emptyMap(),
mock(InstanceContext.class, RETURNS_DEEP_STUBS));
+ }
+
@Test
void assertFindTableRule() {
assertTrue(createMaximumShardingRule().findShardingTable("logic_Table").isPresent());
