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 6b491278bb1 Refactor LoadSingleTableExecutorTest (#33101)
6b491278bb1 is described below
commit 6b491278bb1e039e37e67bf2ed2fa1c9022ead47
Author: Liang Zhang <[email protected]>
AuthorDate: Wed Oct 2 23:15:16 2024 +0800
Refactor LoadSingleTableExecutorTest (#33101)
* Refactor LoadSingleTableExecutorTest
* Refactor LoadSingleTableExecutorTest
---
.../handler/update/LoadSingleTableExecutor.java | 79 ++++++-------
.../update/LoadSingleTableExecutorTest.java | 128 ++++++++++++++-------
...tDefaultSingleTableStorageUnitExecutorTest.java | 6 +-
3 files changed, 128 insertions(+), 85 deletions(-)
diff --git
a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutor.java
b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutor.java
index 1679b96875d..8eef49fa8d1 100644
---
a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutor.java
+++
b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutor.java
@@ -30,7 +30,6 @@ import
org.apache.shardingsphere.infra.exception.kernel.metadata.resource.storag
import
org.apache.shardingsphere.infra.exception.kernel.metadata.resource.storageunit.InvalidStorageUnitStatusException;
import
org.apache.shardingsphere.infra.exception.kernel.metadata.resource.storageunit.MissingRequiredStorageUnitsException;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
import
org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
import org.apache.shardingsphere.single.config.SingleRuleConfiguration;
@@ -60,27 +59,44 @@ public final class LoadSingleTableExecutor implements
DatabaseRuleCreateExecutor
@Override
public void checkBeforeUpdate(final LoadSingleTableStatement sqlStatement)
{
- checkStorageUnits(sqlStatement);
+ Collection<String> storageUnitNames =
getStorageUnitNames(sqlStatement);
+ if (!storageUnitNames.isEmpty()) {
+ checkShouldExistStorageUnits(storageUnitNames);
+ }
String defaultSchemaName = new
DatabaseTypeRegistry(database.getProtocolType()).getDefaultSchemaName(database.getName());
- checkDuplicatedTables(sqlStatement, defaultSchemaName);
- checkActualTableExist(sqlStatement, defaultSchemaName);
+ checkShouldNotExistLogicTables(sqlStatement, defaultSchemaName);
+ if (!storageUnitNames.isEmpty()) {
+ checkShouldExistActualTables(sqlStatement, storageUnitNames,
defaultSchemaName);
+ }
+ }
+
+ private Collection<String> getStorageUnitNames(final
LoadSingleTableStatement sqlStatement) {
+ return
sqlStatement.getTables().stream().map(SingleTableSegment::getStorageUnitName).filter(each
-> !SingleTableConstants.ASTERISK.equals(each)).collect(Collectors.toSet());
}
- private void checkDuplicatedTables(final LoadSingleTableStatement
sqlStatement, final String defaultSchemaName) {
+ private void checkShouldExistStorageUnits(final Collection<String>
storageUnitNames) {
+
ShardingSpherePreconditions.checkNotEmpty(database.getResourceMetaData().getStorageUnits(),
() -> new EmptyStorageUnitException(database.getName()));
+ Collection<String> notExistedStorageUnitNames =
database.getResourceMetaData().getNotExistedDataSources(storageUnitNames);
+ Collection<String> logicDataSourceNames =
database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class).stream()
+ .flatMap(each ->
each.getDataSourceMapper().keySet().stream()).collect(Collectors.toSet());
+ notExistedStorageUnitNames.removeIf(logicDataSourceNames::contains);
+ ShardingSpherePreconditions.checkMustEmpty(notExistedStorageUnitNames,
() -> new MissingRequiredStorageUnitsException(database.getName(),
notExistedStorageUnitNames));
+ }
+
+ private void checkShouldNotExistLogicTables(final LoadSingleTableStatement
sqlStatement, final String defaultSchemaName) {
Collection<SingleTableSegment> tableSegments =
sqlStatement.getTables();
DialectDatabaseMetaData dialectDatabaseMetaData = new
DatabaseTypeRegistry(database.getProtocolType()).getDialectDatabaseMetaData();
boolean isSchemaSupportedDatabaseType =
dialectDatabaseMetaData.getDefaultSchema().isPresent();
ShardingSphereSchema schema = database.getSchema(defaultSchemaName);
for (SingleTableSegment each : tableSegments) {
- checkDatabaseTypeAndTableNodeStyle(isSchemaSupportedDatabaseType,
each);
- if (SingleTableConstants.ASTERISK.equals(each.getTableName())) {
- continue;
+ checkTableNodeFormat(isSchemaSupportedDatabaseType, each);
+ if (!SingleTableConstants.ASTERISK.equals(each.getTableName())) {
+
ShardingSpherePreconditions.checkState(!schema.containsTable(each.getTableName()),
() -> new TableExistsException(each.getTableName()));
}
-
ShardingSpherePreconditions.checkState(!schema.containsTable(each.getTableName()),
() -> new TableExistsException(each.getTableName()));
}
}
- private void checkDatabaseTypeAndTableNodeStyle(final boolean
isSchemaSupportedDatabaseType, final SingleTableSegment singleTableSegment) {
+ private void checkTableNodeFormat(final boolean
isSchemaSupportedDatabaseType, final SingleTableSegment singleTableSegment) {
if
(SingleTableConstants.ALL_TABLES.equals(singleTableSegment.toString()) ||
SingleTableConstants.ALL_SCHEMA_TABLES.equals(singleTableSegment.toString())) {
return;
}
@@ -93,31 +109,14 @@ public final class LoadSingleTableExecutor implements
DatabaseRuleCreateExecutor
}
}
- private void checkStorageUnits(final LoadSingleTableStatement
sqlStatement) {
-
ShardingSpherePreconditions.checkNotEmpty(database.getResourceMetaData().getStorageUnits(),
() -> new EmptyStorageUnitException(database.getName()));
- Collection<String> requiredDataSources =
getRequiredDataSources(sqlStatement);
- if (requiredDataSources.isEmpty()) {
- return;
- }
- Collection<String> notExistedDataSources =
database.getResourceMetaData().getNotExistedDataSources(requiredDataSources);
- Collection<String> logicDataSources =
database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class).stream()
- .flatMap(each ->
each.getDataSourceMapper().keySet().stream()).collect(Collectors.toSet());
- notExistedDataSources.removeIf(logicDataSources::contains);
- ShardingSpherePreconditions.checkMustEmpty(notExistedDataSources, ()
-> new MissingRequiredStorageUnitsException(database.getName(),
notExistedDataSources));
- }
-
- private void checkActualTableExist(final LoadSingleTableStatement
sqlStatement, final String defaultSchemaName) {
- Collection<String> requiredDataSources =
getRequiredDataSources(sqlStatement);
- if (requiredDataSources.isEmpty()) {
- return;
- }
- ResourceMetaData resourceMetaData = database.getResourceMetaData();
- Map<String, DataSource> aggregateDataSourceMap =
SingleTableLoadUtils.getAggregatedDataSourceMap(
-
resourceMetaData.getStorageUnits().entrySet().stream().collect(Collectors.toMap(Entry::getKey,
entry -> entry.getValue().getDataSource())),
database.getRuleMetaData().getRules());
- Collection<String> invalidDataSources =
requiredDataSources.stream().filter(each ->
!aggregateDataSourceMap.containsKey(each)).collect(Collectors.toList());
+ private void checkShouldExistActualTables(final LoadSingleTableStatement
sqlStatement, final Collection<String> storageUnitNames, final String
defaultSchemaName) {
+ Map<String, DataSource> dataSourceMap =
database.getResourceMetaData().getStorageUnits().entrySet()
+ .stream().collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSource()));
+ Map<String, DataSource> aggregatedDataSourceMap =
SingleTableLoadUtils.getAggregatedDataSourceMap(dataSourceMap,
database.getRuleMetaData().getRules());
+ Collection<String> invalidDataSources =
storageUnitNames.stream().filter(each ->
!aggregatedDataSourceMap.containsKey(each)).collect(Collectors.toList());
ShardingSpherePreconditions.checkState(invalidDataSources.isEmpty(),
() -> new InvalidStorageUnitStatusException(String.format("`%s` is invalid,
please use `%s`",
- String.join(",", invalidDataSources), String.join(",",
aggregateDataSourceMap.keySet()))));
- Map<String, Map<String, Collection<String>>> actualTableNodes =
getActualTableNodes(requiredDataSources, aggregateDataSourceMap);
+ String.join(",", invalidDataSources), String.join(",",
aggregatedDataSourceMap.keySet()))));
+ Map<String, Map<String, Collection<String>>> actualTableNodes =
getActualTableNodes(storageUnitNames, aggregatedDataSourceMap);
for (SingleTableSegment each : sqlStatement.getTables()) {
String tableName = each.getTableName();
if (!SingleTableConstants.ASTERISK.equals(tableName)) {
@@ -128,14 +127,10 @@ public final class LoadSingleTableExecutor implements
DatabaseRuleCreateExecutor
}
}
- private Collection<String> getRequiredDataSources(final
LoadSingleTableStatement sqlStatement) {
- return
sqlStatement.getTables().stream().map(SingleTableSegment::getStorageUnitName).filter(each
-> !SingleTableConstants.ASTERISK.equals(each)).collect(Collectors.toSet());
- }
-
- private Map<String, Map<String, Collection<String>>>
getActualTableNodes(final Collection<String> requiredDataSources, final
Map<String, DataSource> aggregateDataSourceMap) {
- Map<String, Map<String, Collection<String>>> result = new
LinkedHashMap<>(requiredDataSources.size(), 1F);
- for (String each : requiredDataSources) {
- DataSource dataSource = aggregateDataSourceMap.get(each);
+ private Map<String, Map<String, Collection<String>>>
getActualTableNodes(final Collection<String> storageUnitNames, final
Map<String, DataSource> aggregatedDataSourceMap) {
+ Map<String, Map<String, Collection<String>>> result = new
LinkedHashMap<>(storageUnitNames.size(), 1F);
+ for (String each : storageUnitNames) {
+ DataSource dataSource = aggregatedDataSourceMap.get(each);
Map<String, Collection<String>> schemaTableNames =
SingleTableDataNodeLoader.loadSchemaTableNames(database.getName(),
DatabaseTypeEngine.getStorageType(dataSource), dataSource, each);
if (!schemaTableNames.isEmpty()) {
result.put(each, schemaTableNames);
diff --git
a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutorTest.java
b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutorTest.java
index 5a90b41f4af..2d7adb810bf 100644
---
a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutorTest.java
+++
b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutorTest.java
@@ -17,42 +17,58 @@
package org.apache.shardingsphere.single.distsql.handler.update;
+import
org.apache.shardingsphere.distsql.handler.engine.update.DistSQLUpdateExecuteEngine;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
+import org.apache.shardingsphere.infra.datanode.DataNode;
import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.table.TableExistsException;
-import
org.apache.shardingsphere.infra.exception.kernel.metadata.resource.storageunit.EmptyStorageUnitException;
+import
org.apache.shardingsphere.infra.exception.kernel.metadata.TableNotFoundException;
+import
org.apache.shardingsphere.infra.exception.kernel.metadata.datanode.InvalidDataNodeFormatException;
import
org.apache.shardingsphere.infra.exception.kernel.metadata.resource.storageunit.MissingRequiredStorageUnitsException;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnit;
+import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
+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.mode.manager.ContextManager;
+import
org.apache.shardingsphere.mode.persist.service.MetaDataManagerPersistService;
import org.apache.shardingsphere.single.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.datanode.SingleTableDataNodeLoader;
import org.apache.shardingsphere.single.distsql.segment.SingleTableSegment;
import
org.apache.shardingsphere.single.distsql.statement.rdl.LoadSingleTableStatement;
import org.apache.shardingsphere.single.rule.SingleRule;
+import org.apache.shardingsphere.single.util.SingleTableLoadUtils;
+import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
+import org.apache.shardingsphere.test.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.mock.StaticMockSettings;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+import java.sql.SQLException;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
-import java.util.Iterator;
import java.util.LinkedList;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-@ExtendWith(MockitoExtension.class)
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings({SingleTableDataNodeLoader.class,
SingleTableLoadUtils.class})
+@MockitoSettings(strictness = Strictness.LENIENT)
class LoadSingleTableExecutorTest {
- private final LoadSingleTableExecutor executor = new
LoadSingleTableExecutor();
-
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private ShardingSphereDatabase database;
@@ -61,59 +77,93 @@ class LoadSingleTableExecutorTest {
@BeforeEach
void setUp() {
+ when(database.getName()).thenReturn("foo_db");
when(database.getProtocolType()).thenReturn(TypedSPILoader.getService(DatabaseType.class,
"FIXTURE"));
when(database.getSchema("foo_db")).thenReturn(schema);
when(database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class)).thenReturn(Collections.emptyList());
}
+ private ContextManager mockContextManager(final SingleRule rule) {
+ ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
+ when(result.getDatabase("foo_db")).thenReturn(database);
+ if (null == rule) {
+ when(database.getRuleMetaData()).thenReturn(new
RuleMetaData(Collections.emptyList()));
+ } else {
+ when(rule.getAttributes()).thenReturn(new RuleAttributes());
+ when(database.getRuleMetaData()).thenReturn(new
RuleMetaData(Collections.singleton(rule)));
+ }
+ return result;
+ }
+
@Test
- void assertCheckWithDuplicatedTables() {
- when(database.getName()).thenReturn("foo_db");
- when(schema.containsTable("foo")).thenReturn(true);
+ void assertExecuteUpdateWithNotExistedStorageUnits() {
+ LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Collections.singleton(new SingleTableSegment("foo_ds",
"foo_tbl")));
+ assertThrows(MissingRequiredStorageUnitsException.class, () -> new
DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
mockContextManager(mock(SingleRule.class))).executeUpdate());
+ }
+
+ @Test
+ void assertExecuteUpdateWithInvalidTableNodeFormatWhenSchemaNotSupported()
{
+ when(schema.containsTable("foo_tbl")).thenReturn(true);
when(database.getResourceMetaData().getNotExistedDataSources(any())).thenReturn(Collections.emptyList());
- LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Collections.singleton(new SingleTableSegment("ds_0",
"foo")));
- executor.setDatabase(database);
- assertThrows(TableExistsException.class, () ->
executor.checkBeforeUpdate(sqlStatement));
+ LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Collections.singleton(new SingleTableSegment("foo_ds",
"foo_schema", "foo_tbl")));
+ assertThrows(InvalidDataNodeFormatException.class, () -> new
DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
mockContextManager(mock(SingleRule.class))).executeUpdate());
}
@Test
- void assertCheckWithEmptyStorageUnits() {
- when(database.getName()).thenReturn("foo_db");
-
when(database.getResourceMetaData().getStorageUnits().isEmpty()).thenReturn(true);
- executor.setDatabase(database);
- LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Collections.singleton(new SingleTableSegment("*",
"*")));
- assertThrows(EmptyStorageUnitException.class, () ->
executor.checkBeforeUpdate(sqlStatement));
+ void assertExecuteUpdateWithExistedLogicTables() {
+ when(schema.containsTable("foo_tbl")).thenReturn(true);
+
when(database.getResourceMetaData().getNotExistedDataSources(any())).thenReturn(Collections.emptyList());
+ LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Arrays.asList(
+ new SingleTableSegment("*", "*"), new SingleTableSegment("*",
"*", "*"), new SingleTableSegment("foo_ds", "*"), new
SingleTableSegment("foo_ds", "foo_tbl")));
+ assertThrows(TableExistsException.class, () -> new
DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
mockContextManager(mock(SingleRule.class))).executeUpdate());
}
@Test
- void assertCheckWithInvalidStorageUnit() {
- when(database.getName()).thenReturn("foo_db");
- executor.setDatabase(database);
- LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Collections.singleton(new SingleTableSegment("ds_0",
"foo")));
- assertThrows(MissingRequiredStorageUnitsException.class, () ->
executor.checkBeforeUpdate(sqlStatement));
+ void assertExecuteUpdateWithNotExistedActualTables() {
+
when(database.getResourceMetaData().getNotExistedDataSources(any())).thenReturn(Collections.emptyList());
+ StorageUnit storageUnit = mock(StorageUnit.class);
+ when(storageUnit.getDataSource()).thenReturn(new MockedDataSource());
+
when(database.getResourceMetaData().getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds",
storageUnit));
+ when(SingleTableLoadUtils.getAggregatedDataSourceMap(any(),
any())).thenReturn(Collections.singletonMap("foo_ds", new MockedDataSource()));
+ LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Collections.singleton(new SingleTableSegment("foo_ds",
"foo_tbl")));
+ assertThrows(TableNotFoundException.class, () -> new
DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
mockContextManager(mock(SingleRule.class))).executeUpdate());
}
@Test
- void assertBuild() {
- LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Collections.singletonList(new
SingleTableSegment("ds_0", "foo")));
+ void assertExecuteUpdateWithSingleRule() throws SQLException {
+ Collection<String> currentTables = new
LinkedList<>(Collections.singleton("foo_ds.foo_tbl"));
+
when(database.getResourceMetaData().getNotExistedDataSources(any())).thenReturn(Collections.emptyList());
+ StorageUnit storageUnit = mock(StorageUnit.class);
+ when(storageUnit.getDataSource()).thenReturn(new MockedDataSource());
+
when(database.getResourceMetaData().getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds",
storageUnit));
+ when(SingleTableDataNodeLoader.load(eq("foo_db"), any(),
any())).thenReturn(Collections.singletonMap("foo_tbl",
Collections.singleton(new DataNode("foo_ds.foo_tbl"))));
+ when(SingleTableLoadUtils.convertToDataNodes(eq("foo_db"), any(),
any())).thenReturn(Collections.singleton(new DataNode("foo_ds.foo_tbl")));
+ SingleRuleConfiguration currentConfig = new
SingleRuleConfiguration(currentTables, null);
+ LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Collections.singleton(new SingleTableSegment("*",
"bar_tbl")));
SingleRule rule = mock(SingleRule.class);
- when(rule.getConfiguration()).thenReturn(new
SingleRuleConfiguration());
- executor.setRule(rule);
- SingleRuleConfiguration actual =
executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- assertThat(actual.getTables().iterator().next(), is("ds_0.foo"));
+ when(rule.getConfiguration()).thenReturn(currentConfig);
+ ContextManager contextManager = mockContextManager(rule);
+ new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
+ MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
+
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
any());
}
@Test
- void assertUpdate() {
- Collection<String> currentTables = new
LinkedList<>(Collections.singletonList("ds_0.foo"));
+ void assertExecuteUpdateWithoutSingleRule() throws SQLException {
+ Collection<String> currentTables = new
LinkedList<>(Collections.singleton("foo_ds.foo_tbl"));
+
when(database.getResourceMetaData().getNotExistedDataSources(any())).thenReturn(Collections.emptyList());
+ StorageUnit storageUnit = mock(StorageUnit.class);
+ when(storageUnit.getDataSource()).thenReturn(new MockedDataSource());
+
when(database.getResourceMetaData().getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds",
storageUnit));
+ when(SingleTableDataNodeLoader.load(eq("foo_db"), any(),
any())).thenReturn(Collections.singletonMap("foo_tbl",
Collections.singleton(new DataNode("foo_ds.foo_tbl"))));
+ when(SingleTableLoadUtils.convertToDataNodes(eq("foo_db"), any(),
any())).thenReturn(Collections.singleton(new DataNode("foo_ds.foo_tbl")));
SingleRuleConfiguration currentConfig = new
SingleRuleConfiguration(currentTables, null);
- LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Collections.singletonList(new
SingleTableSegment("ds_0", "bar")));
+ LoadSingleTableStatement sqlStatement = new
LoadSingleTableStatement(Collections.singleton(new SingleTableSegment("*",
"bar_tbl")));
SingleRule rule = mock(SingleRule.class);
when(rule.getConfiguration()).thenReturn(currentConfig);
- executor.setRule(rule);
- SingleRuleConfiguration toBeCreatedConfig =
executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- Iterator<String> iterator = toBeCreatedConfig.getTables().iterator();
- assertThat(iterator.next(), is("ds_0.foo"));
- assertThat(iterator.next(), is("ds_0.bar"));
+ ContextManager contextManager = mockContextManager(null);
+ new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
+ MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
+
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
any());
}
}
diff --git
a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
index 487c43d0650..da84b3fbee6 100644
---
a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
+++
b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
@@ -62,8 +62,7 @@ class SetDefaultSingleTableStorageUnitExecutorTest {
when(rule.getConfiguration()).thenReturn(new
SingleRuleConfiguration(Collections.emptyList(), "foo_ds"));
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
ContextManager contextManager = mockContextManager(rule, database);
- DistSQLUpdateExecuteEngine engine = new DistSQLUpdateExecuteEngine(new
SetDefaultSingleTableStorageUnitStatement(null), "foo_db", contextManager);
- engine.executeUpdate();
+ new DistSQLUpdateExecuteEngine(new
SetDefaultSingleTableStorageUnitStatement(null), "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
verify(metaDataManagerPersistService)
.removeRuleConfigurationItem(eq("foo_db"),
ArgumentMatchers.<SingleRuleConfiguration>argThat(x ->
x.getDefaultDataSource().equals(Optional.of("foo_ds"))));
@@ -79,8 +78,7 @@ class SetDefaultSingleTableStorageUnitExecutorTest {
when(database.getResourceMetaData().getStorageUnits().keySet()).thenReturn(new
HashSet<>(Arrays.asList("foo_ds", "bar_ds")));
when(database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class)).thenReturn(Collections.emptyList());
ContextManager contextManager = mockContextManager(rule, database);
- DistSQLUpdateExecuteEngine engine = new DistSQLUpdateExecuteEngine(new
SetDefaultSingleTableStorageUnitStatement("bar_ds"), "foo_db", contextManager);
- engine.executeUpdate();
+ new DistSQLUpdateExecuteEngine(new
SetDefaultSingleTableStorageUnitStatement("bar_ds"), "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
verify(metaDataManagerPersistService).removeRuleConfigurationItem("foo_db",
null);
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.<SingleRuleConfiguration>argThat(x ->
x.getDefaultDataSource().equals(Optional.of("bar_ds"))));
