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 d74313f48da Refactor MetaDataManagerPersistService (#34572)
d74313f48da is described below
commit d74313f48dac881849934c5442af14a50811dfc2
Author: Liang Zhang <zhangli...@apache.org>
AuthorDate: Thu Feb 6 17:38:47 2025 +0800
Refactor MetaDataManagerPersistService (#34572)
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
* Refactor MetaDataManagerPersistService
---
.../CreateBroadcastTableRuleExecutorTest.java | 8 +-
.../update/DropBroadcastTableRuleExecutorTest.java | 3 +-
.../update/AlterEncryptRuleExecutorTest.java | 10 +-
.../update/CreateEncryptRuleExecutorTest.java | 4 +-
.../update/DropEncryptRuleExecutorTest.java | 8 +-
.../handler/update/AlterMaskRuleExecutorTest.java | 6 +-
.../handler/update/CreateMaskRuleExecutorTest.java | 6 +-
.../handler/update/DropMaskRuleExecutorTest.java | 8 +-
.../database/type/AlterDatabaseRuleOperator.java | 4 +-
.../database/type/CreateDatabaseRuleOperator.java | 2 +-
.../database/type/DropDatabaseRuleOperator.java | 6 +-
.../rdl/resource/AlterStorageUnitExecutor.java | 2 +-
.../resource/UnregisterStorageUnitExecutor.java | 2 +-
.../UnregisterStorageUnitExecutorTest.java | 6 +-
.../update/LoadSingleTableExecutorTest.java | 4 +-
...tDefaultSingleTableStorageUnitExecutorTest.java | 12 +--
.../type/AlterViewFederationMetaDataRefresher.java | 2 +-
.../CreateViewFederationMetaDataRefresher.java | 2 +-
.../type/DropViewFederationMetaDataRefresher.java | 2 +-
.../index/AlterIndexPushDownMetaDataRefresher.java | 2 +-
.../CreateIndexPushDownMetaDataRefresher.java | 2 +-
.../index/DropIndexPushDownMetaDataRefresher.java | 3 +-
.../AlterSchemaPushDownMetaDataRefresher.java | 2 +-
.../CreateSchemaPushDownMetaDataRefresher.java | 2 +-
.../DropSchemaPushDownMetaDataRefresher.java | 2 +-
.../table/AlterTablePushDownMetaDataRefresher.java | 2 +-
.../CreateTablePushDownMetaDataRefresher.java | 4 +-
.../table/DropTablePushDownMetaDataRefresher.java | 4 +-
.../RenameTablePushDownMetaDataRefresher.java | 2 +-
.../view/AlterViewPushDownMetaDataRefresher.java | 2 +-
.../view/CreateViewPushDownMetaDataRefresher.java | 2 +-
.../view/DropViewPushDownMetaDataRefresher.java | 2 +-
.../service/MetaDataManagerPersistService.java | 53 ++++++-----
.../ClusterMetaDataManagerPersistService.java | 87 ++++++++---------
.../ClusterMetaDataManagerPersistServiceTest.java | 31 +++---
.../StandaloneMetaDataManagerPersistService.java | 105 ++++++++++-----------
...tandaloneMetaDataManagerPersistServiceTest.java | 30 +++---
.../database/DropDatabaseBackendHandler.java | 5 +-
.../YamlDatabaseConfigurationImportExecutor.java | 6 +-
39 files changed, 226 insertions(+), 219 deletions(-)
diff --git
a/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
b/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
index ae57e0e4577..f3636ae0ccc 100644
---
a/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
+++
b/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
@@ -37,7 +37,7 @@ import java.util.Collections;
import java.util.HashSet;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -72,7 +72,7 @@ class CreateBroadcastTableRuleExecutorTest {
ContextManager contextManager = mockContextManager(database, rule);
new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
-
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
+ verify(metaDataManagerPersistService).alterRuleConfiguration(any(),
ArgumentMatchers.<BroadcastRuleConfiguration>argThat(x ->
x.getTables().equals(new HashSet<>(Arrays.asList("foo_tbl", "bar_tbl")))));
}
@@ -85,7 +85,7 @@ class CreateBroadcastTableRuleExecutorTest {
ContextManager contextManager = mockContextManager(database, rule);
new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
-
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
+ verify(metaDataManagerPersistService).alterRuleConfiguration(any(),
ArgumentMatchers.<BroadcastRuleConfiguration>argThat(x ->
x.getTables().equals(new HashSet<>(Arrays.asList("foo_tbl", "bar_tbl")))));
}
@@ -96,7 +96,7 @@ class CreateBroadcastTableRuleExecutorTest {
ContextManager contextManager = mockContextManager(database, null);
new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
-
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
+ verify(metaDataManagerPersistService).alterRuleConfiguration(any(),
ArgumentMatchers.<BroadcastRuleConfiguration>argThat(x ->
x.getTables().equals(new HashSet<>(Arrays.asList("foo_tbl", "bar_tbl")))));
}
diff --git
a/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutorTest.java
b/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutorTest.java
index c8ce8ab05a4..6dc737f322b 100644
---
a/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutorTest.java
+++
b/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutorTest.java
@@ -52,12 +52,13 @@ class DropBroadcastTableRuleExecutorTest {
void assertExecuteUpdate() throws SQLException {
DropBroadcastTableRuleStatement sqlStatement = new
DropBroadcastTableRuleStatement(true, new ArrayList<>(Arrays.asList("foo_tbl",
"bar_tbl")));
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+ when(database.getName()).thenReturn("foo_db");
BroadcastRule rule = mock(BroadcastRule.class, RETURNS_DEEP_STUBS);
when(rule.getConfiguration().getTables()).thenReturn(Collections.singleton("foo_tbl"));
ContextManager contextManager = mockContextManager(database, rule);
new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
-
verify(metaDataManagerPersistService).removeRuleConfiguration("foo_db",
"broadcast");
+
verify(metaDataManagerPersistService).removeRuleConfiguration(database,
"broadcast");
}
private ContextManager mockContextManager(final ShardingSphereDatabase
database, final BroadcastRule rule) {
diff --git
a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutorTest.java
b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutorTest.java
index 1580fd1b48e..c9d63d14b53 100644
---
a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutorTest.java
+++
b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutorTest.java
@@ -44,7 +44,7 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -90,8 +90,8 @@ class AlterEncryptRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
new
DistSQLUpdateExecuteEngine(createSQLStatementWithAssistQueryAndLikeColumns(),
"foo_db", contextManager).executeUpdate();
-
metaDataManagerPersistService.removeRuleConfigurationItem(eq("foo_db"),
ArgumentMatchers.argThat(this::assertToBeDroppedRuleConfiguration));
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertToBeAlteredRuleConfiguration));
+ metaDataManagerPersistService.removeRuleConfigurationItem(any(),
ArgumentMatchers.argThat(this::assertToBeDroppedRuleConfiguration));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertToBeAlteredRuleConfiguration));
}
@Test
@@ -102,8 +102,8 @@ class AlterEncryptRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new
DistSQLUpdateExecuteEngine(createSQLStatementWithoutAssistQueryAndLikeColumns(),
"foo_db", contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
-
metaDataManagerPersistService.removeRuleConfigurationItem(eq("foo_db"),
ArgumentMatchers.argThat(this::assertToBeDroppedRuleConfiguration));
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertToBeAlteredRuleConfiguration));
+ metaDataManagerPersistService.removeRuleConfigurationItem(any(),
ArgumentMatchers.argThat(this::assertToBeDroppedRuleConfiguration));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertToBeAlteredRuleConfiguration));
}
private ContextManager mockContextManager(final EncryptRule rule) {
diff --git
a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutorTest.java
b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutorTest.java
index 417f66a712f..f846b784cc1 100644
---
a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutorTest.java
+++
b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutorTest.java
@@ -48,7 +48,7 @@ import java.util.Properties;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -104,7 +104,7 @@ class CreateEncryptRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertIfNotExistsRuleConfiguration));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertIfNotExistsRuleConfiguration));
}
private CreateEncryptRuleStatement createAESEncryptRuleSQLStatement(final
boolean ifNotExists) {
diff --git
a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutorTest.java
b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutorTest.java
index 981a1a9ea33..8be14c436e4 100644
---
a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutorTest.java
+++
b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutorTest.java
@@ -45,8 +45,8 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
-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.when;
@@ -69,7 +69,7 @@ class DropEncryptRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new DistSQLUpdateExecuteEngine(createSQLStatement("T_ENCRYPT"),
"foo_db", contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertRuleConfiguration));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertRuleConfiguration));
}
private boolean assertRuleConfiguration(final EncryptRuleConfiguration
actual) {
@@ -87,7 +87,7 @@ class DropEncryptRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new DistSQLUpdateExecuteEngine(createSQLStatement("T_ENCRYPT"),
"foo_db", contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertRuleConfigurationWithoutEncryptors));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertRuleConfigurationWithoutEncryptors));
}
private boolean assertRuleConfigurationWithoutEncryptors(final
EncryptRuleConfiguration actual) {
@@ -105,7 +105,7 @@ class DropEncryptRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new DistSQLUpdateExecuteEngine(statement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertRuleConfigurationWithoutEncryptors));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertRuleConfigurationWithoutEncryptors));
}
private DropEncryptRuleStatement createSQLStatement(final String
tableName) {
diff --git
a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutorTest.java
b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutorTest.java
index 36d1068dcde..c73c7e27f44 100644
---
a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutorTest.java
+++
b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutorTest.java
@@ -43,7 +43,7 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -68,8 +68,8 @@ class AlterMaskRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
-
metaDataManagerPersistService.removeRuleConfigurationItem(eq("foo_db"),
ArgumentMatchers.argThat(this::assertToBeDroppedRuleConfiguration));
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertToBeAlteredRuleConfiguration));
+ metaDataManagerPersistService.removeRuleConfigurationItem(any(),
ArgumentMatchers.argThat(this::assertToBeDroppedRuleConfiguration));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertToBeAlteredRuleConfiguration));
}
private boolean assertToBeDroppedRuleConfiguration(final
MaskRuleConfiguration actual) {
diff --git
a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutorTest.java
b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutorTest.java
index 950c812c67b..9da63cc2e40 100644
---
a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutorTest.java
+++
b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutorTest.java
@@ -43,7 +43,7 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -66,7 +66,7 @@ class CreateMaskRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertRuleConfiguration));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertRuleConfiguration));
}
@Test
@@ -78,7 +78,7 @@ class CreateMaskRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertRuleConfiguration));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertRuleConfiguration));
}
private CreateMaskRuleStatement createSQLStatement(final boolean
ifNotExists, final String algorithmType) {
diff --git
a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutorTest.java
b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutorTest.java
index daa0b18fd59..dde951ef799 100644
---
a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutorTest.java
+++
b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutorTest.java
@@ -39,7 +39,7 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -61,7 +61,7 @@ class DropMaskRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new DistSQLUpdateExecuteEngine(createSQLStatement(false, "T_MASK"),
"foo_db", contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertRuleConfigurationWithoutIfExists));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertRuleConfigurationWithoutIfExists));
}
private boolean assertRuleConfigurationWithoutIfExists(final
MaskRuleConfiguration actual) {
@@ -79,8 +79,8 @@ class DropMaskRuleExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new DistSQLUpdateExecuteEngine(createSQLStatement(true, "T_USER"),
"foo_db", contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertRuleConfigurationWithoutIfExists));
- metaDataManagerPersistService.alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.argThat(this::assertRuleConfigurationWithIfExists));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertRuleConfigurationWithoutIfExists));
+ metaDataManagerPersistService.alterRuleConfiguration(any(),
ArgumentMatchers.argThat(this::assertRuleConfigurationWithIfExists));
}
private DropMaskRuleStatement createSQLStatement(final boolean ifExists,
final String tableName) {
diff --git
a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/AlterDatabaseRuleOperator.java
b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/AlterDatabaseRuleOperator.java
index 7c6f0598e76..222f487f866 100644
---
a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/AlterDatabaseRuleOperator.java
+++
b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/AlterDatabaseRuleOperator.java
@@ -49,9 +49,9 @@ public final class AlterDatabaseRuleOperator implements
DatabaseRuleOperator {
public void operate(final DatabaseRuleDefinitionStatement sqlStatement,
final ShardingSphereDatabase database, final RuleConfiguration
currentRuleConfig) throws SQLException {
RuleConfiguration toBeAlteredRuleConfig =
executor.buildToBeAlteredRuleConfiguration(sqlStatement);
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
-
metaDataManagerPersistService.alterRuleConfiguration(database.getName(),
decorateRuleConfiguration(database, toBeAlteredRuleConfig));
+ metaDataManagerPersistService.alterRuleConfiguration(database,
decorateRuleConfiguration(database, toBeAlteredRuleConfig));
RuleConfiguration toBeDroppedRuleConfig =
executor.buildToBeDroppedRuleConfiguration(toBeAlteredRuleConfig);
-
metaDataManagerPersistService.removeRuleConfigurationItem(database.getName(),
toBeDroppedRuleConfig);
+ metaDataManagerPersistService.removeRuleConfigurationItem(database,
toBeDroppedRuleConfig);
}
@SuppressWarnings("unchecked")
diff --git
a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/CreateDatabaseRuleOperator.java
b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/CreateDatabaseRuleOperator.java
index 8645350a27c..79abcc49f2b 100644
---
a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/CreateDatabaseRuleOperator.java
+++
b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/CreateDatabaseRuleOperator.java
@@ -49,7 +49,7 @@ public final class CreateDatabaseRuleOperator implements
DatabaseRuleOperator {
public void operate(final DatabaseRuleDefinitionStatement sqlStatement,
final ShardingSphereDatabase database, final RuleConfiguration
currentRuleConfig) throws SQLException {
RuleConfiguration toBeCreatedRuleConfig =
executor.buildToBeCreatedRuleConfiguration(sqlStatement);
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
-
metaDataManagerPersistService.alterRuleConfiguration(database.getName(),
decorateRuleConfiguration(database, toBeCreatedRuleConfig));
+ metaDataManagerPersistService.alterRuleConfiguration(database,
decorateRuleConfiguration(database, toBeCreatedRuleConfig));
}
@SuppressWarnings("unchecked")
diff --git
a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/DropDatabaseRuleOperator.java
b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/DropDatabaseRuleOperator.java
index 273cf15dc9c..72c5cf7983b 100644
---
a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/DropDatabaseRuleOperator.java
+++
b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/database/type/DropDatabaseRuleOperator.java
@@ -62,14 +62,14 @@ public final class DropDatabaseRuleOperator implements
DatabaseRuleOperator {
}
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
RuleConfiguration toBeDroppedRuleConfig =
executor.buildToBeDroppedRuleConfiguration(sqlStatement);
-
metaDataManagerPersistService.removeRuleConfigurationItem(database.getName(),
toBeDroppedRuleConfig);
+ metaDataManagerPersistService.removeRuleConfigurationItem(database,
toBeDroppedRuleConfig);
RuleConfiguration toBeAlteredRuleConfig =
executor.buildToBeAlteredRuleConfiguration(sqlStatement);
if (null != toBeAlteredRuleConfig
&&
TypedSPILoader.getService(DatabaseRuleConfigurationEmptyChecker.class,
toBeAlteredRuleConfig.getClass()).isEmpty((DatabaseRuleConfiguration)
toBeAlteredRuleConfig)) {
YamlRuleConfiguration yamlRuleConfig = new
YamlRuleConfigurationSwapperEngine().swapToYamlRuleConfiguration(currentRuleConfig);
-
metaDataManagerPersistService.removeRuleConfiguration(database.getName(),
Objects.requireNonNull(yamlRuleConfig.getClass().getAnnotation(RepositoryTupleEntity.class)).value());
+ metaDataManagerPersistService.removeRuleConfiguration(database,
Objects.requireNonNull(yamlRuleConfig.getClass().getAnnotation(RepositoryTupleEntity.class)).value());
} else {
-
metaDataManagerPersistService.alterRuleConfiguration(database.getName(),
toBeAlteredRuleConfig);
+ metaDataManagerPersistService.alterRuleConfiguration(database,
toBeAlteredRuleConfig);
}
}
}
diff --git
a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/AlterStorageUnitExecutor.java
b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/AlterStorageUnitExecutor.java
index bc68f391b2e..1a8859dbcc2 100644
---
a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/AlterStorageUnitExecutor.java
+++
b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/AlterStorageUnitExecutor.java
@@ -66,7 +66,7 @@ public final class AlterStorageUnitExecutor implements
DistSQLUpdateExecutor<Alt
Map<String, DataSourcePoolProperties> propsMap =
DataSourceSegmentsConverter.convert(database.getProtocolType(),
sqlStatement.getStorageUnits());
validateHandler.validate(propsMap,
getExpectedPrivileges(sqlStatement));
try {
-
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService().alterStorageUnits(database.getName(),
propsMap);
+
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService().alterStorageUnits(database,
propsMap);
} catch (final SQLException | ShardingSphereExternalException ex) {
throw new StorageUnitsOperateException("alter", propsMap.keySet(),
ex);
}
diff --git
a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/UnregisterStorageUnitExecutor.java
b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/UnregisterStorageUnitExecutor.java
index a01b50de523..d6ab102b574 100644
---
a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/UnregisterStorageUnitExecutor.java
+++
b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/UnregisterStorageUnitExecutor.java
@@ -57,7 +57,7 @@ public final class UnregisterStorageUnitExecutor implements
DistSQLUpdateExecuto
}
checkInUsed(sqlStatement);
try {
-
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService().unregisterStorageUnits(database.getName(),
sqlStatement.getStorageUnitNames());
+
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService().unregisterStorageUnits(database,
sqlStatement.getStorageUnitNames());
} catch (final SQLException | ShardingSphereServerException ex) {
throw new StorageUnitsOperateException("unregister",
sqlStatement.getStorageUnitNames(), ex);
}
diff --git
a/infra/distsql-handler/src/test/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/UnregisterStorageUnitExecutorTest.java
b/infra/distsql-handler/src/test/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/UnregisterStorageUnitExecutorTest.java
index 18e5451b9a5..7eceece1709 100644
---
a/infra/distsql-handler/src/test/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/UnregisterStorageUnitExecutorTest.java
+++
b/infra/distsql-handler/src/test/java/org/apache/shardingsphere/distsql/handler/executor/rdl/resource/UnregisterStorageUnitExecutorTest.java
@@ -96,7 +96,7 @@ class UnregisterStorageUnitExecutorTest {
when(database.getRuleMetaData().getInUsedStorageUnitNameAndRulesMap()).thenReturn(Collections.emptyMap());
UnregisterStorageUnitStatement sqlStatement = new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false);
executor.executeUpdate(sqlStatement, contextManager);
- verify(metaDataManagerPersistService).unregisterStorageUnits("foo_db",
sqlStatement.getStorageUnitNames());
+ verify(metaDataManagerPersistService).unregisterStorageUnits(database,
sqlStatement.getStorageUnitNames());
}
@Test
@@ -127,14 +127,14 @@ class UnregisterStorageUnitExecutorTest {
when(database.getRuleMetaData()).thenReturn(new
RuleMetaData(Collections.singleton(new DistSQLHandlerFixtureRule())));
UnregisterStorageUnitStatement sqlStatement = new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), true, false);
executor.executeUpdate(sqlStatement, contextManager);
- verify(metaDataManagerPersistService).unregisterStorageUnits("foo_db",
sqlStatement.getStorageUnitNames());
+ verify(metaDataManagerPersistService).unregisterStorageUnits(database,
sqlStatement.getStorageUnitNames());
}
@Test
void assertExecuteUpdateWithIfExists() throws SQLException {
UnregisterStorageUnitStatement sqlStatement = new
UnregisterStorageUnitStatement(true, Collections.singleton("foo_ds"), true,
false);
executor.executeUpdate(sqlStatement, contextManager);
- verify(metaDataManagerPersistService).unregisterStorageUnits("foo_db",
sqlStatement.getStorageUnitNames());
+ verify(metaDataManagerPersistService).unregisterStorageUnits(database,
sqlStatement.getStorageUnitNames());
}
@Test
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 17c3edf0c9d..f1b93d172d6 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
@@ -146,7 +146,7 @@ class LoadSingleTableExecutorTest {
ContextManager contextManager = mockContextManager(rule);
new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
-
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
any());
+ verify(metaDataManagerPersistService).alterRuleConfiguration(any(),
any());
}
@Test
@@ -165,6 +165,6 @@ class LoadSingleTableExecutorTest {
ContextManager contextManager = mockContextManager(null);
new DistSQLUpdateExecuteEngine(sqlStatement, "foo_db",
contextManager).executeUpdate();
MetaDataManagerPersistService metaDataManagerPersistService =
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService();
-
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
any());
+ verify(metaDataManagerPersistService).alterRuleConfiguration(any(),
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 85f18249981..bfd7d8ee89e 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
@@ -37,7 +37,7 @@ import java.util.HashSet;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -64,14 +64,14 @@ class SetDefaultSingleTableStorageUnitExecutorTest {
ContextManager contextManager = mockContextManager(database, rule);
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"))));
-
verify(metaDataManagerPersistService).alterRuleConfiguration(eq("foo_db"),
ArgumentMatchers.<SingleRuleConfiguration>argThat(x ->
!x.getDefaultDataSource().isPresent()));
+
verify(metaDataManagerPersistService).removeRuleConfigurationItem(any(),
ArgumentMatchers.<SingleRuleConfiguration>argThat(x ->
x.getDefaultDataSource().equals(Optional.of("foo_ds"))));
+ verify(metaDataManagerPersistService).alterRuleConfiguration(any(),
ArgumentMatchers.<SingleRuleConfiguration>argThat(x ->
!x.getDefaultDataSource().isPresent()));
}
@Test
void assertExecuteUpdateWithDefaultStorageUnit() throws SQLException {
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+ when(database.getName()).thenReturn("foo_db");
when(database.getResourceMetaData().getStorageUnits().keySet()).thenReturn(new
HashSet<>(Arrays.asList("foo_ds", "bar_ds")));
when(database.getRuleMetaData().getAttributes(DataSourceMapperRuleAttribute.class)).thenReturn(Collections.emptyList());
SingleRule rule = mock(SingleRule.class, RETURNS_DEEP_STUBS);
@@ -80,8 +80,8 @@ class SetDefaultSingleTableStorageUnitExecutorTest {
ContextManager contextManager = mockContextManager(database, rule);
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"))));
+
verify(metaDataManagerPersistService).removeRuleConfigurationItem(database,
null);
+ verify(metaDataManagerPersistService).alterRuleConfiguration(any(),
ArgumentMatchers.<SingleRuleConfiguration>argThat(x ->
x.getDefaultDataSource().equals(Optional.of("bar_ds"))));
}
private ContextManager mockContextManager(final ShardingSphereDatabase
database, final SingleRule rule) {
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/AlterViewFederationMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/AlterViewFederationMetaDataRefresher.java
index 3a94ad2700a..518e61ec03b 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/AlterViewFederationMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/AlterViewFederationMetaDataRefresher.java
@@ -48,7 +48,7 @@ public final class AlterViewFederationMetaDataRefresher
implements FederationMet
droppedViews.add(viewName);
}
sqlStatement.getViewDefinition().ifPresent(optional ->
alteredViews.add(new ShardingSphereView(viewName, optional)));
- metaDataManagerPersistService.alterSchema(database.getName(),
schemaName, Collections.emptyList(), alteredViews, Collections.emptyList(),
droppedViews);
+ metaDataManagerPersistService.alterSchema(database, schemaName,
Collections.emptyList(), alteredViews, Collections.emptyList(), droppedViews);
}
@Override
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/CreateViewFederationMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/CreateViewFederationMetaDataRefresher.java
index bc01b703836..efe29a46e5b 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/CreateViewFederationMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/CreateViewFederationMetaDataRefresher.java
@@ -34,7 +34,7 @@ public final class CreateViewFederationMetaDataRefresher
implements FederationMe
@Override
public void refresh(final MetaDataManagerPersistService
metaDataManagerPersistService, final ShardingSphereDatabase database, final
String schemaName, final CreateViewStatement sqlStatement) {
String viewName =
TableRefreshUtils.getTableName(sqlStatement.getView().getTableName().getIdentifier(),
sqlStatement.getDatabaseType());
- metaDataManagerPersistService.alterSchema(database.getName(),
schemaName,
+ metaDataManagerPersistService.alterSchema(database, schemaName,
Collections.emptyList(), Collections.singleton(new
ShardingSphereView(viewName, sqlStatement.getViewDefinition())),
Collections.emptyList(), Collections.emptyList());
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/DropViewFederationMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/DropViewFederationMetaDataRefresher.java
index ba1dae4fac9..c379f6649e6 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/DropViewFederationMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/federation/type/DropViewFederationMetaDataRefresher.java
@@ -34,7 +34,7 @@ public final class DropViewFederationMetaDataRefresher
implements FederationMeta
@Override
public void refresh(final MetaDataManagerPersistService
metaDataManagerPersistService, final ShardingSphereDatabase database, final
String schemaName, final DropViewStatement sqlStatement) {
Collection<String> droppedViews =
sqlStatement.getViews().stream().map(each ->
each.getTableName().getIdentifier().getValue()).collect(Collectors.toList());
- metaDataManagerPersistService.alterSchema(database.getName(),
schemaName, Collections.emptyList(), Collections.emptyList(),
Collections.emptyList(), droppedViews);
+ metaDataManagerPersistService.alterSchema(database, schemaName,
Collections.emptyList(), Collections.emptyList(), Collections.emptyList(),
droppedViews);
}
@Override
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/AlterIndexPushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/AlterIndexPushDownMetaDataRefresher.java
index d846f4de881..a722eaa58e2 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/AlterIndexPushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/AlterIndexPushDownMetaDataRefresher.java
@@ -61,7 +61,7 @@ public final class AlterIndexPushDownMetaDataRefresher
implements PushDownMetaDa
newTable.removeIndex(indexName);
String renameIndexName =
renameIndex.get().getIndexName().getIdentifier().getValue();
newTable.putIndex(new ShardingSphereIndex(renameIndexName, new
LinkedList<>(), false));
- metaDataManagerPersistService.alterSchema(database.getName(),
actualSchemaName, Collections.singleton(newTable), Collections.emptyList(),
Collections.emptyList(), Collections.emptyList());
+ metaDataManagerPersistService.alterSchema(database, actualSchemaName,
Collections.singleton(newTable), Collections.emptyList(),
Collections.emptyList(), Collections.emptyList());
}
private Optional<String> findLogicTableName(final ShardingSphereSchema
schema, final String indexName) {
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/CreateIndexPushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/CreateIndexPushDownMetaDataRefresher.java
index 1f25ec77d2c..e686e9d221b 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/CreateIndexPushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/CreateIndexPushDownMetaDataRefresher.java
@@ -53,7 +53,7 @@ public final class CreateIndexPushDownMetaDataRefresher
implements PushDownMetaD
ShardingSphereTable table = schema.getTable(tableName);
ShardingSphereTable newTable = new
ShardingSphereTable(table.getName(), table.getAllColumns(),
table.getAllIndexes(), table.getAllConstraints(), table.getType());
newTable.putIndex(new ShardingSphereIndex(indexName, new
LinkedList<>(), false));
- metaDataManagerPersistService.alterSchema(database.getName(),
schemaName, Collections.singleton(newTable), Collections.emptyList(),
Collections.emptyList(), Collections.emptyList());
+ metaDataManagerPersistService.alterSchema(database, schemaName,
Collections.singleton(newTable), Collections.emptyList(),
Collections.emptyList(), Collections.emptyList());
}
@Override
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/DropIndexPushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/DropIndexPushDownMetaDataRefresher.java
index 30cb1982e1b..7cfe11e96a3 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/DropIndexPushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/index/DropIndexPushDownMetaDataRefresher.java
@@ -57,8 +57,7 @@ public final class DropIndexPushDownMetaDataRefresher
implements PushDownMetaDat
ShardingSphereTable table = schema.getTable(logicTableName.get());
ShardingSphereTable newTable = new
ShardingSphereTable(table.getName(), table.getAllColumns(),
table.getAllIndexes(), table.getAllConstraints(), table.getType());
newTable.removeIndex(each.getIndexName().getIdentifier().getValue());
- metaDataManagerPersistService.alterSchema(database.getName(),
actualSchemaName,
- Collections.singleton(newTable), Collections.emptyList(),
Collections.emptyList(), Collections.emptyList());
+ metaDataManagerPersistService.alterSchema(database,
actualSchemaName, Collections.singleton(newTable), Collections.emptyList(),
Collections.emptyList(), Collections.emptyList());
}
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/AlterSchemaPushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/AlterSchemaPushDownMetaDataRefresher.java
index d2aa7bdc60a..0f2ff50bcdc 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/AlterSchemaPushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/AlterSchemaPushDownMetaDataRefresher.java
@@ -40,7 +40,7 @@ public final class AlterSchemaPushDownMetaDataRefresher
implements PushDownMetaD
if (!renameSchemaName.isPresent()) {
return;
}
- metaDataManagerPersistService.renameSchema(database.getName(),
sqlStatement.getSchemaName().getValue().toLowerCase(), renameSchemaName.get());
+ metaDataManagerPersistService.renameSchema(database,
sqlStatement.getSchemaName().getValue().toLowerCase(), renameSchemaName.get());
}
@Override
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/CreateSchemaPushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/CreateSchemaPushDownMetaDataRefresher.java
index 57ed9b87bd4..28da59909a8 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/CreateSchemaPushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/CreateSchemaPushDownMetaDataRefresher.java
@@ -36,7 +36,7 @@ public final class CreateSchemaPushDownMetaDataRefresher
implements PushDownMeta
@Override
public void refresh(final MetaDataManagerPersistService
metaDataManagerPersistService, final ShardingSphereDatabase database, final
Collection<String> logicDataSourceNames,
final String schemaName, final DatabaseType
databaseType, final CreateSchemaStatement sqlStatement, final
ConfigurationProperties props) {
- getSchemaName(sqlStatement).ifPresent(optional ->
metaDataManagerPersistService.createSchema(database.getName(),
optional.getValue().toLowerCase()));
+ getSchemaName(sqlStatement).ifPresent(optional ->
metaDataManagerPersistService.createSchema(database,
optional.getValue().toLowerCase()));
}
private static Optional<IdentifierValue> getSchemaName(final
CreateSchemaStatement sqlStatement) {
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/DropSchemaPushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/DropSchemaPushDownMetaDataRefresher.java
index f739b292f99..0e78c512e19 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/DropSchemaPushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/schema/DropSchemaPushDownMetaDataRefresher.java
@@ -35,7 +35,7 @@ public final class DropSchemaPushDownMetaDataRefresher
implements PushDownMetaDa
@Override
public void refresh(final MetaDataManagerPersistService
metaDataManagerPersistService, final ShardingSphereDatabase database, final
Collection<String> logicDataSourceNames,
final String schemaName, final DatabaseType
databaseType, final DropSchemaStatement sqlStatement, final
ConfigurationProperties props) {
- metaDataManagerPersistService.dropSchema(database.getName(),
getSchemaNames(sqlStatement));
+ metaDataManagerPersistService.dropSchema(database,
getSchemaNames(sqlStatement));
}
private Collection<String> getSchemaNames(final DropSchemaStatement
sqlStatement) {
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/AlterTablePushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/AlterTablePushDownMetaDataRefresher.java
index 2027161fc3c..6f501c7bc70 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/AlterTablePushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/AlterTablePushDownMetaDataRefresher.java
@@ -56,7 +56,7 @@ public final class AlterTablePushDownMetaDataRefresher
implements PushDownMetaDa
} else {
alteredTables.add(getTable(database, logicDataSourceNames,
schemaName, tableName, props));
}
- metaDataManagerPersistService.alterSchema(database.getName(),
schemaName, alteredTables, Collections.emptyList(), droppedTables,
Collections.emptyList());
+ metaDataManagerPersistService.alterSchema(database, schemaName,
alteredTables, Collections.emptyList(), droppedTables, Collections.emptyList());
}
private ShardingSphereTable getTable(final ShardingSphereDatabase
database, final Collection<String> logicDataSourceNames, final String
schemaName,
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/CreateTablePushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/CreateTablePushDownMetaDataRefresher.java
index a98f0cc65ae..fd9ecf9e361 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/CreateTablePushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/CreateTablePushDownMetaDataRefresher.java
@@ -52,9 +52,9 @@ public final class CreateTablePushDownMetaDataRefresher
implements PushDownMetaD
ruleMetaData.getAttributes(MutableDataNodeRuleAttribute.class).forEach(each ->
each.put(logicDataSourceNames.iterator().next(), schemaName, tableName));
}
ShardingSphereTable loadedTable = loadTable(database, schemaName,
tableName, ruleMetaData, props);
- metaDataManagerPersistService.createTable(database.getName(),
schemaName, loadedTable);
+ metaDataManagerPersistService.createTable(database, schemaName,
loadedTable);
if (isSingleTable && TableRefreshUtils.isNeedRefresh(ruleMetaData,
schemaName, tableName)) {
-
metaDataManagerPersistService.alterSingleRuleConfiguration(database.getName(),
ruleMetaData);
+
metaDataManagerPersistService.alterSingleRuleConfiguration(database,
ruleMetaData);
}
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/DropTablePushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/DropTablePushDownMetaDataRefresher.java
index 804decb3424..f7ee2b0a21e 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/DropTablePushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/DropTablePushDownMetaDataRefresher.java
@@ -40,9 +40,9 @@ public final class DropTablePushDownMetaDataRefresher
implements PushDownMetaDat
boolean needRefresh =
TableRefreshUtils.isNeedRefresh(database.getRuleMetaData(), schemaName,
sqlStatement.getTables());
boolean isRefreshed = false;
for (SimpleTableSegment each : sqlStatement.getTables()) {
- metaDataManagerPersistService.dropTable(database.getName(),
schemaName, each.getTableName().getIdentifier().getValue());
+ metaDataManagerPersistService.dropTable(database, schemaName,
each.getTableName().getIdentifier().getValue());
if (!isRefreshed && needRefresh &&
TableRefreshUtils.isSingleTable(each.getTableName().getIdentifier().getValue(),
database)) {
-
metaDataManagerPersistService.alterSingleRuleConfiguration(database.getName(),
database.getRuleMetaData());
+
metaDataManagerPersistService.alterSingleRuleConfiguration(database,
database.getRuleMetaData());
isRefreshed = true;
}
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/RenameTablePushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/RenameTablePushDownMetaDataRefresher.java
index 357d87001c9..a7522f7d3f3 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/RenameTablePushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/table/RenameTablePushDownMetaDataRefresher.java
@@ -48,7 +48,7 @@ public final class RenameTablePushDownMetaDataRefresher
implements PushDownMetaD
each.getRenameTable().getTableName().getIdentifier().getValue(),
toBeRenamedTable.getAllColumns(), toBeRenamedTable.getAllIndexes(),
toBeRenamedTable.getAllConstraints()));
droppedTables.add(toBeRenamedTableName);
}
- metaDataManagerPersistService.alterSchema(database.getName(),
schemaName, alteredTables, Collections.emptyList(), droppedTables,
Collections.emptyList());
+ metaDataManagerPersistService.alterSchema(database, schemaName,
alteredTables, Collections.emptyList(), droppedTables, Collections.emptyList());
}
@Override
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/AlterViewPushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/AlterViewPushDownMetaDataRefresher.java
index fd1dd1b5abc..91e945b7249 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/AlterViewPushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/AlterViewPushDownMetaDataRefresher.java
@@ -69,7 +69,7 @@ public final class AlterViewPushDownMetaDataRefresher
implements PushDownMetaDat
alteredTables.add(schema.getTable(viewName));
alteredViews.add(schema.getView(viewName));
}
- metaDataManagerPersistService.alterSchema(database.getName(),
schemaName, alteredTables, alteredViews, droppedTables, droppedViews);
+ metaDataManagerPersistService.alterSchema(database, schemaName,
alteredTables, alteredViews, droppedTables, droppedViews);
}
private ShardingSphereSchema getSchema(final ShardingSphereDatabase
database, final Collection<String> logicDataSourceNames,
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/CreateViewPushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/CreateViewPushDownMetaDataRefresher.java
index eee33b07c14..0cd31423f74 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/CreateViewPushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/CreateViewPushDownMetaDataRefresher.java
@@ -57,7 +57,7 @@ public final class CreateViewPushDownMetaDataRefresher
implements PushDownMetaDa
Map<String, ShardingSphereSchema> schemas =
GenericSchemaBuilder.build(Collections.singletonList(viewName),
database.getProtocolType(), material);
Optional<ShardingSphereTable> actualTableMetaData =
Optional.ofNullable(schemas.get(schemaName)).map(optional ->
optional.getTable(viewName));
Preconditions.checkState(actualTableMetaData.isPresent(), "Load actual
view metadata '%s' failed.", viewName);
- metaDataManagerPersistService.alterSchema(database.getName(),
schemaName,
+ metaDataManagerPersistService.alterSchema(database, schemaName,
Collections.singleton(actualTableMetaData.get()),
Collections.singleton(new ShardingSphereView(viewName,
sqlStatement.getViewDefinition())),
Collections.emptyList(), Collections.emptyList());
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/DropViewPushDownMetaDataRefresher.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/DropViewPushDownMetaDataRefresher.java
index 358c87af0e5..8229a3a03cc 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/DropViewPushDownMetaDataRefresher.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/metadata/pushdown/type/view/DropViewPushDownMetaDataRefresher.java
@@ -44,7 +44,7 @@ public final class DropViewPushDownMetaDataRefresher
implements PushDownMetaData
droppedTables.add(viewName);
droppedViews.add(viewName);
}
- metaDataManagerPersistService.alterSchema(database.getName(),
schemaName, Collections.emptyList(), Collections.emptyList(), droppedTables,
droppedViews);
+ metaDataManagerPersistService.alterSchema(database, schemaName,
Collections.emptyList(), Collections.emptyList(), droppedTables, droppedViews);
}
@Override
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/persist/service/MetaDataManagerPersistService.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/persist/service/MetaDataManagerPersistService.java
index 85f33b8fc9a..3d81153cb31 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/persist/service/MetaDataManagerPersistService.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/persist/service/MetaDataManagerPersistService.java
@@ -19,6 +19,7 @@ package org.apache.shardingsphere.mode.persist.service;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereView;
@@ -43,65 +44,65 @@ public interface MetaDataManagerPersistService {
/**
* Drop database.
*
- * @param databaseName database name
+ * @param database database
*/
- void dropDatabase(String databaseName);
+ void dropDatabase(ShardingSphereDatabase database);
/**
* Create schema.
*
- * @param databaseName database name
+ * @param database database
* @param schemaName schema name
*/
- void createSchema(String databaseName, String schemaName);
+ void createSchema(ShardingSphereDatabase database, String schemaName);
/**
* Alter schema.
*
- * @param databaseName database name
+ * @param database database
* @param schemaName schema name
* @param alteredTables altered tables
* @param alteredViews altered views
* @param droppedTables dropped tables
* @param droppedViews dropped views
*/
- void alterSchema(String databaseName, String schemaName,
+ void alterSchema(ShardingSphereDatabase database, String schemaName,
Collection<ShardingSphereTable> alteredTables,
Collection<ShardingSphereView> alteredViews, Collection<String> droppedTables,
Collection<String> droppedViews);
/**
* Rename schema.
*
- * @param databaseName database name
+ * @param database database
* @param schemaName schema name
* @param renameSchemaName rename schema name
*/
- void renameSchema(String databaseName, String schemaName, String
renameSchemaName);
+ void renameSchema(ShardingSphereDatabase database, String schemaName,
String renameSchemaName);
/**
* Drop schema.
*
- * @param databaseName database name
+ * @param database database
* @param schemaNames schema names
*/
- void dropSchema(String databaseName, Collection<String> schemaNames);
+ void dropSchema(ShardingSphereDatabase database, Collection<String>
schemaNames);
/**
* Create table.
*
- * @param databaseName database name
+ * @param database database
* @param schemaName schema name
* @param table table
*/
- void createTable(String databaseName, String schemaName,
ShardingSphereTable table);
+ void createTable(ShardingSphereDatabase database, String schemaName,
ShardingSphereTable table);
/**
* Drop tables.
*
- * @param databaseName database name
+ * @param database database
* @param schemaName schema name
* @param tableName table name
*/
- void dropTable(String databaseName, String schemaName, String tableName);
+ void dropTable(ShardingSphereDatabase database, String schemaName, String
tableName);
/**
* Register storage units.
@@ -115,55 +116,55 @@ public interface MetaDataManagerPersistService {
/**
* Alter storage units.
*
- * @param databaseName database name
+ * @param database database
* @param toBeUpdatedProps to be updated storage unit properties
* @throws SQLException SQL exception
*/
- void alterStorageUnits(String databaseName, Map<String,
DataSourcePoolProperties> toBeUpdatedProps) throws SQLException;
+ void alterStorageUnits(ShardingSphereDatabase database, Map<String,
DataSourcePoolProperties> toBeUpdatedProps) throws SQLException;
/**
* Unregister storage units.
- * @param databaseName database name
+ * @param database database
* @param toBeDroppedStorageUnitNames to be dropped storage unit names
* @throws SQLException SQL exception
*/
- void unregisterStorageUnits(String databaseName, Collection<String>
toBeDroppedStorageUnitNames) throws SQLException;
+ void unregisterStorageUnits(ShardingSphereDatabase database,
Collection<String> toBeDroppedStorageUnitNames) throws SQLException;
/**
* Alter single rule configuration.
*
- * @param databaseName database name
+ * @param database database
* @param ruleMetaData rule meta data
* @throws SQLException SQL exception
*/
- void alterSingleRuleConfiguration(String databaseName, RuleMetaData
ruleMetaData) throws SQLException;
+ void alterSingleRuleConfiguration(ShardingSphereDatabase database,
RuleMetaData ruleMetaData) throws SQLException;
/**
* Alter rule configuration.
*
- * @param databaseName database name
+ * @param database database
* @param toBeAlteredRuleConfig to be altered rule config
* @throws SQLException SQL exception
*/
- void alterRuleConfiguration(String databaseName, RuleConfiguration
toBeAlteredRuleConfig) throws SQLException;
+ void alterRuleConfiguration(ShardingSphereDatabase database,
RuleConfiguration toBeAlteredRuleConfig) throws SQLException;
/**
* Remove rule configuration item.
*
- * @param databaseName database name
+ * @param database database
* @param toBeRemovedRuleConfig to be removed rule config
* @throws SQLException SQL exception
*/
- void removeRuleConfigurationItem(String databaseName, RuleConfiguration
toBeRemovedRuleConfig) throws SQLException;
+ void removeRuleConfigurationItem(ShardingSphereDatabase database,
RuleConfiguration toBeRemovedRuleConfig) throws SQLException;
/**
* Remove rule configuration.
*
- * @param databaseName database name
+ * @param database database
* @param ruleName rule name
* @throws SQLException SQL exception
*/
- void removeRuleConfiguration(String databaseName, String ruleName) throws
SQLException;
+ void removeRuleConfiguration(ShardingSphereDatabase database, String
ruleName) throws SQLException;
/**
* Alter global rule configuration.
diff --git
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
index 69651c39e70..5ed3375d85a 100644
---
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
+++
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
@@ -21,6 +21,7 @@ import lombok.SneakyThrows;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.destroyer.DataSourcePoolDestroyer;
import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.metadata.database.resource.node.StorageNode;
import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
@@ -75,42 +76,42 @@ public final class ClusterMetaDataManagerPersistService
implements MetaDataManag
}
@Override
- public void dropDatabase(final String databaseName) {
- clusterDatabaseListenerPersistCoordinator.persist(databaseName,
ClusterDatabaseListenerCoordinatorType.DROP);
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getDatabase().drop(databaseName);
+ public void dropDatabase(final ShardingSphereDatabase database) {
+ clusterDatabaseListenerPersistCoordinator.persist(database.getName(),
ClusterDatabaseListenerCoordinatorType.DROP);
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getDatabase().drop(database.getName());
}
@Override
- public void createSchema(final String databaseName, final String
schemaName) {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().add(databaseName,
schemaName);
+ public void createSchema(final ShardingSphereDatabase database, final
String schemaName) {
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().add(database.getName(),
schemaName);
}
@Override
- public void alterSchema(final String databaseName, final String schemaName,
+ public void alterSchema(final ShardingSphereDatabase database, final
String schemaName,
final Collection<ShardingSphereTable>
alteredTables, final Collection<ShardingSphereView> alteredViews,
final Collection<String> droppedTables, final
Collection<String> droppedViews) {
DatabaseMetaDataPersistFacade databaseMetaDataFacade =
metaDataPersistFacade.getDatabaseMetaDataFacade();
- databaseMetaDataFacade.getTable().persist(databaseName, schemaName,
alteredTables);
- databaseMetaDataFacade.getView().persist(databaseName, schemaName,
alteredViews);
- droppedTables.forEach(each ->
databaseMetaDataFacade.getTable().drop(databaseName, schemaName, each));
- droppedViews.forEach(each ->
databaseMetaDataFacade.getView().drop(databaseName, schemaName, each));
+ databaseMetaDataFacade.getTable().persist(database.getName(),
schemaName, alteredTables);
+ databaseMetaDataFacade.getView().persist(database.getName(),
schemaName, alteredViews);
+ droppedTables.forEach(each ->
databaseMetaDataFacade.getTable().drop(database.getName(), schemaName, each));
+ droppedViews.forEach(each ->
databaseMetaDataFacade.getView().drop(database.getName(), schemaName, each));
}
@Override
- public void renameSchema(final String databaseName, final String
schemaName, final String renameSchemaName) {
- ShardingSphereSchema schema =
metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getSchema(schemaName);
+ public void renameSchema(final ShardingSphereDatabase database, final
String schemaName, final String renameSchemaName) {
+ ShardingSphereSchema schema =
metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(database.getName()).getSchema(schemaName);
if (schema.isEmpty()) {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().add(databaseName,
renameSchemaName);
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().add(database.getName(),
renameSchemaName);
} else {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().persist(databaseName,
renameSchemaName, schema.getAllTables());
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getView().persist(databaseName,
renameSchemaName, schema.getAllViews());
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().persist(database.getName(),
renameSchemaName, schema.getAllTables());
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getView().persist(database.getName(),
renameSchemaName, schema.getAllViews());
}
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().drop(databaseName,
schemaName);
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().drop(database.getName(),
schemaName);
}
@Override
- public void dropSchema(final String databaseName, final Collection<String>
schemaNames) {
- schemaNames.forEach(each -> dropSchema(databaseName, each));
+ public void dropSchema(final ShardingSphereDatabase database, final
Collection<String> schemaNames) {
+ schemaNames.forEach(each -> dropSchema(database.getName(), each));
}
private void dropSchema(final String databaseName, final String
schemaName) {
@@ -118,13 +119,13 @@ public final class ClusterMetaDataManagerPersistService
implements MetaDataManag
}
@Override
- public void createTable(final String databaseName, final String
schemaName, final ShardingSphereTable table) {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().persist(databaseName,
schemaName, Collections.singleton(table));
+ public void createTable(final ShardingSphereDatabase database, final
String schemaName, final ShardingSphereTable table) {
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().persist(database.getName(),
schemaName, Collections.singleton(table));
}
@Override
- public void dropTable(final String databaseName, final String schemaName,
final String tableName) {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().drop(databaseName,
schemaName, tableName);
+ public void dropTable(final ShardingSphereDatabase database, final String
schemaName, final String tableName) {
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().drop(database.getName(),
schemaName, tableName);
}
@Override
@@ -146,19 +147,19 @@ public final class ClusterMetaDataManagerPersistService
implements MetaDataManag
}
@Override
- public void alterStorageUnits(final String databaseName, final Map<String,
DataSourcePoolProperties> toBeUpdatedProps) throws SQLException {
+ public void alterStorageUnits(final ShardingSphereDatabase database, final
Map<String, DataSourcePoolProperties> toBeUpdatedProps) throws SQLException {
MetaDataContexts originalMetaDataContexts = new
MetaDataContexts(metaDataContextManager.getMetaDataContexts().getMetaData(),
metaDataContextManager.getMetaDataContexts().getStatistics());
Map<StorageNode, DataSource> newDataSources = new
HashMap<>(toBeUpdatedProps.size());
try {
SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager()
-
.switchByAlterStorageUnit(originalMetaDataContexts.getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeUpdatedProps);
+
.switchByAlterStorageUnit(originalMetaDataContexts.getMetaData().getDatabase(database.getName()).getResourceMetaData(),
toBeUpdatedProps);
newDataSources.putAll(switchingResource.getNewDataSources());
MetaDataContexts reloadMetaDataContexts = new
MetaDataContextsFactory(metaDataPersistFacade,
metaDataContextManager.getComputeNodeInstanceContext()).createBySwitchResource(
- databaseName, false, switchingResource,
originalMetaDataContexts);
+ database.getName(), false, switchingResource,
originalMetaDataContexts);
DataSourceUnitPersistService dataSourceService =
metaDataPersistFacade.getDataSourceUnitService();
metaDataPersistFacade.getMetaDataVersionService()
-
.switchActiveVersion(dataSourceService.persist(databaseName, toBeUpdatedProps));
- afterStorageUnitsAltered(databaseName, originalMetaDataContexts,
reloadMetaDataContexts);
+
.switchActiveVersion(dataSourceService.persist(database.getName(),
toBeUpdatedProps));
+ afterStorageUnitsAltered(database.getName(),
originalMetaDataContexts, reloadMetaDataContexts);
reloadMetaDataContexts.getMetaData().close();
} finally {
closeNewDataSources(newDataSources);
@@ -166,15 +167,15 @@ public final class ClusterMetaDataManagerPersistService
implements MetaDataManag
}
@Override
- public void unregisterStorageUnits(final String databaseName, final
Collection<String> toBeDroppedStorageUnitNames) throws SQLException {
- for (String each : getToBeDroppedResourceNames(databaseName,
toBeDroppedStorageUnitNames)) {
+ public void unregisterStorageUnits(final ShardingSphereDatabase database,
final Collection<String> toBeDroppedStorageUnitNames) throws SQLException {
+ for (String each : getToBeDroppedResourceNames(database.getName(),
toBeDroppedStorageUnitNames)) {
MetaDataContexts originalMetaDataContexts = new
MetaDataContexts(metaDataContextManager.getMetaDataContexts().getMetaData(),
metaDataContextManager.getMetaDataContexts().getStatistics());
SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager()
-
.createByUnregisterStorageUnit(originalMetaDataContexts.getMetaData().getDatabase(databaseName).getResourceMetaData(),
Collections.singletonList(each));
+
.createByUnregisterStorageUnit(originalMetaDataContexts.getMetaData().getDatabase(database.getName()).getResourceMetaData(),
Collections.singletonList(each));
MetaDataContexts reloadMetaDataContexts = new
MetaDataContextsFactory(metaDataPersistFacade,
metaDataContextManager.getComputeNodeInstanceContext()).createBySwitchResource(
- databaseName, false, switchingResource,
originalMetaDataContexts);
-
metaDataPersistFacade.getDataSourceUnitService().delete(databaseName, each);
- afterStorageUnitsDropped(databaseName, originalMetaDataContexts,
reloadMetaDataContexts);
+ database.getName(), false, switchingResource,
originalMetaDataContexts);
+
metaDataPersistFacade.getDataSourceUnitService().delete(database.getName(),
each);
+ afterStorageUnitsDropped(database.getName(),
originalMetaDataContexts, reloadMetaDataContexts);
reloadMetaDataContexts.getMetaData().close();
}
}
@@ -211,21 +212,21 @@ public final class ClusterMetaDataManagerPersistService
implements MetaDataManag
}
@Override
- public void alterSingleRuleConfiguration(final String databaseName, final
RuleMetaData ruleMetaData) {
+ public void alterSingleRuleConfiguration(final ShardingSphereDatabase
database, final RuleMetaData ruleMetaData) {
SingleRuleConfiguration singleRuleConfig =
ruleMetaData.getSingleRule(SingleRule.class).getConfiguration();
- Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().persist(databaseName,
Collections.singleton(singleRuleConfig));
+ Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().persist(database.getName(),
Collections.singleton(singleRuleConfig));
metaDataPersistFacade.getMetaDataVersionService().switchActiveVersion(metaDataVersions);
}
@Override
- public void alterRuleConfiguration(final String databaseName, final
RuleConfiguration toBeAlteredRuleConfig) {
+ public void alterRuleConfiguration(final ShardingSphereDatabase database,
final RuleConfiguration toBeAlteredRuleConfig) {
if (null == toBeAlteredRuleConfig) {
return;
}
MetaDataContexts originalMetaDataContexts = new
MetaDataContexts(metaDataContextManager.getMetaDataContexts().getMetaData(),
metaDataContextManager.getMetaDataContexts().getStatistics());
- Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().persist(databaseName,
Collections.singleton(toBeAlteredRuleConfig));
+ Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().persist(database.getName(),
Collections.singleton(toBeAlteredRuleConfig));
metaDataPersistFacade.getMetaDataVersionService().switchActiveVersion(metaDataVersions);
- afterRuleConfigurationAltered(databaseName, originalMetaDataContexts);
+ afterRuleConfigurationAltered(database.getName(),
originalMetaDataContexts);
}
@SneakyThrows(InterruptedException.class)
@@ -237,17 +238,17 @@ public final class ClusterMetaDataManagerPersistService
implements MetaDataManag
}
@Override
- public void removeRuleConfigurationItem(final String databaseName, final
RuleConfiguration toBeRemovedRuleConfig) {
+ public void removeRuleConfigurationItem(final ShardingSphereDatabase
database, final RuleConfiguration toBeRemovedRuleConfig) {
if (null != toBeRemovedRuleConfig) {
-
metaDataPersistFacade.getDatabaseRuleService().delete(databaseName,
Collections.singleton(toBeRemovedRuleConfig));
+
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
Collections.singleton(toBeRemovedRuleConfig));
}
}
@Override
- public void removeRuleConfiguration(final String databaseName, final
String ruleName) {
+ public void removeRuleConfiguration(final ShardingSphereDatabase database,
final String ruleName) {
MetaDataContexts originalMetaDataContexts = new
MetaDataContexts(metaDataContextManager.getMetaDataContexts().getMetaData(),
metaDataContextManager.getMetaDataContexts().getStatistics());
- metaDataPersistFacade.getDatabaseRuleService().delete(databaseName,
ruleName);
- afterRuleConfigurationDropped(databaseName, originalMetaDataContexts);
+
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
ruleName);
+ afterRuleConfigurationDropped(database.getName(),
originalMetaDataContexts);
}
@SneakyThrows(InterruptedException.class)
diff --git
a/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistServiceTest.java
b/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistServiceTest.java
index 371f8299632..242359075f3 100644
---
a/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistServiceTest.java
+++
b/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistServiceTest.java
@@ -19,6 +19,7 @@ package
org.apache.shardingsphere.mode.manager.cluster.persist.service;
import lombok.SneakyThrows;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
@@ -80,20 +81,21 @@ class ClusterMetaDataManagerPersistServiceTest {
@Test
void assertDropDatabase() {
- metaDataManagerPersistService.dropDatabase("foo_db");
+ metaDataManagerPersistService.dropDatabase(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()));
verify(clusterDatabaseListenerPersistCoordinator).persist("foo_db",
ClusterDatabaseListenerCoordinatorType.DROP);
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getDatabase()).drop("foo_db");
}
@Test
void assertCreateSchema() {
- metaDataManagerPersistService.createSchema("foo_db", "foo_schema");
+ metaDataManagerPersistService.createSchema(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_schema");
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema()).add("foo_db",
"foo_schema");
}
@Test
void assertAlterSchema() {
- metaDataManagerPersistService.alterSchema("foo_db", "foo_schema",
Collections.emptyList(), Collections.emptyList(), Collections.emptyList(),
Collections.emptyList());
+ metaDataManagerPersistService.alterSchema(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()),
+ "foo_schema", Collections.emptyList(),
Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getTable()).persist("foo_db",
"foo_schema", Collections.emptyList());
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getView()).persist("foo_db",
"foo_schema", Collections.emptyList());
}
@@ -102,7 +104,7 @@ class ClusterMetaDataManagerPersistServiceTest {
void assertRenameNotEmptySchemaName() {
ShardingSphereSchema schema = mock(ShardingSphereSchema.class);
when(metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(schema);
- metaDataManagerPersistService.renameSchema("foo_db", "foo_schema",
"bar_schema");
+ metaDataManagerPersistService.renameSchema(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_schema", "bar_schema");
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getTable()).persist(eq("foo_db"),
eq("bar_schema"), anyCollection());
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getView()).persist(eq("foo_db"),
eq("bar_schema"), anyCollection());
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema()).drop("foo_db",
"foo_schema");
@@ -114,14 +116,14 @@ class ClusterMetaDataManagerPersistServiceTest {
ShardingSphereSchema schema = mock(ShardingSphereSchema.class);
when(schema.isEmpty()).thenReturn(true);
when(metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db").getSchema("foo_schema")).thenReturn(schema);
- metaDataManagerPersistService.renameSchema("foo_db", "foo_schema",
"bar_schema");
+ metaDataManagerPersistService.renameSchema(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_schema", "bar_schema");
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema()).drop("foo_db",
"foo_schema");
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema()).add("foo_db",
"bar_schema");
}
@Test
void assertDropSchema() {
- metaDataManagerPersistService.dropSchema("foo_db",
Collections.singleton("foo_schema"));
+ metaDataManagerPersistService.dropSchema(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), Collections.singleton("foo_schema"));
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema()).drop("foo_db",
"foo_schema");
}
@@ -131,39 +133,40 @@ class ClusterMetaDataManagerPersistServiceTest {
SingleRuleConfiguration singleRuleConfig = new
SingleRuleConfiguration();
when(singleRule.getConfiguration()).thenReturn(singleRuleConfig);
when(metaDataPersistFacade.getDatabaseRuleService().persist("foo_db",
Collections.singleton(singleRuleConfig))).thenReturn(Collections.emptyList());
- metaDataManagerPersistService.alterSingleRuleConfiguration("foo_db",
new RuleMetaData(Collections.singleton(singleRule)));
+ metaDataManagerPersistService.alterSingleRuleConfiguration(
+ new ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), new RuleMetaData(Collections.singleton(singleRule)));
verify(metaDataPersistFacade.getMetaDataVersionService()).switchActiveVersion(Collections.emptyList());
}
@Test
void assertAlterNullRuleConfiguration() {
- metaDataManagerPersistService.alterRuleConfiguration("foo_db", null);
+ metaDataManagerPersistService.alterRuleConfiguration(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), null);
verify(metaDataPersistFacade.getDatabaseRuleService(),
times(0)).persist(eq("foo_db"), any());
}
@Test
void assertAlterRuleConfiguration() {
RuleConfiguration ruleConfig = new SingleRuleConfiguration();
- metaDataManagerPersistService.alterRuleConfiguration("foo_db",
ruleConfig);
+ metaDataManagerPersistService.alterRuleConfiguration(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), ruleConfig);
verify(metaDataPersistFacade.getDatabaseRuleService()).persist("foo_db",
Collections.singleton(ruleConfig));
}
@Test
void assertRemoveNullRuleConfigurationItem() {
- metaDataManagerPersistService.removeRuleConfigurationItem("foo_db",
null);
+ metaDataManagerPersistService.removeRuleConfigurationItem(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), null);
verify(metaDataPersistFacade.getDatabaseRuleService(),
times(0)).delete(eq("foo_db"), anyCollection());
}
@Test
void assertRemoveRuleConfigurationItem() {
RuleConfiguration ruleConfig = new SingleRuleConfiguration();
- metaDataManagerPersistService.removeRuleConfigurationItem("foo_db",
ruleConfig);
+ metaDataManagerPersistService.removeRuleConfigurationItem(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), ruleConfig);
verify(metaDataPersistFacade.getDatabaseRuleService()).delete("foo_db",
Collections.singleton(ruleConfig));
}
@Test
void assertRemoveRuleConfiguration() {
- metaDataManagerPersistService.removeRuleConfiguration("foo_db",
"fixtureRule");
+ metaDataManagerPersistService.removeRuleConfiguration(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "fixtureRule");
verify(metaDataPersistFacade.getDatabaseRuleService()).delete("foo_db",
"fixtureRule");
}
@@ -184,13 +187,13 @@ class ClusterMetaDataManagerPersistServiceTest {
@Test
void assertCreateTable() {
ShardingSphereTable table = mock(ShardingSphereTable.class);
- metaDataManagerPersistService.createTable("foo_db", "foo_schema",
table);
+ metaDataManagerPersistService.createTable(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_schema", table);
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getTable()).persist("foo_db",
"foo_schema", Collections.singleton(table));
}
@Test
void assertDropTable() {
- metaDataManagerPersistService.dropTable("foo_db", "foo_schema",
"foo_tbl");
+ metaDataManagerPersistService.dropTable(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_schema", "foo_tbl");
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getTable()).drop("foo_db",
"foo_schema", "foo_tbl");
}
}
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
index a984bc3b8cd..e1d29fa919c 100644
---
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
@@ -78,51 +78,51 @@ public final class StandaloneMetaDataManagerPersistService
implements MetaDataMa
}
@Override
- public void dropDatabase(final String databaseName) {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getDatabase().drop(databaseName);
-
metaDataContextManager.getDatabaseMetaDataManager().dropDatabase(databaseName);
+ public void dropDatabase(final ShardingSphereDatabase database) {
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getDatabase().drop(database.getName());
+
metaDataContextManager.getDatabaseMetaDataManager().dropDatabase(database.getName());
clearServiceCache();
}
@Override
- public void createSchema(final String databaseName, final String
schemaName) {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().add(databaseName,
schemaName);
-
metaDataContextManager.getDatabaseMetaDataManager().addSchema(databaseName,
schemaName);
+ public void createSchema(final ShardingSphereDatabase database, final
String schemaName) {
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().add(database.getName(),
schemaName);
+
metaDataContextManager.getDatabaseMetaDataManager().addSchema(database.getName(),
schemaName);
}
@Override
- public void alterSchema(final String databaseName, final String schemaName,
+ public void alterSchema(final ShardingSphereDatabase database, final
String schemaName,
final Collection<ShardingSphereTable>
alteredTables, final Collection<ShardingSphereView> alteredViews,
final Collection<String> droppedTables, final
Collection<String> droppedViews) {
DatabaseMetaDataPersistFacade databaseMetaDataFacade =
metaDataPersistFacade.getDatabaseMetaDataFacade();
- databaseMetaDataFacade.getTable().persist(databaseName, schemaName,
alteredTables);
- databaseMetaDataFacade.getView().persist(databaseName, schemaName,
alteredViews);
- droppedTables.forEach(each ->
databaseMetaDataFacade.getTable().drop(databaseName, schemaName, each));
- droppedViews.forEach(each ->
databaseMetaDataFacade.getView().drop(databaseName, schemaName, each));
- alteredTables.forEach(each ->
metaDataContextManager.getDatabaseMetaDataManager().alterTable(databaseName,
schemaName, each));
- alteredViews.forEach(each ->
metaDataContextManager.getDatabaseMetaDataManager().alterView(databaseName,
schemaName, each));
- droppedTables.forEach(each ->
metaDataContextManager.getDatabaseMetaDataManager().dropTable(databaseName,
schemaName, each));
- droppedViews.forEach(each ->
metaDataContextManager.getDatabaseMetaDataManager().dropView(databaseName,
schemaName, each));
+ databaseMetaDataFacade.getTable().persist(database.getName(),
schemaName, alteredTables);
+ databaseMetaDataFacade.getView().persist(database.getName(),
schemaName, alteredViews);
+ droppedTables.forEach(each ->
databaseMetaDataFacade.getTable().drop(database.getName(), schemaName, each));
+ droppedViews.forEach(each ->
databaseMetaDataFacade.getView().drop(database.getName(), schemaName, each));
+ alteredTables.forEach(each ->
metaDataContextManager.getDatabaseMetaDataManager().alterTable(database.getName(),
schemaName, each));
+ alteredViews.forEach(each ->
metaDataContextManager.getDatabaseMetaDataManager().alterView(database.getName(),
schemaName, each));
+ droppedTables.forEach(each ->
metaDataContextManager.getDatabaseMetaDataManager().dropTable(database.getName(),
schemaName, each));
+ droppedViews.forEach(each ->
metaDataContextManager.getDatabaseMetaDataManager().dropView(database.getName(),
schemaName, each));
ShardingSphereMetaData metaData =
metaDataContextManager.getMetaDataContexts().getMetaData();
metaData.getGlobalRuleMetaData().getRules().forEach(each ->
((GlobalRule) each).refresh(metaData.getAllDatabases(),
GlobalRuleChangedType.SCHEMA_CHANGED));
}
@Override
- public void renameSchema(final String databaseName, final String
schemaName, final String renameSchemaName) {
- ShardingSphereSchema schema =
metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getSchema(schemaName);
+ public void renameSchema(final ShardingSphereDatabase database, final
String schemaName, final String renameSchemaName) {
+ ShardingSphereSchema schema =
metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(database.getName()).getSchema(schemaName);
if (schema.isEmpty()) {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().add(databaseName,
renameSchemaName);
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().add(database.getName(),
renameSchemaName);
} else {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().persist(databaseName,
renameSchemaName, schema.getAllTables());
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getView().persist(databaseName,
renameSchemaName, schema.getAllViews());
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().persist(database.getName(),
renameSchemaName, schema.getAllTables());
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getView().persist(database.getName(),
renameSchemaName, schema.getAllViews());
}
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().drop(databaseName,
schemaName);
-
metaDataContextManager.getDatabaseMetaDataManager().renameSchema(databaseName,
schemaName, renameSchemaName);
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().drop(database.getName(),
schemaName);
+
metaDataContextManager.getDatabaseMetaDataManager().renameSchema(database.getName(),
schemaName, renameSchemaName);
}
@Override
- public void dropSchema(final String databaseName, final Collection<String>
schemaNames) {
- schemaNames.forEach(each -> dropSchema(databaseName, each));
+ public void dropSchema(final ShardingSphereDatabase database, final
Collection<String> schemaNames) {
+ schemaNames.forEach(each -> dropSchema(database.getName(), each));
}
private void dropSchema(final String databaseName, final String
schemaName) {
@@ -131,15 +131,15 @@ public final class
StandaloneMetaDataManagerPersistService implements MetaDataMa
}
@Override
- public void createTable(final String databaseName, final String
schemaName, final ShardingSphereTable table) {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().persist(databaseName,
schemaName, Collections.singleton(table));
-
metaDataContextManager.getDatabaseMetaDataManager().alterTable(databaseName,
schemaName, table);
+ public void createTable(final ShardingSphereDatabase database, final
String schemaName, final ShardingSphereTable table) {
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().persist(database.getName(),
schemaName, Collections.singleton(table));
+
metaDataContextManager.getDatabaseMetaDataManager().alterTable(database.getName(),
schemaName, table);
}
@Override
- public void dropTable(final String databaseName, final String schemaName,
final String tableName) {
-
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().drop(databaseName,
schemaName, tableName);
-
metaDataContextManager.getDatabaseMetaDataManager().dropTable(databaseName,
schemaName, tableName);
+ public void dropTable(final ShardingSphereDatabase database, final String
schemaName, final String tableName) {
+
metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().drop(database.getName(),
schemaName, tableName);
+
metaDataContextManager.getDatabaseMetaDataManager().dropTable(database.getName(),
schemaName, tableName);
}
@Override
@@ -165,54 +165,53 @@ public final class
StandaloneMetaDataManagerPersistService implements MetaDataMa
}
@Override
- public void alterStorageUnits(final String databaseName, final Map<String,
DataSourcePoolProperties> toBeUpdatedProps) throws SQLException {
+ public void alterStorageUnits(final ShardingSphereDatabase database, final
Map<String, DataSourcePoolProperties> toBeUpdatedProps) throws SQLException {
SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(metaDataContextManager.getMetaDataContexts().getMetaData()
- .getDatabase(databaseName).getResourceMetaData(),
toBeUpdatedProps);
+ .getDatabase(database.getName()).getResourceMetaData(),
toBeUpdatedProps);
ShardingSphereDatabase changedDatabase = new
MetaDataContextsFactory(metaDataPersistFacade,
metaDataContextManager.getComputeNodeInstanceContext()).createChangedDatabase(
- databaseName, true, switchingResource, null,
metaDataContextManager.getMetaDataContexts());
+ database.getName(), true, switchingResource, null,
metaDataContextManager.getMetaDataContexts());
metaDataContextManager.getMetaDataContexts().getMetaData().putDatabase(changedDatabase);
metaDataContextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getRules()
.forEach(each -> ((GlobalRule)
each).refresh(metaDataContextManager.getMetaDataContexts().getMetaData().getAllDatabases(),
GlobalRuleChangedType.DATABASE_CHANGED));
DataSourceUnitPersistService dataSourceService =
metaDataPersistFacade.getDataSourceUnitService();
-
metaDataPersistFacade.getMetaDataVersionService().switchActiveVersion(dataSourceService.persist(databaseName,
toBeUpdatedProps));
+
metaDataPersistFacade.getMetaDataVersionService().switchActiveVersion(dataSourceService.persist(database.getName(),
toBeUpdatedProps));
switchingResource.closeStaleDataSources();
clearServiceCache();
}
@Override
- public void unregisterStorageUnits(final String databaseName, final
Collection<String> toBeDroppedStorageUnitNames) throws SQLException {
+ public void unregisterStorageUnits(final ShardingSphereDatabase database,
final Collection<String> toBeDroppedStorageUnitNames) throws SQLException {
SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().switchByUnregisterStorageUnit(metaDataContextManager.getMetaDataContexts().getMetaData()
- .getDatabase(databaseName).getResourceMetaData(),
toBeDroppedStorageUnitNames);
+ .getDatabase(database.getName()).getResourceMetaData(),
toBeDroppedStorageUnitNames);
MetaDataContexts reloadMetaDataContexts = new
MetaDataContextsFactory(metaDataPersistFacade,
metaDataContextManager.getComputeNodeInstanceContext()).createBySwitchResource(
- databaseName, false, switchingResource,
metaDataContextManager.getMetaDataContexts());
- ShardingSphereDatabase reloadDatabase =
reloadMetaDataContexts.getMetaData().getDatabase(databaseName);
- ShardingSphereDatabase currentDatabase =
metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName);
- metaDataPersistFacade.persistReloadDatabaseByDrop(databaseName,
reloadDatabase, currentDatabase);
- GenericSchemaManager.getToBeDroppedSchemaNames(reloadDatabase,
currentDatabase).forEach(each ->
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().drop(databaseName,
each));
+ database.getName(), false, switchingResource,
metaDataContextManager.getMetaDataContexts());
+ ShardingSphereDatabase reloadDatabase =
reloadMetaDataContexts.getMetaData().getDatabase(database.getName());
+ ShardingSphereDatabase currentDatabase =
metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(database.getName());
+ metaDataPersistFacade.persistReloadDatabaseByDrop(database.getName(),
reloadDatabase, currentDatabase);
+ GenericSchemaManager.getToBeDroppedSchemaNames(reloadDatabase,
currentDatabase).forEach(each ->
metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema().drop(database.getName(),
each));
metaDataContextManager.getMetaDataContexts().update(reloadMetaDataContexts);
switchingResource.closeStaleDataSources();
clearServiceCache();
}
@Override
- public void alterSingleRuleConfiguration(final String databaseName, final
RuleMetaData ruleMetaData) throws SQLException {
+ public void alterSingleRuleConfiguration(final ShardingSphereDatabase
database, final RuleMetaData ruleMetaData) throws SQLException {
SingleRuleConfiguration singleRuleConfig =
ruleMetaData.getSingleRule(SingleRule.class).getConfiguration();
- Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().persist(databaseName,
Collections.singleton(singleRuleConfig));
+ Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().persist(database.getName(),
Collections.singleton(singleRuleConfig));
metaDataPersistFacade.getMetaDataVersionService().switchActiveVersion(metaDataVersions);
-
metaDataContextManager.getDatabaseRuleConfigurationManager().alter(databaseName,
singleRuleConfig);
+
metaDataContextManager.getDatabaseRuleConfigurationManager().alter(database.getName(),
singleRuleConfig);
clearServiceCache();
}
@Override
- public void alterRuleConfiguration(final String databaseName, final
RuleConfiguration toBeAlteredRuleConfig) throws SQLException {
+ public void alterRuleConfiguration(final ShardingSphereDatabase database,
final RuleConfiguration toBeAlteredRuleConfig) throws SQLException {
if (null == toBeAlteredRuleConfig) {
return;
}
- Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService()
-
.persist(metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(),
Collections.singleton(toBeAlteredRuleConfig));
+ Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().persist(database.getName(),
Collections.singleton(toBeAlteredRuleConfig));
metaDataPersistFacade.getMetaDataVersionService().switchActiveVersion(metaDataVersions);
for (MetaDataVersion each : metaDataVersions) {
- Optional<AlterRuleItem> alterRuleItem =
ruleItemChangedBuilder.build(databaseName, each.getActiveVersionNodePath(),
each.getNextActiveVersion(), new RuleItemAlteredBuildExecutor());
+ Optional<AlterRuleItem> alterRuleItem =
ruleItemChangedBuilder.build(database.getName(),
each.getActiveVersionNodePath(), each.getNextActiveVersion(), new
RuleItemAlteredBuildExecutor());
if (alterRuleItem.isPresent()) {
metaDataContextManager.getDatabaseRuleItemManager().alter(alterRuleItem.get());
}
@@ -221,13 +220,13 @@ public final class
StandaloneMetaDataManagerPersistService implements MetaDataMa
}
@Override
- public void removeRuleConfigurationItem(final String databaseName, final
RuleConfiguration toBeRemovedRuleConfig) throws SQLException {
+ public void removeRuleConfigurationItem(final ShardingSphereDatabase
database, final RuleConfiguration toBeRemovedRuleConfig) throws SQLException {
if (null == toBeRemovedRuleConfig) {
return;
}
- Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().delete(databaseName,
Collections.singleton(toBeRemovedRuleConfig));
+ Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
Collections.singleton(toBeRemovedRuleConfig));
for (MetaDataVersion each : metaDataVersions) {
- Optional<DropRuleItem> dropRuleItem =
ruleItemChangedBuilder.build(databaseName, each.getActiveVersionNodePath(),
each.getNextActiveVersion(), new RuleItemDroppedBuildExecutor());
+ Optional<DropRuleItem> dropRuleItem =
ruleItemChangedBuilder.build(database.getName(),
each.getActiveVersionNodePath(), each.getNextActiveVersion(), new
RuleItemDroppedBuildExecutor());
if (dropRuleItem.isPresent()) {
metaDataContextManager.getDatabaseRuleItemManager().drop(dropRuleItem.get());
}
@@ -236,8 +235,8 @@ public final class StandaloneMetaDataManagerPersistService
implements MetaDataMa
}
@Override
- public void removeRuleConfiguration(final String databaseName, final
String ruleName) {
- metaDataPersistFacade.getDatabaseRuleService().delete(databaseName,
ruleName);
+ public void removeRuleConfiguration(final ShardingSphereDatabase database,
final String ruleName) {
+
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
ruleName);
clearServiceCache();
}
diff --git
a/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
b/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
index ef0b2e58b74..c83fbc26bdc 100644
---
a/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
+++
b/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
@@ -87,14 +87,14 @@ class StandaloneMetaDataManagerPersistServiceTest {
@Test
void assertDropDatabase() {
- metaDataManagerPersistService.dropDatabase("foo_db");
+ metaDataManagerPersistService.dropDatabase(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()));
verify(metaDataContextManager.getDatabaseMetaDataManager()).dropDatabase("foo_db");
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getDatabase()).drop("foo_db");
}
@Test
void assertCreateSchema() {
- metaDataManagerPersistService.createSchema("foo_db", "foo_schema");
+ metaDataManagerPersistService.createSchema(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_schema");
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema()).add("foo_db",
"foo_schema");
}
@@ -102,7 +102,8 @@ class StandaloneMetaDataManagerPersistServiceTest {
void assertAlterSchema() {
DatabaseMetaDataPersistFacade databaseMetaDataFacade =
mock(DatabaseMetaDataPersistFacade.class, RETURNS_DEEP_STUBS);
when(metaDataPersistFacade.getDatabaseMetaDataFacade()).thenReturn(databaseMetaDataFacade);
- metaDataManagerPersistService.alterSchema("foo_db", "foo_schema",
Collections.emptyList(), Collections.emptyList(), Collections.emptyList(),
Collections.emptyList());
+ metaDataManagerPersistService.alterSchema(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()),
+ "foo_schema", Collections.emptyList(),
Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
verify(databaseMetaDataFacade.getTable()).persist("foo_db",
"foo_schema", new LinkedList<>());
}
@@ -114,7 +115,7 @@ class StandaloneMetaDataManagerPersistServiceTest {
when(metaDataContextManager.getMetaDataContexts().getMetaData()).thenReturn(metaData);
DatabaseMetaDataPersistFacade databaseMetaDataFacade =
mock(DatabaseMetaDataPersistFacade.class, RETURNS_DEEP_STUBS);
when(metaDataPersistFacade.getDatabaseMetaDataFacade()).thenReturn(databaseMetaDataFacade);
- metaDataManagerPersistService.renameSchema("foo_db", "foo_schema",
"bar_schema");
+ metaDataManagerPersistService.renameSchema(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_schema", "bar_schema");
verify(databaseMetaDataFacade.getSchema(), times(0)).add("foo_db",
"bar_schema");
verify(databaseMetaDataFacade.getTable()).persist(eq("foo_db"),
eq("bar_schema"), anyCollection());
verify(databaseMetaDataFacade.getView()).persist(eq("foo_db"),
eq("bar_schema"), anyCollection());
@@ -131,7 +132,7 @@ class StandaloneMetaDataManagerPersistServiceTest {
when(metaDataContextManager.getMetaDataContexts().getMetaData()).thenReturn(metaData);
DatabaseMetaDataPersistFacade databaseMetaDataFacade =
mock(DatabaseMetaDataPersistFacade.class, RETURNS_DEEP_STUBS);
when(metaDataPersistFacade.getDatabaseMetaDataFacade()).thenReturn(databaseMetaDataFacade);
- metaDataManagerPersistService.renameSchema("foo_db", "foo_schema",
"bar_schema");
+ metaDataManagerPersistService.renameSchema(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_schema", "bar_schema");
verify(databaseMetaDataFacade.getSchema()).add("foo_db", "bar_schema");
verify(databaseMetaDataFacade.getSchema()).drop("foo_db",
"foo_schema");
}
@@ -143,7 +144,7 @@ class StandaloneMetaDataManagerPersistServiceTest {
when(database.getSchema("foo_schema")).thenReturn(new
ShardingSphereSchema("foo_schema"));
ShardingSphereMetaData metaData = new
ShardingSphereMetaData(Collections.singleton(database), mock(), mock(), new
ConfigurationProperties(new Properties()));
when(metaDataContextManager.getMetaDataContexts().getMetaData()).thenReturn(metaData);
- metaDataManagerPersistService.dropSchema("foo_db",
Collections.singleton("foo_schema"));
+ metaDataManagerPersistService.dropSchema(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), Collections.singleton("foo_schema"));
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getSchema()).drop("foo_db",
"foo_schema");
verify(metaDataContextManager.getDatabaseMetaDataManager()).dropSchema("foo_db",
"foo_schema");
}
@@ -153,14 +154,15 @@ class StandaloneMetaDataManagerPersistServiceTest {
SingleRuleConfiguration singleRuleConfig = new
SingleRuleConfiguration();
SingleRule singleRule = mock(SingleRule.class);
when(singleRule.getConfiguration()).thenReturn(singleRuleConfig);
- metaDataManagerPersistService.alterSingleRuleConfiguration("foo_db",
new RuleMetaData(Collections.singleton(singleRule)));
+ metaDataManagerPersistService.alterSingleRuleConfiguration(
+ new ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), new RuleMetaData(Collections.singleton(singleRule)));
verify(metaDataPersistFacade.getMetaDataVersionService()).switchActiveVersion(any());
verify(metaDataContextManager.getDatabaseRuleConfigurationManager()).alter("foo_db",
singleRuleConfig);
}
@Test
void assertAlterNullRuleConfiguration() throws SQLException {
- metaDataManagerPersistService.alterRuleConfiguration("foo_db", null);
+ metaDataManagerPersistService.alterRuleConfiguration(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), null);
verify(metaDataPersistFacade, times(0)).getMetaDataVersionService();
}
@@ -177,14 +179,14 @@ class StandaloneMetaDataManagerPersistServiceTest {
RuleItemChangedBuilder ruleItemChangedBuilder =
mock(RuleItemChangedBuilder.class);
when(ruleItemChangedBuilder.build(eq("foo_db"), any(), anyInt(),
any())).thenReturn(Optional.of(alterRuleItem));
setRuleConfigurationEventBuilder(ruleItemChangedBuilder);
- metaDataManagerPersistService.alterRuleConfiguration("foo_db",
ruleConfig);
+ metaDataManagerPersistService.alterRuleConfiguration(database,
ruleConfig);
verify(metaDataPersistFacade.getMetaDataVersionService()).switchActiveVersion(metaDataVersion);
verify(metaDataContextManager.getDatabaseRuleItemManager()).alter(any(AlterRuleItem.class));
}
@Test
void assertRemoveNullRuleConfigurationItem() throws SQLException {
- metaDataManagerPersistService.removeRuleConfigurationItem("foo_db",
null);
+ metaDataManagerPersistService.removeRuleConfigurationItem(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), null);
verify(metaDataPersistFacade, times(0)).getMetaDataVersionService();
}
@@ -197,13 +199,13 @@ class StandaloneMetaDataManagerPersistServiceTest {
DropRuleItem dropRuleItem = mock(DropRuleItem.class);
when(ruleItemChangedBuilder.build(eq("foo_db"), any(), anyInt(),
any())).thenReturn(Optional.of(dropRuleItem));
setRuleConfigurationEventBuilder(ruleItemChangedBuilder);
- metaDataManagerPersistService.removeRuleConfigurationItem("foo_db",
ruleConfig);
+ metaDataManagerPersistService.removeRuleConfigurationItem(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), ruleConfig);
verify(metaDataContextManager.getDatabaseRuleItemManager()).drop(any(DropRuleItem.class));
}
@Test
void assertRemoveRuleConfiguration() {
- metaDataManagerPersistService.removeRuleConfiguration("foo_db",
"foo_rule");
+ metaDataManagerPersistService.removeRuleConfiguration(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_rule");
verify(metaDataPersistFacade.getDatabaseRuleService()).delete("foo_db",
"foo_rule");
}
@@ -226,13 +228,13 @@ class StandaloneMetaDataManagerPersistServiceTest {
@Test
void assertCreateTable() {
ShardingSphereTable table = new ShardingSphereTable("foo_tbl",
Collections.emptyList(), Collections.emptyList(), Collections.emptyList(),
TableType.TABLE);
- metaDataManagerPersistService.createTable("foo_db", "foo_schema",
table);
+ metaDataManagerPersistService.createTable(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_schema", table);
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getTable()).persist("foo_db",
"foo_schema", Collections.singleton(table));
}
@Test
void assertDropTable() {
- metaDataManagerPersistService.dropTable("foo_db", "foo_schema",
"foo_tbl");
+ metaDataManagerPersistService.dropTable(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList()), "foo_schema", "foo_tbl");
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getTable()).drop("foo_db",
"foo_schema", "foo_tbl");
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/DropDatabaseBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/DropDatabaseBackendHandler.java
index c6de2b3f49a..463c0b968be 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/DropDatabaseBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/database/DropDatabaseBackendHandler.java
@@ -26,6 +26,7 @@ import
org.apache.shardingsphere.infra.database.core.type.DatabaseTypeRegistry;
import
org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.DatabaseDropNotExistsException;
import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.UnknownDatabaseException;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.user.Grantee;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.handler.ProxyBackendHandler;
@@ -54,8 +55,8 @@ public final class DropDatabaseBackendHandler implements
ProxyBackendHandler {
connectionSession.setCurrentDatabaseName(null);
}
if
(ProxyContext.getInstance().databaseExists(sqlStatement.getDatabaseName())) {
- String databaseName =
ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getDatabase(sqlStatement.getDatabaseName()).getName();
-
ProxyContext.getInstance().getContextManager().getPersistServiceFacade().getMetaDataManagerPersistService().dropDatabase(databaseName);
+ ShardingSphereDatabase database =
ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData().getDatabase(sqlStatement.getDatabaseName());
+
ProxyContext.getInstance().getContextManager().getPersistServiceFacade().getMetaDataManagerPersistService().dropDatabase(database);
}
return new UpdateResponseHeader(sqlStatement);
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
index 0e590cb6625..e427faa3106 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
@@ -85,7 +85,7 @@ public final class YamlDatabaseConfigurationImportExecutor {
importDataSources(databaseName, yamlConfig.getDataSources());
importRules(databaseName, yamlConfig.getRules());
} catch (final ShardingSphereSQLException ex) {
-
dropDatabase(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName());
+
dropDatabase(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName));
throw ex;
}
}
@@ -160,7 +160,7 @@ public final class YamlDatabaseConfigurationImportExecutor {
return result;
}
- private void dropDatabase(final String databaseName) {
-
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService().dropDatabase(databaseName);
+ private void dropDatabase(final ShardingSphereDatabase database) {
+
contextManager.getPersistServiceFacade().getMetaDataManagerPersistService().dropDatabase(database);
}
}
