This is an automated email from the ASF dual-hosted git repository.
soulasuna 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 a8b6562af3b Extract SchemaManager for schema meta data changed (#20830)
a8b6562af3b is described below
commit a8b6562af3bddc0c6ea8388552e22576027258a8
Author: zhaojinchao <[email protected]>
AuthorDate: Wed Sep 7 10:10:21 2022 +0800
Extract SchemaManager for schema meta data changed (#20830)
---
.../metadata/database/schema/SchemaManager.java | 87 ++++++++++++++++++++++
.../database/schema/SchemaManagerTest.java | 71 ++++++++++++++++++
.../mode/manager/ContextManager.java | 45 ++++++-----
.../service/DatabaseMetaDataPersistService.java | 20 ++++-
.../schema/TableMetaDataPersistService.java | 26 +------
.../service/schema/ViewMetaDataPersistService.java | 24 +-----
.../DatabaseMetaDataPersistServiceTest.java | 14 +++-
7 files changed, 216 insertions(+), 71 deletions(-)
diff --git
a/shardingsphere-infra/shardingsphere-infra-common/src/main/java/org/apache/shardingsphere/infra/metadata/database/schema/SchemaManager.java
b/shardingsphere-infra/shardingsphere-infra-common/src/main/java/org/apache/shardingsphere/infra/metadata/database/schema/SchemaManager.java
new file mode 100644
index 00000000000..cee27b1bda2
--- /dev/null
+++
b/shardingsphere-infra/shardingsphere-infra-common/src/main/java/org/apache/shardingsphere/infra/metadata/database/schema/SchemaManager.java
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.infra.metadata.database.schema;
+
+import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereSchema;
+import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereTable;
+import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereView;
+
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
+/**
+ * Schema meta data manager.
+ */
+public final class SchemaManager {
+
+ /**
+ * Get to be deleted schema meta data.
+ *
+ * @param loadedSchema loaded schema
+ * @param currentSchema current schema
+ * @return To be deleted schema meta data
+ */
+ public static ShardingSphereSchema getToBeDeletedSchemaMetaData(final
ShardingSphereSchema loadedSchema, final ShardingSphereSchema currentSchema) {
+ return new
ShardingSphereSchema(getToBeDeletedTables(loadedSchema.getTables(),
currentSchema.getTables()), getToBeDeletedViews(loadedSchema.getViews(),
currentSchema.getViews()));
+ }
+
+ /**
+ * Get to be added table meta data.
+ *
+ * @param loadedTables loaded tables
+ * @param currentTables current tables
+ * @return To be added table meta data
+ */
+ public static Map<String, ShardingSphereTable> getToBeAddedTables(final
Map<String, ShardingSphereTable> loadedTables, final Map<String,
ShardingSphereTable> currentTables) {
+ return loadedTables.entrySet().stream().filter(entry ->
!entry.getValue().equals(currentTables.get(entry.getKey()))).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
+ }
+
+ /**
+ * Get to be deleted table meta data.
+ *
+ * @param loadedTables loaded tables
+ * @param currentTables current tables
+ * @return To be deleted table meta data
+ */
+ public static Map<String, ShardingSphereTable> getToBeDeletedTables(final
Map<String, ShardingSphereTable> loadedTables, final Map<String,
ShardingSphereTable> currentTables) {
+ return currentTables.entrySet().stream().filter(entry ->
!loadedTables.containsKey(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
+ }
+
+ /**
+ * Get to be added view meta data.
+ *
+ * @param loadedViews loaded views
+ * @param currentViews current views
+ * @return To be added view meta data
+ */
+ public static Map<String, ShardingSphereView> getToBeAddedViews(final
Map<String, ShardingSphereView> loadedViews, final Map<String,
ShardingSphereView> currentViews) {
+ return loadedViews.entrySet().stream().filter(entry ->
!entry.getValue().equals(currentViews.get(entry.getKey()))).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
+ }
+
+ /**
+ * Get to be deleted view meta data.
+ *
+ * @param loadedViews loaded views
+ * @param currentViews current views
+ * @return To be deleted view meta data
+ */
+ public static Map<String, ShardingSphereView> getToBeDeletedViews(final
Map<String, ShardingSphereView> loadedViews, final Map<String,
ShardingSphereView> currentViews) {
+ return currentViews.entrySet().stream().filter(entry ->
!loadedViews.containsKey(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
+ }
+}
diff --git
a/shardingsphere-infra/shardingsphere-infra-common/src/test/java/org/apache/shardingsphere/infra/metadata/database/schema/SchemaManagerTest.java
b/shardingsphere-infra/shardingsphere-infra-common/src/test/java/org/apache/shardingsphere/infra/metadata/database/schema/SchemaManagerTest.java
new file mode 100644
index 00000000000..6734e816557
--- /dev/null
+++
b/shardingsphere-infra/shardingsphere-infra-common/src/test/java/org/apache/shardingsphere/infra/metadata/database/schema/SchemaManagerTest.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.infra.metadata.database.schema;
+
+import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereSchema;
+import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereTable;
+import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereView;
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.Map;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+public final class SchemaManagerTest {
+
+ @Test
+ public void assertGetToBeDeletedSchemaMetaData() {
+ ShardingSphereSchema loadedSchemas = new
ShardingSphereSchema(Collections.emptyMap(), Collections.emptyMap());
+ ShardingSphereSchema currentSchemas =
+ new ShardingSphereSchema(Collections.singletonMap("foo_table",
new ShardingSphereTable()), Collections.singletonMap("foo_view", new
ShardingSphereView("", "")));
+ ShardingSphereSchema actual =
SchemaManager.getToBeDeletedSchemaMetaData(loadedSchemas, currentSchemas);
+ assertThat(actual.getTables().size(), is(1));
+ assertThat(actual.getViews().size(), is(1));
+ }
+
+ @Test
+ public void assertGetToBeAddedTables() {
+ Map<String, ShardingSphereTable> actual =
SchemaManager.getToBeAddedTables(Collections.singletonMap("foo_table", new
ShardingSphereTable()), Collections.emptyMap());
+ assertThat(actual.size(), is(1));
+ assertTrue(actual.containsKey("foo_table"));
+ }
+
+ @Test
+ public void assertGetToBeDeletedTables() {
+ Map<String, ShardingSphereTable> actual =
SchemaManager.getToBeDeletedTables(Collections.emptyMap(),
Collections.singletonMap("foo_table", new ShardingSphereTable()));
+ assertThat(actual.size(), is(1));
+ assertTrue(actual.containsKey("foo_table"));
+ }
+
+ @Test
+ public void assertGetToBeAddedViews() {
+ Map<String, ShardingSphereView> actual =
SchemaManager.getToBeAddedViews(Collections.singletonMap("foo_view", new
ShardingSphereView("", "")), Collections.emptyMap());
+ assertThat(actual.size(), is(1));
+ assertTrue(actual.containsKey("foo_view"));
+ }
+
+ @Test
+ public void assertGetToBeDeletedViews() {
+ Map<String, ShardingSphereView> actual =
SchemaManager.getToBeDeletedViews(Collections.emptyMap(),
Collections.singletonMap("foo_view", new ShardingSphereView("", "")));
+ assertThat(actual.size(), is(1));
+ assertTrue(actual.containsKey("foo_view"));
+ }
+}
diff --git
a/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
b/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
index 2ff6c460d18..d18688b3f2a 100644
---
a/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
+++
b/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
@@ -34,6 +34,7 @@ import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabasesFactory;
import
org.apache.shardingsphere.infra.metadata.database.resource.ShardingSphereResource;
import
org.apache.shardingsphere.infra.metadata.database.rule.ShardingSphereRuleMetaData;
+import org.apache.shardingsphere.infra.metadata.database.schema.SchemaManager;
import
org.apache.shardingsphere.infra.metadata.database.schema.builder.GenericSchemaBuilder;
import
org.apache.shardingsphere.infra.metadata.database.schema.builder.GenericSchemaBuilderMaterials;
import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereSchema;
@@ -246,8 +247,7 @@ public final class ContextManager implements AutoCloseable {
Map<String, DataSourceProperties> toBeReservedDataSourcePropsMap =
getToBeReservedDataSourcePropsMap(databaseName, toBeDroppedResourceNames);
SwitchingResource switchingResource = new
ResourceSwitchManager().create(metaDataContexts.getMetaData().getDatabase(databaseName).getResource(),
toBeReservedDataSourcePropsMap);
Map<String, ShardingSphereDatabase> reloadDatabases =
createChangedDatabases(databaseName, switchingResource, null);
- // TODO Consider add drop view logic
-
deleteTableMetaData(metaDataContexts.getMetaData().getDatabase(databaseName),
reloadDatabases.get(databaseName.toLowerCase()));
+ deleteSchemaMetaData(databaseName,
reloadDatabases.get(databaseName.toLowerCase()),
metaDataContexts.getMetaData().getDatabase(databaseName));
metaDataContexts.getMetaData().getDatabases().putAll(reloadDatabases);
metaDataContexts.getPersistService().getDataSourceService().persist(metaDataContexts.getMetaData().getActualDatabaseName(databaseName),
toBeReservedDataSourcePropsMap);
toBeDroppedResourceNames.forEach(each ->
metaDataContexts.getMetaData().getDatabase(databaseName).getResource().getDataSources().remove(each));
@@ -259,6 +259,19 @@ public final class ContextManager implements AutoCloseable
{
return dataSourcePropsMap.entrySet().stream().filter(entry ->
!toBeDroppedResourceNames.contains(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
}
+ private synchronized void deleteSchemaMetaData(final String databaseName,
final ShardingSphereDatabase reloadDatabase, final ShardingSphereDatabase
currentDatabase) {
+ getToBeDeletedSchemaMetaData(reloadDatabase.getSchemas(),
+ currentDatabase.getSchemas()).forEach((key, value) ->
metaDataContexts.getPersistService().getDatabaseMetaDataService().delete(databaseName,
key, value));
+ deleteSchemas(databaseName, reloadDatabase, currentDatabase);
+ }
+
+ private Map<String, ShardingSphereSchema>
getToBeDeletedSchemaMetaData(final Map<String, ShardingSphereSchema>
loadedSchemas, final Map<String, ShardingSphereSchema> currentSchemas) {
+ Map<String, ShardingSphereSchema> result = new
LinkedHashMap<>(currentSchemas.size(), 1);
+ currentSchemas.entrySet().stream().filter(entry ->
loadedSchemas.containsKey(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue))
+ .forEach((key, value) -> result.put(key,
SchemaManager.getToBeDeletedSchemaMetaData(loadedSchemas.get(key), value)));
+ return result;
+ }
+
/**
* Alter rule configuration.
*
@@ -402,37 +415,21 @@ public final class ContextManager implements
AutoCloseable {
ShardingSphereResource currentResource =
metaDataContexts.getMetaData().getDatabase(databaseName).getResource();
SwitchingResource switchingResource = new
SwitchingResource(currentResource, currentResource.getDataSources(),
Collections.emptyMap());
MetaDataContexts reloadedMetaDataContexts =
createMetaDataContexts(databaseName, switchingResource, null);
- Map<String, ShardingSphereSchema> toBeDeletedSchemas =
getToBeDeletedSchemas(reloadedMetaDataContexts.getMetaData().getDatabase(databaseName));
+ deleteSchemas(databaseName,
reloadedMetaDataContexts.getMetaData().getDatabase(databaseName),
metaDataContexts.getMetaData().getDatabase(databaseName));
metaDataContexts = reloadedMetaDataContexts;
- toBeDeletedSchemas.keySet().forEach(each ->
reloadedMetaDataContexts.getPersistService().getDatabaseMetaDataService().dropSchema(databaseName,
each));
compareAndPersistMetaData(reloadedMetaDataContexts);
} catch (final SQLException ex) {
log.error("Reload database: {} failed", databaseName, ex);
}
}
- private void deleteTableMetaData(final ShardingSphereDatabase
currentDatabase, final ShardingSphereDatabase reloadDatabase) {
- Map<String, ShardingSphereSchema> toBeDeletedTables =
getToBeDeletedTables(currentDatabase.getSchemas(), reloadDatabase.getSchemas());
- toBeDeletedTables.forEach((key, value) -> value.getTables().keySet()
- .forEach(each ->
metaDataContexts.getPersistService().getDatabaseMetaDataService().getTableMetaDataPersistService().delete(currentDatabase.getName(),
key, each)));
- Map<String, ShardingSphereSchema> toBeDeletedSchemas =
getToBeDeletedSchemas(reloadDatabase);
- toBeDeletedSchemas.keySet().forEach(each ->
metaDataContexts.getPersistService().getDatabaseMetaDataService().dropSchema(currentDatabase.getName(),
each));
- }
-
- private Map<String, ShardingSphereSchema> getToBeDeletedTables(final
Map<String, ShardingSphereSchema> currentSchemas, final Map<String,
ShardingSphereSchema> reloadedSchemas) {
- Map<String, ShardingSphereSchema> result = new
LinkedHashMap<>(currentSchemas.size(), 1);
- currentSchemas.entrySet().stream().filter(entry ->
reloadedSchemas.containsKey(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue))
- .forEach((key, value) -> result.put(key, new
ShardingSphereSchema(getToBeDeletedTables(value, reloadedSchemas.get(key)),
Collections.emptyMap())));
- return result;
- }
-
- private Map<String, ShardingSphereTable> getToBeDeletedTables(final
ShardingSphereSchema currentSchema, final ShardingSphereSchema reloadedSchema) {
- return currentSchema.getTables().entrySet().stream().filter(entry ->
!reloadedSchema.getTables().containsKey(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
+ private synchronized void deleteSchemas(final String databaseName, final
ShardingSphereDatabase reloadDatabase, final ShardingSphereDatabase
currentDatabase) {
+ getToBeDeletedSchemas(reloadDatabase.getSchemas(),
currentDatabase.getSchemas()).keySet().forEach(each ->
+
metaDataContexts.getPersistService().getDatabaseMetaDataService().dropSchema(databaseName,
each));
}
- private Map<String, ShardingSphereSchema> getToBeDeletedSchemas(final
ShardingSphereDatabase reloadedDatabase) {
- Map<String, ShardingSphereSchema> currentSchemas =
metaDataContexts.getMetaData().getDatabase(reloadedDatabase.getName()).getSchemas();
- return currentSchemas.entrySet().stream().filter(entry ->
!reloadedDatabase.containsSchema(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
+ private Map<String, ShardingSphereSchema> getToBeDeletedSchemas(final
Map<String, ShardingSphereSchema> loadedSchemas, final Map<String,
ShardingSphereSchema> currentSchemas) {
+ return currentSchemas.entrySet().stream().filter(entry ->
!loadedSchemas.containsKey(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
}
private void persistMetaData(final String databaseName) {
diff --git
a/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/DatabaseMetaDataPersistService.java
b/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/DatabaseMetaDataPersistService.java
index fab932a1502..a614fd66c48 100644
---
a/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/DatabaseMetaDataPersistService.java
+++
b/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/DatabaseMetaDataPersistService.java
@@ -101,7 +101,9 @@ public final class DatabaseMetaDataPersistService {
* @param schema schema meta data
*/
public void compareAndPersist(final String databaseName, final String
schemaName, final ShardingSphereSchema schema) {
- addSchema(databaseName, schemaName);
+ if (schema.getTables().isEmpty() && schema.getViews().isEmpty()) {
+ addSchema(databaseName, schemaName);
+ }
tableMetaDataPersistService.compareAndPersist(databaseName,
schemaName, schema.getTables());
viewMetaDataPersistService.compareAndPersist(databaseName, schemaName,
schema.getViews());
}
@@ -114,11 +116,25 @@ public final class DatabaseMetaDataPersistService {
* @param schema schema meta data
*/
public void persist(final String databaseName, final String schemaName,
final ShardingSphereSchema schema) {
- addSchema(databaseName, schemaName);
+ if (schema.getTables().isEmpty() && schema.getViews().isEmpty()) {
+ addSchema(databaseName, schemaName);
+ }
tableMetaDataPersistService.persist(databaseName, schemaName,
schema.getTables());
viewMetaDataPersistService.persist(databaseName, schemaName,
schema.getViews());
}
+ /**
+ * Delete schema meta data.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param schema schema meta data
+ */
+ public void delete(final String databaseName, final String schemaName,
final ShardingSphereSchema schema) {
+ schema.getTables().forEach((key, value) ->
tableMetaDataPersistService.delete(databaseName, schemaName, key));
+ schema.getViews().forEach((key, value) ->
viewMetaDataPersistService.delete(databaseName, schemaName, key));
+ }
+
/**
* Load schema meta data.
*
diff --git
a/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/schema/TableMetaDataPersistService.java
b/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/schema/TableMetaDataPersistService.java
index 2e3d1b9ce51..0cd5ccc5706 100644
---
a/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/schema/TableMetaDataPersistService.java
+++
b/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/schema/TableMetaDataPersistService.java
@@ -19,6 +19,7 @@ package
org.apache.shardingsphere.mode.metadata.persist.service.schema;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang.StringUtils;
+import org.apache.shardingsphere.infra.metadata.database.schema.SchemaManager;
import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereTable;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import
org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereTable;
@@ -27,11 +28,9 @@ import
org.apache.shardingsphere.mode.metadata.persist.node.DatabaseMetaDataNode
import org.apache.shardingsphere.mode.persist.PersistRepository;
import java.util.Map;
-import java.util.Map.Entry;
import java.util.LinkedHashMap;
import java.util.Collection;
import java.util.Collections;
-import java.util.stream.Collectors;
/**
* Table meta data persist service.
@@ -43,16 +42,16 @@ public final class TableMetaDataPersistService implements
SchemaMetaDataPersistS
@Override
public void compareAndPersist(final String databaseName, final String
schemaName, final Map<String, ShardingSphereTable> loadedTables) {
- // TODO Add ShardingSphereSchemaFactory to support toBeAddedTables and
toBeDeletedTables.
Map<String, ShardingSphereTable> currentTables = load(databaseName,
schemaName);
- persist(databaseName, schemaName, getToBeAddedTables(loadedTables,
currentTables));
- getToBeDeletedTables(loadedTables, currentTables).forEach((key, value)
-> delete(databaseName, schemaName, key));
+ persist(databaseName, schemaName,
SchemaManager.getToBeAddedTables(loadedTables, currentTables));
+ SchemaManager.getToBeDeletedTables(loadedTables,
currentTables).forEach((key, value) -> delete(databaseName, schemaName, key));
}
@Override
public void persist(final String databaseName, final String schemaName,
final Map<String, ShardingSphereTable> tables) {
tables.forEach((key, value) ->
repository.persist(DatabaseMetaDataNode.getTableMetaDataPath(databaseName,
schemaName, key.toLowerCase()),
YamlEngine.marshal(new
YamlTableSwapper().swapToYamlConfiguration(value))));
+
}
@Override
@@ -66,23 +65,6 @@ public final class TableMetaDataPersistService implements
SchemaMetaDataPersistS
repository.delete(DatabaseMetaDataNode.getTableMetaDataPath(databaseName,
schemaName, tableName.toLowerCase()));
}
- private Map<String, ShardingSphereTable> getToBeAddedTables(final
Map<String, ShardingSphereTable> loadedTables, final Map<String,
ShardingSphereTable> currentTables) {
- Map<String, ShardingSphereTable> result = new
LinkedHashMap<>(loadedTables.size(), 1);
- for (Entry<String, ShardingSphereTable> entry :
loadedTables.entrySet()) {
- ShardingSphereTable currentTable =
currentTables.get(entry.getKey());
- if (null != currentTable &&
!entry.getValue().equals(currentTable)) {
- result.put(entry.getKey(), entry.getValue());
- } else if (null == currentTable) {
- result.put(entry.getKey(), entry.getValue());
- }
- }
- return result;
- }
-
- private Map<String, ShardingSphereTable> getToBeDeletedTables(final
Map<String, ShardingSphereTable> loadedTables, final Map<String,
ShardingSphereTable> currentTables) {
- return currentTables.entrySet().stream().filter(entry ->
!loadedTables.containsKey(entry.getKey())).collect(Collectors.toMap(Map.Entry::getKey,
Map.Entry::getValue));
- }
-
private Map<String, ShardingSphereTable>
getTableMetaDataByTableNames(final String databaseName, final String
schemaName, final Collection<String> tableNames) {
Map<String, ShardingSphereTable> result = new
LinkedHashMap<>(tableNames.size(), 1);
tableNames.forEach(each -> {
diff --git
a/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/schema/ViewMetaDataPersistService.java
b/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/schema/ViewMetaDataPersistService.java
index 907a36fd8d4..513a488d712 100644
---
a/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/schema/ViewMetaDataPersistService.java
+++
b/shardingsphere-mode/shardingsphere-mode-core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/service/schema/ViewMetaDataPersistService.java
@@ -19,6 +19,7 @@ package
org.apache.shardingsphere.mode.metadata.persist.service.schema;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang.StringUtils;
+import org.apache.shardingsphere.infra.metadata.database.schema.SchemaManager;
import
org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereView;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereView;
@@ -30,7 +31,6 @@ import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
-import java.util.stream.Collectors;
/**
* View meta data persist service.
@@ -42,10 +42,9 @@ public final class ViewMetaDataPersistService implements
SchemaMetaDataPersistSe
@Override
public void compareAndPersist(final String databaseName, final String
schemaName, final Map<String, ShardingSphereView> loadedViews) {
- // TODO Add ShardingSphereSchemaFactory to support getToBeAddedViews
and getToBeDeletedViews.
Map<String, ShardingSphereView> currentViews = load(databaseName,
schemaName);
- persist(databaseName, schemaName, getToBeAddedViews(loadedViews,
currentViews));
- getToBeDeletedViews(loadedViews, currentViews).forEach((key, value) ->
delete(databaseName, schemaName, key));
+ persist(databaseName, schemaName,
SchemaManager.getToBeAddedViews(loadedViews, currentViews));
+ SchemaManager.getToBeDeletedViews(loadedViews,
currentViews).forEach((key, value) -> delete(databaseName, schemaName, key));
}
@Override
@@ -65,23 +64,6 @@ public final class ViewMetaDataPersistService implements
SchemaMetaDataPersistSe
repository.delete(DatabaseMetaDataNode.getViewMetaDataPath(databaseName,
schemaName, viewName.toLowerCase()));
}
- private Map<String, ShardingSphereView> getToBeAddedViews(final
Map<String, ShardingSphereView> loadedViews, final Map<String,
ShardingSphereView> currentViews) {
- Map<String, ShardingSphereView> result = new
LinkedHashMap<>(loadedViews.size(), 1);
- for (Map.Entry<String, ShardingSphereView> entry :
loadedViews.entrySet()) {
- ShardingSphereView currentView = currentViews.get(entry.getKey());
- if (null != currentView && !entry.getValue().equals(currentView)) {
- result.put(entry.getKey(), entry.getValue());
- } else if (null == currentView) {
- result.put(entry.getKey(), entry.getValue());
- }
- }
- return result;
- }
-
- private Map<String, ShardingSphereView> getToBeDeletedViews(final
Map<String, ShardingSphereView> loadedViews, final Map<String,
ShardingSphereView> currentViews) {
- return currentViews.entrySet().stream().filter(entry ->
!loadedViews.containsKey(entry.getKey())).collect(Collectors.toMap(Map.Entry::getKey,
Map.Entry::getValue));
- }
-
private Map<String, ShardingSphereView> getViewMetaDataByViewNames(final
String databaseName, final String schemaName, final Collection<String>
viewNames) {
Map<String, ShardingSphereView> result = new
LinkedHashMap<>(viewNames.size(), 1);
viewNames.forEach(each -> {
diff --git
a/shardingsphere-mode/shardingsphere-mode-core/src/test/java/org/apache/shardingsphere/mode/metadata/persist/service/DatabaseMetaDataPersistServiceTest.java
b/shardingsphere-mode/shardingsphere-mode-core/src/test/java/org/apache/shardingsphere/mode/metadata/persist/service/DatabaseMetaDataPersistServiceTest.java
index fe7d92fb76d..b7a0e48f6d0 100644
---
a/shardingsphere-mode/shardingsphere-mode-core/src/test/java/org/apache/shardingsphere/mode/metadata/persist/service/DatabaseMetaDataPersistServiceTest.java
+++
b/shardingsphere-mode/shardingsphere-mode-core/src/test/java/org/apache/shardingsphere/mode/metadata/persist/service/DatabaseMetaDataPersistServiceTest.java
@@ -53,13 +53,24 @@ public final class DatabaseMetaDataPersistServiceTest {
@Mock
private PersistRepository repository;
+ @Test
+ public void assertPersistEmptySchemas() {
+ new DatabaseMetaDataPersistService(repository).persist("foo_db",
"foo_schema", new ShardingSphereSchema());
+
verify(repository).persist(eq("/metadata/foo_db/schemas/foo_schema/tables"),
anyString());
+ }
+
+ @Test
+ public void assertCompareAndPersistEmptySchemas() {
+ new
DatabaseMetaDataPersistService(repository).compareAndPersist("foo_db",
"foo_schema", new ShardingSphereSchema());
+
verify(repository).persist(eq("/metadata/foo_db/schemas/foo_schema/tables"),
anyString());
+ }
+
@Test
public void assertPersist() {
ShardingSphereTable table = new
YamlTableSwapper().swapToObject(YamlEngine.unmarshal(readYAML(),
YamlShardingSphereTable.class));
ShardingSphereSchema schema = new ShardingSphereSchema();
schema.getTables().put("t_order", table);
new DatabaseMetaDataPersistService(repository).persist("foo_db",
"foo_schema", schema);
-
verify(repository).persist(eq("/metadata/foo_db/schemas/foo_schema/tables"),
anyString());
verify(repository).persist(eq("/metadata/foo_db/schemas/foo_schema/tables/t_order"),
anyString());
}
@@ -101,7 +112,6 @@ public final class DatabaseMetaDataPersistServiceTest {
ShardingSphereView view = new ShardingSphereView("FOO_VIEW", "select
id from foo_table");
new DatabaseMetaDataPersistService(repository).persist("foo_db",
"foo_schema",
new ShardingSphereSchema(Collections.singletonMap("FOO_TABLE",
table), Collections.singletonMap("FOO_VIEW", view)));
-
verify(repository).persist(eq("/metadata/foo_db/schemas/foo_schema/tables"),
anyString());
verify(repository).persist(eq("/metadata/foo_db/schemas/foo_schema/tables/foo_table"),
anyString());
}
