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 2026/09/08 10:19:36 UTC

(shardingsphere) branch master updated: Fix CREATE READWRITE_SPLITTING RULE IF NOT EXISTS for existing rule (#39371)

This is an automated email from the ASF dual-hosted git repository.

terrymanu 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 4cb41851215 Fix CREATE READWRITE_SPLITTING RULE IF NOT EXISTS for existing rule (#39371)
4cb41851215 is described below

commit 4cb41851215ec88693f1e104a453aef6621803cd
Author: Eunbin Son <58...@users.noreply.github.com>
AuthorDate: Tue Sep 8 19:19:28 2026 +0900

    Fix CREATE READWRITE_SPLITTING RULE IF NOT EXISTS for existing rule (#39371)
    
    * Fix CREATE READWRITE_SPLITTING RULE IF NOT EXISTS for existing rule
    
    * Skip existing rules in readwrite-splitting IF NOT EXISTS checks
    
    checkCreation skipped only the duplicate-name check for IF NOT EXISTS and
    continued into actual data source validation with every submitted
    segment. Since that validation seeds the duplicate sets from the whole
    current configuration, repeating an unchanged rule threw
    DuplicateReadwriteSplittingActualDataSourceException instead of becoming
    a no-op, because the executor removes existing-name segments later.
    
    Exclude segments whose rule name already exists from the remaining
    creation validations when IF NOT EXISTS is specified, and keep validating
    genuinely new segments.
    
    Add a case reusing the same rule name and the same write and read storage
    units, and a case where a new segment reuses an existing write data
    source and must still fail.
    
    * Validate new readwrite-splitting names against expanded names
    
    Excluding every ReadwriteSplittingRule mapper key from the logic data
    source set also removed collision protection: with an existing group
    rw_${0..1}, creating literal rw_0 passed because the remaining duplicate
    checks compare raw configuration names, and rebuilding the rule then
    merged both definitions under expanded key rw_0.
    
    Restore the full logic data source set and instead exempt only the exact
    existing configurations that IF NOT EXISTS discards, so genuinely new
    segments are still validated against all expanded logical names.
    
    ---------
    
    Co-authored-by: Liang Zhang <zh...@apache.org>
---
 RELEASE-NOTES.md                                   |  1 +
 .../ReadwriteSplittingRuleStatementChecker.java    | 20 ++++--
 ...ReadwriteSplittingRuleStatementCheckerTest.java | 74 +++++++++++++++++++++-
 3 files changed, 87 insertions(+), 8 deletions(-)

diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md
index 7b429a9443d..628090686a6 100644
--- a/RELEASE-NOTES.md
+++ b/RELEASE-NOTES.md
@@ -42,6 +42,7 @@
 1. Metadata: Fix wrong logic table metadata when config same actual table name in different storage unit - [#39157](https://github.com/apache/shardingsphere/pull/39157)
 1. DistSQL: Fix case-sensitive storage unit matching in `SHOW RULES USED STORAGE UNIT` - [#38848](https://github.com/apache/shardingsphere/pull/38848)
 1. DistSQL: Use case-insensitive table name matching in broadcast create and drop executors - [#39200](https://github.com/apache/shardingsphere/pull/39200)
+1. DistSQL: Fix `CREATE READWRITE_SPLITTING RULE IF NOT EXISTS` failing for an existing rule name - [#39371](https://github.com/apache/shardingsphere/pull/39371)
 1. DistSQL: Match mask table names case-insensitively in create and alter executors - [#39361](https://github.com/apache/shardingsphere/pull/39361)
 1. JDBC: Fix stale generated values leaking into prepared statement executeBatch calls without pending batches - [#38160](https://github.com/apache/shardingsphere/pull/38160)
 1. JDBC: Fix MySQL-compatible typed string conversion for `ResultSet#getObject(index, Class<T>)` - [#38444](https://github.com/apache/shardingsphere/pull/38444)
diff --git a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementChecker.java b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementChecker.java
index 414b1eed691..0e77b52a023 100644
--- a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementChecker.java
+++ b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementChecker.java
@@ -67,10 +67,20 @@ public final class ReadwriteSplittingRuleStatementChecker {
                                      final ReadwriteSplittingRuleConfiguration currentRuleConfig, final boolean ifNotExists) {
         checkDuplicateRuleNames(database, segments, currentRuleConfig, ifNotExists);
         String databaseName = database.getName();
-        checkDataSourcesExist(databaseName, segments, database);
-        checkDuplicatedDataSourceNames(databaseName, segments, currentRuleConfig, true);
-        checkTransactionalReadQueryStrategy(segments);
-        checkLoadBalancers(segments);
+        Collection<ReadwriteSplittingRuleSegment> toBeCreatedSegments = ifNotExists ? getNotExistedSegments(segments, currentRuleConfig) : segments;
+        checkDataSourcesExist(databaseName, toBeCreatedSegments, database);
+        checkDuplicatedDataSourceNames(databaseName, toBeCreatedSegments, currentRuleConfig, true);
+        checkTransactionalReadQueryStrategy(toBeCreatedSegments);
+        checkLoadBalancers(toBeCreatedSegments);
+    }
+    
+    private static Collection<ReadwriteSplittingRuleSegment> getNotExistedSegments(final Collection<ReadwriteSplittingRuleSegment> segments,
+                                                                                   final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+        if (null == currentRuleConfig) {
+            return segments;
+        }
+        Collection<String> currentRuleNames = currentRuleConfig.getDataSourceGroups().stream().map(ReadwriteSplittingDataSourceGroupRuleConfiguration::getName).collect(Collectors.toSet());
+        return segments.stream().filter(each -> !currentRuleNames.contains(each.getName())).collect(Collectors.toList());
     }
     
     /**
@@ -100,7 +110,7 @@ public final class ReadwriteSplittingRuleStatementChecker {
     private static void checkDuplicateRuleNames(final ShardingSphereDatabase database,
                                                 final Collection<ReadwriteSplittingRuleSegment> segments, final ReadwriteSplittingRuleConfiguration currentRuleConfig, final boolean ifNotExists) {
         checkDuplicateRuleNamesWithSelf(database.getName(), segments);
-        checkDuplicateRuleNamesWithExistsDataSources(database, segments);
+        checkDuplicateRuleNamesWithExistsDataSources(database, ifNotExists ? getNotExistedSegments(segments, currentRuleConfig) : segments);
         if (!ifNotExists) {
             checkDuplicateRuleNamesWithRuleConfiguration(database.getName(), currentRuleConfig, segments);
         }
diff --git a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementCheckerTest.java b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementCheckerTest.java
index d148530299b..5f7d9bedd3c 100644
--- a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementCheckerTest.java
+++ b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementCheckerTest.java
@@ -26,6 +26,9 @@ import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.MissingReq
 import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.MissingRequiredStrategyException;
 import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
 import org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
+import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
+import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
+import org.apache.shardingsphere.infra.rule.attribute.RuleAttributes;
 import org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
 import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
 import org.apache.shardingsphere.infra.util.props.PropertiesBuilder;
@@ -34,6 +37,7 @@ import org.apache.shardingsphere.readwritesplitting.config.ReadwriteSplittingRul
 import org.apache.shardingsphere.readwritesplitting.config.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
 import org.apache.shardingsphere.readwritesplitting.distsql.segment.ReadwriteSplittingRuleSegment;
 import org.apache.shardingsphere.readwritesplitting.exception.actual.DuplicateReadwriteSplittingActualDataSourceException;
+import org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
 import org.apache.shardingsphere.test.infra.framework.extension.mock.AutoMockExtension;
 import org.apache.shardingsphere.test.infra.framework.extension.mock.StaticMockSettings;
 import org.junit.jupiter.api.BeforeEach;
@@ -48,6 +52,8 @@ import org.mockito.Mock;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Properties;
 import java.util.stream.Stream;
 
@@ -55,6 +61,7 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 @ExtendWith(AutoMockExtension.class)
@@ -70,7 +77,7 @@ class ReadwriteSplittingRuleStatementCheckerTest {
     @BeforeEach
     void setUp() {
         when(database.getName()).thenReturn("foo_db");
-        when(database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class)).thenReturn(Collections.emptyList());
+        when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.emptyList()));
         lenient().when(resourceMetaData.getStorageUnits()).thenReturn(Collections.emptyMap());
         lenient().when(resourceMetaData.getNotExistedDataSources(any())).thenReturn(Collections.emptySet());
         when(database.getResourceMetaData()).thenReturn(resourceMetaData);
@@ -130,10 +137,53 @@ class ReadwriteSplittingRuleStatementCheckerTest {
         assertDoesNotThrow(() -> ReadwriteSplittingRuleStatementChecker.checkCreation(database, Collections.singleton(segment), currentRuleConfig, true));
     }
     
+    @Test
+    void assertCheckCreationWithIfNotExistsWhenActualDataSourcesUnchanged() {
+        ReadwriteSplittingRuleSegment segment = new ReadwriteSplittingRuleSegment("foo_rule_0", "write_ds_0", Arrays.asList("read_ds_0", "read_ds_1"), null, null);
+        Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration> dataSourceGroups = Collections.singleton(
+                new ReadwriteSplittingDataSourceGroupRuleConfiguration("foo_rule_0", "write_ds_0", Arrays.asList("read_ds_0", "read_ds_1"), "RANDOM"));
+        ReadwriteSplittingRuleConfiguration currentRuleConfig = new ReadwriteSplittingRuleConfiguration(dataSourceGroups, Collections.emptyMap());
+        assertDoesNotThrow(() -> ReadwriteSplittingRuleStatementChecker.checkCreation(database, Collections.singleton(segment), currentRuleConfig, true));
+    }
+    
+    @Test
+    void assertCheckCreationWithIfNotExistsWhenNewSegmentDuplicatesExistedDataSource() {
+        ReadwriteSplittingRuleSegment existedSegment = new ReadwriteSplittingRuleSegment("foo_rule_0", "write_ds_0", Arrays.asList("read_ds_0", "read_ds_1"), null, null);
+        ReadwriteSplittingRuleSegment newSegment = new ReadwriteSplittingRuleSegment("foo_rule_1", "write_ds_0", Collections.singletonList("read_ds_2"), null, null);
+        Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration> dataSourceGroups = Collections.singleton(
+                new ReadwriteSplittingDataSourceGroupRuleConfiguration("foo_rule_0", "write_ds_0", Arrays.asList("read_ds_0", "read_ds_1"), "RANDOM"));
+        ReadwriteSplittingRuleConfiguration currentRuleConfig = new ReadwriteSplittingRuleConfiguration(dataSourceGroups, Collections.emptyMap());
+        assertThrows(DuplicateReadwriteSplittingActualDataSourceException.class,
+                () -> ReadwriteSplittingRuleStatementChecker.checkCreation(database, Arrays.asList(existedSegment, newSegment), currentRuleConfig, true));
+    }
+    
+    @Test
+    void assertCheckCreationWithIfNotExistsWhenRuleNameExistsInExpandedLogicDataSources() {
+        RuleMetaData ruleMetaData = mockRuleMetaDataWithLogicDataSources(ReadwriteSplittingRule.class, Arrays.asList("rw_0", "rw_1"));
+        when(database.getRuleMetaData()).thenReturn(ruleMetaData);
+        ReadwriteSplittingRuleSegment segment = new ReadwriteSplittingRuleSegment("rw_0", "write_ds_0", Collections.singletonList("read_ds_0"), null, null);
+        Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration> dataSourceGroups = Collections.singleton(
+                new ReadwriteSplittingDataSourceGroupRuleConfiguration("rw_${0..1}", "write_ds_9", Collections.singletonList("read_ds_9"), "RANDOM"));
+        ReadwriteSplittingRuleConfiguration currentRuleConfig = new ReadwriteSplittingRuleConfiguration(dataSourceGroups, Collections.emptyMap());
+        assertThrows(InvalidRuleConfigurationException.class,
+                () -> ReadwriteSplittingRuleStatementChecker.checkCreation(database, Collections.singleton(segment), currentRuleConfig, true));
+    }
+    
+    @Test
+    void assertCheckCreationWithIfNotExistsWhenRuleNameExistsInOwnLogicDataSources() {
+        RuleMetaData ruleMetaData = mockRuleMetaDataWithLogicDataSource(ReadwriteSplittingRule.class, "foo_rule_0");
+        when(database.getRuleMetaData()).thenReturn(ruleMetaData);
+        ReadwriteSplittingRuleSegment segment = new ReadwriteSplittingRuleSegment("foo_rule_0", "write_ds_0", Arrays.asList("read_ds_0", "read_ds_1"), null, null);
+        Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration> dataSourceGroups = Collections.singleton(
+                new ReadwriteSplittingDataSourceGroupRuleConfiguration("foo_rule_0", "write_ds_9", Collections.singletonList("read_ds_9"), "RANDOM"));
+        ReadwriteSplittingRuleConfiguration currentRuleConfig = new ReadwriteSplittingRuleConfiguration(dataSourceGroups, Collections.emptyMap());
+        assertDoesNotThrow(() -> ReadwriteSplittingRuleStatementChecker.checkCreation(database, Collections.singleton(segment), currentRuleConfig, true));
+    }
+    
     @Test
     void assertCheckCreationWithDuplicateRuleNameInLogicDataSources() {
-        DataSourceMapperRuleAttribute ruleAttribute = () -> Collections.singletonMap("foo_rule_0", Collections.singleton("actual_ds_0"));
-        when(database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class)).thenReturn(Collections.singleton(ruleAttribute));
+        RuleMetaData ruleMetaData = mockRuleMetaDataWithLogicDataSource(ShardingSphereRule.class, "foo_rule_0");
+        when(database.getRuleMetaData()).thenReturn(ruleMetaData);
         ReadwriteSplittingRuleSegment segment = new ReadwriteSplittingRuleSegment("foo_rule_0", "write_ds_0", Arrays.asList("read_ds_0", "read_ds_1"), null, null);
         assertThrows(InvalidRuleConfigurationException.class, () -> ReadwriteSplittingRuleStatementChecker.checkCreation(database, Collections.singleton(segment), null, false));
     }
@@ -186,6 +236,24 @@ class ReadwriteSplittingRuleStatementCheckerTest {
         assertThrows(MissingRequiredRuleException.class, () -> ReadwriteSplittingRuleStatementChecker.checkAlteration(database, Collections.singleton(segment), currentRuleConfig));
     }
     
+    private RuleMetaData mockRuleMetaDataWithLogicDataSources(final Class<? extends ShardingSphereRule> ruleClass, final Collection<String> logicDataSourceNames) {
+        ShardingSphereRule rule = mock(ruleClass);
+        Map<String, Collection<String>> dataSourceMapper = new LinkedHashMap<>(logicDataSourceNames.size(), 1F);
+        for (String each : logicDataSourceNames) {
+            dataSourceMapper.put(each, Collections.singleton("actual_ds_0"));
+        }
+        DataSourceMapperRuleAttribute ruleAttribute = () -> dataSourceMapper;
+        lenient().when(rule.getAttributes()).thenReturn(new RuleAttributes(ruleAttribute));
+        return new RuleMetaData(Collections.singleton(rule));
+    }
+    
+    private RuleMetaData mockRuleMetaDataWithLogicDataSource(final Class<? extends ShardingSphereRule> ruleClass, final String logicDataSourceName) {
+        ShardingSphereRule rule = mock(ruleClass);
+        DataSourceMapperRuleAttribute ruleAttribute = () -> Collections.singletonMap(logicDataSourceName, Collections.singleton("actual_ds_0"));
+        lenient().when(rule.getAttributes()).thenReturn(new RuleAttributes(ruleAttribute));
+        return new RuleMetaData(Collections.singleton(rule));
+    }
+    
     private static Stream<Arguments> invalidWeightConfigurationArguments() {
         return Stream.of(
                 Arguments.of("empty weight properties",