This is an automated email from the ASF dual-hosted git repository.
tuichenchuxin 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 886fbde99ae Split DatabaseMetaDataNode to segment metadata data key
node (#30635)
886fbde99ae is described below
commit 886fbde99aec2764c763ac329de1e14782d1adb2
Author: zhaojinchao <[email protected]>
AuthorDate: Mon Mar 25 16:47:36 2024 +0800
Split DatabaseMetaDataNode to segment metadata data key node (#30635)
* Split DatabaseMetaDataNode to segment metadata data key node
* Fix ci
---
.../persist/node/DatabaseMetaDataNode.java | 409 +--------------------
.../node/metadata/DataSourceMetaDataNode.java | 216 +++++++++++
.../node/metadata/DatabaseRuleMetaDataNode.java | 106 ++++++
.../persist/node/metadata/TableMetaDataNode.java | 144 ++++++++
.../persist/node/metadata/ViewMetaDataNode.java | 144 ++++++++
.../datasource/DataSourceNodePersistService.java | 28 +-
.../datasource/DataSourceUnitPersistService.java | 28 +-
.../database/rule/DatabaseRulePersistService.java | 18 +-
.../schema/TableMetaDataPersistService.java | 28 +-
.../service/schema/ViewMetaDataPersistService.java | 28 +-
.../persist/node/DatabaseMetaDataNodeTest.java | 137 -------
.../node/metadata/DataSourceMetaDataNodeTest.java | 81 ++++
.../metadata/DatabaseRuleMetaDataNodeTest.java | 45 +++
.../node/metadata/TableMetaDataNodeTest.java | 61 +++
.../node/metadata/ViewMetaDataNodeTest.java | 75 ++++
.../metadata/watcher/MetaDataChangedWatcher.java | 21 +-
16 files changed, 952 insertions(+), 617 deletions(-)
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/DatabaseMetaDataNode.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/DatabaseMetaDataNode.java
index 1b5cd7f7c88..c35a9ef2aa4 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/DatabaseMetaDataNode.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/DatabaseMetaDataNode.java
@@ -32,30 +32,14 @@ public final class DatabaseMetaDataNode {
private static final String ROOT_NODE = "metadata";
- private static final String DATA_SOURCES_NODE = "data_sources";
-
- private static final String DATA_SOURCE_NODES_NODE = "nodes";
-
- private static final String DATA_SOURCE_UNITS_NODE = "units";
-
- private static final String RULE_NODE = "rules";
-
private static final String SCHEMAS_NODE = "schemas";
private static final String TABLES_NODE = "tables";
- private static final String VIEWS_NODE = "views";
-
private static final String ACTIVE_VERSION = "active_version";
private static final String VERSIONS = "versions";
- private static final String TABLES_PATTERN =
"/([\\w\\-]+)/schemas/([\\w\\-]+)/tables";
-
- private static final String VIEWS_PATTERN =
"/([\\w\\-]+)/schemas/([\\w\\-]+)/views";
-
- private static final String ACTIVE_VERSION_SUFFIX =
"/([\\w\\-]+)/active_version";
-
/**
* Get database name path.
*
@@ -66,28 +50,6 @@ public final class DatabaseMetaDataNode {
return String.join("/", getMetaDataNode(), databaseName);
}
- /**
- * Get meta data tables path.
- *
- * @param databaseName database name
- * @param schemaName schema name
- * @return tables path
- */
- public static String getMetaDataTablesPath(final String databaseName,
final String schemaName) {
- return String.join("/", getMetaDataSchemaPath(databaseName,
schemaName), TABLES_NODE);
- }
-
- /**
- * Get meta data views path.
- *
- * @param databaseName database name
- * @param schemaName schema name
- * @return views path
- */
- public static String getMetaDataViewsPath(final String databaseName, final
String schemaName) {
- return String.join("/", getMetaDataSchemaPath(databaseName,
schemaName), VIEWS_NODE);
- }
-
/**
* Get schema path.
*
@@ -110,335 +72,14 @@ public final class DatabaseMetaDataNode {
}
/**
- * Get data source units node.
- *
- * @param databaseName database name
- * @return data sources node
- */
- public static String getDataSourceUnitsNode(final String databaseName) {
- return String.join("/", getMetaDataNode(), databaseName,
DATA_SOURCES_NODE, DATA_SOURCE_UNITS_NODE);
- }
-
- /**
- * Get data source nodes node.
- *
- * @param databaseName database name
- * @return data sources node
- */
- public static String getDataSourceNodesNode(final String databaseName) {
- return String.join("/", getMetaDataNode(), databaseName,
DATA_SOURCES_NODE, DATA_SOURCE_NODES_NODE);
- }
-
- /**
- * Get data source unit node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source node
- */
- public static String getDataSourceUnitNode(final String databaseName,
final String dataSourceName) {
- return String.join("/", getDataSourceUnitsNode(databaseName),
dataSourceName);
- }
-
- /**
- * Get data source unit node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source node
- */
- public static String getDataSourceNode(final String databaseName, final
String dataSourceName) {
- return String.join("/", getDataSourceUnitsNode(databaseName),
dataSourceName);
- }
-
- /**
- * Get data source unit node with version.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @param version version
- * @return data source node with version
- */
- public static String getDataSourceUnitNodeWithVersion(final String
databaseName, final String dataSourceName, final String version) {
- return String.join("/", getDataSourceUnitVersionsNode(databaseName,
dataSourceName), version);
- }
-
- /**
- * Get data source node with version.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @param version version
- * @return data source node with version
- */
- public static String getDataSourceNodeWithVersion(final String
databaseName, final String dataSourceName, final String version) {
- return String.join("/", getDataSourceNodeVersionsNode(databaseName,
dataSourceName), version);
- }
-
- /**
- * Get data source unit active version node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source active version node
- */
- public static String getDataSourceUnitActiveVersionNode(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceUnitsNode(databaseName),
dataSourceName, ACTIVE_VERSION);
- }
-
- /**
- * Get data source node active version node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source active version node
- */
- public static String getDataSourceNodeActiveVersionNode(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceNodesNode(databaseName),
dataSourceName, ACTIVE_VERSION);
- }
-
- /**
- * Get data source unit versions node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source versions node
- */
- public static String getDataSourceUnitVersionsNode(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceUnitsNode(databaseName),
dataSourceName, VERSIONS);
- }
-
- /**
- * Get data source node versions node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source versions node
- */
- public static String getDataSourceNodeVersionsNode(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceNodesNode(databaseName),
dataSourceName, VERSIONS);
- }
-
- /**
- * Get database rule active version node.
- *
- * @param databaseName database name
- * @param ruleName rule name
- * @param key key
- * @return database rule active version node
- */
- public static String getDatabaseRuleActiveVersionNode(final String
databaseName, final String ruleName, final String key) {
- return String.join("/", getDatabaseRuleNode(databaseName, ruleName),
key, ACTIVE_VERSION);
- }
-
- /**
- * Get database rule versions node.
- *
- * @param databaseName database name
- * @param ruleName rule name
- * @param key key
- * @return database rule versions node
- */
- public static String getDatabaseRuleVersionsNode(final String
databaseName, final String ruleName, final String key) {
- return String.join("/", getDatabaseRuleNode(databaseName, ruleName),
key, VERSIONS);
- }
-
- /**
- * Get database rule version node.
- *
- * @param databaseName database name
- * @param ruleName rule name
- * @param key key
- * @param version version
- * @return database rule next version
- */
- public static String getDatabaseRuleVersionNode(final String databaseName,
final String ruleName, final String key, final String version) {
- return String.join("/", getDatabaseRuleNode(databaseName, ruleName),
key, VERSIONS, version);
- }
-
- /**
- * Get database rule node.
- *
- * @param databaseName database name
- * @param ruleName rule name
- * @param key key
- * @return database rule node without version
- */
- public static String getDatabaseRuleNode(final String databaseName, final
String ruleName, final String key) {
- return String.join("/", getDatabaseRuleNode(databaseName, ruleName),
key);
- }
-
- /**
- * Get database rule root node.
- *
- * @param databaseName database name
- * @param ruleName rule name
- * @return database rule root node
- */
- public static String getDatabaseRuleNode(final String databaseName, final
String ruleName) {
- return String.join("/", getRulesNode(databaseName), ruleName);
- }
-
- /**
- * Get database rules node.
- *
- * @param databaseName database name
- * @return database rules node
- */
- public static String getRulesNode(final String databaseName) {
- return String.join("/", getMetaDataNode(), databaseName, RULE_NODE);
- }
-
- /**
- * Get table active version node.
- *
- * @param databaseName database name
- * @param schemaName schema name
- * @param tableName table name
- * @return tables active version node
- */
- public static String getTableActiveVersionNode(final String databaseName,
final String schemaName, final String tableName) {
- return String.join("/", getTableNode(databaseName, schemaName,
tableName), ACTIVE_VERSION);
- }
-
- /**
- * Get table versions node.
- *
- * @param databaseName database name
- * @param schemaName schema name
- * @param tableName table name
- * @return tables versions node
- */
- public static String getTableVersionsNode(final String databaseName, final
String schemaName, final String tableName) {
- return String.join("/", getTableNode(databaseName, schemaName,
tableName), VERSIONS);
- }
-
- /**
- * Get table version node.
- *
- * @param databaseName database name
- * @param schemaName schema name
- * @param tableName table name
- * @param version version
- * @return table version node
- */
- public static String getTableVersionNode(final String databaseName, final
String schemaName, final String tableName, final String version) {
- return String.join("/", getTableVersionsNode(databaseName, schemaName,
tableName), version);
- }
-
- /**
- * Get table node.
- *
- * @param databaseName database name
- * @param schemaName schema name
- * @param tableName table name
- * @return table node
- */
- public static String getTableNode(final String databaseName, final String
schemaName, final String tableName) {
- return String.join("/", getMetaDataNode(), databaseName, SCHEMAS_NODE,
schemaName, TABLES_NODE, tableName);
- }
-
- /**
- * Get view name active version node.
- *
- * @param databaseName database name
- * @param schemaName schema name
- * @param viewName view name
- * @return view active version node
- */
- public static String getViewActiveVersionNode(final String databaseName,
final String schemaName, final String viewName) {
- return String.join("/", getViewNode(databaseName, schemaName,
viewName), ACTIVE_VERSION);
- }
-
- /**
- * Get view versions node.
- *
- * @param databaseName database name
- * @param schemaName schema name
- * @param viewName view name
- * @return view versions node
- */
- public static String getViewVersionsNode(final String databaseName, final
String schemaName, final String viewName) {
- return String.join("/", getViewNode(databaseName, schemaName,
viewName), VERSIONS);
- }
-
- /**
- * Get view version node.
- *
- * @param databaseName database name
- * @param schemaName schema name
- * @param viewName view name
- * @param version version
- * @return view version node
- */
- public static String getViewVersionNode(final String databaseName, final
String schemaName, final String viewName, final String version) {
- return String.join("/", getViewVersionsNode(databaseName, schemaName,
viewName), version);
- }
-
- /**
- * Get view node.
+ * Get meta data tables path.
*
* @param databaseName database name
* @param schemaName schema name
- * @param viewName view name
* @return tables path
*/
- public static String getViewNode(final String databaseName, final String
schemaName, final String viewName) {
- return String.join("/", getMetaDataNode(), databaseName, SCHEMAS_NODE,
schemaName, VIEWS_NODE, viewName);
- }
-
- /**
- * Is data sources node.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourcesNode(final String path) {
- return Pattern.compile(getMetaDataNode() + "/([\\w\\-]+)/" +
DATA_SOURCES_NODE + "/?", Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- /**
- * Get data source name by data source unit node.
- *
- * @param path path
- * @return data source name
- */
- public static Optional<String> getDataSourceNameByDataSourceUnitNode(final
String path) {
- Pattern pattern = Pattern.compile(getMetaDataNode() + "/([\\w\\-]+)/"
+ DATA_SOURCES_NODE + "/" + DATA_SOURCE_UNITS_NODE + "/([\\w\\-]+)?",
Pattern.CASE_INSENSITIVE);
- Matcher matcher = pattern.matcher(path);
- return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
- }
-
- /**
- * Get data source name by data source nodes node.
- *
- * @param path path
- * @return data source name
- */
- public static Optional<String> getDataSourceNameByDataSourceNode(final
String path) {
- Pattern pattern = Pattern.compile(getMetaDataNode() + "/([\\w\\-]+)/"
+ DATA_SOURCES_NODE + "/" + DATA_SOURCE_NODES_NODE + "/([\\w\\-]+)?",
Pattern.CASE_INSENSITIVE);
- Matcher matcher = pattern.matcher(path);
- return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
- }
-
- /**
- * Is data source unit active version node.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourceUnitActiveVersionNode(final String path)
{
- return Pattern.compile(getMetaDataNode() + "/([\\w\\-]+)/" +
DATA_SOURCES_NODE + "/" + DATA_SOURCE_UNITS_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- /**
- * Is data source unit active version node.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourceNodeActiveVersionNode(final String path)
{
- return Pattern.compile(getMetaDataNode() + "/([\\w\\-]+)/" +
DATA_SOURCES_NODE + "/" + DATA_SOURCE_NODES_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
+ public static String getMetaDataTablesPath(final String databaseName,
final String schemaName) {
+ return String.join("/", getMetaDataSchemaPath(databaseName,
schemaName), TABLES_NODE);
}
/**
@@ -489,50 +130,6 @@ public final class DatabaseMetaDataNode {
return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
}
- /**
- * Get table name.
- *
- * @param path path
- * @return table name
- */
- public static Optional<String> getTableName(final String path) {
- Pattern pattern = Pattern.compile(getMetaDataNode() + TABLES_PATTERN +
"/([\\w\\-]+)/([\\w\\-]+)$", Pattern.CASE_INSENSITIVE);
- Matcher matcher = pattern.matcher(path);
- return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
- }
-
- /**
- * Is table active version node.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isTableActiveVersionNode(final String path) {
- return Pattern.compile(getMetaDataNode() + TABLES_PATTERN +
ACTIVE_VERSION_SUFFIX, Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- /**
- * Get view name.
- *
- * @param path path
- * @return view name
- */
- public static Optional<String> getViewName(final String path) {
- Pattern pattern = Pattern.compile(getMetaDataNode() + VIEWS_PATTERN +
"/([\\w\\-]+)?", Pattern.CASE_INSENSITIVE);
- Matcher matcher = pattern.matcher(path);
- return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
- }
-
- /**
- * Is view active version node.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isViewActiveVersionNode(final String path) {
- return Pattern.compile(getMetaDataNode() + VIEWS_PATTERN +
ACTIVE_VERSION_SUFFIX, Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
/**
* Get version node by active version path.
*
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNode.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNode.java
new file mode 100644
index 00000000000..706c83f1d8c
--- /dev/null
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNode.java
@@ -0,0 +1,216 @@
+/*
+ * 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.metadata.persist.node.metadata;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Data source meta data node.
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class DataSourceMetaDataNode {
+
+ private static final String ROOT_NODE = "metadata";
+
+ private static final String DATA_SOURCES_NODE = "data_sources";
+
+ private static final String DATA_SOURCE_NODES_NODE = "nodes";
+
+ private static final String DATA_SOURCE_UNITS_NODE = "units";
+
+ private static final String ACTIVE_VERSION = "active_version";
+
+ private static final String VERSIONS = "versions";
+
+ private static final String DATABASE_DATA_SOURCES_NODE =
"/([\\w\\-]+)/data_sources/";
+
+ private static final String ACTIVE_VERSION_SUFFIX =
"/([\\w\\-]+)/active_version";
+
+ /**
+ * Get data source units node.
+ *
+ * @param databaseName database name
+ * @return data sources node
+ */
+ public static String getDataSourceUnitsNode(final String databaseName) {
+ return String.join("/", getMetaDataNode(), databaseName,
DATA_SOURCES_NODE, DATA_SOURCE_UNITS_NODE);
+ }
+
+ /**
+ * Get data source nodes node.
+ *
+ * @param databaseName database name
+ * @return data sources node
+ */
+ public static String getDataSourceNodesNode(final String databaseName) {
+ return String.join("/", getMetaDataNode(), databaseName,
DATA_SOURCES_NODE, DATA_SOURCE_NODES_NODE);
+ }
+
+ /**
+ * Get data source unit node.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source node
+ */
+ public static String getDataSourceUnitNode(final String databaseName,
final String dataSourceName) {
+ return String.join("/", getDataSourceUnitsNode(databaseName),
dataSourceName);
+ }
+
+ /**
+ * Get data source node node.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source node
+ */
+ public static String getDataSourceNodeNode(final String databaseName,
final String dataSourceName) {
+ return String.join("/", getDataSourceNodesNode(databaseName),
dataSourceName);
+ }
+
+ /**
+ * Get data source unit version node.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @param version version
+ * @return data source unit version node
+ */
+ public static String getDataSourceUnitVersionNode(final String
databaseName, final String dataSourceName, final String version) {
+ return String.join("/", getDataSourceUnitVersionsNode(databaseName,
dataSourceName), version);
+ }
+
+ /**
+ * Get data source unit versions node.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source versions node
+ */
+ public static String getDataSourceUnitVersionsNode(final String
databaseName, final String dataSourceName) {
+ return String.join("/", getDataSourceUnitsNode(databaseName),
dataSourceName, VERSIONS);
+ }
+
+ /**
+ * Get data source unit active version node.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source active version node
+ */
+ public static String getDataSourceUnitActiveVersionNode(final String
databaseName, final String dataSourceName) {
+ return String.join("/", getDataSourceUnitsNode(databaseName),
dataSourceName, ACTIVE_VERSION);
+ }
+
+ /**
+ * Get data source node versions node.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source versions node
+ */
+ public static String getDataSourceNodeVersionsNode(final String
databaseName, final String dataSourceName) {
+ return String.join("/", getDataSourceNodesNode(databaseName),
dataSourceName, VERSIONS);
+ }
+
+ /**
+ * Get data source node version node.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @param version version
+ * @return data source node version node
+ */
+ public static String getDataSourceNodeVersionNode(final String
databaseName, final String dataSourceName, final String version) {
+ return String.join("/", getDataSourceNodeVersionsNode(databaseName,
dataSourceName), version);
+ }
+
+ /**
+ * Get data source node active version node.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source active version node
+ */
+ public static String getDataSourceNodeActiveVersionNode(final String
databaseName, final String dataSourceName) {
+ return String.join("/", getDataSourceNodesNode(databaseName),
dataSourceName, ACTIVE_VERSION);
+ }
+
+ /**
+ * Is data sources node.
+ *
+ * @param path path
+ * @return true or false
+ */
+ public static boolean isDataSourcesNode(final String path) {
+ return Pattern.compile(getMetaDataNode() + DATABASE_DATA_SOURCES_NODE
+ "?", Pattern.CASE_INSENSITIVE).matcher(path).find();
+ }
+
+ /**
+ * Get data source name by data source unit node.
+ *
+ * @param path path
+ * @return data source name
+ */
+ public static Optional<String> getDataSourceNameByDataSourceUnitNode(final
String path) {
+ Pattern pattern = Pattern.compile(getMetaDataNode() +
DATABASE_DATA_SOURCES_NODE + DATA_SOURCE_UNITS_NODE + "/([\\w\\-]+)?",
Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(path);
+ return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
+ }
+
+ /**
+ * Get data source name by data source nodes node.
+ *
+ * @param path path
+ * @return data source name
+ */
+ public static Optional<String> getDataSourceNameByDataSourceNode(final
String path) {
+ Pattern pattern = Pattern.compile(getMetaDataNode() +
DATABASE_DATA_SOURCES_NODE + DATA_SOURCE_NODES_NODE + "/([\\w\\-]+)?",
Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(path);
+ return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
+ }
+
+ /**
+ * Is data source unit active version node.
+ *
+ * @param path path
+ * @return true or false
+ */
+ public static boolean isDataSourceUnitActiveVersionNode(final String path)
{
+ return Pattern.compile(getMetaDataNode() + DATABASE_DATA_SOURCES_NODE
+ DATA_SOURCE_UNITS_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
+ }
+
+ /**
+ * Is data source node active version node.
+ *
+ * @param path path
+ * @return true or false
+ */
+ public static boolean isDataSourceNodeActiveVersionNode(final String path)
{
+ return Pattern.compile(getMetaDataNode() + DATABASE_DATA_SOURCES_NODE
+ DATA_SOURCE_NODES_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
+ }
+
+ private static String getMetaDataNode() {
+ return String.join("/", "", ROOT_NODE);
+ }
+}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DatabaseRuleMetaDataNode.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DatabaseRuleMetaDataNode.java
new file mode 100644
index 00000000000..2d6f273ba3f
--- /dev/null
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DatabaseRuleMetaDataNode.java
@@ -0,0 +1,106 @@
+/*
+ * 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.metadata.persist.node.metadata;
+
+/**
+ * Database rule meta data node.
+ */
+public final class DatabaseRuleMetaDataNode {
+
+ private static final String ROOT_NODE = "metadata";
+
+ private static final String RULE_NODE = "rules";
+
+ private static final String ACTIVE_VERSION = "active_version";
+
+ private static final String VERSIONS = "versions";
+
+ /**
+ * Get database rule active version node.
+ *
+ * @param databaseName database name
+ * @param ruleName rule name
+ * @param key key
+ * @return database rule active version node
+ */
+ public static String getDatabaseRuleActiveVersionNode(final String
databaseName, final String ruleName, final String key) {
+ return String.join("/", getDatabaseRuleNode(databaseName, ruleName),
key, ACTIVE_VERSION);
+ }
+
+ /**
+ * Get database rule versions node.
+ *
+ * @param databaseName database name
+ * @param ruleName rule name
+ * @param key key
+ * @return database rule versions node
+ */
+ public static String getDatabaseRuleVersionsNode(final String
databaseName, final String ruleName, final String key) {
+ return String.join("/", getDatabaseRuleNode(databaseName, ruleName),
key, VERSIONS);
+ }
+
+ /**
+ * Get database rule version node.
+ *
+ * @param databaseName database name
+ * @param ruleName rule name
+ * @param key key
+ * @param version version
+ * @return database rule next version
+ */
+ public static String getDatabaseRuleVersionNode(final String databaseName,
final String ruleName, final String key, final String version) {
+ return String.join("/", getDatabaseRuleNode(databaseName, ruleName),
key, VERSIONS, version);
+ }
+
+ /**
+ * Get database rule node.
+ *
+ * @param databaseName database name
+ * @param ruleName rule name
+ * @param key key
+ * @return database rule node without version
+ */
+ public static String getDatabaseRuleNode(final String databaseName, final
String ruleName, final String key) {
+ return String.join("/", getDatabaseRuleNode(databaseName, ruleName),
key);
+ }
+
+ /**
+ * Get database rule root node.
+ *
+ * @param databaseName database name
+ * @param ruleName rule name
+ * @return database rule root node
+ */
+ public static String getDatabaseRuleNode(final String databaseName, final
String ruleName) {
+ return String.join("/", getRulesNode(databaseName), ruleName);
+ }
+
+ /**
+ * Get database rules node.
+ *
+ * @param databaseName database name
+ * @return database rules node
+ */
+ public static String getRulesNode(final String databaseName) {
+ return String.join("/", getMetaDataNode(), databaseName, RULE_NODE);
+ }
+
+ private static String getMetaDataNode() {
+ return String.join("/", "", ROOT_NODE);
+ }
+}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/TableMetaDataNode.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/TableMetaDataNode.java
new file mode 100644
index 00000000000..7c05f6032aa
--- /dev/null
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/TableMetaDataNode.java
@@ -0,0 +1,144 @@
+/*
+ * 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.metadata.persist.node.metadata;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Table meta data node.
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class TableMetaDataNode {
+
+ private static final String ROOT_NODE = "metadata";
+
+ private static final String SCHEMAS_NODE = "schemas";
+
+ private static final String TABLES_NODE = "tables";
+
+ private static final String ACTIVE_VERSION = "active_version";
+
+ private static final String VERSIONS = "versions";
+
+ private static final String TABLES_PATTERN =
"/([\\w\\-]+)/schemas/([\\w\\-]+)/tables";
+
+ private static final String ACTIVE_VERSION_SUFFIX =
"/([\\w\\-]+)/active_version";
+
+ /**
+ * Get meta data tables node.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @return tables path
+ */
+ public static String getMetaDataTablesNode(final String databaseName,
final String schemaName) {
+ return String.join("/", getMetaDataNode(), databaseName, SCHEMAS_NODE,
schemaName, TABLES_NODE);
+ }
+
+ /**
+ * Get table active version node.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param tableName table name
+ * @return tables active version node
+ */
+ public static String getTableActiveVersionNode(final String databaseName,
final String schemaName, final String tableName) {
+ return String.join("/", getMetaDataNode(), databaseName, SCHEMAS_NODE,
schemaName, TABLES_NODE, tableName, ACTIVE_VERSION);
+ }
+
+ /**
+ * Get table versions node.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param tableName table name
+ * @return tables versions node
+ */
+ public static String getTableVersionsNode(final String databaseName, final
String schemaName, final String tableName) {
+ return String.join("/", getMetaDataNode(), databaseName, SCHEMAS_NODE,
schemaName, TABLES_NODE, tableName, VERSIONS);
+ }
+
+ /**
+ * Get table version node.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param tableName table name
+ * @param version version
+ * @return table version node
+ */
+ public static String getTableVersionNode(final String databaseName, final
String schemaName, final String tableName, final String version) {
+ return String.join("/", getTableVersionsNode(databaseName, schemaName,
tableName), version);
+ }
+
+ /**
+ * Get table node.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param tableName table name
+ * @return table node
+ */
+ public static String getTableNode(final String databaseName, final String
schemaName, final String tableName) {
+ return String.join("/", getMetaDataNode(), databaseName, SCHEMAS_NODE,
schemaName, TABLES_NODE, tableName);
+ }
+
+ /**
+ * Get table name by active version node.
+ *
+ * @param path path
+ * @return table name
+ */
+ public static Optional<String> getTableNameByActiveVersionNode(final
String path) {
+ Pattern pattern = Pattern.compile(getMetaDataNode() + TABLES_PATTERN +
ACTIVE_VERSION_SUFFIX, Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(path);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
+ }
+
+ /**
+ * Get table name.
+ *
+ * @param path path
+ * @return table name
+ */
+ public static Optional<String> getTableName(final String path) {
+ Pattern pattern = Pattern.compile(getMetaDataNode() + TABLES_PATTERN +
"/([\\w\\-]+)$", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(path);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
+ }
+
+ /**
+ * Is table active version node.
+ *
+ * @param path path
+ * @return true or false
+ */
+ public static boolean isTableActiveVersionNode(final String path) {
+ return Pattern.compile(getMetaDataNode() + TABLES_PATTERN +
ACTIVE_VERSION_SUFFIX, Pattern.CASE_INSENSITIVE).matcher(path).find();
+ }
+
+ private static String getMetaDataNode() {
+ return String.join("/", "", ROOT_NODE);
+ }
+}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/ViewMetaDataNode.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/ViewMetaDataNode.java
new file mode 100644
index 00000000000..34c2f92bd35
--- /dev/null
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/ViewMetaDataNode.java
@@ -0,0 +1,144 @@
+/*
+ * 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.metadata.persist.node.metadata;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * View meta data node.
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class ViewMetaDataNode {
+
+ private static final String ROOT_NODE = "metadata";
+
+ private static final String SCHEMAS_NODE = "schemas";
+
+ private static final String VIEWS_NODE = "views";
+
+ private static final String ACTIVE_VERSION = "active_version";
+
+ private static final String VERSIONS = "versions";
+
+ private static final String VIEWS_PATTERN =
"/([\\w\\-]+)/schemas/([\\w\\-]+)/views";
+
+ private static final String ACTIVE_VERSION_SUFFIX =
"/([\\w\\-]+)/active_version";
+
+ /**
+ * Get meta data views node.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @return views path
+ */
+ public static String getMetaDataViewsNode(final String databaseName, final
String schemaName) {
+ return String.join("/", getMetaDataNode(), databaseName, SCHEMAS_NODE,
schemaName, VIEWS_NODE);
+ }
+
+ /**
+ * Get view active version node.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param viewName view name
+ * @return view active version node
+ */
+ public static String getViewActiveVersionNode(final String databaseName,
final String schemaName, final String viewName) {
+ return String.join("/", getMetaDataNode(), databaseName, SCHEMAS_NODE,
schemaName, VIEWS_NODE, viewName, ACTIVE_VERSION);
+ }
+
+ /**
+ * Get view versions node.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param viewName view name
+ * @return view versions node
+ */
+ public static String getViewVersionsNode(final String databaseName, final
String schemaName, final String viewName) {
+ return String.join("/", getMetaDataNode(), databaseName, SCHEMAS_NODE,
schemaName, VIEWS_NODE, viewName, VERSIONS);
+ }
+
+ /**
+ * Get view version node.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param viewName view name
+ * @param version version
+ * @return view version node
+ */
+ public static String getViewVersionNode(final String databaseName, final
String schemaName, final String viewName, final String version) {
+ return String.join("/", getViewVersionsNode(databaseName, schemaName,
viewName), version);
+ }
+
+ /**
+ * Get view node.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param viewName view name
+ * @return view node
+ */
+ public static String getViewNode(final String databaseName, final String
schemaName, final String viewName) {
+ return String.join("/", "", ROOT_NODE, databaseName, SCHEMAS_NODE,
schemaName, VIEWS_NODE, viewName);
+ }
+
+ /**
+ * Get view name by active version node.
+ *
+ * @param path path
+ * @return view name
+ */
+ public static Optional<String> getViewNameByActiveVersionNode(final String
path) {
+ Pattern pattern = Pattern.compile(getMetaDataNode() + VIEWS_PATTERN +
ACTIVE_VERSION_SUFFIX, Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(path);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
+ }
+
+ /**
+ * Get view name.
+ *
+ * @param path path
+ * @return view name
+ */
+ public static Optional<String> getViewName(final String path) {
+ Pattern pattern = Pattern.compile(getMetaDataNode() + VIEWS_PATTERN +
"/([\\w\\-]+)$", Pattern.CASE_INSENSITIVE);
+ Matcher matcher = pattern.matcher(path);
+ return matcher.find() ? Optional.of(matcher.group(3)) :
Optional.empty();
+ }
+
+ /**
+ * Is view active version node.
+ *
+ * @param path path
+ * @return true or false
+ */
+ public static boolean isViewActiveVersionNode(final String path) {
+ return Pattern.compile(getMetaDataNode() + VIEWS_PATTERN +
ACTIVE_VERSION_SUFFIX, Pattern.CASE_INSENSITIVE).matcher(path).find();
+ }
+
+ private static String getMetaDataNode() {
+ return String.join("/", "", ROOT_NODE);
+ }
+}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceNodePersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceNodePersistService.java
index 335fc04f1ac..62502f8bfca 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceNodePersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceNodePersistService.java
@@ -23,7 +23,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePo
import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import
org.apache.shardingsphere.infra.yaml.config.swapper.resource.YamlDataSourceConfigurationSwapper;
-import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.DataSourceMetaDataNode;
import
org.apache.shardingsphere.metadata.persist.service.config.database.DatabaseBasedPersistService;
import org.apache.shardingsphere.mode.spi.PersistRepository;
@@ -48,12 +48,12 @@ public final class DataSourceNodePersistService implements
DatabaseBasedPersistS
public void persist(final String databaseName, final Map<String,
DataSourcePoolProperties> dataSourceConfigs) {
for (Entry<String, DataSourcePoolProperties> entry :
dataSourceConfigs.entrySet()) {
String activeVersion = getDataSourceActiveVersion(databaseName,
entry.getKey());
- List<String> versions =
repository.getChildrenKeys(DatabaseMetaDataNode.getDataSourceNodeVersionsNode(databaseName,
entry.getKey()));
-
repository.persist(DatabaseMetaDataNode.getDataSourceNodeWithVersion(databaseName,
entry.getKey(), versions.isEmpty()
+ List<String> versions =
repository.getChildrenKeys(DataSourceMetaDataNode.getDataSourceNodeVersionsNode(databaseName,
entry.getKey()));
+
repository.persist(DataSourceMetaDataNode.getDataSourceNodeVersionNode(databaseName,
entry.getKey(), versions.isEmpty()
? DEFAULT_VERSION
: String.valueOf(Integer.parseInt(versions.get(0)) + 1)),
YamlEngine.marshal(new
YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
if (Strings.isNullOrEmpty(activeVersion)) {
-
repository.persist(DatabaseMetaDataNode.getDataSourceNodeActiveVersionNode(databaseName,
entry.getKey()), DEFAULT_VERSION);
+
repository.persist(DataSourceMetaDataNode.getDataSourceNodeActiveVersionNode(databaseName,
entry.getKey()), DEFAULT_VERSION);
}
}
}
@@ -62,8 +62,8 @@ public final class DataSourceNodePersistService implements
DatabaseBasedPersistS
@Override
public Map<String, DataSourcePoolProperties> load(final String
databaseName) {
Map<String, DataSourcePoolProperties> result = new LinkedHashMap<>();
- for (String each :
repository.getChildrenKeys(DatabaseMetaDataNode.getDataSourceNodesNode(databaseName)))
{
- String dataSourceValue =
repository.getDirectly(DatabaseMetaDataNode.getDataSourceNodeWithVersion(databaseName,
each, getDataSourceActiveVersion(databaseName, each)));
+ for (String each :
repository.getChildrenKeys(DataSourceMetaDataNode.getDataSourceNodesNode(databaseName)))
{
+ String dataSourceValue =
repository.getDirectly(DataSourceMetaDataNode.getDataSourceNodeVersionNode(databaseName,
each, getDataSourceActiveVersion(databaseName, each)));
if (!Strings.isNullOrEmpty(dataSourceValue)) {
result.put(each, new
YamlDataSourceConfigurationSwapper().swapToDataSourcePoolProperties(YamlEngine.unmarshal(dataSourceValue,
Map.class)));
}
@@ -75,7 +75,7 @@ public final class DataSourceNodePersistService implements
DatabaseBasedPersistS
@Override
public Map<String, DataSourcePoolProperties> load(final String
databaseName, final String name) {
Map<String, DataSourcePoolProperties> result = new LinkedHashMap<>();
- String dataSourceValue =
repository.getDirectly(DatabaseMetaDataNode.getDataSourceNodeWithVersion(databaseName,
name, getDataSourceActiveVersion(databaseName, name)));
+ String dataSourceValue =
repository.getDirectly(DataSourceMetaDataNode.getDataSourceNodeVersionNode(databaseName,
name, getDataSourceActiveVersion(databaseName, name)));
if (!Strings.isNullOrEmpty(dataSourceValue)) {
result.put(name, new
YamlDataSourceConfigurationSwapper().swapToDataSourcePoolProperties(YamlEngine.unmarshal(dataSourceValue,
Map.class)));
}
@@ -84,14 +84,14 @@ public final class DataSourceNodePersistService implements
DatabaseBasedPersistS
@Override
public void delete(final String databaseName, final String name) {
- repository.delete(DatabaseMetaDataNode.getDataSourceNode(databaseName,
name));
+
repository.delete(DataSourceMetaDataNode.getDataSourceNodeNode(databaseName,
name));
}
@Override
public Collection<MetaDataVersion> deleteConfig(final String databaseName,
final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
Collection<MetaDataVersion> result = new LinkedList<>();
for (Entry<String, DataSourcePoolProperties> entry :
dataSourceConfigs.entrySet()) {
- String delKey =
DatabaseMetaDataNode.getDataSourceNode(databaseName, entry.getKey());
+ String delKey =
DataSourceMetaDataNode.getDataSourceNodeNode(databaseName, entry.getKey());
repository.delete(delKey);
result.add(new MetaDataVersion(delKey));
}
@@ -102,19 +102,19 @@ public final class DataSourceNodePersistService
implements DatabaseBasedPersistS
public Collection<MetaDataVersion> persistConfig(final String
databaseName, final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
Collection<MetaDataVersion> result = new LinkedList<>();
for (Entry<String, DataSourcePoolProperties> entry :
dataSourceConfigs.entrySet()) {
- List<String> versions =
repository.getChildrenKeys(DatabaseMetaDataNode.getDataSourceNodeVersionsNode(databaseName,
entry.getKey()));
+ List<String> versions =
repository.getChildrenKeys(DataSourceMetaDataNode.getDataSourceNodeVersionsNode(databaseName,
entry.getKey()));
String nextActiveVersion = versions.isEmpty() ? DEFAULT_VERSION :
String.valueOf(Integer.parseInt(versions.get(0)) + 1);
-
repository.persist(DatabaseMetaDataNode.getDataSourceNodeWithVersion(databaseName,
entry.getKey(), nextActiveVersion),
+
repository.persist(DataSourceMetaDataNode.getDataSourceNodeVersionNode(databaseName,
entry.getKey(), nextActiveVersion),
YamlEngine.marshal(new
YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
if (Strings.isNullOrEmpty(getDataSourceActiveVersion(databaseName,
entry.getKey()))) {
-
repository.persist(DatabaseMetaDataNode.getDataSourceNodeActiveVersionNode(databaseName,
entry.getKey()), DEFAULT_VERSION);
+
repository.persist(DataSourceMetaDataNode.getDataSourceNodeActiveVersionNode(databaseName,
entry.getKey()), DEFAULT_VERSION);
}
- result.add(new
MetaDataVersion(DatabaseMetaDataNode.getDataSourceNode(databaseName,
entry.getKey()), getDataSourceActiveVersion(databaseName, entry.getKey()),
nextActiveVersion));
+ result.add(new
MetaDataVersion(DataSourceMetaDataNode.getDataSourceNodeNode(databaseName,
entry.getKey()), getDataSourceActiveVersion(databaseName, entry.getKey()),
nextActiveVersion));
}
return result;
}
private String getDataSourceActiveVersion(final String databaseName, final
String dataSourceName) {
- return
repository.getDirectly(DatabaseMetaDataNode.getDataSourceNodeActiveVersionNode(databaseName,
dataSourceName));
+ return
repository.getDirectly(DataSourceMetaDataNode.getDataSourceNodeActiveVersionNode(databaseName,
dataSourceName));
}
}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceUnitPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceUnitPersistService.java
index d3729c2c5d8..26dcd9879f4 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceUnitPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceUnitPersistService.java
@@ -23,7 +23,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePo
import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import
org.apache.shardingsphere.infra.yaml.config.swapper.resource.YamlDataSourceConfigurationSwapper;
-import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.DataSourceMetaDataNode;
import
org.apache.shardingsphere.metadata.persist.service.config.database.DatabaseBasedPersistService;
import org.apache.shardingsphere.mode.spi.PersistRepository;
@@ -48,12 +48,12 @@ public final class DataSourceUnitPersistService implements
DatabaseBasedPersistS
public void persist(final String databaseName, final Map<String,
DataSourcePoolProperties> dataSourceConfigs) {
for (Entry<String, DataSourcePoolProperties> entry :
dataSourceConfigs.entrySet()) {
String activeVersion = getDataSourceActiveVersion(databaseName,
entry.getKey());
- List<String> versions =
repository.getChildrenKeys(DatabaseMetaDataNode.getDataSourceUnitVersionsNode(databaseName,
entry.getKey()));
-
repository.persist(DatabaseMetaDataNode.getDataSourceUnitNodeWithVersion(databaseName,
entry.getKey(), versions.isEmpty()
+ List<String> versions =
repository.getChildrenKeys(DataSourceMetaDataNode.getDataSourceUnitVersionsNode(databaseName,
entry.getKey()));
+
repository.persist(DataSourceMetaDataNode.getDataSourceUnitVersionNode(databaseName,
entry.getKey(), versions.isEmpty()
? DEFAULT_VERSION
: String.valueOf(Integer.parseInt(versions.get(0)) + 1)),
YamlEngine.marshal(new
YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
if (Strings.isNullOrEmpty(activeVersion)) {
-
repository.persist(DatabaseMetaDataNode.getDataSourceUnitActiveVersionNode(databaseName,
entry.getKey()), DEFAULT_VERSION);
+
repository.persist(DataSourceMetaDataNode.getDataSourceUnitActiveVersionNode(databaseName,
entry.getKey()), DEFAULT_VERSION);
}
}
}
@@ -62,8 +62,8 @@ public final class DataSourceUnitPersistService implements
DatabaseBasedPersistS
@Override
public Map<String, DataSourcePoolProperties> load(final String
databaseName) {
Map<String, DataSourcePoolProperties> result = new LinkedHashMap<>();
- for (String each :
repository.getChildrenKeys(DatabaseMetaDataNode.getDataSourceUnitsNode(databaseName)))
{
- String dataSourceValue =
repository.getDirectly(DatabaseMetaDataNode.getDataSourceUnitNodeWithVersion(databaseName,
each, getDataSourceActiveVersion(databaseName, each)));
+ for (String each :
repository.getChildrenKeys(DataSourceMetaDataNode.getDataSourceUnitsNode(databaseName)))
{
+ String dataSourceValue =
repository.getDirectly(DataSourceMetaDataNode.getDataSourceUnitVersionNode(databaseName,
each, getDataSourceActiveVersion(databaseName, each)));
if (!Strings.isNullOrEmpty(dataSourceValue)) {
result.put(each, new
YamlDataSourceConfigurationSwapper().swapToDataSourcePoolProperties(YamlEngine.unmarshal(dataSourceValue,
Map.class)));
}
@@ -75,7 +75,7 @@ public final class DataSourceUnitPersistService implements
DatabaseBasedPersistS
@Override
public Map<String, DataSourcePoolProperties> load(final String
databaseName, final String name) {
Map<String, DataSourcePoolProperties> result = new LinkedHashMap<>();
- String dataSourceValue =
repository.getDirectly(DatabaseMetaDataNode.getDataSourceUnitNodeWithVersion(databaseName,
name, getDataSourceActiveVersion(databaseName, name)));
+ String dataSourceValue =
repository.getDirectly(DataSourceMetaDataNode.getDataSourceUnitVersionNode(databaseName,
name, getDataSourceActiveVersion(databaseName, name)));
if (!Strings.isNullOrEmpty(dataSourceValue)) {
result.put(name, new
YamlDataSourceConfigurationSwapper().swapToDataSourcePoolProperties(YamlEngine.unmarshal(dataSourceValue,
Map.class)));
}
@@ -84,14 +84,14 @@ public final class DataSourceUnitPersistService implements
DatabaseBasedPersistS
@Override
public void delete(final String databaseName, final String name) {
-
repository.delete(DatabaseMetaDataNode.getDataSourceUnitNode(databaseName,
name));
+
repository.delete(DataSourceMetaDataNode.getDataSourceUnitNode(databaseName,
name));
}
@Override
public Collection<MetaDataVersion> deleteConfig(final String databaseName,
final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
Collection<MetaDataVersion> result = new LinkedList<>();
for (Entry<String, DataSourcePoolProperties> entry :
dataSourceConfigs.entrySet()) {
- String delKey =
DatabaseMetaDataNode.getDataSourceUnitNode(databaseName, entry.getKey());
+ String delKey =
DataSourceMetaDataNode.getDataSourceUnitNode(databaseName, entry.getKey());
repository.delete(delKey);
result.add(new MetaDataVersion(delKey));
}
@@ -102,19 +102,19 @@ public final class DataSourceUnitPersistService
implements DatabaseBasedPersistS
public Collection<MetaDataVersion> persistConfig(final String
databaseName, final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
Collection<MetaDataVersion> result = new LinkedList<>();
for (Entry<String, DataSourcePoolProperties> entry :
dataSourceConfigs.entrySet()) {
- List<String> versions =
repository.getChildrenKeys(DatabaseMetaDataNode.getDataSourceUnitVersionsNode(databaseName,
entry.getKey()));
+ List<String> versions =
repository.getChildrenKeys(DataSourceMetaDataNode.getDataSourceUnitVersionsNode(databaseName,
entry.getKey()));
String nextActiveVersion = versions.isEmpty() ? DEFAULT_VERSION :
String.valueOf(Integer.parseInt(versions.get(0)) + 1);
-
repository.persist(DatabaseMetaDataNode.getDataSourceUnitNodeWithVersion(databaseName,
entry.getKey(), nextActiveVersion),
+
repository.persist(DataSourceMetaDataNode.getDataSourceUnitVersionNode(databaseName,
entry.getKey(), nextActiveVersion),
YamlEngine.marshal(new
YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
if (Strings.isNullOrEmpty(getDataSourceActiveVersion(databaseName,
entry.getKey()))) {
-
repository.persist(DatabaseMetaDataNode.getDataSourceUnitActiveVersionNode(databaseName,
entry.getKey()), DEFAULT_VERSION);
+
repository.persist(DataSourceMetaDataNode.getDataSourceUnitActiveVersionNode(databaseName,
entry.getKey()), DEFAULT_VERSION);
}
- result.add(new
MetaDataVersion(DatabaseMetaDataNode.getDataSourceUnitNode(databaseName,
entry.getKey()), getDataSourceActiveVersion(databaseName, entry.getKey()),
nextActiveVersion));
+ result.add(new
MetaDataVersion(DataSourceMetaDataNode.getDataSourceUnitNode(databaseName,
entry.getKey()), getDataSourceActiveVersion(databaseName, entry.getKey()),
nextActiveVersion));
}
return result;
}
private String getDataSourceActiveVersion(final String databaseName, final
String dataSourceName) {
- return
repository.getDirectly(DatabaseMetaDataNode.getDataSourceUnitActiveVersionNode(databaseName,
dataSourceName));
+ return
repository.getDirectly(DataSourceMetaDataNode.getDataSourceUnitActiveVersionNode(databaseName,
dataSourceName));
}
}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/rule/DatabaseRulePersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/rule/DatabaseRulePersistService.java
index 66ce8e195e4..93c9a298160 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/rule/DatabaseRulePersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/rule/DatabaseRulePersistService.java
@@ -23,7 +23,7 @@ import
org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import org.apache.shardingsphere.infra.util.yaml.datanode.YamlDataNode;
import
org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlDataNodeRuleConfigurationSwapper;
import
org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlDataNodeRuleConfigurationSwapperEngine;
-import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.DatabaseRuleMetaDataNode;
import
org.apache.shardingsphere.metadata.persist.service.config.AbstractPersistService;
import
org.apache.shardingsphere.metadata.persist.service.config.database.DatabaseBasedPersistService;
import org.apache.shardingsphere.mode.spi.PersistRepository;
@@ -64,13 +64,13 @@ public final class DatabaseRulePersistService extends
AbstractPersistService imp
@Override
public Collection<RuleConfiguration> load(final String databaseName) {
- Collection<YamlDataNode> dataNodes =
getDataNodes(DatabaseMetaDataNode.getRulesNode(databaseName));
+ Collection<YamlDataNode> dataNodes =
getDataNodes(DatabaseRuleMetaDataNode.getRulesNode(databaseName));
return dataNodes.isEmpty() ? Collections.emptyList() : new
YamlDataNodeRuleConfigurationSwapperEngine().swapToRuleConfigurations(dataNodes);
}
@Override
public void delete(final String databaseName, final String name) {
-
repository.delete(DatabaseMetaDataNode.getDatabaseRuleNode(databaseName, name));
+
repository.delete(DatabaseRuleMetaDataNode.getDatabaseRuleNode(databaseName,
name));
}
@SuppressWarnings({"unchecked", "rawtypes"})
@@ -91,13 +91,13 @@ public final class DatabaseRulePersistService extends
AbstractPersistService imp
private Collection<MetaDataVersion> persistDataNodes(final String
databaseName, final String ruleName, final Collection<YamlDataNode> dataNodes) {
Collection<MetaDataVersion> result = new LinkedList<>();
for (YamlDataNode each : dataNodes) {
- List<String> versions =
repository.getChildrenKeys(DatabaseMetaDataNode.getDatabaseRuleVersionsNode(databaseName,
ruleName, each.getKey()));
+ List<String> versions =
repository.getChildrenKeys(DatabaseRuleMetaDataNode.getDatabaseRuleVersionsNode(databaseName,
ruleName, each.getKey()));
String nextVersion = versions.isEmpty() ? DEFAULT_VERSION :
String.valueOf(Integer.parseInt(versions.get(0)) + 1);
-
repository.persist(DatabaseMetaDataNode.getDatabaseRuleVersionNode(databaseName,
ruleName, each.getKey(), nextVersion), each.getValue());
+
repository.persist(DatabaseRuleMetaDataNode.getDatabaseRuleVersionNode(databaseName,
ruleName, each.getKey(), nextVersion), each.getValue());
if (Strings.isNullOrEmpty(getActiveVersion(databaseName, ruleName,
each.getKey()))) {
-
repository.persist(DatabaseMetaDataNode.getDatabaseRuleActiveVersionNode(databaseName,
ruleName, each.getKey()), DEFAULT_VERSION);
+
repository.persist(DatabaseRuleMetaDataNode.getDatabaseRuleActiveVersionNode(databaseName,
ruleName, each.getKey()), DEFAULT_VERSION);
}
- result.add(new
MetaDataVersion(DatabaseMetaDataNode.getDatabaseRuleNode(databaseName,
ruleName, each.getKey()), getActiveVersion(databaseName, ruleName,
each.getKey()), nextVersion));
+ result.add(new
MetaDataVersion(DatabaseRuleMetaDataNode.getDatabaseRuleNode(databaseName,
ruleName, each.getKey()), getActiveVersion(databaseName, ruleName,
each.getKey()), nextVersion));
}
return result;
}
@@ -122,7 +122,7 @@ public final class DatabaseRulePersistService extends
AbstractPersistService imp
private Collection<MetaDataVersion> deleteDataNodes(final String
databaseName, final String ruleName, final Collection<YamlDataNode> dataNodes) {
Collection<MetaDataVersion> result = new LinkedList<>();
for (YamlDataNode each : dataNodes) {
- String delKey =
DatabaseMetaDataNode.getDatabaseRuleNode(databaseName, ruleName, each.getKey());
+ String delKey =
DatabaseRuleMetaDataNode.getDatabaseRuleNode(databaseName, ruleName,
each.getKey());
repository.delete(delKey);
result.add(new MetaDataVersion(delKey));
}
@@ -130,6 +130,6 @@ public final class DatabaseRulePersistService extends
AbstractPersistService imp
}
private String getActiveVersion(final String databaseName, final String
ruleName, final String key) {
- return
repository.getDirectly(DatabaseMetaDataNode.getDatabaseRuleActiveVersionNode(databaseName,
ruleName, key));
+ return
repository.getDirectly(DatabaseRuleMetaDataNode.getDatabaseRuleActiveVersionNode(databaseName,
ruleName, key));
}
}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistService.java
index 0cac6e01166..caa12fd28a0 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/TableMetaDataPersistService.java
@@ -24,7 +24,7 @@ import
org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import
org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereTable;
import org.apache.shardingsphere.infra.yaml.schema.swapper.YamlTableSwapper;
-import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.TableMetaDataNode;
import org.apache.shardingsphere.mode.spi.PersistRepository;
import java.util.Collection;
@@ -49,12 +49,12 @@ public final class TableMetaDataPersistService implements
SchemaMetaDataPersistS
public void persist(final String databaseName, final String schemaName,
final Map<String, ShardingSphereTable> tables) {
for (Entry<String, ShardingSphereTable> entry : tables.entrySet()) {
String tableName = entry.getKey().toLowerCase();
- List<String> versions =
repository.getChildrenKeys(DatabaseMetaDataNode.getTableVersionsNode(databaseName,
schemaName, tableName));
-
repository.persist(DatabaseMetaDataNode.getTableVersionNode(databaseName,
schemaName, tableName, versions.isEmpty()
+ List<String> versions =
repository.getChildrenKeys(TableMetaDataNode.getTableVersionsNode(databaseName,
schemaName, tableName));
+
repository.persist(TableMetaDataNode.getTableVersionNode(databaseName,
schemaName, tableName, versions.isEmpty()
? DEFAULT_VERSION
: String.valueOf(Integer.parseInt(versions.get(0)) + 1)),
YamlEngine.marshal(new
YamlTableSwapper().swapToYamlConfiguration(entry.getValue())));
- if
(Strings.isNullOrEmpty(repository.getDirectly(DatabaseMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, tableName)))) {
-
repository.persist(DatabaseMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, tableName), DEFAULT_VERSION);
+ if
(Strings.isNullOrEmpty(repository.getDirectly(TableMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, tableName)))) {
+
repository.persist(TableMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, tableName), DEFAULT_VERSION);
}
}
}
@@ -64,25 +64,25 @@ public final class TableMetaDataPersistService implements
SchemaMetaDataPersistS
Collection<MetaDataVersion> result = new LinkedList<>();
for (Entry<String, ShardingSphereTable> entry : tables.entrySet()) {
String tableName = entry.getKey().toLowerCase();
- List<String> versions =
repository.getChildrenKeys(DatabaseMetaDataNode.getTableVersionsNode(databaseName,
schemaName, tableName));
+ List<String> versions =
repository.getChildrenKeys(TableMetaDataNode.getTableVersionsNode(databaseName,
schemaName, tableName));
String nextActiveVersion = versions.isEmpty() ? DEFAULT_VERSION :
String.valueOf(Integer.parseInt(versions.get(0)) + 1);
-
repository.persist(DatabaseMetaDataNode.getTableVersionNode(databaseName,
schemaName, tableName, nextActiveVersion),
+
repository.persist(TableMetaDataNode.getTableVersionNode(databaseName,
schemaName, tableName, nextActiveVersion),
YamlEngine.marshal(new
YamlTableSwapper().swapToYamlConfiguration(entry.getValue())));
if (Strings.isNullOrEmpty(getActiveVersion(databaseName,
schemaName, tableName))) {
-
repository.persist(DatabaseMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, tableName), DEFAULT_VERSION);
+
repository.persist(TableMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, tableName), DEFAULT_VERSION);
}
- result.add(new
MetaDataVersion(DatabaseMetaDataNode.getTableNode(databaseName, schemaName,
tableName), getActiveVersion(databaseName, schemaName, tableName),
nextActiveVersion));
+ result.add(new
MetaDataVersion(TableMetaDataNode.getTableNode(databaseName, schemaName,
tableName), getActiveVersion(databaseName, schemaName, tableName),
nextActiveVersion));
}
return result;
}
private String getActiveVersion(final String databaseName, final String
schemaName, final String tableName) {
- return
repository.getDirectly(DatabaseMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, tableName));
+ return
repository.getDirectly(TableMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, tableName));
}
@Override
public Map<String, ShardingSphereTable> load(final String databaseName,
final String schemaName) {
- Collection<String> tableNames =
repository.getChildrenKeys(DatabaseMetaDataNode.getMetaDataTablesPath(databaseName,
schemaName));
+ Collection<String> tableNames =
repository.getChildrenKeys(TableMetaDataNode.getMetaDataTablesNode(databaseName,
schemaName));
return tableNames.isEmpty() ? Collections.emptyMap() :
getTableMetaDataByTableNames(databaseName, schemaName, tableNames);
}
@@ -94,8 +94,8 @@ public final class TableMetaDataPersistService implements
SchemaMetaDataPersistS
private Map<String, ShardingSphereTable>
getTableMetaDataByTableNames(final String databaseName, final String
schemaName, final Collection<String> tableNames) {
Map<String, ShardingSphereTable> result = new
LinkedHashMap<>(tableNames.size(), 1F);
tableNames.forEach(each -> {
- String table =
repository.getDirectly(DatabaseMetaDataNode.getTableVersionNode(databaseName,
schemaName, each,
-
repository.getDirectly(DatabaseMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, each))));
+ String table =
repository.getDirectly(TableMetaDataNode.getTableVersionNode(databaseName,
schemaName, each,
+
repository.getDirectly(TableMetaDataNode.getTableActiveVersionNode(databaseName,
schemaName, each))));
if (!Strings.isNullOrEmpty(table)) {
result.put(each.toLowerCase(), new
YamlTableSwapper().swapToObject(YamlEngine.unmarshal(table,
YamlShardingSphereTable.class)));
}
@@ -105,6 +105,6 @@ public final class TableMetaDataPersistService implements
SchemaMetaDataPersistS
@Override
public void delete(final String databaseName, final String schemaName,
final String tableName) {
- repository.delete(DatabaseMetaDataNode.getTableNode(databaseName,
schemaName, tableName.toLowerCase()));
+ repository.delete(TableMetaDataNode.getTableNode(databaseName,
schemaName, tableName.toLowerCase()));
}
}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/ViewMetaDataPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/ViewMetaDataPersistService.java
index 72b32bf273c..65eb5fb9717 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/ViewMetaDataPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/schema/ViewMetaDataPersistService.java
@@ -24,7 +24,7 @@ import
org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereView;
import org.apache.shardingsphere.infra.yaml.schema.swapper.YamlViewSwapper;
-import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.ViewMetaDataNode;
import org.apache.shardingsphere.mode.spi.PersistRepository;
import java.util.Collection;
@@ -49,12 +49,12 @@ public final class ViewMetaDataPersistService implements
SchemaMetaDataPersistSe
public void persist(final String databaseName, final String schemaName,
final Map<String, ShardingSphereView> views) {
for (Entry<String, ShardingSphereView> entry : views.entrySet()) {
String viewName = entry.getKey().toLowerCase();
- List<String> versions =
repository.getChildrenKeys(DatabaseMetaDataNode.getViewVersionsNode(databaseName,
schemaName, viewName));
-
repository.persist(DatabaseMetaDataNode.getViewVersionNode(databaseName,
schemaName, viewName, versions.isEmpty()
+ List<String> versions =
repository.getChildrenKeys(ViewMetaDataNode.getViewVersionsNode(databaseName,
schemaName, viewName));
+
repository.persist(ViewMetaDataNode.getViewVersionNode(databaseName,
schemaName, viewName, versions.isEmpty()
? DEFAULT_VERSION
: String.valueOf(Integer.parseInt(versions.get(0)) + 1)),
YamlEngine.marshal(new
YamlViewSwapper().swapToYamlConfiguration(entry.getValue())));
- if
(Strings.isNullOrEmpty(repository.getDirectly(DatabaseMetaDataNode.getViewActiveVersionNode(databaseName,
schemaName, viewName)))) {
-
repository.persist(DatabaseMetaDataNode.getViewActiveVersionNode(databaseName,
schemaName, viewName), DEFAULT_VERSION);
+ if
(Strings.isNullOrEmpty(repository.getDirectly(ViewMetaDataNode.getViewActiveVersionNode(databaseName,
schemaName, viewName)))) {
+
repository.persist(ViewMetaDataNode.getViewActiveVersionNode(databaseName,
schemaName, viewName), DEFAULT_VERSION);
}
}
}
@@ -64,25 +64,25 @@ public final class ViewMetaDataPersistService implements
SchemaMetaDataPersistSe
Collection<MetaDataVersion> result = new LinkedList<>();
for (Entry<String, ShardingSphereView> entry : views.entrySet()) {
String viewName = entry.getKey().toLowerCase();
- List<String> versions =
repository.getChildrenKeys(DatabaseMetaDataNode.getViewVersionsNode(databaseName,
schemaName, viewName));
+ List<String> versions =
repository.getChildrenKeys(ViewMetaDataNode.getViewVersionsNode(databaseName,
schemaName, viewName));
String nextActiveVersion = versions.isEmpty() ? DEFAULT_VERSION :
String.valueOf(Integer.parseInt(versions.get(0)) + 1);
-
repository.persist(DatabaseMetaDataNode.getViewVersionNode(databaseName,
schemaName, viewName, nextActiveVersion),
+
repository.persist(ViewMetaDataNode.getViewVersionNode(databaseName,
schemaName, viewName, nextActiveVersion),
YamlEngine.marshal(new
YamlViewSwapper().swapToYamlConfiguration(entry.getValue())));
if (Strings.isNullOrEmpty(getActiveVersion(databaseName,
schemaName, viewName))) {
-
repository.persist(DatabaseMetaDataNode.getViewActiveVersionNode(databaseName,
schemaName, viewName), DEFAULT_VERSION);
+
repository.persist(ViewMetaDataNode.getViewActiveVersionNode(databaseName,
schemaName, viewName), DEFAULT_VERSION);
}
- result.add(new
MetaDataVersion(DatabaseMetaDataNode.getViewNode(databaseName, schemaName,
viewName), getActiveVersion(databaseName, schemaName, viewName),
nextActiveVersion));
+ result.add(new
MetaDataVersion(ViewMetaDataNode.getViewNode(databaseName, schemaName,
viewName), getActiveVersion(databaseName, schemaName, viewName),
nextActiveVersion));
}
return result;
}
private String getActiveVersion(final String databaseName, final String
schemaName, final String viewName) {
- return
repository.getDirectly(DatabaseMetaDataNode.getViewActiveVersionNode(databaseName,
schemaName, viewName));
+ return
repository.getDirectly(ViewMetaDataNode.getViewActiveVersionNode(databaseName,
schemaName, viewName));
}
@Override
public Map<String, ShardingSphereView> load(final String databaseName,
final String schemaName) {
- Collection<String> viewNames =
repository.getChildrenKeys(DatabaseMetaDataNode.getMetaDataViewsPath(databaseName,
schemaName));
+ Collection<String> viewNames =
repository.getChildrenKeys(ViewMetaDataNode.getMetaDataViewsNode(databaseName,
schemaName));
return viewNames.isEmpty() ? Collections.emptyMap() :
getViewMetaDataByViewNames(databaseName, schemaName, viewNames);
}
@@ -94,8 +94,8 @@ public final class ViewMetaDataPersistService implements
SchemaMetaDataPersistSe
private Map<String, ShardingSphereView> getViewMetaDataByViewNames(final
String databaseName, final String schemaName, final Collection<String>
viewNames) {
Map<String, ShardingSphereView> result = new
LinkedHashMap<>(viewNames.size(), 1F);
viewNames.forEach(each -> {
- String view =
repository.getDirectly(DatabaseMetaDataNode.getViewVersionNode(databaseName,
schemaName, each,
-
repository.getDirectly(DatabaseMetaDataNode.getViewActiveVersionNode(databaseName,
schemaName, each))));
+ String view =
repository.getDirectly(ViewMetaDataNode.getViewVersionNode(databaseName,
schemaName, each,
+
repository.getDirectly(ViewMetaDataNode.getViewActiveVersionNode(databaseName,
schemaName, each))));
if (!Strings.isNullOrEmpty(view)) {
result.put(each.toLowerCase(), new
YamlViewSwapper().swapToObject(YamlEngine.unmarshal(view,
YamlShardingSphereView.class)));
}
@@ -105,6 +105,6 @@ public final class ViewMetaDataPersistService implements
SchemaMetaDataPersistSe
@Override
public void delete(final String databaseName, final String schemaName,
final String viewName) {
- repository.delete(DatabaseMetaDataNode.getViewNode(databaseName,
schemaName, viewName.toLowerCase()));
+ repository.delete(ViewMetaDataNode.getViewNode(databaseName,
schemaName, viewName.toLowerCase()));
}
}
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/DatabaseMetaDataNodeTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/DatabaseMetaDataNodeTest.java
index 645e1cad74b..9d03e62b767 100644
---
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/DatabaseMetaDataNodeTest.java
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/DatabaseMetaDataNodeTest.java
@@ -27,28 +27,6 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class DatabaseMetaDataNodeTest {
- @Test
- void assertIsDataSourcesNode() {
-
assertTrue(DatabaseMetaDataNode.isDataSourcesNode("/metadata/logic_db/data_sources/foo_ds"));
- }
-
- @Test
- void assertGetDataSourceNameByDataSourceUnitNode() {
- Optional<String> actual =
DatabaseMetaDataNode.getDataSourceNameByDataSourceUnitNode("/metadata/logic_db/data_sources/units/foo_ds/versions/0");
- assertTrue(actual.isPresent());
- assertThat(actual.get(), is("foo_ds"));
- }
-
- @Test
- void assertIsDataSourceUnitActiveVersionNode() {
-
assertTrue(DatabaseMetaDataNode.isDataSourceUnitActiveVersionNode("/metadata/logic_db/data_sources/units/foo_ds/active_version"));
- }
-
- @Test
- void assertIsDataSourceNodeActiveVersionNode() {
-
assertTrue(DatabaseMetaDataNode.isDataSourceNodeActiveVersionNode("/metadata/logic_db/data_sources/nodes/foo_ds/active_version"));
- }
-
@Test
void assertGetDatabaseName() {
Optional<String> actual =
DatabaseMetaDataNode.getDatabaseName("/metadata/foo_db");
@@ -76,119 +54,4 @@ class DatabaseMetaDataNodeTest {
assertTrue(actual.isPresent());
assertThat(actual.get(), is("foo_schema"));
}
-
- @Test
- void assertGetTableName() {
- Optional<String> actual =
DatabaseMetaDataNode.getTableName("/metadata/foo_db/schemas/foo_schema/tables/foo_table/active_version");
- assertTrue(actual.isPresent());
- assertThat(actual.get(), is("foo_table"));
- }
-
- @Test
- void assertIsTableActiveVersionNode() {
-
assertTrue(DatabaseMetaDataNode.isTableActiveVersionNode("/metadata/foo_db/schemas/foo_schema/tables/foo_table/active_version"));
- }
-
- @Test
- void assertGetViewName() {
- Optional<String> actual =
DatabaseMetaDataNode.getViewName("/metadata/foo_db/schemas/foo_schema/views/foo_view");
- assertTrue(actual.isPresent());
- assertThat(actual.get(), is("foo_view"));
- }
-
- @Test
- void assertIsViewActiveVersionNode() {
-
assertTrue(DatabaseMetaDataNode.isViewActiveVersionNode("/metadata/foo_db/schemas/foo_schema/views/foo_view/active_version"));
- }
-
- @Test
- void assertGetVersionNodeByActiveVersionPath() {
-
assertThat(DatabaseMetaDataNode.getVersionNodeByActiveVersionPath("/metadata/foo_db/schemas/foo_schema/views/foo_view/active_version",
"0"),
-
is("/metadata/foo_db/schemas/foo_schema/views/foo_view/versions/0"));
- }
-
- @Test
- void assertGetMetaDataDataSourcesNode() {
- assertThat(DatabaseMetaDataNode.getDataSourceUnitsNode("foo_db"),
is("/metadata/foo_db/data_sources/units"));
- }
-
- @Test
- void assertGetMetaDataDataSourceNode() {
- assertThat(DatabaseMetaDataNode.getDataSourceUnitNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds"));
- }
-
- @Test
- void assertGetDataSourceUnitNodeWithVersion() {
-
assertThat(DatabaseMetaDataNode.getDataSourceUnitNodeWithVersion("foo_db",
"foo_ds", "0"), is("/metadata/foo_db/data_sources/units/foo_ds/versions/0"));
- }
-
- @Test
- void assertGetDataSourceUnitVersionsNode() {
-
assertThat(DatabaseMetaDataNode.getDataSourceUnitVersionsNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/versions"));
- }
-
- @Test
- void assertGetDataSourceUnitActiveVersionNode() {
-
assertThat(DatabaseMetaDataNode.getDataSourceUnitActiveVersionNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/active_version"));
- }
-
- @Test
- void assertGetDatabaseRuleActiveVersionNode() {
-
assertThat(DatabaseMetaDataNode.getDatabaseRuleActiveVersionNode("foo_db",
"foo_rule", "foo_tables"),
is("/metadata/foo_db/rules/foo_rule/foo_tables/active_version"));
- }
-
- @Test
- void assertGetDatabaseRuleVersionsNode() {
- assertThat(DatabaseMetaDataNode.getDatabaseRuleVersionsNode("foo_db",
"sharding", "foo_key"), is("/metadata/foo_db/rules/sharding/foo_key/versions"));
- }
-
- @Test
- void assertGetDatabaseRuleVersionNode() {
- assertThat(DatabaseMetaDataNode.getDatabaseRuleVersionNode("foo_db",
"foo_rule", "foo_tables", "1"),
is("/metadata/foo_db/rules/foo_rule/foo_tables/versions/1"));
- }
-
- @Test
- void assertGetTableActiveVersionNode() {
- assertThat(DatabaseMetaDataNode.getTableActiveVersionNode("foo_db",
"foo_schema", "foo_table"),
is("/metadata/foo_db/schemas/foo_schema/tables/foo_table/active_version"));
- }
-
- @Test
- void assertGetTableVersionsNode() {
- assertThat(DatabaseMetaDataNode.getTableVersionsNode("foo_db",
"foo_schema", "foo_table"),
is("/metadata/foo_db/schemas/foo_schema/tables/foo_table/versions"));
- }
-
- @Test
- void assertGetTableVersionNode() {
- assertThat(DatabaseMetaDataNode.getTableVersionNode("foo_db",
"foo_schema", "foo_table", "0"),
is("/metadata/foo_db/schemas/foo_schema/tables/foo_table/versions/0"));
- }
-
- @Test
- void assertGetTableNode() {
- assertThat(DatabaseMetaDataNode.getTableNode("foo_db", "foo_schema",
"foo_table"), is("/metadata/foo_db/schemas/foo_schema/tables/foo_table"));
- }
-
- @Test
- void assertGetViewActiveVersionNode() {
- assertThat(DatabaseMetaDataNode.getViewActiveVersionNode("foo_db",
"foo_schema", "foo_view"),
is("/metadata/foo_db/schemas/foo_schema/views/foo_view/active_version"));
- }
-
- @Test
- void assertGetViewVersionsNode() {
- assertThat(DatabaseMetaDataNode.getViewVersionsNode("foo_db",
"foo_schema", "foo_view"),
is("/metadata/foo_db/schemas/foo_schema/views/foo_view/versions"));
- }
-
- @Test
- void assertGetViewVersionNode() {
- assertThat(DatabaseMetaDataNode.getViewVersionNode("foo_db",
"foo_schema", "foo_view", "0"),
is("/metadata/foo_db/schemas/foo_schema/views/foo_view/versions/0"));
- }
-
- @Test
- void assertGetViewNode() {
- assertThat(DatabaseMetaDataNode.getViewNode("foo_db", "foo_schema",
"foo_view"), is("/metadata/foo_db/schemas/foo_schema/views/foo_view"));
- }
-
- @Test
- void assertGetDataSourceNodeVersionsNode() {
-
assertThat(DatabaseMetaDataNode.getDataSourceNodeVersionsNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds/versions"));
- }
}
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodeTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodeTest.java
new file mode 100644
index 00000000000..4c9cbf38bfc
--- /dev/null
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodeTest.java
@@ -0,0 +1,81 @@
+/*
+ * 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.metadata.persist.node.metadata;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class DataSourceMetaDataNodeTest {
+
+ @Test
+ void assertIsDataSourcesNode() {
+
assertTrue(DataSourceMetaDataNode.isDataSourcesNode("/metadata/logic_db/data_sources/foo_ds"));
+ }
+
+ @Test
+ void assertGetDataSourceNameByDataSourceUnitNode() {
+ Optional<String> actual =
DataSourceMetaDataNode.getDataSourceNameByDataSourceUnitNode("/metadata/logic_db/data_sources/units/foo_ds/versions/0");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo_ds"));
+ }
+
+ @Test
+ void assertIsDataSourceUnitActiveVersionNode() {
+
assertTrue(DataSourceMetaDataNode.isDataSourceUnitActiveVersionNode("/metadata/logic_db/data_sources/units/foo_ds/active_version"));
+ }
+
+ @Test
+ void assertIsDataSourceNodeActiveVersionNode() {
+
assertTrue(DataSourceMetaDataNode.isDataSourceNodeActiveVersionNode("/metadata/logic_db/data_sources/nodes/foo_ds/active_version"));
+ }
+
+ @Test
+ void assertGetMetaDataDataSourcesNode() {
+ assertThat(DataSourceMetaDataNode.getDataSourceUnitsNode("foo_db"),
is("/metadata/foo_db/data_sources/units"));
+ }
+
+ @Test
+ void assertGetMetaDataDataSourceNode() {
+ assertThat(DataSourceMetaDataNode.getDataSourceUnitNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds"));
+ }
+
+ @Test
+ void assertGetDataSourceUnitNodeWithVersion() {
+
assertThat(DataSourceMetaDataNode.getDataSourceUnitVersionNode("foo_db",
"foo_ds", "0"), is("/metadata/foo_db/data_sources/units/foo_ds/versions/0"));
+ }
+
+ @Test
+ void assertGetDataSourceUnitVersionsNode() {
+
assertThat(DataSourceMetaDataNode.getDataSourceUnitVersionsNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/versions"));
+ }
+
+ @Test
+ void assertGetDataSourceUnitActiveVersionNode() {
+
assertThat(DataSourceMetaDataNode.getDataSourceUnitActiveVersionNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/active_version"));
+ }
+
+ @Test
+ void assertGetDataSourceNodeVersionsNode() {
+
assertThat(DataSourceMetaDataNode.getDataSourceNodeVersionsNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds/versions"));
+ }
+}
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DatabaseRuleMetaDataNodeTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DatabaseRuleMetaDataNodeTest.java
new file mode 100644
index 00000000000..394e227f933
--- /dev/null
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DatabaseRuleMetaDataNodeTest.java
@@ -0,0 +1,45 @@
+/*
+ * 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.metadata.persist.node.metadata;
+
+import org.junit.jupiter.api.Test;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+class DatabaseRuleMetaDataNodeTest {
+
+ @Test
+ void assertGetDatabaseRuleNode() {
+ assertThat(DatabaseRuleMetaDataNode.getDatabaseRuleNode("foo_db",
"foo_rule", "sharding"), is("/metadata/foo_db/rules/foo_rule/sharding"));
+ }
+
+ @Test
+ void assertGetDatabaseRuleActiveVersionNode() {
+
assertThat(DatabaseRuleMetaDataNode.getDatabaseRuleActiveVersionNode("foo_db",
"foo_rule", "foo_tables"),
is("/metadata/foo_db/rules/foo_rule/foo_tables/active_version"));
+ }
+
+ @Test
+ void assertGetDatabaseRuleVersionsNode() {
+
assertThat(DatabaseRuleMetaDataNode.getDatabaseRuleVersionsNode("foo_db",
"sharding", "foo_key"), is("/metadata/foo_db/rules/sharding/foo_key/versions"));
+ }
+
+ @Test
+ void assertGetDatabaseRuleVersionNode() {
+
assertThat(DatabaseRuleMetaDataNode.getDatabaseRuleVersionNode("foo_db",
"foo_rule", "foo_tables", "1"),
is("/metadata/foo_db/rules/foo_rule/foo_tables/versions/1"));
+ }
+}
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/TableMetaDataNodeTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/TableMetaDataNodeTest.java
new file mode 100644
index 00000000000..8af0ac316d5
--- /dev/null
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/TableMetaDataNodeTest.java
@@ -0,0 +1,61 @@
+/*
+ * 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.metadata.persist.node.metadata;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class TableMetaDataNodeTest {
+
+ @Test
+ void assertGetTableNameByActiveVersionNode() {
+ Optional<String> actual =
TableMetaDataNode.getTableNameByActiveVersionNode("/metadata/foo_db/schemas/foo_schema/tables/foo_table/active_version");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo_table"));
+ }
+
+ @Test
+ void assertIsTableActiveVersionNode() {
+
assertTrue(TableMetaDataNode.isTableActiveVersionNode("/metadata/foo_db/schemas/foo_schema/tables/foo_table/active_version"));
+ }
+
+ @Test
+ void assertGetTableActiveVersionNode() {
+ assertThat(TableMetaDataNode.getTableActiveVersionNode("foo_db",
"foo_schema", "foo_table"),
is("/metadata/foo_db/schemas/foo_schema/tables/foo_table/active_version"));
+ }
+
+ @Test
+ void assertGetTableVersionsNode() {
+ assertThat(TableMetaDataNode.getTableVersionsNode("foo_db",
"foo_schema", "foo_table"),
is("/metadata/foo_db/schemas/foo_schema/tables/foo_table/versions"));
+ }
+
+ @Test
+ void assertGetTableVersionNode() {
+ assertThat(TableMetaDataNode.getTableVersionNode("foo_db",
"foo_schema", "foo_table", "0"),
is("/metadata/foo_db/schemas/foo_schema/tables/foo_table/versions/0"));
+ }
+
+ @Test
+ void assertGetTableNode() {
+ assertThat(TableMetaDataNode.getTableNode("foo_db", "foo_schema",
"foo_table"), is("/metadata/foo_db/schemas/foo_schema/tables/foo_table"));
+ }
+}
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/ViewMetaDataNodeTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/ViewMetaDataNodeTest.java
new file mode 100644
index 00000000000..444efffc664
--- /dev/null
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/ViewMetaDataNodeTest.java
@@ -0,0 +1,75 @@
+/*
+ * 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.metadata.persist.node.metadata;
+
+import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ViewMetaDataNodeTest {
+
+ @Test
+ void assertGetViewName() {
+ Optional<String> actual =
ViewMetaDataNode.getViewName("/metadata/foo_db/schemas/foo_schema/views/foo_view");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo_view"));
+ }
+
+ @Test
+ void assertIsViewActiveVersionNode() {
+
assertTrue(ViewMetaDataNode.isViewActiveVersionNode("/metadata/foo_db/schemas/foo_schema/views/foo_view/active_version"));
+ }
+
+ @Test
+ void assertGetVersionNodeByActiveVersionPath() {
+
assertThat(DatabaseMetaDataNode.getVersionNodeByActiveVersionPath("/metadata/foo_db/schemas/foo_schema/views/foo_view/active_version",
"0"),
+
is("/metadata/foo_db/schemas/foo_schema/views/foo_view/versions/0"));
+ }
+
+ @Test
+ void assertGetViewActiveVersionNode() {
+ assertThat(ViewMetaDataNode.getViewActiveVersionNode("foo_db",
"foo_schema", "foo_view"),
is("/metadata/foo_db/schemas/foo_schema/views/foo_view/active_version"));
+ }
+
+ @Test
+ void assertGetViewVersionsNode() {
+ assertThat(ViewMetaDataNode.getViewVersionsNode("foo_db",
"foo_schema", "foo_view"),
is("/metadata/foo_db/schemas/foo_schema/views/foo_view/versions"));
+ }
+
+ @Test
+ void assertGetViewVersionNode() {
+ assertThat(ViewMetaDataNode.getViewVersionNode("foo_db", "foo_schema",
"foo_view", "0"),
is("/metadata/foo_db/schemas/foo_schema/views/foo_view/versions/0"));
+ }
+
+ @Test
+ void assertGetViewNode() {
+ assertThat(ViewMetaDataNode.getViewNode("foo_db", "foo_schema",
"foo_view"), is("/metadata/foo_db/schemas/foo_schema/views/foo_view"));
+ }
+
+ @Test
+ void assertGetTableNameByActiveVersionNode() {
+ Optional<String> actual =
ViewMetaDataNode.getViewNameByActiveVersionNode("/metadata/foo_db/schemas/foo_schema/views/foo_view/active_version");
+ assertTrue(actual.isPresent());
+ assertThat(actual.get(), is("foo_view"));
+ }
+}
diff --git
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/registry/metadata/watcher/MetaDataChangedWatcher.java
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/registry/metadata/watcher/MetaDataChangedWatcher.java
index d95c1655948..c3d21be85ea 100644
---
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/registry/metadata/watcher/MetaDataChangedWatcher.java
+++
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/registry/metadata/watcher/MetaDataChangedWatcher.java
@@ -20,6 +20,9 @@ package
org.apache.shardingsphere.mode.manager.cluster.coordinator.registry.meta
import com.google.common.base.Preconditions;
import org.apache.shardingsphere.infra.rule.event.GovernanceEvent;
import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.DataSourceMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.TableMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.ViewMetaDataNode;
import org.apache.shardingsphere.mode.event.DataChangedEvent;
import org.apache.shardingsphere.mode.event.DataChangedEvent.Type;
import
org.apache.shardingsphere.mode.event.datasource.nodes.AlterStorageNodeEvent;
@@ -75,16 +78,16 @@ public final class MetaDataChangedWatcher implements
GovernanceWatcher<Governanc
return createSchemaChangedEvent(databaseName.get(),
schemaName.get(), event);
}
schemaName = DatabaseMetaDataNode.getSchemaNameByTableNode(key);
- if (databaseName.isPresent() && schemaName.isPresent() &&
DatabaseMetaDataNode.isTableActiveVersionNode(event.getKey())) {
+ if (databaseName.isPresent() && schemaName.isPresent() &&
TableMetaDataNode.isTableActiveVersionNode(event.getKey())) {
return createTableChangedEvent(databaseName.get(),
schemaName.get(), event);
}
- if (databaseName.isPresent() && schemaName.isPresent() &&
DatabaseMetaDataNode.isViewActiveVersionNode(event.getKey())) {
+ if (databaseName.isPresent() && schemaName.isPresent() &&
ViewMetaDataNode.isViewActiveVersionNode(event.getKey())) {
return createViewChangedEvent(databaseName.get(),
schemaName.get(), event);
}
if (!databaseName.isPresent()) {
return Optional.empty();
}
- if (DatabaseMetaDataNode.isDataSourcesNode(key)) {
+ if (DataSourceMetaDataNode.isDataSourcesNode(key)) {
return createDataSourceEvent(databaseName.get(), event);
}
return ruleConfigurationEventBuilder.build(databaseName.get(), event);
@@ -111,7 +114,7 @@ public final class MetaDataChangedWatcher implements
GovernanceWatcher<Governanc
}
private Optional<GovernanceEvent> createTableChangedEvent(final String
databaseName, final String schemaName, final DataChangedEvent event) {
- Optional<String> tableName =
DatabaseMetaDataNode.getTableName(event.getKey());
+ Optional<String> tableName =
TableMetaDataNode.getTableNameByActiveVersionNode(event.getKey());
Preconditions.checkState(tableName.isPresent(), "Not found table
name.");
if (Type.DELETED == event.getType()) {
return Optional.of(new DropTableEvent(databaseName, schemaName,
tableName.get()));
@@ -120,7 +123,7 @@ public final class MetaDataChangedWatcher implements
GovernanceWatcher<Governanc
}
private Optional<GovernanceEvent> createViewChangedEvent(final String
databaseName, final String schemaName, final DataChangedEvent event) {
- Optional<String> viewName =
DatabaseMetaDataNode.getViewName(event.getKey());
+ Optional<String> viewName =
ViewMetaDataNode.getViewNameByActiveVersionNode(event.getKey());
Preconditions.checkState(viewName.isPresent(), "Not found view name.");
if (Type.DELETED == event.getType()) {
return Optional.of(new DropViewEvent(databaseName, schemaName,
viewName.get(), event.getKey(), event.getValue()));
@@ -129,17 +132,17 @@ public final class MetaDataChangedWatcher implements
GovernanceWatcher<Governanc
}
private Optional<GovernanceEvent> createDataSourceEvent(final String
databaseName, final DataChangedEvent event) {
- if
(DatabaseMetaDataNode.isDataSourceUnitActiveVersionNode(event.getKey())) {
+ if
(DataSourceMetaDataNode.isDataSourceUnitActiveVersionNode(event.getKey())) {
return createStorageUnitChangedEvent(databaseName, event);
}
- if
(DatabaseMetaDataNode.isDataSourceNodeActiveVersionNode(event.getKey())) {
+ if
(DataSourceMetaDataNode.isDataSourceNodeActiveVersionNode(event.getKey())) {
return createStorageNodeChangedEvent(databaseName, event);
}
return Optional.empty();
}
private Optional<GovernanceEvent> createStorageUnitChangedEvent(final
String databaseName, final DataChangedEvent event) {
- Optional<String> dataSourceUnitName =
DatabaseMetaDataNode.getDataSourceNameByDataSourceUnitNode(event.getKey());
+ Optional<String> dataSourceUnitName =
DataSourceMetaDataNode.getDataSourceNameByDataSourceUnitNode(event.getKey());
if (!dataSourceUnitName.isPresent()) {
return Optional.empty();
}
@@ -153,7 +156,7 @@ public final class MetaDataChangedWatcher implements
GovernanceWatcher<Governanc
}
private Optional<GovernanceEvent> createStorageNodeChangedEvent(final
String databaseName, final DataChangedEvent event) {
- Optional<String> dataSourceNodeName =
DatabaseMetaDataNode.getDataSourceNameByDataSourceNode(event.getKey());
+ Optional<String> dataSourceNodeName =
DataSourceMetaDataNode.getDataSourceNameByDataSourceNode(event.getKey());
if (!dataSourceNodeName.isPresent()) {
return Optional.empty();
}
