This is an automated email from the ASF dual-hosted git repository.
jiangmaolin 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 c613079e5f8 Check weight load balancer props when create
readwrite-splitting rule (#33249)
c613079e5f8 is described below
commit c613079e5f8c7132dedb078d9968e5563015795e
Author: Raigor <[email protected]>
AuthorDate: Tue Oct 15 13:00:48 2024 +0800
Check weight load balancer props when create readwrite-splitting rule
(#33249)
---
.../ReadwriteSplittingRuleStatementChecker.java | 30 +++++++++++++---
.../AlterReadwriteSplittingRuleExecutorTest.java | 40 ++++++++++++++-------
.../CreateReadwriteSplittingRuleExecutorTest.java | 41 ++++++++++++++--------
3 files changed, 79 insertions(+), 32 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 17f69afec6b..894a61dc1c9 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
@@ -20,6 +20,8 @@ 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;
+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.rule.attribute.datasource.DataSourceMappe
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.HashSet;
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 @@ public final class ReadwriteSplittingRuleStatementChecker {
}
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()));
+ }
}
}
diff --git
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutorTest.java
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutorTest.java
index 9db2fe18acb..f8f97d97dd5 100644
---
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutorTest.java
+++
b/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.segment.ReadwriteSpl
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 @@ class AlterReadwriteSplittingRuleExecutorTest {
}
@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,18 +96,18 @@ class AlterReadwriteSplittingRuleExecutorTest {
}
@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);
@@ -112,29 +115,39 @@ class AlterReadwriteSplittingRuleExecutorTest {
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,12 +156,13 @@ class AlterReadwriteSplittingRuleExecutorTest {
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"),
@@ -156,7 +170,7 @@ class AlterReadwriteSplittingRuleExecutorTest {
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"),
diff --git
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java
index f8654c06fe3..f12739e47bd 100644
---
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java
+++
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.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.DuplicateRuleException;
import
org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
@@ -33,6 +34,8 @@ import
org.apache.shardingsphere.readwritesplitting.exception.actual.DuplicateRe
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
import org.apache.shardingsphere.test.mock.AutoMockExtension;
import org.apache.shardingsphere.test.mock.StaticMockSettings;
+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;
@@ -81,7 +84,7 @@ class CreateReadwriteSplittingRuleExecutorTest {
}
@Test
- void assertCheckSQLStatementWithDuplicateResource() {
+ void assertCheckSQLStatementWithDuplicateDataSources() {
when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("write_ds",
null));
ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
@@ -90,13 +93,13 @@ class CreateReadwriteSplittingRuleExecutorTest {
}
@Test
- void assertCheckSQLStatementWithoutExistedResources() {
+ void assertCheckSQLStatementWithNotExistedDataSources() {
when(resourceMetaData.getNotExistedDataSources(any())).thenReturn(Arrays.asList("read_ds_0",
"read_ds_1"));
assertThrows(MissingRequiredStorageUnitsException.class, () ->
executor.checkBeforeUpdate(createSQLStatement("TEST")));
}
@Test
- void assertCheckSQLStatementWithDuplicateLogicResource() {
+ void assertCheckSQLStatementWithDuplicateLogicDataSource() {
DataSourceMapperRuleAttribute ruleAttribute =
mock(DataSourceMapperRuleAttribute.class);
when(ruleAttribute.getDataSourceMapper()).thenReturn(Collections.singletonMap("duplicate_ds",
Collections.singleton("ds_0")));
when(database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class)).thenReturn(Collections.singleton(ruleAttribute));
@@ -107,33 +110,40 @@ class CreateReadwriteSplittingRuleExecutorTest {
}
@Test
- void assertCheckSQLStatementWithDuplicateWriteResourceNamesInStatement() {
+ void assertCheckSQLStatementWithDuplicateWriteDataSourcesInStatement() {
assertThrows(DuplicateReadwriteSplittingActualDataSourceException.class,
- () ->
executor.checkBeforeUpdate(createSQLStatementWithDuplicateWriteResourceNames("write_ds_0",
"write_ds_1", "TEST")));
+ () ->
executor.checkBeforeUpdate(createSQLStatementWithDuplicateWriteDataSources("write_ds_0",
"write_ds_1", "TEST")));
}
@Test
- void assertCheckSQLStatementWithDuplicateWriteResourceNames() {
+ void assertCheckSQLStatementWithDuplicateWriteDataSources() {
ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
executor.setRule(rule);
assertThrows(DuplicateReadwriteSplittingActualDataSourceException.class,
- () ->
executor.checkBeforeUpdate(createSQLStatement("readwrite_ds_1", "ds_write",
Arrays.asList("read_ds_0", "read_ds_1"), "TEST")));
+ () ->
executor.checkBeforeUpdate(createSQLStatement("readwrite_ds_1", "ds_write",
Arrays.asList("read_ds_0", "read_ds_1"), "TEST", new Properties())));
}
@Test
- void assertCheckSQLStatementWithDuplicateReadResourceNamesInStatement() {
+ void assertCheckSQLStatementWithDuplicateReadDataSourcesInStatement() {
assertThrows(DuplicateReadwriteSplittingActualDataSourceException.class,
- () ->
executor.checkBeforeUpdate(createSQLStatementWithDuplicateReadResourceNames("write_ds_0",
"write_ds_1", "TEST")));
+ () ->
executor.checkBeforeUpdate(createSQLStatementWithDuplicateReadDataSources("write_ds_0",
"write_ds_1", "TEST")));
}
@Test
- void assertCheckSQLStatementWithDuplicateReadResourceNames() {
+ void assertCheckSQLStatementWithDuplicateReadDataSources() {
ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
executor.setRule(rule);
assertThrows(DuplicateReadwriteSplittingActualDataSourceException.class,
- () ->
executor.checkBeforeUpdate(createSQLStatement("readwrite_ds_1", "write_ds_1",
Arrays.asList("read_ds_0", "read_ds_1"), "TEST")));
+ () ->
executor.checkBeforeUpdate(createSQLStatement("readwrite_ds_1", "write_ds_1",
Arrays.asList("read_ds_0", "read_ds_1"), "TEST", new Properties())));
+ }
+
+ @Test
+ void assertCheckSQLStatementWithInvalidLoadBalancerProperties() {
+ assertThrows(InvalidAlgorithmConfigurationException.class,
+ () ->
executor.checkBeforeUpdate(createSQLStatement("readwrite_group", "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")))));
}
@Test
@@ -172,15 +182,16 @@ class CreateReadwriteSplittingRuleExecutorTest {
new AlgorithmSegment(loadBalancerName, new Properties())));
}
- private CreateReadwriteSplittingRuleStatement createSQLStatement(final
String ruleName, final String writeDataSource, final Collection<String>
readDataSources, final String loadBalancerName) {
- return createSQLStatement(false, new
ReadwriteSplittingRuleSegment(ruleName, writeDataSource, readDataSources, new
AlgorithmSegment(loadBalancerName, new Properties())));
+ private CreateReadwriteSplittingRuleStatement createSQLStatement(final
String ruleName, final String writeDataSource, final Collection<String>
readDataSources,
+ final
String loadBalancerName, final Properties props) {
+ return createSQLStatement(false, new
ReadwriteSplittingRuleSegment(ruleName, writeDataSource, readDataSources, new
AlgorithmSegment(loadBalancerName, props)));
}
private CreateReadwriteSplittingRuleStatement createSQLStatement(final
boolean ifNotExists, final ReadwriteSplittingRuleSegment... ruleSegments) {
return new CreateReadwriteSplittingRuleStatement(ifNotExists,
Arrays.asList(ruleSegments));
}
- private CreateReadwriteSplittingRuleStatement
createSQLStatementWithDuplicateWriteResourceNames(final String ruleName0, final
String ruleName1, final String loadBalancerName) {
+ private CreateReadwriteSplittingRuleStatement
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"),
@@ -188,7 +199,7 @@ class CreateReadwriteSplittingRuleExecutorTest {
return createSQLStatement(false, ruleSegment0, ruleSegment1);
}
- private CreateReadwriteSplittingRuleStatement
createSQLStatementWithDuplicateReadResourceNames(final String ruleName0, final
String ruleName1, final String loadBalancerName) {
+ private CreateReadwriteSplittingRuleStatement
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"),
