Pick fix commits in 5.5.1-fix from apache (#27)

* Pick 5.5.0-fix #15, optimize the rollback strategy for import database config failed

* Pick #33248, Check weight load balancer props when create readwrite-splitting rule

* Pick #33274, Add query parameters and check for mysql kill processId

* Pick #33367, Remove ShardingRouteAlgorithmException check logic temporarily to support different actual table name config

* Pick #33346, Fix missing logic db when query information_schema.SCHEMATA with NOT IN clause

* Pick #33370, Fix table does not exist exception when use HintManager#setDatabaseName to transparent

Author: RaigorJiang

features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementChecker.java

@@ -20,6 +20,8 @@
 import com.google.common.base.Strings;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
+import org.apache.shardingsphere.distsql.segment.AlgorithmSegment;
+import org.apache.shardingsphere.infra.algorithm.core.exception.InvalidAlgorithmConfigurationException;
 import org.apache.shardingsphere.infra.algorithm.loadbalancer.core.LoadBalanceAlgorithm;
 import org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
 import org.apache.shardingsphere.infra.exception.kernel.metadata.resource.storageunit.MissingRequiredStorageUnitsException;
@@ -33,11 +35,11 @@
 import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
 import org.apache.shardingsphere.readwritesplitting.config.ReadwriteSplittingRuleConfiguration;
 import org.apache.shardingsphere.readwritesplitting.config.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
-import org.apache.shardingsphere.readwritesplitting.transaction.TransactionalReadQueryStrategy;
 import org.apache.shardingsphere.readwritesplitting.constant.ReadwriteSplittingDataSourceType;
 import org.apache.shardingsphere.readwritesplitting.distsql.segment.ReadwriteSplittingRuleSegment;
 import org.apache.shardingsphere.readwritesplitting.exception.ReadwriteSplittingRuleExceptionIdentifier;
 import org.apache.shardingsphere.readwritesplitting.exception.actual.DuplicateReadwriteSplittingActualDataSourceException;
+import org.apache.shardingsphere.readwritesplitting.transaction.TransactionalReadQueryStrategy;
 
 import java.util.Arrays;
 import java.util.Collection;
@@ -46,7 +48,6 @@
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.Map.Entry;
-import java.util.Objects;
 import java.util.stream.Collectors;
 
 /**
@@ -218,7 +219,28 @@ private static void checkTransactionalReadQueryStrategy(final Collection<Readwri
     }
 
     private static void checkLoadBalancers(final Collection<ReadwriteSplittingRuleSegment> segments) {
-        segments.stream().map(ReadwriteSplittingRuleSegment::getLoadBalancer).filter(Objects::nonNull)
-                .forEach(each -> TypedSPILoader.checkService(LoadBalanceAlgorithm.class, each.getName(), each.getProps()));
+        for (ReadwriteSplittingRuleSegment each : segments) {
+            AlgorithmSegment loadBalancer = each.getLoadBalancer();
+            if (loadBalancer != null) {
+                TypedSPILoader.checkService(LoadBalanceAlgorithm.class, loadBalancer.getName(), loadBalancer.getProps());
+                checkProperties(each);
+            }
+        }
+    }
+    
+    private static void checkProperties(final ReadwriteSplittingRuleSegment each) {
+        if ("WEIGHT".equalsIgnoreCase(each.getLoadBalancer().getName())) {
+            ShardingSpherePreconditions.checkNotEmpty(each.getLoadBalancer().getProps(),
+                    () -> new InvalidAlgorithmConfigurationException("Load balancer", each.getLoadBalancer().getName()));
+            checkDataSource(each);
+        }
+    }
+    
+    private static void checkDataSource(final ReadwriteSplittingRuleSegment ruleSegment) {
+        for (Object each : ruleSegment.getLoadBalancer().getProps().keySet()) {
+            String dataSourceName = (String) each;
+            ShardingSpherePreconditions.checkState(ruleSegment.getReadDataSources().contains(dataSourceName) || ruleSegment.getWriteDataSource().equals(dataSourceName),
+                    () -> new InvalidAlgorithmConfigurationException("Load balancer", ruleSegment.getLoadBalancer().getName()));
+        }
     }
 }

features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutorTest.java

@@ -18,6 +18,7 @@
 package org.apache.shardingsphere.readwritesplitting.distsql.handler.update;
 
 import org.apache.shardingsphere.distsql.segment.AlgorithmSegment;
+import org.apache.shardingsphere.infra.algorithm.core.exception.InvalidAlgorithmConfigurationException;
 import org.apache.shardingsphere.infra.exception.kernel.metadata.resource.storageunit.MissingRequiredStorageUnitsException;
 import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.MissingRequiredRuleException;
 import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
@@ -29,6 +30,8 @@
 import org.apache.shardingsphere.readwritesplitting.distsql.statement.AlterReadwriteSplittingRuleStatement;
 import org.apache.shardingsphere.readwritesplitting.exception.actual.DuplicateReadwriteSplittingActualDataSourceException;
 import org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
+import org.apache.shardingsphere.test.util.PropertiesBuilder;
+import org.apache.shardingsphere.test.util.PropertiesBuilder.Property;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -74,7 +77,7 @@ void assertCheckSQLStatementWithoutToBeAlteredRules() {
     }
 
     @Test
-    void assertCheckSQLStatementWithoutExistedResources() {
+    void assertCheckSQLStatementWithNotExistedDataSources() {
         when(resourceMetaData.getNotExistedDataSources(any())).thenReturn(Collections.singleton("read_ds_0"));
         ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
         when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
@@ -93,48 +96,58 @@ void assertCheckSQLStatementWithoutToBeAlteredLoadBalancers() {
     }
 
     @Test
-    void assertCheckSQLStatementWithDuplicateWriteResourceNamesInStatement() {
+    void assertCheckSQLStatementWithDuplicateWriteDataSourcesInStatement() {
         ShardingSphereDatabase database = mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
         when(database.getResourceMetaData()).thenReturn(resourceMetaData);
         ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
         when(rule.getConfiguration()).thenReturn(createCurrentRuleConfigurationWithMultipleRules());
         executor.setRule(rule);
         assertThrows(DuplicateReadwriteSplittingActualDataSourceException.class,
-                () -> executor.checkBeforeUpdate(createSQLStatementWithDuplicateWriteResourceNames("readwrite_ds_0", "readwrite_ds_1", "TEST")));
+                () -> executor.checkBeforeUpdate(createSQLStatementWithDuplicateWriteDataSources("readwrite_ds_0", "readwrite_ds_1", "TEST")));
     }
 
     @Test
-    void assertCheckSQLStatementWithDuplicateWriteResourceNames() {
+    void assertCheckSQLStatementWithDuplicateWriteDataSources() {
         ShardingSphereDatabase database = mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
         when(database.getResourceMetaData()).thenReturn(resourceMetaData);
         ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
         when(rule.getConfiguration()).thenReturn(createCurrentRuleConfigurationWithMultipleRules());
         executor.setRule(rule);
         assertThrows(DuplicateReadwriteSplittingActualDataSourceException.class,
                 () -> executor.checkBeforeUpdate(
-                        createSQLStatement("readwrite_ds_0", "ds_write_1", Arrays.asList("read_ds_0", "read_ds_1"), "TEST")));
+                        createSQLStatement("readwrite_ds_0", "ds_write_1", Arrays.asList("read_ds_0", "read_ds_1"), "TEST", new Properties())));
     }
 
     @Test
-    void assertCheckSQLStatementWithDuplicateReadResourceNamesInStatement() {
+    void assertCheckSQLStatementWithDuplicateReadDataSourcesInStatement() {
         ShardingSphereDatabase database = mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
         when(database.getResourceMetaData()).thenReturn(resourceMetaData);
         ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
         when(rule.getConfiguration()).thenReturn(createCurrentRuleConfigurationWithMultipleRules());
         executor.setRule(rule);
         assertThrows(DuplicateReadwriteSplittingActualDataSourceException.class,
-                () -> executor.checkBeforeUpdate(createSQLStatementWithDuplicateReadResourceNames("readwrite_ds_0", "readwrite_ds_1", "TEST")));
+                () -> executor.checkBeforeUpdate(createSQLStatementWithDuplicateReadDataSources("readwrite_ds_0", "readwrite_ds_1", "TEST")));
     }
 
     @Test
-    void assertCheckSQLStatementWithDuplicateReadResourceNames() {
+    void assertCheckSQLStatementWithDuplicateReadDataSources() {
         ShardingSphereDatabase database = mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
         when(database.getResourceMetaData()).thenReturn(resourceMetaData);
         ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
         when(rule.getConfiguration()).thenReturn(createCurrentRuleConfigurationWithMultipleRules());
         executor.setRule(rule);
         assertThrows(DuplicateReadwriteSplittingActualDataSourceException.class,
-                () -> executor.checkBeforeUpdate(createSQLStatement("readwrite_ds_1", "write_ds_1", Arrays.asList("read_ds_0_0", "read_ds_0_1"), "TEST")));
+                () -> executor.checkBeforeUpdate(createSQLStatement("readwrite_ds_1", "write_ds_1", Arrays.asList("read_ds_0_0", "read_ds_0_1"), "TEST", new Properties())));
+    }
+    
+    @Test
+    void assertCheckSQLStatementWithInvalidLoadBalancerProperties() {
+        ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
+        when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
+        executor.setRule(rule);
+        assertThrows(InvalidAlgorithmConfigurationException.class,
+                () -> executor.checkBeforeUpdate(createSQLStatement("readwrite_ds", "write_ds", Arrays.asList("read_ds_0", "read_ds_1"), "weight",
+                        PropertiesBuilder.build(new Property("read_ds_0", "5"), new Property("read_ds_2", "5")))));
     }
 
     private AlterReadwriteSplittingRuleStatement createSQLStatement(final String loadBalancerTypeName) {
@@ -143,20 +156,21 @@ private AlterReadwriteSplittingRuleStatement createSQLStatement(final String loa
         return new AlterReadwriteSplittingRuleStatement(Collections.singleton(ruleSegment));
     }
 
-    private AlterReadwriteSplittingRuleStatement createSQLStatement(final String ruleName, final String writeDataSource, final Collection<String> readDataSources, final String loadBalancerName) {
-        ReadwriteSplittingRuleSegment ruleSegment = new ReadwriteSplittingRuleSegment(ruleName, writeDataSource, readDataSources, new AlgorithmSegment(loadBalancerName, new Properties()));
+    private AlterReadwriteSplittingRuleStatement createSQLStatement(final String ruleName, final String writeDataSource, final Collection<String> readDataSources,
+                                                                    final String loadBalancerName, final Properties props) {
+        ReadwriteSplittingRuleSegment ruleSegment = new ReadwriteSplittingRuleSegment(ruleName, writeDataSource, readDataSources, new AlgorithmSegment(loadBalancerName, props));
         return new AlterReadwriteSplittingRuleStatement(Collections.singleton(ruleSegment));
     }
 
-    private AlterReadwriteSplittingRuleStatement createSQLStatementWithDuplicateWriteResourceNames(final String ruleName0, final String ruleName1, final String loadBalancerName) {
+    private AlterReadwriteSplittingRuleStatement createSQLStatementWithDuplicateWriteDataSources(final String ruleName0, final String ruleName1, final String loadBalancerName) {
         ReadwriteSplittingRuleSegment ruleSegment0 = new ReadwriteSplittingRuleSegment(ruleName0, "write_ds", Arrays.asList("read_ds_0", "read_ds_1"),
                 new AlgorithmSegment(loadBalancerName, new Properties()));
         ReadwriteSplittingRuleSegment ruleSegment1 = new ReadwriteSplittingRuleSegment(ruleName1, "write_ds", Arrays.asList("read_ds_2", "read_ds_3"),
                 new AlgorithmSegment(loadBalancerName, new Properties()));
         return new AlterReadwriteSplittingRuleStatement(Arrays.asList(ruleSegment0, ruleSegment1));
     }
 
-    private AlterReadwriteSplittingRuleStatement createSQLStatementWithDuplicateReadResourceNames(final String ruleName0, final String ruleName1, final String loadBalancerName) {
+    private AlterReadwriteSplittingRuleStatement createSQLStatementWithDuplicateReadDataSources(final String ruleName0, final String ruleName1, final String loadBalancerName) {
         ReadwriteSplittingRuleSegment ruleSegment0 = new ReadwriteSplittingRuleSegment(ruleName0, "write_ds_0", Arrays.asList("read_ds_0", "read_ds_1"),
                 new AlgorithmSegment(loadBalancerName, new Properties()));
         ReadwriteSplittingRuleSegment ruleSegment1 = new ReadwriteSplittingRuleSegment(ruleName1, "write_ds_1", Arrays.asList("read_ds_0", "read_ds_1"),