(shardingsphere) branch master updated: Add SQLStatementCompilerEngineFactoryTest (#37325)

[zh...@apache.org]

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

zhangliang 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 0c4c7199046 Add SQLStatementCompilerEngineFactoryTest (#37325)
0c4c7199046 is described below

commit 0c4c7199046f29bb4262a986bf09a0ca8fa82926
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Wed Dec 10 15:05:57 2025 +0800

    Add SQLStatementCompilerEngineFactoryTest (#37325)
    
    * Add SQLStatementCompilerEngineFactoryTest
    
    * Add CalciteSchemaBuilderTest
---
 .../context/schema/CalciteSchemaBuilder.java       |  3 +-
 .../SQLStatementCompilerEngineFactoryTest.java     | 65 ++++++++++++++
 .../compiler/context/CalciteSchemaBuilderTest.java | 98 ++++++++++++++++++++++
 3 files changed, 164 insertions(+), 2 deletions(-)

diff --git a/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/context/schema/CalciteSchemaBuilder.java b/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/context/schema/CalciteSchemaBuilder.java
index 83ebc1884d6..3f0d9678005 100644
--- a/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/context/schema/CalciteSchemaBuilder.java
+++ b/kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/context/schema/CalciteSchemaBuilder.java
@@ -95,8 +95,7 @@ public final class CalciteSchemaBuilder {
     
     private static void registerNestedSchemaFunction(final CalciteSchema calciteSchema, final DatabaseType databaseType) {
         for (CalciteSchema each : calciteSchema.getSubSchemaMap().values()) {
-            Collection<CalciteSchema> subSchemas = each.subSchemas().getNames(LikePattern.any()).stream().map(schemaName -> each.subSchemas().get(schemaName)).collect(Collectors.toList());
-            registerFunction(subSchemas, databaseType);
+            registerFunction(each.subSchemas().getNames(LikePattern.any()).stream().map(schemaName -> each.subSchemas().get(schemaName)).collect(Collectors.toList()), databaseType);
         }
     }
 }
diff --git a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/compiler/SQLStatementCompilerEngineFactoryTest.java b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/compiler/SQLStatementCompilerEngineFactoryTest.java
new file mode 100644
index 00000000000..e61e6a4167c
--- /dev/null
+++ b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/compiler/SQLStatementCompilerEngineFactoryTest.java
@@ -0,0 +1,65 @@
+/*
+ * 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.sqlfederation.compiler.compiler;
+
+import com.github.benmanes.caffeine.cache.LoadingCache;
+import com.github.benmanes.caffeine.cache.Policy;
+import com.github.benmanes.caffeine.cache.Policy.Eviction;
+import org.apache.shardingsphere.sqlfederation.compiler.SQLFederationExecutionPlan;
+import org.apache.shardingsphere.sqlfederation.compiler.planner.cache.ExecutionPlanCacheBuilder;
+import org.apache.shardingsphere.sqlfederation.compiler.planner.cache.ExecutionPlanCacheKey;
+import org.apache.shardingsphere.sqlfederation.config.SQLFederationCacheOption;
+import org.apache.shardingsphere.test.infra.framework.extension.mock.AutoMockExtension;
+import org.apache.shardingsphere.test.infra.framework.extension.mock.StaticMockSettings;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.util.Optional;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.sameInstance;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(AutoMockExtension.class)
+@StaticMockSettings(ExecutionPlanCacheBuilder.class)
+class SQLStatementCompilerEngineFactoryTest {
+    
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    @Test
+    void assertGetSQLStatementCompilerEngineCoversAllBranches() {
+        LoadingCache<ExecutionPlanCacheKey, SQLFederationExecutionPlan> cacheWithEviction = mock(LoadingCache.class);
+        Policy cachePolicyWithEviction = mock(Policy.class);
+        Eviction eviction = mock(Eviction.class);
+        when(cachePolicyWithEviction.eviction()).thenReturn(Optional.of(eviction));
+        when(cacheWithEviction.policy()).thenReturn(cachePolicyWithEviction);
+        when(ExecutionPlanCacheBuilder.build(any(SQLFederationCacheOption.class))).thenReturn(cacheWithEviction, mock(LoadingCache.class));
+        SQLStatementCompilerEngine actualCreatedEngine = SQLStatementCompilerEngineFactory.getSQLStatementCompilerEngine("factory_db", "factory_schema", new SQLFederationCacheOption(1, 1L));
+        SQLStatementCompilerEngine actualUpdatedEngine = SQLStatementCompilerEngineFactory.getSQLStatementCompilerEngine("factory_db", "factory_schema", new SQLFederationCacheOption(1, 2L));
+        SQLStatementCompilerEngine actualReplacedEngine = SQLStatementCompilerEngineFactory.getSQLStatementCompilerEngine("factory_db", "factory_schema", new SQLFederationCacheOption(2, 2L));
+        SQLStatementCompilerEngine actualUnchangedEngine = SQLStatementCompilerEngineFactory.getSQLStatementCompilerEngine("factory_db", "factory_schema", new SQLFederationCacheOption(2, 2L));
+        assertThat(actualUpdatedEngine, is(actualCreatedEngine));
+        assertThat(actualReplacedEngine, is(not(sameInstance(actualCreatedEngine))));
+        assertThat(actualUnchangedEngine, is(actualReplacedEngine));
+        verify(eviction).setMaximum(2L);
+    }
+}
diff --git a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/context/CalciteSchemaBuilderTest.java b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/context/CalciteSchemaBuilderTest.java
new file mode 100644
index 00000000000..bb3b7b65bd2
--- /dev/null
+++ b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/context/CalciteSchemaBuilderTest.java
@@ -0,0 +1,98 @@
+/*
+ * 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.sqlfederation.compiler.context;
+
+import org.apache.calcite.jdbc.CalciteSchema;
+import org.apache.calcite.schema.SchemaPlus;
+import org.apache.shardingsphere.database.connector.core.spi.DatabaseTypedSPILoader;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
+import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
+import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
+import org.apache.shardingsphere.sqlfederation.compiler.context.schema.CalciteSchemaBuilder;
+import org.apache.shardingsphere.sqlfederation.compiler.sql.function.DialectSQLFederationFunctionRegister;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.MockedStatic;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Optional;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasItem;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.verify;
+
+class CalciteSchemaBuilderTest {
+    
+    @Test
+    void assertBuildWithoutSchemas() {
+        DatabaseType databaseType = TypedSPILoader.getService(DatabaseType.class, "MySQL");
+        ShardingSphereDatabase databaseWithoutSchemas = new ShardingSphereDatabase(
+                "empty_db", databaseType, mock(ResourceMetaData.class), new RuleMetaData(Collections.emptyList()), Collections.emptyList());
+        CalciteSchemaBuilder.build(Collections.emptyList());
+        CalciteSchema actual = CalciteSchemaBuilder.build(Collections.singleton(databaseWithoutSchemas));
+        assertFalse(actual.getSubSchemaMap().containsKey("empty_db"));
+    }
+    
+    @Test
+    void assertBuildWithDefaultSchemaRegistersNestedFunctions() {
+        DatabaseType databaseType = TypedSPILoader.getService(DatabaseType.class, "PostgreSQL");
+        Collection<ShardingSphereSchema> schemas = Arrays.asList(new ShardingSphereSchema("public"), new ShardingSphereSchema("other"));
+        ShardingSphereDatabase database = new ShardingSphereDatabase("pg_db", databaseType, mock(ResourceMetaData.class), new RuleMetaData(Collections.emptyList()), schemas);
+        DialectSQLFederationFunctionRegister functionRegister = mock(DialectSQLFederationFunctionRegister.class);
+        try (MockedStatic<DatabaseTypedSPILoader> databaseTypedSPILoader = mockStatic(DatabaseTypedSPILoader.class, CALLS_REAL_METHODS)) {
+            databaseTypedSPILoader.when(() -> DatabaseTypedSPILoader.findService(DialectSQLFederationFunctionRegister.class, databaseType))
+                    .thenReturn(Optional.of(functionRegister)).thenReturn(Optional.empty());
+            CalciteSchema actual = CalciteSchemaBuilder.build(Collections.singletonList(database));
+            assertTrue(actual.getSubSchemaMap().containsKey("pg_db"));
+            CalciteSchema databaseSchema = actual.getSubSchema("pg_db", true);
+            assertNotNull(databaseSchema);
+            assertTrue(databaseSchema.getSubSchemaMap().keySet().containsAll(Arrays.asList("public", "other")));
+            ArgumentCaptor<String> schemaNameCaptor = ArgumentCaptor.forClass(String.class);
+            verify(functionRegister).registerFunction(any(SchemaPlus.class), schemaNameCaptor.capture());
+            assertThat(Arrays.asList("public", "other"), hasItem(schemaNameCaptor.getValue()));
+        }
+    }
+    
+    @Test
+    void assertBuildWithoutDefaultSchemaRegistersFunctions() {
+        DatabaseType databaseType = TypedSPILoader.getService(DatabaseType.class, "MySQL");
+        ShardingSphereDatabase database = new ShardingSphereDatabase("mysql_db", databaseType, mock(ResourceMetaData.class),
+                new RuleMetaData(Collections.emptyList()), Collections.singletonList(new ShardingSphereSchema("foo_schema")));
+        try (MockedStatic<DatabaseTypedSPILoader> databaseTypedSPILoader = mockStatic(DatabaseTypedSPILoader.class, CALLS_REAL_METHODS)) {
+            DialectSQLFederationFunctionRegister functionRegister = mock(DialectSQLFederationFunctionRegister.class);
+            databaseTypedSPILoader.when(() -> DatabaseTypedSPILoader.findService(DialectSQLFederationFunctionRegister.class, databaseType))
+                    .thenReturn(Optional.empty()).thenReturn(Optional.of(functionRegister));
+            CalciteSchema actual = CalciteSchemaBuilder.build(Collections.singletonList(database));
+            assertTrue(actual.getSubSchemaMap().containsKey("mysql_db"));
+            verify(functionRegister).registerFunction(any(SchemaPlus.class), eq("mysql_db"));
+        }
+    }
+}