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

zhangliang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git


The following commit(s) were added to refs/heads/master by this push:
     new 772e661969f Remove unreached codes on 
ReadwriteSplittingRuleStatementChecker (#38258)
772e661969f is described below

commit 772e661969f9e44caef31979cb76b92947009bc9
Author: Liang Zhang <[email protected]>
AuthorDate: Sat Feb 28 01:03:46 2026 +0800

    Remove unreached codes on ReadwriteSplittingRuleStatementChecker (#38258)
---
 .../ReadwriteSplittingRuleStatementChecker.java    | 12 +-----
 ...ReadwriteSplittingRuleStatementCheckerTest.java | 46 ++++++++--------------
 2 files changed, 19 insertions(+), 39 deletions(-)

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 002bb7d5910..51a981b8acf 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
@@ -17,7 +17,6 @@
 
 package org.apache.shardingsphere.readwritesplitting.distsql.handler.checker;
 
-import com.google.common.base.Strings;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.distsql.segment.AlgorithmSegment;
@@ -120,9 +119,7 @@ public final class ReadwriteSplittingRuleStatementChecker {
     private static void checkDuplicateRuleNamesWithExistsDataSources(final 
ShardingSphereDatabase database, final 
Collection<ReadwriteSplittingRuleSegment> segments) {
         Collection<String> currentRuleNames = new HashSet<>();
         ResourceMetaData resourceMetaData = database.getResourceMetaData();
-        if (null != resourceMetaData && null != 
resourceMetaData.getStorageUnits()) {
-            
currentRuleNames.addAll(resourceMetaData.getStorageUnits().keySet());
-        }
+        currentRuleNames.addAll(resourceMetaData.getStorageUnits().keySet());
         currentRuleNames.addAll(getLogicDataSources(database));
         Collection<String> toBeCreatedRuleNames = 
segments.stream().map(ReadwriteSplittingRuleSegment::getName).filter(currentRuleNames::contains).collect(Collectors.toList());
         ShardingSpherePreconditions.checkMustEmpty(toBeCreatedRuleNames, () -> 
new InvalidRuleConfigurationException("Readwrite-splitting", 
toBeCreatedRuleNames,
@@ -182,9 +179,6 @@ public final class ReadwriteSplittingRuleStatementChecker {
     private static void checkDuplicateWriteDataSourceNames(final 
Collection<ReadwriteSplittingRuleSegment> segments, final String databaseName,
                                                            final 
Collection<String> writeDataSourceNames) {
         for (ReadwriteSplittingRuleSegment each : segments) {
-            if (Strings.isNullOrEmpty(each.getWriteDataSource())) {
-                continue;
-            }
             String writeDataSource = each.getWriteDataSource();
             
ShardingSpherePreconditions.checkState(writeDataSourceNames.add(writeDataSource),
 () -> new DuplicateReadwriteSplittingActualDataSourceException(
                     ReadwriteSplittingDataSourceType.WRITE, writeDataSource, 
new ReadwriteSplittingRuleExceptionIdentifier(databaseName, "")));
@@ -194,9 +188,7 @@ public final class ReadwriteSplittingRuleStatementChecker {
     private static void checkDuplicateReadDataSourceNames(final 
Collection<ReadwriteSplittingRuleSegment> segments, final String databaseName,
                                                           final 
Collection<String> readDataSourceNames) {
         for (ReadwriteSplittingRuleSegment each : segments) {
-            if (null != each.getReadDataSources()) {
-                checkDuplicateReadDataSourceNames(each, databaseName, 
readDataSourceNames);
-            }
+            checkDuplicateReadDataSourceNames(each, databaseName, 
readDataSourceNames);
         }
     }
     
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 85f0b268424..6b60f291196 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
@@ -51,7 +51,6 @@ 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)
@@ -81,28 +80,17 @@ class ReadwriteSplittingRuleStatementCheckerTest {
         assertThrows(DuplicateRuleException.class, () -> 
ReadwriteSplittingRuleStatementChecker.checkCreation(database, segments, null, 
false));
     }
     
-    @Test
-    void assertCheckCreationWithNullStorageUnits() {
-        when(resourceMetaData.getStorageUnits()).thenReturn(null);
-        ReadwriteSplittingRuleSegment segment = new 
ReadwriteSplittingRuleSegment("foo_rule_0", "write_ds_0", 
Arrays.asList("read_ds_0", "read_ds_1"), null, null);
-        assertDoesNotThrow(() -> 
ReadwriteSplittingRuleStatementChecker.checkCreation(database, 
Collections.singleton(segment), null, false));
-    }
-    
-    @Test
-    void assertCheckCreationWithEmptyWriteDataSource() {
-        ReadwriteSplittingRuleSegment segment = new 
ReadwriteSplittingRuleSegment("foo_rule_0", "", 
Collections.singleton("read_ds_0"), null, null);
-        assertDoesNotThrow(() -> 
ReadwriteSplittingRuleStatementChecker.checkCreation(database, 
Collections.singleton(segment), null, false));
-    }
-    
     @Test
     void assertCheckCreationWithInvalidTransactionalReadQueryStrategy() {
-        ReadwriteSplittingRuleSegment segment = new 
ReadwriteSplittingRuleSegment("foo_rule_0", "write_ds_0", 
Arrays.asList("read_ds_0", "read_ds_1"), "invalid", null);
+        ReadwriteSplittingRuleSegment segment = new 
ReadwriteSplittingRuleSegment("foo_rule_0", "write_ds_0", 
createReadDataSources(), "invalid", null);
         assertThrows(MissingRequiredStrategyException.class, () -> 
ReadwriteSplittingRuleStatementChecker.checkCreation(database, 
Collections.singleton(segment), null, false));
     }
     
-    @Test
-    void assertCheckCreationWithValidTransactionalReadQueryStrategy() {
-        ReadwriteSplittingRuleSegment segment = new 
ReadwriteSplittingRuleSegment("foo_rule_0", "write_ds_0", 
Arrays.asList("read_ds_0", "read_ds_1"), "primary", null);
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("validTransactionalReadQueryStrategyArguments")
+    void assertCheckCreationWithValidTransactionalReadQueryStrategy(final 
String name, final String transactionalReadQueryStrategy) {
+        ReadwriteSplittingRuleSegment segment = new 
ReadwriteSplittingRuleSegment("foo_rule_0", "write_ds_0",
+                Arrays.asList("read_ds_0", "read_ds_1"), 
transactionalReadQueryStrategy, null);
         assertDoesNotThrow(() -> 
ReadwriteSplittingRuleStatementChecker.checkCreation(database, 
Collections.singleton(segment), null, false));
     }
     
@@ -119,17 +107,6 @@ class ReadwriteSplittingRuleStatementCheckerTest {
         assertDoesNotThrow(() -> 
ReadwriteSplittingRuleStatementChecker.checkCreation(database, 
Collections.singleton(segment), null, false));
     }
     
-    @Test
-    void assertCheckCreationWithNullReadDataSourcesForDuplicateCheck() {
-        ReadwriteSplittingRuleSegment segment = 
mock(ReadwriteSplittingRuleSegment.class);
-        when(segment.getName()).thenReturn("foo_rule_0");
-        when(segment.getWriteDataSource()).thenReturn("write_ds_0");
-        
when(segment.getReadDataSources()).thenReturn(Collections.singleton("read_ds_0")).thenReturn(null);
-        when(segment.getTransactionalReadQueryStrategy()).thenReturn(null);
-        when(segment.getLoadBalancer()).thenReturn(null);
-        assertDoesNotThrow(() -> 
ReadwriteSplittingRuleStatementChecker.checkCreation(database, 
Collections.singleton(segment), null, false));
-    }
-    
     @Test
     void assertCheckAlteration() {
         ReadwriteSplittingRuleSegment segment = new 
ReadwriteSplittingRuleSegment("foo_rule_0", "write_ds_0", 
Arrays.asList("read_ds_0", "read_ds_1"), null, null);
@@ -152,4 +129,15 @@ class ReadwriteSplittingRuleStatementCheckerTest {
                         new ReadwriteSplittingRuleSegment("foo_rule_0", 
"write_ds_0", Arrays.asList("read_ds_0", "read_ds_1"), null,
                                 new AlgorithmSegment("weight", 
PropertiesBuilder.build(new Property("read_ds_0", "1"))))));
     }
+    
+    private static Stream<Arguments> 
validTransactionalReadQueryStrategyArguments() {
+        return Stream.of(
+                Arguments.of("lowercase strategy", "primary"),
+                Arguments.of("uppercase strategy", "PRIMARY"),
+                Arguments.of("mixed-case strategy", "PrImArY"));
+    }
+    
+    private static Collection<String> createReadDataSources() {
+        return Arrays.asList("read_ds_0", "read_ds_1");
+    }
 }

Reply via email to