This is an automated email from the ASF dual-hosted git repository.
panjuan 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 e2c5ce5233a Refactor usage of ContextManager (#28215)
e2c5ce5233a is described below
commit e2c5ce5233a4a4c79c02975873cfd75e379143b1
Author: Liang Zhang <[email protected]>
AuthorDate: Tue Aug 22 21:57:08 2023 +0800
Refactor usage of ContextManager (#28215)
---
.../impl/jdbc/JDBCMetaDataInfoExporter.java | 2 +-
.../core/src/test/resources/logback-test.xml | 33 ++++
.../DriverDatabaseConnectionManager.java | 9 +-
.../core/datasource/ShardingSphereDataSource.java | 13 +-
.../batch/BatchPreparedStatementExecutorTest.java | 12 --
.../DriverDatabaseConnectionManagerTest.java | 17 +-
.../connection/ShardingSphereConnectionTest.java | 210 ++++++++++++---------
.../datasource/ShardingSphereDataSourceTest.java | 10 +-
.../ShardingSphereDatabaseMetaDataTest.java | 6 -
.../mode/manager/ContextManager.java | 10 +
.../mode/manager/ContextManagerTest.java | 2 +-
.../ral/updatable/RefreshTableMetaDataUpdater.java | 11 +-
.../unit/RegisterStorageUnitBackendHandler.java | 2 +-
.../updatable/RefreshTableMetaDataUpdaterTest.java | 9 +-
.../RegisterStorageUnitBackendHandlerTest.java | 2 +-
15 files changed, 203 insertions(+), 145 deletions(-)
diff --git
a/agent/plugins/metrics/core/src/main/java/org/apache/shardingsphere/agent/plugin/metrics/core/exporter/impl/jdbc/JDBCMetaDataInfoExporter.java
b/agent/plugins/metrics/core/src/main/java/org/apache/shardingsphere/agent/plugin/metrics/core/exporter/impl/jdbc/JDBCMetaDataInfoExporter.java
index 069b58353c0..957ed707294 100644
---
a/agent/plugins/metrics/core/src/main/java/org/apache/shardingsphere/agent/plugin/metrics/core/exporter/impl/jdbc/JDBCMetaDataInfoExporter.java
+++
b/agent/plugins/metrics/core/src/main/java/org/apache/shardingsphere/agent/plugin/metrics/core/exporter/impl/jdbc/JDBCMetaDataInfoExporter.java
@@ -59,7 +59,7 @@ public final class JDBCMetaDataInfoExporter implements
MetricsExporter {
ShardingSphereDataSource dataSource = (ShardingSphereDataSource)
entry.getValue();
String databaseName =
AgentReflectionUtils.getFieldValue(dataSource, "databaseName");
ContextManager contextManager =
AgentReflectionUtils.getFieldValue(dataSource, "contextManager");
- result.addMetric(Arrays.asList(databaseName,
"storage_unit_count"), contextManager.getDataSourceMap(databaseName).size());
+ result.addMetric(Arrays.asList(databaseName,
"storage_unit_count"), contextManager.getStorageUnits(databaseName).size());
}
return Optional.of(result);
}
diff --git a/agent/plugins/metrics/core/src/test/resources/logback-test.xml
b/agent/plugins/metrics/core/src/test/resources/logback-test.xml
new file mode 100644
index 00000000000..d90fc4a7156
--- /dev/null
+++ b/agent/plugins/metrics/core/src/test/resources/logback-test.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0"?>
+<!--
+ ~ 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.
+ -->
+
+<configuration>
+ <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
+ <encoder>
+ <pattern>[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread]
%logger{36} - %msg%n</pattern>
+ </encoder>
+ </appender>
+ <logger name="org.apache.shardingsphere" level="warn" additivity="false">
+ <appender-ref ref="console" />
+ </logger>
+
+ <root>
+ <level value="error" />
+ <appender-ref ref="console" />
+ </root>
+</configuration>
diff --git
a/jdbc/core/src/main/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManager.java
b/jdbc/core/src/main/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManager.java
index b8dba0cc885..52888a2611d 100644
---
a/jdbc/core/src/main/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManager.java
+++
b/jdbc/core/src/main/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManager.java
@@ -33,6 +33,7 @@ import
org.apache.shardingsphere.infra.executor.sql.prepare.driver.DatabaseConne
import org.apache.shardingsphere.infra.instance.metadata.InstanceMetaData;
import org.apache.shardingsphere.infra.instance.metadata.InstanceType;
import
org.apache.shardingsphere.infra.instance.metadata.proxy.ProxyInstanceMetaData;
+import
org.apache.shardingsphere.infra.metadata.database.resource.storage.StorageUnit;
import org.apache.shardingsphere.infra.metadata.user.ShardingSphereUser;
import org.apache.shardingsphere.infra.session.connection.ConnectionContext;
import
org.apache.shardingsphere.infra.session.connection.transaction.TransactionConnectionContext;
@@ -54,6 +55,7 @@ import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Optional;
import java.util.Random;
@@ -81,9 +83,12 @@ public final class DriverDatabaseConnectionManager
implements DatabaseConnection
private final ConnectionContext connectionContext;
public DriverDatabaseConnectionManager(final String databaseName, final
ContextManager contextManager) {
- dataSourceMap.putAll(contextManager.getDataSourceMap(databaseName));
+ for (Entry<String, StorageUnit> entry :
contextManager.getStorageUnits(databaseName).entrySet()) {
+ DataSource dataSource = entry.getValue().getDataSource();
+ dataSourceMap.put(entry.getKey(), dataSource);
+ physicalDataSourceMap.put(entry.getKey(), dataSource);
+ }
dataSourceMap.putAll(getTrafficDataSourceMap(databaseName,
contextManager));
-
physicalDataSourceMap.putAll(contextManager.getDataSourceMap(databaseName));
connectionTransaction = createConnectionTransaction(databaseName,
contextManager);
connectionContext = new ConnectionContext(cachedConnections::keySet);
}
diff --git
a/jdbc/core/src/main/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSource.java
b/jdbc/core/src/main/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSource.java
index 3257becc8d5..3cd1eef41b7 100644
---
a/jdbc/core/src/main/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSource.java
+++
b/jdbc/core/src/main/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSource.java
@@ -26,6 +26,7 @@ import
org.apache.shardingsphere.infra.config.rule.scope.GlobalRuleConfiguration
import org.apache.shardingsphere.infra.instance.metadata.InstanceMetaData;
import
org.apache.shardingsphere.infra.instance.metadata.InstanceMetaDataBuilder;
import org.apache.shardingsphere.infra.instance.metadata.InstanceType;
+import
org.apache.shardingsphere.infra.metadata.database.resource.storage.StorageUnit;
import org.apache.shardingsphere.infra.spi.ShardingSphereServiceLoader;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.mode.manager.ContextManager;
@@ -101,8 +102,8 @@ public final class ShardingSphereDataSource extends
AbstractDataSourceAdapter im
@Override
public void close() throws SQLException {
contextManagerDestroyedCallback(databaseName);
- for (DataSource each :
contextManager.getDataSourceMap(databaseName).values()) {
- close(each);
+ for (StorageUnit each :
contextManager.getStorageUnits(databaseName).values()) {
+ close(each.getDataSource());
}
contextManager.close();
}
@@ -132,14 +133,14 @@ public final class ShardingSphereDataSource extends
AbstractDataSourceAdapter im
@Override
public int getLoginTimeout() throws SQLException {
- Map<String, DataSource> dataSourceMap =
contextManager.getDataSourceMap(databaseName);
- return dataSourceMap.isEmpty() ? 0 :
dataSourceMap.values().iterator().next().getLoginTimeout();
+ Map<String, StorageUnit> storageUnits =
contextManager.getStorageUnits(databaseName);
+ return storageUnits.isEmpty() ? 0 :
storageUnits.values().iterator().next().getDataSource().getLoginTimeout();
}
@Override
public void setLoginTimeout(final int seconds) throws SQLException {
- for (DataSource each :
contextManager.getDataSourceMap(databaseName).values()) {
- each.setLoginTimeout(seconds);
+ for (StorageUnit each :
contextManager.getStorageUnits(databaseName).values()) {
+ each.getDataSource().setLoginTimeout(seconds);
}
}
}
diff --git
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/executor/batch/BatchPreparedStatementExecutorTest.java
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/executor/batch/BatchPreparedStatementExecutorTest.java
index 91d514857ae..4434dcacd93 100644
---
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/executor/batch/BatchPreparedStatementExecutorTest.java
+++
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/executor/batch/BatchPreparedStatementExecutorTest.java
@@ -50,16 +50,13 @@ import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
-import javax.sql.DataSource;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
-import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
-import java.util.Map;
import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
@@ -97,7 +94,6 @@ class BatchPreparedStatementExecutorTest {
ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
MetaDataContexts metaDataContexts = mockMetaDataContexts();
when(result.getMetaDataContexts()).thenReturn(metaDataContexts);
-
when(result.getDataSourceMap("foo_db")).thenReturn(mockDataSourceMap());
return result;
}
@@ -120,14 +116,6 @@ class BatchPreparedStatementExecutorTest {
return result;
}
- private Map<String, DataSource> mockDataSourceMap() {
- Map<String, DataSource> result = new LinkedHashMap<>(2, 1F);
- DataSource dataSource = mock(DataSource.class, RETURNS_DEEP_STUBS);
- result.put("ds_0", dataSource);
- result.put("ds_1", dataSource);
- return result;
- }
-
@AfterEach
void tearDown() {
executorEngine.close();
diff --git
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManagerTest.java
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManagerTest.java
index ae72690f776..893c6c4067c 100644
---
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManagerTest.java
+++
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManagerTest.java
@@ -24,6 +24,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePo
import
org.apache.shardingsphere.infra.executor.sql.execute.engine.ConnectionMode;
import org.apache.shardingsphere.infra.instance.metadata.InstanceType;
import
org.apache.shardingsphere.infra.instance.metadata.proxy.ProxyInstanceMetaData;
+import
org.apache.shardingsphere.infra.metadata.database.resource.storage.StorageUnit;
import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
import org.apache.shardingsphere.infra.metadata.user.ShardingSphereUser;
import org.apache.shardingsphere.metadata.persist.MetaDataPersistService;
@@ -74,8 +75,8 @@ class DriverDatabaseConnectionManagerTest {
private ContextManager mockContextManager() throws SQLException {
ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
- Map<String, DataSource> dataSourceMap = mockDataSourceMap();
-
when(result.getDataSourceMap(DefaultDatabase.LOGIC_NAME)).thenReturn(dataSourceMap);
+ Map<String, StorageUnit> storageUnits = mockStorageUnits();
+
when(result.getStorageUnits(DefaultDatabase.LOGIC_NAME)).thenReturn(storageUnits);
MetaDataPersistService persistService = mockMetaDataPersistService();
when(result.getMetaDataContexts().getPersistService()).thenReturn(persistService);
when(result.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(
@@ -87,12 +88,16 @@ class DriverDatabaseConnectionManagerTest {
return result;
}
- private Map<String, DataSource> mockDataSourceMap() throws SQLException {
- Map<String, DataSource> result = new HashMap<>(2, 1F);
- result.put("ds", new MockedDataSource());
+ private Map<String, StorageUnit> mockStorageUnits() throws SQLException {
+ Map<String, StorageUnit> result = new HashMap<>(2, 1F);
+ StorageUnit validStorageUnit = mock(StorageUnit.class);
+ when(validStorageUnit.getDataSource()).thenReturn(new
MockedDataSource());
+ result.put("ds", validStorageUnit);
+ StorageUnit invalidStorageUnit = mock(StorageUnit.class);
DataSource invalidDataSource = mock(DataSource.class);
when(invalidDataSource.getConnection()).thenThrow(new SQLException());
- result.put("invalid_ds", invalidDataSource);
+ when(invalidStorageUnit.getDataSource()).thenReturn(invalidDataSource);
+ result.put("invalid_ds", invalidStorageUnit);
return result;
}
diff --git
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/ShardingSphereConnectionTest.java
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/ShardingSphereConnectionTest.java
index 2ef4191b237..b8fb0254e17 100644
---
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/ShardingSphereConnectionTest.java
+++
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/ShardingSphereConnectionTest.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.driver.jdbc.core.connection;
import lombok.SneakyThrows;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
import
org.apache.shardingsphere.infra.executor.sql.execute.engine.ConnectionMode;
+import
org.apache.shardingsphere.infra.metadata.database.resource.storage.StorageUnit;
import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
import org.apache.shardingsphere.infra.session.connection.ConnectionContext;
import org.apache.shardingsphere.mode.manager.ContextManager;
@@ -29,12 +30,9 @@ import
org.apache.shardingsphere.transaction.ConnectionTransaction.DistributedTr
import org.apache.shardingsphere.transaction.api.TransactionType;
import
org.apache.shardingsphere.transaction.config.TransactionRuleConfiguration;
import org.apache.shardingsphere.transaction.rule.TransactionRule;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.internal.configuration.plugins.Plugins;
-import javax.sql.DataSource;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.SQLException;
@@ -54,52 +52,33 @@ import static org.mockito.Mockito.when;
class ShardingSphereConnectionTest {
- private ShardingSphereConnection connection;
-
- @BeforeEach
- void setUp() {
- connection = new ShardingSphereConnection(DefaultDatabase.LOGIC_NAME,
mockContextManager());
- }
-
- private ContextManager mockContextManager() {
- ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
-
when(result.getDataSourceMap(DefaultDatabase.LOGIC_NAME)).thenReturn(Collections.singletonMap("ds",
mock(DataSource.class, RETURNS_DEEP_STUBS)));
-
when(result.getMetaDataContexts().getMetaData().getGlobalRuleMetaData())
- .thenReturn(new
RuleMetaData(Arrays.asList(mockTransactionRule(), mock(TrafficRule.class))));
- return result;
- }
-
- private TransactionRule mockTransactionRule() {
- return new TransactionRule(new
TransactionRuleConfiguration(TransactionType.LOCAL.name(), "", new
Properties()), Collections.emptyMap());
- }
-
- @AfterEach
- void clear() {
- try {
- connection.close();
- } catch (final SQLException ignored) {
- }
- }
-
@Test
void assertIsHoldTransaction() throws SQLException {
- connection.setAutoCommit(false);
- assertTrue(connection.isHoldTransaction());
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ connection.setAutoCommit(false);
+ assertTrue(connection.isHoldTransaction());
+ }
}
@Test
void assertIsNotHoldTransaction() throws SQLException {
- connection.setAutoCommit(true);
- assertFalse(connection.isHoldTransaction());
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ connection.setAutoCommit(true);
+ assertFalse(connection.isHoldTransaction());
+ }
+
}
@Test
void assertSetAutoCommitWithLocalTransaction() throws SQLException {
Connection physicalConnection = mock(Connection.class);
-
when(connection.getContextManager().getDataSourceMap(DefaultDatabase.LOGIC_NAME).get("ds").getConnection()).thenReturn(physicalConnection);
- connection.getDatabaseConnectionManager().getConnections("ds", 0, 1,
ConnectionMode.MEMORY_STRICTLY);
- connection.setAutoCommit(true);
- assertTrue(connection.getAutoCommit());
+ StorageUnit storageUnit = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
+
when(storageUnit.getDataSource().getConnection()).thenReturn(physicalConnection);
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME,
mockContextManager(storageUnit))) {
+ connection.getDatabaseConnectionManager().getConnections("ds", 0,
1, ConnectionMode.MEMORY_STRICTLY);
+ connection.setAutoCommit(true);
+ assertTrue(connection.getAutoCommit());
+ }
verify(physicalConnection).setAutoCommit(true);
}
@@ -108,24 +87,29 @@ class ShardingSphereConnectionTest {
ConnectionTransaction connectionTransaction =
mock(ConnectionTransaction.class);
when(connectionTransaction.getDistributedTransactionOperationType(true)).thenReturn(DistributedTransactionOperationType.COMMIT);
when(connectionTransaction.getTransactionType()).thenReturn(TransactionType.XA);
- mockConnectionManager(connectionTransaction);
- connection.setAutoCommit(true);
- assertTrue(connection.getAutoCommit());
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ mockConnectionManager(connection, connectionTransaction);
+ connection.setAutoCommit(true);
+ assertTrue(connection.getAutoCommit());
+ }
verify(connectionTransaction).commit();
}
@Test
void assertCommitWithLocalTransaction() throws SQLException {
Connection physicalConnection = mock(Connection.class);
-
when(connection.getContextManager().getDataSourceMap(DefaultDatabase.LOGIC_NAME).get("ds").getConnection()).thenReturn(physicalConnection);
- connection.getDatabaseConnectionManager().getConnections("ds", 0, 1,
ConnectionMode.MEMORY_STRICTLY);
- connection.setAutoCommit(false);
- assertFalse(connection.getAutoCommit());
-
assertTrue(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
- verify(physicalConnection).setAutoCommit(false);
- connection.commit();
-
assertFalse(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
- verify(physicalConnection).commit();
+ StorageUnit storageUnit = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
+
when(storageUnit.getDataSource().getConnection()).thenReturn(physicalConnection);
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME,
mockContextManager(storageUnit))) {
+ connection.getDatabaseConnectionManager().getConnections("ds", 0,
1, ConnectionMode.MEMORY_STRICTLY);
+ connection.setAutoCommit(false);
+ assertFalse(connection.getAutoCommit());
+
assertTrue(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
+ verify(physicalConnection).setAutoCommit(false);
+ connection.commit();
+
assertFalse(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
+ verify(physicalConnection).commit();
+ }
}
@Test
@@ -133,25 +117,30 @@ class ShardingSphereConnectionTest {
ConnectionTransaction connectionTransaction =
mock(ConnectionTransaction.class);
when(connectionTransaction.getDistributedTransactionOperationType(false)).thenReturn(DistributedTransactionOperationType.BEGIN);
when(connectionTransaction.getTransactionType()).thenReturn(TransactionType.XA);
- DriverDatabaseConnectionManager databaseConnectionManager =
mockConnectionManager(connectionTransaction);
- connection.setAutoCommit(false);
-
assertTrue(databaseConnectionManager.getConnectionContext().getTransactionContext().isInTransaction());
- assertFalse(connection.getAutoCommit());
-
assertTrue(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
- verify(connectionTransaction).begin();
- connection.commit();
-
assertFalse(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
- verify(databaseConnectionManager).commit();
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ DriverDatabaseConnectionManager databaseConnectionManager =
mockConnectionManager(connection, connectionTransaction);
+ connection.setAutoCommit(false);
+
assertTrue(databaseConnectionManager.getConnectionContext().getTransactionContext().isInTransaction());
+ assertFalse(connection.getAutoCommit());
+
assertTrue(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
+ verify(connectionTransaction).begin();
+ connection.commit();
+
assertFalse(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
+ verify(databaseConnectionManager).commit();
+ }
}
@Test
void assertRollbackWithLocalTransaction() throws SQLException {
Connection physicalConnection = mock(Connection.class);
-
when(connection.getContextManager().getDataSourceMap(DefaultDatabase.LOGIC_NAME).get("ds").getConnection()).thenReturn(physicalConnection);
- connection.getDatabaseConnectionManager().getConnections("ds", 0, 1,
ConnectionMode.MEMORY_STRICTLY);
- connection.setAutoCommit(false);
- assertFalse(connection.getAutoCommit());
- connection.rollback();
+ StorageUnit storageUnit = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
+
when(storageUnit.getDataSource().getConnection()).thenReturn(physicalConnection);
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME,
mockContextManager(storageUnit))) {
+ connection.getDatabaseConnectionManager().getConnections("ds", 0,
1, ConnectionMode.MEMORY_STRICTLY);
+ connection.setAutoCommit(false);
+ assertFalse(connection.getAutoCommit());
+ connection.rollback();
+ }
verify(physicalConnection).rollback();
}
@@ -160,18 +149,20 @@ class ShardingSphereConnectionTest {
ConnectionTransaction connectionTransaction =
mock(ConnectionTransaction.class);
when(connectionTransaction.getDistributedTransactionOperationType(false)).thenReturn(DistributedTransactionOperationType.BEGIN);
when(connectionTransaction.getTransactionType()).thenReturn(TransactionType.XA);
- final DriverDatabaseConnectionManager databaseConnectionManager =
mockConnectionManager(connectionTransaction);
- connection.setAutoCommit(false);
- assertFalse(connection.getAutoCommit());
-
assertTrue(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
- verify(connectionTransaction).begin();
- connection.rollback();
-
assertFalse(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
- verify(databaseConnectionManager).rollback();
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ final DriverDatabaseConnectionManager databaseConnectionManager =
mockConnectionManager(connection, connectionTransaction);
+ connection.setAutoCommit(false);
+ assertFalse(connection.getAutoCommit());
+
assertTrue(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
+ verify(connectionTransaction).begin();
+ connection.rollback();
+
assertFalse(connection.getDatabaseConnectionManager().getConnectionContext().getTransactionContext().isInTransaction());
+ verify(databaseConnectionManager).rollback();
+ }
}
@SneakyThrows(ReflectiveOperationException.class)
- private DriverDatabaseConnectionManager mockConnectionManager(final
ConnectionTransaction connectionTransaction) {
+ private DriverDatabaseConnectionManager mockConnectionManager(final
ShardingSphereConnection connection, final ConnectionTransaction
connectionTransaction) {
DriverDatabaseConnectionManager result =
mock(DriverDatabaseConnectionManager.class);
when(result.getConnectionTransaction()).thenReturn(connectionTransaction);
when(result.getConnectionContext()).thenReturn(new
ConnectionContext());
@@ -181,42 +172,56 @@ class ShardingSphereConnectionTest {
@Test
void assertIsValidWhenEmptyConnection() throws SQLException {
- assertTrue(connection.isValid(0));
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ assertTrue(connection.isValid(0));
+ }
}
@Test
void assertIsInvalid() throws SQLException {
- connection.getDatabaseConnectionManager().getConnections("ds", 0, 1,
ConnectionMode.MEMORY_STRICTLY);
- assertFalse(connection.isValid(0));
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ connection.getDatabaseConnectionManager().getConnections("ds", 0,
1, ConnectionMode.MEMORY_STRICTLY);
+ assertFalse(connection.isValid(0));
+ }
}
@Test
void assertSetReadOnly() throws SQLException {
- assertFalse(connection.isReadOnly());
- Connection physicalConnection =
connection.getDatabaseConnectionManager().getConnections("ds", 0, 1,
ConnectionMode.MEMORY_STRICTLY).get(0);
- connection.setReadOnly(true);
- assertTrue(connection.isReadOnly());
- verify(physicalConnection).setReadOnly(true);
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ assertFalse(connection.isReadOnly());
+ Connection physicalConnection =
connection.getDatabaseConnectionManager().getConnections("ds", 0, 1,
ConnectionMode.MEMORY_STRICTLY).get(0);
+ connection.setReadOnly(true);
+ assertTrue(connection.isReadOnly());
+ verify(physicalConnection).setReadOnly(true);
+ }
}
@Test
void assertGetTransactionIsolationWithoutCachedConnections() throws
SQLException {
- assertThat(connection.getTransactionIsolation(),
is(Connection.TRANSACTION_READ_UNCOMMITTED));
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ assertThat(connection.getTransactionIsolation(),
is(Connection.TRANSACTION_READ_UNCOMMITTED));
+ }
+
}
@Test
void assertSetTransactionIsolation() throws SQLException {
- Connection physicalConnection =
connection.getDatabaseConnectionManager().getConnections("ds", 0, 1,
ConnectionMode.MEMORY_STRICTLY).get(0);
-
connection.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
-
verify(physicalConnection).setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ Connection physicalConnection =
connection.getDatabaseConnectionManager().getConnections("ds", 0, 1,
ConnectionMode.MEMORY_STRICTLY).get(0);
+
connection.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
+
verify(physicalConnection).setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
+ }
}
@Test
void assertCreateArrayOf() throws SQLException {
Connection physicalConnection = mock(Connection.class);
-
when(connection.getContextManager().getDataSourceMap(DefaultDatabase.LOGIC_NAME).get("ds").getConnection()).thenReturn(physicalConnection);
- connection.getDatabaseConnectionManager().getConnections("ds", 0, 1,
ConnectionMode.MEMORY_STRICTLY);
- assertNull(connection.createArrayOf("int", null));
+ StorageUnit storageUnit = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
+
when(storageUnit.getDataSource().getConnection()).thenReturn(physicalConnection);
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME,
mockContextManager(storageUnit))) {
+ connection.getDatabaseConnectionManager().getConnections("ds", 0,
1, ConnectionMode.MEMORY_STRICTLY);
+ assertNull(connection.createArrayOf("int", null));
+ }
verify(physicalConnection).createArrayOf("int", null);
}
@@ -225,14 +230,33 @@ class ShardingSphereConnectionTest {
CallableStatement expected = mock(CallableStatement.class);
Connection physicalConnection = mock(Connection.class);
when(physicalConnection.prepareCall("")).thenReturn(expected);
-
when(connection.getContextManager().getDataSourceMap(DefaultDatabase.LOGIC_NAME).get("ds").getConnection()).thenReturn(physicalConnection);
- CallableStatement actual = connection.prepareCall("");
- assertThat(actual, is(expected));
+ StorageUnit storageUnit = mock(StorageUnit.class, RETURNS_DEEP_STUBS);
+
when(storageUnit.getDataSource().getConnection()).thenReturn(physicalConnection);
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME,
mockContextManager(storageUnit))) {
+ assertThat(connection.prepareCall(""), is(expected));
+ }
}
@Test
void assertClose() throws SQLException {
- connection.close();
- assertTrue(connection.isClosed());
+ try (ShardingSphereConnection connection = new
ShardingSphereConnection(DefaultDatabase.LOGIC_NAME, mockContextManager())) {
+ connection.close();
+ assertTrue(connection.isClosed());
+ }
+ }
+
+ private ContextManager mockContextManager() {
+ return mockContextManager(mock(StorageUnit.class, RETURNS_DEEP_STUBS));
+ }
+
+ private ContextManager mockContextManager(final StorageUnit storageUnit) {
+ ContextManager result = mock(ContextManager.class, RETURNS_DEEP_STUBS);
+
when(result.getStorageUnits(DefaultDatabase.LOGIC_NAME)).thenReturn(Collections.singletonMap("ds",
storageUnit));
+
when(result.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(new
RuleMetaData(Arrays.asList(mockTransactionRule(), mock(TrafficRule.class))));
+ return result;
+ }
+
+ private TransactionRule mockTransactionRule() {
+ return new TransactionRule(new
TransactionRuleConfiguration(TransactionType.LOCAL.name(), "", new
Properties()), Collections.emptyMap());
}
}
diff --git
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSourceTest.java
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSourceTest.java
index 71387956c18..380119975e8 100644
---
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSourceTest.java
+++
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSourceTest.java
@@ -59,7 +59,7 @@ class ShardingSphereDataSourceTest {
assertNotNull(contextManager.getMetaDataContexts().getMetaData().getDatabase(DefaultDatabase.LOGIC_NAME));
assertThat(contextManager.getClusterStateContext().getCurrentState(),
is(ClusterState.OK));
assertThat(contextManager.getInstanceContext().getInstance().getState().getCurrentState(),
is(InstanceState.OK));
-
assertTrue(contextManager.getDataSourceMap(DefaultDatabase.LOGIC_NAME).isEmpty());
+
assertTrue(contextManager.getStorageUnits(DefaultDatabase.LOGIC_NAME).isEmpty());
}
}
@@ -72,8 +72,8 @@ class ShardingSphereDataSourceTest {
assertNotNull(contextManager.getMetaDataContexts().getMetaData().getDatabase(DefaultDatabase.LOGIC_NAME));
assertThat(contextManager.getClusterStateContext().getCurrentState(),
is(ClusterState.OK));
assertThat(contextManager.getInstanceContext().getInstance().getState().getCurrentState(),
is(InstanceState.OK));
-
assertThat(contextManager.getDataSourceMap(DefaultDatabase.LOGIC_NAME).size(),
is(1));
-
assertThat(contextManager.getDataSourceMap(DefaultDatabase.LOGIC_NAME).get("ds").getConnection().getMetaData().getURL(),
is("jdbc:mock://127.0.0.1/foo_ds"));
+
assertThat(contextManager.getStorageUnits(DefaultDatabase.LOGIC_NAME).size(),
is(1));
+
assertThat(contextManager.getStorageUnits(DefaultDatabase.LOGIC_NAME).get("ds").getDataSource().getConnection().getMetaData().getURL(),
is("jdbc:mock://127.0.0.1/foo_ds"));
}
}
@@ -106,7 +106,7 @@ class ShardingSphereDataSourceTest {
@Test
void assertEmptyDataSourceMap() throws Exception {
try (ShardingSphereDataSource actual = new
ShardingSphereDataSource(DefaultDatabase.LOGIC_NAME, null)) {
-
assertTrue(getContextManager(actual).getDataSourceMap(DefaultDatabase.LOGIC_NAME).isEmpty());
+
assertTrue(getContextManager(actual).getStorageUnits(DefaultDatabase.LOGIC_NAME).isEmpty());
assertThat(actual.getLoginTimeout(), is(0));
}
}
@@ -114,7 +114,7 @@ class ShardingSphereDataSourceTest {
@Test
void assertNotEmptyDataSourceMap() throws Exception {
try (ShardingSphereDataSource actual =
createShardingSphereDataSource(createHikariDataSource())) {
-
assertThat(getContextManager(actual).getDataSourceMap(DefaultDatabase.LOGIC_NAME).size(),
is(1));
+
assertThat(getContextManager(actual).getStorageUnits(DefaultDatabase.LOGIC_NAME).size(),
is(1));
assertThat(actual.getLoginTimeout(), is(15));
}
}
diff --git
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/metadata/ShardingSphereDatabaseMetaDataTest.java
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/metadata/ShardingSphereDatabaseMetaDataTest.java
index 13c319343e8..8309a103d9e 100644
---
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/metadata/ShardingSphereDatabaseMetaDataTest.java
+++
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/metadata/ShardingSphereDatabaseMetaDataTest.java
@@ -43,8 +43,6 @@ import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
@@ -80,20 +78,16 @@ class ShardingSphereDatabaseMetaDataTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private MetaDataContexts metaDataContexts;
- private final Map<String, DataSource> dataSourceMap = new HashMap<>();
-
private ShardingSphereDatabaseMetaData shardingSphereDatabaseMetaData;
@BeforeEach
void setUp() throws SQLException {
- dataSourceMap.put(DATA_SOURCE_NAME, dataSource);
when(dataSource.getConnection()).thenReturn(connection);
when(connection.getMetaData()).thenReturn(databaseMetaData);
when(resultSet.getMetaData()).thenReturn(mock(ResultSetMetaData.class));
when(shardingSphereConnection.getDatabaseConnectionManager().getRandomPhysicalDataSourceName()).thenReturn(DATA_SOURCE_NAME);
when(shardingSphereConnection.getDatabaseConnectionManager().getRandomConnection()).thenReturn(connection);
when(shardingSphereConnection.getContextManager().getMetaDataContexts()).thenReturn(metaDataContexts);
-
when(shardingSphereConnection.getContextManager().getDataSourceMap(DefaultDatabase.LOGIC_NAME)).thenReturn(dataSourceMap);
when(shardingSphereConnection.getDatabaseName()).thenReturn(DefaultDatabase.LOGIC_NAME);
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
when(metaDataContexts.getMetaData().getDatabase(shardingSphereConnection.getDatabaseName())).thenReturn(database);
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
index 6be5893c1ca..28c07889387 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
@@ -109,6 +109,16 @@ public final class ContextManager implements AutoCloseable
{
return
metaDataContexts.get().getMetaData().getDatabase(databaseName).getResourceMetaData().getStorageUnitMetaData().getDataSources();
}
+ /**
+ * Get storage units.
+ *
+ * @param databaseName database name
+ * @return storage units
+ */
+ public Map<String, StorageUnit> getStorageUnits(final String databaseName)
{
+ return
metaDataContexts.get().getMetaData().getDatabase(databaseName).getResourceMetaData().getStorageUnitMetaData().getStorageUnits();
+ }
+
/**
* Reload database meta data from governance center.
*
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
index f78db7fc528..f1ef8afd9b1 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
@@ -116,7 +116,7 @@ class ContextManagerTest {
ShardingSphereDatabase database =
new ShardingSphereDatabase(DefaultDatabase.LOGIC_NAME,
mock(DatabaseType.class), resourceMetaData, mock(RuleMetaData.class),
Collections.emptyMap());
when(metaDataContexts.getMetaData().getDatabase(DefaultDatabase.LOGIC_NAME)).thenReturn(database);
-
assertThat(contextManager.getDataSourceMap(DefaultDatabase.LOGIC_NAME).size(),
is(1));
+
assertThat(contextManager.getStorageUnits(DefaultDatabase.LOGIC_NAME).size(),
is(1));
}
@Test
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdater.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdater.java
index 3815015988e..22f72c543a1 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdater.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdater.java
@@ -25,12 +25,12 @@ import
org.apache.shardingsphere.infra.database.core.type.DatabaseTypeRegistry;
import
org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.NoDatabaseSelectedException;
import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.UnknownDatabaseException;
+import
org.apache.shardingsphere.infra.metadata.database.resource.storage.StorageUnit;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import
org.apache.shardingsphere.proxy.backend.handler.distsql.ral.updatable.updater.ConnectionSessionRequiredRALUpdater;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
-import javax.sql.DataSource;
import java.util.Collections;
import java.util.Map;
@@ -43,7 +43,7 @@ public final class RefreshTableMetaDataUpdater implements
ConnectionSessionRequi
public void executeUpdate(final ConnectionSession connectionSession, final
RefreshTableMetaDataStatement sqlStatement) {
String databaseName = getDatabaseName(connectionSession);
ContextManager contextManager =
ProxyContext.getInstance().getContextManager();
- checkDataSources(databaseName,
contextManager.getDataSourceMap(databaseName), sqlStatement);
+ checkStorageUnits(databaseName,
contextManager.getStorageUnits(databaseName), sqlStatement);
String schemaName = getSchemaName(databaseName, sqlStatement,
connectionSession);
if (sqlStatement.getStorageUnitName().isPresent()) {
if (sqlStatement.getTableName().isPresent()) {
@@ -60,11 +60,12 @@ public final class RefreshTableMetaDataUpdater implements
ConnectionSessionRequi
}
}
- private void checkDataSources(final String databaseName, final Map<String,
DataSource> dataSources, final RefreshTableMetaDataStatement sqlStatement) {
- ShardingSpherePreconditions.checkState(!dataSources.isEmpty(), () ->
new EmptyStorageUnitException(databaseName));
+ private void checkStorageUnits(final String databaseName, final
Map<String, StorageUnit> storageUnits, final RefreshTableMetaDataStatement
sqlStatement) {
+ ShardingSpherePreconditions.checkState(!storageUnits.isEmpty(), () ->
new EmptyStorageUnitException(databaseName));
if (sqlStatement.getStorageUnitName().isPresent()) {
String storageUnitName = sqlStatement.getStorageUnitName().get();
-
ShardingSpherePreconditions.checkState(dataSources.containsKey(storageUnitName),
() -> new MissingRequiredStorageUnitsException(databaseName,
Collections.singletonList(storageUnitName)));
+ ShardingSpherePreconditions.checkState(
+ storageUnits.containsKey(storageUnitName), () -> new
MissingRequiredStorageUnitsException(databaseName,
Collections.singletonList(storageUnitName)));
}
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandler.java
index b89c09d950a..6aade316f1e 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandler.java
@@ -112,7 +112,7 @@ public final class RegisterStorageUnitBackendHandler
extends StorageUnitDefiniti
}
private Collection<String> getCurrentStorageUnitNames(final String
databaseName) {
- return
ProxyContext.getInstance().getContextManager().getDataSourceMap(databaseName).keySet();
+ return
ProxyContext.getInstance().getContextManager().getStorageUnits(databaseName).keySet();
}
private Collection<String> getLogicalDataSourceNames(final String
databaseName) {
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdaterTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdaterTest.java
index 9e0c5f01d4a..0e0866a33f3 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdaterTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/RefreshTableMetaDataUpdaterTest.java
@@ -17,12 +17,12 @@
package org.apache.shardingsphere.proxy.backend.handler.distsql.ral.updatable;
-import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.NoDatabaseSelectedException;
-import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.UnknownDatabaseException;
import
org.apache.shardingsphere.distsql.handler.exception.storageunit.EmptyStorageUnitException;
import
org.apache.shardingsphere.distsql.handler.exception.storageunit.MissingRequiredStorageUnitsException;
import
org.apache.shardingsphere.distsql.parser.statement.ral.updatable.RefreshTableMetaDataStatement;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
+import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.NoDatabaseSelectedException;
+import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.UnknownDatabaseException;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
@@ -30,7 +30,6 @@ import
org.apache.shardingsphere.proxy.backend.handler.distsql.ral.UpdatableRALB
import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
import
org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
-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.Test;
@@ -70,7 +69,7 @@ class RefreshTableMetaDataUpdaterTest {
@Test
void assertEmptyResource() {
ContextManager contextManager = mock(ContextManager.class,
RETURNS_DEEP_STUBS);
-
when(contextManager.getDataSourceMap("foo_db")).thenReturn(Collections.emptyMap());
+
when(contextManager.getStorageUnits("foo_db")).thenReturn(Collections.emptyMap());
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
when(ProxyContext.getInstance().databaseExists("foo_db")).thenReturn(true);
UpdatableRALBackendHandler<?> backendHandler = new
UpdatableRALBackendHandler<>(new RefreshTableMetaDataStatement(),
mockConnectionSession("foo_db"));
@@ -80,7 +79,6 @@ class RefreshTableMetaDataUpdaterTest {
@Test
void assertMissingRequiredResources() {
ContextManager contextManager = mock(ContextManager.class,
RETURNS_DEEP_STUBS);
-
when(contextManager.getDataSourceMap("foo_db")).thenReturn(Collections.singletonMap("ds_0",
new MockedDataSource()));
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
when(ProxyContext.getInstance().databaseExists("foo_db")).thenReturn(true);
UpdatableRALBackendHandler<?> backendHandler = new
UpdatableRALBackendHandler<>(new RefreshTableMetaDataStatement("t_order",
"ds_1", null), mockConnectionSession("foo_db"));
@@ -90,7 +88,6 @@ class RefreshTableMetaDataUpdaterTest {
@Test
void assertUpdate() throws SQLException {
ContextManager contextManager = mock(ContextManager.class,
RETURNS_DEEP_STUBS);
-
when(contextManager.getDataSourceMap("foo_db")).thenReturn(Collections.singletonMap("ds_0",
new MockedDataSource()));
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
when(ProxyContext.getInstance().databaseExists("foo_db")).thenReturn(true);
UpdatableRALBackendHandler<?> backendHandler = new
UpdatableRALBackendHandler<>(new RefreshTableMetaDataStatement(),
mockConnectionSession("foo_db"));
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandlerTest.java
index d4e12d5c851..1fb0d6d2837 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandlerTest.java
@@ -97,7 +97,7 @@ class RegisterStorageUnitBackendHandlerTest {
@Test
void assertExecuteWithDuplicateStorageUnitNamesWithResourceMetaData() {
ContextManager contextManager = mock(ContextManager.class,
RETURNS_DEEP_STUBS);
-
when(contextManager.getDataSourceMap("foo_db").keySet()).thenReturn(Collections.singleton("ds_0"));
+
when(contextManager.getStorageUnits("foo_db").keySet()).thenReturn(Collections.singleton("ds_0"));
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
assertThrows(DuplicateStorageUnitException.class, () ->
handler.execute("foo_db", createRegisterStorageUnitStatement()));
}
