diff --git a/.github/workflows/nightly-build.yml b/.github/workflows/nightly-build.yml index 3a414ead7610bc..391149379d6626 100644 --- a/.github/workflows/nightly-build.yml +++ b/.github/workflows/nightly-build.yml @@ -136,7 +136,6 @@ jobs: password: ${{ secrets.GITHUB_TOKEN }} - name: Push Docker Image run: | - ./mvnw -PgenerateStandardMetadata -DskipNativeTests -B -T1C clean test ./mvnw -am -pl distribution/proxy-native -Prelease.native,docker.buildx.push.native -B -T1C -DskipTests -Dproxy.image.repository=${{ env.PROXY_NATIVE }} -Dproxy.image.tag=${{ github.sha }} clean package build-cache: diff --git a/distribution/proxy-native/access-filter.json b/distribution/proxy-native/access-filter.json deleted file mode 100644 index a5c58ae341dcda..00000000000000 --- a/distribution/proxy-native/access-filter.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "rules": [ - {"includeClasses": "**"}, - {"excludeClasses": "com.atomikos.jdbc.**"}, - {"excludeClasses": "com.mchange.v2.c3p0.**"}, - {"excludeClasses": "com.mysql.jdbc.**"}, - {"excludeClasses": "com.zaxxer.hikari.**"}, - {"excludeClasses": "org.apache.commons.dbcp2.**"}, - {"excludeClasses": "org.junit.platform.launcher.**"}, - {"excludeClasses": "org.mariadb.jdbc.**"}, - {"excludeClasses": "org.apache.shardingsphere.sharding.UndefinedClass"} - ], - "regexRules": [ - {"excludeClasses": ".*Fixture*.*"}, - {"excludeClasses": ".*Mocked*.*"} - ] -} diff --git a/docs/document/content/user-manual/shardingsphere-proxy/startup/graalvm-native-image.cn.md b/docs/document/content/user-manual/shardingsphere-proxy/startup/graalvm-native-image.cn.md index 4afb9ffa1c376b..f769afac492c7c 100644 --- a/docs/document/content/user-manual/shardingsphere-proxy/startup/graalvm-native-image.cn.md +++ b/docs/document/content/user-manual/shardingsphere-proxy/startup/graalvm-native-image.cn.md @@ -25,10 +25,6 @@ services: - "3307:3307" ``` -- 若你发现构建过程存在缺失的 GraalVM Reachability Metadata, - 应当在 https://github.com/oracle/graalvm-reachability-metadata 打开新的 issue ， - 并提交包含 ShardingSphere 自身或依赖的第三方库缺失的 GraalVM Reachability Metadata 的 PR。 - - ShardingSphere 的 master 分支尚未准备好处理 Native Image 中的单元测试 ， 你总是需要在构建 GraalVM Native Image 的过程中， 加上特定于 `GraalVM Native Build Tools` 的 `-DskipNativeTests` 或 `-DskipTests` 参数跳过 Native Image 中的单元测试。 @@ -54,19 +50,13 @@ services: 或 `GraalVM Community Edition` 的下游发行版。若使用 `SDKMAN!`， ```shell -sdk install java 17.0.8-graalce +sdk install java 17.0.9-graalce ``` 2. 根据 https://www.graalvm.org/jdk17/reference-manual/native-image/#prerequisites 的要求安装本地工具链。 3. 如果需要构建 Docker Image， 确保 `docker-ce` 已安装。 -4. 首先需要在项目的根目录下，执行如下命令以为所有子模块采集 Standard 形态的 GraalVM 可达性元数据。 - -```shell -./mvnw -PgenerateStandardMetadata -DskipNativeTests -B -T1C clean test -``` - ## 操作步骤 1. 获取 Apache ShardingSphere Git Source @@ -148,7 +138,7 @@ services: 另请注意，某些第三方依赖将需要在 `Dockerfile` 安装更多系统库，例如 `libdl`。 因此请确保根据你的使用情况调整 `distribution/proxy-native` 下的 `pom.xml` 和 `Dockerfile` 的内容。 -# 可观察性 +## 可观察性 - 针对 GraalVM Native Image 形态的 ShardingSphere Proxy，其提供的可观察性的能力与 https://shardingsphere.apache.org/document/current/cn/user-manual/shardingsphere-proxy/observability/ 并不一致。 @@ -160,7 +150,7 @@ services: https://github.com/oracle/graal/issues/5648 。 - 对于使用 `ShardingSphere Agent` 等 APM Java Agent 的情形， GraalVM 的 `native-image` 组件尚未完全支持在构建 Native - Image 时使用 javaagent，你需要关注尚未关闭的 https://github.com/oracle/graal/issues/1065。 + Image 时使用 javaagent，你需要关注尚未关闭的 https://github.com/oracle/graal/issues/1065 。 - 以下部分采用 `Apache SkyWalking Java Agent` 作为示例，可用于跟踪 GraalVM 社区的对应 issue。 @@ -184,3 +174,58 @@ services: ```bash ./mvnw -am -pl distribution/proxy-native -B -T1C -Prelease.native -DskipTests clean package ``` + +## 贡献 GraalVM Reachability Metadata + +ShardingSphere 对在 GraalVM Native Image 下的可用性的验证，是通过 GraalVM Native Build Tools 的 Maven Plugin 子项目来完成的。 +通过在 JVM 下运行单元测试，为单元测试打上 `junit-platform-unique-ids*` 标签，此后构建为 GraalVM Native Image 进行 nativeTest 来测试 +在 GraalVM Native Image 下的单元测试覆盖率。请不要使用 `io.kotest:kotest-runner-junit5-jvm:5.5.4` 等在 `test listener` mode 下 +failed to discover tests 的测试库。 + +ShardingSphere 定义了 `shardingsphere-infra-nativetest` 的 Maven Module 用于为 native Test 提供小型的单元测试子集， +此单元测试子集避免了使用 Mockito 等 native Test 下无法使用的第三方库。 + +ShardingSphere 定义了 `nativeTestInShardingSphere` 的 Maven Profile 用于为 `shardingsphere-infra-nativetest` 模块执行 nativeTest 。 + +假设贡献者处于新的 Ubuntu 22.04.3 LTS 实例下，其可通过如下 bash 命令通过 SDKMAN! 管理 JDK 和工具链， +并为 `shardingsphere-infra-nativetest` 子模块执行 nativeTest。 + +```bash +sudo apt install unzip zip curl sed -y +curl -s "https://get.sdkman.io" | bash +source "$HOME/.sdkman/bin/sdkman-init.sh" +sdk install java 17.0.9-graalce +sdk use java 17.0.9-graalce +sudo apt-get install build-essential libz-dev zlib1g-dev -y + +git clone git@github.com:apache/shardingsphere.git +cd ./shardingsphere/ +./mvnw -PnativeTestInShardingSphere -T1C -e clean test +``` + +当贡献者发现缺少与 ShardingSphere 无关的第三方库的 GraalVM Reachability Metadata 时，应当在 +https://github.com/oracle/graalvm-reachability-metadata 打开新的 issue， 并提交包含依赖的第三方库缺失的 GraalVM Reachability +Metadata 的 PR。ShardingSphere 在 `shardingsphere-infra-reachability-metadata` 子模块主动托管了部分第三方库的 GraalVM Reachability Metadata。 + +如果 nativeTest 执行失败， 应为单元测试生成初步的 GraalVM Reachability Metadata，并手动调整以修复 nativeTest。 +如有需要，请使用 `org.junit.jupiter.api.condition.DisabledInNativeImage` 注解或 `org.graalvm.nativeimage.imagecode` 的 +System Property 屏蔽部分单元测试在 GraalVM Native Image 下运行。 + +ShardingSphere 定义了 `generateMetadata` 的 Maven Profile 用于在普通 JVM 下携带 GraalVM Tracing Agent 执行单元测试，并在特定目录下生成或合并 +已有的 GraalVM Reachability Metadata 文件。可通过如下 bash 命令简单处理此流程。贡献者仍可能需要手动调整具体的 JSON 条目，并在适当的时候 +调整 Maven Profile 和 GraalVM Tracing Agent 的 Filter 链。 + +以下命令仅为 `shardingsphere-infra-nativetest` 生成 Conditional 形态的 GraalVM Reachability Metadata 的一个举例。生成的 GraalVM +Reachability Metadata 位于 `shardingsphere-infra-reachability-metadata` 子模块下。 + +对于测试类和测试文件独立使用的 GraalVM Reachability Metadata，贡献者应该放置到 +`${user.dir}/infra/nativetest/src/test/resources/META-INF/native-image/shardingsphere-infra-nativetest-test-metadata/` +文件夹下。`${}` 内为相关子模块对应的 POM 4.0 的常规系统变量，自行替换。 + +```bash +git clone git@github.com:apache/shardingsphere.git +cd ./shardingsphere/ +./mvnw -PgenerateMetadata -DskipNativeTests -e -T1C clean test native:metadata-copy +``` + +请手动删除无任何具体条目的 JSON 文件。 diff --git a/docs/document/content/user-manual/shardingsphere-proxy/startup/graalvm-native-image.en.md b/docs/document/content/user-manual/shardingsphere-proxy/startup/graalvm-native-image.en.md index 638177fff99c94..91f4ca8c672175 100644 --- a/docs/document/content/user-manual/shardingsphere-proxy/startup/graalvm-native-image.en.md +++ b/docs/document/content/user-manual/shardingsphere-proxy/startup/graalvm-native-image.en.md @@ -27,10 +27,6 @@ services: - "3307:3307" ```` -- If you find that the build process has missing GraalVM Reachability Metadata, a new issue should be opened - at https://github.com/oracle/graalvm-reachability-metadata, and submit a PR containing GraalVM Reachability Metadata - missing from ShardingSphere itself or dependent third-party libraries. - - The master branch of ShardingSphere is not yet ready to handle unit tests in Native Image, you always need to build GraalVM Native Image in the process, Plus `-DskipNativeTests` or `-DskipTests` parameter specific to `GraalVM Native Build Tools` to skip unit tests in @@ -62,20 +58,13 @@ services: JDK 17 according to https://www.graalvm.org/downloads/. If `SDKMAN!` is used, ```shell -sdk install java 17.0.8-graalce +sdk install java 17.0.9-graalce ``` 2. Install the local toolchain as required by https://www.graalvm.org/jdk17/reference-manual/native-image/#prerequisites. 3. If you need to build a Docker Image, make sure `docker-ce` is installed. -4. First, you need to execute the following command in the root directory of the project to collect the GraalVM - Reachability Metadata of the Standard form for all submodules. - -```shell -./mvnw -PgenerateStandardMetadata -DskipNativeTests -B -T1C clean test -``` - ## Steps 1. Get Apache ShardingSphere Git Source @@ -163,7 +152,7 @@ services: the `Dockerfile`. So make sure to tune `distribution/proxy-native` according to your usage `pom.xml` and `Dockerfile` below. -# Observability +## Observability - ShardingSphere for GraalVM Native Image form Proxy, which provides observability capabilities with https://shardingsphere.apache.org/document/current/cn/user-manual/shardingsphere-proxy/observability/ diff --git a/infra/nativetest/native-image-filter/extra-filter.json b/infra/nativetest/native-image-filter/extra-filter.json new file mode 100644 index 00000000000000..0781beee690316 --- /dev/null +++ b/infra/nativetest/native-image-filter/extra-filter.json @@ -0,0 +1,31 @@ +{ + "rules": [ + {"includeClasses": "**"}, + + {"excludeClasses": "com.sun.crypto.provider.**"}, + {"excludeClasses": "com.sun.org.apache.xerces.internal.jaxp.**"}, + {"excludeClasses": "java.**"}, + {"includeClasses": "java.lang.Boolean"}, + {"includeClasses": "java.lang.Thread"}, + {"includeClasses": "java.util.Properties"}, + {"excludeClasses": "javax.security.auth.x500.**"}, + {"excludeClasses": "sun.misc.**"}, + {"excludeClasses": "sun.security.**"}, + + {"excludeClasses": "com.github.benmanes.caffeine.cache.**"}, + {"excludeClasses": "com.google.common.util.concurrent.**"}, + {"excludeClasses": "com.sun.xml.bind.v2.**"}, + {"excludeClasses": "com.zaxxer.hikari.**"}, + {"excludeClasses": "javax.xml.bind.annotation.**"}, + {"excludeClasses": "groovy.**"}, + {"excludeClasses": "org.apache.calcite.**"}, + {"excludeClasses": "org.codehaus.groovy.**"}, + {"excludeClasses": "org.h2.**"}, + {"excludeClasses": "org.locationtech.jts.geom.**"}, + {"excludeClasses": "org.slf4j.event.**"}, + + {"excludeClasses": "org.apache.shardingsphere.infra.nativetest.**"} + ], + "regexRules": [ + ] +} diff --git a/distribution/proxy-native/caller-filter.json b/infra/nativetest/native-image-filter/user-code-filter.json similarity index 100% rename from distribution/proxy-native/caller-filter.json rename to infra/nativetest/native-image-filter/user-code-filter.json diff --git a/infra/nativetest/pom.xml b/infra/nativetest/pom.xml new file mode 100644 index 00000000000000..5fb8d91c8be180 --- /dev/null +++ b/infra/nativetest/pom.xml @@ -0,0 +1,67 @@ + + + + + 4.0.0 + + org.apache.shardingsphere + shardingsphere-infra + 5.4.2-SNAPSHOT + + shardingsphere-infra-nativetest + ${project.artifactId} + + + true + + + + + org.apache.shardingsphere + shardingsphere-jdbc-core + ${project.version} + test + + + + org.hamcrest + hamcrest + test + + + com.zaxxer + HikariCP + test + + + com.h2database + h2 + test + + + + + + + org.graalvm.buildtools + native-maven-plugin + ${native-maven-plugin.version} + + + + diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/FileTestUtils.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/FileTestUtils.java new file mode 100644 index 00000000000000..30768fb598a657 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/FileTestUtils.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.infra.nativetest; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * The background for this class comes from oracle/graal#7682 + * and Accessing Resources in Native Image. + * GraalVM Native Image has special features in its handling of file systems. + * This means we are better off reading the file via `java.io.InputStream` instead of `java.net.URL` to avoid extra code + * processing. + * + * @see java.net.URL + * @see InputStream + */ +public class FileTestUtils { + + /** + * read file From file URL string. + * @param fileUrl fileUrl + * @return byte array + */ + public static byte[] readFromFileURLString(final String fileUrl) { + return readInputStream(ClassLoader.getSystemResourceAsStream(fileUrl)).getBytes(StandardCharsets.UTF_8); + } + + private static String readInputStream(final InputStream is) { + StringBuilder out = new StringBuilder(); + try ( + InputStreamReader streamReader = new InputStreamReader(is, StandardCharsets.UTF_8); + BufferedReader reader = new BufferedReader(streamReader)) { + String line; + while ((line = reader.readLine()) != null) { + out.append(line); + // ShardingSphere does not actively handle line separators when parsing YAML and needs to be actively added. + out.append(System.lineSeparator()); + } + } catch (IOException e) { + Logger.getLogger(FileTestUtils.class.getName()).log(Level.SEVERE, null, e); + } + return out.toString(); + } +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/EncryptTest.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/EncryptTest.java new file mode 100644 index 00000000000000..4fd0146d782453 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/EncryptTest.java @@ -0,0 +1,123 @@ +/* + * 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.infra.nativetest.jdbc.features; + +import org.apache.shardingsphere.driver.api.yaml.YamlShardingSphereDataSourceFactory; +import org.apache.shardingsphere.infra.nativetest.FileTestUtils; + +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Address; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Order; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.OrderItem; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.AddressRepository; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderItemRepository; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderRepository; +import org.junit.jupiter.api.Test; + +import javax.sql.DataSource; +import java.io.IOException; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.LongStream; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +public final class EncryptTest { + + private OrderRepository orderRepository; + + private OrderItemRepository orderItemRepository; + + private AddressRepository addressRepository; + + @Test + void testEncryptInLocalTransactions() throws SQLException, IOException { + DataSource dataSource = YamlShardingSphereDataSourceFactory.createDataSource(FileTestUtils.readFromFileURLString("yaml/encrypt.yaml")); + orderRepository = new OrderRepository(dataSource); + orderItemRepository = new OrderItemRepository(dataSource); + addressRepository = new AddressRepository(dataSource); + this.initEnvironment(); + this.processSuccess(); + this.cleanEnvironment(); + } + + private void initEnvironment() throws SQLException { + orderRepository.createTableIfNotExists(); + orderItemRepository.createTableIfNotExists(); + addressRepository.createTableIfNotExists(); + orderRepository.truncateTable(); + orderItemRepository.truncateTable(); + addressRepository.truncateTable(); + } + + private void processSuccess() throws SQLException { + final List orderIds = insertData(); + assertThat(orderRepository.selectAll(), + equalTo(IntStream.range(1, 11).mapToObj(i -> new Order(i, i % 2, i, i, "INSERT_TEST")).collect(Collectors.toList()))); + assertThat(orderItemRepository.selectAll(), + equalTo(IntStream.range(1, 11).mapToObj(i -> new OrderItem(i, i, i, "13800000001", "INSERT_TEST")).collect(Collectors.toList()))); + assertThat(addressRepository.selectAll(), + equalTo(LongStream.range(1, 11).mapToObj(i -> new Address(i, "address_test_" + i)).collect(Collectors.toList()))); + deleteData(orderIds); + assertThat(orderRepository.selectAll(), equalTo(new ArrayList<>())); + assertThat(orderItemRepository.selectAll(), equalTo(new ArrayList<>())); + assertThat(addressRepository.selectAll(), equalTo(new ArrayList<>())); + } + + private List insertData() throws SQLException { + List result = new ArrayList<>(10); + for (int i = 1; i <= 10; i++) { + Order order = new Order(); + order.setUserId(i); + order.setOrderType(i % 2); + order.setAddressId(i); + order.setStatus("INSERT_TEST"); + orderRepository.insert(order); + + OrderItem orderItem = new OrderItem(); + orderItem.setOrderId(order.getOrderId()); + orderItem.setUserId(i); + orderItem.setPhone("13800000001"); + orderItem.setStatus("INSERT_TEST"); + orderItemRepository.insert(orderItem); + + Address address = new Address((long) i, "address_test_" + i); + addressRepository.insert(address); + result.add(order.getOrderId()); + } + return result; + } + + private void deleteData(final List orderIds) throws SQLException { + long count = 1; + for (Long each : orderIds) { + orderRepository.delete(each); + orderItemRepository.delete(each); + addressRepository.delete(count++); + } + } + + private void cleanEnvironment() throws SQLException { + orderRepository.dropTable(); + orderItemRepository.dropTable(); + addressRepository.dropTable(); + } +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/MaskTest.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/MaskTest.java new file mode 100644 index 00000000000000..18b11bf6af87d4 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/MaskTest.java @@ -0,0 +1,123 @@ +/* + * 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.infra.nativetest.jdbc.features; + +import org.apache.shardingsphere.driver.api.yaml.YamlShardingSphereDataSourceFactory; +import org.apache.shardingsphere.infra.nativetest.FileTestUtils; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Address; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Order; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.OrderItem; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.AddressRepository; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderItemRepository; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderRepository; +import org.junit.jupiter.api.Test; + +import javax.sql.DataSource; +import java.io.IOException; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.LongStream; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +public final class MaskTest { + + private OrderRepository orderRepository; + + private OrderItemRepository orderItemRepository; + + private AddressRepository addressRepository; + + @Test + void testMaskInLocalTransactions() throws SQLException, IOException { + DataSource dataSource = YamlShardingSphereDataSourceFactory.createDataSource(FileTestUtils.readFromFileURLString("yaml/mask.yaml")); + orderRepository = new OrderRepository(dataSource); + orderItemRepository = new OrderItemRepository(dataSource); + addressRepository = new AddressRepository(dataSource); + this.initEnvironment(); + this.processSuccess(); + this.cleanEnvironment(); + } + + private void initEnvironment() throws SQLException { + orderRepository.createTableIfNotExists(); + orderItemRepository.createTableIfNotExists(); + addressRepository.createTableIfNotExists(); + orderRepository.truncateTable(); + orderItemRepository.truncateTable(); + addressRepository.truncateTable(); + } + + private void processSuccess() throws SQLException { + final List orderIds = insertData(); + assertThat(orderRepository.selectAll(), + equalTo(IntStream.range(1, 11).mapToObj(i -> new Order(i, i % 2, i, i, "INSERT_TEST")).collect(Collectors.toList()))); + assertThat(orderItemRepository.selectAll(), + equalTo(IntStream.range(1, 11).mapToObj(i -> new OrderItem(i, i, i, "138****0001", "INSERT_TEST")).collect(Collectors.toList()))); + assertThat(addressRepository.selectAll(), + equalTo(LongStream.range(1, 11).mapToObj(i -> new Address(i, "address_test_" + i)).collect(Collectors.toList()))); + deleteData(orderIds); + assertThat(orderRepository.selectAll(), equalTo(new ArrayList<>())); + assertThat(orderItemRepository.selectAll(), equalTo(new ArrayList<>())); + assertThat(addressRepository.selectAll(), equalTo(new ArrayList<>())); + } + + private List insertData() throws SQLException { + List result = new ArrayList<>(10); + for (int i = 1; i <= 10; i++) { + Order order = new Order(); + order.setUserId(i); + order.setOrderType(i % 2); + order.setAddressId(i); + order.setStatus("INSERT_TEST"); + orderRepository.insert(order); + + OrderItem orderItem = new OrderItem(); + orderItem.setOrderId(order.getOrderId()); + orderItem.setUserId(i); + orderItem.setPhone("13800000001"); + orderItem.setStatus("INSERT_TEST"); + orderItemRepository.insert(orderItem); + + Address address = new Address((long) i, "address_test_" + i); + addressRepository.insert(address); + + result.add(order.getOrderId()); + } + return result; + } + + private void deleteData(final List orderIds) throws SQLException { + long count = 1; + for (Long each : orderIds) { + orderRepository.delete(each); + orderItemRepository.delete(each); + addressRepository.delete(count++); + } + } + + private void cleanEnvironment() throws SQLException { + orderRepository.dropTable(); + orderItemRepository.dropTable(); + addressRepository.dropTable(); + } +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ReadWriteSplittingTest.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ReadWriteSplittingTest.java new file mode 100644 index 00000000000000..9d6e1311e4fe35 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ReadWriteSplittingTest.java @@ -0,0 +1,121 @@ +/* + * 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.infra.nativetest.jdbc.features; + +import org.apache.shardingsphere.driver.api.yaml.YamlShardingSphereDataSourceFactory; +import org.apache.shardingsphere.infra.nativetest.FileTestUtils; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Address; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Order; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.OrderItem; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.AddressRepository; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderItemRepository; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderRepository; +import org.h2.jdbc.JdbcSQLSyntaxErrorException; +import org.junit.jupiter.api.Test; + +import javax.sql.DataSource; +import java.io.IOException; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertThrows; + +public final class ReadWriteSplittingTest { + + private OrderRepository orderRepository; + + private OrderItemRepository orderItemRepository; + + private AddressRepository addressRepository; + + @Test + void testReadWriteSplittingInLocalTransactions() throws SQLException, IOException { + DataSource dataSource = YamlShardingSphereDataSourceFactory.createDataSource(FileTestUtils.readFromFileURLString("yaml/readwrite-splitting.yaml")); + orderRepository = new OrderRepository(dataSource); + orderItemRepository = new OrderItemRepository(dataSource); + addressRepository = new AddressRepository(dataSource); + this.initEnvironment(); + this.processSuccess(); + this.cleanEnvironment(); + } + + private void initEnvironment() throws SQLException { + orderRepository.createTableIfNotExists(); + orderItemRepository.createTableIfNotExists(); + addressRepository.createTableIfNotExists(); + orderRepository.truncateTable(); + orderItemRepository.truncateTable(); + addressRepository.truncateTable(); + } + + private void processSuccess() throws SQLException { + List orderIds = insertData(); + // This is intentional because the read operation is in the slave database and the corresponding table does not exist. + assertThrows(JdbcSQLSyntaxErrorException.class, this::printData); + deleteData(orderIds); + // This is intentional because the read operation is in the slave database and the corresponding table does not exist. + assertThrows(JdbcSQLSyntaxErrorException.class, this::printData); + } + + private List insertData() throws SQLException { + List result = new ArrayList<>(10); + for (int i = 1; i <= 10; i++) { + Order order = new Order(); + order.setUserId(i); + order.setOrderType(i % 2); + order.setAddressId(i); + order.setStatus("INSERT_TEST"); + orderRepository.insert(order); + + OrderItem orderItem = new OrderItem(); + orderItem.setOrderId(order.getOrderId()); + orderItem.setUserId(i); + orderItem.setPhone("13800000001"); + orderItem.setStatus("INSERT_TEST"); + orderItemRepository.insert(orderItem); + + Address address = new Address((long) i, "address_test_" + i); + addressRepository.insert(address); + + result.add(order.getOrderId()); + } + return result; + } + + private void deleteData(final List orderIds) throws SQLException { + long count = 1; + for (Long each : orderIds) { + orderRepository.delete(each); + orderItemRepository.delete(each); + addressRepository.delete(count++); + } + } + + private void printData() throws SQLException { + orderRepository.selectAll(); + orderItemRepository.selectAll(); + addressRepository.selectAll(); + } + + private void cleanEnvironment() throws SQLException { + orderRepository.dropTable(); + orderItemRepository.dropTable(); + addressRepository.dropTable(); + } +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ShadowTest.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ShadowTest.java new file mode 100644 index 00000000000000..34eef534fee1df --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ShadowTest.java @@ -0,0 +1,152 @@ +/* + * 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.infra.nativetest.jdbc.features; + +import org.apache.shardingsphere.driver.api.yaml.YamlShardingSphereDataSourceFactory; +import org.apache.shardingsphere.infra.nativetest.FileTestUtils; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Address; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Order; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.OrderItem; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.AddressRepository; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderItemRepository; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderRepository; +import org.junit.jupiter.api.Test; + +import javax.sql.DataSource; +import java.io.IOException; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.LongStream; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +public final class ShadowTest { + + private OrderRepository orderRepository; + + private OrderItemRepository orderItemRepository; + + private AddressRepository addressRepository; + + @Test + void testShadowInLocalTransactions() throws SQLException, IOException { + DataSource dataSource = YamlShardingSphereDataSourceFactory.createDataSource(FileTestUtils.readFromFileURLString("yaml/shadow.yaml")); + orderRepository = new OrderRepository(dataSource); + orderItemRepository = new OrderItemRepository(dataSource); + addressRepository = new AddressRepository(dataSource); + this.initEnvironment(); + this.processSuccess(); + this.cleanEnvironment(); + } + + private void initEnvironment() throws SQLException { + orderRepository.createTableIfNotExists(); + orderItemRepository.createTableIfNotExists(); + addressRepository.createTableIfNotExists(); + orderRepository.truncateTable(); + orderItemRepository.truncateTable(); + addressRepository.truncateTable(); + orderRepository.createTableIfNotExistsShadow(); + orderRepository.truncateTableShadow(); + } + + private void processSuccess() throws SQLException { + final List orderIds = insertData(); + assertThat(this.selectAll(), equalTo(Arrays.asList( + new Order(1, 0, 2, 2, "INSERT_TEST"), + new Order(2, 0, 4, 4, "INSERT_TEST"), + new Order(3, 0, 6, 6, "INSERT_TEST"), + new Order(4, 0, 8, 8, "INSERT_TEST"), + new Order(5, 0, 10, 10, "INSERT_TEST"), + new Order(1, 1, 1, 1, "INSERT_TEST"), + new Order(2, 1, 3, 3, "INSERT_TEST"), + new Order(3, 1, 5, 5, "INSERT_TEST"), + new Order(4, 1, 7, 7, "INSERT_TEST"), + new Order(5, 1, 9, 9, "INSERT_TEST")))); + assertThat(orderItemRepository.selectAll(), equalTo(Arrays.asList( + new OrderItem(1, 1, 1, "13800000001", "INSERT_TEST"), + new OrderItem(2, 1, 2, "13800000001", "INSERT_TEST"), + new OrderItem(3, 2, 3, "13800000001", "INSERT_TEST"), + new OrderItem(4, 2, 4, "13800000001", "INSERT_TEST"), + new OrderItem(5, 3, 5, "13800000001", "INSERT_TEST"), + new OrderItem(6, 3, 6, "13800000001", "INSERT_TEST"), + new OrderItem(7, 4, 7, "13800000001", "INSERT_TEST"), + new OrderItem(8, 4, 8, "13800000001", "INSERT_TEST"), + new OrderItem(9, 5, 9, "13800000001", "INSERT_TEST"), + new OrderItem(10, 5, 10, "13800000001", "INSERT_TEST")))); + assertThat(addressRepository.selectAll(), + equalTo(LongStream.range(1, 11).mapToObj(i -> new Address(i, "address_test_" + i)).collect(Collectors.toList()))); + deleteData(orderIds); + assertThat(this.selectAll(), equalTo(Collections.singletonList(new Order(1, 0, 2, 2, "INSERT_TEST")))); + assertThat(orderItemRepository.selectAll(), equalTo(new ArrayList<>())); + assertThat(addressRepository.selectAll(), equalTo(new ArrayList<>())); + } + + private List insertData() throws SQLException { + List result = new ArrayList<>(10); + for (int i = 1; i <= 10; i++) { + Order order = new Order(); + order.setUserId(i); + order.setOrderType(i % 2); + order.setAddressId(i); + order.setStatus("INSERT_TEST"); + orderRepository.insert(order); + + OrderItem orderItem = new OrderItem(); + orderItem.setOrderId(order.getOrderId()); + orderItem.setUserId(i); + orderItem.setPhone("13800000001"); + orderItem.setStatus("INSERT_TEST"); + orderItemRepository.insert(orderItem); + + Address address = new Address((long) i, "address_test_" + i); + addressRepository.insert(address); + + result.add(order.getOrderId()); + } + return result; + } + + private void deleteData(final List orderIds) throws SQLException { + long count = 1; + for (Long each : orderIds) { + orderRepository.deleteShadow(each); + orderRepository.delete(each); + orderItemRepository.delete(each); + addressRepository.delete(count++); + } + } + + private List selectAll() throws SQLException { + List result = orderRepository.selectAll(); + result.addAll(orderRepository.selectShadowOrder()); + return result; + } + + private void cleanEnvironment() throws SQLException { + orderRepository.dropTableShadow(); + orderRepository.dropTable(); + orderItemRepository.dropTable(); + addressRepository.dropTable(); + } +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ShardingTest.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ShardingTest.java new file mode 100644 index 00000000000000..9a7e96ff6cab53 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ShardingTest.java @@ -0,0 +1,138 @@ +/* + * 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.infra.nativetest.jdbc.features; + +import org.apache.shardingsphere.driver.api.yaml.YamlShardingSphereDataSourceFactory; +import org.apache.shardingsphere.infra.nativetest.FileTestUtils; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Address; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Order; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.OrderItem; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.AddressRepository; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderItemRepository; +import org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderRepository; +import org.junit.jupiter.api.Test; + +import javax.sql.DataSource; +import java.io.IOException; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.LongStream; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +public final class ShardingTest { + + private OrderRepository orderRepository; + + private OrderItemRepository orderItemRepository; + + private AddressRepository addressRepository; + + @Test + void testShardingInLocalTransactions() throws SQLException, IOException { + DataSource dataSource = YamlShardingSphereDataSourceFactory.createDataSource(FileTestUtils.readFromFileURLString("yaml/sharding.yaml")); + orderRepository = new OrderRepository(dataSource); + orderItemRepository = new OrderItemRepository(dataSource); + addressRepository = new AddressRepository(dataSource); + this.initEnvironment(); + this.processSuccess(); + } + + private void initEnvironment() throws SQLException { + orderRepository.createTableIfNotExists(); + orderItemRepository.createTableIfNotExists(); + addressRepository.createTableIfNotExists(); + orderRepository.truncateTable(); + orderItemRepository.truncateTable(); + addressRepository.truncateTable(); + } + + private void processSuccess() throws SQLException { + final List orderIds = insertData(); + + List orders = orderRepository.selectAll(); + assertThat(orders.stream().map(Order::getOrderType).collect(Collectors.toList()), + equalTo(Arrays.asList(1, 1, 1, 1, 1, 0, 0, 0, 0, 0))); + assertThat(orders.stream().map(Order::getUserId).collect(Collectors.toList()), + equalTo(new ArrayList<>(Arrays.asList(1, 3, 5, 7, 9, 2, 4, 6, 8, 10)))); + assertThat(orders.stream().map(Order::getAddressId).collect(Collectors.toList()), + equalTo(new ArrayList<>(Arrays.asList(1L, 3L, 5L, 7L, 9L, 2L, 4L, 6L, 8L, 10L)))); + assertThat(orders.stream().map(Order::getStatus).collect(Collectors.toList()), + equalTo(IntStream.range(1, 11).mapToObj(i -> "INSERT_TEST").collect(Collectors.toList()))); + + List orderItems = orderItemRepository.selectAll(); + assertThat(orderItems.stream().map(OrderItem::getUserId).collect(Collectors.toList()), + equalTo(new ArrayList<>(Arrays.asList(1, 3, 5, 7, 9, 2, 4, 6, 8, 10)))); + assertThat(orderItems.stream().map(OrderItem::getPhone).collect(Collectors.toList()), + equalTo(IntStream.range(1, 11).mapToObj(i -> "13800000001").collect(Collectors.toList()))); + assertThat(orderItems.stream().map(OrderItem::getStatus).collect(Collectors.toList()), + equalTo(IntStream.range(1, 11).mapToObj(i -> "INSERT_TEST").collect(Collectors.toList()))); + + assertThat(addressRepository.selectAll(), + equalTo(LongStream.range(1, 11).mapToObj(i -> new Address(i, "address_test_" + i)).collect(Collectors.toList()))); + deleteData(orderIds); + assertThat(orderRepository.selectAll(), equalTo(new ArrayList<>())); + assertThat(orderItemRepository.selectAll(), equalTo(new ArrayList<>())); + assertThat(addressRepository.selectAll(), equalTo(new ArrayList<>())); + } + + private List insertData() throws SQLException { + List result = new ArrayList<>(10); + for (int i = 1; i <= 10; i++) { + Order order = new Order(); + order.setUserId(i); + order.setOrderType(i % 2); + order.setAddressId(i); + order.setStatus("INSERT_TEST"); + orderRepository.insert(order); + + OrderItem orderItem = new OrderItem(); + orderItem.setOrderId(order.getOrderId()); + orderItem.setUserId(i); + orderItem.setPhone("13800000001"); + orderItem.setStatus("INSERT_TEST"); + orderItemRepository.insert(orderItem); + + Address address = new Address((long) i, "address_test_" + i); + addressRepository.insert(address); + + result.add(order.getOrderId()); + } + return result; + } + + private void deleteData(final List orderIds) throws SQLException { + long count = 1; + for (Long each : orderIds) { + orderRepository.delete(each); + orderItemRepository.delete(each); + addressRepository.delete(count++); + } + } + + private void cleanEnvironment() throws SQLException { + orderRepository.dropTable(); + orderItemRepository.dropTable(); + addressRepository.dropTable(); + } +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/algorithm/ClassBasedInlineShardingAlgorithmFixture.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/algorithm/ClassBasedInlineShardingAlgorithmFixture.java new file mode 100644 index 00000000000000..55652a13e6d499 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/algorithm/ClassBasedInlineShardingAlgorithmFixture.java @@ -0,0 +1,44 @@ +/* + * 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.infra.nativetest.jdbc.features.algorithm; + +import org.apache.shardingsphere.sharding.api.sharding.standard.PreciseShardingValue; +import org.apache.shardingsphere.sharding.api.sharding.standard.RangeShardingValue; +import org.apache.shardingsphere.sharding.api.sharding.standard.StandardShardingAlgorithm; + +import java.util.Collection; + +@SuppressWarnings("unused") +public final class ClassBasedInlineShardingAlgorithmFixture implements StandardShardingAlgorithm { + + @Override + public String doSharding(final Collection availableTargetNames, final PreciseShardingValue shardingValue) { + String resultDatabaseName = "ds_" + shardingValue.getValue() % 2; + for (String each : availableTargetNames) { + if (each.equals(resultDatabaseName)) { + return each; + } + } + return null; + } + + @Override + public Collection doSharding(final Collection availableTargetNames, final RangeShardingValue shardingValue) { + throw new RuntimeException("This algorithm class does not support range queries."); + } +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/algorithm/TestQueryAssistedShardingEncryptAlgorithm.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/algorithm/TestQueryAssistedShardingEncryptAlgorithm.java new file mode 100644 index 00000000000000..d47fb24bf567a7 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/algorithm/TestQueryAssistedShardingEncryptAlgorithm.java @@ -0,0 +1,46 @@ +/* + * 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.infra.nativetest.jdbc.features.algorithm; + +import lombok.Getter; +import org.apache.shardingsphere.encrypt.api.context.EncryptContext; +import org.apache.shardingsphere.encrypt.api.encrypt.assisted.AssistedEncryptAlgorithm; + +import java.util.Properties; + +@SuppressWarnings("LombokGetterMayBeUsed") +public final class TestQueryAssistedShardingEncryptAlgorithm implements AssistedEncryptAlgorithm { + + @Getter + private Properties props; + + @Override + public String encrypt(final Object plainValue, final EncryptContext encryptContext) { + return "assistedEncryptValue"; + } + + @Override + public String getType() { + return "assistedTest"; + } + + @Override + public void init(final Properties props) { + this.props = props; + } +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/Address.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/Address.java new file mode 100644 index 00000000000000..530e1eb6d86c69 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/Address.java @@ -0,0 +1,36 @@ +/* + * 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.infra.nativetest.jdbc.features.entity; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; + +@Data +@AllArgsConstructor +@NoArgsConstructor +public class Address implements Serializable { + + private static final long serialVersionUID = 4743102234543827855L; + + private Long addressId; + + private String addressName; +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/Order.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/Order.java new file mode 100644 index 00000000000000..751889802f8bc7 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/Order.java @@ -0,0 +1,42 @@ +/* + * 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.infra.nativetest.jdbc.features.entity; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; + +@Data +@AllArgsConstructor +@NoArgsConstructor +public class Order implements Serializable { + + private static final long serialVersionUID = 8306802022239174861L; + + private long orderId; + + private int orderType; + + private int userId; + + private long addressId; + + private String status; +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/OrderItem.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/OrderItem.java new file mode 100644 index 00000000000000..3c4a00c691f466 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/OrderItem.java @@ -0,0 +1,42 @@ +/* + * 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.infra.nativetest.jdbc.features.entity; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; + +@Data +@AllArgsConstructor +@NoArgsConstructor +public class OrderItem implements Serializable { + + private static final long serialVersionUID = 1332162822494069342L; + + private long orderItemId; + + private long orderId; + + private int userId; + + private String phone; + + private String status; +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/AddressRepository.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/AddressRepository.java new file mode 100644 index 00000000000000..65806f92e12cfe --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/AddressRepository.java @@ -0,0 +1,133 @@ +/* + * 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.infra.nativetest.jdbc.features.repository; + +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Address; + +import javax.sql.DataSource; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.LinkedList; +import java.util.List; + +@SuppressWarnings({"SqlDialectInspection", "SqlNoDataSourceInspection"}) +public final class AddressRepository { + + private final DataSource dataSource; + + public AddressRepository(final DataSource dataSource) { + this.dataSource = dataSource; + } + + /** + * create table t_address if not exists. + * @throws SQLException SQL exception + */ + public void createTableIfNotExists() throws SQLException { + String sql = "CREATE TABLE IF NOT EXISTS t_address (address_id BIGINT NOT NULL, address_name VARCHAR(100) NOT NULL, PRIMARY KEY (address_id))"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * drop table t_address. + * @throws SQLException SQL exception + */ + public void dropTable() throws SQLException { + String sql = "DROP TABLE IF EXISTS t_address"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * truncate table t_address. + * @throws SQLException SQL exception + */ + public void truncateTable() throws SQLException { + String sql = "TRUNCATE TABLE t_address"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * insert something to table t_address. + * @param address address + * @return addressId of the insert statement + * @throws SQLException SQL exception + */ + public Long insert(final Address address) throws SQLException { + String sql = "INSERT INTO t_address (address_id, address_name) VALUES (?, ?)"; + try ( + Connection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(sql)) { + preparedStatement.setLong(1, address.getAddressId()); + preparedStatement.setString(2, address.getAddressName()); + preparedStatement.executeUpdate(); + } + return address.getAddressId(); + } + + /** + * delete by id. + * @param id id + * @throws SQLException SQL exception + */ + public void delete(final Long id) throws SQLException { + String sql = "DELETE FROM t_address WHERE address_id=?"; + try ( + Connection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(sql)) { + preparedStatement.setLong(1, id); + preparedStatement.executeUpdate(); + } + } + + /** + * select all. + * @return list of address + * @throws SQLException SQL exception + */ + public List
selectAll() throws SQLException { + String sql = "SELECT * FROM t_address"; + List
result = new LinkedList<>(); + try ( + Connection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(sql); + ResultSet resultSet = preparedStatement.executeQuery()) { + while (resultSet.next()) { + Address address = new Address(); + address.setAddressId(resultSet.getLong(1)); + address.setAddressName(resultSet.getString(2)); + result.add(address); + } + } + return result; + } +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/OrderItemRepository.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/OrderItemRepository.java new file mode 100644 index 00000000000000..320a0786935df8 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/OrderItemRepository.java @@ -0,0 +1,185 @@ +/* + * 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.infra.nativetest.jdbc.features.repository; + +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.OrderItem; + +import javax.sql.DataSource; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.LinkedList; +import java.util.List; + +@SuppressWarnings({"SqlDialectInspection", "SqlNoDataSourceInspection"}) +public final class OrderItemRepository { + + private final DataSource dataSource; + + public OrderItemRepository(final DataSource dataSource) { + this.dataSource = dataSource; + } + + /** + * create table if not exists. + * @throws SQLException SQL exception + */ + public void createTableIfNotExists() throws SQLException { + String sql = "CREATE TABLE IF NOT EXISTS t_order_item " + + "(order_item_id BIGINT NOT NULL AUTO_INCREMENT, order_id BIGINT NOT NULL, user_id INT NOT NULL, phone VARCHAR(50), status VARCHAR(50), PRIMARY KEY (order_item_id))"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * drop table. + * @throws SQLException SQL exception + */ + public void dropTable() throws SQLException { + String sql = "DROP TABLE IF EXISTS t_order_item"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * truncate table. + * @throws SQLException SQL exception + */ + public void truncateTable() throws SQLException { + String sql = "TRUNCATE TABLE t_order_item"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * create shadow table if not exists. + * @throws SQLException SQL exception + */ + public void createTableIfNotExistsShadow() throws SQLException { + String sql = "CREATE TABLE IF NOT EXISTS t_order_item " + + "(order_item_id BIGINT NOT NULL AUTO_INCREMENT, order_id BIGINT NOT NULL, user_id INT NOT NULL, phone " + + "VARCHAR(50), status VARCHAR(50), PRIMARY KEY (order_item_id)) /* SHARDINGSPHERE_HINT:shadow=true,foo=bar*/"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * drop shadow table. + * @throws SQLException SQL exception + */ + public void dropTableShadow() throws SQLException { + String sql = "DROP TABLE t_order_item /* SHARDINGSPHERE_HINT:shadow=true,foo=bar*/"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * truncate shadow table. + * @throws SQLException SQL exception + */ + public void truncateTableShadow() throws SQLException { + String sql = "TRUNCATE TABLE t_order_item /* SHARDINGSPHERE_HINT:shadow=true,foo=bar*/"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * insert something to table. + * @param orderItem orderItem + * @return orderItemId of the insert statement + * @throws SQLException SQL exception + */ + public Long insert(final OrderItem orderItem) throws SQLException { + String sql = "INSERT INTO t_order_item (order_id, user_id, phone, status) VALUES (?, ?, ?, ?)"; + try ( + Connection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) { + preparedStatement.setLong(1, orderItem.getOrderId()); + preparedStatement.setInt(2, orderItem.getUserId()); + preparedStatement.setString(3, orderItem.getPhone()); + preparedStatement.setString(4, orderItem.getStatus()); + preparedStatement.executeUpdate(); + try (ResultSet resultSet = preparedStatement.getGeneratedKeys()) { + if (resultSet.next()) { + orderItem.setOrderItemId(resultSet.getLong(1)); + } + } + } + return orderItem.getOrderItemId(); + } + + /** + * delete by orderItemId. + * @param orderItemId orderItemId + * @throws SQLException SQL exception + */ + public void delete(final Long orderItemId) throws SQLException { + String sql = "DELETE FROM t_order_item WHERE order_id=?"; + try ( + Connection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(sql)) { + preparedStatement.setLong(1, orderItemId); + preparedStatement.executeUpdate(); + } + } + + /** + * select all. + * @return list of OrderItem + * @throws SQLException SQL exception + */ + public List selectAll() throws SQLException { + String sql = "SELECT i.* FROM t_order o, t_order_item i WHERE o.order_id = i.order_id"; + List result = new LinkedList<>(); + try ( + Connection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(sql); + ResultSet resultSet = preparedStatement.executeQuery()) { + while (resultSet.next()) { + OrderItem orderItem = new OrderItem(); + orderItem.setOrderItemId(resultSet.getLong(1)); + orderItem.setOrderId(resultSet.getLong(2)); + orderItem.setUserId(resultSet.getInt(3)); + orderItem.setPhone(resultSet.getString(4)); + orderItem.setStatus(resultSet.getString(5)); + result.add(orderItem); + } + } + return result; + } +} diff --git a/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/OrderRepository.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/OrderRepository.java new file mode 100644 index 00000000000000..fb5aad9c1bdf24 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/OrderRepository.java @@ -0,0 +1,221 @@ +/* + * 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.infra.nativetest.jdbc.features.repository; + +import org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Order; + +import javax.sql.DataSource; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.LinkedList; +import java.util.List; + +@SuppressWarnings({"SqlDialectInspection", "SqlNoDataSourceInspection"}) +public final class OrderRepository { + + private final DataSource dataSource; + + public OrderRepository(final DataSource dataSource) { + this.dataSource = dataSource; + } + + /** + * create table if not exists. + * @throws SQLException SQL exception + */ + public void createTableIfNotExists() throws SQLException { + String sql = "CREATE TABLE IF NOT EXISTS t_order " + + "(order_id BIGINT NOT NULL AUTO_INCREMENT, order_type INT(11), user_id INT NOT NULL, address_id BIGINT NOT NULL, status VARCHAR(50), PRIMARY KEY (order_id))"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * drop table. + * TODO There is a bug in this function in shadow's unit test and requires additional fixes. + * @throws SQLException SQL exception + */ + public void dropTable() throws SQLException { + String sql = "DROP TABLE IF EXISTS t_order"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * truncate table. + * @throws SQLException SQL exception + */ + public void truncateTable() throws SQLException { + String sql = "TRUNCATE TABLE t_order"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * create shadow table if not exists. + * @throws SQLException SQL exception + */ + public void createTableIfNotExistsShadow() throws SQLException { + String sql = + "CREATE TABLE IF NOT EXISTS t_order (order_id BIGINT NOT NULL AUTO_INCREMENT, order_type INT(11), " + + "user_id INT NOT NULL, address_id BIGINT NOT NULL, status VARCHAR(50), PRIMARY KEY (order_id)) " + + "/* SHARDINGSPHERE_HINT:shadow=true,foo=bar*/"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * drop shadow table. + * @throws SQLException SQL exception + */ + public void dropTableShadow() throws SQLException { + String sql = "DROP TABLE IF EXISTS t_order /* SHARDINGSPHERE_HINT:shadow=true,foo=bar*/"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * truncate shadow table. + * @throws SQLException SQL exception + */ + public void truncateTableShadow() throws SQLException { + String sql = "TRUNCATE TABLE t_order /* SHARDINGSPHERE_HINT:shadow=true,foo=bar*/"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + /** + * select Order from shadow table. + * @return list of Order + * @throws SQLException SQL exception + */ + public List selectShadowOrder() throws SQLException { + String sql = "SELECT * FROM t_order WHERE order_type=1"; + return getOrders(sql); + } + + /** + * delete Order from shadow table. + * @param orderId orderId + * @throws SQLException SQL Exception + */ + public void deleteShadow(final Long orderId) throws SQLException { + String sql = "DELETE FROM t_order WHERE order_id=? AND order_type=1"; + try ( + Connection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(sql)) { + preparedStatement.setLong(1, orderId); + preparedStatement.executeUpdate(); + } + } + + /** + * insert Order to table. + * @param order order + * @return orderId of the insert statement + * @throws SQLException SQL Exception + */ + public Long insert(final Order order) throws SQLException { + String sql = "INSERT INTO t_order (user_id, order_type, address_id, status) VALUES (?, ?, ?, ?)"; + try ( + Connection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) { + preparedStatement.setInt(1, order.getUserId()); + preparedStatement.setInt(2, order.getOrderType()); + preparedStatement.setLong(3, order.getAddressId()); + preparedStatement.setString(4, order.getStatus()); + preparedStatement.executeUpdate(); + try (ResultSet resultSet = preparedStatement.getGeneratedKeys()) { + if (resultSet.next()) { + order.setOrderId(resultSet.getLong(1)); + } + } + } + return order.getOrderId(); + } + + /** + * delete by orderId. + * @param orderId orderId + * @throws SQLException SQL exception + */ + public void delete(final Long orderId) throws SQLException { + String sql = "DELETE FROM t_order WHERE order_id=?"; + try ( + Connection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(sql)) { + preparedStatement.setLong(1, orderId); + preparedStatement.executeUpdate(); + } + } + + /** + * select all. + * @return list of Order + * @throws SQLException SQL exception + */ + public List selectAll() throws SQLException { + return getOrders("SELECT * FROM t_order"); + } + + /** + * get Orders by SQL. + * @param sql SQL + * @return list of Order + * @throws SQLException SQL exception + */ + private List getOrders(final String sql) throws SQLException { + List result = new LinkedList<>(); + try ( + Connection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(sql); + ResultSet resultSet = preparedStatement.executeQuery()) { + while (resultSet.next()) { + Order order = new Order(); + order.setOrderId(resultSet.getLong(1)); + order.setOrderType(resultSet.getInt(2)); + order.setUserId(resultSet.getInt(3)); + order.setAddressId(resultSet.getLong(4)); + order.setStatus(resultSet.getString(5)); + result.add(order); + } + } + return result; + } +} diff --git a/infra/nativetest/src/test/resources/META-INF/native-image/shardingsphere-infra-nativetest-test-image/reflect-config.json b/infra/nativetest/src/test/resources/META-INF/native-image/shardingsphere-infra-nativetest-test-image/reflect-config.json new file mode 100644 index 00000000000000..4aed2e014fdd9d --- /dev/null +++ b/infra/nativetest/src/test/resources/META-INF/native-image/shardingsphere-infra-nativetest-test-image/reflect-config.json @@ -0,0 +1,7 @@ +[ +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.algorithm.sharding.classbased.ClassBasedShardingAlgorithmFactory"}, + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.algorithm.ClassBasedInlineShardingAlgorithmFixture", + "methods":[{"name":"","parameterTypes":[] }] +} +] diff --git a/infra/nativetest/src/test/resources/META-INF/native-image/shardingsphere-infra-nativetest-test-image/resource-config.json b/infra/nativetest/src/test/resources/META-INF/native-image/shardingsphere-infra-nativetest-test-image/resource-config.json new file mode 100644 index 00000000000000..2773c5f2fde1bf --- /dev/null +++ b/infra/nativetest/src/test/resources/META-INF/native-image/shardingsphere-infra-nativetest-test-image/resource-config.json @@ -0,0 +1,21 @@ +{ + "resources":{ + "includes":[{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.nativetest.jdbc.features.EncryptTest"}, + "pattern":"\\Qyaml/encrypt.yaml\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.nativetest.jdbc.features.MaskTest"}, + "pattern":"\\Qyaml/mask.yaml\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.nativetest.jdbc.features.ReadWriteSplittingTest"}, + "pattern":"\\Qyaml/readwrite-splitting.yaml\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.nativetest.jdbc.features.ShadowTest"}, + "pattern":"\\Qyaml/shadow.yaml\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.nativetest.jdbc.features.ShardingTest"}, + "pattern":"\\Qyaml/sharding.yaml\\E" + } + ]}, + "bundles":[] +} diff --git a/infra/nativetest/src/test/resources/META-INF/services/org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm b/infra/nativetest/src/test/resources/META-INF/services/org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm new file mode 100644 index 00000000000000..be8532cc700cbc --- /dev/null +++ b/infra/nativetest/src/test/resources/META-INF/services/org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm @@ -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.infra.nativetest.jdbc.features.algorithm.TestQueryAssistedShardingEncryptAlgorithm diff --git a/infra/nativetest/src/test/resources/yaml/encrypt.yaml b/infra/nativetest/src/test/resources/yaml/encrypt.yaml new file mode 100644 index 00000000000000..5eb2edb87cc195 --- /dev/null +++ b/infra/nativetest/src/test/resources/yaml/encrypt.yaml @@ -0,0 +1,60 @@ +# +# 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. +# + +mode: + type: Standalone + repository: + type: JDBC + +dataSources: + ds_0: + dataSourceClassName: com.zaxxer.hikari.HikariDataSource + driverClassName: org.h2.Driver + jdbcUrl: jdbc:h2:mem:local_encrypt_ds_0;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + +rules: +- !ENCRYPT + tables: + t_order: + columns: + status: + cipher: + name: status + encryptorName: standard_encryptor + assistedQuery: + name: status_assisted + encryptorName: assisted_encryptor + t_order_item: + columns: + phone: + cipher: + name: phone + encryptorName: standard_encryptor + encryptors: + standard_encryptor: + type: AES + props: + aes-key-value: 123456 + assisted_encryptor: + type: assistedTest + props: + aes-key-value: 123456 + +props: + sql-show: true diff --git a/infra/nativetest/src/test/resources/yaml/mask.yaml b/infra/nativetest/src/test/resources/yaml/mask.yaml new file mode 100644 index 00000000000000..6cb5ebed162ecf --- /dev/null +++ b/infra/nativetest/src/test/resources/yaml/mask.yaml @@ -0,0 +1,47 @@ +# +# 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. +# + +mode: + type: Standalone + repository: + type: JDBC + +dataSources: + ds_0: + dataSourceClassName: com.zaxxer.hikari.HikariDataSource + driverClassName: org.h2.Driver + jdbcUrl: jdbc:h2:mem:local_mask_ds_0;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + +rules: +- !MASK + tables: + t_order_item: + columns: + phone: + maskAlgorithm: keep_first_n_last_m_mask + maskAlgorithms: + keep_first_n_last_m_mask: + type: KEEP_FIRST_N_LAST_M + props: + first-n: 3 + last-m: 4 + replace-char: '*' + +props: + sql-show: true \ No newline at end of file diff --git a/infra/nativetest/src/test/resources/yaml/readwrite-splitting.yaml b/infra/nativetest/src/test/resources/yaml/readwrite-splitting.yaml new file mode 100644 index 00000000000000..ea6dde97013bf5 --- /dev/null +++ b/infra/nativetest/src/test/resources/yaml/readwrite-splitting.yaml @@ -0,0 +1,57 @@ +# +# 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. +# + +mode: + type: Standalone + repository: + type: JDBC + +dataSources: + ds_0: + dataSourceClassName: com.zaxxer.hikari.HikariDataSource + driverClassName: org.h2.Driver + jdbcUrl: jdbc:h2:mem:local_readwrite_splitting_ds_0;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + ds_1: + dataSourceClassName: com.zaxxer.hikari.HikariDataSource + driverClassName: org.h2.Driver + jdbcUrl: jdbc:h2:mem:local_readwrite_splitting_ds_1;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + ds_2: + dataSourceClassName: com.zaxxer.hikari.HikariDataSource + driverClassName: org.h2.Driver + jdbcUrl: jdbc:h2:mem:local_readwrite_splitting_ds_2;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + +rules: +- !READWRITE_SPLITTING + # We need to prevent the logical database name, writeDataSourceName and readDataSourceNames from being parsed by + # GroovyShell under Native Image for the read-write separation function. + # That is, switch to another Row Value Expression SPI implementation. + dataSources: + readwrite_ds: + writeDataSourceName: ds_0 + readDataSourceNames: + - ds_1 + - ds_2 + +props: + sql-show: true + diff --git a/infra/nativetest/src/test/resources/yaml/shadow.yaml b/infra/nativetest/src/test/resources/yaml/shadow.yaml new file mode 100644 index 00000000000000..21a23e4204e4d6 --- /dev/null +++ b/infra/nativetest/src/test/resources/yaml/shadow.yaml @@ -0,0 +1,88 @@ +# +# 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. +# + +mode: + type: Standalone + repository: + type: JDBC + +dataSources: + ds_0: + dataSourceClassName: com.zaxxer.hikari.HikariDataSource + driverClassName: org.h2.Driver + jdbcUrl: jdbc:h2:mem:local_shadow_ds_0;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + ds_1: + dataSourceClassName: com.zaxxer.hikari.HikariDataSource + driverClassName: org.h2.Driver + jdbcUrl: jdbc:h2:mem:local_shadow_ds_1;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + +rules: +- !SHADOW + dataSources: + shadow-data-source: + productionDataSourceName: ds_0 + shadowDataSourceName: ds_1 + tables: + t_order: + dataSourceNames: + - shadow-data-source + shadowAlgorithmNames: + - order-type-insert-match-algorithm + - order-type-delete-match-algorithm + - order-type-select-match-algorithm + - sql-hint-algorithm + shadowAlgorithms: + order-type-insert-match-algorithm: + type: VALUE_MATCH + props: + operation: insert + column: order_type + value: "1" + order-type-delete-match-algorithm: + type: VALUE_MATCH + props: + operation: delete + column: order_type + value: "1" + order-type-select-match-algorithm: + type: VALUE_MATCH + props: + operation: select + column: order_type + value: "1" + sql-hint-algorithm: + type: SQL_HINT + props: + shadow: true + foo: bar + defaultShadowAlgorithmName: sql-hint-algorithm + +sqlParser: + sqlCommentParseEnabled: true + sqlStatementCache: + initialCapacity: 128 + maximumSize: 1024 + parseTreeCache: + initialCapacity: 2000 + maximumSize: 65535 + +props: + sql-show: true diff --git a/infra/nativetest/src/test/resources/yaml/sharding.yaml b/infra/nativetest/src/test/resources/yaml/sharding.yaml new file mode 100644 index 00000000000000..b8a4658bd5afc9 --- /dev/null +++ b/infra/nativetest/src/test/resources/yaml/sharding.yaml @@ -0,0 +1,82 @@ +# +# 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. +# + +mode: + type: Standalone + repository: + type: JDBC + +dataSources: + ds_0: + dataSourceClassName: com.zaxxer.hikari.HikariDataSource + driverClassName: org.h2.Driver + jdbcUrl: jdbc:h2:mem:local_sharding_ds_0;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + ds_1: + dataSourceClassName: com.zaxxer.hikari.HikariDataSource + driverClassName: org.h2.Driver + jdbcUrl: jdbc:h2:mem:local_sharding_ds_1;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + ds_2: + dataSourceClassName: com.zaxxer.hikari.HikariDataSource + driverClassName: org.h2.Driver + jdbcUrl: jdbc:h2:mem:local_sharding_ds_2;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + +rules: +- !SHARDING + tables: + t_order: + actualDataNodes: + keyGenerateStrategy: + column: order_id + keyGeneratorName: snowflake + t_order_item: + actualDataNodes: + keyGenerateStrategy: + column: order_item_id + keyGeneratorName: snowflake + defaultDatabaseStrategy: + standard: + shardingColumn: user_id + shardingAlgorithmName: inline + shardingAlgorithms: + # GroovyShell related classes are not available on GraalVM CE 23.0.2 For JDK 17.0.9, + # This CLASS_BASE algorithm class is designed to emulate INLINE's `ds_${user_id % 2}`. + # See https://github.com/oracle/graal/issues/5522 . + inline: + type: CLASS_BASED + props: + strategy: STANDARD + algorithmClassName: org.apache.shardingsphere.infra.nativetest.jdbc.features.algorithm.ClassBasedInlineShardingAlgorithmFixture + keyGenerators: + snowflake: + type: SNOWFLAKE + auditors: + sharding_key_required_auditor: + type: DML_SHARDING_CONDITIONS + +- !BROADCAST + tables: + - t_address + +props: + sql-show: true + diff --git a/infra/pom.xml b/infra/pom.xml index e5b2c38cc7987c..61cf88285b3607 100644 --- a/infra/pom.xml +++ b/infra/pom.xml @@ -44,5 +44,7 @@ session expr util + reachability-metadata + nativetest diff --git a/infra/reachability-metadata/pom.xml b/infra/reachability-metadata/pom.xml new file mode 100644 index 00000000000000..1d578449de5c1a --- /dev/null +++ b/infra/reachability-metadata/pom.xml @@ -0,0 +1,29 @@ + + + + + 4.0.0 + + org.apache.shardingsphere + shardingsphere-infra + 5.4.2-SNAPSHOT + + shardingsphere-infra-reachability-metadata + ${project.artifactId} + + diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/com.github.ben-manes.caffeine/caffeine/2.9.3/reflect-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/com.github.ben-manes.caffeine/caffeine/2.9.3/reflect-config.json new file mode 100644 index 00000000000000..995222a3c6b519 --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/com.github.ben-manes.caffeine/caffeine/2.9.3/reflect-config.json @@ -0,0 +1,62 @@ +[ +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.BBHeader$ReadAndWriteCounterRef"}, + "name":"com.github.benmanes.caffeine.cache.BBHeader$ReadAndWriteCounterRef", + "fields":[{"name":"writeCounter"}] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.BBHeader$ReadCounterRef"}, + "name":"com.github.benmanes.caffeine.cache.BBHeader$ReadCounterRef", + "fields":[{"name":"readCounter"}] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.BLCHeader$DrainStatusRef"}, + "name":"com.github.benmanes.caffeine.cache.BLCHeader$DrainStatusRef", + "fields":[{"name":"drainStatus"}] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.BaseMpscLinkedArrayQueue"}, + "name":"com.github.benmanes.caffeine.cache.BaseMpscLinkedArrayQueueColdProducerFields", + "fields":[{"name":"producerLimit"}] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.BaseMpscLinkedArrayQueue"}, + "name":"com.github.benmanes.caffeine.cache.BaseMpscLinkedArrayQueueConsumerFields", + "fields":[{"name":"consumerIndex"}] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.BaseMpscLinkedArrayQueue"}, + "name":"com.github.benmanes.caffeine.cache.BaseMpscLinkedArrayQueueProducerFields", + "fields":[{"name":"producerIndex"}] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.LocalLoadingCache"}, + "name":"com.github.benmanes.caffeine.cache.CacheLoader", + "methods":[{"name":"loadAll","parameterTypes":["java.lang.Iterable"] }] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.PD"}, + "name":"com.github.benmanes.caffeine.cache.PD", + "fields":[{"name":"value"}] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.NodeFactory"}, + "name":"com.github.benmanes.caffeine.cache.PDMS", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.LocalCacheFactory"}, + "name":"com.github.benmanes.caffeine.cache.SIMS", + "methods":[{"name":"","parameterTypes":["com.github.benmanes.caffeine.cache.Caffeine","com.github.benmanes.caffeine.cache.CacheLoader","boolean"] }] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.StripedBuffer"}, + "name":"com.github.benmanes.caffeine.cache.StripedBuffer", + "fields":[{"name":"tableBusy"}] +}, +{ + "condition":{"typeReachable":"com.github.benmanes.caffeine.cache.StripedBuffer"}, + "name":"java.lang.Thread", + "fields":[{"name":"threadLocalRandomProbe"}] +} +] diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/com.zaxxer/HikariCP/4.0.3/reflect-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/com.zaxxer/HikariCP/4.0.3/reflect-config.json new file mode 100644 index 00000000000000..9022218575148b --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/com.zaxxer/HikariCP/4.0.3/reflect-config.json @@ -0,0 +1,20 @@ +[ +{ + "condition":{"typeReachable":"com.zaxxer.hikari.HikariConfig"}, + "name":"com.zaxxer.hikari.HikariConfig", + "queryAllPublicMethods":true, + "fields":[{"name":"dataSourceProperties"}, {"name":"jdbcUrl"}], + "methods":[{"name":"getCatalog","parameterTypes":[] }, {"name":"getConnectionInitSql","parameterTypes":[] }, {"name":"getConnectionTestQuery","parameterTypes":[] }, {"name":"getConnectionTimeout","parameterTypes":[] }, {"name":"getDataSource","parameterTypes":[] }, {"name":"getDataSourceClassName","parameterTypes":[] }, {"name":"getDataSourceJNDI","parameterTypes":[] }, {"name":"getDataSourceProperties","parameterTypes":[] }, {"name":"getDriverClassName","parameterTypes":[] }, {"name":"getExceptionOverrideClassName","parameterTypes":[] }, {"name":"getHealthCheckProperties","parameterTypes":[] }, {"name":"getHealthCheckRegistry","parameterTypes":[] }, {"name":"getIdleTimeout","parameterTypes":[] }, {"name":"getInitializationFailTimeout","parameterTypes":[] }, {"name":"getJdbcUrl","parameterTypes":[] }, {"name":"getKeepaliveTime","parameterTypes":[] }, {"name":"getLeakDetectionThreshold","parameterTypes":[] }, {"name":"getMaxLifetime","parameterTypes":[] }, {"name":"getMaximumPoolSize","parameterTypes":[] }, {"name":"getMetricRegistry","parameterTypes":[] }, {"name":"getMetricsTrackerFactory","parameterTypes":[] }, {"name":"getMinimumIdle","parameterTypes":[] }, {"name":"getPassword","parameterTypes":[] }, {"name":"getPoolName","parameterTypes":[] }, {"name":"getScheduledExecutor","parameterTypes":[] }, {"name":"getSchema","parameterTypes":[] }, {"name":"getThreadFactory","parameterTypes":[] }, {"name":"getTransactionIsolation","parameterTypes":[] }, {"name":"getUsername","parameterTypes":[] }, {"name":"getValidationTimeout","parameterTypes":[] }, {"name":"isAllowPoolSuspension","parameterTypes":[] }, {"name":"isAutoCommit","parameterTypes":[] }, {"name":"isIsolateInternalQueries","parameterTypes":[] }, {"name":"isReadOnly","parameterTypes":[] }, {"name":"isRegisterMbeans","parameterTypes":[] }, {"name":"setAllowPoolSuspension","parameterTypes":["boolean"] }, {"name":"setAutoCommit","parameterTypes":["boolean"] }, {"name":"setCatalog","parameterTypes":["java.lang.String"] }, {"name":"setClass","parameterTypes":["java.lang.Class"] }, {"name":"setConnectionInitSql","parameterTypes":["java.lang.String"] }, {"name":"setConnectionTestQuery","parameterTypes":["java.lang.String"] }, {"name":"setConnectionTimeout","parameterTypes":["long"] }, {"name":"setDataSource","parameterTypes":["javax.sql.DataSource"] }, {"name":"setDataSourceClassName","parameterTypes":["java.lang.String"] }, {"name":"setDataSourceJNDI","parameterTypes":["java.lang.String"] }, {"name":"setDataSourceProperties","parameterTypes":["java.util.Properties"] }, {"name":"setDriverClassName","parameterTypes":["java.lang.String"] }, {"name":"setExceptionOverrideClassName","parameterTypes":["java.lang.String"] }, {"name":"setHealthCheckProperties","parameterTypes":["java.util.Properties"] }, {"name":"setHealthCheckRegistry","parameterTypes":["java.lang.Object"] }, {"name":"setIdleTimeout","parameterTypes":["long"] }, {"name":"setInitializationFailTimeout","parameterTypes":["long"] }, {"name":"setIsolateInternalQueries","parameterTypes":["boolean"] }, {"name":"setJdbcUrl","parameterTypes":["java.lang.String"] }, {"name":"setKeepaliveTime","parameterTypes":["long"] }, {"name":"setLeakDetectionThreshold","parameterTypes":["long"] }, {"name":"setMaxLifetime","parameterTypes":["long"] }, {"name":"setMaximumPoolSize","parameterTypes":["int"] }, {"name":"setMetricRegistry","parameterTypes":["java.lang.Object"] }, {"name":"setMetricsTrackerFactory","parameterTypes":["com.zaxxer.hikari.metrics.MetricsTrackerFactory"] }, {"name":"setMinimumIdle","parameterTypes":["int"] }, {"name":"setPassword","parameterTypes":["java.lang.String"] }, {"name":"setPoolName","parameterTypes":["java.lang.String"] }, {"name":"setReadOnly","parameterTypes":["boolean"] }, {"name":"setRegisterMbeans","parameterTypes":["boolean"] }, {"name":"setScheduledExecutor","parameterTypes":["java.util.concurrent.ScheduledExecutorService"] }, {"name":"setSchema","parameterTypes":["java.lang.String"] }, {"name":"setThreadFactory","parameterTypes":["java.util.concurrent.ThreadFactory"] }, {"name":"setTransactionIsolation","parameterTypes":["java.lang.String"] }, {"name":"setUsername","parameterTypes":["java.lang.String"] }, {"name":"setValidationTimeout","parameterTypes":["long"] }] +}, +{ + "condition":{"typeReachable":"com.zaxxer.hikari.HikariDataSource"}, + "name":"com.zaxxer.hikari.HikariDataSource", + "fields":[{"name":"dataSourceProperties"}, {"name":"jdbcUrl"}], + "methods":[{"name":"","parameterTypes":[] }, {"name":"getAllowPoolSuspension","parameterTypes":[] }, {"name":"getAutoCommit","parameterTypes":[] }, {"name":"getIsolateInternalQueries","parameterTypes":[] }, {"name":"getReadOnly","parameterTypes":[] }, {"name":"getRegisterMbeans","parameterTypes":[] }, {"name":"isClosed","parameterTypes":[] }, {"name":"isRunning","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"com.zaxxer.hikari.util.PropertyElf"}, + "name":"com.zaxxer.hikari.HikariDataSource", + "methods":[{"name":"getAllowPoolSuspension","parameterTypes":[] }, {"name":"getAutoCommit","parameterTypes":[] }, {"name":"getIsolateInternalQueries","parameterTypes":[] }, {"name":"getReadOnly","parameterTypes":[] }, {"name":"getRegisterMbeans","parameterTypes":[] }] +} +] diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.calcite/calcite-core/1.35.0/reflect-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.calcite/calcite-core/1.35.0/reflect-config.json new file mode 100644 index 00000000000000..5563fa603270ad --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.calcite/calcite-core/1.35.0/reflect-config.json @@ -0,0 +1,797 @@ +[ +{ + "condition":{"typeReachable":"org.apache.calcite.plan.RelOptCluster"}, + "name":"[B" +}, +{ + "condition":{"typeReachable":"org.apache.calcite.plan.RelOptCluster"}, + "name":"[Ljava.lang.String;" +}, +{ + "condition":{"typeReachable":"org.apache.calcite.plan.RelOptCluster"}, + "name":"[Lsun.security.pkcs.SignerInfo;" +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"java.lang.Boolean", + "fields":[{"name":"FALSE"}, {"name":"TRUE"}] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.DataContext", + "methods":[{"name":"get","parameterTypes":["java.lang.String"] }, {"name":"getQueryProvider","parameterTypes":[] }, {"name":"getRootSchema","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.adapter.enumerable.AggregateLambdaFactory", + "methods":[{"name":"accumulatorAdder","parameterTypes":[] }, {"name":"accumulatorInitializer","parameterTypes":[] }, {"name":"resultSelector","parameterTypes":["org.apache.calcite.linq4j.function.Function2"] }, {"name":"singleGroupResultSelector","parameterTypes":["org.apache.calcite.linq4j.function.Function1"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.adapter.enumerable.BasicAggregateLambdaFactory", + "queryAllDeclaredConstructors":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.adapter.enumerable.BasicLazyAccumulator", + "queryAllDeclaredConstructors":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.adapter.enumerable.EnumUtils", + "methods":[{"name":"hopping","parameterTypes":["org.apache.calcite.linq4j.Enumerator","int","long","long","long"] }, {"name":"sessionize","parameterTypes":["org.apache.calcite.linq4j.Enumerator","int","int","long"] }, {"name":"tumbling","parameterTypes":["org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.function.Function1"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.adapter.enumerable.LazyAggregateLambdaFactory", + "queryAllDeclaredConstructors":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.adapter.enumerable.MatchUtils", + "methods":[{"name":"lastWithSymbol","parameterTypes":["java.lang.String","java.util.List","java.util.List","int"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$ArgMinMaxImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$BitOpImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$CollectImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$CountImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$CountWinImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$DenseRankImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$FirstValueImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$FusionImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$GroupingImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$IntersectionImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$LagImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$LastValueImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$LeadImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$ListaggImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$LiteralAggImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$MinMaxImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$ModeImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$NthValueImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$NtileImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$RankImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$RowNumberImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$SingleValueImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.adapter.enumerable.RexImpTable$Builder"}, + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$SumImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.adapter.enumerable.SourceSorter", + "queryAllDeclaredConstructors":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.adapter.java.ReflectiveSchema", + "methods":[{"name":"getTarget","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.adapter.jdbc.JdbcSchema", + "methods":[{"name":"getDataSource","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.avatica.remote.Driver"}, + "name":"org.apache.calcite.avatica.AvaticaJdbc41Factory", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.avatica.util.DateTimeUtils", + "queryAllPublicMethods":true, + "methods":[{"name":"addMonths","parameterTypes":["int","int"] }, {"name":"addMonths","parameterTypes":["long","int"] }, {"name":"dateStringToUnixDate","parameterTypes":["java.lang.String"] }, {"name":"intervalDayTimeToString","parameterTypes":["long","org.apache.calcite.avatica.util.TimeUnitRange","int"] }, {"name":"intervalYearMonthToString","parameterTypes":["int","org.apache.calcite.avatica.util.TimeUnitRange"] }, {"name":"lastDay","parameterTypes":["int"] }, {"name":"subtractMonths","parameterTypes":["long","long"] }, {"name":"timeStringToUnixDate","parameterTypes":["java.lang.String"] }, {"name":"timestampStringToUnixDate","parameterTypes":["java.lang.String"] }, {"name":"unixDateCeil","parameterTypes":["org.apache.calcite.avatica.util.TimeUnitRange","int"] }, {"name":"unixDateExtract","parameterTypes":["org.apache.calcite.avatica.util.TimeUnitRange","long"] }, {"name":"unixDateFloor","parameterTypes":["org.apache.calcite.avatica.util.TimeUnitRange","int"] }, {"name":"unixDateToString","parameterTypes":["int"] }, {"name":"unixTimeToString","parameterTypes":["int"] }, {"name":"unixTimestampCeil","parameterTypes":["org.apache.calcite.avatica.util.TimeUnitRange","long"] }, {"name":"unixTimestampFloor","parameterTypes":["org.apache.calcite.avatica.util.TimeUnitRange","long"] }, {"name":"unixTimestampToString","parameterTypes":["long"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.interpreter.Context", + "fields":[{"name":"root"}, {"name":"values"}] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.interpreter.Row", + "methods":[{"name":"asCopy","parameterTypes":["java.lang.Object[]"] }, {"name":"getObject","parameterTypes":["int"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.interpreter.Scalar", + "methods":[{"name":"execute","parameterTypes":["org.apache.calcite.interpreter.Context"] }, {"name":"execute","parameterTypes":["org.apache.calcite.interpreter.Context","java.lang.Object[]"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.jdbc.Driver"}, + "name":"org.apache.calcite.jdbc.CalciteJdbc41Factory", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.AbstractEnumerable", + "queryAllDeclaredConstructors":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.Enumerable", + "methods":[{"name":"asQueryable","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.EnumerableDefaults", + "methods":[{"name":"antiJoin","parameterTypes":["org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.EqualityComparer","org.apache.calcite.linq4j.function.Predicate2"] }, {"name":"correlateBatchJoin","parameterTypes":["org.apache.calcite.linq4j.JoinType","org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.Function2","org.apache.calcite.linq4j.function.Predicate2","int"] }, {"name":"groupByMultiple","parameterTypes":["org.apache.calcite.linq4j.Enumerable","java.util.List","org.apache.calcite.linq4j.function.Function0","org.apache.calcite.linq4j.function.Function2","org.apache.calcite.linq4j.function.Function2"] }, {"name":"lazyCollectionSpool","parameterTypes":["java.util.Collection","org.apache.calcite.linq4j.Enumerable"] }, {"name":"mergeJoin","parameterTypes":["org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.Predicate2","org.apache.calcite.linq4j.function.Function2","org.apache.calcite.linq4j.JoinType","java.util.Comparator"] }, {"name":"mergeUnion","parameterTypes":["java.util.List","org.apache.calcite.linq4j.function.Function1","java.util.Comparator","boolean","org.apache.calcite.linq4j.function.EqualityComparer"] }, {"name":"nestedLoopJoin","parameterTypes":["org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.function.Predicate2","org.apache.calcite.linq4j.function.Function2","org.apache.calcite.linq4j.JoinType"] }, {"name":"orderBy","parameterTypes":["org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.function.Function1","java.util.Comparator","int","int"] }, {"name":"repeatUnion","parameterTypes":["org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.Enumerable","int","boolean","org.apache.calcite.linq4j.function.EqualityComparer","org.apache.calcite.linq4j.function.Function0"] }, {"name":"semiJoin","parameterTypes":["org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.EqualityComparer","org.apache.calcite.linq4j.function.Predicate2"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.Enumerator", + "methods":[{"name":"close","parameterTypes":[] }, {"name":"current","parameterTypes":[] }, {"name":"moveNext","parameterTypes":[] }, {"name":"reset","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.ExtendedEnumerable", + "methods":[{"name":"aggregate","parameterTypes":["java.lang.Object","org.apache.calcite.linq4j.function.Function2","org.apache.calcite.linq4j.function.Function1"] }, {"name":"asEnumerable","parameterTypes":[] }, {"name":"concat","parameterTypes":["org.apache.calcite.linq4j.Enumerable"] }, {"name":"correlateJoin","parameterTypes":["org.apache.calcite.linq4j.JoinType","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.Function2"] }, {"name":"distinct","parameterTypes":[] }, {"name":"distinct","parameterTypes":["org.apache.calcite.linq4j.function.EqualityComparer"] }, {"name":"except","parameterTypes":["org.apache.calcite.linq4j.Enumerable","boolean"] }, {"name":"foreach","parameterTypes":["org.apache.calcite.linq4j.function.Function1"] }, {"name":"groupBy","parameterTypes":["org.apache.calcite.linq4j.function.Function1"] }, {"name":"groupBy","parameterTypes":["org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.Function0","org.apache.calcite.linq4j.function.Function2","org.apache.calcite.linq4j.function.Function2"] }, {"name":"hashJoin","parameterTypes":["org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.Function2","org.apache.calcite.linq4j.function.EqualityComparer","boolean","boolean","org.apache.calcite.linq4j.function.Predicate2"] }, {"name":"intersect","parameterTypes":["org.apache.calcite.linq4j.Enumerable","boolean"] }, {"name":"into","parameterTypes":["java.util.Collection"] }, {"name":"orderBy","parameterTypes":["org.apache.calcite.linq4j.function.Function1","java.util.Comparator"] }, {"name":"removeAll","parameterTypes":["java.util.Collection"] }, {"name":"select","parameterTypes":["org.apache.calcite.linq4j.function.Function1"] }, {"name":"select","parameterTypes":["org.apache.calcite.linq4j.function.Function2"] }, {"name":"selectMany","parameterTypes":["org.apache.calcite.linq4j.function.Function1"] }, {"name":"skip","parameterTypes":["int"] }, {"name":"sortedGroupBy","parameterTypes":["org.apache.calcite.linq4j.function.Function1","org.apache.calcite.linq4j.function.Function0","org.apache.calcite.linq4j.function.Function2","org.apache.calcite.linq4j.function.Function2","java.util.Comparator"] }, {"name":"take","parameterTypes":["int"] }, {"name":"toList","parameterTypes":[] }, {"name":"union","parameterTypes":["org.apache.calcite.linq4j.Enumerable"] }, {"name":"where","parameterTypes":["org.apache.calcite.linq4j.function.Predicate1"] }, {"name":"where","parameterTypes":["org.apache.calcite.linq4j.function.Predicate2"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.ExtendedQueryable", + "methods":[{"name":"select","parameterTypes":["org.apache.calcite.linq4j.tree.FunctionExpression"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.Linq4j", + "methods":[{"name":"asEnumerable","parameterTypes":["java.lang.Iterable"] }, {"name":"asEnumerable","parameterTypes":["java.lang.Object[]"] }, {"name":"emptyEnumerable","parameterTypes":[] }, {"name":"singletonEnumerable","parameterTypes":["java.lang.Object"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.MemoryFactory$Memory", + "methods":[{"name":"get","parameterTypes":[] }, {"name":"get","parameterTypes":["int"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.Queryable" +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.RawEnumerable", + "methods":[{"name":"enumerator","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.function.Function0", + "methods":[{"name":"apply","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.function.Function1", + "methods":[{"name":"apply","parameterTypes":["java.lang.Object"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.function.Functions", + "methods":[{"name":"all","parameterTypes":["java.util.List","org.apache.calcite.linq4j.function.Predicate1"] }, {"name":"arrayComparer","parameterTypes":[] }, {"name":"exists","parameterTypes":["java.util.List","org.apache.calcite.linq4j.function.Predicate1"] }, {"name":"identityComparer","parameterTypes":[] }, {"name":"identitySelector","parameterTypes":[] }, {"name":"nullsComparator","parameterTypes":["boolean","boolean"] }, {"name":"nullsComparator","parameterTypes":["boolean","boolean","java.util.Comparator"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.linq4j.tree.Primitive", + "methods":[{"name":"asList","parameterTypes":["java.lang.Object"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$AllPredicates", + "methods":[{"name":"getAllPredicates","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$AllPredicates"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$AllPredicates$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Collation", + "methods":[{"name":"collations","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$Collation"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Collation$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ColumnOrigin", + "methods":[{"name":"getColumnOrigins","parameterTypes":["int"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$ColumnOrigin"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ColumnOrigin$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ColumnUniqueness", + "methods":[{"name":"areColumnsUnique","parameterTypes":["org.apache.calcite.util.ImmutableBitSet","boolean"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$ColumnUniqueness"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ColumnUniqueness$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$CumulativeCost", + "methods":[{"name":"getCumulativeCost","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$CumulativeCost"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$CumulativeCost$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$DistinctRowCount", + "methods":[{"name":"getDistinctRowCount","parameterTypes":["org.apache.calcite.util.ImmutableBitSet","org.apache.calcite.rex.RexNode"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$DistinctRowCount"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$DistinctRowCount$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Distribution", + "methods":[{"name":"distribution","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$Distribution"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Distribution$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ExplainVisibility", + "methods":[{"name":"isVisibleInExplain","parameterTypes":["org.apache.calcite.sql.SqlExplainLevel"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$ExplainVisibility"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ExplainVisibility$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ExpressionLineage", + "methods":[{"name":"getExpressionLineage","parameterTypes":["org.apache.calcite.rex.RexNode"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$ExpressionLineage"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ExpressionLineage$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$LowerBoundCost", + "methods":[{"name":"getLowerBoundCost","parameterTypes":["org.apache.calcite.plan.volcano.VolcanoPlanner"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$LowerBoundCost"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$LowerBoundCost$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$MaxRowCount", + "methods":[{"name":"getMaxRowCount","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$MaxRowCount"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$MaxRowCount$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Memory", + "methods":[{"name":"cumulativeMemoryWithinPhase","parameterTypes":[] }, {"name":"cumulativeMemoryWithinPhaseSplit","parameterTypes":[] }, {"name":"memory","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$Memory"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Memory$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$MinRowCount", + "methods":[{"name":"getMinRowCount","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$MinRowCount"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$MinRowCount$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$NodeTypes", + "methods":[{"name":"getNodeTypes","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$NodeTypes"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$NodeTypes$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$NonCumulativeCost", + "methods":[{"name":"getNonCumulativeCost","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$NonCumulativeCost"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$NonCumulativeCost$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Parallelism", + "methods":[{"name":"isPhaseTransition","parameterTypes":[] }, {"name":"splitCount","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$Parallelism"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Parallelism$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$PercentageOriginalRows", + "methods":[{"name":"getPercentageOriginalRows","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$PercentageOriginalRows"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$PercentageOriginalRows$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$PopulationSize", + "methods":[{"name":"getPopulationSize","parameterTypes":["org.apache.calcite.util.ImmutableBitSet"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$PopulationSize"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$PopulationSize$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Predicates", + "methods":[{"name":"getPredicates","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$Predicates"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Predicates$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$RowCount", + "methods":[{"name":"getRowCount","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$RowCount"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$RowCount$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Selectivity", + "methods":[{"name":"getSelectivity","parameterTypes":["org.apache.calcite.rex.RexNode"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$Selectivity"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Selectivity$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Size", + "methods":[{"name":"averageColumnSizes","parameterTypes":[] }, {"name":"averageRowSize","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$Size"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Size$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$TableReferences", + "methods":[{"name":"getTableReferences","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$TableReferences"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$TableReferences$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$UniqueKeys", + "methods":[{"name":"getUniqueKeys","parameterTypes":["boolean"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.BuiltInMetadata$UniqueKeys"}, + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$UniqueKeys$Handler", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.rel.metadata.Metadata", + "methods":[{"name":"rel","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdAllPredicates"}, + "name":"org.apache.calcite.rel.metadata.RelMdAllPredicates", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdCollation"}, + "name":"org.apache.calcite.rel.metadata.RelMdCollation", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdColumnOrigins"}, + "name":"org.apache.calcite.rel.metadata.RelMdColumnOrigins", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdColumnUniqueness"}, + "name":"org.apache.calcite.rel.metadata.RelMdColumnUniqueness", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdDistinctRowCount"}, + "name":"org.apache.calcite.rel.metadata.RelMdDistinctRowCount", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdDistribution"}, + "name":"org.apache.calcite.rel.metadata.RelMdDistribution", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdExplainVisibility"}, + "name":"org.apache.calcite.rel.metadata.RelMdExplainVisibility", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdExpressionLineage"}, + "name":"org.apache.calcite.rel.metadata.RelMdExpressionLineage", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdLowerBoundCost"}, + "name":"org.apache.calcite.rel.metadata.RelMdLowerBoundCost", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdMaxRowCount"}, + "name":"org.apache.calcite.rel.metadata.RelMdMaxRowCount", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdMemory"}, + "name":"org.apache.calcite.rel.metadata.RelMdMemory", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdMinRowCount"}, + "name":"org.apache.calcite.rel.metadata.RelMdMinRowCount", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdNodeTypes"}, + "name":"org.apache.calcite.rel.metadata.RelMdNodeTypes", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdParallelism"}, + "name":"org.apache.calcite.rel.metadata.RelMdParallelism", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdPercentageOriginalRows"}, + "name":"org.apache.calcite.rel.metadata.RelMdPercentageOriginalRows$RelMdCumulativeCost", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdPercentageOriginalRows"}, + "name":"org.apache.calcite.rel.metadata.RelMdPercentageOriginalRows$RelMdNonCumulativeCost", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdPercentageOriginalRows"}, + "name":"org.apache.calcite.rel.metadata.RelMdPercentageOriginalRows$RelMdPercentageOriginalRowsHandler", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdPopulationSize"}, + "name":"org.apache.calcite.rel.metadata.RelMdPopulationSize", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdPredicates"}, + "name":"org.apache.calcite.rel.metadata.RelMdPredicates", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdRowCount"}, + "name":"org.apache.calcite.rel.metadata.RelMdRowCount", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdSelectivity"}, + "name":"org.apache.calcite.rel.metadata.RelMdSelectivity", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdSize"}, + "name":"org.apache.calcite.rel.metadata.RelMdSize", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdTableReferences"}, + "name":"org.apache.calcite.rel.metadata.RelMdTableReferences", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.rel.metadata.RelMdUniqueKeys"}, + "name":"org.apache.calcite.rel.metadata.RelMdUniqueKeys", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.ArrayBindable", + "methods":[{"name":"getElementType","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.BinarySearch", + "methods":[{"name":"lowerBound","parameterTypes":["java.lang.Object[]","java.lang.Object","int","int","java.util.Comparator"] }, {"name":"lowerBound","parameterTypes":["java.lang.Object[]","java.lang.Object","int","int","org.apache.calcite.linq4j.function.Function1","java.util.Comparator"] }, {"name":"upperBound","parameterTypes":["java.lang.Object[]","java.lang.Object","int","int","java.util.Comparator"] }, {"name":"upperBound","parameterTypes":["java.lang.Object[]","java.lang.Object","int","int","org.apache.calcite.linq4j.function.Function1","java.util.Comparator"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.Bindable", + "methods":[{"name":"bind","parameterTypes":["org.apache.calcite.DataContext"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.CompressionFunctions", + "methods":[{"name":"compress","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.Enumerables", + "methods":[{"name":"match","parameterTypes":["org.apache.calcite.linq4j.Enumerable","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.runtime.Matcher","org.apache.calcite.runtime.Enumerables$Emitter","int","int"] }, {"name":"slice0","parameterTypes":["org.apache.calcite.linq4j.Enumerable"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.Enumerables$Emitter", + "methods":[{"name":"emit","parameterTypes":["java.util.List","java.util.List","java.util.List","int","java.util.function.Consumer"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.FlatLists", + "fields":[{"name":"COMPARABLE_EMPTY_LIST"}], + "methods":[{"name":"copyOf","parameterTypes":["java.lang.Comparable[]"] }, {"name":"of","parameterTypes":["java.lang.Object","java.lang.Object"] }, {"name":"of","parameterTypes":["java.lang.Object","java.lang.Object","java.lang.Object"] }, {"name":"of","parameterTypes":["java.lang.Object","java.lang.Object","java.lang.Object","java.lang.Object"] }, {"name":"of","parameterTypes":["java.lang.Object","java.lang.Object","java.lang.Object","java.lang.Object","java.lang.Object"] }, {"name":"of","parameterTypes":["java.lang.Object","java.lang.Object","java.lang.Object","java.lang.Object","java.lang.Object","java.lang.Object"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.FunctionContexts", + "methods":[{"name":"of","parameterTypes":["org.apache.calcite.DataContext","java.lang.Object[]"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.JsonFunctions", + "queryAllPublicMethods":true, + "methods":[{"name":"dejsonize","parameterTypes":["java.lang.String"] }, {"name":"isJsonArray","parameterTypes":["java.lang.String"] }, {"name":"isJsonObject","parameterTypes":["java.lang.String"] }, {"name":"isJsonScalar","parameterTypes":["java.lang.String"] }, {"name":"isJsonValue","parameterTypes":["java.lang.String"] }, {"name":"jsonApiCommonSyntax","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"jsonArray","parameterTypes":["org.apache.calcite.sql.SqlJsonConstructorNullClause"] }, {"name":"jsonArrayAggAdd","parameterTypes":["java.util.List","java.lang.Object","org.apache.calcite.sql.SqlJsonConstructorNullClause"] }, {"name":"jsonDepth","parameterTypes":["java.lang.String"] }, {"name":"jsonExists","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"jsonInsert","parameterTypes":["java.lang.String","java.lang.Object"] }, {"name":"jsonKeys","parameterTypes":["java.lang.String"] }, {"name":"jsonLength","parameterTypes":["java.lang.String"] }, {"name":"jsonObject","parameterTypes":["org.apache.calcite.sql.SqlJsonConstructorNullClause"] }, {"name":"jsonObjectAggAdd","parameterTypes":["java.util.Map","java.lang.String","java.lang.Object","org.apache.calcite.sql.SqlJsonConstructorNullClause"] }, {"name":"jsonPretty","parameterTypes":["java.lang.String"] }, {"name":"jsonQuery","parameterTypes":["java.lang.String","java.lang.String","org.apache.calcite.sql.SqlJsonQueryWrapperBehavior","org.apache.calcite.sql.SqlJsonQueryEmptyOrErrorBehavior","org.apache.calcite.sql.SqlJsonQueryEmptyOrErrorBehavior"] }, {"name":"jsonRemove","parameterTypes":["java.lang.String"] }, {"name":"jsonReplace","parameterTypes":["java.lang.String","java.lang.Object"] }, {"name":"jsonSet","parameterTypes":["java.lang.String","java.lang.Object"] }, {"name":"jsonStorageSize","parameterTypes":["java.lang.String"] }, {"name":"jsonType","parameterTypes":["java.lang.String"] }, {"name":"jsonValue","parameterTypes":["java.lang.String","java.lang.String","org.apache.calcite.sql.SqlJsonValueEmptyOrErrorBehavior","java.lang.Object","org.apache.calcite.sql.SqlJsonValueEmptyOrErrorBehavior","java.lang.Object"] }, {"name":"jsonValueExpression","parameterTypes":["java.lang.String"] }, {"name":"jsonize","parameterTypes":["java.lang.Object"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.Matcher", + "methods":[{"name":"builder","parameterTypes":["org.apache.calcite.runtime.Automaton"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.Matcher$Builder", + "methods":[{"name":"add","parameterTypes":["java.lang.String","java.util.function.Predicate"] }, {"name":"build","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.PairList", + "methods":[{"name":"copyOf","parameterTypes":["java.lang.Object","java.lang.Object","java.lang.Object[]"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.Pattern$PatternBuilder", + "methods":[{"name":"automaton","parameterTypes":[] }, {"name":"build","parameterTypes":[] }, {"name":"seq","parameterTypes":[] }, {"name":"symbol","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.RandomFunction", + "methods":[{"name":"rand","parameterTypes":[] }, {"name":"randInteger","parameterTypes":["int"] }, {"name":"randIntegerSeed","parameterTypes":["int","int"] }, {"name":"randSeed","parameterTypes":["int"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.ResultSetEnumerable", + "methods":[{"name":"createEnricher","parameterTypes":["java.lang.Integer[]","org.apache.calcite.DataContext"] }, {"name":"of","parameterTypes":["javax.sql.DataSource","java.lang.String","org.apache.calcite.linq4j.function.Function1"] }, {"name":"of","parameterTypes":["javax.sql.DataSource","java.lang.String","org.apache.calcite.linq4j.function.Function1","org.apache.calcite.runtime.ResultSetEnumerable$PreparedStatementEnricher"] }, {"name":"setTimeout","parameterTypes":["org.apache.calcite.DataContext"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.SortedMultiMap", + "methods":[{"name":"arrays","parameterTypes":["java.util.Comparator"] }, {"name":"putMulti","parameterTypes":["java.lang.Object","java.lang.Object"] }, {"name":"singletonArrayIterator","parameterTypes":["java.util.Comparator","java.util.List"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.SpatialTypeFunctions", + "methods":[{"name":"ST_GeomFromEWKT","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.SqlFunctions", + "queryAllPublicMethods":true, + "methods":[{"name":"array","parameterTypes":["java.lang.Object[]"] }, {"name":"arrayAppend","parameterTypes":["java.util.List","java.lang.Object"] }, {"name":"arrayExcept","parameterTypes":["java.util.List","java.util.List"] }, {"name":"arrayIntersect","parameterTypes":["java.util.List","java.util.List"] }, {"name":"arrayItemOptional","parameterTypes":["java.util.List","int","int","boolean"] }, {"name":"arrayMax","parameterTypes":["java.util.List"] }, {"name":"arrayMin","parameterTypes":["java.util.List"] }, {"name":"arrayPosition","parameterTypes":["java.util.List","java.lang.Object"] }, {"name":"arrayPrepend","parameterTypes":["java.util.List","java.lang.Object"] }, {"name":"arrayRemove","parameterTypes":["java.util.List","java.lang.Object"] }, {"name":"arrayToList","parameterTypes":["java.sql.Array"] }, {"name":"arrayUnion","parameterTypes":["java.util.List","java.util.List"] }, {"name":"arraysOverlap","parameterTypes":["java.util.List","java.util.List"] }, {"name":"arraysZip","parameterTypes":["java.util.List","java.util.List"] }, {"name":"ascii","parameterTypes":["java.lang.String"] }, {"name":"bitAnd","parameterTypes":["long","long"] }, {"name":"bitLength","parameterTypes":["java.lang.String"] }, {"name":"bitOr","parameterTypes":["long","long"] }, {"name":"bitXor","parameterTypes":["long","long"] }, {"name":"ceil","parameterTypes":["int","int"] }, {"name":"charFromAscii","parameterTypes":["int"] }, {"name":"charFromUtf8","parameterTypes":["int"] }, {"name":"charLength","parameterTypes":["java.lang.String"] }, {"name":"compact","parameterTypes":["java.util.List"] }, {"name":"concat","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"concatMulti","parameterTypes":["java.lang.String[]"] }, {"name":"concatMultiWithNull","parameterTypes":["java.lang.String[]"] }, {"name":"concatMultiWithSeparator","parameterTypes":["java.lang.String[]"] }, {"name":"concatWithNull","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"convertWithCharset","parameterTypes":["java.lang.String","java.lang.String","java.lang.String"] }, {"name":"cosh","parameterTypes":["long"] }, {"name":"currentDate","parameterTypes":["org.apache.calcite.DataContext"] }, {"name":"currentTime","parameterTypes":["org.apache.calcite.DataContext"] }, {"name":"currentTimestamp","parameterTypes":["org.apache.calcite.DataContext"] }, {"name":"customDateAdd","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","int","int"] }, {"name":"customDateCeil","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","int"] }, {"name":"customDateDiff","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","int","int"] }, {"name":"customDateFloor","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","int"] }, {"name":"customTimestampAdd","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","long","long"] }, {"name":"customTimestampCeil","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","long"] }, {"name":"customTimestampDiff","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","long","long"] }, {"name":"customTimestampFloor","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","long"] }, {"name":"dayNameWithDate","parameterTypes":["int","java.util.Locale"] }, {"name":"dayNameWithTimestamp","parameterTypes":["long","java.util.Locale"] }, {"name":"difference","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"distinct","parameterTypes":["java.util.List"] }, {"name":"element","parameterTypes":["java.util.List"] }, {"name":"endsWith","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"flatList","parameterTypes":[] }, {"name":"flatProduct","parameterTypes":["int[]","boolean","org.apache.calcite.runtime.SqlFunctions$FlatProductInputType[]"] }, {"name":"floor","parameterTypes":["int","int"] }, {"name":"formatDate","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","int"] }, {"name":"formatTime","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","int"] }, {"name":"formatTimestamp","parameterTypes":["org.apache.calcite.DataContext","java.lang.String","long"] }, {"name":"fromBase32","parameterTypes":["java.lang.String"] }, {"name":"fromBase64","parameterTypes":["java.lang.String"] }, {"name":"fromHex","parameterTypes":["java.lang.String"] }, {"name":"greater","parameterTypes":["java.lang.Comparable","java.lang.Comparable"] }, {"name":"gt","parameterTypes":["boolean","boolean"] }, {"name":"gtNullable","parameterTypes":["java.lang.Comparable","java.lang.Comparable"] }, {"name":"ilike","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"initcap","parameterTypes":["java.lang.String"] }, {"name":"internalToDate","parameterTypes":["int"] }, {"name":"internalToTime","parameterTypes":["int"] }, {"name":"internalToTimestamp","parameterTypes":["long"] }, {"name":"isASet","parameterTypes":["java.util.Collection"] }, {"name":"isNotFalse","parameterTypes":["java.lang.Boolean"] }, {"name":"isTrue","parameterTypes":["java.lang.Boolean"] }, {"name":"itemOptional","parameterTypes":["java.lang.Object","java.lang.Object"] }, {"name":"left","parameterTypes":["java.lang.String","int"] }, {"name":"lesser","parameterTypes":["java.lang.Comparable","java.lang.Comparable"] }, {"name":"like","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"localTime","parameterTypes":["org.apache.calcite.DataContext"] }, {"name":"localTimestamp","parameterTypes":["org.apache.calcite.DataContext"] }, {"name":"locale","parameterTypes":["org.apache.calcite.DataContext"] }, {"name":"log","parameterTypes":["long","long"] }, {"name":"lower","parameterTypes":["java.lang.String"] }, {"name":"lpad","parameterTypes":["java.lang.String","int","java.lang.String"] }, {"name":"lt","parameterTypes":["boolean","boolean"] }, {"name":"ltNullable","parameterTypes":["java.lang.Comparable","java.lang.Comparable"] }, {"name":"ltrim","parameterTypes":["java.lang.String"] }, {"name":"mapConcat","parameterTypes":["java.util.Map[]"] }, {"name":"mapEntries","parameterTypes":["java.util.Map"] }, {"name":"mapFromArrays","parameterTypes":["java.util.List","java.util.List"] }, {"name":"mapFromEntries","parameterTypes":["java.util.List"] }, {"name":"mapItemOptional","parameterTypes":["java.util.Map","java.lang.Object"] }, {"name":"mapKeys","parameterTypes":["java.util.Map"] }, {"name":"mapValues","parameterTypes":["java.util.Map"] }, {"name":"md5","parameterTypes":["java.lang.String"] }, {"name":"memberOf","parameterTypes":["java.lang.Object","java.util.Collection"] }, {"name":"monthNameWithDate","parameterTypes":["int","java.util.Locale"] }, {"name":"monthNameWithTimestamp","parameterTypes":["long","java.util.Locale"] }, {"name":"multisetExceptAll","parameterTypes":["java.util.Collection","java.util.Collection"] }, {"name":"multisetExceptDistinct","parameterTypes":["java.util.Collection","java.util.Collection"] }, {"name":"multisetIntersectAll","parameterTypes":["java.util.Collection","java.util.Collection"] }, {"name":"multisetIntersectDistinct","parameterTypes":["java.util.Collection","java.util.Collection"] }, {"name":"multisetUnionAll","parameterTypes":["java.util.Collection","java.util.Collection"] }, {"name":"multisetUnionDistinct","parameterTypes":["java.util.Collection","java.util.Collection"] }, {"name":"not","parameterTypes":["java.lang.Boolean"] }, {"name":"nullableAll","parameterTypes":["java.util.List","org.apache.calcite.linq4j.function.Function1"] }, {"name":"nullableExists","parameterTypes":["java.util.List","org.apache.calcite.linq4j.function.Function1"] }, {"name":"octetLength","parameterTypes":["org.apache.calcite.avatica.util.ByteString"] }, {"name":"overlay","parameterTypes":["java.lang.String","java.lang.String","int"] }, {"name":"overlay","parameterTypes":["java.lang.String","java.lang.String","int","int"] }, {"name":"position","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"posixRegex","parameterTypes":["java.lang.String","java.lang.String","boolean"] }, {"name":"regexpReplace","parameterTypes":["java.lang.String","java.lang.String","java.lang.String"] }, {"name":"regexpReplace","parameterTypes":["java.lang.String","java.lang.String","java.lang.String","int"] }, {"name":"regexpReplace","parameterTypes":["java.lang.String","java.lang.String","java.lang.String","int","int"] }, {"name":"regexpReplace","parameterTypes":["java.lang.String","java.lang.String","java.lang.String","int","int","java.lang.String"] }, {"name":"repeat","parameterTypes":["java.lang.Object","java.lang.Integer"] }, {"name":"repeat","parameterTypes":["java.lang.String","int"] }, {"name":"replace","parameterTypes":["java.lang.String","java.lang.String","java.lang.String"] }, {"name":"reverse","parameterTypes":["java.lang.String"] }, {"name":"reverse","parameterTypes":["java.util.List"] }, {"name":"right","parameterTypes":["java.lang.String","int"] }, {"name":"rlike","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"round","parameterTypes":["int","int"] }, {"name":"round","parameterTypes":["long","long"] }, {"name":"rpad","parameterTypes":["java.lang.String","int","java.lang.String"] }, {"name":"rtrim","parameterTypes":["java.lang.String"] }, {"name":"sequenceCurrentValue","parameterTypes":["java.lang.String"] }, {"name":"sequenceNextValue","parameterTypes":["java.lang.String"] }, {"name":"sha1","parameterTypes":["java.lang.String"] }, {"name":"sha256","parameterTypes":["java.lang.String"] }, {"name":"sha512","parameterTypes":["java.lang.String"] }, {"name":"similar","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"sinh","parameterTypes":["long"] }, {"name":"slice","parameterTypes":["java.util.List"] }, {"name":"sortArray","parameterTypes":["java.util.List","boolean"] }, {"name":"soundex","parameterTypes":["java.lang.String"] }, {"name":"space","parameterTypes":["int"] }, {"name":"startsWith","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"strToMap","parameterTypes":["java.lang.String","java.lang.String","java.lang.String"] }, {"name":"strcmp","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"structAccess","parameterTypes":["java.lang.Object","int","java.lang.String"] }, {"name":"submultisetOf","parameterTypes":["java.util.Collection","java.util.Collection"] }, {"name":"substring","parameterTypes":["java.lang.String","int","int"] }, {"name":"systemUser","parameterTypes":["org.apache.calcite.DataContext"] }, {"name":"tanh","parameterTypes":["long"] }, {"name":"throwUnless","parameterTypes":["boolean","java.lang.String"] }, {"name":"timeWithLocalTimeZoneToString","parameterTypes":["int","java.util.TimeZone"] }, {"name":"timeWithLocalTimeZoneToTime","parameterTypes":["int","java.util.TimeZone"] }, {"name":"timeWithLocalTimeZoneToTimestamp","parameterTypes":["java.lang.String","int","java.util.TimeZone"] }, {"name":"timeWithLocalTimeZoneToTimestampWithLocalTimeZone","parameterTypes":["java.lang.String","int"] }, {"name":"timeZone","parameterTypes":["org.apache.calcite.DataContext"] }, {"name":"timestampToDate","parameterTypes":["long"] }, {"name":"timestampWithLocalTimeZoneToDate","parameterTypes":["long","java.util.TimeZone"] }, {"name":"timestampWithLocalTimeZoneToString","parameterTypes":["long","java.util.TimeZone"] }, {"name":"timestampWithLocalTimeZoneToTime","parameterTypes":["long","java.util.TimeZone"] }, {"name":"timestampWithLocalTimeZoneToTimeWithLocalTimeZone","parameterTypes":["long"] }, {"name":"timestampWithLocalTimeZoneToTimestamp","parameterTypes":["long","java.util.TimeZone"] }, {"name":"toBase32","parameterTypes":["java.lang.String"] }, {"name":"toBase64","parameterTypes":["java.lang.String"] }, {"name":"toBoolean","parameterTypes":["java.lang.String"] }, {"name":"toChar","parameterTypes":["long","java.lang.String"] }, {"name":"toHex","parameterTypes":["org.apache.calcite.avatica.util.ByteString"] }, {"name":"toInt","parameterTypes":["java.sql.Date"] }, {"name":"toInt","parameterTypes":["java.sql.Date","java.util.TimeZone"] }, {"name":"toInt","parameterTypes":["java.sql.Time"] }, {"name":"toIntOptional","parameterTypes":["java.sql.Date"] }, {"name":"toIntOptional","parameterTypes":["java.sql.Date","java.util.TimeZone"] }, {"name":"toIntOptional","parameterTypes":["java.sql.Time"] }, {"name":"toLong","parameterTypes":["java.sql.Timestamp"] }, {"name":"toLong","parameterTypes":["java.sql.Timestamp","java.util.TimeZone"] }, {"name":"toLongOptional","parameterTypes":["java.sql.Timestamp"] }, {"name":"toLongOptional","parameterTypes":["java.sql.Timestamp","java.util.TimeZone"] }, {"name":"toString","parameterTypes":["boolean"] }, {"name":"toTimeWithLocalTimeZone","parameterTypes":["java.lang.String"] }, {"name":"toTimeWithLocalTimeZone","parameterTypes":["java.lang.String","java.util.TimeZone"] }, {"name":"toTimestampWithLocalTimeZone","parameterTypes":["java.lang.String"] }, {"name":"toTimestampWithLocalTimeZone","parameterTypes":["java.lang.String","java.util.TimeZone"] }, {"name":"translate3","parameterTypes":["java.lang.String","java.lang.String","java.lang.String"] }, {"name":"translateWithCharset","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"trim","parameterTypes":["boolean","boolean","java.lang.String","java.lang.String","boolean"] }, {"name":"truncate","parameterTypes":["java.lang.String","int"] }, {"name":"truncateOrPad","parameterTypes":["java.lang.String","int"] }, {"name":"upper","parameterTypes":["java.lang.String"] }, {"name":"user","parameterTypes":["org.apache.calcite.DataContext"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.Utilities", + "methods":[{"name":"compare","parameterTypes":["java.lang.Comparable","java.lang.Comparable"] }, {"name":"compare","parameterTypes":["java.lang.Comparable","java.lang.Comparable","java.util.Comparator"] }, {"name":"compareNullsFirst","parameterTypes":["java.lang.Comparable","java.lang.Comparable"] }, {"name":"compareNullsFirst","parameterTypes":["java.lang.Comparable","java.lang.Comparable","java.util.Comparator"] }, {"name":"compareNullsLast","parameterTypes":["java.lang.Comparable","java.lang.Comparable"] }, {"name":"compareNullsLast","parameterTypes":["java.lang.Comparable","java.lang.Comparable","java.util.Comparator"] }, {"name":"hash","parameterTypes":["int","java.lang.Object"] }, {"name":"patternBuilder","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.runtime.XmlFunctions", + "methods":[{"name":"existsNode","parameterTypes":["java.lang.String","java.lang.String","java.lang.String"] }, {"name":"extractValue","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"extractXml","parameterTypes":["java.lang.String","java.lang.String","java.lang.String"] }, {"name":"xmlTransform","parameterTypes":["java.lang.String","java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.schema.ModifiableTable", + "methods":[{"name":"getModifiableCollection","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.schema.QueryableTable", + "methods":[{"name":"asQueryable","parameterTypes":["org.apache.calcite.linq4j.QueryProvider","org.apache.calcite.schema.SchemaPlus","java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.schema.ScannableTable", + "methods":[{"name":"scan","parameterTypes":["org.apache.calcite.DataContext"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.schema.Schema", + "methods":[{"name":"getSubSchema","parameterTypes":["java.lang.String"] }, {"name":"getTable","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.schema.SchemaPlus", + "methods":[{"name":"add","parameterTypes":["java.lang.String","org.apache.calcite.schema.Table"] }, {"name":"removeTable","parameterTypes":["java.lang.String"] }, {"name":"unwrap","parameterTypes":["java.lang.Class"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.linq4j.tree.Types"}, + "name":"org.apache.calcite.schema.Schemas", + "methods":[{"name":"enumerable","parameterTypes":["org.apache.calcite.schema.FilterableTable","org.apache.calcite.DataContext"] }, {"name":"enumerable","parameterTypes":["org.apache.calcite.schema.ProjectableFilterableTable","org.apache.calcite.DataContext"] }, {"name":"enumerable","parameterTypes":["org.apache.calcite.schema.ScannableTable","org.apache.calcite.DataContext"] }, {"name":"queryable","parameterTypes":["org.apache.calcite.DataContext","org.apache.calcite.schema.SchemaPlus","java.lang.Class","java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.calcite.sql.fun.SqlLibraryOperatorTableFactory"}, + "name":"org.apache.calcite.sql.fun.SqlLibraryOperators", + "allPublicFields":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.sql.util.ReflectiveSqlOperatorTable"}, + "name":"org.apache.calcite.sql.fun.SqlStdOperatorTable", + "allPublicFields":true +}, +{ + "condition":{"typeReachable":"org.apache.calcite.sql2rel.ReflectiveConvertletTable"}, + "name":"org.apache.calcite.sql2rel.StandardConvertletTable", + "queryAllPublicMethods":true +} +] diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.groovy/groovy/4.0.10/reflect-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.groovy/groovy/4.0.10/reflect-config.json new file mode 100644 index 00000000000000..5449d84e76d290 --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.groovy/groovy/4.0.10/reflect-config.json @@ -0,0 +1,250 @@ +[ +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.io.FileType" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"groovy.lang.Buildable", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.Closure" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.EmptyRange" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"groovy.lang.ExpandoMetaClass", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.GString" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.stdclasses.CachedClosureClass"}, + "name":"groovy.lang.GroovyCallable", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.GroovyObject" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.stdclasses.CachedClosureClass"}, + "name":"groovy.lang.GroovyObject", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.IntRange" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.ListWithDefault" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.MetaClass" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"groovy.lang.MetaClass", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"groovy.lang.MetaObjectProtocol", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.MetaProperty" +}, +{ + "condition":{"typeReachable":"groovy.lang.MetaClassImpl"}, + "name":"groovy.lang.MutableMetaClass", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.ObjectRange" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.Range" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.SpreadMap" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.Writable" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"groovy.lang.Writable", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.lang.groovydoc.Groovydoc" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"groovy.runtime.metaclass.CustomMetaClassCreationHandle" +}, +{ + "condition":{"typeReachable":"groovy.lang.Binding"}, + "name":"groovy.runtime.metaclass.groovy.lang.BindingMetaClass" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"groovy.runtime.metaclass.groovy.lang.ExpandoMetaClassMetaClass" +}, +{ + "condition":{"typeReachable":"groovy.lang.GroovyShell"}, + "name":"groovy.runtime.metaclass.groovy.lang.GroovyShellMetaClass" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"groovy.util.BufferedIterator" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"java.lang.Thread" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"org.codehaus.groovy.runtime.GStringImpl" +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.reflection.GeneratedMetaMethod$DgmMethodRecord"}, + "name":"org.codehaus.groovy.runtime.NullObject" +}, +{ + "condition":{"typeReachable":"groovy.lang.MetaClassImpl"}, + "name":"org.codehaus.groovy.runtime.callsite.CallSite", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.NumberNumberDiv", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.NumberNumberMinus", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.NumberNumberMultiply", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.NumberNumberPlus", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.BooleanArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.BooleanArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ByteArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ByteArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.CharacterArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.CharacterArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.DoubleArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.DoubleArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.FloatArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.FloatArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.IntegerArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.IntegerArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.LongArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.LongArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ObjectArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ObjectArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ShortArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl"}, + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ShortArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.codehaus.groovy.vmplugin.VMPluginFactory"}, + "name":"org.codehaus.groovy.vmplugin.v16.Java16", + "methods":[{"name":"","parameterTypes":[] }] +} +] diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere.elasticjob/elasticjob-lite-core/3.0.4/reflect-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere.elasticjob/elasticjob-lite-core/3.0.4/reflect-config.json new file mode 100644 index 00000000000000..0f72d7a24a1073 --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere.elasticjob/elasticjob-lite-core/3.0.4/reflect-config.json @@ -0,0 +1,80 @@ +[ +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.executor.ElasticJobExecutor"}, + "name":"java.util.Properties", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.failover.FailoverListenerManager"}, + "name":"java.util.Properties", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.reconcile.ReconcileService"}, + "name":"java.util.Properties", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.sharding.ShardingListenerManager$ListenServersChangedJobListener"}, + "name":"java.util.Properties", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.sharding.ShardingListenerManager$ShardingTotalCountChangedJobListener"}, + "name":"java.util.Properties", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.instance.InstanceNode"}, + "name":"org.apache.shardingsphere.elasticjob.infra.handler.sharding.JobInstance", + "allDeclaredFields":true, + "methods":[{"name":"getJobInstanceId","parameterTypes":[] }, {"name":"getLabels","parameterTypes":[] }, {"name":"getServerIp","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.executor.ElasticJobExecutor"}, + "name":"org.apache.shardingsphere.elasticjob.infra.pojo.JobConfigurationPOJO", + "methods":[{"name":"setCron","parameterTypes":["java.lang.String"] }, {"name":"setProps","parameterTypes":["java.util.Properties"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.infra.yaml.YamlEngine"}, + "name":"org.apache.shardingsphere.elasticjob.infra.pojo.JobConfigurationPOJO", + "allDeclaredFields":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setDescription","parameterTypes":["java.lang.String"] }, {"name":"setDisabled","parameterTypes":["boolean"] }, {"name":"setFailover","parameterTypes":["boolean"] }, {"name":"setJobName","parameterTypes":["java.lang.String"] }, {"name":"setJobParameter","parameterTypes":["java.lang.String"] }, {"name":"setMaxTimeDiffSeconds","parameterTypes":["int"] }, {"name":"setMisfire","parameterTypes":["boolean"] }, {"name":"setMonitorExecution","parameterTypes":["boolean"] }, {"name":"setOverwrite","parameterTypes":["boolean"] }, {"name":"setReconcileIntervalMinutes","parameterTypes":["int"] }, {"name":"setShardingItemParameters","parameterTypes":["java.lang.String"] }, {"name":"setShardingTotalCount","parameterTypes":["int"] }, {"name":"setStaticSharding","parameterTypes":["boolean"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.api.bootstrap.impl.ScheduleJobBootstrap"}, + "name":"org.apache.shardingsphere.elasticjob.infra.pojo.JobConfigurationPOJO", + "methods":[{"name":"setCron","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.config.ConfigurationService"}, + "name":"org.apache.shardingsphere.elasticjob.infra.pojo.JobConfigurationPOJO", + "allDeclaredFields":true, + "methods":[{"name":"getCron","parameterTypes":[] }, {"name":"getDescription","parameterTypes":[] }, {"name":"getJobErrorHandlerType","parameterTypes":[] }, {"name":"getJobExecutorServiceHandlerType","parameterTypes":[] }, {"name":"getJobExtraConfigurations","parameterTypes":[] }, {"name":"getJobListenerTypes","parameterTypes":[] }, {"name":"getJobName","parameterTypes":[] }, {"name":"getJobParameter","parameterTypes":[] }, {"name":"getJobShardingStrategyType","parameterTypes":[] }, {"name":"getLabel","parameterTypes":[] }, {"name":"getMaxTimeDiffSeconds","parameterTypes":[] }, {"name":"getProps","parameterTypes":[] }, {"name":"getReconcileIntervalMinutes","parameterTypes":[] }, {"name":"getShardingItemParameters","parameterTypes":[] }, {"name":"getShardingTotalCount","parameterTypes":[] }, {"name":"getTimeZone","parameterTypes":[] }, {"name":"isDisabled","parameterTypes":[] }, {"name":"isFailover","parameterTypes":[] }, {"name":"isMisfire","parameterTypes":[] }, {"name":"isMonitorExecution","parameterTypes":[] }, {"name":"isOverwrite","parameterTypes":[] }, {"name":"isStaticSharding","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.failover.FailoverListenerManager"}, + "name":"org.apache.shardingsphere.elasticjob.infra.pojo.JobConfigurationPOJO", + "methods":[{"name":"setCron","parameterTypes":["java.lang.String"] }, {"name":"setProps","parameterTypes":["java.util.Properties"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.reconcile.ReconcileService"}, + "name":"org.apache.shardingsphere.elasticjob.infra.pojo.JobConfigurationPOJO", + "methods":[{"name":"setCron","parameterTypes":["java.lang.String"] }, {"name":"setProps","parameterTypes":["java.util.Properties"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.sharding.ShardingListenerManager$ListenServersChangedJobListener"}, + "name":"org.apache.shardingsphere.elasticjob.infra.pojo.JobConfigurationPOJO", + "methods":[{"name":"setCron","parameterTypes":["java.lang.String"] }, {"name":"setProps","parameterTypes":["java.util.Properties"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.sharding.ShardingListenerManager$ShardingTotalCountChangedJobListener"}, + "name":"org.apache.shardingsphere.elasticjob.infra.pojo.JobConfigurationPOJO", + "methods":[{"name":"setCron","parameterTypes":["java.lang.String"] }, {"name":"setProps","parameterTypes":["java.util.Properties"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.schedule.JobScheduler"}, + "name":"org.apache.shardingsphere.elasticjob.lite.internal.schedule.JobShutdownHookPlugin", + "methods":[{"name":"","parameterTypes":[] }, {"name":"setCleanShutdown","parameterTypes":["boolean"] }] +} +] diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere.elasticjob/elasticjob-lite-core/3.0.4/resource-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere.elasticjob/elasticjob-lite-core/3.0.4/resource-config.json new file mode 100644 index 00000000000000..cba6a606abc03b --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere.elasticjob/elasticjob-lite-core/3.0.4/resource-config.json @@ -0,0 +1,29 @@ +{ + "resources":{ + "includes":[{ + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.schedule.JobScheduler"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.elasticjob.error.handler.JobErrorHandlerPropertiesValidator\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.error.handler.JobErrorHandlerFactory"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.elasticjob.error.handler.JobErrorHandler\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.executor.item.JobItemExecutorFactory"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.elasticjob.executor.item.impl.ClassedJobItemExecutor\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.executor.item.JobItemExecutorFactory"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.elasticjob.executor.item.impl.TypedJobItemExecutor\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.executor.context.ExecutorContext"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.elasticjob.infra.context.Reloadable\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.infra.handler.threadpool.JobExecutorServiceHandlerFactory"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.elasticjob.infra.handler.threadpool.JobExecutorServiceHandler\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.lite.internal.setup.JobClassNameProviderFactory"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.elasticjob.lite.internal.setup.JobClassNameProvider\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.elasticjob.reg.exception.RegExceptionHandler"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.elasticjob.reg.exception.IgnoredExceptionProvider\\E" + }]}, + "bundles":[] +} diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/reflect-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/reflect-config.json new file mode 100644 index 00000000000000..dcc0a39e137ac2 --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/reflect-config.json @@ -0,0 +1,706 @@ +[ +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationPlannerUtils"}, + "name":"[B" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.datasource.pool.CatalogSwitchableDataSource"}, + "name":"[Lcom.zaxxer.hikari.util.ConcurrentBag$IConcurrentBagEntry;" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.repository.standalone.jdbc.JDBCRepository"}, + "name":"[Lcom.zaxxer.hikari.util.ConcurrentBag$IConcurrentBagEntry;" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationPlannerUtils"}, + "name":"[Ljava.lang.String;" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.database.DatabaseTypeEngine"}, + "name":"[Ljava.sql.Statement;" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.state.datasource.DataSourceStateManager"}, + "name":"[Ljava.sql.Statement;" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.repository.standalone.jdbc.JDBCRepository"}, + "name":"[Ljava.sql.Statement;" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationPlannerUtils"}, + "name":"[Lsun.security.pkcs.SignerInfo;" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.expr.groovy.GroovyInlineExpressionParser"}, + "name":"java.lang.Boolean" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.expr.groovy.GroovyInlineExpressionParser"}, + "name":"java.lang.Thread" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.parser.sql.SQLStatementParserEngineFactory"}, + "name":"java.lang.Thread", + "fields":[{"name":"threadLocalRandomProbe"}] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.util.yaml.YamlEngine"}, + "name":"java.util.Properties", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.authority.rule.AuthorityRule"}, + "name":"org.apache.shardingsphere.authority.provider.database.DatabasePermittedAuthorityRegistryProvider", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.authority.rule.AuthorityRule"}, + "name":"org.apache.shardingsphere.authority.provider.simple.AllPermittedAuthorityRegistryProvider", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.authority.yaml.config.YamlAuthorityRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.broadcast.yaml.config.YamlBroadcastRuleConfiguration"}, + "name":"org.apache.shardingsphere.broadcast.yaml.config.YamlBroadcastRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setTables","parameterTypes":["java.util.Collection"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.broadcast.yaml.swapper.NewYamlBroadcastRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.broadcast.yaml.config.YamlBroadcastRuleConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getTables","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.broadcast.yaml.config.YamlBroadcastRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.repository.standalone.jdbc.JDBCRepository"}, + "name":"org.apache.shardingsphere.driver.ShardingSphereDriver" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.driver.api.yaml.YamlJDBCConfiguration"}, + "name":"org.apache.shardingsphere.driver.api.yaml.YamlJDBCConfiguration", + "methods":[{"name":"setSqlParser","parameterTypes":["org.apache.shardingsphere.parser.yaml.config.YamlSQLParserRuleConfiguration"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.util.yaml.YamlEngine"}, + "name":"org.apache.shardingsphere.driver.api.yaml.YamlJDBCConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setDataSources","parameterTypes":["java.util.Map"] }, {"name":"setMode","parameterTypes":["org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlModeConfiguration"] }, {"name":"setProps","parameterTypes":["java.util.Properties"] }, {"name":"setRules","parameterTypes":["java.util.Collection"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.encrypt.rule.EncryptRule"}, + "name":"org.apache.shardingsphere.encrypt.algorithm.assisted.MD5AssistedEncryptAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.encrypt.rule.EncryptRule"}, + "name":"org.apache.shardingsphere.encrypt.algorithm.standard.AESEncryptAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.encrypt.yaml.config.YamlCompatibleEncryptRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.encrypt.yaml.config.YamlEncryptRuleConfiguration"}, + "name":"org.apache.shardingsphere.encrypt.yaml.config.YamlEncryptRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setEncryptors","parameterTypes":["java.util.Map"] }, {"name":"setTables","parameterTypes":["java.util.Map"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.encrypt.yaml.config.YamlEncryptRuleConfiguration" +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptColumnItemRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getEncryptorName","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }, {"name":"setEncryptorName","parameterTypes":["java.lang.String"] }, {"name":"setName","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptColumnRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getAssistedQuery","parameterTypes":[] }, {"name":"getCipher","parameterTypes":[] }, {"name":"getLikeQuery","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }, {"name":"setAssistedQuery","parameterTypes":["org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptColumnItemRuleConfiguration"] }, {"name":"setCipher","parameterTypes":["org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptColumnItemRuleConfiguration"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptTableRuleConfiguration"}, + "name":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptTableRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setColumns","parameterTypes":["java.util.Map"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.encrypt.yaml.swapper.NewYamlEncryptRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptTableRuleConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getColumns","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.globalclock.core.yaml.config.YamlGlobalClockRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.parser.cache.SQLStatementCacheBuilder"}, + "name":"org.apache.shardingsphere.infra.parser.cache.SQLStatementCacheLoader" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.encrypt.yaml.swapper.NewYamlEncryptRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.algorithm.YamlAlgorithmConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getProps","parameterTypes":[] }, {"name":"getType","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.pojo.algorithm.YamlAlgorithmConfiguration"}, + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.algorithm.YamlAlgorithmConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setProps","parameterTypes":["java.util.Properties"] }, {"name":"setType","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.yaml.swapper.NewYamlMaskRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.algorithm.YamlAlgorithmConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getProps","parameterTypes":[] }, {"name":"getType","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.shadow.yaml.swapper.NewYamlShadowRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.algorithm.YamlAlgorithmConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getProps","parameterTypes":[] }, {"name":"getType","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.yaml.swapper.NewYamlShardingRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.algorithm.YamlAlgorithmConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getProps","parameterTypes":[] }, {"name":"getType","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.util.yaml.YamlEngine"}, + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlModeConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setRepository","parameterTypes":["org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlPersistRepositoryConfiguration"] }, {"name":"setType","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.util.yaml.YamlEngine"}, + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlPersistRepositoryConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setType","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.util.yaml.constructor.ShardingSphereYamlConstructor"}, + "name":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.util.yaml.representer.ShardingSphereYamlRepresenter"}, + "name":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.metadata.persist.service.schema.NewTableMetaDataPersistService"}, + "name":"org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereTable", + "allDeclaredFields":true, + "methods":[{"name":"getColumns","parameterTypes":[] }, {"name":"getConstraints","parameterTypes":[] }, {"name":"getIndexes","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.logging.yaml.config.YamlLoggingRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.rule.MaskRule"}, + "name":"org.apache.shardingsphere.mask.algorithm.cover.KeepFirstNLastMMaskAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.rule.MaskRule"}, + "name":"org.apache.shardingsphere.mask.algorithm.cover.KeepFromXToYMaskAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.rule.MaskRule"}, + "name":"org.apache.shardingsphere.mask.algorithm.cover.MaskAfterSpecialCharsAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.rule.MaskRule"}, + "name":"org.apache.shardingsphere.mask.algorithm.cover.MaskBeforeSpecialCharsAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.rule.MaskRule"}, + "name":"org.apache.shardingsphere.mask.algorithm.cover.MaskFirstNLastMMaskAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.rule.MaskRule"}, + "name":"org.apache.shardingsphere.mask.algorithm.cover.MaskFromXToYMaskAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.rule.MaskRule"}, + "name":"org.apache.shardingsphere.mask.algorithm.hash.MD5MaskAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.rule.MaskRule"}, + "name":"org.apache.shardingsphere.mask.algorithm.replace.GenericTableRandomReplaceAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.mask.yaml.config.YamlMaskRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.yaml.config.YamlMaskRuleConfiguration"}, + "name":"org.apache.shardingsphere.mask.yaml.config.YamlMaskRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setMaskAlgorithms","parameterTypes":["java.util.Map"] }, {"name":"setTables","parameterTypes":["java.util.Map"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskColumnRuleConfiguration"}, + "name":"org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskColumnRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getLogicColumn","parameterTypes":[] }, {"name":"getMaskAlgorithm","parameterTypes":[] }, {"name":"setMaskAlgorithm","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskTableRuleConfiguration"}, + "name":"org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskTableRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setColumns","parameterTypes":["java.util.Map"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mask.yaml.swapper.NewYamlMaskRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskTableRuleConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getColumns","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.util.eventbus.EventBusContext"}, + "name":"org.apache.shardingsphere.mode.manager.standalone.subscriber.StandaloneProcessSubscriber", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.util.eventbus.EventBusContext"}, + "name":"org.apache.shardingsphere.mode.process.ProcessSubscriber", + "queryAllDeclaredMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.manager.standalone.NewStandaloneContextManagerBuilder"}, + "name":"org.apache.shardingsphere.mode.repository.standalone.jdbc.JDBCRepository", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.repository.standalone.jdbc.sql.JDBCRepositorySQLLoader$2"}, + "name":"org.apache.shardingsphere.mode.repository.standalone.jdbc.sql.JDBCRepositorySQL", + "allDeclaredFields":true, + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserCacheOptionRuleConfiguration"}, + "name":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserCacheOptionRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getInitialCapacity","parameterTypes":[] }, {"name":"getMaximumSize","parameterTypes":[] }, {"name":"setInitialCapacity","parameterTypes":["int"] }, {"name":"setMaximumSize","parameterTypes":["long"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserRuleConfiguration"}, + "name":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setParseTreeCache","parameterTypes":["org.apache.shardingsphere.parser.yaml.config.YamlSQLParserCacheOptionRuleConfiguration"] }, {"name":"setSqlCommentParseEnabled","parameterTypes":["boolean"] }, {"name":"setSqlStatementCache","parameterTypes":["org.apache.shardingsphere.parser.yaml.config.YamlSQLParserCacheOptionRuleConfiguration"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.parser.yaml.swapper.NewYamlSQLParserRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserRuleConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getParseTreeCache","parameterTypes":[] }, {"name":"getSqlStatementCache","parameterTypes":[] }, {"name":"isSqlCommentParseEnabled","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule"}, + "name":"org.apache.shardingsphere.readwritesplitting.algorithm.loadbalance.RandomReadQueryLoadBalanceAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule"}, + "name":"org.apache.shardingsphere.readwritesplitting.algorithm.loadbalance.RoundRobinReadQueryLoadBalanceAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule"}, + "name":"org.apache.shardingsphere.readwritesplitting.algorithm.loadbalance.WeightReadQueryLoadBalanceAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.readwritesplitting.yaml.config.YamlReadwriteSplittingRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.readwritesplitting.yaml.config.YamlReadwriteSplittingRuleConfiguration"}, + "name":"org.apache.shardingsphere.readwritesplitting.yaml.config.YamlReadwriteSplittingRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setDataSources","parameterTypes":["java.util.Map"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.readwritesplitting.yaml.config.rule.YamlReadwriteSplittingDataSourceRuleConfiguration"}, + "name":"org.apache.shardingsphere.readwritesplitting.yaml.config.rule.YamlReadwriteSplittingDataSourceRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setReadDataSourceNames","parameterTypes":["java.util.List"] }, {"name":"setWriteDataSourceName","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.readwritesplitting.yaml.swapper.NewYamlReadwriteSplittingRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.readwritesplitting.yaml.config.rule.YamlReadwriteSplittingDataSourceRuleConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getLoadBalancerName","parameterTypes":[] }, {"name":"getReadDataSourceNames","parameterTypes":[] }, {"name":"getTransactionalReadQueryStrategy","parameterTypes":[] }, {"name":"getWriteDataSourceName","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.shadow.rule.ShadowRule"}, + "name":"org.apache.shardingsphere.shadow.algorithm.shadow.column.ColumnRegexMatchedShadowAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.shadow.rule.ShadowRule"}, + "name":"org.apache.shardingsphere.shadow.algorithm.shadow.column.ColumnValueMatchedShadowAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.shadow.rule.ShadowRule"}, + "name":"org.apache.shardingsphere.shadow.algorithm.shadow.hint.SQLHintShadowAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.shadow.yaml.config.YamlShadowRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.shadow.yaml.config.YamlShadowRuleConfiguration"}, + "name":"org.apache.shardingsphere.shadow.yaml.config.YamlShadowRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setDataSources","parameterTypes":["java.util.Map"] }, {"name":"setDefaultShadowAlgorithmName","parameterTypes":["java.lang.String"] }, {"name":"setShadowAlgorithms","parameterTypes":["java.util.Map"] }, {"name":"setTables","parameterTypes":["java.util.Map"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.shadow.yaml.config.datasource.YamlShadowDataSourceConfiguration"}, + "name":"org.apache.shardingsphere.shadow.yaml.config.datasource.YamlShadowDataSourceConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setProductionDataSourceName","parameterTypes":["java.lang.String"] }, {"name":"setShadowDataSourceName","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.shadow.yaml.swapper.NewYamlShadowRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.shadow.yaml.config.datasource.YamlShadowDataSourceConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getProductionDataSourceName","parameterTypes":[] }, {"name":"getShadowDataSourceName","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.shadow.yaml.config.table.YamlShadowTableConfiguration"}, + "name":"org.apache.shardingsphere.shadow.yaml.config.table.YamlShadowTableConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setDataSourceNames","parameterTypes":["java.util.Collection"] }, {"name":"setShadowAlgorithmNames","parameterTypes":["java.util.Collection"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.shadow.yaml.swapper.NewYamlShadowRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.shadow.yaml.config.table.YamlShadowTableConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getDataSourceNames","parameterTypes":[] }, {"name":"getShadowAlgorithmNames","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.audit.DMLShardingConditionsShardingAuditAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.keygen.SnowflakeKeyGenerateAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.keygen.UUIDKeyGenerateAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.classbased.ClassBasedShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.datetime.AutoIntervalShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.datetime.IntervalShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.hint.HintInlineShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.inline.ComplexInlineShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.inline.InlineShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.mod.HashModShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.mod.ModShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.range.BoundaryBasedRangeShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.range.VolumeBasedRangeShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfiguration"}, + "name":"org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setAuditors","parameterTypes":["java.util.Map"] }, {"name":"setDefaultDatabaseStrategy","parameterTypes":["org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlShardingStrategyConfiguration"] }, {"name":"setKeyGenerators","parameterTypes":["java.util.Map"] }, {"name":"setShardingAlgorithms","parameterTypes":["java.util.Map"] }, {"name":"setTables","parameterTypes":["java.util.Map"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.yaml.config.rule.YamlTableRuleConfiguration"}, + "name":"org.apache.shardingsphere.sharding.yaml.config.rule.YamlTableRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setActualDataNodes","parameterTypes":["java.lang.String"] }, {"name":"setKeyGenerateStrategy","parameterTypes":["org.apache.shardingsphere.sharding.yaml.config.strategy.keygen.YamlKeyGenerateStrategyConfiguration"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.yaml.swapper.NewYamlShardingRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.sharding.yaml.config.rule.YamlTableRuleConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getActualDataNodes","parameterTypes":[] }, {"name":"getAuditStrategy","parameterTypes":[] }, {"name":"getDatabaseStrategy","parameterTypes":[] }, {"name":"getKeyGenerateStrategy","parameterTypes":[] }, {"name":"getLogicTable","parameterTypes":[] }, {"name":"getTableStrategy","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.yaml.config.strategy.keygen.YamlKeyGenerateStrategyConfiguration"}, + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.keygen.YamlKeyGenerateStrategyConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getColumn","parameterTypes":[] }, {"name":"getKeyGeneratorName","parameterTypes":[] }, {"name":"setColumn","parameterTypes":["java.lang.String"] }, {"name":"setKeyGeneratorName","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlShardingStrategyConfiguration"}, + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlShardingStrategyConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setStandard","parameterTypes":["org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlStandardShardingStrategyConfiguration"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.yaml.swapper.NewYamlShardingRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlShardingStrategyConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getComplex","parameterTypes":[] }, {"name":"getHint","parameterTypes":[] }, {"name":"getNone","parameterTypes":[] }, {"name":"getStandard","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlStandardShardingStrategyConfiguration"}, + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlStandardShardingStrategyConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getShardingAlgorithmName","parameterTypes":[] }, {"name":"getShardingColumn","parameterTypes":[] }, {"name":"setShardingAlgorithmName","parameterTypes":["java.lang.String"] }, {"name":"setShardingColumn","parameterTypes":["java.lang.String"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.single.yaml.config.pojo.YamlSingleRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.single.yaml.config.swapper.NewYamlSingleRuleConfigurationSwapper"}, + "name":"org.apache.shardingsphere.single.yaml.config.pojo.YamlSingleRuleConfiguration", + "allDeclaredFields":true, + "methods":[{"name":"getDefaultDataSource","parameterTypes":[] }, {"name":"getTables","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sql.parser.core.database.cache.ParseTreeCacheBuilder"}, + "name":"org.apache.shardingsphere.sql.parser.core.database.cache.ParseTreeCacheLoader" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sql.parser.core.SQLParserFactory"}, + "name":"org.apache.shardingsphere.sql.parser.mysql.parser.MySQLLexer", + "methods":[{"name":"","parameterTypes":["org.antlr.v4.runtime.CharStream"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sql.parser.core.SQLParserFactory"}, + "name":"org.apache.shardingsphere.sql.parser.mysql.parser.MySQLParser", + "methods":[{"name":"","parameterTypes":["org.antlr.v4.runtime.TokenStream"] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sql.parser.core.database.visitor.SQLStatementVisitorFactory"}, + "name":"org.apache.shardingsphere.sql.parser.mysql.visitor.statement.MySQLStatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.driver.jdbc.core.statement.ShardingSphereStatement"}, + "name":"org.apache.shardingsphere.sql.parser.mysql.visitor.statement.type.MySQLDDLStatementVisitor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.parser.cache.SQLStatementCacheLoader"}, + "name":"org.apache.shardingsphere.sql.parser.mysql.visitor.statement.type.MySQLDMLStatementVisitor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sql.parser.core.database.visitor.SQLStatementVisitorFactory"}, + "name":"org.apache.shardingsphere.sql.parser.opengauss.visitor.statement.OpenGaussStatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sql.parser.core.database.visitor.SQLStatementVisitorFactory"}, + "name":"org.apache.shardingsphere.sql.parser.oracle.visitor.statement.OracleStatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sql.parser.core.database.visitor.SQLStatementVisitorFactory"}, + "name":"org.apache.shardingsphere.sql.parser.postgresql.visitor.statement.PostgreSQLStatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.binder.statement.dml.DeleteStatementBinder"}, + "name":"org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.dml.MySQLDeleteStatement", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.binder.statement.dml.InsertStatementBinder"}, + "name":"org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.dml.MySQLInsertStatement", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.binder.statement.dml.SelectStatementBinder"}, + "name":"org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.dml.MySQLSelectStatement", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sql.parser.core.database.visitor.SQLStatementVisitorFactory"}, + "name":"org.apache.shardingsphere.sql.parser.sql92.visitor.statement.SQL92StatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sql.parser.core.database.visitor.SQLStatementVisitorFactory"}, + "name":"org.apache.shardingsphere.sql.parser.sqlserver.visitor.statement.SQLServerStatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.driver.api.ShardingSphereDataSourceFactory"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.driver.api.yaml.YamlShardingSphereDataSourceFactory"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.driver.jdbc.core.datasource.ShardingSphereDataSource"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.connection.refresher.type.table.DropTableStatementSchemaRefresher"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.rule.builder.global.GlobalRulesBuilder"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.manager.context.ConfigurationContextManager"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.manager.standalone.NewStandaloneContextManagerBuilder"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.manager.standalone.NewStandaloneModeContextManager"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.manager.standalone.NewStandaloneModeContextManager$$Lambda$1023/0x00007efe285b91f8"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.metadata.NewMetaDataContextsFactory"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.optimizer.context.OptimizerContextFactory"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.optimizer.context.planner.OptimizerPlannerContextFactory"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationPlannerUtils"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.rule.SQLFederationRule"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.rule.builder.SQLFederationRuleBuilder"}, + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.sqlfederation.yaml.config.YamlSQLFederationRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.sqltranslator.yaml.config.YamlSQLTranslatorRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.timeservice.core.rule.TimestampServiceRule"}, + "name":"org.apache.shardingsphere.timeservice.type.system.SystemTimestampService", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.traffic.yaml.config.YamlTrafficRuleConfiguration" +}, +{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts"}, + "name":"org.apache.shardingsphere.transaction.yaml.config.YamlTransactionRuleConfiguration" +} +] diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/resource-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/resource-config.json new file mode 100644 index 00000000000000..c2dc772615781b --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/resource-config.json @@ -0,0 +1,107 @@ +{ + "resources":{ + "includes":[{ + "condition":{"typeReachable":"org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.config.rule.checker.RuleConfigurationChecker\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.metadata.persist.NewMetaDataPersistService"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.config.rule.decorator.RuleConfigurationDecorator\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.database.core.metadata.data.loader.MetaDataLoader"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.database.core.metadata.data.loader.DialectMetaDataLoader\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.database.core.type.DatabaseTypeRegistry"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.database.core.metadata.database.DialectDatabaseMetaData\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.database.core.metadata.database.system.SystemDatabase"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.database.core.metadata.database.system.DialectSystemDatabase\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.database.core.type.DatabaseTypeFactory"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.database.core.type.DatabaseType\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.datanode.DataNodes"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.datanode.DataNodeBuilder\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.datasource.pool.metadata.DataSourcePoolMetaData\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.executor.audit.SQLAuditEngine"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.executor.audit.SQLAuditor\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.executor.sql.prepare.driver.DriverExecutionPrepareEngine"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.executor.sql.prepare.driver.SQLExecutionUnitBuilder\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.expr.core.InlineExpressionParserFactory"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.expr.spi.InlineExpressionParser\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.merge.MergeEngine"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.merge.engine.ResultProcessEngine\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.metadata.database.schema.builder.GenericSchemaBuilder"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.reviser.MetaDataReviseEntry\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.mode.metadata.MetaDataContexts"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.metadata.statistics.builder.ShardingSphereStatisticsBuilder\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.rewrite.SQLRewriteEntry"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.rewrite.context.SQLRewriteContextDecorator\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.route.engine.impl.PartialSQLRouteExecutor"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.route.SQLRouter\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.rule.builder.database.DatabaseRulesBuilder"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.rule.builder.database.DatabaseRulesBuilder"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilder\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.rule.builder.global.GlobalRulesBuilder"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.rule.builder.global.DefaultGlobalRuleConfigurationBuilder\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.rule.builder.global.GlobalRulesBuilder"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.rule.builder.global.GlobalRuleBuilder\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.swapper.mode.YamlModeConfigurationSwapper"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.mode.YamlPersistRepositoryConfigurationSwapper\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.swapper.rule.NewYamlGlobalRuleConfigurationSwapperEngine"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.NewYamlGlobalRuleConfigurationSwapper\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.infra.yaml.config.swapper.rule.NewYamlRuleConfigurationSwapperEngine"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.NewYamlRuleConfigurationSwapper\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.readwritesplitting.route.standard.StandardReadwriteSplittingDataSourceRouter"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.readwritesplitting.route.standard.filter.ReadDataSourcesFilter\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sharding.spi.KeyGenerateAlgorithm\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAlgorithm\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.sharding.rule.ShardingRule"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.optimizer.context.parser.dialect.OptimizerSQLPropertiesBuilder"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sqlfederation.optimizer.context.parser.dialect.OptimizerSQLDialectBuilder\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.engine.SQLFederationEngine"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sqlfederation.spi.SQLFederationDecider\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.sqltranslator.rule.SQLTranslatorRule"}, + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sqltranslator.spi.SQLTranslator\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.sqlfederation.optimizer.context.parser.dialect.impl.H2OptimizerBuilder"}, + "pattern":"\\Qsaffron.properties\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.mode.repository.standalone.jdbc.sql.JDBCRepositorySQLLoader"}, + "pattern":"\\Qsql\\E" + },{ + "condition":{"typeReachable":"org.apache.shardingsphere.mode.repository.standalone.jdbc.sql.JDBCRepositorySQLLoader"}, + "pattern":"\\Qsql/H2.xml\\E" + }, { + "condition":{"typeReachable":"org.apache.shardingsphere.mode.repository.standalone.jdbc.sql.JDBCRepositorySQLLoader"}, + "pattern":"\\Qsql/MySQL.xml\\E" + }]}, + "bundles":[] +} diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.zookeeper/zookeeper/3.9.0/reflect-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.zookeeper/zookeeper/3.9.0/reflect-config.json new file mode 100644 index 00000000000000..a6e52201ca7581 --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.zookeeper/zookeeper/3.9.0/reflect-config.json @@ -0,0 +1,56 @@ +[ +{ + "condition":{"typeReachable":"org.apache.zookeeper.ZooKeeper"}, + "name":"org.apache.zookeeper.ClientCnxnSocketNIO", + "methods":[{"name":"","parameterTypes":["org.apache.zookeeper.client.ZKClientConfig"] }] +}, +{ + "condition":{"typeReachable":"org.apache.zookeeper.metrics.impl.MetricsProviderBootstrap"}, + "name":"org.apache.zookeeper.metrics.impl.DefaultMetricsProvider", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.zookeeper.server.quorum.QuorumPeerConfig"}, + "name":"org.apache.zookeeper.metrics.impl.DefaultMetricsProvider" +}, +{ + "condition":{"typeReachable":"org.apache.zookeeper.server.ServerCnxnFactory"}, + "name":"org.apache.zookeeper.server.ConnectionBean", + "queryAllPublicConstructors":true +}, +{ + "condition":{"typeReachable":"org.apache.zookeeper.server.ServerCnxnFactory"}, + "name":"org.apache.zookeeper.server.ConnectionMXBean", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.zookeeper.server.ZooKeeperServer"}, + "name":"org.apache.zookeeper.server.DataTreeBean", + "queryAllPublicConstructors":true +}, +{ + "condition":{"typeReachable":"org.apache.zookeeper.server.ZooKeeperServer"}, + "name":"org.apache.zookeeper.server.DataTreeMXBean", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.zookeeper.server.ServerCnxnFactory"}, + "name":"org.apache.zookeeper.server.NIOServerCnxnFactory", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "condition":{"typeReachable":"org.apache.zookeeper.server.ZooKeeperServer"}, + "name":"org.apache.zookeeper.server.ZooKeeperServerBean", + "queryAllPublicConstructors":true +}, +{ + "condition":{"typeReachable":"org.apache.zookeeper.server.ZooKeeperServer"}, + "name":"org.apache.zookeeper.server.ZooKeeperServerMXBean", + "queryAllPublicMethods":true +}, +{ + "condition":{"typeReachable":"org.apache.zookeeper.server.watch.WatchManagerFactory"}, + "name":"org.apache.zookeeper.server.watch.WatchManager", + "methods":[{"name":"","parameterTypes":[] }] +} +] diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.glassfish.jaxb/jaxb-runtime/2.3.1/reflect-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.glassfish.jaxb/jaxb-runtime/2.3.1/reflect-config.json new file mode 100644 index 00000000000000..bf4ceb54aca297 --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.glassfish.jaxb/jaxb-runtime/2.3.1/reflect-config.json @@ -0,0 +1,12 @@ +[ +{ + "condition":{"typeReachable":"com.sun.xml.bind.v2.ContextFactory"}, + "name":"com.sun.xml.bind.v2.ContextFactory", + "methods":[{"name":"createContext","parameterTypes":["java.lang.Class[]","java.util.Map"] }] +}, +{ + "condition":{"typeReachable":"com.sun.xml.bind.v2.runtime.property.SingleElementLeafProperty"}, + "name":"com.sun.xml.bind.v2.runtime.property.SingleElementLeafProperty", + "methods":[{"name":"","parameterTypes":["com.sun.xml.bind.v2.runtime.JAXBContextImpl","com.sun.xml.bind.v2.model.runtime.RuntimeElementPropertyInfo"] }] +} +] diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.slf4j/slf4j-api/1.7.36/reflect-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.slf4j/slf4j-api/1.7.36/reflect-config.json new file mode 100644 index 00000000000000..6cc9abf091869c --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.slf4j/slf4j-api/1.7.36/reflect-config.json @@ -0,0 +1,7 @@ +[ +{ + "condition":{"typeReachable":"org.slf4j.event.Level"}, + "name":"org.slf4j.event.Level", + "methods":[{"name":"valueOf","parameterTypes":["java.lang.String"] }] +} +] diff --git a/jdbc/core/pom.xml b/jdbc/core/pom.xml index 561f26fce4c6a9..f5b2f769f98e40 100644 --- a/jdbc/core/pom.xml +++ b/jdbc/core/pom.xml @@ -164,6 +164,11 @@ shardingsphere-logging-core ${project.version} + + org.apache.shardingsphere + shardingsphere-infra-reachability-metadata + ${project.version} + org.apache.shardingsphere diff --git a/pom.xml b/pom.xml index 737a886fe56e25..20a863812bfe33 100644 --- a/pom.xml +++ b/pom.xml @@ -155,7 +155,7 @@ 1.4.13 4.0.0 1.6.2 - 0.9.27 + 0.9.28 1.0.0 @@ -1002,8 +1002,9 @@ - generateStandardMetadata + generateMetadata + 17 true true true @@ -1011,64 +1012,106 @@ true - - - maven-compiler-plugin - ${maven-compiler-plugin.version} - - 17 - 17 - - - - maven-surefire-plugin - ${maven-surefire-plugin.version} - - - org.apache.shardingsphere.agent.core.** - - - - - org.graalvm.buildtools - native-maven-plugin - ${native-maven-plugin.version} - true - - - true - Direct - - config-output-dir=${project.basedir}/src/main/resources/META-INF/native-image/${project.groupId}/${project.artifactId} - - - - ${user.dir}/distribution/proxy-native/caller-filter.json - - - ${user.dir}/distribution/proxy-native/access-filter.json - - - - - - - test-native - - test - - test - - - build-native - - compile-no-fork - - package - - - - + + + + org.apache.maven.plugins + maven-surefire-plugin + ${maven-surefire-plugin.version} + + + org.apache.shardingsphere.infra.nativetest.** + + + + + org.graalvm.buildtools + native-maven-plugin + ${native-maven-plugin.version} + true + + + true + Conditional + + + ${user.dir}/infra/nativetest/native-image-filter/user-code-filter.json + ${user.dir}/infra/nativetest/native-image-filter/extra-filter.json + true + + + + + main + + false + ${user.dir}/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/ + + + + + + build-native + + compile-no-fork + + package + + + test-native + + test + + test + + + + + + + + + nativeTestInShardingSphere + + 17 + + + + + + maven-surefire-plugin + + + org.apache.shardingsphere.infra.nativetest.** + + + + + org.graalvm.buildtools + native-maven-plugin + ${native-maven-plugin.version} + true + + + --report-unsupported-elements-at-runtime + + ${project.build.outputDirectory} + + true + + + + + test-native + + test + + test + + + + +