You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by su...@apache.org on 2024/02/06 15:08:16 UTC

(shardingsphere) branch master updated: Refactor UnregisterStorageUnitExecutorTest (#30028)

This is an automated email from the ASF dual-hosted git repository.

sunnianjun 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 c87cd375e99 Refactor UnregisterStorageUnitExecutorTest (#30028)
c87cd375e99 is described below

commit c87cd375e998a92d3ed072dcd0b72eeae68279e9
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Tue Feb 6 23:08:08 2024 +0800

    Refactor UnregisterStorageUnitExecutorTest (#30028)
    
    * Refactor UnregisterStorageUnitExecutorTest
    
    * Refactor UnregisterStorageUnitExecutorTest
---
 .../resource/UnregisterStorageUnitExecutor.java    |   9 +-
 .../UnregisterStorageUnitExecutorTest.java         | 126 +++++++--------------
 .../fixture/FixtureUnregisterStorageUnitRule.java  |  71 ++++++++++++
 ...xtureUnregisterStorageUnitRuleUsageChecker.java |  35 ++++++
 ....resource.UnregisterStorageUnitRuleUsageChecker |  18 +++
 5 files changed, 170 insertions(+), 89 deletions(-)

diff --git a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitExecutor.java b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitExecutor.java
index 461d1142ec5..a2082563f96 100644
--- a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitExecutor.java
+++ b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitExecutor.java
@@ -78,12 +78,9 @@ public final class UnregisterStorageUnitExecutor implements DistSQLUpdateExecuto
             return;
         }
         Collection<Class<? extends ShardingSphereRule>> ignoreShardingSphereRules = getIgnoreShardingSphereRules(sqlStatement);
-        if (!ignoreShardingSphereRules.isEmpty()) {
-            checkInUsedIgnoreTables(new HashSet<>(inUsedStorageUnitNames), inUsedStorageUnits, ignoreShardingSphereRules);
-        } else {
-            String firstResource = inUsedStorageUnitNames.iterator().next();
-            throw new StorageUnitInUsedException(firstResource, inUsedStorageUnits.get(firstResource));
-        }
+        String firstResource = inUsedStorageUnitNames.iterator().next();
+        ShardingSpherePreconditions.checkState(!ignoreShardingSphereRules.isEmpty(), () -> new StorageUnitInUsedException(firstResource, inUsedStorageUnits.get(firstResource)));
+        checkInUsedIgnoreTables(new HashSet<>(inUsedStorageUnitNames), inUsedStorageUnits, ignoreShardingSphereRules);
     }
     
     private Collection<Class<? extends ShardingSphereRule>> getIgnoreShardingSphereRules(final UnregisterStorageUnitStatement sqlStatement) {
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitExecutorTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitExecutorTest.java
index e6416bfcdfe..633c13331ef 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitExecutorTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitExecutorTest.java
@@ -20,28 +20,25 @@ package org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.resource;
 import org.apache.shardingsphere.distsql.handler.exception.storageunit.MissingRequiredStorageUnitsException;
 import org.apache.shardingsphere.distsql.handler.exception.storageunit.StorageUnitInUsedException;
 import org.apache.shardingsphere.distsql.statement.rdl.resource.unit.type.UnregisterStorageUnitStatement;
-import org.apache.shardingsphere.infra.datanode.DataNode;
 import org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
 import org.apache.shardingsphere.infra.exception.core.external.sql.type.kernel.category.DistSQLException;
 import org.apache.shardingsphere.infra.instance.mode.ModeContextManager;
 import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
 import org.apache.shardingsphere.infra.metadata.database.resource.node.StorageNode;
 import org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnit;
 import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
+import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
+import org.apache.shardingsphere.infra.rule.identifier.type.DataSourceContainedRule;
 import org.apache.shardingsphere.mode.manager.ContextManager;
 import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
-import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
-import org.apache.shardingsphere.shadow.rule.ShadowRule;
-import org.apache.shardingsphere.single.rule.SingleRule;
+import org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.resource.fixture.FixtureUnregisterStorageUnitRule;
 import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
-import org.apache.shardingsphere.test.mock.AutoMockExtension;
-import org.apache.shardingsphere.test.mock.StaticMockSettings;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Answers;
 import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.mockito.junit.jupiter.MockitoSettings;
 import org.mockito.quality.Strictness;
 
@@ -53,44 +50,36 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
 
-@ExtendWith(AutoMockExtension.class)
-@StaticMockSettings(ProxyContext.class)
+@ExtendWith(MockitoExtension.class)
 @MockitoSettings(strictness = Strictness.LENIENT)
 class UnregisterStorageUnitExecutorTest {
     
+    private final UnregisterStorageUnitExecutor executor = new UnregisterStorageUnitExecutor();
+    
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private ShardingSphereDatabase database;
     
-    @Mock
-    private ResourceMetaData resourceMetaData;
-    
-    @Mock
-    private ShadowRule shadowRule;
-    
-    @Mock
-    private SingleRule singleRule;
-    
     private ContextManager contextManager;
     
     @Mock
     private ModeContextManager modeContextManager;
     
-    private UnregisterStorageUnitExecutor executor;
-    
     @BeforeEach
     void setUp() {
-        resourceMetaData = mock(ResourceMetaData.class, RETURNS_DEEP_STUBS);
+        when(database.getName()).thenReturn("foo_db");
+        StorageUnit storageUnit = createStorageUnit();
+        when(database.getResourceMetaData().getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds", storageUnit));
+        contextManager = mockContextManager();
+        executor.setDatabase(database);
+    }
+    
+    private static StorageUnit createStorageUnit() {
         DataSourcePoolProperties dataSourcePoolProps = mock(DataSourcePoolProperties.class, RETURNS_DEEP_STUBS);
         when(dataSourcePoolProps.getConnectionPropertySynonyms().getStandardProperties()).thenReturn(Collections.emptyMap());
         when(dataSourcePoolProps.getConnectionPropertySynonyms().getStandardProperties()).thenReturn(Collections.singletonMap("url", "jdbc:mock://127.0.0.1/foo_db"));
-        StorageUnit storageUnit = new StorageUnit(mock(StorageNode.class), dataSourcePoolProps, new MockedDataSource());
-        when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds", storageUnit));
-        when(database.getName()).thenReturn("foo_db");
-        when(database.getResourceMetaData()).thenReturn(resourceMetaData);
-        contextManager = mockContextManager();
-        when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
-        executor = new UnregisterStorageUnitExecutor();
+        return new StorageUnit(mock(StorageNode.class), dataSourcePoolProps, new MockedDataSource());
     }
     
     private ContextManager mockContextManager() {
@@ -103,83 +92,54 @@ class UnregisterStorageUnitExecutorTest {
     }
     
     @Test
-    void assertExecute() throws SQLException {
-        StorageUnit storageUnit = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
-        when(storageUnit.getDataSource()).thenReturn(new MockedDataSource());
-        when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds", storageUnit));
-        when(database.getResourceMetaData()).thenReturn(resourceMetaData);
+    void assertExecuteUpdateSuccess() throws SQLException {
         when(database.getRuleMetaData().getInUsedStorageUnitNameAndRulesMap()).thenReturn(Collections.emptyMap());
-        UnregisterStorageUnitStatement unregisterStorageUnitStatement = new UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false);
-        executor.setDatabase(database);
-        executor.executeUpdate(unregisterStorageUnitStatement, contextManager);
-        verify(modeContextManager).unregisterStorageUnits("foo_db", unregisterStorageUnitStatement.getStorageUnitNames());
+        UnregisterStorageUnitStatement sqlStatement = new UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false);
+        executor.executeUpdate(sqlStatement, contextManager);
+        verify(modeContextManager).unregisterStorageUnits("foo_db", sqlStatement.getStorageUnitNames());
     }
     
     @Test
-    void assertExecuteUpdateWithStorageUnitNameNotExisted() {
-        when(ProxyContext.getInstance().getContextManager().getDatabase("foo_db").getResourceMetaData().getStorageUnits()).thenReturn(Collections.emptyMap());
-        executor.setDatabase(database);
+    void assertExecuteUpdateWithStorageUnitNotExisted() {
+        when(database.getResourceMetaData().getStorageUnits()).thenReturn(Collections.emptyMap());
         assertThrows(MissingRequiredStorageUnitsException.class,
                 () -> executor.executeUpdate(new UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false), mock(ContextManager.class)));
     }
     
     @Test
-    void assertExecuteUpdateWithStorageUnitNameInUse() {
-        when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(shadowRule)));
-        when(shadowRule.getDataSourceMapper()).thenReturn(Collections.singletonMap("", Collections.singleton("foo_ds")));
-        StorageUnit storageUnit = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
-        when(storageUnit.getDataSource()).thenReturn(new MockedDataSource());
-        when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds", storageUnit));
-        when(database.getResourceMetaData()).thenReturn(resourceMetaData);
-        executor.setDatabase(database);
+    void assertExecuteUpdateWithStorageUnitInUsed() {
+        ShardingSphereRule rule = mock(ShardingSphereRule.class, withSettings().extraInterfaces(DataSourceContainedRule.class));
+        when(((DataSourceContainedRule) rule).getDataSourceMapper()).thenReturn(Collections.singletonMap("", Collections.singleton("foo_ds")));
+        when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(rule)));
         assertThrows(StorageUnitInUsedException.class, () -> executor.executeUpdate(new UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false), mock(ContextManager.class)));
     }
     
     @Test
