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..13dc37c3190fc1 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` 生成 Standard 形态的 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..0d7dc0125da482 --- /dev/null +++ b/infra/nativetest/native-image-filter/extra-filter.json @@ -0,0 +1,7 @@ +{ + "rules": [ + {"includeClasses": "**"} + ], + "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..57204ce3247a16 --- /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} + + + + + + + + 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..6e80670771e578 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/FileTestUtils.java @@ -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. + */ + +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 { + + public static byte[] readFromFileURLString(final String fileUrl) { + return readInputStream(ClassLoader.getSystemResourceAsStream(fileUrl)).getBytes(StandardCharsets.UTF_8); + } + + private static String readInputStream(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..a5a0dec01e3f10 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/EncryptTest.java @@ -0,0 +1,127 @@ +/* + * 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 + public void testEncryptInLocalTransactions() throws SQLException, IOException { + try { + 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(); + } finally { + // 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(); + 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..5023952eb87328 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/MaskTest.java @@ -0,0 +1,127 @@ +/* + * 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 + public void testMaskInLocalTransactions() throws SQLException, IOException { + try { + 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(); + } finally { + // 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(); + 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..53100daa681882 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ReadWriteSplittingTest.java @@ -0,0 +1,144 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.shardingsphere.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 org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +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 static final Logger LOGGER = LoggerFactory.getLogger(ReadWriteSplittingTest.class); + + private OrderRepository orderRepository; + + private OrderItemRepository orderItemRepository; + + private AddressRepository addressRepository; + + @Test + public void testReadWriteSplittingInLocalTransactions() throws SQLException, IOException { + try { + 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(); + } finally { + // this.cleanEnvironment(); + } + } + + private void initEnvironment() throws SQLException { + orderRepository.createTableIfNotExists(); + orderItemRepository.createTableIfNotExists(); + addressRepository.createTableIfNotExists(); + orderRepository.truncateTable(); + orderItemRepository.truncateTable(); + addressRepository.truncateTable(); + } + + private void processSuccess() throws SQLException { + LOGGER.info("-------------- Process Success Begin ---------------"); + 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); + LOGGER.info("-------------- Process Success Finish --------------"); + } + + private List insertData() throws SQLException { + LOGGER.info("---------------------------- Insert Data ----------------------------"); + 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(); + address.setAddressId((long) i); + address.setAddressName("address_test_" + i); + addressRepository.insert(address); + + result.add(order.getOrderId()); + } + return result; + } + + private void deleteData(final List orderIds) throws SQLException { + LOGGER.info("---------------------------- Delete Data ----------------------------"); + long count = 1; + for (Long each : orderIds) { + orderRepository.delete(each); + orderItemRepository.delete(each); + addressRepository.delete(count++); + } + } + + private void printData() throws SQLException { + LOGGER.info("---------------------------- Print Order Data -----------------------"); + for (Object each : orderRepository.selectAll()) { + LOGGER.info(each.toString()); + } + LOGGER.info("---------------------------- Print OrderItem Data -------------------"); + for (Object each : orderItemRepository.selectAll()) { + LOGGER.info(each.toString()); + } + LOGGER.info("---------------------------- Print Address Data -------------------"); + for (Object each : addressRepository.selectAll()) { + LOGGER.info(each.toString()); + } + } + + 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..ec672f899f2d80 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ShadowTest.java @@ -0,0 +1,156 @@ +/* + * 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 + public void testShadowInLocalTransactions() throws SQLException, IOException { + try { + 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(); + } finally { + // 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 { + 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..376b88aeef12ac --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/ShardingTest.java @@ -0,0 +1,143 @@ +/* + * 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 + public void testShardingInLocalTransactions() throws SQLException, IOException { + try { + 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(); + this.cleanEnvironment(); + } finally { + // 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(); + + 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/TestQueryAssistedShardingEncryptAlgorithm.java b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/TestQueryAssistedShardingEncryptAlgorithm.java new file mode 100644 index 00000000000000..529a82d02e54cd --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/TestQueryAssistedShardingEncryptAlgorithm.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.shardingsphere.infra.nativetest.jdbc.features; + +import lombok.Getter; +import org.apache.shardingsphere.encrypt.api.context.EncryptContext; +import org.apache.shardingsphere.encrypt.api.encrypt.assisted.AssistedEncryptAlgorithm; + +import java.util.Properties; + +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(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..c82d7867cb197f --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/Address.java @@ -0,0 +1,34 @@ +/* + * 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.*; + +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..5d1962aaa47e74 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/Order.java @@ -0,0 +1,40 @@ +/* + * 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.*; + +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..23ed77db9a319d --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/entity/OrderItem.java @@ -0,0 +1,41 @@ +/* + * 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..f6833ca5833321 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/AddressRepository.java @@ -0,0 +1,104 @@ +/* + * 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; + +public final class AddressRepository { + + private final DataSource dataSource; + + public AddressRepository(final DataSource dataSource) { + this.dataSource = dataSource; + } + + 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); + } + } + + 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); + } + } + + public void truncateTable() throws SQLException { + String sql = "TRUNCATE TABLE t_address"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + 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(); + } + + 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(); + } + } + + 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..cfb02f2b693f97 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/OrderItemRepository.java @@ -0,0 +1,143 @@ +/* + * 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; + +public final class OrderItemRepository { + + private final DataSource dataSource; + + public OrderItemRepository(final DataSource dataSource) { + this.dataSource = dataSource; + } + + 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); + } + } + + 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); + } + } + + public void truncateTable() throws SQLException { + String sql = "TRUNCATE TABLE t_order_item"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + 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); + } + } + + 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); + } + } + + 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); + } + } + + 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(); + } + + 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(); + } + } + + 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..22d597ebf434c1 --- /dev/null +++ b/infra/nativetest/src/test/java/org/apache/shardingsphere/infra/nativetest/jdbc/features/repository/OrderRepository.java @@ -0,0 +1,162 @@ +/* + * 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; + +public final class OrderRepository { + + private final DataSource dataSource; + + public OrderRepository(final DataSource dataSource) { + this.dataSource = dataSource; + } + + 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); + } + } + + public void dropTable() throws SQLException { + // todo lingh fix in shadow + String sql = "DROP TABLE IF EXISTS t_order"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + public void truncateTable() throws SQLException { + String sql = "TRUNCATE TABLE t_order"; + try ( + Connection connection = dataSource.getConnection(); + Statement statement = connection.createStatement()) { + statement.executeUpdate(sql); + } + } + + 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); + } + } + + 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); + } + } + + 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); + } + } + + public List selectShadowOrder() throws SQLException { + String sql = "SELECT * FROM t_order WHERE order_type=1"; + return getOrders(sql); + } + + 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(); + } + } + + 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(); + } + + 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(); + } + } + + public List selectAll() throws SQLException { + return getOrders("SELECT * FROM t_order"); + } + + 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/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..37c6277959e6d4 --- /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.TestQueryAssistedShardingEncryptAlgorithm diff --git a/infra/nativetest/src/test/resources/logback.xml b/infra/nativetest/src/test/resources/logback.xml new file mode 100644 index 00000000000000..a4847ef2c0bda2 --- /dev/null +++ b/infra/nativetest/src/test/resources/logback.xml @@ -0,0 +1,34 @@ + + + + + + + + ${log.context.name} + + + + ${log.pattern} + + + + + + + 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..0c24088e084239 --- /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:demo_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..40bae34b8e460e --- /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:demo_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..252e9aab8ff531 --- /dev/null +++ b/infra/nativetest/src/test/resources/yaml/readwrite-splitting.yaml @@ -0,0 +1,54 @@ +# +# 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:demo_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:demo_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:demo_ds_2;MODE=MYSQL;IGNORECASE=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE + username: root + password: 123456 + +rules: +- !READWRITE_SPLITTING + 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..aebcc76a0741ce --- /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:demo_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:demo_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 \ No newline at end of file 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..be76577f1aab4d --- /dev/null +++ b/infra/nativetest/src/test/resources/yaml/sharding.yaml @@ -0,0 +1,78 @@ +# +# 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:demo_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:demo_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:demo_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: + inline: + type: INLINE + props: + algorithm-expression: ds_${user_id % 2} + 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/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/jni-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/jni-config.json new file mode 100644 index 00000000000000..c8b081385033ae --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/jni-config.json @@ -0,0 +1,10 @@ +[ +{ + "name":"java.lang.Boolean", + "methods":[{"name":"getBoolean","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"sun.management.VMManagementImpl", + "fields":[{"name":"compTimeMonitoringSupport"}, {"name":"currentThreadCpuTimeSupport"}, {"name":"objectMonitorUsageSupport"}, {"name":"otherThreadCpuTimeSupport"}, {"name":"remoteDiagnosticCommandsSupport"}, {"name":"synchronizerUsageSupport"}, {"name":"threadAllocatedMemorySupport"}, {"name":"threadContentionMonitoringSupport"}] +} +] diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/predefined-classes-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/predefined-classes-config.json new file mode 100644 index 00000000000000..847895071fbcb8 --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/predefined-classes-config.json @@ -0,0 +1,7 @@ +[ + { + "type":"agent-extracted", + "classes":[ + ] + } +] diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/proxy-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/proxy-config.json new file mode 100644 index 00000000000000..641a8f15102354 --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/proxy-config.json @@ -0,0 +1,5 @@ +[ + { + "interfaces":["java.sql.Connection"] + } +] 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..5a2d98a818c4df --- /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,2798 @@ +[ +{ + "name":"Script1", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"","parameterTypes":["groovy.lang.Binding"] }] +}, +{ + "name":"Script1$_run_closure1", + "queryAllDeclaredMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"doCall","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"Script1BeanInfo" +}, +{ + "name":"Script1Customizer" +}, +{ + "name":"[B" +}, +{ + "name":"[C" +}, +{ + "name":"[I" +}, +{ + "name":"[Lcom.zaxxer.hikari.util.ConcurrentBag$IConcurrentBagEntry;" +}, +{ + "name":"[Ljava.io.ObjectStreamField;" +}, +{ + "name":"[Ljava.lang.CharSequence;" +}, +{ + "name":"[Ljava.lang.Class;" +}, +{ + "name":"[Ljava.lang.Object;" +}, +{ + "name":"[Ljava.lang.String;" +}, +{ + "name":"[Ljava.lang.annotation.Annotation;" +}, +{ + "name":"[Ljava.lang.reflect.AnnotatedType;" +}, +{ + "name":"[Ljava.lang.reflect.Constructor;" +}, +{ + "name":"[Ljava.lang.reflect.Field;" +}, +{ + "name":"[Ljava.lang.reflect.Method;" +}, +{ + "name":"[Ljava.lang.reflect.RecordComponent;" +}, +{ + "name":"[Ljava.lang.reflect.Type;" +}, +{ + "name":"[Ljava.lang.reflect.TypeVariable;" +}, +{ + "name":"[Ljava.sql.Statement;" +}, +{ + "name":"[Lorg.codehaus.groovy.runtime.callsite.CallSite;" +}, +{ + "name":"[Lsun.security.pkcs.SignerInfo;" +}, +{ + "name":"ch.qos.logback.classic.encoder.PatternLayoutEncoder", + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"ch.qos.logback.classic.joran.SerializedModelConfigurator", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"ch.qos.logback.classic.pattern.DateConverter", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"ch.qos.logback.classic.pattern.LevelConverter", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"ch.qos.logback.classic.pattern.LineSeparatorConverter", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"ch.qos.logback.classic.pattern.LoggerConverter", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"ch.qos.logback.classic.pattern.MessageConverter", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"ch.qos.logback.classic.pattern.ThreadConverter", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"ch.qos.logback.classic.util.DefaultJoranConfigurator", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"ch.qos.logback.core.ConsoleAppender", + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"ch.qos.logback.core.OutputStreamAppender", + "methods":[{"name":"setEncoder","parameterTypes":["ch.qos.logback.core.encoder.Encoder"] }] +}, +{ + "name":"ch.qos.logback.core.encoder.Encoder", + "methods":[{"name":"valueOf","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"ch.qos.logback.core.encoder.LayoutWrappingEncoder", + "methods":[{"name":"setParent","parameterTypes":["ch.qos.logback.core.spi.ContextAware"] }] +}, +{ + "name":"ch.qos.logback.core.pattern.PatternLayoutEncoderBase", + "methods":[{"name":"setPattern","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"ch.qos.logback.core.spi.ContextAware", + "methods":[{"name":"valueOf","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"com.github.benmanes.caffeine.cache.BBHeader$ReadAndWriteCounterRef", + "fields":[{"name":"writeCounter"}] +}, +{ + "name":"com.github.benmanes.caffeine.cache.BBHeader$ReadCounterRef", + "fields":[{"name":"readCounter"}] +}, +{ + "name":"com.github.benmanes.caffeine.cache.BLCHeader$DrainStatusRef", + "fields":[{"name":"drainStatus"}] +}, +{ + "name":"com.github.benmanes.caffeine.cache.BaseMpscLinkedArrayQueueColdProducerFields", + "fields":[{"name":"producerLimit"}] +}, +{ + "name":"com.github.benmanes.caffeine.cache.BaseMpscLinkedArrayQueueConsumerFields", + "fields":[{"name":"consumerIndex"}] +}, +{ + "name":"com.github.benmanes.caffeine.cache.BaseMpscLinkedArrayQueueProducerFields", + "fields":[{"name":"producerIndex"}] +}, +{ + "name":"com.github.benmanes.caffeine.cache.CacheLoader", + "methods":[{"name":"loadAll","parameterTypes":["java.lang.Iterable"] }] +}, +{ + "name":"com.github.benmanes.caffeine.cache.PD", + "fields":[{"name":"value"}] +}, +{ + "name":"com.github.benmanes.caffeine.cache.PDMS", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"com.github.benmanes.caffeine.cache.SIMS", + "methods":[{"name":"","parameterTypes":["com.github.benmanes.caffeine.cache.Caffeine","com.github.benmanes.caffeine.cache.CacheLoader","boolean"] }] +}, +{ + "name":"com.github.benmanes.caffeine.cache.StripedBuffer", + "fields":[{"name":"tableBusy"}] +}, +{ + "name":"com.google.common.util.concurrent.AbstractFuture", + "fields":[{"name":"listeners"}, {"name":"value"}, {"name":"waiters"}] +}, +{ + "name":"com.google.common.util.concurrent.AbstractFuture$Waiter", + "fields":[{"name":"next"}, {"name":"thread"}] +}, +{ + "name":"com.ibm.icu.text.Collator" +}, +{ + "name":"com.sun.crypto.provider.AESCipher$General", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"com.sun.xml.bind.v2.ContextFactory", + "methods":[{"name":"createContext","parameterTypes":["java.lang.Class[]","java.util.Map"] }] +}, +{ + "name":"com.sun.xml.bind.v2.model.nav.ReflectionNavigator", + "methods":[{"name":"getInstance","parameterTypes":[] }] +}, +{ + "name":"com.sun.xml.bind.v2.runtime.property.ArrayElementLeafProperty", + "queryAllPublicConstructors":true +}, +{ + "name":"com.sun.xml.bind.v2.runtime.property.ArrayElementNodeProperty", + "queryAllPublicConstructors":true +}, +{ + "name":"com.sun.xml.bind.v2.runtime.property.ArrayReferenceNodeProperty", + "queryAllPublicConstructors":true +}, +{ + "name":"com.sun.xml.bind.v2.runtime.property.SingleElementLeafProperty", + "queryAllPublicConstructors":true, + "methods":[{"name":"","parameterTypes":["com.sun.xml.bind.v2.runtime.JAXBContextImpl","com.sun.xml.bind.v2.model.runtime.RuntimeElementPropertyInfo"] }] +}, +{ + "name":"com.sun.xml.bind.v2.runtime.property.SingleElementNodeProperty", + "queryAllPublicConstructors":true +}, +{ + "name":"com.sun.xml.bind.v2.runtime.property.SingleMapNodeProperty", + "queryAllPublicConstructors":true +}, +{ + "name":"com.sun.xml.bind.v2.runtime.property.SingleReferenceNodeProperty", + "queryAllPublicConstructors":true +}, +{ + "name":"com.zaxxer.hikari.HikariConfig", + "fields":[{"name":"dataSourceProperties"}, {"name":"jdbcUrl"}], + "methods":[{"name":"getCatalog","parameterTypes":[] }, {"name":"getConnectionInitSql","parameterTypes":[] }, {"name":"getConnectionTestQuery","parameterTypes":[] }, {"name":"getConnectionTimeout","parameterTypes":[] }, {"name":"getDataSourceClassName","parameterTypes":[] }, {"name":"getDataSourceJNDI","parameterTypes":[] }, {"name":"getDataSourceProperties","parameterTypes":[] }, {"name":"getExceptionOverrideClassName","parameterTypes":[] }, {"name":"getHealthCheckProperties","parameterTypes":[] }, {"name":"getIdleTimeout","parameterTypes":[] }, {"name":"getInitializationFailTimeout","parameterTypes":[] }, {"name":"getJdbcUrl","parameterTypes":[] }, {"name":"getKeepaliveTime","parameterTypes":[] }, {"name":"getLeakDetectionThreshold","parameterTypes":[] }, {"name":"getMaxLifetime","parameterTypes":[] }, {"name":"getMaximumPoolSize","parameterTypes":[] }, {"name":"getMinimumIdle","parameterTypes":[] }, {"name":"getPassword","parameterTypes":[] }, {"name":"getPoolName","parameterTypes":[] }, {"name":"getSchema","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":"setConnectionTimeout","parameterTypes":["long"] }, {"name":"setDataSourceProperties","parameterTypes":["java.util.Properties"] }, {"name":"setIdleTimeout","parameterTypes":["long"] }, {"name":"setJdbcUrl","parameterTypes":["java.lang.String"] }, {"name":"setKeepaliveTime","parameterTypes":["long"] }, {"name":"setMaxLifetime","parameterTypes":["long"] }, {"name":"setMaximumPoolSize","parameterTypes":["int"] }, {"name":"setMinimumIdle","parameterTypes":["int"] }, {"name":"setPassword","parameterTypes":["java.lang.String"] }, {"name":"setReadOnly","parameterTypes":["boolean"] }, {"name":"setUsername","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"com.zaxxer.hikari.HikariDataSource", + "queryAllPublicMethods":true, + "fields":[{"name":"dataSourceProperties"}, {"name":"jdbcUrl"}], + "methods":[{"name":"","parameterTypes":[] }, {"name":"isClosed","parameterTypes":[] }, {"name":"isRunning","parameterTypes":[] }] +}, +{ + "name":"com.zaxxer.hikari.pool.PoolEntry", + "fields":[{"name":"state"}] +}, +{ + "name":"groovy.grape.GrabAnnotationTransformation", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"groovy.grape.GrapeIvy" +}, +{ + "name":"groovy.io.FileType" +}, +{ + "name":"groovy.lang.Binding", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"groovy.lang.BindingBeanInfo" +}, +{ + "name":"groovy.lang.BindingCustomizer" +}, +{ + "name":"groovy.lang.Buildable", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"groovy.lang.Closure", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"getProperty","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"groovy.lang.Closure$1", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"groovy.lang.Closure$1BeanInfo" +}, +{ + "name":"groovy.lang.Closure$1Customizer" +}, +{ + "name":"groovy.lang.ClosureBeanInfo" +}, +{ + "name":"groovy.lang.ClosureCustomizer" +}, +{ + "name":"groovy.lang.EmptyRange" +}, +{ + "name":"groovy.lang.ExpandoMetaClass", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"groovy.lang.ExpandoMetaClassBeanInfo" +}, +{ + "name":"groovy.lang.ExpandoMetaClassCustomizer" +}, +{ + "name":"groovy.lang.GString", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"build","parameterTypes":["groovy.lang.GroovyObject"] }, {"name":"charAt","parameterTypes":["int"] }, {"name":"compareTo","parameterTypes":["java.lang.Object"] }, {"name":"getStrings","parameterTypes":[] }, {"name":"length","parameterTypes":[] }, {"name":"subSequence","parameterTypes":["int","int"] }, {"name":"toString","parameterTypes":[] }, {"name":"writeTo","parameterTypes":["java.io.Writer"] }] +}, +{ + "name":"groovy.lang.GString$1", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"groovy.lang.GString$1BeanInfo" +}, +{ + "name":"groovy.lang.GString$1Customizer" +}, +{ + "name":"groovy.lang.GStringBeanInfo" +}, +{ + "name":"groovy.lang.GStringCustomizer" +}, +{ + "name":"groovy.lang.GroovyCallable", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"groovy.lang.GroovyObject", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"getProperty","parameterTypes":["java.lang.String"] }, {"name":"invokeMethod","parameterTypes":["java.lang.String","java.lang.Object"] }] +}, +{ + "name":"groovy.lang.GroovyObjectSupport", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"getMetaClass","parameterTypes":[] }, {"name":"setMetaClass","parameterTypes":["groovy.lang.MetaClass"] }] +}, +{ + "name":"groovy.lang.GroovyObjectSupportBeanInfo" +}, +{ + "name":"groovy.lang.GroovyObjectSupportCustomizer" +}, +{ + "name":"groovy.lang.GroovyShell", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"groovy.lang.GroovyShellBeanInfo" +}, +{ + "name":"groovy.lang.GroovyShellCustomizer" +}, +{ + "name":"groovy.lang.GroovySystem" +}, +{ + "name":"groovy.lang.IntRange" +}, +{ + "name":"groovy.lang.ListWithDefault" +}, +{ + "name":"groovy.lang.MetaClass", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"groovy.lang.MetaClassImpl", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"groovy.lang.MetaClassImplBeanInfo" +}, +{ + "name":"groovy.lang.MetaClassImplCustomizer" +}, +{ + "name":"groovy.lang.MetaMethod", + "queryAllDeclaredMethods":true, + "methods":[{"name":"doMethodInvoke","parameterTypes":["java.lang.Object","java.lang.Object[]"] }] +}, +{ + "name":"groovy.lang.MetaObjectProtocol", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "methods":[{"name":"getProperty","parameterTypes":["java.lang.Object","java.lang.String"] }, {"name":"invokeConstructor","parameterTypes":["java.lang.Object[]"] }, {"name":"invokeMethod","parameterTypes":["java.lang.Object","java.lang.String","java.lang.Object[]"] }, {"name":"invokeStaticMethod","parameterTypes":["java.lang.Object","java.lang.String","java.lang.Object[]"] }] +}, +{ + "name":"groovy.lang.MetaProperty", + "queryAllDeclaredMethods":true, + "methods":[{"name":"getProperty","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"groovy.lang.MutableMetaClass", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"groovy.lang.ObjectRange" +}, +{ + "name":"groovy.lang.Range", + "queryAllPublicMethods":true +}, +{ + "name":"groovy.lang.Script", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"groovy.lang.ScriptBeanInfo" +}, +{ + "name":"groovy.lang.ScriptCustomizer" +}, +{ + "name":"groovy.lang.SpreadMap" +}, +{ + "name":"groovy.lang.Writable", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"groovy.lang.groovydoc.Groovydoc" +}, +{ + "name":"groovy.runtime.metaclass.CustomMetaClassCreationHandle" +}, +{ + "name":"groovy.runtime.metaclass.Script1$_run_closure1MetaClass" +}, +{ + "name":"groovy.runtime.metaclass.Script1MetaClass" +}, +{ + "name":"groovy.runtime.metaclass.groovy.lang.BindingMetaClass" +}, +{ + "name":"groovy.runtime.metaclass.groovy.lang.Closure$1MetaClass" +}, +{ + "name":"groovy.runtime.metaclass.groovy.lang.ExpandoMetaClassMetaClass" +}, +{ + "name":"groovy.runtime.metaclass.groovy.lang.GString$1MetaClass" +}, +{ + "name":"groovy.runtime.metaclass.groovy.lang.GroovyShellMetaClass" +}, +{ + "name":"groovy.runtime.metaclass.groovy.util.ExpandoMetaClass" +}, +{ + "name":"groovy.runtime.metaclass.java.lang.IntegerMetaClass" +}, +{ + "name":"groovy.runtime.metaclass.org.codehaus.groovy.runtime.GStringImplMetaClass" +}, +{ + "name":"groovy.transform.Internal", + "queryAllDeclaredMethods":true +}, +{ + "name":"groovy.util.BufferedIterator" +}, +{ + "name":"groovy.util.Expando", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"groovy.util.ExpandoBeanInfo" +}, +{ + "name":"groovy.util.ExpandoCustomizer" +}, +{ + "name":"java.beans.PropertyVetoException" +}, +{ + "name":"java.beans.Transient", + "queryAllDeclaredMethods":true, + "methods":[{"name":"value","parameterTypes":[] }] +}, +{ + "name":"java.io.BufferedInputStream" +}, +{ + "name":"java.io.BufferedOutputStream" +}, +{ + "name":"java.io.BufferedReader" +}, +{ + "name":"java.io.BufferedWriter" +}, +{ + "name":"java.io.Closeable", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"java.io.DataInput", + "queryAllPublicMethods":true +}, +{ + "name":"java.io.DataInputStream" +}, +{ + "name":"java.io.DataOutput", + "queryAllPublicMethods":true +}, +{ + "name":"java.io.DataOutputStream" +}, +{ + "name":"java.io.File" +}, +{ + "name":"java.io.FilePermission" +}, +{ + "name":"java.io.Flushable", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"java.io.InputStream", + "queryAllDeclaredMethods":true, + "methods":[{"name":"close","parameterTypes":[] }] +}, +{ + "name":"java.io.ObjectInput", + "queryAllPublicMethods":true +}, +{ + "name":"java.io.ObjectInputStream" +}, +{ + "name":"java.io.ObjectOutput", + "queryAllPublicMethods":true +}, +{ + "name":"java.io.ObjectOutputStream" +}, +{ + "name":"java.io.ObjectStreamConstants", + "queryAllPublicMethods":true +}, +{ + "name":"java.io.OutputStream", + "queryAllDeclaredMethods":true, + "methods":[{"name":"close","parameterTypes":[] }, {"name":"flush","parameterTypes":[] }] +}, +{ + "name":"java.io.PrintStream" +}, +{ + "name":"java.io.PrintWriter" +}, +{ + "name":"java.io.Reader", + "queryAllDeclaredMethods":true, + "methods":[{"name":"close","parameterTypes":[] }, {"name":"read","parameterTypes":["java.nio.CharBuffer"] }] +}, +{ + "name":"java.io.Serializable", + "allDeclaredFields":true, + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"java.io.Writer", + "queryAllDeclaredMethods":true, + "methods":[{"name":"append","parameterTypes":["char"] }, {"name":"append","parameterTypes":["java.lang.CharSequence"] }, {"name":"append","parameterTypes":["java.lang.CharSequence","int","int"] }, {"name":"close","parameterTypes":[] }, {"name":"flush","parameterTypes":[] }] +}, +{ + "name":"java.lang.AbstractStringBuilder", + "queryAllDeclaredMethods":true, + "methods":[{"name":"append","parameterTypes":["char"] }, {"name":"append","parameterTypes":["java.lang.CharSequence"] }, {"name":"append","parameterTypes":["java.lang.CharSequence","int","int"] }, {"name":"charAt","parameterTypes":["int"] }, {"name":"length","parameterTypes":[] }, {"name":"subSequence","parameterTypes":["int","int"] }, {"name":"toString","parameterTypes":[] }] +}, +{ + "name":"java.lang.Appendable", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"java.lang.AutoCloseable", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"java.lang.Boolean", + "fields":[{"name":"FALSE"}, {"name":"TRUE"}] +}, +{ + "name":"java.lang.CharSequence", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"java.lang.Character" +}, +{ + "name":"java.lang.Class", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"forName","parameterTypes":["java.lang.String","boolean","java.lang.ClassLoader"] }, {"name":"getModule","parameterTypes":[] }, {"name":"getPermittedSubclasses","parameterTypes":[] }, {"name":"isSealed","parameterTypes":[] }] +}, +{ + "name":"java.lang.ClassLoader", + "queryAllDeclaredMethods":true +}, +{ + "name":"java.lang.Cloneable", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"java.lang.Comparable", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"compareTo","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"java.lang.Deprecated", + "queryAllDeclaredMethods":true, + "methods":[{"name":"forRemoval","parameterTypes":[] }, {"name":"since","parameterTypes":[] }] +}, +{ + "name":"java.lang.Double" +}, +{ + "name":"java.lang.Enum", + "queryAllDeclaredMethods":true, + "methods":[{"name":"compareTo","parameterTypes":["java.lang.Object"] }, {"name":"describeConstable","parameterTypes":[] }] +}, +{ + "name":"java.lang.Float" +}, +{ + "name":"java.lang.FunctionalInterface", + "queryAllDeclaredMethods":true +}, +{ + "name":"java.lang.Integer", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"java.lang.IntegerBeanInfo" +}, +{ + "name":"java.lang.IntegerCustomizer" +}, +{ + "name":"java.lang.Iterable", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "methods":[{"name":"forEach","parameterTypes":["java.util.function.Consumer"] }] +}, +{ + "name":"java.lang.Long" +}, +{ + "name":"java.lang.Math", + "methods":[{"name":"floorDiv","parameterTypes":["long","long"] }, {"name":"floorMod","parameterTypes":["long","long"] }, {"name":"max","parameterTypes":["int","int"] }, {"name":"min","parameterTypes":["int","int"] }] +}, +{ + "name":"java.lang.Module", + "methods":[{"name":"getDescriptor","parameterTypes":[] }] +}, +{ + "name":"java.lang.Number", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "methods":[{"name":"longValue","parameterTypes":[] }] +}, +{ + "name":"java.lang.NumberBeanInfo" +}, +{ + "name":"java.lang.NumberCustomizer" +}, +{ + "name":"java.lang.Object", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"close","parameterTypes":[] }, {"name":"entrySet","parameterTypes":[] }, {"name":"equals","parameterTypes":["java.lang.Object"] }, {"name":"flush","parameterTypes":[] }, {"name":"get","parameterTypes":["int"] }, {"name":"getDeclaringClass","parameterTypes":[] }, {"name":"getModifiers","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }, {"name":"getTypeParameters","parameterTypes":[] }, {"name":"hashCode","parameterTypes":[] }, {"name":"iterator","parameterTypes":[] }, {"name":"size","parameterTypes":[] }, {"name":"toString","parameterTypes":[] }] +}, +{ + "name":"java.lang.ObjectBeanInfo" +}, +{ + "name":"java.lang.ObjectCustomizer" +}, +{ + "name":"java.lang.Process", + "queryAllDeclaredMethods":true +}, +{ + "name":"java.lang.Readable", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"java.lang.Runnable", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"java.lang.RuntimePermission" +}, +{ + "name":"java.lang.Short" +}, +{ + "name":"java.lang.String", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"toUpperCase","parameterTypes":[] }] +}, +{ + "name":"java.lang.StringBuffer" +}, +{ + "name":"java.lang.StringBuilder" +}, +{ + "name":"java.lang.System$Logger", + "queryAllPublicMethods":true +}, +{ + "name":"java.lang.Thread", + "fields":[{"name":"threadLocalRandomProbe"}] +}, +{ + "name":"java.lang.Throwable" +}, +{ + "name":"java.lang.constant.Constable", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"java.lang.constant.ConstantDesc", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"java.lang.invoke.TypeDescriptor", + "queryAllPublicMethods":true +}, +{ + "name":"java.lang.invoke.TypeDescriptor$OfField", + "queryAllPublicMethods":true +}, +{ + "name":"java.lang.reflect.AccessibleObject", + "methods":[{"name":"getAnnotations","parameterTypes":[] }, {"name":"getDeclaringClass","parameterTypes":[] }, {"name":"getModifiers","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }, {"name":"getTypeParameters","parameterTypes":[] }] +}, +{ + "name":"java.lang.reflect.AnnotatedElement", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"java.lang.reflect.Executable", + "queryAllDeclaredMethods":true, + "methods":[{"name":"getAnnotation","parameterTypes":["java.lang.Class"] }, {"name":"getDeclaredAnnotations","parameterTypes":[] }, {"name":"getDeclaringClass","parameterTypes":[] }, {"name":"getModifiers","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }, {"name":"getTypeParameters","parameterTypes":[] }, {"name":"isSynthetic","parameterTypes":[] }] +}, +{ + "name":"java.lang.reflect.GenericDeclaration", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"java.lang.reflect.Member", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"java.lang.reflect.Type", + "queryAllPublicMethods":true +}, +{ + "name":"java.math.BigDecimal", + "methods":[{"name":"add","parameterTypes":["java.math.BigDecimal"] }, {"name":"negate","parameterTypes":[] }] +}, +{ + "name":"java.math.BigInteger" +}, +{ + "name":"java.net.NetPermission" +}, +{ + "name":"java.net.ServerSocket" +}, +{ + "name":"java.net.Socket" +}, +{ + "name":"java.net.SocketPermission" +}, +{ + "name":"java.net.URI" +}, +{ + "name":"java.net.URL" +}, +{ + "name":"java.net.URLPermission", + "methods":[{"name":"","parameterTypes":["java.lang.String","java.lang.String"] }] +}, +{ + "name":"java.nio.ByteBuffer", + "queryAllDeclaredMethods":true +}, +{ + "name":"java.nio.charset.Charset", + "queryAllDeclaredMethods":true, + "methods":[{"name":"compareTo","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"java.security.AlgorithmParametersSpi" +}, +{ + "name":"java.security.AllPermission" +}, +{ + "name":"java.security.MessageDigestSpi" +}, +{ + "name":"java.security.PrivilegedAction", + "queryAllPublicMethods":true +}, +{ + "name":"java.security.PrivilegedExceptionAction", + "queryAllPublicMethods":true +}, +{ + "name":"java.security.SecureRandomParameters" +}, +{ + "name":"java.security.SecurityPermission" +}, +{ + "name":"java.security.interfaces.DSAPrivateKey" +}, +{ + "name":"java.security.interfaces.DSAPublicKey" +}, +{ + "name":"java.security.spec.DSAParameterSpec" +}, +{ + "name":"java.sql.Date" +}, +{ + "name":"java.sql.PseudoColumnUsage" +}, +{ + "name":"java.sql.ResultSet", + "methods":[{"name":"getDate","parameterTypes":["int","java.util.Calendar"] }, {"name":"getTime","parameterTypes":["int","java.util.Calendar"] }, {"name":"getTimestamp","parameterTypes":["int","java.util.Calendar"] }] +}, +{ + "name":"java.sql.SQLException", + "fields":[{"name":"next"}] +}, +{ + "name":"java.sql.Timestamp" +}, +{ + "name":"java.util.AbstractCollection", + "queryAllDeclaredMethods":true, + "methods":[{"name":"add","parameterTypes":["java.lang.Object"] }, {"name":"addAll","parameterTypes":["java.util.Collection"] }, {"name":"clear","parameterTypes":[] }, {"name":"contains","parameterTypes":["java.lang.Object"] }, {"name":"containsAll","parameterTypes":["java.util.Collection"] }, {"name":"get","parameterTypes":["int"] }, {"name":"isEmpty","parameterTypes":[] }, {"name":"iterator","parameterTypes":[] }, {"name":"remove","parameterTypes":["java.lang.Object"] }, {"name":"removeAll","parameterTypes":["java.util.Collection"] }, {"name":"retainAll","parameterTypes":["java.util.Collection"] }, {"name":"size","parameterTypes":[] }, {"name":"toArray","parameterTypes":[] }, {"name":"toArray","parameterTypes":["java.lang.Object[]"] }] +}, +{ + "name":"java.util.AbstractList", + "queryAllDeclaredMethods":true, + "methods":[{"name":"add","parameterTypes":["int","java.lang.Object"] }, {"name":"add","parameterTypes":["java.lang.Object"] }, {"name":"addAll","parameterTypes":["int","java.util.Collection"] }, {"name":"clear","parameterTypes":[] }, {"name":"equals","parameterTypes":["java.lang.Object"] }, {"name":"get","parameterTypes":["int"] }, {"name":"hashCode","parameterTypes":[] }, {"name":"indexOf","parameterTypes":["java.lang.Object"] }, {"name":"iterator","parameterTypes":[] }, {"name":"lastIndexOf","parameterTypes":["java.lang.Object"] }, {"name":"listIterator","parameterTypes":[] }, {"name":"listIterator","parameterTypes":["int"] }, {"name":"remove","parameterTypes":["int"] }, {"name":"set","parameterTypes":["int","java.lang.Object"] }, {"name":"subList","parameterTypes":["int","int"] }] +}, +{ + "name":"java.util.AbstractMap", + "queryAllDeclaredMethods":true, + "methods":[{"name":"clear","parameterTypes":[] }, {"name":"containsKey","parameterTypes":["java.lang.Object"] }, {"name":"containsValue","parameterTypes":["java.lang.Object"] }, {"name":"entrySet","parameterTypes":[] }, {"name":"equals","parameterTypes":["java.lang.Object"] }, {"name":"get","parameterTypes":["java.lang.Object"] }, {"name":"hashCode","parameterTypes":[] }, {"name":"isEmpty","parameterTypes":[] }, {"name":"keySet","parameterTypes":[] }, {"name":"put","parameterTypes":["java.lang.Object","java.lang.Object"] }, {"name":"putAll","parameterTypes":["java.util.Map"] }, {"name":"remove","parameterTypes":["java.lang.Object"] }, {"name":"size","parameterTypes":[] }, {"name":"values","parameterTypes":[] }] +}, +{ + "name":"java.util.ArrayList", + "methods":[{"name":"","parameterTypes":["java.util.Collection"] }] +}, +{ + "name":"java.util.Arrays", + "methods":[{"name":"asList","parameterTypes":["java.lang.Object[]"] }] +}, +{ + "name":"java.util.BitSet" +}, +{ + "name":"java.util.Collection", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "methods":[{"name":"add","parameterTypes":["java.lang.Object"] }, {"name":"addAll","parameterTypes":["java.util.Collection"] }, {"name":"isEmpty","parameterTypes":[] }, {"name":"retainAll","parameterTypes":["java.util.Collection"] }, {"name":"size","parameterTypes":[] }] +}, +{ + "name":"java.util.Collections", + "methods":[{"name":"emptyList","parameterTypes":[] }, {"name":"reverseOrder","parameterTypes":[] }, {"name":"singletonList","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"java.util.Comparator", + "methods":[{"name":"compare","parameterTypes":["java.lang.Object","java.lang.Object"] }] +}, +{ + "name":"java.util.Date" +}, +{ + "name":"java.util.Deque", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.Enumeration", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.HashSet", + "methods":[{"name":"","parameterTypes":["java.util.Collection"] }] +}, +{ + "name":"java.util.Iterator", + "queryAllPublicMethods":true, + "methods":[{"name":"hasNext","parameterTypes":[] }, {"name":"next","parameterTypes":[] }] +}, +{ + "name":"java.util.List", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "methods":[{"name":"contains","parameterTypes":["java.lang.Object"] }, {"name":"get","parameterTypes":["int"] }] +}, +{ + "name":"java.util.Locale" +}, +{ + "name":"java.util.Map", + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "methods":[{"name":"clear","parameterTypes":[] }, {"name":"get","parameterTypes":["java.lang.Object"] }, {"name":"getOrDefault","parameterTypes":["java.lang.Object","java.lang.Object"] }, {"name":"put","parameterTypes":["java.lang.Object","java.lang.Object"] }] +}, +{ + "name":"java.util.Map$Entry" +}, +{ + "name":"java.util.Objects", + "methods":[{"name":"equals","parameterTypes":["java.lang.Object","java.lang.Object"] }] +}, +{ + "name":"java.util.Optional" +}, +{ + "name":"java.util.OptionalDouble" +}, +{ + "name":"java.util.OptionalInt" +}, +{ + "name":"java.util.OptionalLong" +}, +{ + "name":"java.util.Properties", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"java.util.PropertyPermission" +}, +{ + "name":"java.util.Queue", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.Random" +}, +{ + "name":"java.util.ResourceBundle", + "queryAllDeclaredMethods":true +}, +{ + "name":"java.util.Set", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.SortedMap", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.SortedSet", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.Spliterator", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.TimeZone", + "methods":[{"name":"getOffset","parameterTypes":["long"] }] +}, +{ + "name":"java.util.Timer" +}, +{ + "name":"java.util.TimerTask" +}, +{ + "name":"java.util.concurrent.BlockingQueue", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.concurrent.Callable", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"java.util.concurrent.ForkJoinTask", + "fields":[{"name":"aux"}, {"name":"status"}] +}, +{ + "name":"java.util.concurrent.Future", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.concurrent.atomic.AtomicBoolean", + "fields":[{"name":"value"}] +}, +{ + "name":"java.util.concurrent.atomic.AtomicReference", + "fields":[{"name":"value"}] +}, +{ + "name":"java.util.function.BiPredicate", + "methods":[{"name":"test","parameterTypes":["java.lang.Object","java.lang.Object"] }] +}, +{ + "name":"java.util.function.Consumer", + "methods":[{"name":"accept","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"java.util.function.DoubleFunction", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.function.DoublePredicate", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.function.Function", + "queryAllPublicMethods":true, + "methods":[{"name":"apply","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"java.util.function.IntFunction", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.function.IntPredicate", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.function.LongFunction", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.function.LongPredicate", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.function.Predicate", + "methods":[{"name":"test","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"java.util.function.Supplier", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.function.ToDoubleFunction", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.function.ToIntFunction", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.function.ToLongFunction", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.regex.MatchResult", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.regex.Matcher" +}, +{ + "name":"java.util.regex.Pattern" +}, +{ + "name":"java.util.stream.BaseStream", + "queryAllPublicMethods":true +}, +{ + "name":"java.util.stream.DoubleStream" +}, +{ + "name":"java.util.stream.IntStream" +}, +{ + "name":"java.util.stream.LongStream" +}, +{ + "name":"java.util.stream.Stream", + "queryAllPublicMethods":true +}, +{ + "name":"javax.security.auth.x500.X500Principal", + "fields":[{"name":"thisX500Name"}], + "methods":[{"name":"","parameterTypes":["sun.security.x509.X500Name"] }] +}, +{ + "name":"javax.smartcardio.CardPermission" +}, +{ + "name":"javax.xml.bind.annotation.XmlElement", + "methods":[{"name":"type","parameterTypes":[] }] +}, +{ + "name":"jdk.internal.reflect.CallerSensitive", + "queryAllDeclaredMethods":true +}, +{ + "name":"jdk.internal.vm.annotation.ForceInline", + "queryAllDeclaredMethods":true +}, +{ + "name":"jdk.internal.vm.annotation.IntrinsicCandidate", + "queryAllDeclaredMethods":true +}, +{ + "name":"jdk.internal.vm.annotation.Stable", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.DataContext", + "methods":[{"name":"get","parameterTypes":["java.lang.String"] }, {"name":"getQueryProvider","parameterTypes":[] }, {"name":"getRootSchema","parameterTypes":[] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.BasicAggregateLambdaFactory", + "queryAllDeclaredConstructors":true +}, +{ + "name":"org.apache.calcite.adapter.enumerable.BasicLazyAccumulator", + "queryAllDeclaredConstructors":true +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.LazyAggregateLambdaFactory", + "queryAllDeclaredConstructors":true +}, +{ + "name":"org.apache.calcite.adapter.enumerable.MatchUtils", + "methods":[{"name":"lastWithSymbol","parameterTypes":["java.lang.String","java.util.List","java.util.List","int"] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$ArgMinMaxImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$BitOpImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$CollectImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$CountImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$CountWinImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$DenseRankImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$FirstValueImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$FusionImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$GroupingImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$IntersectionImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$LagImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$LastValueImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$LeadImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$ListaggImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$LiteralAggImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$MinMaxImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$ModeImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$NthValueImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$NtileImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$RankImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$RowNumberImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$SingleValueImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.RexImpTable$SumImplementor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.enumerable.SourceSorter", + "queryAllDeclaredConstructors":true +}, +{ + "name":"org.apache.calcite.adapter.java.ReflectiveSchema", + "methods":[{"name":"getTarget","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.adapter.jdbc.JdbcSchema", + "methods":[{"name":"getDataSource","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.avatica.AvaticaJdbc41Factory", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.avatica.remote.Driver" +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.interpreter.Context", + "fields":[{"name":"root"}, {"name":"values"}] +}, +{ + "name":"org.apache.calcite.interpreter.Row", + "methods":[{"name":"asCopy","parameterTypes":["java.lang.Object[]"] }, {"name":"getObject","parameterTypes":["int"] }] +}, +{ + "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[]"] }] +}, +{ + "name":"org.apache.calcite.jdbc.CalciteJdbc41Factory", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.jdbc.Driver" +}, +{ + "name":"org.apache.calcite.linq4j.AbstractEnumerable", + "queryAllDeclaredConstructors":true +}, +{ + "name":"org.apache.calcite.linq4j.Enumerable", + "methods":[{"name":"asQueryable","parameterTypes":[] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.linq4j.Enumerator", + "methods":[{"name":"close","parameterTypes":[] }, {"name":"current","parameterTypes":[] }, {"name":"moveNext","parameterTypes":[] }, {"name":"reset","parameterTypes":[] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.linq4j.ExtendedQueryable", + "methods":[{"name":"select","parameterTypes":["org.apache.calcite.linq4j.tree.FunctionExpression"] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.linq4j.MemoryFactory$Memory", + "methods":[{"name":"get","parameterTypes":[] }, {"name":"get","parameterTypes":["int"] }] +}, +{ + "name":"org.apache.calcite.linq4j.Queryable" +}, +{ + "name":"org.apache.calcite.linq4j.RawEnumerable", + "methods":[{"name":"enumerator","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.linq4j.function.Function0", + "methods":[{"name":"apply","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.linq4j.function.Function1", + "methods":[{"name":"apply","parameterTypes":["java.lang.Object"] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.linq4j.tree.Primitive", + "methods":[{"name":"asList","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$AllPredicates", + "methods":[{"name":"getAllPredicates","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$AllPredicates$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Collation", + "methods":[{"name":"collations","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Collation$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ColumnOrigin", + "methods":[{"name":"getColumnOrigins","parameterTypes":["int"] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ColumnOrigin$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ColumnUniqueness", + "methods":[{"name":"areColumnsUnique","parameterTypes":["org.apache.calcite.util.ImmutableBitSet","boolean"] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ColumnUniqueness$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$CumulativeCost", + "methods":[{"name":"getCumulativeCost","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$CumulativeCost$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$DistinctRowCount", + "methods":[{"name":"getDistinctRowCount","parameterTypes":["org.apache.calcite.util.ImmutableBitSet","org.apache.calcite.rex.RexNode"] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$DistinctRowCount$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Distribution", + "methods":[{"name":"distribution","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Distribution$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ExplainVisibility", + "methods":[{"name":"isVisibleInExplain","parameterTypes":["org.apache.calcite.sql.SqlExplainLevel"] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ExplainVisibility$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ExpressionLineage", + "methods":[{"name":"getExpressionLineage","parameterTypes":["org.apache.calcite.rex.RexNode"] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$ExpressionLineage$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$LowerBoundCost", + "methods":[{"name":"getLowerBoundCost","parameterTypes":["org.apache.calcite.plan.volcano.VolcanoPlanner"] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$LowerBoundCost$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$MaxRowCount", + "methods":[{"name":"getMaxRowCount","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$MaxRowCount$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Memory", + "methods":[{"name":"cumulativeMemoryWithinPhase","parameterTypes":[] }, {"name":"cumulativeMemoryWithinPhaseSplit","parameterTypes":[] }, {"name":"memory","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Memory$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$MinRowCount", + "methods":[{"name":"getMinRowCount","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$MinRowCount$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$NodeTypes", + "methods":[{"name":"getNodeTypes","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$NodeTypes$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$NonCumulativeCost", + "methods":[{"name":"getNonCumulativeCost","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$NonCumulativeCost$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Parallelism", + "methods":[{"name":"isPhaseTransition","parameterTypes":[] }, {"name":"splitCount","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Parallelism$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$PercentageOriginalRows", + "methods":[{"name":"getPercentageOriginalRows","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$PercentageOriginalRows$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$PopulationSize", + "methods":[{"name":"getPopulationSize","parameterTypes":["org.apache.calcite.util.ImmutableBitSet"] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$PopulationSize$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Predicates", + "methods":[{"name":"getPredicates","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Predicates$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$RowCount", + "methods":[{"name":"getRowCount","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$RowCount$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Selectivity", + "methods":[{"name":"getSelectivity","parameterTypes":["org.apache.calcite.rex.RexNode"] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Selectivity$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Size", + "methods":[{"name":"averageColumnSizes","parameterTypes":[] }, {"name":"averageRowSize","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$Size$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$TableReferences", + "methods":[{"name":"getTableReferences","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$TableReferences$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$UniqueKeys", + "methods":[{"name":"getUniqueKeys","parameterTypes":["boolean"] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.BuiltInMetadata$UniqueKeys$Handler", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.Metadata", + "methods":[{"name":"rel","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdAllPredicates", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdCollation", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdColumnOrigins", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdColumnUniqueness", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdDistinctRowCount", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdDistribution", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdExplainVisibility", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdExpressionLineage", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdLowerBoundCost", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdMaxRowCount", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdMemory", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdMinRowCount", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdNodeTypes", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdParallelism", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdPercentageOriginalRows$RelMdCumulativeCost", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdPercentageOriginalRows$RelMdNonCumulativeCost", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdPercentageOriginalRows$RelMdPercentageOriginalRowsHandler", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdPopulationSize", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdPredicates", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdRowCount", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdSelectivity", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdSize", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdTableReferences", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.rel.metadata.RelMdUniqueKeys", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.calcite.runtime.ArrayBindable", + "methods":[{"name":"getElementType","parameterTypes":[] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.runtime.Bindable", + "methods":[{"name":"bind","parameterTypes":["org.apache.calcite.DataContext"] }] +}, +{ + "name":"org.apache.calcite.runtime.CompressionFunctions", + "methods":[{"name":"compress","parameterTypes":["java.lang.String"] }] +}, +{ + "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"] }] +}, +{ + "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"] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.runtime.FunctionContexts", + "methods":[{"name":"of","parameterTypes":["org.apache.calcite.DataContext","java.lang.Object[]"] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.runtime.Matcher", + "methods":[{"name":"builder","parameterTypes":["org.apache.calcite.runtime.Automaton"] }] +}, +{ + "name":"org.apache.calcite.runtime.Matcher$Builder", + "methods":[{"name":"add","parameterTypes":["java.lang.String","java.util.function.Predicate"] }, {"name":"build","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.runtime.PairList", + "methods":[{"name":"copyOf","parameterTypes":["java.lang.Object","java.lang.Object","java.lang.Object[]"] }] +}, +{ + "name":"org.apache.calcite.runtime.Pattern$PatternBuilder", + "methods":[{"name":"automaton","parameterTypes":[] }, {"name":"build","parameterTypes":[] }, {"name":"seq","parameterTypes":[] }, {"name":"symbol","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"org.apache.calcite.runtime.RandomFunction", + "methods":[{"name":"rand","parameterTypes":[] }, {"name":"randInteger","parameterTypes":["int"] }, {"name":"randIntegerSeed","parameterTypes":["int","int"] }, {"name":"randSeed","parameterTypes":["int"] }] +}, +{ + "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"] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.runtime.SpatialTypeFunctions", + "methods":[{"name":"ST_GeomFromEWKT","parameterTypes":["java.lang.String"] }] +}, +{ + "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"] }] +}, +{ + "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":[] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.schema.ModifiableTable", + "methods":[{"name":"getModifiableCollection","parameterTypes":[] }] +}, +{ + "name":"org.apache.calcite.schema.QueryableTable", + "methods":[{"name":"asQueryable","parameterTypes":["org.apache.calcite.linq4j.QueryProvider","org.apache.calcite.schema.SchemaPlus","java.lang.String"] }] +}, +{ + "name":"org.apache.calcite.schema.ScannableTable", + "methods":[{"name":"scan","parameterTypes":["org.apache.calcite.DataContext"] }] +}, +{ + "name":"org.apache.calcite.schema.Schema", + "methods":[{"name":"getSubSchema","parameterTypes":["java.lang.String"] }, {"name":"getTable","parameterTypes":["java.lang.String"] }] +}, +{ + "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"] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.calcite.sql.fun.SqlLibraryOperators", + "allPublicFields":true +}, +{ + "name":"org.apache.calcite.sql.fun.SqlStdOperatorTable", + "allPublicFields":true +}, +{ + "name":"org.apache.calcite.sql2rel.StandardConvertletTable", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.maven.surefire.junitplatform.JUnitPlatformProvider", + "methods":[{"name":"","parameterTypes":["org.apache.maven.surefire.api.provider.ProviderParameters"] }] +}, +{ + "name":"org.apache.shardingsphere.authority.provider.database.DatabasePermittedAuthorityRegistryProvider", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.authority.provider.simple.AllPermittedAuthorityRegistryProvider", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.authority.yaml.config.YamlAuthorityRuleConfiguration" +}, +{ + "name":"org.apache.shardingsphere.broadcast.yaml.config.YamlBroadcastRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getTables","parameterTypes":[] }, {"name":"setTables","parameterTypes":["java.util.Collection"] }] +}, +{ + "name":"org.apache.shardingsphere.broadcast.yaml.config.YamlBroadcastRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.broadcast.yaml.config.YamlBroadcastRuleConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.driver.ShardingSphereDriver" +}, +{ + "name":"org.apache.shardingsphere.driver.api.yaml.YamlJDBCConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":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"] }, {"name":"setSqlParser","parameterTypes":["org.apache.shardingsphere.parser.yaml.config.YamlSQLParserRuleConfiguration"] }] +}, +{ + "name":"org.apache.shardingsphere.driver.api.yaml.YamlJDBCConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.driver.api.yaml.YamlJDBCConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.encrypt.algorithm.assisted.MD5AssistedEncryptAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.encrypt.algorithm.standard.AESEncryptAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.encrypt.api.encrypt.assisted.AssistedEncryptAlgorithm", + "allDeclaredClasses":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm", + "allDeclaredClasses":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.YamlCompatibleEncryptRuleConfiguration" +}, +{ + "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"] }] +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.YamlEncryptRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.YamlEncryptRuleConfigurationCustomizer" +}, +{ + "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.YamlEncryptColumnItemRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptColumnItemRuleConfigurationCustomizer" +}, +{ + "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"] }] +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptColumnRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptColumnRuleConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptTableRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getColumns","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }, {"name":"setColumns","parameterTypes":["java.util.Map"] }] +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptTableRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.encrypt.yaml.config.rule.YamlEncryptTableRuleConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.globalclock.core.yaml.config.YamlGlobalClockRuleConfiguration" +}, +{ + "name":"org.apache.shardingsphere.infra.algorithm.ShardingSphereAlgorithm", + "allDeclaredClasses":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.FileTestUtils", + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.EncryptTest", + "allDeclaredFields":true, + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"testEncryptInLocalTransactions","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.MaskTest", + "allDeclaredFields":true, + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"testMaskInLocalTransactions","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.ReadWriteSplittingTest", + "allDeclaredFields":true, + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.ShadowTest", + "allDeclaredFields":true, + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"testShadowInLocalTransactions","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.ShardingTest", + "allDeclaredFields":true, + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"testShardingInLocalTransactions","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.TestQueryAssistedShardingEncryptAlgorithm", + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Address", + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.Order", + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.entity.OrderItem", + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.AddressRepository", + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderItemRepository", + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.infra.nativetest.jdbc.features.repository.OrderRepository", + "allDeclaredClasses":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.infra.parser.cache.SQLStatementCacheLoader" +}, +{ + "name":"org.apache.shardingsphere.infra.spi.type.typed.TypedSPI", + "allDeclaredClasses":true, + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.algorithm.YamlAlgorithmConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getProps","parameterTypes":[] }, {"name":"getType","parameterTypes":[] }, {"name":"setProps","parameterTypes":["java.util.Properties"] }, {"name":"setType","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.algorithm.YamlAlgorithmConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.algorithm.YamlAlgorithmConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlModeConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setRepository","parameterTypes":["org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlPersistRepositoryConfiguration"] }, {"name":"setType","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlModeConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlModeConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlPersistRepositoryConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"setType","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlPersistRepositoryConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.config.pojo.mode.YamlPersistRepositoryConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.config.shortcut.YamlRuleConfigurationShortcuts", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereColumn", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"getDataType","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }, {"name":"isCaseSensitive","parameterTypes":[] }, {"name":"isGenerated","parameterTypes":[] }, {"name":"isNullable","parameterTypes":[] }, {"name":"isPrimaryKey","parameterTypes":[] }, {"name":"isUnsigned","parameterTypes":[] }, {"name":"isVisible","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereColumnBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereColumnCustomizer" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereIndex", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"getColumns","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }, {"name":"isUnique","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereIndexBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereIndexCustomizer" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereTable", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"getColumns","parameterTypes":[] }, {"name":"getConstraints","parameterTypes":[] }, {"name":"getIndexes","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereTableBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.infra.yaml.schema.pojo.YamlShardingSphereTableCustomizer" +}, +{ + "name":"org.apache.shardingsphere.logging.yaml.config.YamlLoggingRuleConfiguration" +}, +{ + "name":"org.apache.shardingsphere.mask.algorithm.cover.KeepFirstNLastMMaskAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.mask.algorithm.cover.KeepFromXToYMaskAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.mask.algorithm.cover.MaskAfterSpecialCharsAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.mask.algorithm.cover.MaskBeforeSpecialCharsAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.mask.algorithm.cover.MaskFirstNLastMMaskAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.mask.algorithm.cover.MaskFromXToYMaskAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.mask.algorithm.hash.MD5MaskAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.mask.algorithm.replace.GenericTableRandomReplaceAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.shardingsphere.mask.yaml.config.YamlMaskRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.mask.yaml.config.YamlMaskRuleConfigurationCustomizer" +}, +{ + "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"] }] +}, +{ + "name":"org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskColumnRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskColumnRuleConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskTableRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getColumns","parameterTypes":[] }, {"name":"getName","parameterTypes":[] }, {"name":"setColumns","parameterTypes":["java.util.Map"] }] +}, +{ + "name":"org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskTableRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.mask.yaml.config.rule.YamlMaskTableRuleConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.mode.manager.standalone.subscriber.StandaloneProcessSubscriber", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.shardingsphere.mode.process.ProcessSubscriber", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.apache.shardingsphere.mode.repository.standalone.jdbc.JDBCRepository", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.mode.repository.standalone.jdbc.sql.JDBCRepositorySQL", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserCacheOptionRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserCacheOptionRuleConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getParseTreeCache","parameterTypes":[] }, {"name":"getSqlStatementCache","parameterTypes":[] }, {"name":"isSqlCommentParseEnabled","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"] }] +}, +{ + "name":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.parser.yaml.config.YamlSQLParserRuleConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.readwritesplitting.yaml.config.YamlReadwriteSplittingRuleConfiguration" +}, +{ + "name":"org.apache.shardingsphere.shadow.algorithm.shadow.column.ColumnRegexMatchedShadowAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.shadow.algorithm.shadow.column.ColumnValueMatchedShadowAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.shadow.algorithm.shadow.hint.SQLHintShadowAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.shardingsphere.shadow.yaml.config.YamlShadowRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.shadow.yaml.config.YamlShadowRuleConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.shadow.yaml.config.datasource.YamlShadowDataSourceConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getProductionDataSourceName","parameterTypes":[] }, {"name":"getShadowDataSourceName","parameterTypes":[] }, {"name":"setProductionDataSourceName","parameterTypes":["java.lang.String"] }, {"name":"setShadowDataSourceName","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"org.apache.shardingsphere.shadow.yaml.config.datasource.YamlShadowDataSourceConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.shadow.yaml.config.datasource.YamlShadowDataSourceConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.shadow.yaml.config.table.YamlShadowTableConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getDataSourceNames","parameterTypes":[] }, {"name":"getShadowAlgorithmNames","parameterTypes":[] }, {"name":"setDataSourceNames","parameterTypes":["java.util.Collection"] }, {"name":"setShadowAlgorithmNames","parameterTypes":["java.util.Collection"] }] +}, +{ + "name":"org.apache.shardingsphere.shadow.yaml.config.table.YamlShadowTableConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.shadow.yaml.config.table.YamlShadowTableConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.audit.DMLShardingConditionsShardingAuditAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.keygen.SnowflakeKeyGenerateAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.keygen.UUIDKeyGenerateAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.classbased.ClassBasedShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.datetime.AutoIntervalShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.datetime.IntervalShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.hint.HintInlineShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.inline.ComplexInlineShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.inline.InlineShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.mod.HashModShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.mod.ModShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.range.BoundaryBasedRangeShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.algorithm.sharding.range.VolumeBasedRangeShardingAlgorithm", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "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"] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.rule.YamlTableRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getActualDataNodes","parameterTypes":[] }, {"name":"getAuditStrategy","parameterTypes":[] }, {"name":"getDatabaseStrategy","parameterTypes":[] }, {"name":"getKeyGenerateStrategy","parameterTypes":[] }, {"name":"getLogicTable","parameterTypes":[] }, {"name":"getTableStrategy","parameterTypes":[] }, {"name":"setActualDataNodes","parameterTypes":["java.lang.String"] }, {"name":"setKeyGenerateStrategy","parameterTypes":["org.apache.shardingsphere.sharding.yaml.config.strategy.keygen.YamlKeyGenerateStrategyConfiguration"] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.rule.YamlTableRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.rule.YamlTableRuleConfigurationCustomizer" +}, +{ + "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"] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.keygen.YamlKeyGenerateStrategyConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.keygen.YamlKeyGenerateStrategyConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlShardingStrategyConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"","parameterTypes":[] }, {"name":"getComplex","parameterTypes":[] }, {"name":"getHint","parameterTypes":[] }, {"name":"getNone","parameterTypes":[] }, {"name":"getStandard","parameterTypes":[] }, {"name":"setStandard","parameterTypes":["org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlStandardShardingStrategyConfiguration"] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlShardingStrategyConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlShardingStrategyConfigurationCustomizer" +}, +{ + "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"] }] +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlStandardShardingStrategyConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.sharding.yaml.config.strategy.sharding.YamlStandardShardingStrategyConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.single.yaml.config.pojo.YamlSingleRuleConfiguration", + "allDeclaredFields":true, + "queryAllPublicMethods":true, + "methods":[{"name":"getDefaultDataSource","parameterTypes":[] }, {"name":"getTables","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.single.yaml.config.pojo.YamlSingleRuleConfigurationBeanInfo" +}, +{ + "name":"org.apache.shardingsphere.single.yaml.config.pojo.YamlSingleRuleConfigurationCustomizer" +}, +{ + "name":"org.apache.shardingsphere.sql.parser.core.database.cache.ParseTreeCacheLoader" +}, +{ + "name":"org.apache.shardingsphere.sql.parser.mysql.parser.MySQLLexer", + "methods":[{"name":"","parameterTypes":["org.antlr.v4.runtime.CharStream"] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.mysql.parser.MySQLParser", + "methods":[{"name":"","parameterTypes":["org.antlr.v4.runtime.TokenStream"] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.mysql.visitor.statement.MySQLStatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.mysql.visitor.statement.type.MySQLDDLStatementVisitor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.mysql.visitor.statement.type.MySQLDMLStatementVisitor", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.opengauss.visitor.statement.OpenGaussStatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.oracle.visitor.statement.OracleStatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.postgresql.visitor.statement.PostgreSQLStatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.dml.MySQLDeleteStatement", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.dml.MySQLInsertStatement", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.dml.MySQLSelectStatement", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.sql92.visitor.statement.SQL92StatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sql.parser.sqlserver.visitor.statement.SQLServerStatementVisitorFacade", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.sqlfederation.optimizer.planner.util.SQLFederationFunctionUtils", + "queryAllPublicMethods":true +}, +{ + "name":"org.apache.shardingsphere.sqlfederation.yaml.config.YamlSQLFederationRuleConfiguration" +}, +{ + "name":"org.apache.shardingsphere.sqltranslator.yaml.config.YamlSQLTranslatorRuleConfiguration" +}, +{ + "name":"org.apache.shardingsphere.timeservice.type.system.SystemTimestampService", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.apache.shardingsphere.traffic.yaml.config.YamlTrafficRuleConfiguration" +}, +{ + "name":"org.apache.shardingsphere.transaction.yaml.config.YamlTransactionRuleConfiguration" +}, +{ + "name":"org.apiguardian.api.API", + "queryAllPublicMethods":true +}, +{ + "name":"org.codehaus.groovy.reflection.stdclasses.CachedSAMClass", + "methods":[{"name":"coerceToSAM","parameterTypes":["groovy.lang.Closure","java.lang.reflect.Method","java.lang.Class"] }] +}, +{ + "name":"org.codehaus.groovy.runtime.DefaultGroovyMethodsSupport", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.codehaus.groovy.runtime.DefaultGroovyStaticMethods", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.codehaus.groovy.runtime.GStringImpl", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"org.codehaus.groovy.runtime.GStringImplBeanInfo" +}, +{ + "name":"org.codehaus.groovy.runtime.GStringImplCustomizer" +}, +{ + "name":"org.codehaus.groovy.runtime.GeneratedClosure", + "allDeclaredFields":true, + "queryAllDeclaredMethods":true, + "queryAllPublicMethods":true, + "queryAllDeclaredConstructors":true +}, +{ + "name":"org.codehaus.groovy.runtime.GroovyCategorySupport", + "methods":[{"name":"hasCategoryInCurrentThread","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.InvokerHelper", + "methods":[{"name":"getMetaClass","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"org.codehaus.groovy.runtime.NullObject" +}, +{ + "name":"org.codehaus.groovy.runtime.callsite.CallSite", + "queryAllPublicMethods":true +}, +{ + "name":"org.codehaus.groovy.runtime.dgm$560", + "methods":[{"name":"","parameterTypes":["java.lang.String","org.codehaus.groovy.reflection.CachedClass","java.lang.Class","java.lang.Class[]"] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.NumberNumberDiv", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.NumberNumberMinus", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.NumberNumberMultiply", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.NumberNumberPlus", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.BooleanArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.BooleanArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ByteArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ByteArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.CharacterArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.CharacterArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.DoubleArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.DoubleArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.FloatArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.FloatArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.IntegerArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.IntegerArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.LongArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.LongArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ObjectArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ObjectArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ShortArrayGetAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.dgmimpl.arrays.ShortArrayPutAtMetaMethod", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation", + "methods":[{"name":"castToType","parameterTypes":["java.lang.Object","java.lang.Class"] }] +}, +{ + "name":"org.codehaus.groovy.runtime.typehandling.GroovyCastException", + "methods":[{"name":"","parameterTypes":["java.lang.Object","java.lang.Class"] }] +}, +{ + "name":"org.codehaus.groovy.vmplugin.v10.PluginDefaultGroovyMethods", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.codehaus.groovy.vmplugin.v16.Java16", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.codehaus.groovy.vmplugin.v8.IndyGuardsFiltersAndSignatures", + "methods":[{"name":"invokeGroovyObjectInvoker","parameterTypes":["groovy.lang.MissingMethodException","java.lang.Object","java.lang.String","java.lang.Object[]"] }, {"name":"isNull","parameterTypes":["java.lang.Object"] }, {"name":"isSameMetaClass","parameterTypes":["groovy.lang.MetaClass","java.lang.Object"] }, {"name":"sameClass","parameterTypes":["java.lang.Class","java.lang.Object"] }, {"name":"sameClasses","parameterTypes":["java.lang.Class[]","java.lang.Object[]"] }, {"name":"setBeanProperties","parameterTypes":["groovy.lang.MetaClass","java.lang.Object","java.util.Map"] }, {"name":"unwrap","parameterTypes":["groovy.lang.GroovyRuntimeException"] }, {"name":"unwrap","parameterTypes":["java.lang.Object"] }] +}, +{ + "name":"org.codehaus.groovy.vmplugin.v8.IndyInterface", + "methods":[{"name":"fromCache","parameterTypes":["java.lang.invoke.MutableCallSite","java.lang.Class","java.lang.String","int","java.lang.Boolean","java.lang.Boolean","java.lang.Boolean","java.lang.Object","java.lang.Object[]"] }, {"name":"selectMethod","parameterTypes":["java.lang.invoke.MutableCallSite","java.lang.Class","java.lang.String","int","java.lang.Boolean","java.lang.Boolean","java.lang.Boolean","java.lang.Object","java.lang.Object[]"] }] +}, +{ + "name":"org.codehaus.groovy.vmplugin.v8.PluginDefaultGroovyMethods", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.codehaus.groovy.vmplugin.v9.PluginDefaultGroovyMethods", + "queryAllDeclaredMethods":true +}, +{ + "name":"org.h2.Driver", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.h2.mvstore.MVStore$TxCounter", + "fields":[{"name":"counter"}] +}, +{ + "name":"org.h2.mvstore.Page", + "fields":[{"name":"pos"}] +}, +{ + "name":"org.junit.internal.AssumptionViolatedException" +}, +{ + "name":"org.junit.jupiter.api.Disabled", + "queryAllPublicMethods":true +}, +{ + "name":"org.junit.jupiter.api.Test", + "queryAllPublicMethods":true +}, +{ + "name":"org.junit.jupiter.api.condition.DisabledIfSystemProperty", + "queryAllPublicMethods":true +}, +{ + "name":"org.junit.jupiter.api.condition.DisabledIfSystemPropertyCondition", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"org.junit.jupiter.api.condition.DisabledInNativeImage", + "queryAllPublicMethods":true +}, +{ + "name":"org.junit.jupiter.api.extension.ExtendWith", + "queryAllPublicMethods":true +}, +{ + "name":"org.junit.platform.commons.annotation.Testable", + "queryAllPublicMethods":true +}, +{ + "name":"org.junit.platform.launcher.LauncherSession", + "methods":[{"name":"getLauncher","parameterTypes":[] }] +}, +{ + "name":"org.junit.platform.launcher.core.LauncherFactory", + "methods":[{"name":"openSession","parameterTypes":[] }] +}, +{ + "name":"org.locationtech.jts.geom.Geometry" +}, +{ + "name":"org.slf4j.event.Level", + "methods":[{"name":"valueOf","parameterTypes":["java.lang.String"] }] +}, +{ + "name":"sun.misc.Unsafe", + "allDeclaredFields":true +}, +{ + "name":"sun.security.provider.DSA$SHA256withDSA", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"sun.security.provider.DSAKeyFactory", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"sun.security.provider.DSAParameters", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"sun.security.provider.MD5", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"sun.security.provider.NativePRNG", + "methods":[{"name":"","parameterTypes":[] }, {"name":"","parameterTypes":["java.security.SecureRandomParameters"] }] +}, +{ + "name":"sun.security.provider.SHA", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"sun.security.provider.SHA2$SHA256", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"sun.security.provider.SecureRandom", + "methods":[{"name":"","parameterTypes":[] }, {"name":"","parameterTypes":["java.security.SecureRandomParameters"] }] +}, +{ + "name":"sun.security.provider.X509Factory", + "methods":[{"name":"","parameterTypes":[] }] +}, +{ + "name":"sun.security.util.ObjectIdentifier" +}, +{ + "name":"sun.security.x509.CertificateExtensions" +} +] 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..58c0bb96ac32e9 --- /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,135 @@ +{ + "resources":{ + "includes":[{ + "pattern":"\\QMETA-INF/dgminfo\\E" + }, { + "pattern":"\\QMETA-INF/groovy/org.codehaus.groovy.source.Extensions\\E" + }, { + "pattern":"\\QMETA-INF/services/java.nio.file.spi.FileSystemProvider\\E" + }, { + "pattern":"\\QMETA-INF/services/java.sql.Driver\\E" + }, { + "pattern":"\\QMETA-INF/services/javax.xml.bind.JAXBContext\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.maven.surefire.spi.MasterProcessChannelProcessorFactory\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.authority.spi.AuthorityRegistryProvider\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.driver.state.DriverState\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.config.rule.checker.RuleConfigurationChecker\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.config.rule.decorator.RuleConfigurationDecorator\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.connection.refresher.MetaDataRefresher\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.database.core.connector.ConnectionPropertiesParser\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.database.core.metadata.data.loader.DialectMetaDataLoader\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.database.core.metadata.database.DialectDatabaseMetaData\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.database.core.metadata.database.system.DialectSystemDatabase\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.database.core.type.DatabaseType\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.datanode.DataNodeBuilder\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.datasource.pool.metadata.DataSourcePoolMetaData\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.executor.audit.SQLAuditor\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.executor.sql.prepare.driver.SQLExecutionUnitBuilder\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.expr.spi.InlineExpressionParser\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.instance.metadata.InstanceMetaDataBuilder\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.merge.engine.ResultProcessEngine\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.reviser.MetaDataReviseEntry\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.metadata.statistics.builder.ShardingSphereStatisticsBuilder\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.rewrite.context.SQLRewriteContextDecorator\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.route.SQLRouter\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilder\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.rule.builder.global.DefaultGlobalRuleConfigurationBuilder\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.rule.builder.global.GlobalRuleBuilder\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.util.yaml.constructor.ShardingSphereYamlConstruct\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.util.yaml.representer.processor.ShardingSphereYamlTupleProcessor\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.util.yaml.shortcuts.ShardingSphereYamlShortcuts\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.mode.YamlPersistRepositoryConfigurationSwapper\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.NewYamlGlobalRuleConfigurationSwapper\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.NewYamlRuleConfigurationSwapper\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.mask.spi.MaskAlgorithm\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.mode.manager.ContextManagerBuilder\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.mode.repository.standalone.StandalonePersistRepository\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.shadow.spi.ShadowAlgorithm\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sharding.spi.KeyGenerateAlgorithm\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAlgorithm\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sql.parser.spi.SQLDialectParserFacade\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sql.parser.spi.SQLStatementVisitorFacade\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sqlfederation.optimizer.context.parser.dialect.OptimizerSQLDialectBuilder\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sqlfederation.spi.SQLFederationDecider\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.sqltranslator.spi.SQLTranslator\\E" + }, { + "pattern":"\\QMETA-INF/services/org.apache.shardingsphere.timeservice.spi.TimestampService\\E" + }, { + "pattern":"\\QMETA-INF/services/org.codehaus.groovy.transform.ASTTransformation\\E" + }, { + "pattern":"\\QMETA-INF/services/org.junit.platform.engine.TestEngine\\E" + }, { + "pattern":"\\QMETA-INF/services/org.junit.platform.launcher.TestExecutionListener\\E" + }, { + "pattern":"\\QMETA-INF/services/org.slf4j.spi.SLF4JServiceProvider\\E" + }, { + "pattern":"\\Qlogback.xml\\E" + }, { + "pattern":"\\Qorg/h2/util/data.zip\\E" + }, { + "pattern":"\\Qsaffron.properties\\E" + }, { + "pattern":"\\Qsql\\E" + }, { + "pattern":"\\Qyaml/encrypt.yaml\\E" + }, { + "pattern":"\\Qyaml/mask.yaml\\E" + }, { + "pattern":"\\Qyaml/shadow.yaml\\E" + }, { + "pattern":"\\Qyaml/sharding.yaml\\E" + }, { + "pattern":"java.base:\\Qjdk/internal/icu/impl/data/icudt67b/nfkc.nrm\\E" + }]}, + "bundles":[] +} diff --git a/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/serialization-config.json b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/serialization-config.json new file mode 100644 index 00000000000000..fc967f7f8d99a4 --- /dev/null +++ b/infra/reachability-metadata/src/main/resources/META-INF/native-image/org.apache.shardingsphere/shardingsphere-infra-reachability-metadata/serialization-config.json @@ -0,0 +1,11 @@ +{ + "types":[ + { + "name":"org.junit.platform.launcher.TestIdentifier$SerializedForm" + } + ], + "lambdaCapturingTypes":[ + ], + "proxies":[ + ] +} 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/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 8361a0161b790c..d8e824762311c0 100644 --- a/pom.xml +++ b/pom.xml @@ -154,7 +154,7 @@ 1.4.13 4.0.0 1.6.2 - 0.9.27 + 0.9.28 1.0.0 @@ -998,8 +998,9 @@ - generateStandardMetadata + generateMetadata + 17 true true true @@ -1007,64 +1008,107 @@ 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 + + Standard + + + ${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 + + + + +