This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 030030c77d5 New metadata structure for Standalone mode (#28027)
030030c77d5 is described below
commit 030030c77d5a1708070e957d62d11aa8a8dcb927
Author: zhaojinchao <[email protected]>
AuthorDate: Fri Aug 11 10:06:50 2023 +0800
New metadata structure for Standalone mode (#28027)
* New metadata structure for Standalone mode
* Fix ci
* Update
* Fix unit test
* Fix bug
---
...ava => NewStandaloneContextManagerBuilder.java} | 19 +-
.../NewStandaloneModeContextManager.java | 333 +++++++++++++++++++++
.../StandaloneContextManagerBuilder.java | 7 +-
...YamlPersistRepositoryConfigurationSwapper.java} | 7 +-
...eYamlPersistRepositoryConfigurationSwapper.java | 2 +-
....mode.YamlPersistRepositoryConfigurationSwapper | 1 +
...ardingsphere.mode.manager.ContextManagerBuilder | 1 +
.../distsql/ral/RALBackendHandlerFactory.java | 3 +-
.../distsql/rdl/RDLBackendHandlerFactory.java | 3 +-
.../rdl/rule/NewRuleDefinitionBackendHandler.java | 2 +-
10 files changed, 356 insertions(+), 22 deletions(-)
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/NewStandaloneContextManagerBuilder.java
similarity index 79%
copy from
mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
copy to
mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/NewStandaloneContextManagerBuilder.java
index 3495bd889c0..eeb80576e06 100644
---
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/NewStandaloneContextManagerBuilder.java
@@ -20,9 +20,9 @@ package org.apache.shardingsphere.mode.manager.standalone;
import
org.apache.shardingsphere.infra.config.mode.PersistRepositoryConfiguration;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstance;
import org.apache.shardingsphere.infra.instance.InstanceContext;
-import org.apache.shardingsphere.infra.util.eventbus.EventBusContext;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
-import org.apache.shardingsphere.metadata.persist.MetaDataPersistService;
+import org.apache.shardingsphere.infra.util.eventbus.EventBusContext;
+import org.apache.shardingsphere.metadata.persist.NewMetaDataPersistService;
import org.apache.shardingsphere.mode.lock.GlobalLockContext;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.mode.manager.ContextManagerBuilder;
@@ -30,26 +30,27 @@ import
org.apache.shardingsphere.mode.manager.ContextManagerBuilderParameter;
import
org.apache.shardingsphere.mode.manager.standalone.subscriber.StandaloneProcessSubscriber;
import
org.apache.shardingsphere.mode.manager.standalone.workerid.generator.StandaloneWorkerIdGenerator;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
-import org.apache.shardingsphere.mode.metadata.MetaDataContextsFactory;
+import org.apache.shardingsphere.mode.metadata.NewMetaDataContextsFactory;
import
org.apache.shardingsphere.mode.repository.standalone.StandalonePersistRepository;
import java.sql.SQLException;
import java.util.Properties;
/**
- * Standalone context manager builder.
+ * TODO Rename StandaloneContextManagerBuilder when metadata structure
adjustment completed. #25485
+ * New Standalone context manager builder.
*/
-public final class StandaloneContextManagerBuilder implements
ContextManagerBuilder {
+public final class NewStandaloneContextManagerBuilder implements
ContextManagerBuilder {
@Override
public ContextManager build(final ContextManagerBuilderParameter param)
throws SQLException {
PersistRepositoryConfiguration repositoryConfig =
param.getModeConfiguration().getRepository();
StandalonePersistRepository repository = TypedSPILoader.getService(
StandalonePersistRepository.class, null == repositoryConfig ?
null : repositoryConfig.getType(), null == repositoryConfig ? new Properties()
: repositoryConfig.getProps());
- MetaDataPersistService persistService = new
MetaDataPersistService(repository);
+ NewMetaDataPersistService persistService = new
NewMetaDataPersistService(repository);
InstanceContext instanceContext = buildInstanceContext(param);
new StandaloneProcessSubscriber(instanceContext.getEventBusContext());
- MetaDataContexts metaDataContexts =
MetaDataContextsFactory.create(persistService, param, instanceContext);
+ MetaDataContexts metaDataContexts =
NewMetaDataContextsFactory.create(persistService, param, instanceContext);
ContextManager result = new ContextManager(metaDataContexts,
instanceContext);
setContextManagerAware(result);
return result;
@@ -57,11 +58,11 @@ public final class StandaloneContextManagerBuilder
implements ContextManagerBuil
private InstanceContext buildInstanceContext(final
ContextManagerBuilderParameter param) {
return new InstanceContext(new
ComputeNodeInstance(param.getInstanceMetaData()),
- new StandaloneWorkerIdGenerator(),
param.getModeConfiguration(), new StandaloneModeContextManager(), new
GlobalLockContext(null), new EventBusContext());
+ new StandaloneWorkerIdGenerator(),
param.getModeConfiguration(), new NewStandaloneModeContextManager(), new
GlobalLockContext(null), new EventBusContext());
}
private void setContextManagerAware(final ContextManager contextManager) {
- ((StandaloneModeContextManager)
contextManager.getInstanceContext().getModeContextManager()).setContextManagerAware(contextManager);
+ ((NewStandaloneModeContextManager)
contextManager.getInstanceContext().getModeContextManager()).setContextManagerAware(contextManager);
}
@Override
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/NewStandaloneModeContextManager.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/NewStandaloneModeContextManager.java
new file mode 100644
index 00000000000..edfe3280a8f
--- /dev/null
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/NewStandaloneModeContextManager.java
@@ -0,0 +1,333 @@
+/*
+ * 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.mode.manager.standalone;
+
+import com.google.common.base.Strings;
+import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
+import org.apache.shardingsphere.infra.instance.mode.ModeContextManager;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereView;
+import
org.apache.shardingsphere.infra.metadata.database.schema.pojo.AlterSchemaMetaDataPOJO;
+import
org.apache.shardingsphere.infra.metadata.database.schema.pojo.AlterSchemaPOJO;
+import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
+import org.apache.shardingsphere.infra.rule.identifier.type.MetaDataHeldRule;
+import
org.apache.shardingsphere.infra.rule.identifier.type.MutableDataNodeRule;
+import org.apache.shardingsphere.infra.rule.identifier.type.ResourceHeldRule;
+import org.apache.shardingsphere.infra.rule.identifier.type.TableContainedRule;
+import
org.apache.shardingsphere.infra.spi.type.ordered.cache.OrderedServicesCache;
+import
org.apache.shardingsphere.metadata.persist.service.config.global.GlobalPersistService;
+import
org.apache.shardingsphere.metadata.persist.service.database.DatabaseMetaDataBasedPersistService;
+import org.apache.shardingsphere.mode.manager.ContextManager;
+import org.apache.shardingsphere.mode.manager.ContextManagerAware;
+import org.apache.shardingsphere.mode.manager.switcher.ResourceSwitchManager;
+import org.apache.shardingsphere.mode.manager.switcher.SwitchingResource;
+import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
+
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Properties;
+import java.util.stream.Collectors;
+
+/**
+ * TODO Rename StandaloneModeContextManager when metadata structure adjustment
completed. #25485
+ * New Standalone mode context manager.
+ */
+public final class NewStandaloneModeContextManager implements
ModeContextManager, ContextManagerAware {
+
+ private ContextManager contextManager;
+
+ @Override
+ public void createDatabase(final String databaseName) {
+
contextManager.getResourceMetaDataContextManager().addDatabase(databaseName);
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService().addDatabase(databaseName);
+ clearServiceCache();
+ }
+
+ @Override
+ public void dropDatabase(final String databaseName) {
+
contextManager.getResourceMetaDataContextManager().dropDatabase(databaseName);
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService().dropDatabase(databaseName);
+ clearServiceCache();
+ }
+
+ @Override
+ public void createSchema(final String databaseName, final String
schemaName) {
+ ShardingSphereSchema schema = new ShardingSphereSchema();
+ ShardingSphereDatabase database =
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName);
+ database.putSchema(schemaName, schema);
+ refreshMetaDataHeldRule(database);
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService().persist(databaseName,
schemaName, schema);
+ }
+
+ @Override
+ public void alterSchema(final AlterSchemaPOJO alterSchemaPOJO) {
+ ShardingSphereDatabase database =
contextManager.getMetaDataContexts().getMetaData().getDatabase(alterSchemaPOJO.getDatabaseName());
+ putSchemaMetaData(database, alterSchemaPOJO.getSchemaName(),
alterSchemaPOJO.getRenameSchemaName(),
alterSchemaPOJO.getLogicDataSourceName());
+ removeSchemaMetaData(database, alterSchemaPOJO.getSchemaName());
+ refreshMetaDataHeldRule(database);
+ DatabaseMetaDataBasedPersistService databaseMetaDataService =
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService();
+ databaseMetaDataService.persist(alterSchemaPOJO.getDatabaseName(),
alterSchemaPOJO.getRenameSchemaName(),
database.getSchema(alterSchemaPOJO.getRenameSchemaName()));
+
databaseMetaDataService.getViewMetaDataPersistService().persist(alterSchemaPOJO.getDatabaseName(),
alterSchemaPOJO.getRenameSchemaName(),
+
database.getSchema(alterSchemaPOJO.getRenameSchemaName()).getViews());
+ databaseMetaDataService.dropSchema(alterSchemaPOJO.getDatabaseName(),
alterSchemaPOJO.getSchemaName());
+ }
+
+ private void putSchemaMetaData(final ShardingSphereDatabase database,
final String schemaName, final String renameSchemaName, final String
logicDataSourceName) {
+ ShardingSphereSchema schema = database.getSchema(schemaName);
+ database.putSchema(renameSchemaName, schema);
+ addDataNode(database, logicDataSourceName, schemaName,
schema.getAllTableNames());
+ }
+
+ private void addDataNode(final ShardingSphereDatabase database, final
String logicDataSourceName, final String schemaName, final Collection<String>
tobeAddedTableNames) {
+ tobeAddedTableNames.forEach(each -> {
+ if (!Strings.isNullOrEmpty(logicDataSourceName) &&
isSingleTable(each, database)) {
+
database.getRuleMetaData().findRules(MutableDataNodeRule.class).forEach(rule ->
rule.put(logicDataSourceName, schemaName, each));
+ }
+ });
+ }
+
+ private void addDataNode(final ShardingSphereDatabase database, final
String logicDataSourceName, final String schemaName, final Map<String,
ShardingSphereTable> toBeAddedTables,
+ final Map<String, ShardingSphereView>
toBeAddedViews) {
+ addTablesToDataNode(database, schemaName, logicDataSourceName,
toBeAddedTables);
+ addViewsToDataNode(database, schemaName, logicDataSourceName,
toBeAddedTables, toBeAddedViews);
+ }
+
+ private void addTablesToDataNode(final ShardingSphereDatabase database,
final String schemaName, final String logicDataSourceName, final Map<String,
ShardingSphereTable> toBeAddedTables) {
+ for (Entry<String, ShardingSphereTable> entry :
toBeAddedTables.entrySet()) {
+ if (!Strings.isNullOrEmpty(logicDataSourceName) &&
isSingleTable(entry.getKey(), database)) {
+
database.getRuleMetaData().findRules(MutableDataNodeRule.class).forEach(rule ->
rule.put(logicDataSourceName, schemaName, entry.getKey()));
+ }
+ database.getSchema(schemaName).putTable(entry.getKey(),
entry.getValue());
+ }
+ }
+
+ private void addViewsToDataNode(final ShardingSphereDatabase database,
final String schemaName, final String logicDataSourceName,
+ final Map<String, ShardingSphereTable>
toBeAddedTables, final Map<String, ShardingSphereView> toBeAddedViews) {
+ for (Entry<String, ShardingSphereView> entry :
toBeAddedViews.entrySet()) {
+ if (!Strings.isNullOrEmpty(logicDataSourceName) &&
isSingleTable(entry.getKey(), database)) {
+
database.getRuleMetaData().findRules(MutableDataNodeRule.class).forEach(rule ->
rule.put(logicDataSourceName, schemaName, entry.getKey()));
+ }
+ database.getSchema(schemaName).putTable(entry.getKey(),
toBeAddedTables.get(entry.getKey().toLowerCase()));
+ database.getSchema(schemaName).putView(entry.getKey(),
entry.getValue());
+ }
+ }
+
+ private boolean isSingleTable(final String tableName, final
ShardingSphereDatabase database) {
+ return
database.getRuleMetaData().findRules(TableContainedRule.class).stream().noneMatch(each
-> each.getDistributedTableMapper().contains(tableName));
+ }
+
+ private void removeSchemaMetaData(final ShardingSphereDatabase database,
final String schemaName) {
+ ShardingSphereSchema schema = new
ShardingSphereSchema(database.getSchema(schemaName).getTables(),
database.getSchema(schemaName).getViews());
+ database.removeSchema(schemaName);
+
removeDataNode(database.getRuleMetaData().findRules(MutableDataNodeRule.class),
Collections.singletonList(schemaName), schema.getAllTableNames());
+ }
+
+ private void removeDataNode(final Collection<MutableDataNodeRule> rules,
final Collection<String> schemaNames, final Collection<String>
tobeRemovedTables) {
+ tobeRemovedTables.forEach(each -> rules.forEach(rule ->
rule.remove(schemaNames, each)));
+ }
+
+ private void removeDataNode(final ShardingSphereDatabase database, final
String schemaName, final Collection<String> tobeRemovedTables, final
Collection<String> tobeRemovedViews) {
+ removeTablesToDataNode(database, schemaName, tobeRemovedTables);
+ removeViewsToDataNode(database, schemaName, tobeRemovedTables,
tobeRemovedViews);
+ }
+
+ private void removeDataNode(final Collection<MutableDataNodeRule> rules,
final String schemaName, final Collection<String> tobeRemovedTables) {
+ tobeRemovedTables.forEach(each -> rules.forEach(rule ->
rule.remove(schemaName, each)));
+ }
+
+ private void removeTablesToDataNode(final ShardingSphereDatabase database,
final String schemaName, final Collection<String> toBeDroppedTables) {
+
removeDataNode(database.getRuleMetaData().findRules(MutableDataNodeRule.class),
schemaName, toBeDroppedTables);
+ toBeDroppedTables.forEach(each ->
database.getSchema(schemaName).removeTable(each));
+ }
+
+ private void removeViewsToDataNode(final ShardingSphereDatabase database,
final String schemaName, final Collection<String> toBeDroppedTables, final
Collection<String> toBeDroppedViews) {
+
removeDataNode(database.getRuleMetaData().findRules(MutableDataNodeRule.class),
schemaName, toBeDroppedViews);
+ ShardingSphereSchema schema = database.getSchema(schemaName);
+ toBeDroppedTables.forEach(schema::removeTable);
+ toBeDroppedViews.forEach(schema::removeView);
+ }
+
+ @Override
+ public void dropSchema(final String databaseName, final Collection<String>
schemaNames) {
+ Collection<String> tobeRemovedTables = new LinkedHashSet<>();
+ Collection<String> tobeRemovedSchemas = new LinkedHashSet<>();
+ ShardingSphereDatabase database =
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName);
+ for (String each : schemaNames) {
+ ShardingSphereSchema schema = new
ShardingSphereSchema(database.getSchema(each).getTables(),
database.getSchema(each).getViews());
+ database.removeSchema(each);
+ Optional.of(schema).ifPresent(optional ->
tobeRemovedTables.addAll(optional.getAllTableNames()));
+ tobeRemovedSchemas.add(each.toLowerCase());
+ }
+
removeDataNode(database.getRuleMetaData().findRules(MutableDataNodeRule.class),
tobeRemovedSchemas, tobeRemovedTables);
+ refreshMetaDataHeldRule(database);
+ }
+
+ @Override
+ public void alterSchemaMetaData(final AlterSchemaMetaDataPOJO
alterSchemaMetaDataPOJO) {
+ String databaseName = alterSchemaMetaDataPOJO.getDatabaseName();
+ String schemaName = alterSchemaMetaDataPOJO.getSchemaName();
+ ShardingSphereDatabase database =
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName);
+ Map<String, ShardingSphereTable> tables =
alterSchemaMetaDataPOJO.getAlteredTables().stream().collect(Collectors.toMap(ShardingSphereTable::getName,
table -> table));
+ Map<String, ShardingSphereView> views =
alterSchemaMetaDataPOJO.getAlteredViews().stream().collect(Collectors.toMap(ShardingSphereView::getName,
view -> view));
+ addDataNode(database,
alterSchemaMetaDataPOJO.getLogicDataSourceName(), schemaName, tables, views);
+ removeDataNode(database, schemaName,
alterSchemaMetaDataPOJO.getDroppedTables(),
alterSchemaMetaDataPOJO.getDroppedViews());
+ refreshMetaDataHeldRule(database);
+ DatabaseMetaDataBasedPersistService databaseMetaDataService =
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService();
+
databaseMetaDataService.getTableMetaDataPersistService().persist(databaseName,
schemaName, tables);
+
databaseMetaDataService.getViewMetaDataPersistService().persist(databaseName,
schemaName, views);
+ alterSchemaMetaDataPOJO.getDroppedTables().forEach(each ->
databaseMetaDataService.getTableMetaDataPersistService().delete(databaseName,
schemaName, each));
+ alterSchemaMetaDataPOJO.getDroppedViews().forEach(each ->
databaseMetaDataService.getViewMetaDataPersistService().delete(databaseName,
schemaName, each));
+ }
+
+ private void refreshMetaDataHeldRule(final ShardingSphereDatabase
database) {
+
contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().findRules(MetaDataHeldRule.class).forEach(each
-> each.alterDatabase(database));
+ }
+
+ @Override
+ public void registerStorageUnits(final String databaseName, final
Map<String, DataSourceProperties> toBeRegisterStorageUnitProps) throws
SQLException {
+ SwitchingResource switchingResource =
+ new
ResourceSwitchManager().create(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeRegisterStorageUnitProps);
+
contextManager.getMetaDataContexts().getMetaData().getDatabases().putAll(contextManager.getConfigurationContextManager().createChangedDatabases(databaseName,
false, switchingResource, null));
+
contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().findRules(ResourceHeldRule.class)
+ .forEach(each ->
each.addResource(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName)));
+
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getSchemas()
+ .forEach((schemaName, schema) ->
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService()
+
.persist(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(),
schemaName, schema));
+
contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService().append(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(),
+ toBeRegisterStorageUnitProps);
+ clearServiceCache();
+ }
+
+ @Override
+ public void alterStorageUnits(final String databaseName, final Map<String,
DataSourceProperties> toBeUpdatedStorageUnitProps) throws SQLException {
+ SwitchingResource switchingResource =
+ new
ResourceSwitchManager().create(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeUpdatedStorageUnitProps);
+
contextManager.getMetaDataContexts().getMetaData().getDatabases().putAll(contextManager.getConfigurationContextManager().createChangedDatabases(databaseName,
true, switchingResource, null));
+
contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().findRules(ResourceHeldRule.class)
+ .forEach(each ->
each.addResource(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName)));
+
contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService().append(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(),
+ toBeUpdatedStorageUnitProps);
+ switchingResource.closeStaleDataSources();
+ clearServiceCache();
+ }
+
+ @Override
+ public void unregisterStorageUnits(final String databaseName, final
Collection<String> toBeDroppedStorageUnitNames) throws SQLException {
+ Map<String, DataSourceProperties> dataSourcePropsMap =
contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService()
+
.load(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName());
+ Map<String, DataSourceProperties> toBeDeletedDataSourcePropsMap =
getToBeDeletedDataSourcePropsMap(dataSourcePropsMap,
toBeDroppedStorageUnitNames);
+ SwitchingResource switchingResource =
+ new
ResourceSwitchManager().createByDropResource(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeDeletedDataSourcePropsMap);
+ contextManager.getMetaDataContexts().getMetaData().getDatabases()
+
.putAll(contextManager.getConfigurationContextManager().renewDatabase(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName),
switchingResource));
+ MetaDataContexts reloadMetaDataContexts =
contextManager.getConfigurationContextManager().createMetaDataContexts(databaseName,
false, switchingResource, null);
+
contextManager.getConfigurationContextManager().alterSchemaMetaData(databaseName,
reloadMetaDataContexts.getMetaData().getDatabase(databaseName),
+
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName));
+ contextManager.deletedSchemaNames(databaseName,
reloadMetaDataContexts.getMetaData().getDatabase(databaseName),
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName));
+ contextManager.renewMetaDataContexts(reloadMetaDataContexts);
+ Map<String, DataSourceProperties> toBeReversedDataSourcePropsMap =
getToBeReversedDataSourcePropsMap(dataSourcePropsMap,
toBeDroppedStorageUnitNames);
+
contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService().persist(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(),
+ toBeReversedDataSourcePropsMap);
+ switchingResource.closeStaleDataSources();
+ clearServiceCache();
+ }
+
+ private Map<String, DataSourceProperties>
getToBeDeletedDataSourcePropsMap(final Map<String, DataSourceProperties>
dataSourcePropsMap, final Collection<String> toBeDroppedResourceNames) {
+ return dataSourcePropsMap.entrySet().stream().filter(entry ->
toBeDroppedResourceNames.contains(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
+ }
+
+ private Map<String, DataSourceProperties>
getToBeReversedDataSourcePropsMap(final Map<String, DataSourceProperties>
dataSourcePropsMap, final Collection<String> toBeDroppedResourceNames) {
+ return dataSourcePropsMap.entrySet().stream().filter(entry ->
!toBeDroppedResourceNames.contains(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
+ }
+
+ @Override
+ public void alterRuleConfiguration(final String databaseName, final
Collection<RuleConfiguration> ruleConfigs) {
+
contextManager.getConfigurationContextManager().alterRuleConfiguration(databaseName,
ruleConfigs);
+ contextManager.getMetaDataContexts().getPersistService()
+
.getDatabaseRulePersistService().persist(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(),
ruleConfigs);
+ clearServiceCache();
+ }
+
+ @Override
+ public Collection<MetaDataVersion> alterRuleConfiguration(final String
databaseName, final RuleConfiguration toBeAlteredRuleConfig) {
+ if (null != toBeAlteredRuleConfig) {
+
contextManager.getConfigurationContextManager().alterRuleConfiguration(databaseName,
Collections.singletonList(toBeAlteredRuleConfig));
+ contextManager.getMetaDataContexts().getPersistService()
+
.getDatabaseRulePersistService().persist(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(),
Collections.singletonList(toBeAlteredRuleConfig));
+ clearServiceCache();
+ }
+ return Collections.emptyList();
+ }
+
+ @Override
+ public void removeRuleConfigurationItem(final String databaseName, final
RuleConfiguration toBeRemovedRuleConfig) {
+ if (null != toBeRemovedRuleConfig) {
+
contextManager.getConfigurationContextManager().dropRuleConfiguration(databaseName,
toBeRemovedRuleConfig);
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseRulePersistService().delete(databaseName,
Collections.singleton(toBeRemovedRuleConfig));
+ clearServiceCache();
+ }
+ }
+
+ @Override
+ public void removeRuleConfiguration(final String databaseName, final
String ruleName) {
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseRulePersistService().delete(databaseName,
ruleName);
+ clearServiceCache();
+ }
+
+ @Override
+ public void alterGlobalRuleConfiguration(final
Collection<RuleConfiguration> globalRuleConfigs) {
+
contextManager.getConfigurationContextManager().alterGlobalRuleConfiguration(globalRuleConfigs);
+
contextManager.getMetaDataContexts().getPersistService().getGlobalRuleService().persist(contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getConfigurations());
+ clearServiceCache();
+ }
+
+ @Override
+ public void alterGlobalRuleConfiguration(final RuleConfiguration
toBeAlteredRuleConfig) {
+
contextManager.getConfigurationContextManager().alterGlobalRuleConfiguration(toBeAlteredRuleConfig);
+ GlobalPersistService<Collection<RuleConfiguration>> globalRuleService
=
contextManager.getMetaDataContexts().getPersistService().getGlobalRuleService();
+
contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService().switchActiveVersion(globalRuleService.persistConfig(Collections.singleton(toBeAlteredRuleConfig)));
+ clearServiceCache();
+ }
+
+ @Override
+ public void alterProperties(final Properties props) {
+ contextManager.getConfigurationContextManager().alterProperties(props);
+ if (null !=
contextManager.getMetaDataContexts().getPersistService().getPropsService()) {
+ Collection<MetaDataVersion> versions =
contextManager.getMetaDataContexts().getPersistService().getPropsService().persistConfig(props);
+
contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService().switchActiveVersion(versions);
+ }
+ clearServiceCache();
+ }
+
+ private void clearServiceCache() {
+ OrderedServicesCache.clearCache();
+ }
+
+ @Override
+ public void setContextManagerAware(final ContextManager contextManager) {
+ this.contextManager = contextManager;
+ }
+}
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
index 3495bd889c0..10d41830418 100644
---
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
@@ -66,11 +66,6 @@ public final class StandaloneContextManagerBuilder
implements ContextManagerBuil
@Override
public String getType() {
- return "Standalone";
- }
-
- @Override
- public boolean isDefault() {
- return true;
+ return "Compatible_Standalone";
}
}
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/yaml/StandaloneYamlPersistRepositoryConfigurationSwapper.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/yaml/NewStandaloneYamlPersistRepositoryConfigurationSwapper.java
similarity index 84%
copy from
mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/yaml/StandaloneYamlPersistRepositoryConfigurationSwapper.java
copy to
mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/yaml/NewStandaloneYamlPersistRepositoryConfigurationSwapper.java
index 333044900c7..7d0fd7ce34d 100644
---
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/yaml/StandaloneYamlPersistRepositoryConfigurationSwapper.java
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/yaml/NewStandaloneYamlPersistRepositoryConfigurationSwapper.java
@@ -17,14 +17,15 @@
package org.apache.shardingsphere.mode.manager.standalone.yaml;
-import
org.apache.shardingsphere.mode.repository.standalone.StandalonePersistRepositoryConfiguration;
import
org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlPersistRepositoryConfiguration;
import
org.apache.shardingsphere.infra.yaml.config.swapper.mode.YamlPersistRepositoryConfigurationSwapper;
+import
org.apache.shardingsphere.mode.repository.standalone.StandalonePersistRepositoryConfiguration;
/**
- * Standalone YAML persist repository configuration swapper.
+ * TODO Rename StandaloneYamlPersistRepositoryConfigurationSwapper when
metadata structure adjustment completed. #25485
+ * New Standalone YAML persist repository configuration swapper.
*/
-public final class StandaloneYamlPersistRepositoryConfigurationSwapper
implements
YamlPersistRepositoryConfigurationSwapper<StandalonePersistRepositoryConfiguration>
{
+public final class NewStandaloneYamlPersistRepositoryConfigurationSwapper
implements
YamlPersistRepositoryConfigurationSwapper<StandalonePersistRepositoryConfiguration>
{
@Override
public YamlPersistRepositoryConfiguration swapToYamlConfiguration(final
StandalonePersistRepositoryConfiguration data) {
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/yaml/StandaloneYamlPersistRepositoryConfigurationSwapper.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/yaml/StandaloneYamlPersistRepositoryConfigurationSwapper.java
index 333044900c7..847cdf5bdee 100644
---
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/yaml/StandaloneYamlPersistRepositoryConfigurationSwapper.java
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/yaml/StandaloneYamlPersistRepositoryConfigurationSwapper.java
@@ -41,6 +41,6 @@ public final class
StandaloneYamlPersistRepositoryConfigurationSwapper implement
@Override
public String getType() {
- return "Standalone";
+ return "Compatible_Standalone";
}
}
diff --git
a/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.mode.YamlPersistRepositoryConfigurationSwapper
b/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.mode.YamlPersistRepositoryConfigurationSwapper
index a88aa27daa7..846ad4f18d6 100644
---
a/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.mode.YamlPersistRepositoryConfigurationSwapper
+++
b/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.mode.YamlPersistRepositoryConfigurationSwapper
@@ -16,3 +16,4 @@
#
org.apache.shardingsphere.mode.manager.standalone.yaml.StandaloneYamlPersistRepositoryConfigurationSwapper
+org.apache.shardingsphere.mode.manager.standalone.yaml.NewStandaloneYamlPersistRepositoryConfigurationSwapper
diff --git
a/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.mode.manager.ContextManagerBuilder
b/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.mode.manager.ContextManagerBuilder
index ee1dd93b9fa..71671fd356b 100644
---
a/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.mode.manager.ContextManagerBuilder
+++
b/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.mode.manager.ContextManagerBuilder
@@ -16,3 +16,4 @@
#
org.apache.shardingsphere.mode.manager.standalone.StandaloneContextManagerBuilder
+org.apache.shardingsphere.mode.manager.standalone.NewStandaloneContextManagerBuilder
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/RALBackendHandlerFactory.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/RALBackendHandlerFactory.java
index 5ee976e81bb..9f67920d932 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/RALBackendHandlerFactory.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/RALBackendHandlerFactory.java
@@ -45,7 +45,8 @@ public final class RALBackendHandlerFactory {
return new QueryableRALBackendHandler<>((QueryableRALStatement)
sqlStatement, connectionSession);
}
if (sqlStatement instanceof UpdatableGlobalRuleRALStatement) {
- if
("Cluster".equals(ProxyContext.getInstance().getContextManager().getInstanceContext().getModeConfiguration().getType()))
{
+ String modeType =
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeConfiguration().getType();
+ if ("Cluster".equals(modeType) || "Standalone".equals(modeType)) {
return new
NewUpdatableGlobalRuleRALBackendHandler((UpdatableGlobalRuleRALStatement)
sqlStatement);
}
return new
UpdatableGlobalRuleRALBackendHandler((UpdatableGlobalRuleRALStatement)
sqlStatement);
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandlerFactory.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandlerFactory.java
index 07be027b282..a5a96aaaf02 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandlerFactory.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandlerFactory.java
@@ -52,7 +52,8 @@ public final class RDLBackendHandlerFactory {
return
getStorageUnitBackendHandler((StorageUnitDefinitionStatement) sqlStatement,
connectionSession);
}
// TODO Remove when metadata structure adjustment completed. #25485
- if
("Cluster".equals(ProxyContext.getInstance().getContextManager().getInstanceContext().getModeConfiguration().getType()))
{
+ String modeType =
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeConfiguration().getType();
+ if ("Cluster".equals(modeType) || "Standalone".equals(modeType)) {
return new
NewRuleDefinitionBackendHandler<>((RuleDefinitionStatement) sqlStatement,
connectionSession);
}
return new RuleDefinitionBackendHandler<>((RuleDefinitionStatement)
sqlStatement, connectionSession);
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/NewRuleDefinitionBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/NewRuleDefinitionBackendHandler.java
index 60b4a1ec05a..5185efcb505 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/NewRuleDefinitionBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/NewRuleDefinitionBackendHandler.java
@@ -138,7 +138,7 @@ public final class NewRuleDefinitionBackendHandler<T
extends RuleDefinitionState
return Collections.emptyList();
}
ModeContextManager modeContextManager =
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeContextManager();
- final RuleConfiguration toBeDroppedRuleConfig =
updater.buildToBeDroppedRuleConfiguration(currentRuleConfig, sqlStatement);
+ RuleConfiguration toBeDroppedRuleConfig =
updater.buildToBeDroppedRuleConfiguration(currentRuleConfig, sqlStatement);
// TODO remove updateCurrentRuleConfiguration after update refactor
completed.
if (updater.updateCurrentRuleConfiguration(sqlStatement,
currentRuleConfig) && ((DatabaseRuleConfiguration)
currentRuleConfig).isEmpty()) {
modeContextManager.removeRuleConfigurationItem(database.getName(),
toBeDroppedRuleConfig);