-    void assertExecuteUpdateWithStorageUnitNameInUseWithoutIgnoreSingleTables() {
-        when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(singleRule)));
-        DataNode dataNode = mock(DataNode.class);
-        when(dataNode.getDataSourceName()).thenReturn("foo_ds");
-        when(singleRule.getAllDataNodes()).thenReturn(Collections.singletonMap("", Collections.singleton(dataNode)));
-        StorageUnit storageUnit = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
-        when(storageUnit.getDataSource()).thenReturn(new MockedDataSource());
-        when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds", storageUnit));
-        when(database.getResourceMetaData()).thenReturn(resourceMetaData);
-        executor.setDatabase(database);
+    void assertExecuteUpdateWithStorageUnitInUsedWithoutIgnoredTables() {
+        when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(new FixtureUnregisterStorageUnitRule())));
         assertThrows(StorageUnitInUsedException.class, () -> executor.executeUpdate(new UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false), mock(ContextManager.class)));
     }
     
     @Test
-    void assertStorageUnitNameInUseIgnoreSingleTables() throws SQLException {
-        when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(singleRule)));
-        DataNode dataNode = mock(DataNode.class);
-        when(dataNode.getDataSourceName()).thenReturn("foo_ds");
-        when(singleRule.getAllDataNodes()).thenReturn(Collections.singletonMap("", Collections.singleton(dataNode)));
-        StorageUnit storageUnit = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
-        when(storageUnit.getDataSource()).thenReturn(new MockedDataSource());
-        when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds", storageUnit));
-        when(database.getResourceMetaData()).thenReturn(resourceMetaData);
-        when(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db")).thenReturn(database);
-        UnregisterStorageUnitStatement unregisterStorageUnitStatement = new UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), true, false);
-        executor.setDatabase(database);
-        executor.executeUpdate(unregisterStorageUnitStatement, contextManager);
-        verify(modeContextManager).unregisterStorageUnits("foo_db", unregisterStorageUnitStatement.getStorageUnitNames());
+    void assertExecuteUpdateWithStorageUnitInUsedWithIgnoredTables() throws SQLException {
+        when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(new FixtureUnregisterStorageUnitRule())));
+        UnregisterStorageUnitStatement sqlStatement = new UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), true, false);
+        executor.executeUpdate(sqlStatement, contextManager);
+        verify(modeContextManager).unregisterStorageUnits("foo_db", sqlStatement.getStorageUnitNames());
     }
     
     @Test
-    void assertExecuteWithIfExists() throws SQLException {
-        UnregisterStorageUnitStatement unregisterStorageUnitStatement = new UnregisterStorageUnitStatement(true, Collections.singleton("foo_ds"), true, false);
-        executor.setDatabase(database);
-        executor.executeUpdate(unregisterStorageUnitStatement, contextManager);
-        verify(modeContextManager).unregisterStorageUnits("foo_db", unregisterStorageUnitStatement.getStorageUnitNames());
+    void assertExecuteUpdateWithIfExists() throws SQLException {
+        UnregisterStorageUnitStatement sqlStatement = new UnregisterStorageUnitStatement(true, Collections.singleton("foo_ds"), true, false);
+        executor.executeUpdate(sqlStatement, contextManager);
+        verify(modeContextManager).unregisterStorageUnits("foo_db", sqlStatement.getStorageUnitNames());
     }
     
     @Test
-    void assertExecuteUpdateWithStorageUnitNameInUseWithIfExists() {
-        when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(shadowRule)));
-        when(shadowRule.getDataSourceMapper()).thenReturn(Collections.singletonMap("", Collections.singleton("foo_ds")));
-        UnregisterStorageUnitStatement unregisterStorageUnitStatement = new UnregisterStorageUnitStatement(true, Collections.singleton("foo_ds"), true, false);
-        executor.setDatabase(database);
-        assertThrows(DistSQLException.class, () -> executor.executeUpdate(unregisterStorageUnitStatement, contextManager));
+    void assertExecuteUpdateWithStorageUnitInUsedWithIfExists() {
+        ShardingSphereRule rule = mock(ShardingSphereRule.class, withSettings().extraInterfaces(DataSourceContainedRule.class));
+        when(((DataSourceContainedRule) rule).getDataSourceMapper()).thenReturn(Collections.singletonMap("", Collections.singleton("foo_ds")));
+        when(database.getRuleMetaData()).thenReturn(new RuleMetaData(Collections.singleton(rule)));
+        assertThrows(DistSQLException.class, () -> executor.executeUpdate(new UnregisterStorageUnitStatement(true, Collections.singleton("foo_ds"), true, false), contextManager));
     }
 }
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/fixture/FixtureUnregisterStorageUnitRule.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/fixture/FixtureUnregisterStorageUnitRule.java
new file mode 100644
index 00000000000..4ec678db75e
--- /dev/null
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/fixture/FixtureUnregisterStorageUnitRule.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.resource.fixture;
+
+import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import org.apache.shardingsphere.infra.datanode.DataNode;
+import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
+import org.apache.shardingsphere.infra.rule.identifier.type.DataNodeContainedRule;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public final class FixtureUnregisterStorageUnitRule implements ShardingSphereRule, DataNodeContainedRule {
+    
+    @Override
+    public RuleConfiguration getConfiguration() {
+        return null;
+    }
+    
+    @Override
+    public Map<String, Collection<DataNode>> getAllDataNodes() {
+        DataNode dataNode = mock(DataNode.class);
+        when(dataNode.getDataSourceName()).thenReturn("foo_ds");
+        return Collections.singletonMap("", Collections.singleton(dataNode));
+    }
+    
+    @Override
+    public Collection<DataNode> getDataNodesByTableName(final String tableName) {
+        return null;
+    }
+    
+    @Override
+    public Optional<String> findFirstActualTable(final String logicTable) {
+        return Optional.empty();
+    }
+    
+    @Override
+    public boolean isNeedAccumulate(final Collection<String> tables) {
+        return false;
+    }
+    
+    @Override
+    public Optional<String> findLogicTableByActualTable(final String actualTable) {
+        return Optional.empty();
+    }
+    
+    @Override
+    public Optional<String> findActualTableByCatalog(final String catalog, final String logicTable) {
+        return Optional.empty();
+    }
+}
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/fixture/FixtureUnregisterStorageUnitRuleUsageChecker.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/fixture/FixtureUnregisterStorageUnitRuleUsageChecker.java
new file mode 100644
index 00000000000..c86f10c4b44
--- /dev/null
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/fixture/FixtureUnregisterStorageUnitRuleUsageChecker.java
@@ -0,0 +1,35 @@
+/*
+ * 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.proxy.backend.handler.distsql.rdl.resource.fixture;
+
+import org.apache.shardingsphere.distsql.handler.type.update.rdl.resource.UnregisterStorageUnitRuleUsageChecker;
+import org.apache.shardingsphere.distsql.statement.rdl.resource.unit.type.UnregisterStorageUnitStatement;
+import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
+
+public final class FixtureUnregisterStorageUnitRuleUsageChecker implements UnregisterStorageUnitRuleUsageChecker {
+    
+    @Override
+    public boolean isIgnored(final UnregisterStorageUnitStatement sqlStatement) {
+        return sqlStatement.isIgnoreSingleTables();
+    }
+    
+    @Override
+    public Class<? extends ShardingSphereRule> getRule() {
+        return FixtureUnregisterStorageUnitRule.class;
+    }
+}
diff --git a/proxy/backend/core/src/test/resources/META-INF/services/org.apache.shardingsphere.distsql.handler.type.update.rdl.resource.UnregisterStorageUnitRuleUsageChecker b/proxy/backend/core/src/test/resources/META-INF/services/org.apache.shardingsphere.distsql.handler.type.update.rdl.resource.UnregisterStorageUnitRuleUsageChecker
new file mode 100644
index 00000000000..757d77bbc12
--- /dev/null
+++ b/proxy/backend/core/src/test/resources/META-INF/services/org.apache.shardingsphere.distsql.handler.type.update.rdl.resource.UnregisterStorageUnitRuleUsageChecker
@@ -0,0 +1,18 @@
+#
+# 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.
+#
+
+org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.resource.fixture.FixtureUnregisterStorageUnitRuleUsageChecker