test: more reduce tests

.cargo/config.toml

@@ -3,3 +3,18 @@ linker = "aarch64-linux-gnu-gcc"
 
 [alias]
 sqlness = "run --bin sqlness-runner --"
+
+
+[build]
+rustflags = [
+    # lints
+    # TODO: use lint configuration in cargo https://github.com/rust-lang/cargo/issues/5034
+    "-Wclippy::print_stdout",
+    "-Wclippy::print_stderr",
+    "-Wclippy::implicit_clone",
+
+    # It seems clippy has made a false positive decision here when upgrading rust toolchain to
+    # nightly-2023-08-07, we do need it to be borrowed mutably.
+    # Allow it for now; try disallow it when the toolchain is upgraded in the future.
+    "-Aclippy::needless_pass_by_ref_mut",
+]

.env.example

@@ -19,5 +19,3 @@ GT_GCS_BUCKET = GCS bucket
 GT_GCS_SCOPE  = GCS scope
 GT_GCS_CREDENTIAL_PATH = GCS credential path 
 GT_GCS_ENDPOINT = GCS end point
-# Settings for kafka wal test
-GT_KAFKA_ENDPOINTS = localhost:9092

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -21,7 +21,6 @@ body:
         - Locking issue
         - Performance issue
         - Unexpected error
-        - User Experience
         - Other
     validations:
       required: true
@@ -34,40 +33,21 @@ body:
       multiple: true
       options:
         - Standalone mode
-        - Distributed Cluster
-        - Storage Engine
-        - Query Engine
-        - Table Engine
-        - Write Protocols
-        - MetaSrv
         - Frontend
         - Datanode
+        - Meta
         - Other
     validations:
       required: true
 
   - type: textarea
-    id: reproduce
+    id: what-happened
     attributes:
-      label: Minimal reproduce step
+      label: What happened?
       description: |
-        Please walk us through and provide steps and details on how
-        to reproduce the issue. If possible, provide scripts that we
-        can run to trigger the bug.
-    validations:
-      required: true
-
-  - type: textarea
-    id: expected-manner
-    attributes:
-      label: What did you expect to see?
-    validations:
-      required: true
-
-  - type: textarea
-    id: actual-manner
-    attributes:
-      label: What did you see instead?
+        Tell us what happened and also what you would have expected to
+        happen instead.
+      placeholder: "Describe the bug"
     validations:
       required: true
 
@@ -83,17 +63,6 @@ body:
     validations:
       required: true
 
-  - type: input
-    id: greptimedb
-    attributes:
-      label: What version of GreptimeDB did you use?
-      description: |
-        Please provide the version of GreptimeDB. For example:
-        0.5.1 etc. You can get it by executing command line `greptime --version`.
-      placeholder: "0.5.1"
-    validations:
-      required: true
-
   - type: textarea
     id: logs
     attributes:
@@ -103,3 +72,14 @@ body:
         trace. This will be automatically formatted into code, so no
         need for backticks.
       render: bash
+
+  - type: textarea
+    id: reproduce
+    attributes:
+      label: How can we reproduce the bug?
+      description: |
+        Please walk us through and provide steps and details on how
+        to reproduce the issue. If possible, provide scripts that we
+        can run to trigger the bug.
+    validations:
+      required: true

.github/actions/build-dev-builder-image/action.yml

@@ -0,0 +1,93 @@
+name: Build and push dev-builder image
+description: Build and push dev-builder image to DockerHub and ACR
+inputs:
+  dockerhub-image-registry:
+    description: The dockerhub image registry to store the images
+    required: false
+    default: docker.io
+  dockerhub-image-registry-username:
+    description: The dockerhub username to login to the image registry
+    required: true
+  dockerhub-image-registry-token:
+    description: The dockerhub token to login to the image registry
+    required: true
+  dockerhub-image-namespace:
+    description: The dockerhub namespace of the image registry to store the images
+    required: false
+    default: greptime
+  acr-image-registry:
+    description: The ACR image registry to store the images
+    required: true
+  acr-image-registry-username:
+    description: The ACR username to login to the image registry
+    required: true
+  acr-image-registry-password:
+    description: The ACR password to login to the image registry
+    required: true
+  acr-image-namespace:
+    description: The ACR namespace of the image registry to store the images
+    required: false
+    default: greptime
+  version:
+    description: Version of the dev-builder
+    required: false
+    default: latest
+runs:
+  using: composite
+  steps:
+    - name: Login to Dockerhub
+      uses: docker/login-action@v2
+      with:
+        registry: ${{ inputs.dockerhub-image-registry }}
+        username: ${{ inputs.dockerhub-image-registry-username }}
+        password: ${{ inputs.dockerhub-image-registry-token }}
+
+    - name: Build and push ubuntu dev builder image to dockerhub
+      shell: bash
+      run:
+        make dev-builder \
+        BASE_IMAGE=ubuntu \
+        BUILDX_MULTI_PLATFORM_BUILD=true \
+        IMAGE_REGISTRY=${{ inputs.dockerhub-image-registry }} \
+        IMAGE_NAMESPACE=${{ inputs.dockerhub-image-namespace }} \
+        IMAGE_TAG=${{ inputs.version }}
+
+    - name: Build and push centos dev builder image to dockerhub
+      shell: bash
+      run:
+        make dev-builder \
+        BASE_IMAGE=centos \
+        BUILDX_MULTI_PLATFORM_BUILD=true \
+        IMAGE_REGISTRY=${{ inputs.dockerhub-image-registry }} \
+        IMAGE_NAMESPACE=${{ inputs.dockerhub-image-namespace }} \
+        IMAGE_TAG=${{ inputs.version }}
+
+    - name: Login to ACR
+      uses: docker/login-action@v2
+      continue-on-error: true
+      with:
+        registry: ${{ inputs.acr-image-registry }}
+        username: ${{ inputs.acr-image-registry-username }}
+        password: ${{ inputs.acr-image-registry-password }}
+
+    - name: Build and push ubuntu dev builder image to ACR
+      shell: bash
+      continue-on-error: true
+      run: # buildx will cache the images that already built, so it will not take long time to build the images again.
+        make dev-builder \
+        BASE_IMAGE=ubuntu \
+        BUILDX_MULTI_PLATFORM_BUILD=true \
+        IMAGE_REGISTRY=${{ inputs.acr-image-registry }} \
+        IMAGE_NAMESPACE=${{ inputs.acr-image-namespace }} \
+        IMAGE_TAG=${{ inputs.version }}
+
+    - name: Build and push centos dev builder image to ACR
+      shell: bash
+      continue-on-error: true
+      run: # buildx will cache the images that already built, so it will not take long time to build the images again.
+        make dev-builder \
+        BASE_IMAGE=centos \
+        BUILDX_MULTI_PLATFORM_BUILD=true \
+        IMAGE_REGISTRY=${{ inputs.acr-image-registry }} \
+        IMAGE_NAMESPACE=${{ inputs.acr-image-namespace }} \
+        IMAGE_TAG=${{ inputs.version }}

.github/actions/build-dev-builder-images/action.yml

@@ -1,76 +0,0 @@
-name: Build and push dev-builder images
-description: Build and push dev-builder images to DockerHub and ACR
-inputs:
-  dockerhub-image-registry:
-    description: The dockerhub image registry to store the images
-    required: false
-    default: docker.io
-  dockerhub-image-registry-username:
-    description: The dockerhub username to login to the image registry
-    required: true
-  dockerhub-image-registry-token:
-    description: The dockerhub token to login to the image registry
-    required: true
-  dockerhub-image-namespace:
-    description: The dockerhub namespace of the image registry to store the images
-    required: false
-    default: greptime
-  version:
-    description: Version of the dev-builder
-    required: false
-    default: latest
-  build-dev-builder-ubuntu:
-    description: Build dev-builder-ubuntu image
-    required: false
-    default: 'true'
-  build-dev-builder-centos:
-    description: Build dev-builder-centos image
-    required: false
-    default: 'true'
-  build-dev-builder-android:
-    description: Build dev-builder-android image
-    required: false
-    default: 'true'
-runs:
-  using: composite
-  steps:
-    - name: Login to Dockerhub
-      uses: docker/login-action@v2
-      with:
-        registry: ${{ inputs.dockerhub-image-registry }}
-        username: ${{ inputs.dockerhub-image-registry-username }}
-        password: ${{ inputs.dockerhub-image-registry-token }}
-
-    - name: Build and push dev-builder-ubuntu image
-      shell: bash
-      if: ${{ inputs.build-dev-builder-ubuntu == 'true' }}
-      run: |
-        make dev-builder \
-          BASE_IMAGE=ubuntu \
-          BUILDX_MULTI_PLATFORM_BUILD=true \
-          IMAGE_REGISTRY=${{ inputs.dockerhub-image-registry }} \
-          IMAGE_NAMESPACE=${{ inputs.dockerhub-image-namespace }} \
-          IMAGE_TAG=${{ inputs.version }}
-
-    - name: Build and push dev-builder-centos image
-      shell: bash
-      if: ${{ inputs.build-dev-builder-centos == 'true' }}
-      run: |
-        make dev-builder \
-          BASE_IMAGE=centos \
-          BUILDX_MULTI_PLATFORM_BUILD=true \
-          IMAGE_REGISTRY=${{ inputs.dockerhub-image-registry }} \
-          IMAGE_NAMESPACE=${{ inputs.dockerhub-image-namespace }} \
-          IMAGE_TAG=${{ inputs.version }}
-
-    - name: Build and push dev-builder-android image # Only build image for amd64 platform.
-      shell: bash
-      if: ${{ inputs.build-dev-builder-android == 'true' }}
-      run: |
-        make dev-builder \
-          BASE_IMAGE=android \
-          IMAGE_REGISTRY=${{ inputs.dockerhub-image-registry }} \
-          IMAGE_NAMESPACE=${{ inputs.dockerhub-image-namespace }} \
-          IMAGE_TAG=${{ inputs.version }} && \
-        
-        docker push ${{ inputs.dockerhub-image-registry }}/${{ inputs.dockerhub-image-namespace }}/dev-builder-android:${{ inputs.version }}

.github/actions/build-greptime-binary/action.yml

@@ -16,20 +16,35 @@ inputs:
   version:
     description: Version of the artifact
     required: true
+  release-to-s3-bucket:
+    description: S3 bucket to store released artifacts
+    required: true
+  aws-access-key-id:
+    description: AWS access key id
+    required: true
+  aws-secret-access-key:
+    description: AWS secret access key
+    required: true
+  aws-region:
+    description: AWS region
+    required: true
+  upload-to-s3:
+    description: Upload to S3
+    required: false
+    default: 'true'
+  upload-latest-artifacts:
+    description: Upload the latest artifacts to S3
+    required: false
+    default: 'true'
   working-dir:
     description: Working directory to build the artifacts
     required: false
     default: .
-  build-android-artifacts:
-    description: Build android artifacts
-    required: false
-    default: 'false'
 runs:
   using: composite
   steps:
     - name: Build greptime binary
       shell: bash
-      if: ${{ inputs.build-android-artifacts == 'false' }}
       run: |
         cd ${{ inputs.working-dir }} && \
         make build-by-dev-builder \
@@ -39,27 +54,14 @@ runs:
 
     - name: Upload artifacts
       uses: ./.github/actions/upload-artifacts
-      if: ${{ inputs.build-android-artifacts == 'false' }}
-      env:
-        PROFILE_TARGET: ${{ inputs.cargo-profile == 'dev' && 'debug' || inputs.cargo-profile }}
       with:
         artifacts-dir: ${{ inputs.artifacts-dir }}
-        target-file: ./target/$PROFILE_TARGET/greptime
-        version: ${{ inputs.version }}
-        working-dir: ${{ inputs.working-dir }}
-
-    # TODO(zyy17): We can remove build-android-artifacts flag in the future.
-    - name: Build greptime binary
-      shell: bash
-      if: ${{ inputs.build-android-artifacts == 'true' }}
-      run: |
-        cd ${{ inputs.working-dir }} && make strip-android-bin
-
-    - name: Upload android artifacts
-      uses: ./.github/actions/upload-artifacts
-      if: ${{ inputs.build-android-artifacts == 'true' }}
-      with:
-        artifacts-dir: ${{ inputs.artifacts-dir }}
-        target-file: ./target/aarch64-linux-android/release/greptime
+        target-file: ./target/${{ inputs.cargo-profile }}/greptime
         version: ${{ inputs.version }}
+        release-to-s3-bucket: ${{ inputs.release-to-s3-bucket }}
+        aws-access-key-id: ${{ inputs.aws-access-key-id }}
+        aws-secret-access-key: ${{ inputs.aws-secret-access-key }}
+        aws-region: ${{ inputs.aws-region }}
+        upload-to-s3: ${{ inputs.upload-to-s3 }}
+        upload-latest-artifacts: ${{ inputs.upload-latest-artifacts }}
         working-dir: ${{ inputs.working-dir }}

.github/actions/build-greptime-images/action.yml

@@ -53,7 +53,7 @@ runs:
       uses: docker/setup-buildx-action@v2
 
     - name: Download amd64 artifacts
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v3
       with:
         name: ${{ inputs.amd64-artifact-name }}
 
@@ -66,7 +66,7 @@ runs:
         mv ${{ inputs.amd64-artifact-name }} amd64
 
     - name: Download arm64 artifacts
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v3
       if: ${{ inputs.arm64-artifact-name }}
       with:
         name: ${{ inputs.arm64-artifact-name }}

.github/actions/build-linux-artifacts/action.yml

@@ -13,10 +13,30 @@ inputs:
   disable-run-tests:
     description: Disable running integration tests
     required: true
+  release-to-s3-bucket:
+    description: S3 bucket to store released artifacts
+    required: true
+  aws-access-key-id:
+    description: AWS access key id
+    required: true
+  aws-secret-access-key:
+    description: AWS secret access key
+    required: true
+  aws-region:
+    description: AWS region
+    required: true
   dev-mode:
     description: Enable dev mode, only build standard greptime
     required: false
     default: 'false'
+  upload-to-s3:
+    description: Upload to S3
+    required: false
+    default: 'true'
+  upload-latest-artifacts:
+    description: Upload the latest artifacts to S3
+    required: false
+    default: 'true'
   working-dir:
     description: Working directory to build the artifacts
     required: false
@@ -34,7 +54,7 @@ runs:
 
     - name: Upload sqlness logs
       if: ${{ failure() && inputs.disable-run-tests == 'false' }} # Only upload logs when the integration tests failed.
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
       with:
         name: sqlness-logs
         path: /tmp/greptime-*.log
@@ -48,6 +68,12 @@ runs:
         cargo-profile: ${{ inputs.cargo-profile }}
         artifacts-dir: greptime-linux-${{ inputs.arch }}-pyo3-${{ inputs.version }}
         version: ${{ inputs.version }}
+        release-to-s3-bucket: ${{ inputs.release-to-s3-bucket }}
+        aws-access-key-id: ${{ inputs.aws-access-key-id }}
+        aws-secret-access-key: ${{ inputs.aws-secret-access-key }}
+        aws-region: ${{ inputs.aws-region }}
+        upload-to-s3: ${{ inputs.upload-to-s3 }}
+        upload-latest-artifacts: ${{ inputs.upload-latest-artifacts }}
         working-dir: ${{ inputs.working-dir }}
 
     - name: Build greptime without pyo3
@@ -59,6 +85,12 @@ runs:
         cargo-profile: ${{ inputs.cargo-profile }}
         artifacts-dir: greptime-linux-${{ inputs.arch }}-${{ inputs.version }}
         version: ${{ inputs.version }}
+        release-to-s3-bucket: ${{ inputs.release-to-s3-bucket }}
+        aws-access-key-id: ${{ inputs.aws-access-key-id }}
+        aws-secret-access-key: ${{ inputs.aws-secret-access-key }}
+        aws-region: ${{ inputs.aws-region }}
+        upload-to-s3: ${{ inputs.upload-to-s3 }}
+        upload-latest-artifacts: ${{ inputs.upload-latest-artifacts }}
         working-dir: ${{ inputs.working-dir }}
 
     - name: Clean up the target directory # Clean up the target directory for the centos7 base image, or it will still use the objects of last build.
@@ -75,14 +107,10 @@ runs:
         cargo-profile: ${{ inputs.cargo-profile }}
         artifacts-dir: greptime-linux-${{ inputs.arch }}-centos-${{ inputs.version }}
         version: ${{ inputs.version }}
+        release-to-s3-bucket: ${{ inputs.release-to-s3-bucket }}
+        aws-access-key-id: ${{ inputs.aws-access-key-id }}
+        aws-secret-access-key: ${{ inputs.aws-secret-access-key }}
+        aws-region: ${{ inputs.aws-region }}
+        upload-to-s3: ${{ inputs.upload-to-s3 }}
+        upload-latest-artifacts: ${{ inputs.upload-latest-artifacts }}
         working-dir: ${{ inputs.working-dir }}
-
-    - name: Build greptime on android base image
-      uses: ./.github/actions/build-greptime-binary
-      if: ${{ inputs.arch == 'amd64' && inputs.dev-mode == 'false' }} # Only build android base image on amd64.
-      with:
-        base-image: android
-        artifacts-dir: greptime-android-arm64-${{ inputs.version }}
-        version: ${{ inputs.version }}
-        working-dir: ${{ inputs.working-dir }}
-        build-android-artifacts: true

.github/actions/build-macos-artifacts/action.yml

@@ -19,9 +19,21 @@ inputs:
   disable-run-tests:
     description: Disable running integration tests
     required: true
+  release-to-s3-bucket:
+    description: S3 bucket to store released artifacts
+    required: true
   artifacts-dir:
     description: Directory to store artifacts
     required: true
+  aws-access-key-id:
+    description: AWS access key id
+    required: true
+  aws-secret-access-key:
+    description: AWS secret access key
+    required: true
+  aws-region:
+    description: AWS region
+    required: true
 runs:
   using: composite
   steps:
@@ -67,7 +79,7 @@ runs:
 
     - name: Upload sqlness logs
       if: ${{ failure() }} # Only upload logs when the integration tests failed.
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
       with:
         name: sqlness-logs
         path: /tmp/greptime-*.log
@@ -87,3 +99,7 @@ runs:
         artifacts-dir: ${{ inputs.artifacts-dir }}
         target-file: target/${{ inputs.arch }}/${{ inputs.cargo-profile }}/greptime
         version: ${{ inputs.version }}
+        release-to-s3-bucket: ${{ inputs.release-to-s3-bucket }}
+        aws-access-key-id: ${{ inputs.aws-access-key-id }}
+        aws-secret-access-key: ${{ inputs.aws-secret-access-key }}
+        aws-region: ${{ inputs.aws-region }}

.github/actions/build-windows-artifacts/action.yml

@@ -1,80 +0,0 @@
-name: Build Windows artifacts
-description: Build Windows artifacts
-inputs:
-  arch:
-    description: Architecture to build
-    required: true
-  rust-toolchain:
-    description: Rust toolchain to use
-    required: true
-  cargo-profile:
-    description: Cargo profile to build
-    required: true
-  features:
-    description: Cargo features to build
-    required: true
-  version:
-    description: Version of the artifact
-    required: true
-  disable-run-tests:
-    description: Disable running integration tests
-    required: true
-  artifacts-dir:
-    description: Directory to store artifacts
-    required: true
-runs:
-  using: composite
-  steps:
-    - uses: arduino/setup-protoc@v3
-
-    - name: Install rust toolchain
-      uses: dtolnay/rust-toolchain@master
-      with:
-        toolchain: ${{ inputs.rust-toolchain }}
-        targets: ${{ inputs.arch }}
-        components: llvm-tools-preview
-
-    - name: Rust Cache
-      uses: Swatinem/rust-cache@v2
-
-    - name: Install Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.10'
-
-    - name: Install PyArrow Package
-      shell: pwsh
-      run: pip install pyarrow
-
-    - name: Install WSL distribution
-      uses: Vampire/setup-wsl@v2
-      with:
-        distribution: Ubuntu-22.04
-
-    - name: Install latest nextest release # For integration tests.
-      if: ${{ inputs.disable-run-tests == 'false' }}
-      uses: taiki-e/install-action@nextest
-
-    - name: Run integration tests
-      if: ${{ inputs.disable-run-tests == 'false' }}
-      shell: pwsh
-      run: make test sqlness-test
-
-    - name: Upload sqlness logs
-      if: ${{ failure() }} # Only upload logs when the integration tests failed.
-      uses: actions/upload-artifact@v4
-      with:
-        name: sqlness-logs
-        path: /tmp/greptime-*.log
-        retention-days: 3
-
-    - name: Build greptime binary
-      shell: pwsh
-      run: cargo build --profile ${{ inputs.cargo-profile }} --features ${{ inputs.features }} --target ${{ inputs.arch }}
-
-    - name: Upload artifacts
-      uses: ./.github/actions/upload-artifacts
-      with:
-        artifacts-dir: ${{ inputs.artifacts-dir }}
-        target-file: target/${{ inputs.arch }}/${{ inputs.cargo-profile }}/greptime
-        version: ${{ inputs.version }}

.github/actions/deploy-greptimedb/action.yml

@@ -1,31 +0,0 @@
-name: Deploy GreptimeDB cluster
-description: Deploy GreptimeDB cluster on Kubernetes
-inputs:
-  aws-ci-test-bucket:
-    description: 'AWS S3 bucket name for testing'
-    required: true
-  aws-region:
-    description: 'AWS region for testing'
-    required: true
-  data-root:
-    description: 'Data root for testing'
-    required: true
-  aws-access-key-id:
-    description: 'AWS access key id for testing'
-    required: true
-  aws-secret-access-key:
-    description: 'AWS secret access key for testing'
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Deploy GreptimeDB by Helm
-      shell: bash
-      env:
-        DATA_ROOT: ${{ inputs.data-root }}
-        AWS_CI_TEST_BUCKET: ${{ inputs.aws-ci-test-bucket }}
-        AWS_REGION: ${{ inputs.aws-region }}
-        AWS_ACCESS_KEY_ID: ${{ inputs.aws-access-key-id }}
-        AWS_SECRET_ACCESS_KEY: ${{ inputs.aws-secret-access-key }}
-      run: |
-        ./.github/scripts/deploy-greptimedb.sh

.github/actions/release-artifacts/action.yml

@@ -1,5 +1,5 @@
-name: Publish GitHub release
-description: Publish GitHub release
+name: Release artifacts
+description: Release artifacts
 inputs:
   version:
     description: Version to release
@@ -15,7 +15,7 @@ runs:
     #   |- greptime-darwin-amd64-v0.5.0.sha256sum/greptime-darwin-amd64-v0.5.0.sha256sum
     #   ...
     - name: Download artifacts
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v3
 
     - name: Create git tag for release
       if: ${{ github.event_name != 'push' }} # Meaning this is a scheduled or manual workflow.
@@ -31,12 +31,10 @@ runs:
           echo "prerelease=false" >> $GITHUB_ENV
           echo "makeLatest=true" >> $GITHUB_ENV
           echo "generateReleaseNotes=false" >> $GITHUB_ENV
-          echo "omitBody=true" >> $GITHUB_ENV
         else
           echo "prerelease=true" >> $GITHUB_ENV
           echo "makeLatest=false" >> $GITHUB_ENV
           echo "generateReleaseNotes=true" >> $GITHUB_ENV
-          echo "omitBody=false" >> $GITHUB_ENV
         fi
 
     - name: Publish release
@@ -47,7 +45,6 @@ runs:
         makeLatest: ${{ env.makeLatest }}
         tag: ${{ inputs.version }}
         generateReleaseNotes: ${{ env.generateReleaseNotes }}
-        omitBody: ${{ env.omitBody }} # omitBody is true when the release is a official release.
         allowUpdates: true
         artifacts: |
           **/greptime-*/*

.github/actions/release-cn-artifacts/action.yaml

@@ -1,138 +0,0 @@
-name: Release CN artifacts
-description: Release artifacts to CN region
-inputs:
-  src-image-registry:
-    description: The source image registry to store the images
-    required: true
-    default: docker.io
-  src-image-namespace:
-    description: The namespace of the source image registry to store the images
-    required: true
-    default: greptime
-  src-image-name:
-    description: The name of the source image
-    required: false
-    default: greptimedb
-  dst-image-registry:
-    description: The destination image registry to store the images
-    required: true
-  dst-image-namespace:
-    description: The namespace of the destination image registry to store the images
-    required: true
-    default: greptime
-  dst-image-registry-username:
-    description: The username to login to the image registry
-    required: true
-  dst-image-registry-password:
-    description: The password to login to the image registry
-    required: true
-  version:
-    description: Version of the artifact
-    required: true
-  dev-mode:
-    description: Enable dev mode, only push standard greptime
-    required: false
-    default: 'false'
-  push-latest-tag:
-    description: Whether to push the latest tag of the image
-    required: false
-    default: 'true'
-  aws-cn-s3-bucket:
-    description: S3 bucket to store released artifacts in CN region
-    required: true
-  aws-cn-access-key-id:
-    description: AWS access key id in CN region
-    required: true
-  aws-cn-secret-access-key:
-    description: AWS secret access key in CN region
-    required: true
-  aws-cn-region:
-    description: AWS region in CN
-    required: true
-  upload-to-s3:
-    description: Upload to S3
-    required: false
-    default: 'true'
-  artifacts-dir:
-    description: Directory to store artifacts
-    required: false
-    default: 'artifacts'
-  update-version-info:
-    description: Update the version info in S3
-    required: false
-    default: 'true'
-  upload-max-retry-times:
-    description: Max retry times for uploading artifacts to S3
-    required: false
-    default: "20"
-  upload-retry-timeout:
-    description: Timeout for uploading artifacts to S3
-    required: false
-    default: "30" # minutes
-runs:
-  using: composite
-  steps:
-    - name: Download artifacts
-      uses: actions/download-artifact@v4
-      with:
-        path: ${{ inputs.artifacts-dir }}
-
-    - name: Release artifacts to cn region
-      uses: nick-invision/retry@v2
-      if: ${{ inputs.upload-to-s3 == 'true' }}
-      env:
-        AWS_ACCESS_KEY_ID: ${{ inputs.aws-cn-access-key-id }}
-        AWS_SECRET_ACCESS_KEY: ${{ inputs.aws-cn-secret-access-key }}
-        AWS_DEFAULT_REGION: ${{ inputs.aws-cn-region }}
-        UPDATE_VERSION_INFO: ${{ inputs.update-version-info }}
-      with:
-        max_attempts: ${{ inputs.upload-max-retry-times }}
-        timeout_minutes: ${{ inputs.upload-retry-timeout }}
-        command: |
-          ./.github/scripts/upload-artifacts-to-s3.sh \
-            ${{ inputs.artifacts-dir }} \
-            ${{ inputs.version }} \
-            ${{ inputs.aws-cn-s3-bucket }}
-
-    - name: Push greptimedb image from Dockerhub to ACR
-      shell: bash
-      env:
-        DST_REGISTRY_USERNAME: ${{ inputs.dst-image-registry-username }}
-        DST_REGISTRY_PASSWORD: ${{ inputs.dst-image-registry-password }}
-      run: |
-        ./.github/scripts/copy-image.sh \
-         ${{ inputs.src-image-registry }}/${{ inputs.src-image-namespace }}/${{ inputs.src-image-name }}:${{ inputs.version }} \
-         ${{ inputs.dst-image-registry }}/${{ inputs.dst-image-namespace }}
-
-    - name: Push latest greptimedb image from Dockerhub to ACR
-      shell: bash
-      if: ${{ inputs.push-latest-tag == 'true' }}
-      env:
-        DST_REGISTRY_USERNAME: ${{ inputs.dst-image-registry-username }}
-        DST_REGISTRY_PASSWORD: ${{ inputs.dst-image-registry-password }}
-      run: |
-        ./.github/scripts/copy-image.sh \
-         ${{ inputs.src-image-registry }}/${{ inputs.src-image-namespace }}/${{ inputs.src-image-name }}:latest \
-         ${{ inputs.dst-image-registry }}/${{ inputs.dst-image-namespace }}
-
-    - name: Push greptimedb-centos image from DockerHub to ACR
-      shell: bash
-      if: ${{ inputs.dev-mode == 'false' }}
-      env:
-        DST_REGISTRY_USERNAME: ${{ inputs.dst-image-registry-username }}
-        DST_REGISTRY_PASSWORD: ${{ inputs.dst-image-registry-password }}
-      run: |
-        ./.github/scripts/copy-image.sh \
-         ${{ inputs.src-image-registry }}/${{ inputs.src-image-namespace }}/${{ inputs.src-image-name }}-centos:latest \
-         ${{ inputs.dst-image-registry }}/${{ inputs.dst-image-namespace }}
-
-    - name: Push greptimedb-centos image from DockerHub to ACR
-      shell: bash
-      if: ${{ inputs.dev-mode == 'false' && inputs.push-latest-tag == 'true' }}
-      env:
-        DST_REGISTRY_USERNAME: ${{ inputs.dst-image-registry-username }}
-        DST_REGISTRY_PASSWORD: ${{ inputs.dst-image-registry-password }}
-      run: |
-        ./.github/scripts/copy-image.sh \
-         ${{ inputs.src-image-registry }}/${{ inputs.src-image-namespace }}/${{ inputs.src-image-name }}-centos:latest \
-         ${{ inputs.dst-image-registry }}/${{ inputs.dst-image-namespace }}

.github/actions/sqlness-test/action.yml

@@ -1,59 +0,0 @@
-name: Run sqlness test
-description: Run sqlness test on GreptimeDB
-
-inputs:
-  aws-ci-test-bucket:
-    description: 'AWS S3 bucket name for testing'
-    required: true
-  aws-region:
-    description: 'AWS region for testing'
-    required: true
-  data-root:
-    description: 'Data root for testing'
-    required: true
-  aws-access-key-id:
-    description: 'AWS access key id for testing'
-    required: true
-  aws-secret-access-key:
-    description: 'AWS secret access key for testing'
-    required: true
-
-runs:
-  using: composite
-  steps:
-    - name: Deploy GreptimeDB cluster by Helm
-      uses: ./.github/actions/deploy-greptimedb
-      with:
-        data-root: ${{ inputs.data-root }}
-        aws-ci-test-bucket: ${{ inputs.aws-ci-test-bucket }}
-        aws-region: ${{ inputs.aws-region }}
-        aws-access-key-id: ${{ inputs.aws-access-key-id }}
-        aws-secret-access-key: ${{ inputs.aws-secret-access-key }}
-
-    # TODO(zyy17): The following tests will be replaced by the real sqlness test.
-    - name: Run tests on greptimedb cluster
-      shell: bash
-      run: |
-        mysql -h 127.0.0.1 -P 14002 -e "CREATE TABLE IF NOT EXISTS system_metrics (host VARCHAR(255), idc VARCHAR(255), cpu_util DOUBLE, memory_util DOUBLE, disk_util DOUBLE, ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY(host, idc), TIME INDEX(ts));" && \
-        mysql -h 127.0.0.1 -P 14002 -e "SHOW TABLES;"
-
-    - name: Run tests on greptimedb cluster that uses S3
-      shell: bash
-      run: |
-        mysql -h 127.0.0.1 -P 24002 -e "CREATE TABLE IF NOT EXISTS system_metrics (host VARCHAR(255), idc VARCHAR(255), cpu_util DOUBLE, memory_util DOUBLE, disk_util DOUBLE, ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY(host, idc), TIME INDEX(ts));" && \
-        mysql -h 127.0.0.1 -P 24002 -e "SHOW TABLES;"
-
-    - name: Run tests on standalone greptimedb
-      shell: bash
-      run: |
-        mysql -h 127.0.0.1 -P 34002 -e "CREATE TABLE IF NOT EXISTS system_metrics (host VARCHAR(255), idc VARCHAR(255), cpu_util DOUBLE, memory_util DOUBLE, disk_util DOUBLE, ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY(host, idc), TIME INDEX(ts));" && \
-        mysql -h 127.0.0.1 -P 34002 -e "SHOW TABLES;"
-
-    - name: Clean S3 data
-      shell: bash
-      env:
-        AWS_DEFAULT_REGION: ${{ inputs.aws-region }}
-        AWS_ACCESS_KEY_ID: ${{ inputs.aws-access-key-id }}
-        AWS_SECRET_ACCESS_KEY: ${{ inputs.aws-secret-access-key }}
-      run: |
-        aws s3 rm s3://${{ inputs.aws-ci-test-bucket }}/${{ inputs.data-root }} --recursive

.github/actions/upload-artifacts/action.yml

@@ -6,10 +6,38 @@ inputs:
     required: true
   target-file:
     description: The path of the target artifact
-    required: false
+    required: true
   version:
     description: Version of the artifact
     required: true
+  release-to-s3-bucket:
+    description: S3 bucket to store released artifacts
+    required: true
+  aws-access-key-id:
+    description: AWS access key id
+    required: true
+  aws-secret-access-key:
+    description: AWS secret access key
+    required: true
+  aws-region:
+    description: AWS region
+    required: true
+  upload-to-s3:
+    description: Upload to S3
+    required: false
+    default: 'true'
+  upload-latest-artifacts:
+    description: Upload the latest artifacts to S3
+    required: false
+    default: 'true'
+  upload-max-retry-times:
+    description: Max retry times for uploading artifacts to S3
+    required: false
+    default: "20"
+  upload-retry-timeout:
+    description: Timeout for uploading artifacts to S3
+    required: false
+    default: "10" # minutes
   working-dir:
     description: Working directory to upload the artifacts
     required: false
@@ -18,12 +46,11 @@ runs:
   using: composite
   steps:
     - name: Create artifacts directory
-      if: ${{ inputs.target-file != '' }}
       working-directory: ${{ inputs.working-dir }}
       shell: bash
       run: |
         mkdir -p ${{ inputs.artifacts-dir }} && \
-        cp ${{ inputs.target-file }} ${{ inputs.artifacts-dir }}
+        mv ${{ inputs.target-file }} ${{ inputs.artifacts-dir }}
 
     # The compressed artifacts will use the following layout:
     # greptime-linux-amd64-pyo3-v0.3.0sha256sum
@@ -34,31 +61,65 @@ runs:
       working-directory: ${{ inputs.working-dir }}
       shell: bash
       run: |
-        tar -zcvf ${{ inputs.artifacts-dir }}.tar.gz ${{ inputs.artifacts-dir }}
-
-    - name: Calculate checksum
-      if: runner.os != 'Windows'
-      working-directory: ${{ inputs.working-dir }}
-      shell: bash
-      run: |
+        tar -zcvf ${{ inputs.artifacts-dir }}.tar.gz ${{ inputs.artifacts-dir }} && \
         echo $(shasum -a 256 ${{ inputs.artifacts-dir }}.tar.gz | cut -f1 -d' ') > ${{ inputs.artifacts-dir }}.sha256sum
 
-    - name: Calculate checksum on Windows
-      if: runner.os == 'Windows'
-      working-directory: ${{ inputs.working-dir }}
-      shell: pwsh
-      run: Get-FileHash ${{ inputs.artifacts-dir }}.tar.gz -Algorithm SHA256 | select -ExpandProperty Hash > ${{ inputs.artifacts-dir }}.sha256sum
-
     # Note: The artifacts will be double zip compressed(related issue: https://github.com/actions/upload-artifact/issues/39).
-    # However, when we use 'actions/download-artifact' to download the artifacts, it will be automatically unzipped.
+    # However, when we use 'actions/download-artifact@v3' to download the artifacts, it will be automatically unzipped.
     - name: Upload artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
       with:
         name: ${{ inputs.artifacts-dir }}
         path: ${{ inputs.working-dir }}/${{ inputs.artifacts-dir }}.tar.gz
 
     - name: Upload checksum
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
       with:
         name: ${{ inputs.artifacts-dir }}.sha256sum
         path: ${{ inputs.working-dir }}/${{ inputs.artifacts-dir }}.sha256sum
+
+    - name: Upload artifacts to S3
+      if: ${{ inputs.upload-to-s3 == 'true' }}
+      uses: nick-invision/retry@v2
+      env:
+        AWS_ACCESS_KEY_ID: ${{ inputs.aws-access-key-id }}
+        AWS_SECRET_ACCESS_KEY: ${{ inputs.aws-secret-access-key }}
+        AWS_DEFAULT_REGION: ${{ inputs.aws-region }}
+      with:
+        max_attempts: ${{ inputs.upload-max-retry-times }}
+        timeout_minutes: ${{ inputs.upload-retry-timeout }}
+        # The bucket layout will be:
+        # releases/greptimedb
+        # ├── v0.1.0
+        # │   ├── greptime-darwin-amd64-pyo3-v0.1.0.sha256sum
+        # │   └── greptime-darwin-amd64-pyo3-v0.1.0.tar.gz
+        # └── v0.2.0
+        #    ├── greptime-darwin-amd64-pyo3-v0.2.0.sha256sum
+        #    └── greptime-darwin-amd64-pyo3-v0.2.0.tar.gz
+        command: |
+          cd ${{ inputs.working-dir }} && \
+          aws s3 cp \
+            ${{ inputs.artifacts-dir }}.tar.gz \
+            s3://${{ inputs.release-to-s3-bucket }}/releases/greptimedb/${{ inputs.version }}/${{ inputs.artifacts-dir }}.tar.gz && \
+          aws s3 cp \
+            ${{ inputs.artifacts-dir }}.sha256sum \
+            s3://${{ inputs.release-to-s3-bucket }}/releases/greptimedb/${{ inputs.version }}/${{ inputs.artifacts-dir }}.sha256sum
+
+    - name: Upload latest artifacts to S3
+      if: ${{ inputs.upload-to-s3 == 'true' && inputs.upload-latest-artifacts == 'true' }} # We'll also upload the latest artifacts to S3 in the scheduled and formal release.
+      uses: nick-invision/retry@v2
+      env:
+        AWS_ACCESS_KEY_ID: ${{ inputs.aws-access-key-id }}
+        AWS_SECRET_ACCESS_KEY: ${{ inputs.aws-secret-access-key }}
+        AWS_DEFAULT_REGION: ${{ inputs.aws-region }}
+      with:
+        max_attempts: ${{ inputs.upload-max-retry-times }}
+        timeout_minutes: ${{ inputs.upload-retry-timeout }}
+        command: |
+          cd ${{ inputs.working-dir }} && \
+          aws s3 cp \
+            ${{ inputs.artifacts-dir }}.tar.gz \
+            s3://${{ inputs.release-to-s3-bucket }}/releases/greptimedb/latest/${{ inputs.artifacts-dir }}.tar.gz && \
+          aws s3 cp \
+            ${{ inputs.artifacts-dir }}.sha256sum \
+            s3://${{ inputs.release-to-s3-bucket }}/releases/greptimedb/latest/${{ inputs.artifacts-dir }}.sha256sum

.github/doc-label-config.yml

@@ -1,4 +0,0 @@
-Doc not needed:
-    - '- \[x\]  This PR does not require documentation updates.'
-Doc update required:
-    - '- \[ \]  This PR does not require documentation updates.'

.github/pull_request_template.md

@@ -1,10 +1,8 @@
-I hereby agree to the terms of the [GreptimeDB CLA](https://github.com/GreptimeTeam/.github/blob/main/CLA.md).
-
-## Refer to a related PR or issue link (optional)
+I hereby agree to the terms of the [GreptimeDB CLA](https://gist.github.com/xtang/6378857777706e568c1949c7578592cc)
 
 ## What's changed and what's your intention?
 
-__!!! DO NOT LEAVE THIS BLOCK EMPTY !!!__
+_PLEASE DO NOT LEAVE THIS EMPTY !!!_
 
 Please explain IN DETAIL what the changes are in this PR and why they are needed:
 
@@ -17,4 +15,5 @@ Please explain IN DETAIL what the changes are in this PR and why they are needed
 
 - [ ]  I have written the necessary rustdoc comments.
 - [ ]  I have added the necessary unit tests and integration tests.
-- [x]  This PR does not require documentation updates.
+
+## Refer to a related PR or issue link (optional)

.github/scripts/copy-image.sh

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-set -o pipefail
-
-SRC_IMAGE=$1
-DST_REGISTRY=$2
-SKOPEO_STABLE_IMAGE="quay.io/skopeo/stable:latest"
-
-# Check if necessary variables are set.
-function check_vars() {
-  for var in DST_REGISTRY_USERNAME DST_REGISTRY_PASSWORD DST_REGISTRY SRC_IMAGE; do
-    if [ -z "${!var}" ]; then
-      echo "$var is not set or empty."
-      echo "Usage: DST_REGISTRY_USERNAME=<your-dst-registry-username> DST_REGISTRY_PASSWORD=<your-dst-registry-password> $0 <dst-registry> <src-image>"
-      exit 1
-    fi
-  done
-}
-
-# Copies images from DockerHub to the destination registry.
-function copy_images_from_dockerhub() {
-  # Check if docker is installed.
-  if ! command -v docker &> /dev/null; then
-    echo "docker is not installed. Please install docker to continue."
-    exit 1
-  fi
-
-  # Extract the name and tag of the source image.
-  IMAGE_NAME=$(echo "$SRC_IMAGE" | sed "s/.*\///")
-
-  echo "Copying $SRC_IMAGE to $DST_REGISTRY/$IMAGE_NAME"
-
-  docker run "$SKOPEO_STABLE_IMAGE" copy -a docker://"$SRC_IMAGE" \
-    --dest-creds "$DST_REGISTRY_USERNAME":"$DST_REGISTRY_PASSWORD" \
-    docker://"$DST_REGISTRY/$IMAGE_NAME"
-}
-
-function main() {
-  check_vars
-  copy_images_from_dockerhub
-}
-
-# Usage example:
-# DST_REGISTRY_USERNAME=123 DST_REGISTRY_PASSWORD=456 \
-#   ./copy-image.sh greptime/greptimedb:v0.4.0 greptime-registry.cn-hangzhou.cr.aliyuncs.com
-main

.github/scripts/deploy-greptimedb.sh

@@ -1,169 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-set -o pipefail
-
-KUBERNETES_VERSION="${KUBERNETES_VERSION:-v1.24.0}"
-ENABLE_STANDALONE_MODE="${ENABLE_STANDALONE_MODE:-true}"
-DEFAULT_INSTALL_NAMESPACE=${DEFAULT_INSTALL_NAMESPACE:-default}
-GREPTIMEDB_IMAGE_TAG=${GREPTIMEDB_IMAGE_TAG:-latest}
-ETCD_CHART="oci://registry-1.docker.io/bitnamicharts/etcd"
-GREPTIME_CHART="https://greptimeteam.github.io/helm-charts/"
-
-# Ceate a cluster with 1 control-plane node and 5 workers.
-function create_kind_cluster() {
-  cat <<EOF | kind create cluster --name "${CLUSTER}" --image kindest/node:"$KUBERNETES_VERSION" --config=-
-kind: Cluster
-apiVersion: kind.x-k8s.io/v1alpha4
-nodes:
-- role: control-plane
-- role: worker
-- role: worker
-- role: worker
-- role: worker
-- role: worker
-EOF
-}
-
-# Add greptime Helm chart repo.
-function add_greptime_chart() {
-  helm repo add greptime "$GREPTIME_CHART"
-  helm repo update
-}
-
-# Deploy a etcd cluster with 3 members.
-function deploy_etcd_cluster() {
-  local namespace="$1"
-
-  helm install etcd "$ETCD_CHART" \
-    --set replicaCount=3 \
-    --set auth.rbac.create=false \
-    --set auth.rbac.token.enabled=false \
-    -n "$namespace"
-
-  # Wait for etcd cluster to be ready.
-  kubectl rollout status statefulset/etcd -n "$namespace"
-}
-
-# Deploy greptimedb-operator.
-function deploy_greptimedb_operator() {
-  # Use the latest chart and image.
-  helm install greptimedb-operator greptime/greptimedb-operator \
-    --set image.tag=latest \
-    -n "$DEFAULT_INSTALL_NAMESPACE"
-
-  # Wait for greptimedb-operator to be ready.
-  kubectl rollout status deployment/greptimedb-operator -n "$DEFAULT_INSTALL_NAMESPACE"
-}
-
-# Deploy greptimedb cluster by using local storage.
-# It will expose cluster service ports as '14000', '14001', '14002', '14003' to local access.
-function deploy_greptimedb_cluster() {
-  local cluster_name=$1
-  local install_namespace=$2
-
-  kubectl create ns "$install_namespace"
-
-  deploy_etcd_cluster "$install_namespace"
-
-  helm install "$cluster_name" greptime/greptimedb-cluster \
-    --set image.tag="$GREPTIMEDB_IMAGE_TAG" \
-    --set meta.etcdEndpoints="etcd.$install_namespace:2379" \
-    -n "$install_namespace"
-
-  # Wait for greptimedb cluster to be ready.
-  while true; do
-    PHASE=$(kubectl -n "$install_namespace" get gtc "$cluster_name" -o jsonpath='{.status.clusterPhase}')
-    if [ "$PHASE" == "Running" ]; then
-      echo "Cluster is ready"
-      break
-    else
-      echo "Cluster is not ready yet: Current phase: $PHASE"
-      sleep 5 # wait for 5 seconds before check again.
-    fi
-  done
-
-  # Expose greptimedb cluster to local access.
-  kubectl -n "$install_namespace" port-forward svc/"$cluster_name"-frontend \
-    14000:4000 \
-    14001:4001 \
-    14002:4002 \
-    14003:4003 > /tmp/connections.out &
-}
-
-# Deploy greptimedb cluster by using S3.
-# It will expose cluster service ports as '24000', '24001', '24002', '24003' to local access.
-function deploy_greptimedb_cluster_with_s3_storage() {
-  local cluster_name=$1
-  local install_namespace=$2
-
-  kubectl create ns "$install_namespace"
-
-  deploy_etcd_cluster "$install_namespace"
-
-  helm install "$cluster_name" greptime/greptimedb-cluster -n "$install_namespace" \
-    --set image.tag="$GREPTIMEDB_IMAGE_TAG" \
-    --set meta.etcdEndpoints="etcd.$install_namespace:2379" \
-    --set storage.s3.bucket="$AWS_CI_TEST_BUCKET" \
-    --set storage.s3.region="$AWS_REGION" \
-    --set storage.s3.root="$DATA_ROOT" \
-    --set storage.credentials.secretName=s3-credentials \
-    --set storage.credentials.accessKeyId="$AWS_ACCESS_KEY_ID" \
-    --set storage.credentials.secretAccessKey="$AWS_SECRET_ACCESS_KEY"
-
-  # Wait for greptimedb cluster to be ready.
-  while true; do
-    PHASE=$(kubectl -n "$install_namespace" get gtc "$cluster_name" -o jsonpath='{.status.clusterPhase}')
-    if [ "$PHASE" == "Running" ]; then
-      echo "Cluster is ready"
-      break
-    else
-      echo "Cluster is not ready yet: Current phase: $PHASE"
-      sleep 5 # wait for 5 seconds before check again.
-    fi
-  done
-
-  # Expose greptimedb cluster to local access.
-  kubectl -n "$install_namespace" port-forward svc/"$cluster_name"-frontend \
-    24000:4000 \
-    24001:4001 \
-    24002:4002 \
-    24003:4003 > /tmp/connections.out &
-}
-
-# Deploy standalone greptimedb.
-# It will expose cluster service ports as '34000', '34001', '34002', '34003' to local access.
-function deploy_standalone_greptimedb() {
-  helm install greptimedb-standalone greptime/greptimedb-standalone \
-    --set image.tag="$GREPTIMEDB_IMAGE_TAG" \
-    -n "$DEFAULT_INSTALL_NAMESPACE"
-
-  # Wait for etcd cluster to be ready.
-  kubectl rollout status statefulset/greptimedb-standalone -n "$DEFAULT_INSTALL_NAMESPACE"
-
-  # Expose greptimedb to local access.
-  kubectl -n "$DEFAULT_INSTALL_NAMESPACE" port-forward svc/greptimedb-standalone \
-    34000:4000 \
-    34001:4001 \
-    34002:4002 \
-    34003:4003 > /tmp/connections.out &
-}
-
-# Entrypoint of the script.
-function main() {
-  create_kind_cluster
-  add_greptime_chart
-
-  # Deploy standalone greptimedb in the same K8s.
-  if [ "$ENABLE_STANDALONE_MODE" == "true" ]; then
-    deploy_standalone_greptimedb
-  fi
-
-  deploy_greptimedb_operator
-  deploy_greptimedb_cluster testcluster testcluster
-  deploy_greptimedb_cluster_with_s3_storage testcluster-s3 testcluster-s3
-}
-
-# Usages:
-# - Deploy greptimedb cluster: ./deploy-greptimedb.sh
-main

.github/scripts/upload-artifacts-to-s3.sh

@@ -1,102 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-set -o pipefail
-
-ARTIFACTS_DIR=$1
-VERSION=$2
-AWS_S3_BUCKET=$3
-RELEASE_DIRS="releases/greptimedb"
-GREPTIMEDB_REPO="GreptimeTeam/greptimedb"
-
-# Check if necessary variables are set.
-function check_vars() {
-  for var in AWS_S3_BUCKET VERSION ARTIFACTS_DIR; do
-    if [ -z "${!var}" ]; then
-      echo "$var is not set or empty."
-      echo "Usage: $0 <artifacts-dir> <version> <aws-s3-bucket>"
-      exit 1
-    fi
-  done
-}
-
-# Uploads artifacts to AWS S3 bucket.
-function upload_artifacts() {
-  # The bucket layout will be:
-  # releases/greptimedb
-  # ├── latest-version.txt
-  # ├── latest-nightly-version.txt
-  # ├── v0.1.0
-  # │   ├── greptime-darwin-amd64-pyo3-v0.1.0.sha256sum
-  # │   └── greptime-darwin-amd64-pyo3-v0.1.0.tar.gz
-  # └── v0.2.0
-  #    ├── greptime-darwin-amd64-pyo3-v0.2.0.sha256sum
-  #    └── greptime-darwin-amd64-pyo3-v0.2.0.tar.gz
-  find "$ARTIFACTS_DIR" -type f \( -name "*.tar.gz" -o -name "*.sha256sum" \) | while IFS= read -r file; do
-    aws s3 cp \
-      "$file" "s3://$AWS_S3_BUCKET/$RELEASE_DIRS/$VERSION/$(basename "$file")"
-  done
-}
-
-# Updates the latest version information in AWS S3 if UPDATE_VERSION_INFO is true.
-function update_version_info() {
-  if [ "$UPDATE_VERSION_INFO" == "true" ]; then
-    # If it's the officail release(like v1.0.0, v1.0.1, v1.0.2, etc.), update latest-version.txt.
-    if [[ "$VERSION" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-      echo "Updating latest-version.txt"
-      echo "$VERSION" > latest-version.txt
-      aws s3 cp \
-        latest-version.txt "s3://$AWS_S3_BUCKET/$RELEASE_DIRS/latest-version.txt"
-    fi
-
-    # If it's the nightly release, update latest-nightly-version.txt.
-    if [[ "$VERSION" == *"nightly"* ]]; then
-      echo "Updating latest-nightly-version.txt"
-      echo "$VERSION" > latest-nightly-version.txt
-      aws s3 cp \
-        latest-nightly-version.txt "s3://$AWS_S3_BUCKET/$RELEASE_DIRS/latest-nightly-version.txt"
-    fi
-  fi
-}
-
-# Downloads artifacts from Github if DOWNLOAD_ARTIFACTS_FROM_GITHUB is true.
-function download_artifacts_from_github() {
-  if [ "$DOWNLOAD_ARTIFACTS_FROM_GITHUB" == "true" ]; then
-    # Check if jq is installed.
-    if ! command -v jq &> /dev/null; then
-      echo "jq is not installed. Please install jq to continue."
-      exit 1
-    fi
-
-    # Get the latest release API response.
-    RELEASES_API_RESPONSE=$(curl -s -H "Accept: application/vnd.github.v3+json" "https://api.github.com/repos/$GREPTIMEDB_REPO/releases/latest")
-
-    # Extract download URLs for the artifacts.
-    # Exclude source code archives which are typically named as 'greptimedb-<version>.zip' or 'greptimedb-<version>.tar.gz'.
-    ASSET_URLS=$(echo "$RELEASES_API_RESPONSE" | jq -r '.assets[] | select(.name | test("greptimedb-.*\\.(zip|tar\\.gz)$") | not) | .browser_download_url')
-
-    # Download each asset.
-    while IFS= read -r url; do
-      if [ -n "$url" ]; then
-        curl -LJO "$url"
-        echo "Downloaded: $url"
-      fi
-    done <<< "$ASSET_URLS"
-  fi
-}
-
-function main() {
-  check_vars
-  download_artifacts_from_github
-  upload_artifacts
-  update_version_info
-}
-
-# Usage example:
-#   AWS_ACCESS_KEY_ID=<your_access_key_id> \
-#   AWS_SECRET_ACCESS_KEY=<your_secret_access_key> \
-#   AWS_DEFAULT_REGION=<your_region> \
-#   UPDATE_VERSION_INFO=true \
-#   DOWNLOAD_ARTIFACTS_FROM_GITHUB=false \
-#     ./upload-artifacts-to-s3.sh <artifacts-dir> <version> <aws-s3-bucket>
-main

.github/workflows/apidoc.yml

@@ -1,7 +1,7 @@
 on:
   push:
     branches:
-      - main
+      - develop
     paths-ignore:
       - 'docs/**'
       - 'config/**'
@@ -13,14 +13,14 @@ on:
 name: Build API docs
 
 env:
-  RUST_TOOLCHAIN: nightly-2023-12-19
+  RUST_TOOLCHAIN: nightly-2023-08-07
 
 jobs:
   apidoc:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: arduino/setup-protoc@v3
+    - uses: actions/checkout@v3
+    - uses: arduino/setup-protoc@v1
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
     - uses: dtolnay/rust-toolchain@master

.github/workflows/dev-build.yml

@@ -16,11 +16,11 @@ on:
         description: The runner uses to build linux-amd64 artifacts
         default: ec2-c6i.4xlarge-amd64
         options:
-          - ubuntu-20.04
-          - ubuntu-20.04-8-cores
-          - ubuntu-20.04-16-cores
-          - ubuntu-20.04-32-cores
-          - ubuntu-20.04-64-cores
+          - ubuntu-latest
+          - ubuntu-latest-8-cores
+          - ubuntu-latest-16-cores
+          - ubuntu-latest-32-cores
+          - ubuntu-latest-64-cores
           - ec2-c6i.xlarge-amd64 # 4C8G
           - ec2-c6i.2xlarge-amd64 # 8C16G
           - ec2-c6i.4xlarge-amd64 # 16C32G
@@ -55,18 +55,10 @@ on:
         description: Build and push images to DockerHub and ACR
         required: false
         default: true
-      cargo_profile:
-        type: choice
-        description: The cargo profile to use in building GreptimeDB.
-        default: nightly
-        options:
-          - dev
-          - release
-          - nightly
 
 # Use env variables to control all the release process.
 env:
-  CARGO_PROFILE: ${{ inputs.cargo_profile }}
+  CARGO_PROFILE: nightly
 
   # Controls whether to run tests, include unit-test, integration-test and sqlness.
   DISABLE_RUN_TESTS: ${{ inputs.skip_test || vars.DEFAULT_SKIP_TEST }}
@@ -86,7 +78,7 @@ jobs:
   allocate-runners:
     name: Allocate runners
     if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     outputs:
       linux-amd64-runner: ${{ steps.start-linux-amd64-runner.outputs.label }}
       linux-arm64-runner: ${{ steps.start-linux-arm64-runner.outputs.label }}
@@ -101,7 +93,7 @@ jobs:
       version: ${{ steps.create-version.outputs.version }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -155,12 +147,12 @@ jobs:
     runs-on: ${{ needs.allocate-runners.outputs.linux-amd64-runner }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
       - name: Checkout greptimedb
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           repository: ${{ inputs.repository }}
           ref: ${{ inputs.commit }}
@@ -172,7 +164,12 @@ jobs:
           cargo-profile: ${{ env.CARGO_PROFILE }}
           version: ${{ needs.allocate-runners.outputs.version }}
           disable-run-tests: ${{ env.DISABLE_RUN_TESTS }}
+          release-to-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
+          aws-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
           dev-mode: true # Only build the standard greptime binary.
+          upload-to-s3: false # No need to upload to S3.
           working-dir: ${{ env.CHECKOUT_GREPTIMEDB_PATH }}
 
   build-linux-arm64-artifacts:
@@ -184,12 +181,12 @@ jobs:
     runs-on: ${{ needs.allocate-runners.outputs.linux-arm64-runner }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
       - name: Checkout greptimedb
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           repository: ${{ inputs.repository }}
           ref: ${{ inputs.commit }}
@@ -201,7 +198,12 @@ jobs:
           cargo-profile: ${{ env.CARGO_PROFILE }}
           version: ${{ needs.allocate-runners.outputs.version }}
           disable-run-tests: ${{ env.DISABLE_RUN_TESTS }}
+          release-to-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
+          aws-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
           dev-mode: true # Only build the standard greptime binary.
+          upload-to-s3: false # No need to upload to S3.
           working-dir: ${{ env.CHECKOUT_GREPTIMEDB_PATH }}
 
   release-images-to-dockerhub:
@@ -212,11 +214,11 @@ jobs:
       build-linux-amd64-artifacts,
       build-linux-arm64-artifacts,
     ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     outputs:
       build-result: ${{ steps.set-build-result.outputs.build-result }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -237,51 +239,48 @@ jobs:
         run: |
           echo "build-result=success" >> $GITHUB_OUTPUT
 
-  release-cn-artifacts:
-    name: Release artifacts to CN region
+  release-images-to-acr:
+    name: Build and push images to ACR
     if: ${{ inputs.release_images || github.event_name == 'schedule' }}
     needs: [
       allocate-runners,
-      release-images-to-dockerhub,
+      build-linux-amd64-artifacts,
+      build-linux-arm64-artifacts,
     ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
+    # When we push to ACR, it's easy to fail due to some unknown network issues.
+    # However, we don't want to fail the whole workflow because of this.
+    # The ACR have daily sync with DockerHub, so don't worry about the image not being updated.
     continue-on-error: true
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
-      - name: Release artifacts to CN region
-        uses: ./.github/actions/release-cn-artifacts
+      - name: Build and push images to ACR
+        uses: ./.github/actions/build-images
         with:
-          src-image-registry: docker.io
-          src-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          src-image-name: ${{ env.IMAGE_NAME }}
-          dst-image-registry-username: ${{ secrets.ALICLOUD_USERNAME }}
-          dst-image-registry-password: ${{ secrets.ALICLOUD_PASSWORD }}
-          dst-image-registry: ${{ vars.ACR_IMAGE_REGISTRY }}
-          dst-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
+          image-registry: ${{ vars.ACR_IMAGE_REGISTRY }}
+          image-namespace: ${{ vars.IMAGE_NAMESPACE }}
+          image-name: ${{ env.IMAGE_NAME }}
+          image-registry-username: ${{ secrets.ALICLOUD_USERNAME }}
+          image-registry-password: ${{ secrets.ALICLOUD_PASSWORD }}
           version: ${{ needs.allocate-runners.outputs.version }}
-          aws-cn-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
-          aws-cn-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
-          aws-cn-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
-          aws-cn-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
-          dev-mode: true                     # Only build the standard images(exclude centos images).
-          push-latest-tag: false             # Don't push the latest tag to registry.
-          update-version-info: false         # Don't update the version info in S3.
+          push-latest-tag: false # Don't push the latest tag to registry.
+          dev-mode: true # Only build the standard images.
 
   stop-linux-amd64-runner: # It's always run as the last job in the workflow to make sure that the runner is released.
     name: Stop linux-amd64 runner
     # Only run this job when the runner is allocated.
     if: ${{ always() }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: [
       allocate-runners,
       build-linux-amd64-artifacts,
     ]
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -299,14 +298,14 @@ jobs:
     name: Stop linux-arm64 runner
     # Only run this job when the runner is allocated.
     if: ${{ always() }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: [
       allocate-runners,
       build-linux-arm64-artifacts,
     ]
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -326,18 +325,18 @@ jobs:
     needs: [
       release-images-to-dockerhub
     ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     env:
       SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_DEVELOP_CHANNEL }}
     steps:
-      - name: Notifiy dev build successful result
+      - name: Notifiy nightly build successful result
         uses: slackapi/slack-github-action@v1.23.0
         if: ${{ needs.release-images-to-dockerhub.outputs.build-result == 'success' }}
         with:
           payload: |
             {"text": "GreptimeDB's ${{ env.NEXT_RELEASE_VERSION }} build has completed successfully."}
 
-      - name: Notifiy dev build failed result
+      - name: Notifiy nightly build failed result
         uses: slackapi/slack-github-action@v1.23.0
         if: ${{ needs.release-images-to-dockerhub.outputs.build-result != 'success' }}
         with:

.github/workflows/develop.yml

@@ -1,7 +1,7 @@
 on:
   merge_group:
   pull_request:
-    types: [ opened, synchronize, reopened, ready_for_review ]
+    types: [opened, synchronize, reopened, ready_for_review]
     paths-ignore:
       - 'docs/**'
       - 'config/**'
@@ -9,9 +9,9 @@ on:
       - '.dockerignore'
       - 'docker/**'
       - '.gitignore'
-      - 'grafana/**'
   push:
     branches:
+      - develop
       - main
     paths-ignore:
       - 'docs/**'
@@ -20,7 +20,6 @@ on:
       - '.dockerignore'
       - 'docker/**'
       - '.gitignore'
-      - 'grafana/**'
   workflow_dispatch:
 
 name: CI
@@ -30,26 +29,24 @@ concurrency:
   cancel-in-progress: true
 
 env:
-  RUST_TOOLCHAIN: nightly-2023-12-19
+  RUST_TOOLCHAIN: nightly-2023-08-07
 
 jobs:
   typos:
     name: Spell Check with Typos
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - uses: crate-ci/typos@v1.13.10
 
   check:
     name: Check
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ windows-latest, ubuntu-20.04 ]
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-protoc@v1
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
       - uses: dtolnay/rust-toolchain@master
@@ -57,130 +54,62 @@ jobs:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          # Shares with `Clippy` job
-          shared-key: "check-lint"
       - name: Run cargo check
         run: cargo check --locked --workspace --all-targets
 
   toml:
     name: Toml Check
-    runs-on: ubuntu-20.04
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: stable
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          shared-key: "check-toml"
       - name: Install taplo
-        run: cargo +stable install taplo-cli --version ^0.9 --locked
+        run: cargo +stable install taplo-cli --version ^0.8 --locked
       - name: Run taplo
         run: taplo format --check
 
-  build:
-    name: Build GreptimeDB binaries
+  sqlness:
+    name: Sqlness Test
+    if: github.event.pull_request.draft == false
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ ubuntu-20.04 ]
+        os: [ ubuntu-latest-8-cores, windows-latest-8-cores ]
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-protoc@v1
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
-      - uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          shared-key: "build-binaries"
-      - name: Build greptime binaries
-        shell: bash
-        run: cargo build
-      - name: Pack greptime binaries
-        shell: bash
-        run: |
-          mkdir bins && \
-          mv ./target/debug/greptime bins && \
-          mv ./target/debug/sqlness-runner bins
-      - name: Print greptime binaries info
-        run: ls -lh bins
-      - name: Upload artifacts
-        uses: ./.github/actions/upload-artifacts
-        with:
-          artifacts-dir: bins
-          version: current
-
-  sqlness:
-    name: Sqlness Test
-    needs: build
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-20.04 ]
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download pre-built binaries
-        uses: actions/download-artifact@v4
-        with:
-          name: bins
-          path: .
-      - name: Unzip binaries
-        run: tar -xvf ./bins.tar.gz
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
       - name: Run sqlness
-        run: RUST_BACKTRACE=1 ./bins/sqlness-runner -c ./tests/cases --bins-dir ./bins
+        run: cargo sqlness
       - name: Upload sqlness logs
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: sqlness-logs
-          path: /tmp/greptime-*.log
-          retention-days: 3
-
-  sqlness-kafka-wal:
-    name: Sqlness Test with Kafka Wal
-    needs: build
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-20.04 ]
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download pre-built binaries
-        uses: actions/download-artifact@v4
-        with:
-          name: bins
-          path: .
-      - name: Unzip binaries
-        run: tar -xvf ./bins.tar.gz
-      - name: Setup kafka server
-        working-directory: tests-integration/fixtures/kafka
-        run: docker compose -f docker-compose-standalone.yml up -d --wait
-      - name: Run sqlness
-        run: RUST_BACKTRACE=1 ./bins/sqlness-runner -w kafka -k 127.0.0.1:9092 -c ./tests/cases --bins-dir ./bins
-      - name: Upload sqlness logs
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: sqlness-logs-with-kafka-wal
-          path: /tmp/greptime-*.log
+          path: ${{ runner.temp }}/greptime-*.log
           retention-days: 3
 
   fmt:
     name: Rustfmt
-    runs-on: ubuntu-20.04
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-protoc@v1
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
       - uses: dtolnay/rust-toolchain@master
@@ -189,19 +118,17 @@ jobs:
           components: rustfmt
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          shared-key: "check-rust-fmt"
       - name: Run cargo fmt
         run: cargo fmt --all -- --check
 
   clippy:
     name: Clippy
-    runs-on: ubuntu-20.04
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-protoc@v1
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
       - uses: dtolnay/rust-toolchain@master
@@ -210,20 +137,16 @@ jobs:
           components: clippy
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          # Shares with `Check` job
-          shared-key: "check-lint"
       - name: Run cargo clippy
         run: cargo clippy --workspace --all-targets -- -D warnings
 
   coverage:
     if: github.event.pull_request.draft == false
-    runs-on: ubuntu-20.04-8-cores
+    runs-on: ubuntu-latest-8-cores
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-protoc@v1
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
       - uses: KyleMayes/install-llvm-action@v1
@@ -236,26 +159,17 @@ jobs:
           components: llvm-tools-preview
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
-        with:
-          # Shares cross multiple jobs
-          shared-key: "coverage-test"
       - name: Install latest nextest release
         uses: taiki-e/install-action@nextest
-      - name: Install cargo-llvm-cov
-        uses: taiki-e/install-action@cargo-llvm-cov
       - name: Install Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v4
         with:
           python-version: '3.10'
       - name: Install PyArrow Package
         run: pip install pyarrow
-      - name: Setup etcd server
-        working-directory: tests-integration/fixtures/etcd
-        run: docker compose -f docker-compose-standalone.yml up -d --wait
-      - name: Setup kafka server
-        working-directory: tests-integration/fixtures/kafka
-        run: docker compose -f docker-compose-standalone.yml up -d --wait
-      - name: Run nextest cases
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
+      - name: Collect coverage data
         run: cargo llvm-cov nextest --workspace --lcov --output-path lcov.info -F pyo3_backend -F dashboard
         env:
           CARGO_BUILD_RUSTFLAGS: "-C link-arg=-fuse-ld=lld"
@@ -265,11 +179,9 @@ jobs:
           GT_S3_ACCESS_KEY_ID: ${{ secrets.S3_ACCESS_KEY_ID }}
           GT_S3_ACCESS_KEY: ${{ secrets.S3_ACCESS_KEY }}
           GT_S3_REGION: ${{ secrets.S3_REGION }}
-          GT_ETCD_ENDPOINTS: http://127.0.0.1:2379
-          GT_KAFKA_ENDPOINTS: 127.0.0.1:9092
           UNITTEST_LOG_DIR: "__unittest_logs"
       - name: Codecov upload
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v2
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./lcov.info
@@ -277,20 +189,42 @@ jobs:
           fail_ci_if_error: false
           verbose: true
 
-  compat:
-    name: Compatibility Test
-    needs: build
-    runs-on: ubuntu-20.04
+  test-on-windows:
+    if: github.event.pull_request.draft == false
+    runs-on: windows-latest-8-cores
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
-      - name: Download pre-built binaries
-        uses: actions/download-artifact@v4
+      - run: git config --global core.autocrlf false
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-protoc@v1
         with:
-          name: bins
-          path: .
-      - name: Unzip binaries
-        run: |
-          mkdir -p ./bins/current
-          tar -xvf ./bins.tar.gz --strip-components=1 -C ./bins/current
-      - run: ./tests/compat/test-compat.sh 0.6.0
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
+          components: llvm-tools-preview
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+      - name: Install Cargo Nextest
+        uses: taiki-e/install-action@nextest
+      - name: Install Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+      - name: Install PyArrow Package
+        run: pip install pyarrow
+      - name: Install WSL distribution
+        uses: Vampire/setup-wsl@v2
+        with:
+          distribution: Ubuntu-22.04
+      - name: Running tests
+        run: cargo nextest run -F pyo3_backend,dashboard
+        env:
+          RUST_BACKTRACE: 1
+          CARGO_INCREMENTAL: 0
+          GT_S3_BUCKET: ${{ secrets.S3_BUCKET }}
+          GT_S3_ACCESS_KEY_ID: ${{ secrets.S3_ACCESS_KEY_ID }}
+          GT_S3_ACCESS_KEY: ${{ secrets.S3_ACCESS_KEY }}
+          GT_S3_REGION: ${{ secrets.S3_REGION }}
+          UNITTEST_LOG_DIR: "__unittest_logs"

.github/workflows/doc-issue.yml

@@ -11,10 +11,10 @@ on:
 jobs:
   doc_issue:
     if: github.event.label.name == 'doc update required'
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - name: create an issue in doc repo
-        uses: dacbd/create-issue-action@v1.2.1
+        uses: dacbd/create-issue-action@main
         with:
           owner: GreptimeTeam
           repo: docs
@@ -25,10 +25,10 @@ jobs:
             ${{ github.event.issue.html_url || github.event.pull_request.html_url }}
   cloud_issue:
     if: github.event.label.name == 'cloud followup required'
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - name: create an issue in cloud repo
-        uses: dacbd/create-issue-action@v1.2.1
+        uses: dacbd/create-issue-action@main
         with:
           owner: GreptimeTeam
           repo: greptimedb-cloud

.github/workflows/doc-label.yml

@@ -1,36 +0,0 @@
-name: "PR Doc Labeler"
-on:
-  pull_request_target:
-    types: [opened, edited, synchronize, ready_for_review, auto_merge_enabled, labeled, unlabeled]
-
-permissions:
-  pull-requests: write
-  contents: read
-
-jobs:
-  triage:
-    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    runs-on: ubuntu-latest
-    steps:
-    - uses: github/issue-labeler@v3.4
-      with:
-        configuration-path: .github/doc-label-config.yml
-        enable-versioned-regex: false
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        sync-labels: 1
-    - name: create an issue in doc repo
-      uses: dacbd/create-issue-action@v1.2.1
-      if: ${{ github.event.action == 'opened' && contains(github.event.pull_request.body, '- [ ]  This PR does not require documentation updates.') }}
-      with:
-        owner: GreptimeTeam
-        repo: docs
-        token: ${{ secrets.DOCS_REPO_TOKEN }}
-        title: Update docs for ${{ github.event.issue.title || github.event.pull_request.title }}
-        body: |
-          A document change request is generated from
-          ${{ github.event.issue.html_url || github.event.pull_request.html_url }}
-    - name: Check doc labels
-      uses: docker://agilepathway/pull-request-label-checker:latest
-      with:
-        one_of: Doc update required,Doc not needed
-        repo_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/docs.yml

@@ -9,9 +9,9 @@ on:
       - '.dockerignore'
       - 'docker/**'
       - '.gitignore'
-      - 'grafana/**'
   push:
     branches:
+      - develop
       - main
     paths:
       - 'docs/**'
@@ -20,7 +20,6 @@ on:
       - '.dockerignore'
       - 'docker/**'
       - '.gitignore'
-      - 'grafana/**'
   workflow_dispatch:
 
 name: CI
@@ -31,48 +30,41 @@ name: CI
 jobs:
   typos:
     name: Spell Check with Typos
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - uses: crate-ci/typos@v1.13.10
 
   check:
     name: Check
-    runs-on: ubuntu-20.04
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     steps:
       - run: 'echo "No action required"'
 
   fmt:
     name: Rustfmt
-    runs-on: ubuntu-20.04
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     steps:
       - run: 'echo "No action required"'
 
   clippy:
     name: Clippy
-    runs-on: ubuntu-20.04
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     steps:
       - run: 'echo "No action required"'
 
   coverage:
-    runs-on: ubuntu-20.04
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     steps:
       - run: 'echo "No action required"'
 
   sqlness:
     name: Sqlness Test
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-20.04 ]
-    steps:
-      - run: 'echo "No action required"'
-
-  sqlness-kafka-wal:
-    name: Sqlness Test with Kafka Wal
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-20.04 ]
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     steps:
       - run: 'echo "No action required"'

.github/workflows/license.yaml

@@ -3,14 +3,14 @@ name: License checker
 on:
   push:
     branches:
-    - main
+    - develop
   pull_request:
     types: [opened, synchronize, reopened, ready_for_review]
 jobs:
   license-header-check:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     name: license-header-check
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
     - name: Check License Header
-      uses: korandoru/hawkeye@v4
+      uses: apache/skywalking-eyes/header@df70871af1a8109c9a5b1dc824faaf65246c5236

.github/workflows/nightly-build.yml

@@ -14,11 +14,11 @@ on:
         description: The runner uses to build linux-amd64 artifacts
         default: ec2-c6i.2xlarge-amd64
         options:
-          - ubuntu-20.04
-          - ubuntu-20.04-8-cores
-          - ubuntu-20.04-16-cores
-          - ubuntu-20.04-32-cores
-          - ubuntu-20.04-64-cores
+          - ubuntu-latest
+          - ubuntu-latest-8-cores
+          - ubuntu-latest-16-cores
+          - ubuntu-latest-32-cores
+          - ubuntu-latest-64-cores
           - ec2-c6i.xlarge-amd64 # 4C8G
           - ec2-c6i.2xlarge-amd64 # 8C16G
           - ec2-c6i.4xlarge-amd64 # 16C32G
@@ -70,7 +70,7 @@ jobs:
   allocate-runners:
     name: Allocate runners
     if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     outputs:
       linux-amd64-runner: ${{ steps.start-linux-amd64-runner.outputs.label }}
       linux-arm64-runner: ${{ steps.start-linux-arm64-runner.outputs.label }}
@@ -85,7 +85,7 @@ jobs:
       version: ${{ steps.create-version.outputs.version }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -137,7 +137,7 @@ jobs:
     ]
     runs-on: ${{ needs.allocate-runners.outputs.linux-amd64-runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -147,6 +147,11 @@ jobs:
           cargo-profile: ${{ env.CARGO_PROFILE }}
           version: ${{ needs.allocate-runners.outputs.version }}
           disable-run-tests: ${{ env.DISABLE_RUN_TESTS }}
+          release-to-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
+          aws-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
+          upload-latest-artifacts: false
 
   build-linux-arm64-artifacts:
     name: Build linux-arm64 artifacts
@@ -156,7 +161,7 @@ jobs:
     ]
     runs-on: ${{ needs.allocate-runners.outputs.linux-arm64-runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -166,6 +171,11 @@ jobs:
           cargo-profile: ${{ env.CARGO_PROFILE }}
           version: ${{ needs.allocate-runners.outputs.version }}
           disable-run-tests: ${{ env.DISABLE_RUN_TESTS }}
+          release-to-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
+          aws-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
+          upload-latest-artifacts: false
 
   release-images-to-dockerhub:
     name: Build and push images to DockerHub
@@ -175,11 +185,11 @@ jobs:
       build-linux-amd64-artifacts,
       build-linux-arm64-artifacts,
     ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     outputs:
       nightly-build-result: ${{ steps.set-nightly-build-result.outputs.nightly-build-result }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -198,54 +208,46 @@ jobs:
         run: |
           echo "nightly-build-result=success" >> $GITHUB_OUTPUT
 
-  release-cn-artifacts:
-    name: Release artifacts to CN region
+  release-images-to-acr:
+    name: Build and push images to ACR
     if: ${{ inputs.release_images || github.event_name == 'schedule' }}
     needs: [
       allocate-runners,
-      release-images-to-dockerhub,
+      build-linux-amd64-artifacts,
+      build-linux-arm64-artifacts,
     ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     # When we push to ACR, it's easy to fail due to some unknown network issues.
     # However, we don't want to fail the whole workflow because of this.
     # The ACR have daily sync with DockerHub, so don't worry about the image not being updated.
     continue-on-error: true
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
-      - name: Release artifacts to CN region
-        uses: ./.github/actions/release-cn-artifacts
+      - name: Build and push images to ACR
+        uses: ./.github/actions/build-images
         with:
-          src-image-registry: docker.io
-          src-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          src-image-name: greptimedb
-          dst-image-registry-username: ${{ secrets.ALICLOUD_USERNAME }}
-          dst-image-registry-password: ${{ secrets.ALICLOUD_PASSWORD }}
-          dst-image-registry: ${{ vars.ACR_IMAGE_REGISTRY }}
-          dst-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
+          image-registry: ${{ vars.ACR_IMAGE_REGISTRY }}
+          image-namespace: ${{ vars.IMAGE_NAMESPACE }}
+          image-registry-username: ${{ secrets.ALICLOUD_USERNAME }}
+          image-registry-password: ${{ secrets.ALICLOUD_PASSWORD }}
           version: ${{ needs.allocate-runners.outputs.version }}
-          aws-cn-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
-          aws-cn-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
-          aws-cn-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
-          aws-cn-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
-          dev-mode: false
-          update-version-info: false  # Don't update version info in S3.
-          push-latest-tag: false      # Don't push the latest tag to registry.
+          push-latest-tag: false # Don't push the latest tag to registry.
 
   stop-linux-amd64-runner: # It's always run as the last job in the workflow to make sure that the runner is released.
     name: Stop linux-amd64 runner
     # Only run this job when the runner is allocated.
     if: ${{ always() }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: [
       allocate-runners,
       build-linux-amd64-artifacts,
     ]
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -263,14 +265,14 @@ jobs:
     name: Stop linux-arm64 runner
     # Only run this job when the runner is allocated.
     if: ${{ always() }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: [
       allocate-runners,
       build-linux-arm64-artifacts,
     ]
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -290,7 +292,7 @@ jobs:
     needs: [
       release-images-to-dockerhub
     ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     env:
       SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_DEVELOP_CHANNEL }}
     steps:

.github/workflows/nightly-ci.yml

@@ -1,100 +0,0 @@
-# Nightly CI: runs tests every night for our second tier plaforms (Windows)
-
-on:
-  schedule:
-    - cron: '0 23 * * 1-5'
-  workflow_dispatch:
-
-name: Nightly CI
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  RUST_TOOLCHAIN: nightly-2023-12-19
-
-jobs:
-  sqlness:
-    name: Sqlness Test
-    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ windows-latest-8-cores ]
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_TOOLCHAIN }}
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-      - name: Run sqlness
-        run: cargo sqlness
-      - name: Notify slack if failed
-        if: failure()
-        uses: slackapi/slack-github-action@v1.23.0
-        env:
-          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_DEVELOP_CHANNEL }}
-        with:
-          payload: |
-            {"text": "Nightly CI failed for sqlness tests"}
-      - name: Upload sqlness logs
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: sqlness-logs
-          path: /tmp/greptime-*.log
-          retention-days: 3
-
-  test-on-windows:
-    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    runs-on: windows-latest-8-cores
-    timeout-minutes: 60
-    steps:
-      - run: git config --global core.autocrlf false
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_TOOLCHAIN }}
-          components: llvm-tools-preview
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-      - name: Install Cargo Nextest
-        uses: taiki-e/install-action@nextest
-      - name: Install Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.10'
-      - name: Install PyArrow Package
-        run: pip install pyarrow
-      - name: Install WSL distribution
-        uses: Vampire/setup-wsl@v2
-        with:
-          distribution: Ubuntu-22.04
-      - name: Running tests
-        run: cargo nextest run -F pyo3_backend,dashboard
-        env:
-          RUST_BACKTRACE: 1
-          CARGO_INCREMENTAL: 0
-          GT_S3_BUCKET: ${{ secrets.S3_BUCKET }}
-          GT_S3_ACCESS_KEY_ID: ${{ secrets.S3_ACCESS_KEY_ID }}
-          GT_S3_ACCESS_KEY: ${{ secrets.S3_ACCESS_KEY }}
-          GT_S3_REGION: ${{ secrets.S3_REGION }}
-          UNITTEST_LOG_DIR: "__unittest_logs"
-      - name: Notify slack if failed
-        if: failure()
-        uses: slackapi/slack-github-action@v1.23.0
-        env:
-          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_DEVELOP_CHANNEL }}
-        with:
-          payload: |
-            {"text": "Nightly CI failed for cargo test"}

.github/workflows/nightly-funtional-tests.yml

@@ -1,27 +0,0 @@
-name: Nightly functional tests
-
-on:
-  schedule:
-    # At 00:00 on Tuesday.
-    - cron: '0 0 * * 2'
-  workflow_dispatch:
-
-jobs:
-  sqlness-test:
-    name: Run sqlness test
-    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Run sqlness test
-        uses: ./.github/actions/sqlness-test
-        with:
-          data-root: sqlness-test
-          aws-ci-test-bucket: ${{ vars.AWS_CI_TEST_BUCKET }}
-          aws-region: ${{ vars.AWS_CI_TEST_BUCKET_REGION }}
-          aws-access-key-id: ${{ secrets.AWS_CI_TEST_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_CI_TEST_SECRET_ACCESS_KEY }}

.github/workflows/pr-title-checker.yml

@@ -10,19 +10,19 @@ on:
 
 jobs:
   check:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: thehanimo/pr-title-checker@v1.4.2
+      - uses: thehanimo/pr-title-checker@v1.3.4
         with:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           pass_on_octokit_error: false
           configuration_path: ".github/pr-title-checker-config.json"
   breaking:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: thehanimo/pr-title-checker@v1.4.2
+      - uses: thehanimo/pr-title-checker@v1.3.4
         with:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           pass_on_octokit_error: false

.github/workflows/release-dev-builder-images.yaml

@@ -1,85 +0,0 @@
-name: Release dev-builder images
-
-on:
-  workflow_dispatch: # Allows you to run this workflow manually.
-    inputs:
-      version:
-        description: Version of the dev-builder
-        required: false
-        default: latest
-      release_dev_builder_ubuntu_image:
-        type: boolean
-        description: Release dev-builder-ubuntu image
-        required: false
-        default: false
-      release_dev_builder_centos_image:
-        type: boolean
-        description: Release dev-builder-centos image
-        required: false
-        default: false
-      release_dev_builder_android_image:
-        type: boolean
-        description: Release dev-builder-android image
-        required: false
-        default: false
-
-jobs:
-  release-dev-builder-images:
-    name: Release dev builder images
-    if: ${{ inputs.release_dev_builder_ubuntu_image || inputs.release_dev_builder_centos_image || inputs.release_dev_builder_android_image }} # Only manually trigger this job.
-    runs-on: ubuntu-20.04-16-cores
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Build and push dev builder images
-        uses: ./.github/actions/build-dev-builder-images
-        with:
-          version: ${{ inputs.version }}
-          dockerhub-image-registry-username: ${{ secrets.DOCKERHUB_USERNAME }}
-          dockerhub-image-registry-token: ${{ secrets.DOCKERHUB_TOKEN }}
-          build-dev-builder-ubuntu: ${{ inputs.release_dev_builder_ubuntu_image }}
-          build-dev-builder-centos: ${{ inputs.release_dev_builder_centos_image }}
-          build-dev-builder-android: ${{ inputs.release_dev_builder_android_image }}
-
-  release-dev-builder-images-cn: # Note: Be careful issue: https://github.com/containers/skopeo/issues/1874 and we decide to use the latest stable skopeo container.
-    name: Release dev builder images to CN region
-    runs-on: ubuntu-20.04
-    needs: [
-      release-dev-builder-images
-    ]
-    steps:
-      - name: Push dev-builder-ubuntu image
-        shell: bash
-        if: ${{ inputs.release_dev_builder_ubuntu_image }}
-        env:
-          DST_REGISTRY_USERNAME: ${{ secrets.ALICLOUD_USERNAME }}
-          DST_REGISTRY_PASSWORD: ${{ secrets.ALICLOUD_PASSWORD }}
-        run: |
-          docker run quay.io/skopeo/stable:latest copy -a docker://docker.io/${{ vars.IMAGE_NAMESPACE }}/dev-builder-ubuntu:${{ inputs.version }} \
-            --dest-creds "$DST_REGISTRY_USERNAME":"$DST_REGISTRY_PASSWORD" \
-            docker://${{ vars.ACR_IMAGE_REGISTRY }}/${{ vars.IMAGE_NAMESPACE }}/dev-builder-ubuntu:${{ inputs.version }}
-
-      - name: Push dev-builder-centos image
-        shell: bash
-        if: ${{ inputs.release_dev_builder_centos_image }}
-        env:
-          DST_REGISTRY_USERNAME: ${{ secrets.ALICLOUD_USERNAME }}
-          DST_REGISTRY_PASSWORD: ${{ secrets.ALICLOUD_PASSWORD }}
-        run: |
-          docker run quay.io/skopeo/stable:latest copy -a docker://docker.io/${{ vars.IMAGE_NAMESPACE }}/dev-builder-centos:${{ inputs.version }} \
-            --dest-creds "$DST_REGISTRY_USERNAME":"$DST_REGISTRY_PASSWORD" \
-            docker://${{ vars.ACR_IMAGE_REGISTRY }}/${{ vars.IMAGE_NAMESPACE }}/dev-builder-centos:${{ inputs.version }}
-
-      - name: Push dev-builder-android image
-        shell: bash
-        if: ${{ inputs.release_dev_builder_android_image }}
-        env:
-          DST_REGISTRY_USERNAME: ${{ secrets.ALICLOUD_USERNAME }}
-          DST_REGISTRY_PASSWORD: ${{ secrets.ALICLOUD_PASSWORD }}
-        run: |
-          docker run quay.io/skopeo/stable:latest copy -a docker://docker.io/${{ vars.IMAGE_NAMESPACE }}/dev-builder-android:${{ inputs.version }} \
-            --dest-creds "$DST_REGISTRY_USERNAME":"$DST_REGISTRY_PASSWORD" \
-            docker://${{ vars.ACR_IMAGE_REGISTRY }}/${{ vars.IMAGE_NAMESPACE }}/dev-builder-android:${{ inputs.version }}

.github/workflows/release.yml

@@ -18,11 +18,11 @@ on:
         description: The runner uses to build linux-amd64 artifacts
         default: ec2-c6i.4xlarge-amd64
         options:
-          - ubuntu-20.04
-          - ubuntu-20.04-8-cores
-          - ubuntu-20.04-16-cores
-          - ubuntu-20.04-32-cores
-          - ubuntu-20.04-64-cores
+          - ubuntu-latest
+          - ubuntu-latest-8-cores
+          - ubuntu-latest-16-cores
+          - ubuntu-latest-32-cores
+          - ubuntu-latest-64-cores
           - ec2-c6i.xlarge-amd64 # 4C8G
           - ec2-c6i.2xlarge-amd64 # 8C16G
           - ec2-c6i.4xlarge-amd64 # 16C32G
@@ -63,12 +63,7 @@ on:
         description: Build macos artifacts
         required: false
         default: false
-      build_windows_artifacts:
-        type: boolean
-        description: Build Windows artifacts
-        required: false
-        default: false
-      publish_github_release:
+      release_artifacts:
         type: boolean
         description: Create GitHub release and upload artifacts
         required: false
@@ -78,11 +73,16 @@ on:
         description: Build and push images to DockerHub and ACR
         required: false
         default: false
+      release_dev_builder_image:
+        type: boolean
+        description: Release dev-builder image
+        required: false
+        default: false
 
 # Use env variables to control all the release process.
 env:
   # The arguments of building greptime.
-  RUST_TOOLCHAIN: nightly-2023-12-19
+  RUST_TOOLCHAIN: nightly-2023-08-07
   CARGO_PROFILE: nightly
 
   # Controls whether to run tests, include unit-test, integration-test and sqlness.
@@ -91,18 +91,17 @@ env:
   # The scheduled version is '${{ env.NEXT_RELEASE_VERSION }}-nightly-YYYYMMDD', like v0.2.0-nigthly-20230313;
   NIGHTLY_RELEASE_PREFIX: nightly
   # Note: The NEXT_RELEASE_VERSION should be modified manually by every formal release.
-  NEXT_RELEASE_VERSION: v0.8.0
+  NEXT_RELEASE_VERSION: v0.4.0
 
 jobs:
   allocate-runners:
     name: Allocate runners
     if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     outputs:
       linux-amd64-runner: ${{ steps.start-linux-amd64-runner.outputs.label }}
       linux-arm64-runner: ${{ steps.start-linux-arm64-runner.outputs.label }}
       macos-runner: ${{ inputs.macos_runner || vars.DEFAULT_MACOS_RUNNER }}
-      windows-runner: windows-latest-8-cores
 
       # The following EC2 resource id will be used for resource releasing.
       linux-amd64-ec2-runner-label: ${{ steps.start-linux-amd64-runner.outputs.label }}
@@ -114,7 +113,7 @@ jobs:
       version: ${{ steps.create-version.outputs.version }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -168,7 +167,7 @@ jobs:
     ]
     runs-on: ${{ needs.allocate-runners.outputs.linux-amd64-runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -178,6 +177,10 @@ jobs:
           cargo-profile: ${{ env.CARGO_PROFILE }}
           version: ${{ needs.allocate-runners.outputs.version }}
           disable-run-tests: ${{ env.DISABLE_RUN_TESTS }}
+          release-to-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
+          aws-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
 
   build-linux-arm64-artifacts:
     name: Build linux-arm64 artifacts
@@ -187,7 +190,7 @@ jobs:
     ]
     runs-on: ${{ needs.allocate-runners.outputs.linux-arm64-runner }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -197,6 +200,10 @@ jobs:
           cargo-profile: ${{ env.CARGO_PROFILE }}
           version: ${{ needs.allocate-runners.outputs.version }}
           disable-run-tests: ${{ env.DISABLE_RUN_TESTS }}
+          release-to-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
+          aws-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
 
   build-macos-artifacts:
     name: Build macOS artifacts
@@ -221,14 +228,12 @@ jobs:
             arch: x86_64-apple-darwin
             artifacts-dir-prefix: greptime-darwin-amd64-pyo3
     runs-on: ${{ matrix.os }}
-    outputs:
-      build-macos-result: ${{ steps.set-build-macos-result.outputs.build-macos-result }}
     needs: [
       allocate-runners,
     ]
     if: ${{ inputs.build_macos_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -240,55 +245,11 @@ jobs:
           features: ${{ matrix.features }}
           version: ${{ needs.allocate-runners.outputs.version }}
           disable-run-tests: ${{ env.DISABLE_RUN_TESTS }}
+          release-to-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
           artifacts-dir: ${{ matrix.artifacts-dir-prefix }}-${{ needs.allocate-runners.outputs.version }}
-
-      - name: Set build macos result
-        id: set-build-macos-result
-        run: |
-          echo "build-macos-result=success" >> $GITHUB_OUTPUT    
-
-  build-windows-artifacts:
-    name: Build Windows artifacts
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ${{ needs.allocate-runners.outputs.windows-runner }}
-            arch: x86_64-pc-windows-msvc
-            features: servers/dashboard
-            artifacts-dir-prefix: greptime-windows-amd64
-          - os: ${{ needs.allocate-runners.outputs.windows-runner }}
-            arch: x86_64-pc-windows-msvc
-            features: pyo3_backend,servers/dashboard
-            artifacts-dir-prefix: greptime-windows-amd64-pyo3
-    runs-on: ${{ matrix.os }}
-    outputs:
-      build-windows-result: ${{ steps.set-build-windows-result.outputs.build-windows-result }}
-    needs: [
-      allocate-runners,
-    ]
-    if: ${{ inputs.build_windows_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
-    steps:
-      - run: git config --global core.autocrlf false
-
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - uses: ./.github/actions/build-windows-artifacts
-        with:
-          arch: ${{ matrix.arch }}
-          rust-toolchain: ${{ env.RUST_TOOLCHAIN }}
-          cargo-profile: ${{ env.CARGO_PROFILE }}
-          features: ${{ matrix.features }}
-          version: ${{ needs.allocate-runners.outputs.version }}
-          disable-run-tests: ${{ env.DISABLE_RUN_TESTS }}
-          artifacts-dir: ${{ matrix.artifacts-dir-prefix }}-${{ needs.allocate-runners.outputs.version }}
-
-      - name: Set build windows result
-        id: set-build-windows-result
-        run: |
-          echo "build-windows-result=success" >> $Env:GITHUB_OUTPUT
+          aws-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
 
   release-images-to-dockerhub:
     name: Build and push images to DockerHub
@@ -299,10 +260,8 @@ jobs:
       build-linux-arm64-artifacts,
     ]
     runs-on: ubuntu-2004-16-cores
-    outputs:
-      build-image-result: ${{ steps.set-build-image-result.outputs.build-image-result }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -315,73 +274,73 @@ jobs:
           image-registry-password: ${{ secrets.DOCKERHUB_TOKEN }}
           version: ${{ needs.allocate-runners.outputs.version }}
 
-      - name: Set build image result
-        id: set-build-image-result
-        run: |
-          echo "build-image-result=success" >> $GITHUB_OUTPUT    
-
-  release-cn-artifacts:
-    name: Release artifacts to CN region
+  release-images-to-acr:
+    name: Build and push images to ACR
     if: ${{ inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
-    needs: [ # The job have to wait for all the artifacts are built.
+    needs: [
       allocate-runners,
       build-linux-amd64-artifacts,
       build-linux-arm64-artifacts,
-      build-macos-artifacts,
-      build-windows-artifacts,
-      release-images-to-dockerhub,
     ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-2004-16-cores
     # When we push to ACR, it's easy to fail due to some unknown network issues.
     # However, we don't want to fail the whole workflow because of this.
     # The ACR have daily sync with DockerHub, so don't worry about the image not being updated.
     continue-on-error: true
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
-      - name: Release artifacts to CN region
-        uses: ./.github/actions/release-cn-artifacts
+      - name: Build and push images to ACR
+        uses: ./.github/actions/build-images
         with:
-          src-image-registry: docker.io
-          src-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          src-image-name: greptimedb
-          dst-image-registry-username: ${{ secrets.ALICLOUD_USERNAME }}
-          dst-image-registry-password: ${{ secrets.ALICLOUD_PASSWORD }}
-          dst-image-registry: ${{ vars.ACR_IMAGE_REGISTRY }}
-          dst-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
+          image-registry: ${{ vars.ACR_IMAGE_REGISTRY }}
+          image-namespace: ${{ vars.IMAGE_NAMESPACE }}
+          image-registry-username: ${{ secrets.ALICLOUD_USERNAME }}
+          image-registry-password: ${{ secrets.ALICLOUD_PASSWORD }}
           version: ${{ needs.allocate-runners.outputs.version }}
-          aws-cn-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
-          aws-cn-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
-          aws-cn-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
-          aws-cn-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
-          dev-mode: false
-          update-version-info: true
-          push-latest-tag: true
 
-  publish-github-release:
+  release-artifacts:
     name: Create GitHub release and upload artifacts
-    if: ${{ inputs.publish_github_release || github.event_name == 'push' || github.event_name == 'schedule' }}
-    needs: [ # The job have to wait for all the artifacts are built.
+    if: ${{ inputs.release_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
+    needs: [
       allocate-runners,
       build-linux-amd64-artifacts,
       build-linux-arm64-artifacts,
       build-macos-artifacts,
-      build-windows-artifacts,
       release-images-to-dockerhub,
     ]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
-      - name: Publish GitHub release
-        uses: ./.github/actions/publish-github-release
+      - name: Release artifacts
+        uses: ./.github/actions/release-artifacts
         with:
           version: ${{ needs.allocate-runners.outputs.version }}
 
+  release-dev-builder-image:
+    name: Release dev builder image
+    if: ${{ inputs.release_dev_builder_image }} # Only manually trigger this job.
+    runs-on: ubuntu-latest-16-cores
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Build and push dev builder image
+        uses: ./.github/actions/build-dev-builder-image
+        with:
+          dockerhub-image-registry-username: ${{ secrets.DOCKERHUB_USERNAME }}
+          dockerhub-image-registry-token: ${{ secrets.DOCKERHUB_TOKEN }}
+          acr-image-registry: ${{ vars.ACR_IMAGE_REGISTRY }}
+          acr-image-registry-username: ${{ secrets.ALICLOUD_USERNAME }}
+          acr-image-registry-password: ${{ secrets.ALICLOUD_PASSWORD }}
+
   ### Stop runners ###
   # It's very necessary to split the job of releasing runners into 'stop-linux-amd64-runner' and 'stop-linux-arm64-runner'.
   # Because we can terminate the specified EC2 instance immediately after the job is finished without uncessary waiting.
@@ -389,14 +348,14 @@ jobs:
     name: Stop linux-amd64 runner
     # Only run this job when the runner is allocated.
     if: ${{ always() }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: [
       allocate-runners,
       build-linux-amd64-artifacts,
     ]
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -414,14 +373,14 @@ jobs:
     name: Stop linux-arm64 runner
     # Only run this job when the runner is allocated.
     if: ${{ always() }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: [
       allocate-runners,
       build-linux-arm64-artifacts,
     ]
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
@@ -434,29 +393,3 @@ jobs:
           aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
           aws-region: ${{ vars.EC2_RUNNER_REGION }}
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
-
-  notification:
-    if: ${{ always() }} # Not requiring successful dependent jobs, always run.
-    name: Send notification to Greptime team
-    needs: [
-      release-images-to-dockerhub,
-      build-macos-artifacts,
-      build-windows-artifacts,
-    ]
-    runs-on: ubuntu-20.04
-    env:
-      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_DEVELOP_CHANNEL }}
-    steps:
-      - name: Notifiy release successful result
-        uses: slackapi/slack-github-action@v1.25.0
-        if: ${{ needs.release-images-to-dockerhub.outputs.build-image-result == 'success' && needs.build-windows-artifacts.outputs.build-windows-result == 'success' && needs.build-macos-artifacts.outputs.build-macos-result == 'success' }}
-        with:
-          payload: |
-            {"text": "GreptimeDB's release version has completed successfully."}
-
-      - name: Notifiy release failed result
-        uses: slackapi/slack-github-action@v1.25.0
-        if: ${{ needs.release-images-to-dockerhub.outputs.build-image-result != 'success' || needs.build-windows-artifacts.outputs.build-windows-result != 'success' || needs.build-macos-artifacts.outputs.build-macos-result != 'success' }}
-        with:
-          payload: |
-            {"text": "GreptimeDB's release version has failed, please check 'https://github.com/GreptimeTeam/greptimedb/actions/workflows/release.yml'."}

.licenserc.yaml

@@ -0,0 +1,14 @@
+header:
+  license:
+    spdx-id: Apache-2.0
+    copyright-owner: Greptime Team
+
+  paths:
+    - "**/*.rs"
+    - "**/*.py"
+
+  comment: on-failure
+
+dependency:
+  files:
+    - Cargo.toml

CONTRIBUTING.md

@@ -2,7 +2,7 @@
 
 Thanks a lot for considering contributing to GreptimeDB. We believe people like you would make GreptimeDB a great product. We intend to build a community where individuals can have open talks, show respect for one another, and speak with true ❤️. Meanwhile, we are to keep transparency and make your effort count here.
 
-Please read the guidelines, and they can help you get started. Communicate with respect to developers maintaining and developing the project. In return, they should reciprocate that respect by addressing your issue, reviewing changes, as well as helping finalize and merge your pull requests.
+Read the guidelines, and they can help you get started. Communicate with respect to developers maintaining and developing the project. In return, they should reciprocate that respect by addressing your issue, reviewing changes, as well as helping finalize and merge your pull requests.
 
 Follow our [README](https://github.com/GreptimeTeam/greptimedb#readme) to get the whole picture of the project. To learn about the design of GreptimeDB, please refer to the [design docs](https://github.com/GrepTimeTeam/docs).
 
@@ -10,7 +10,7 @@ Follow our [README](https://github.com/GreptimeTeam/greptimedb#readme) to get th
 
 It can feel intimidating to contribute to a complex project, but it can also be exciting and fun. These general notes will help everyone participate in this communal activity.
 
-- Follow the [Code of Conduct](https://github.com/GreptimeTeam/greptimedb/blob/main/CODE_OF_CONDUCT.md)
+- Follow the [Code of Conduct](https://github.com/GreptimeTeam/greptimedb/blob/develop/CODE_OF_CONDUCT.md)
 - Small changes make huge differences. We will happily accept a PR making a single character change if it helps move forward. Don't wait to have everything working.
 - Check the closed issues before opening your issue.
 - Try to follow the existing style of the code.
@@ -21,12 +21,12 @@ Pull requests are great, but we accept all kinds of other help if you like. Such
 - Write tutorials or blog posts. Blog, speak about, or create tutorials about one of GreptimeDB's many features. Mention [@greptime](https://twitter.com/greptime) on Twitter and email info@greptime.com so we can give pointers and tips and help you spread the word by promoting your content on Greptime communication channels.
 - Improve the documentation. [Submit documentation](http://github.com/greptimeTeam/docs/) updates, enhancements, designs, or bug fixes, and fixing any spelling or grammar errors will be very much appreciated.
 - Present at meetups and conferences about your GreptimeDB projects. Your unique challenges and successes in building things with GreptimeDB can provide great speaking material. We'd love to review your talk abstract, so get in touch with us if you'd like some help!
-- Submitting bug reports. To report a bug or a security issue, you can [open a new GitHub issue](https://github.com/GrepTimeTeam/greptimedb/issues/new).
+- Submit bug reports. To report a bug or a security issue, you can [open a new GitHub issue](https://github.com/GrepTimeTeam/greptimedb/issues/new).
 - Speak up feature requests. Send feedback is a great way for us to understand your different use cases of GreptimeDB better. If you want to share your experience with GreptimeDB, or if you want to discuss any ideas, you can start a discussion on [GitHub discussions](https://github.com/GreptimeTeam/greptimedb/discussions), chat with the Greptime team on [Slack](https://greptime.com/slack), or you can tweet [@greptime](https://twitter.com/greptime) on Twitter.
 
 ## Code of Conduct
 
-Also, there are things that we are not looking for because they don't match the goals of the product or benefit the community. Please read [Code of Conduct](https://github.com/GreptimeTeam/greptimedb/blob/main/CODE_OF_CONDUCT.md); we hope everyone can keep good manners and become an honored member.
+Also, there are things that we are not looking for because they don't match the goals of the product or benefit the community. Please read [Code of Conduct](https://github.com/GreptimeTeam/greptimedb/blob/develop/CODE_OF_CONDUCT.md); we hope everyone can keep good manners and become an honored member.
 
 ## License
 
@@ -49,7 +49,6 @@ GreptimeDB uses the [Apache 2.0 license](https://github.com/GreptimeTeam/greptim
 ### Before PR
 
 - To ensure that community is free and confident in its ability to use your contributions, please sign the Contributor License Agreement (CLA) which will be incorporated in the pull request process.
-- Make sure all files have proper license header (running `docker run --rm -v $(pwd):/github/workspace ghcr.io/korandoru/hawkeye-native:v3 format` from the project root).
 - Make sure all your codes are formatted and follow the [coding style](https://pingcap.github.io/style-guide/rust/).
 - Make sure all unit tests are passed (using `cargo test --workspace` or [nextest](https://nexte.st/index.html) `cargo nextest run`).
 - Make sure all clippy warnings are fixed (you can check it locally by running `cargo clippy --workspace --all-targets -- -D warnings`).
@@ -82,7 +81,7 @@ Now, `pre-commit` will run automatically on `git commit`.
 ### Title
 
 The titles of pull requests should be prefixed with category names listed in [Conventional Commits specification](https://www.conventionalcommits.org/en/v1.0.0)
-like `feat`/`fix`/`docs`, with a concise summary of code change following. AVOID using the last commit message as pull request title.
+like `feat`/`fix`/`docs`, with a concise summary of code change following. DO NOT use last commit message as pull request title.
 
 ### Description
 
@@ -101,7 +100,7 @@ of what you were trying to do and what went wrong. You can also reach for help i
 
 ## Community
 
-The core team will be thrilled if you would like to participate in any way you like. When you are stuck, try to ask for help by filing an issue, with a detailed description of what you were trying to do and what went wrong. If you have any questions or if you would like to get involved in our community, please check out:
+The core team will be thrilled if you participate in any way you like. When you are stuck, try ask for help by filing an issue, with a detailed description of what you were trying to do and what went wrong. If you have any questions or if you would like to get involved in our community, please check out:
 
 - [GreptimeDB Community Slack](https://greptime.com/slack)
 - [GreptimeDB Github Discussions](https://github.com/GreptimeTeam/greptimedb/discussions)

Cargo.toml

@@ -8,17 +8,15 @@ members = [
     "src/cmd",
     "src/common/base",
     "src/common/catalog",
-    "src/common/config",
     "src/common/datasource",
     "src/common/error",
     "src/common/function",
-    "src/common/macro",
+    "src/common/function-macro",
     "src/common/greptimedb-telemetry",
     "src/common/grpc",
     "src/common/grpc-expr",
     "src/common/mem-prof",
     "src/common/meta",
-    "src/common/plugins",
     "src/common/procedure",
     "src/common/procedure-test",
     "src/common/query",
@@ -28,130 +26,84 @@ members = [
     "src/common/telemetry",
     "src/common/test-util",
     "src/common/time",
-    "src/common/decimal",
     "src/common/version",
-    "src/common/wal",
     "src/datanode",
     "src/datatypes",
-    "src/file-engine",
-    "src/flow",
+    "src/file-table-engine",
     "src/frontend",
     "src/log-store",
     "src/meta-client",
     "src/meta-srv",
-    "src/metric-engine",
+    "src/mito",
     "src/mito2",
     "src/object-store",
-    "src/operator",
     "src/partition",
-    "src/plugins",
     "src/promql",
-    "src/puffin",
     "src/query",
     "src/script",
     "src/servers",
     "src/session",
     "src/sql",
+    "src/storage",
     "src/store-api",
+    "src/flow",
     "src/table",
-    "src/index",
-    "tests-fuzz",
+    "src/table-procedure",
     "tests-integration",
     "tests/runner",
 ]
 resolver = "2"
 
 [workspace.package]
-version = "0.7.0"
+version = "0.4.0-nightly"
 edition = "2021"
 license = "Apache-2.0"
 
-[workspace.lints]
-clippy.print_stdout = "warn"
-clippy.print_stderr = "warn"
-clippy.implicit_clone = "warn"
-rust.unknown_lints = "deny"
-
 [workspace.dependencies]
-ahash = { version = "0.8", features = ["compile-time-rng"] }
-aquamarine = "0.3"
-arrow = { version = "47.0" }
-arrow-array = "47.0"
-arrow-flight = "47.0"
-arrow-ipc = { version = "47.0", features = ["lz4"] }
-arrow-schema = { version = "47.0", features = ["serde"] }
+arrow = { version = "43.0" }
+etcd-client = "0.11"
+arrow-array = "43.0"
+arrow-flight = "43.0"
+arrow-schema = { version = "43.0", features = ["serde"] }
 async-stream = "0.3"
 async-trait = "0.1"
-axum = { version = "0.6", features = ["headers"] }
-base64 = "0.21"
-bigdecimal = "0.4.2"
-bitflags = "2.4.1"
-bytemuck = "1.12"
-bytes = { version = "1.5", features = ["serde"] }
 chrono = { version = "0.4", features = ["serde"] }
-clap = { version = "4.4", features = ["derive"] }
-dashmap = "5.4"
-datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
-datafusion-common = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
-datafusion-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
-datafusion-optimizer = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
-datafusion-physical-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
-datafusion-sql = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
-datafusion-substrait = { git = "https://github.com/apache/arrow-datafusion.git", rev = "26e43acac3a96cec8dd4c8365f22dfb1a84306e9" }
+datafusion = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "c0b0fca548e99d020c76e1a1cd7132aab26000e1" }
+datafusion-common = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "c0b0fca548e99d020c76e1a1cd7132aab26000e1" }
+datafusion-expr = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "c0b0fca548e99d020c76e1a1cd7132aab26000e1" }
+datafusion-optimizer = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "c0b0fca548e99d020c76e1a1cd7132aab26000e1" }
+datafusion-physical-expr = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "c0b0fca548e99d020c76e1a1cd7132aab26000e1" }
+datafusion-sql = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "c0b0fca548e99d020c76e1a1cd7132aab26000e1" }
+datafusion-substrait = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "c0b0fca548e99d020c76e1a1cd7132aab26000e1" }
 derive_builder = "0.12"
-etcd-client = "0.12"
-fst = "0.4.7"
 futures = "0.3"
 futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "96f1f0404f421ee560a4310c73c5071e49168168" }
+greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "4a277f27caa035a801d5b9c020a0449777736614" }
 humantime-serde = "1.1"
 itertools = "0.10"
 lazy_static = "1.4"
-meter-core = { git = "https://github.com/GreptimeTeam/greptime-meter.git", rev = "80b72716dcde47ec4161478416a5c6c21343364d" }
-mockall = "0.11.4"
-moka = "0.12"
-num_cpus = "1.16"
 once_cell = "1.18"
-opentelemetry-proto = { git = "https://github.com/waynexia/opentelemetry-rust.git", rev = "33841b38dda79b15f2024952be5f32533325ca02", features = [
-    "gen-tonic",
-    "metrics",
-    "trace",
-] }
-parquet = "47.0"
+opentelemetry-proto = { version = "0.2", features = ["gen-tonic", "metrics"] }
+parquet = "43.0"
 paste = "1.0"
-pin-project = "1.0"
-prometheus = { version = "0.13.3", features = ["process"] }
-prost = "0.12"
-raft-engine = { version = "0.4.1", default-features = false }
+prost = "0.11"
 rand = "0.8"
 regex = "1.8"
-regex-automata = { version = "0.2", features = ["transducer"] }
-reqwest = { version = "0.11", default-features = false, features = [
-    "json",
-    "rustls-tls-native-roots",
-    "stream",
-] }
-rskafka = "0.5"
-rust_decimal = "1.33"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-serde_with = "3"
-smallvec = { version = "1", features = ["serde"] }
-snafu = "0.7"
-sysinfo = "0.30"
-# on branch v0.38.x
-sqlparser = { git = "https://github.com/GreptimeTeam/sqlparser-rs.git", rev = "6a93567ae38d42be5c8d08b13c8ff4dde26502ef", features = [
+snafu = { version = "0.7", features = ["backtraces"] }
+sqlparser = { git = "https://github.com/GreptimeTeam/sqlparser-rs.git", rev = "296a4f6c73b129d6f565a42a2e5e53c6bc2b9da4", features = [
     "visitor",
 ] }
 strum = { version = "0.25", features = ["derive"] }
 tempfile = "3"
 tokio = { version = "1.28", features = ["full"] }
-tokio-stream = { version = "0.1" }
 tokio-util = { version = "0.7", features = ["io-util", "compat"] }
-toml = "0.8.8"
-tonic = { version = "0.10", features = ["tls"] }
+toml = "0.7"
+tonic = { version = "0.9", features = ["tls"] }
 uuid = { version = "1", features = ["serde", "v4", "fast-rng"] }
-
+metrics = "0.20"
+meter-core = { git = "https://github.com/GreptimeTeam/greptime-meter.git", rev = "abbd357c1e193cd270ea65ee7652334a150b628f" }
 ## workspaces members
 api = { path = "src/api" }
 auth = { path = "src/auth" }
@@ -160,59 +112,54 @@ client = { path = "src/client" }
 cmd = { path = "src/cmd" }
 common-base = { path = "src/common/base" }
 common-catalog = { path = "src/common/catalog" }
-common-config = { path = "src/common/config" }
 common-datasource = { path = "src/common/datasource" }
-common-decimal = { path = "src/common/decimal" }
 common-error = { path = "src/common/error" }
 common-function = { path = "src/common/function" }
+common-function-macro = { path = "src/common/function-macro" }
 common-greptimedb-telemetry = { path = "src/common/greptimedb-telemetry" }
 common-grpc = { path = "src/common/grpc" }
 common-grpc-expr = { path = "src/common/grpc-expr" }
-common-macro = { path = "src/common/macro" }
 common-mem-prof = { path = "src/common/mem-prof" }
 common-meta = { path = "src/common/meta" }
-common-plugins = { path = "src/common/plugins" }
 common-procedure = { path = "src/common/procedure" }
 common-procedure-test = { path = "src/common/procedure-test" }
+common-pprof = { path = "src/common/pprof" }
 common-query = { path = "src/common/query" }
 common-recordbatch = { path = "src/common/recordbatch" }
 common-runtime = { path = "src/common/runtime" }
+substrait = { path = "src/common/substrait" }
 common-telemetry = { path = "src/common/telemetry" }
 common-test-util = { path = "src/common/test-util" }
 common-time = { path = "src/common/time" }
 common-version = { path = "src/common/version" }
-common-wal = { path = "src/common/wal" }
 datanode = { path = "src/datanode" }
 datatypes = { path = "src/datatypes" }
-file-engine = { path = "src/file-engine" }
+file-table-engine = { path = "src/file-table-engine" }
 frontend = { path = "src/frontend" }
-index = { path = "src/index" }
 log-store = { path = "src/log-store" }
 meta-client = { path = "src/meta-client" }
 meta-srv = { path = "src/meta-srv" }
-metric-engine = { path = "src/metric-engine" }
+mito = { path = "src/mito" }
 mito2 = { path = "src/mito2" }
 object-store = { path = "src/object-store" }
-operator = { path = "src/operator" }
 partition = { path = "src/partition" }
-plugins = { path = "src/plugins" }
 promql = { path = "src/promql" }
-puffin = { path = "src/puffin" }
 query = { path = "src/query" }
 script = { path = "src/script" }
 servers = { path = "src/servers" }
 session = { path = "src/session" }
 sql = { path = "src/sql" }
+storage = { path = "src/storage" }
 store-api = { path = "src/store-api" }
-substrait = { path = "src/common/substrait" }
 table = { path = "src/table" }
+table-procedure = { path = "src/table-procedure" }
 
 [workspace.dependencies.meter-macros]
 git = "https://github.com/GreptimeTeam/greptime-meter.git"
-rev = "80b72716dcde47ec4161478416a5c6c21343364d"
+rev = "abbd357c1e193cd270ea65ee7652334a150b628f"
 
 [profile.release]
-debug = 1
+debug = true
 
 [profile.nightly]
 inherits = "release"

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2022 Greptime Team
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

Makefile

@@ -55,50 +55,23 @@ else
 	BUILDX_MULTI_PLATFORM_BUILD_OPTS := -o type=docker
 endif
 
-ifneq ($(strip $(CARGO_BUILD_EXTRA_OPTS)),)
-	CARGO_BUILD_OPTS += ${CARGO_BUILD_EXTRA_OPTS}
-endif
-
 ##@ Build
 
 .PHONY: build
 build: ## Build debug version greptime.
-	cargo ${CARGO_EXTENSION} build ${CARGO_BUILD_OPTS}
+	cargo build ${CARGO_BUILD_OPTS}
 
-.PHONY: build-by-dev-builder
+.POHNY: build-by-dev-builder
 build-by-dev-builder: ## Build greptime by dev-builder.
 	docker run --network=host \
 	-v ${PWD}:/greptimedb -v ${CARGO_REGISTRY_CACHE}:/root/.cargo/registry \
 	-w /greptimedb ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/dev-builder-${BASE_IMAGE}:latest \
 	make build \
-	CARGO_EXTENSION="${CARGO_EXTENSION}" \
 	CARGO_PROFILE=${CARGO_PROFILE} \
 	FEATURES=${FEATURES} \
 	TARGET_DIR=${TARGET_DIR} \
 	TARGET=${TARGET} \
-	RELEASE=${RELEASE} \
-	CARGO_BUILD_EXTRA_OPTS="${CARGO_BUILD_EXTRA_OPTS}"
-
-.PHONY: build-android-bin
-build-android-bin: ## Build greptime binary for android.
-	docker run --network=host \
-	-v ${PWD}:/greptimedb -v ${CARGO_REGISTRY_CACHE}:/root/.cargo/registry \
-	-w /greptimedb ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/dev-builder-android:latest \
-	make build \
-	CARGO_EXTENSION="ndk --platform 23 -t aarch64-linux-android" \
-	CARGO_PROFILE=release \
-	FEATURES="${FEATURES}" \
-	TARGET_DIR="${TARGET_DIR}" \
-	TARGET="${TARGET}" \
-	RELEASE="${RELEASE}" \
-	CARGO_BUILD_EXTRA_OPTS="--bin greptime --no-default-features"
-
-.PHONY: strip-android-bin
-strip-android-bin: build-android-bin ## Strip greptime binary for android.
-	docker run --network=host \
-	-v ${PWD}:/greptimedb \
-	-w /greptimedb ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/dev-builder-android:latest \
-	bash -c '$${NDK_ROOT}/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-strip /greptimedb/target/aarch64-linux-android/release/greptime'
+	RELEASE=${RELEASE}
 
 .PHONY: clean
 clean: ## Clean the project.
@@ -144,12 +117,11 @@ multi-platform-buildx: ## Create buildx multi-platform builder.
 	docker buildx inspect ${BUILDX_BUILDER_NAME} || docker buildx create --name ${BUILDX_BUILDER_NAME} --driver docker-container --bootstrap --use
 
 ##@ Test
-.PHONY: test
 test: nextest ## Run unit and integration tests.
 	cargo nextest run ${NEXTEST_OPTS}
 
-.PHONY: nextest
-nextest: ## Install nextest tools.
+.PHONY: nextest ## Install nextest tools.
+nextest:
 	cargo --list | grep nextest || cargo install cargo-nextest --locked
 
 .PHONY: sqlness-test
@@ -158,11 +130,11 @@ sqlness-test: ## Run sqlness test.
 
 .PHONY: check
 check: ## Cargo check all the targets.
-	cargo check --workspace --all-targets --all-features
+	cargo check --workspace --all-targets
 
 .PHONY: clippy
 clippy: ## Check clippy rules.
-	cargo clippy --workspace --all-targets --all-features -- -D warnings
+	cargo clippy --workspace --all-targets -F pyo3_backend -- -D warnings
 
 .PHONY: fmt-check
 fmt-check: ## Check code format.

README.md

@@ -1,8 +1,8 @@
 <p align="center">
   <picture>
-    <source media="(prefers-color-scheme: light)" srcset="https://cdn.jsdelivr.net/gh/GreptimeTeam/greptimedb@main/docs/logo-text-padding.png">
-    <source media="(prefers-color-scheme: dark)" srcset="https://cdn.jsdelivr.net/gh/GreptimeTeam/greptimedb@main/docs/logo-text-padding-dark.png">
-    <img alt="GreptimeDB Logo" src="https://cdn.jsdelivr.net/gh/GreptimeTeam/greptimedb@main/docs/logo-text-padding.png" width="400px">
+    <source media="(prefers-color-scheme: light)" srcset="https://cdn.jsdelivr.net/gh/GreptimeTeam/greptimedb@develop/docs/logo-text-padding.png">
+    <source media="(prefers-color-scheme: dark)" srcset="https://cdn.jsdelivr.net/gh/GreptimeTeam/greptimedb@develop/docs/logo-text-padding-dark.png">
+    <img alt="GreptimeDB Logo" src="https://cdn.jsdelivr.net/gh/GreptimeTeam/greptimedb@develop/docs/logo-text-padding.png" width="400px">
   </picture>
 </p>
 
@@ -12,11 +12,11 @@
 </h3>
 
 <p align="center">
-    <a href="https://codecov.io/gh/GrepTimeTeam/greptimedb"><img src="https://codecov.io/gh/GrepTimeTeam/greptimedb/branch/main/graph/badge.svg?token=FITFDI3J3C"></img></a>
+    <a href="https://codecov.io/gh/GrepTimeTeam/greptimedb"><img src="https://codecov.io/gh/GrepTimeTeam/greptimedb/branch/develop/graph/badge.svg?token=FITFDI3J3C"></img></a>
     &nbsp;
     <a href="https://github.com/GreptimeTeam/greptimedb/actions/workflows/develop.yml"><img src="https://github.com/GreptimeTeam/greptimedb/actions/workflows/develop.yml/badge.svg" alt="CI"></img></a>
     &nbsp;
-    <a href="https://github.com/greptimeTeam/greptimedb/blob/main/LICENSE"><img src="https://img.shields.io/github/license/greptimeTeam/greptimedb"></a>
+    <a href="https://github.com/greptimeTeam/greptimedb/blob/develop/LICENSE"><img src="https://img.shields.io/github/license/greptimeTeam/greptimedb"></a>
 </p>
 
 <p align="center">
@@ -29,17 +29,21 @@
 
 ## What is GreptimeDB
 
-GreptimeDB is an open-source time-series database focusing on efficiency, scalability, and analytical capabilities.
-It's designed to work on infrastructure of the cloud era, and users benefit from its elasticity and commodity storage.
+GreptimeDB is an open-source time-series database with a special focus on
+scalability, analytical capabilities and efficiency. It's designed to work on
+infrastructure of the cloud era, and users benefit from its elasticity and commodity
+storage.
 
-Our core developers have been building time-series data platforms for years. Based on their best-practices, GreptimeDB is born to give you:
+Our core developers have been building time-series data platform
+for years. Based on their best-practices, GreptimeDB is born to give you:
 
-- Optimized columnar layout for handling time-series data; compacted, compressed, and stored on various storage backends, particularly cloud object storage with 50x cost efficiency.
-- Fully open-source distributed cluster architecture that harnesses the power of cloud-native elastic computing resources.
-- Seamless scalability from a standalone binary at edge to a robust, highly available distributed cluster in cloud, with a transparent experience for both developers and administrators.
-- Native SQL and PromQL for queries, and Python scripting to facilitate complex analytical tasks.
-- Flexible indexing capabilities and distributed, parallel-processing query engine, tackling high cardinality issues down.
-- Widely adopted database protocols and APIs, including MySQL, PostgreSQL, and Prometheus Remote Storage, etc.
+- A standalone binary that scales to highly-available distributed cluster, providing a transparent experience for cluster users
+- Optimized columnar layout for handling time-series data; compacted, compressed, and stored on various storage backends
+- Flexible indexes, tackling high cardinality issues down
+- Distributed, parallel query execution, leveraging elastic computing resource
+- Native SQL, and Python scripting for advanced analytical scenarios
+- Widely adopted database protocols and APIs, native PromQL supports
+- Extensible table engine architecture for extensive workloads
 
 ## Quick Start
 
@@ -92,11 +96,11 @@ Or if you built from docker:
 docker run -p 4002:4002 -v "$(pwd):/tmp/greptimedb" greptime/greptimedb standalone start
 ```
 
-Please see the online document site for more installation options and [operations info](https://docs.greptime.com/user-guide/operations/overview).
+Please see [the online document site](https://docs.greptime.com/getting-started/overview#install-greptimedb) for more installation options and [operations info](https://docs.greptime.com/user-guide/operations/overview).
 
 ### Get started
 
-Read the [complete getting started guide](https://docs.greptime.com/getting-started/overview) on our [official document site](https://docs.greptime.com/).
+Read the [complete getting started guide](https://docs.greptime.com/getting-started/overview#connect) on our [official document site](https://docs.greptime.com/).
 
 To write and query data, GreptimeDB is compatible with multiple [protocols and clients](https://docs.greptime.com/user-guide/clients/overview).
 
@@ -105,7 +109,7 @@ To write and query data, GreptimeDB is compatible with multiple [protocols and c
 ### Installation
 
 - [Pre-built Binaries](https://greptime.com/download):
-  For Linux and macOS, you can easily download pre-built binaries including official releases and nightly builds that are ready to use.
+  For Linux and macOS, you can easily download pre-built binaries including official releases and nightly builds that are ready to use. 
   In most cases, downloading the version without PyO3 is sufficient. However, if you plan to run scripts in CPython (and use Python packages like NumPy and Pandas), you will need to download the version with PyO3 and install a Python with the same version as the Python in the PyO3 version.
   We recommend using virtualenv for the installation process to manage multiple Python versions.
 - [Docker Images](https://hub.docker.com/r/greptime/greptimedb)(**recommended**): pre-built
@@ -127,15 +131,10 @@ To write and query data, GreptimeDB is compatible with multiple [protocols and c
 
 - [GreptimeDB C++ Client](https://github.com/GreptimeTeam/greptimedb-client-cpp)
 - [GreptimeDB Erlang Client](https://github.com/GreptimeTeam/greptimedb-client-erl)
-- [GreptimeDB Go Ingester](https://github.com/GreptimeTeam/greptimedb-ingester-go)
-- [GreptimeDB Java Ingester](https://github.com/GreptimeTeam/greptimedb-ingester-java)
+- [GreptimeDB Go Client](https://github.com/GreptimeTeam/greptimedb-client-go)
+- [GreptimeDB Java Client](https://github.com/GreptimeTeam/greptimedb-client-java)
 - [GreptimeDB Python Client](https://github.com/GreptimeTeam/greptimedb-client-py) (WIP)
 - [GreptimeDB Rust Client](https://github.com/GreptimeTeam/greptimedb-client-rust)
-- [GreptimeDB JavaScript Client](https://github.com/GreptimeTeam/greptime-js-sdk)
-
-### Grafana Dashboard
-
-Our official Grafana dashboard is available at [grafana](./grafana/README.md) directory.
 
 ## Project Status
 
@@ -165,17 +164,18 @@ In addition, you may:
 
 ## License
 
-GreptimeDB uses the [Apache License 2.0](https://apache.org/licenses/LICENSE-2.0.txt) to strike a balance between
+GreptimeDB uses the [Apache 2.0 license][1] to strike a balance between
 open contributions and allowing you to use the software however you want.
 
+[1]: <https://github.com/greptimeTeam/greptimedb/blob/develop/LICENSE>
+
 ## Contributing
 
 Please refer to [contribution guidelines](CONTRIBUTING.md) for more information.
 
 ## Acknowledgement
-
-- GreptimeDB uses [Apache Arrow™](https://arrow.apache.org/) as the memory model and [Apache Parquet™](https://parquet.apache.org/) as the persistent file format.
-- GreptimeDB's query engine is powered by [Apache Arrow DataFusion™](https://arrow.apache.org/datafusion/).
-- [Apache OpenDAL™](https://opendal.apache.org) gives GreptimeDB a very general and elegant data access abstraction layer.
-- GreptimeDB's meta service is based on [etcd](https://etcd.io/).
+- GreptimeDB uses [Apache Arrow](https://arrow.apache.org/) as the memory model and [Apache Parquet](https://parquet.apache.org/) as the persistent file format.
+- GreptimeDB's query engine is powered by [Apache Arrow DataFusion](https://github.com/apache/arrow-datafusion).
+- [OpenDAL](https://github.com/datafuselabs/opendal) from [Datafuse Labs](https://github.com/datafuselabs) gives GreptimeDB a very general and elegant data access abstraction layer.
+- GreptimeDB’s meta service is based on [etcd](https://etcd.io/).
 - GreptimeDB uses [RustPython](https://github.com/RustPython/RustPython) for experimental embedded python scripting.

benchmarks/Cargo.toml

@@ -4,15 +4,10 @@ version.workspace = true
 edition.workspace = true
 license.workspace = true
 
-[lints]
-workspace = true
-
 [dependencies]
 arrow.workspace = true
-chrono.workspace = true
-clap.workspace = true
-client.workspace = true
-futures-util.workspace = true
+clap = { version = "4.0", features = ["derive"] }
+client = { workspace = true }
 indicatif = "0.17.1"
 itertools.workspace = true
 parquet.workspace = true

benchmarks/src/bin/nyc-taxi.rs

@@ -27,16 +27,16 @@ use arrow::record_batch::RecordBatch;
 use clap::Parser;
 use client::api::v1::column::Values;
 use client::api::v1::{
-    Column, ColumnDataType, ColumnDef, CreateTableExpr, InsertRequest, InsertRequests, SemanticType,
+    Column, ColumnDataType, ColumnDef, CreateTableExpr, InsertRequest, InsertRequests,
 };
-use client::{Client, Database, Output, DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
-use futures_util::TryStreamExt;
+use client::{Client, Database, DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
 use tokio::task::JoinSet;
 
 const CATALOG_NAME: &str = "greptime";
 const SCHEMA_NAME: &str = "public";
+const TABLE_NAME: &str = "nyc_taxi";
 
 #[derive(Parser)]
 #[command(name = "NYC benchmark runner")]
@@ -74,12 +74,7 @@ fn get_file_list<P: AsRef<Path>>(path: P) -> Vec<PathBuf> {
         .collect()
 }
 
-fn new_table_name() -> String {
-    format!("nyc_taxi_{}", chrono::Utc::now().timestamp())
-}
-
 async fn write_data(
-    table_name: &str,
     batch_size: usize,
     db: &Database,
     path: PathBuf,
@@ -109,7 +104,8 @@ async fn write_data(
         }
         let (columns, row_count) = convert_record_batch(record_batch);
         let request = InsertRequest {
-            table_name: table_name.to_string(),
+            table_name: TABLE_NAME.to_string(),
+            region_number: 0,
             columns,
             row_count,
         };
@@ -118,7 +114,7 @@ async fn write_data(
         };
 
         let now = Instant::now();
-        db.insert(requests).await.unwrap();
+        let _ = db.insert(requests).await.unwrap();
         let elapsed = now.elapsed();
         total_rpc_elapsed_ms += elapsed.as_millis();
         progress_bar.inc(row_count as _);
@@ -136,11 +132,6 @@ fn convert_record_batch(record_batch: RecordBatch) -> (Vec<Column>, u32) {
 
     for (array, field) in record_batch.columns().iter().zip(fields.iter()) {
         let (values, datatype) = build_values(array);
-        let semantic_type = match field.name().as_str() {
-            "VendorID" => SemanticType::Tag,
-            "tpep_pickup_datetime" => SemanticType::Timestamp,
-            _ => SemanticType::Field,
-        };
 
         let column = Column {
             column_name: field.name().clone(),
@@ -151,7 +142,7 @@ fn convert_record_batch(record_batch: RecordBatch) -> (Vec<Column>, u32) {
                 .map(|bitmap| bitmap.buffer().as_slice().to_vec())
                 .unwrap_or_default(),
             datatype: datatype.into(),
-            semantic_type: semantic_type as i32,
+            // datatype and semantic_type are set to default
             ..Default::default()
         };
         columns.push(column);
@@ -198,7 +189,7 @@ fn build_values(column: &ArrayRef) -> (Values, ColumnDataType) {
             let values = array.values();
             (
                 Values {
-                    timestamp_microsecond_values: values.to_vec(),
+                    ts_microsecond_values: values.to_vec(),
                     ..Default::default()
                 },
                 ColumnDataType::TimestampMicrosecond,
@@ -253,212 +244,156 @@ fn is_record_batch_full(batch: &RecordBatch) -> bool {
     batch.columns().iter().all(|col| col.null_count() == 0)
 }
 
-fn create_table_expr(table_name: &str) -> CreateTableExpr {
+fn create_table_expr() -> CreateTableExpr {
     CreateTableExpr {
         catalog_name: CATALOG_NAME.to_string(),
         schema_name: SCHEMA_NAME.to_string(),
-        table_name: table_name.to_string(),
-        desc: String::default(),
+        table_name: TABLE_NAME.to_string(),
+        desc: "".to_string(),
         column_defs: vec![
             ColumnDef {
                 name: "VendorID".to_string(),
-                data_type: ColumnDataType::Int64 as i32,
+                datatype: ColumnDataType::Int64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Tag as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "tpep_pickup_datetime".to_string(),
-                data_type: ColumnDataType::TimestampMicrosecond as i32,
-                is_nullable: false,
+                datatype: ColumnDataType::TimestampMicrosecond as i32,
+                is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Timestamp as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "tpep_dropoff_datetime".to_string(),
-                data_type: ColumnDataType::TimestampMicrosecond as i32,
+                datatype: ColumnDataType::TimestampMicrosecond as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "passenger_count".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "trip_distance".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "RatecodeID".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "store_and_fwd_flag".to_string(),
-                data_type: ColumnDataType::String as i32,
+                datatype: ColumnDataType::String as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "PULocationID".to_string(),
-                data_type: ColumnDataType::Int64 as i32,
+                datatype: ColumnDataType::Int64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "DOLocationID".to_string(),
-                data_type: ColumnDataType::Int64 as i32,
+                datatype: ColumnDataType::Int64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "payment_type".to_string(),
-                data_type: ColumnDataType::Int64 as i32,
+                datatype: ColumnDataType::Int64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "fare_amount".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "extra".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "mta_tax".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "tip_amount".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "tolls_amount".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "improvement_surcharge".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "total_amount".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "congestion_surcharge".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
             ColumnDef {
                 name: "airport_fee".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
                 default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
             },
         ],
         time_index: "tpep_pickup_datetime".to_string(),
         primary_keys: vec!["VendorID".to_string()],
-        create_if_not_exists: true,
+        create_if_not_exists: false,
         table_options: Default::default(),
+        region_numbers: vec![0],
         table_id: None,
         engine: "mito".to_string(),
     }
 }
 
-fn query_set(table_name: &str) -> HashMap<String, String> {
+fn query_set() -> HashMap<String, String> {
     HashMap::from([
         (
             "count_all".to_string(), 
-            format!("SELECT COUNT(*) FROM {table_name};"),
+            format!("SELECT COUNT(*) FROM {TABLE_NAME};"),
         ),
         (
             "fare_amt_by_passenger".to_string(),
-            format!("SELECT passenger_count, MIN(fare_amount), MAX(fare_amount), SUM(fare_amount) FROM {table_name} GROUP BY passenger_count"),
+            format!("SELECT passenger_count, MIN(fare_amount), MAX(fare_amount), SUM(fare_amount) FROM {TABLE_NAME} GROUP BY passenger_count"),
         )
     ])
 }
 
-async fn do_write(args: &Args, db: &Database, table_name: &str) {
+async fn do_write(args: &Args, db: &Database) {
     let mut file_list = get_file_list(args.path.clone().expect("Specify data path in argument"));
     let mut write_jobs = JoinSet::new();
 
-    let create_table_result = db.create(create_table_expr(table_name)).await;
+    let create_table_result = db.create(create_table_expr()).await;
     println!("Create table result: {create_table_result:?}");
 
     let progress_bar_style = ProgressStyle::with_template(
@@ -476,10 +411,8 @@ async fn do_write(args: &Args, db: &Database, table_name: &str) {
             let db = db.clone();
             let mpb = multi_progress_bar.clone();
             let pb_style = progress_bar_style.clone();
-            let table_name = table_name.to_string();
-            let _ = write_jobs.spawn(async move {
-                write_data(&table_name, batch_size, &db, path, mpb, pb_style).await
-            });
+            let _ = write_jobs
+                .spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
         }
     }
     while write_jobs.join_next().await.is_some() {
@@ -488,32 +421,24 @@ async fn do_write(args: &Args, db: &Database, table_name: &str) {
             let db = db.clone();
             let mpb = multi_progress_bar.clone();
             let pb_style = progress_bar_style.clone();
-            let table_name = table_name.to_string();
-            let _ = write_jobs.spawn(async move {
-                write_data(&table_name, batch_size, &db, path, mpb, pb_style).await
-            });
+            let _ = write_jobs
+                .spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
         }
     }
 }
 
-async fn do_query(num_iter: usize, db: &Database, table_name: &str) {
-    for (query_name, query) in query_set(table_name) {
+async fn do_query(num_iter: usize, db: &Database) {
+    for (query_name, query) in query_set() {
         println!("Running query: {query}");
         for i in 0..num_iter {
             let now = Instant::now();
-            let res = db.sql(&query).await.unwrap();
-            match res {
-                Output::AffectedRows(_) | Output::RecordBatches(_) => (),
-                Output::Stream(stream, _) => {
-                    stream.try_collect::<Vec<_>>().await.unwrap();
-                }
-            }
+            let _res = db.sql(&query).await.unwrap();
             let elapsed = now.elapsed();
             println!(
                 "query {}, iteration {}: {}ms",
                 query_name,
                 i,
-                elapsed.as_millis(),
+                elapsed.as_millis()
             );
         }
     }
@@ -530,14 +455,13 @@ fn main() {
         .block_on(async {
             let client = Client::with_urls(vec![&args.endpoint]);
             let db = Database::new(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, client);
-            let table_name = new_table_name();
 
             if !args.skip_write {
-                do_write(&args, &db, &table_name).await;
+                do_write(&args, &db).await;
             }
 
             if !args.skip_read {
-                do_query(args.iter_num, &db, &table_name).await;
+                do_query(args.iter_num, &db).await;
             }
         })
 }

codecov.yml

@@ -8,6 +8,5 @@ coverage:
 ignore:
   - "**/error*.rs" # ignore all error.rs files
   - "tests/runner/*.rs" # ignore integration test runner
-  - "tests-integration/**/*.rs" # ignore integration tests
 comment:                  # this is a top-level key
   layout: "diff"

config/datanode.example.toml

@@ -1,5 +1,7 @@
 # Node running mode, see `standalone.example.toml`.
 mode = "distributed"
+# Whether to use in-memory catalog, see `standalone.example.toml`.
+enable_memory_catalog = false
 # The datanode identifier, should be unique.
 node_id = 42
 # gRPC server address, "127.0.0.1:3001" by default.
@@ -8,36 +10,25 @@ rpc_addr = "127.0.0.1:3001"
 rpc_hostname = "127.0.0.1"
 # The number of gRPC server worker threads, 8 by default.
 rpc_runtime_size = 8
-# Start services after regions have obtained leases.
-# It will block the datanode start if it can't receive leases in the heartbeat from metasrv.
-require_lease_before_startup = false
-
-# Initialize all regions in the background during the startup.
-# By default, it provides services after all regions have been initialized.
-init_regions_in_background = false
 
 [heartbeat]
-# Interval for sending heartbeat messages to the Metasrv, 3 seconds by default.
-interval = "3s"
+# Interval for sending heartbeat messages to the Metasrv in milliseconds, 5000 by default.
+interval_millis = 5000
 
 # Metasrv client options.
-[meta_client]
+[meta_client_options]
 # Metasrv address list.
 metasrv_addrs = ["127.0.0.1:3002"]
-# Heartbeat timeout, 500 milliseconds by default.
-heartbeat_timeout = "500ms"
-# Operation timeout, 3 seconds by default.
-timeout = "3s"
-# Connect server timeout, 1 second by default.
-connect_timeout = "1s"
+# Operation timeout in milliseconds, 3000 by default.
+timeout_millis = 3000
+# Connect server timeout in milliseconds, 5000 by default.
+connect_timeout_millis = 5000
 # `TCP_NODELAY` option for accepted connections, true by default.
 tcp_nodelay = true
 
-# WAL options.
+# WAL options, see `standalone.example.toml`.
 [wal]
-provider = "raft_engine"
-
-# Raft-engine wal options, see `standalone.example.toml`.
+# WAL data directory
 # dir = "/tmp/greptimedb/wal"
 file_size = "256MB"
 purge_threshold = "4GB"
@@ -45,127 +36,49 @@ purge_interval = "10m"
 read_batch_size = 128
 sync_write = false
 
-# Kafka wal options, see `standalone.example.toml`.
-# broker_endpoints = ["127.0.0.1:9092"]
-# Warning: Kafka has a default limit of 1MB per message in a topic.
-# max_batch_size = "1MB"
-# linger = "200ms"
-# consumer_wait_timeout = "100ms"
-# backoff_init = "500ms"
-# backoff_max = "10s"
-# backoff_base = 2
-# backoff_deadline = "5mins"
-
 # Storage options, see `standalone.example.toml`.
 [storage]
 # The working home directory.
 data_home = "/tmp/greptimedb/"
-# Storage type.
 type = "File"
 # TTL for all tables. Disabled by default.
 # global_ttl = "7d"
 
-# Cache configuration for object storage such as 'S3' etc.
-# The local file cache directory
-# cache_path = "/path/local_cache"
-# The local file cache capacity in bytes.
-# cache_capacity = "256MB"
+# Compaction options, see `standalone.example.toml`.
+[storage.compaction]
+max_inflight_tasks = 4
+max_files_in_level0 = 8
+max_purge_tasks = 32
 
-# Custom storage options
-#[[storage.providers]]
-#type = "S3"
-#[[storage.providers]]
-#type = "Gcs"
+# Storage manifest options
+[storage.manifest]
+# Region checkpoint actions margin.
+# Create a checkpoint every <checkpoint_margin> actions.
+checkpoint_margin = 10
+# Region manifest logs and checkpoints gc execution duration
+gc_duration = '10m'
 
-# Mito engine options
-[[region_engine]]
-[region_engine.mito]
-# Number of region workers
-num_workers = 8
-# Request channel size of each worker
-worker_channel_size = 128
-# Max batch size for a worker to handle requests
-worker_request_batch_size = 64
-# Number of meta action updated to trigger a new checkpoint for the manifest
-manifest_checkpoint_distance = 10
-# Whether to compress manifest and checkpoint file by gzip (default false).
-compress_manifest = false
-# Max number of running background jobs
-max_background_jobs = 4
+# Storage flush options
+[storage.flush]
+# Max inflight flush tasks.
+max_flush_tasks = 8
+# Default write buffer size for a region.
+region_write_buffer_size = "32MB"
+# Interval to check whether a region needs flush.
+picker_schedule_interval = "5m"
 # Interval to auto flush a region if it has not flushed yet.
 auto_flush_interval = "1h"
-# Global write buffer size for all regions. If not set, it's default to 1/8 of OS memory with a max limitation of 1GB.
+# Global write buffer size for all regions.
 global_write_buffer_size = "1GB"
-# Global write buffer size threshold to reject write requests. If not set, it's default to 2 times of `global_write_buffer_size`
-global_write_buffer_reject_size = "2GB"
-# Cache size for SST metadata. Setting it to 0 to disable the cache.
-# If not set, it's default to 1/32 of OS memory with a max limitation of 128MB.
-sst_meta_cache_size = "128MB"
-# Cache size for vectors and arrow arrays. Setting it to 0 to disable the cache.
-# If not set, it's default to 1/16 of OS memory with a max limitation of 512MB.
-vector_cache_size = "512MB"
-# Cache size for pages of SST row groups. Setting it to 0 to disable the cache.
-# If not set, it's default to 1/16 of OS memory with a max limitation of 512MB.
-page_cache_size = "512MB"
-# Buffer size for SST writing.
-sst_write_buffer_size = "8MB"
-# Parallelism to scan a region (default: 1/4 of cpu cores).
-# - 0: using the default value (1/4 of cpu cores).
-# - 1: scan in current thread.
-# - n: scan in parallelism n.
-scan_parallelism = 0
-# Capacity of the channel to send data from parallel scan tasks to the main task (default 32).
-parallel_scan_channel_size = 32
-# Whether to allow stale WAL entries read during replay.
-allow_stale_entries = false
 
-[region_engine.mito.inverted_index]
-# Whether to create the index on flush.
-# - "auto": automatically
-# - "disable": never
-create_on_flush = "auto"
-# Whether to create the index on compaction.
-# - "auto": automatically
-# - "disable": never
-create_on_compaction = "auto"
-# Whether to apply the index on query
-# - "auto": automatically
-# - "disable": never
-apply_on_query = "auto"
-# Memory threshold for performing an external sort during index creation.
-# Setting to empty will disable external sorting, forcing all sorting operations to happen in memory.
-mem_threshold_on_create = "64M"
-# File system path to store intermediate files for external sorting (default `{data_home}/index_intermediate`).
-intermediate_path = ""
+# Procedure storage options, see `standalone.example.toml`.
+[procedure]
+max_retry_times = 3
+retry_delay = "500ms"
 
-[region_engine.mito.memtable]
-# Memtable type.
-# - "experimental": experimental memtable
-# - "time_series": time-series memtable (deprecated)
-type = "experimental"
-# The max number of keys in one shard.
-index_max_keys_per_shard = 8192
-# The max rows of data inside the actively writing buffer in one shard.
-data_freeze_threshold = 32768
-# Max dictionary bytes.
-fork_dictionary_bytes = "1GiB"
-
-# Log options, see `standalone.example.toml`
+# Log options
 # [logging]
+# Specify logs directory.
 # dir = "/tmp/greptimedb/logs"
+# Specify the log level [info | debug | error | warn]
 # level = "info"
-
-# Datanode export the metrics generated by itself
-# encoded to Prometheus remote-write format
-# and send to Prometheus remote-write compatible receiver (e.g. send to `greptimedb` itself)
-# This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape.
-# [export_metrics]
-# whether enable export metrics, default is false
-# enable = false
-# The interval of export metrics
-# write_interval = "30s"
-# [export_metrics.remote_write]
-# The url the metrics send to. The url is empty by default, url example: `http://127.0.0.1:4000/v1/prometheus/write?db=information_schema`
-# url = ""
-# HTTP headers of Prometheus remote-write carry
-# headers = {}

config/frontend.example.toml

@@ -1,83 +1,66 @@
 # Node running mode, see `standalone.example.toml`.
 mode = "distributed"
-# The default timezone of the server
-# default_timezone = "UTC"
 
 [heartbeat]
-# Interval for sending heartbeat task to the Metasrv, 5 seconds by default.
-interval = "5s"
-# Interval for retry sending heartbeat task, 5 seconds by default.
-retry_interval = "5s"
+# Interval for sending heartbeat task to the Metasrv in milliseconds, 5000 by default.
+interval_millis = 5000
+# Interval for retry sending heartbeat task in milliseconds, 5000 by default.
+retry_interval_millis = 5000
 
 # HTTP server options, see `standalone.example.toml`.
-[http]
+[http_options]
 addr = "127.0.0.1:4000"
 timeout = "30s"
 body_limit = "64MB"
 
 # gRPC server options, see `standalone.example.toml`.
-[grpc]
+[grpc_options]
 addr = "127.0.0.1:4001"
 runtime_size = 8
 
 # MySQL server options, see `standalone.example.toml`.
-[mysql]
-enable = true
+[mysql_options]
 addr = "127.0.0.1:4002"
 runtime_size = 2
 
 # MySQL server TLS options, see `standalone.example.toml`.
-[mysql.tls]
+[mysql_options.tls]
 mode = "disable"
 cert_path = ""
 key_path = ""
-watch = false
 
 # PostgresSQL server options, see `standalone.example.toml`.
-[postgres]
-enable = true
+[postgres_options]
 addr = "127.0.0.1:4003"
 runtime_size = 2
 
 # PostgresSQL server TLS options, see `standalone.example.toml`.
-[postgres.tls]
+[postgres_options.tls]
 mode = "disable"
 cert_path = ""
 key_path = ""
-watch = false
 
 # OpenTSDB protocol options, see `standalone.example.toml`.
-[opentsdb]
-enable = true
+[opentsdb_options]
 addr = "127.0.0.1:4242"
 runtime_size = 2
 
 # InfluxDB protocol options, see `standalone.example.toml`.
-[influxdb]
+[influxdb_options]
 enable = true
 
 # Prometheus remote storage options, see `standalone.example.toml`.
-[prom_store]
+[prom_store_options]
 enable = true
-# Whether to store the data from Prometheus remote write in metric engine.
-# true by default
-with_metric_engine = true
 
 # Metasrv client options, see `datanode.example.toml`.
-[meta_client]
+[meta_client_options]
 metasrv_addrs = ["127.0.0.1:3002"]
-timeout = "3s"
+timeout_millis = 3000
 # DDL timeouts options.
-ddl_timeout = "10s"
-connect_timeout = "1s"
+ddl_timeout_millis = 10000
+connect_timeout_millis = 5000
 tcp_nodelay = true
-# The configuration about the cache of the Metadata.
-# default: 100000
-metadata_cache_max_capacity = 100000
-# default: 10m
-metadata_cache_ttl = "10m"
-# default: 5m
-metadata_cache_tti = "5m"
 
 # Log options, see `standalone.example.toml`
 # [logging]
@@ -91,16 +74,3 @@ metadata_cache_tti = "5m"
 timeout = "10s"
 connect_timeout = "10s"
 tcp_nodelay = true
-
-# Frontend export the metrics generated by itself
-# encoded to Prometheus remote-write format
-# and send to Prometheus remote-write compatible receiver (e.g. send to `greptimedb` itself)
-# This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape.
-# [export_metrics]
-# whether enable export metrics, default is false
-# enable = false
-# The interval of export metrics
-# write_interval = "30s"
-# for `frontend`, `self_import` is recommend to collect metrics generated by itself
-# [export_metrics.self_import]
-# db = "information_schema"

config/metasrv.example.toml

@@ -6,17 +6,17 @@ bind_addr = "127.0.0.1:3002"
 server_addr = "127.0.0.1:3002"
 # Etcd server address, "127.0.0.1:2379" by default.
 store_addr = "127.0.0.1:2379"
+# Datanode lease in seconds, 15 seconds by default.
+datanode_lease_secs = 15
 # Datanode selector type.
-# - "lease_based" (default value).
-# - "load_based"
-# For details, please see "https://docs.greptime.com/developer-guide/metasrv/selector".
-selector = "lease_based"
+# - "LeaseBased" (default value).
+# - "LoadBased"
+# For details, please see "https://docs.greptime.com/developer-guide/meta/selector".
+selector = "LeaseBased"
 # Store data in memory, false by default.
 use_memory_store = false
 # Whether to enable greptimedb telemetry, true by default.
 enable_telemetry = true
-# If it's not empty, the metasrv will store all data with this key prefix.
-store_key_prefix = ""
 
 # Log options, see `standalone.example.toml`
 # [logging]
@@ -30,64 +30,10 @@ max_retry_times = 12
 # Initial retry delay of procedures, increases exponentially
 retry_delay = "500ms"
 
-# Failure detectors options.
-[failure_detector]
-threshold = 8.0
-min_std_deviation = "100ms"
-acceptable_heartbeat_pause = "3000ms"
-first_heartbeat_estimate = "1000ms"
-
 # # Datanode options.
 # [datanode]
 # # Datanode client options.
 # [datanode.client_options]
-# timeout = "10s"
-# connect_timeout = "10s"
+# timeout_millis = 10000
+# connect_timeout_millis = 10000
 # tcp_nodelay = true
-
-[wal]
-# Available wal providers:
-# - "raft_engine" (default)
-# - "kafka"
-provider = "raft_engine"
-
-# There're none raft-engine wal config since meta srv only involves in remote wal currently.
-
-# Kafka wal config.
-# The broker endpoints of the Kafka cluster. ["127.0.0.1:9092"] by default.
-# broker_endpoints = ["127.0.0.1:9092"]
-# Number of topics to be created upon start.
-# num_topics = 64
-# Topic selector type.
-# Available selector types: 
-# - "round_robin" (default)
-# selector_type = "round_robin"
-# A Kafka topic is constructed by concatenating `topic_name_prefix` and `topic_id`.
-# topic_name_prefix = "greptimedb_wal_topic"
-# Expected number of replicas of each partition.
-# replication_factor = 1
-# Above which a topic creation operation will be cancelled.
-# create_topic_timeout = "30s"
-# The initial backoff for kafka clients.
-# backoff_init = "500ms"
-# The maximum backoff for kafka clients.
-# backoff_max = "10s"
-# Exponential backoff rate, i.e. next backoff = base * current backoff.
-# backoff_base = 2
-# Stop reconnecting if the total wait time reaches the deadline. If this config is missing, the reconnecting won't terminate.
-# backoff_deadline = "5mins"
-
-# Metasrv export the metrics generated by itself
-# encoded to Prometheus remote-write format
-# and send to Prometheus remote-write compatible receiver (e.g. send to `greptimedb` itself)
-# This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape.
-# [export_metrics]
-# whether enable export metrics, default is false
-# enable = false
-# The interval of export metrics
-# write_interval = "30s"
-# [export_metrics.remote_write]
-# The url the metrics send to. The url is empty by default, url example: `http://127.0.0.1:4000/v1/prometheus/write?db=information_schema`
-# url = ""
-# HTTP headers of Prometheus remote-write carry
-# headers = {}

config/standalone.example.toml

@@ -1,12 +1,12 @@
 # Node running mode, "standalone" or "distributed".
 mode = "standalone"
+# Whether to use in-memory catalog, `false` by default.
+enable_memory_catalog = false
 # Whether to enable greptimedb telemetry, true by default.
 enable_telemetry = true
-# The default timezone of the server
-# default_timezone = "UTC"
 
 # HTTP server options.
-[http]
+[http_options]
 # Server address, "127.0.0.1:4000" by default.
 addr = "127.0.0.1:4000"
 # HTTP request timeout, 30s by default.
@@ -16,23 +16,21 @@ timeout = "30s"
 body_limit = "64MB"
 
 # gRPC server options.
-[grpc]
+[grpc_options]
 # Server address, "127.0.0.1:4001" by default.
 addr = "127.0.0.1:4001"
 # The number of server worker threads, 8 by default.
 runtime_size = 8
 
 # MySQL server options.
-[mysql]
-# Whether to enable
-enable = true
+[mysql_options]
 # Server address, "127.0.0.1:4002" by default.
 addr = "127.0.0.1:4002"
 # The number of server worker threads, 2 by default.
 runtime_size = 2
 
 # MySQL server TLS options.
-[mysql.tls]
+[mysql_options.tls]
 # TLS mode, refer to https://www.postgresql.org/docs/current/libpq-ssl.html
 # - "disable" (default value)
 # - "prefer"
@@ -44,58 +42,42 @@ mode = "disable"
 cert_path = ""
 # Private key file path.
 key_path = ""
-# Watch for Certificate and key file change and auto reload
-watch = false
 
 # PostgresSQL server options.
-[postgres]
-# Whether to enable
-enable = true
+[postgres_options]
 # Server address, "127.0.0.1:4003" by default.
 addr = "127.0.0.1:4003"
 # The number of server worker threads, 2 by default.
 runtime_size = 2
 
 # PostgresSQL server TLS options, see `[mysql_options.tls]` section.
-[postgres.tls]
+[postgres_options.tls]
 # TLS mode.
 mode = "disable"
 # certificate file path.
 cert_path = ""
 # private key file path.
 key_path = ""
-# Watch for Certificate and key file change and auto reload
-watch = false
 
 # OpenTSDB protocol options.
-[opentsdb]
-# Whether to enable
-enable = true
+[opentsdb_options]
 # OpenTSDB telnet API server address, "127.0.0.1:4242" by default.
 addr = "127.0.0.1:4242"
 # The number of server worker threads, 2 by default.
 runtime_size = 2
 
 # InfluxDB protocol options.
-[influxdb]
+[influxdb_options]
 # Whether to enable InfluxDB protocol in HTTP API, true by default.
 enable = true
 
 # Prometheus remote storage options
-[prom_store]
+[prom_store_options]
 # Whether to enable Prometheus remote write and read in HTTP API, true by default.
 enable = true
-# Whether to store the data from Prometheus remote write in metric engine.
-# true by default
-with_metric_engine = true
 
+# WAL options.
 [wal]
-# Available wal providers:
-# - "raft_engine" (default)
-# - "kafka"
-provider = "raft_engine"
-
-# Raft-engine wal options.
 # WAL data directory
 # dir = "/tmp/greptimedb/wal"
 # WAL file size in bytes.
@@ -108,61 +90,6 @@ purge_interval = "10m"
 read_batch_size = 128
 # Whether to sync log file after every write.
 sync_write = false
-# Whether to reuse logically truncated log files.
-enable_log_recycle = true
-# Whether to pre-create log files on start up
-prefill_log_files = false
-# Duration for fsyncing log files.
-sync_period = "1000ms"
-
-# Kafka wal options.
-# The broker endpoints of the Kafka cluster. ["127.0.0.1:9092"] by default.
-# broker_endpoints = ["127.0.0.1:9092"]
-
-# Number of topics to be created upon start.
-# num_topics = 64
-# Topic selector type.
-# Available selector types:
-# - "round_robin" (default)
-# selector_type = "round_robin"
-# The prefix of topic name.
-# topic_name_prefix = "greptimedb_wal_topic"
-# The number of replicas of each partition.
-# Warning: the replication factor must be positive and must not be greater than the number of broker endpoints.
-# replication_factor = 1
-
-# The max size of a single producer batch.
-# Warning: Kafka has a default limit of 1MB per message in a topic.
-# max_batch_size = "1MB"
-# The linger duration.
-# linger = "200ms"
-# The consumer wait timeout.
-# consumer_wait_timeout = "100ms"
-# Create topic timeout.
-# create_topic_timeout = "30s"
-
-# The initial backoff delay.
-# backoff_init = "500ms"
-# The maximum backoff delay.
-# backoff_max = "10s"
-# Exponential backoff rate, i.e. next backoff = base * current backoff.
-# backoff_base = 2
-# The deadline of retries.
-# backoff_deadline = "5mins"
-
-# Metadata storage options.
-[metadata_store]
-# Kv file size in bytes.
-file_size = "256MB"
-# Kv purge threshold.
-purge_threshold = "4GB"
-
-# Procedure storage options.
-[procedure]
-# Procedure max retry time.
-max_retry_times = 3
-# Initial retry delay of procedures, increases exponentially
-retry_delay = "500ms"
 
 # Storage options.
 [storage]
@@ -172,89 +99,43 @@ data_home = "/tmp/greptimedb/"
 type = "File"
 # TTL for all tables. Disabled by default.
 # global_ttl = "7d"
-# Cache configuration for object storage such as 'S3' etc.
-# cache_path = "/path/local_cache"
-# The local file cache capacity in bytes.
-# cache_capacity = "256MB"
 
-# Custom storage options
-#[[storage.providers]]
-#type = "S3"
-#[[storage.providers]]
-#type = "Gcs"
+# Compaction options.
+[storage.compaction]
+# Max task number that can concurrently run.
+max_inflight_tasks = 4
+# Max files in level 0 to trigger compaction.
+max_files_in_level0 = 8
+# Max task number for SST purge task after compaction.
+max_purge_tasks = 32
 
-# Mito engine options
-[[region_engine]]
-[region_engine.mito]
-# Number of region workers
-num_workers = 8
-# Request channel size of each worker
-worker_channel_size = 128
-# Max batch size for a worker to handle requests
-worker_request_batch_size = 64
-# Number of meta action updated to trigger a new checkpoint for the manifest
-manifest_checkpoint_distance = 10
-# Whether to compress manifest and checkpoint file by gzip (default false).
-compress_manifest = false
-# Max number of running background jobs
-max_background_jobs = 4
+# Storage manifest options
+[storage.manifest]
+# Region checkpoint actions margin.
+# Create a checkpoint every <checkpoint_margin> actions.
+checkpoint_margin = 10
+# Region manifest logs and checkpoints gc execution duration
+gc_duration = '10m'
+
+# Storage flush options
+[storage.flush]
+# Max inflight flush tasks.
+max_flush_tasks = 8
+# Default write buffer size for a region.
+region_write_buffer_size = "32MB"
+# Interval to check whether a region needs flush.
+picker_schedule_interval = "5m"
 # Interval to auto flush a region if it has not flushed yet.
 auto_flush_interval = "1h"
-# Global write buffer size for all regions. If not set, it's default to 1/8 of OS memory with a max limitation of 1GB.
+# Global write buffer size for all regions.
 global_write_buffer_size = "1GB"
-# Global write buffer size threshold to reject write requests. If not set, it's default to 2 times of `global_write_buffer_size`
-global_write_buffer_reject_size = "2GB"
-# Cache size for SST metadata. Setting it to 0 to disable the cache.
-# If not set, it's default to 1/32 of OS memory with a max limitation of 128MB.
-sst_meta_cache_size = "128MB"
-# Cache size for vectors and arrow arrays. Setting it to 0 to disable the cache.
-# If not set, it's default to 1/16 of OS memory with a max limitation of 512MB.
-vector_cache_size = "512MB"
-# Cache size for pages of SST row groups. Setting it to 0 to disable the cache.
-# If not set, it's default to 1/16 of OS memory with a max limitation of 512MB.
-page_cache_size = "512MB"
-# Buffer size for SST writing.
-sst_write_buffer_size = "8MB"
-# Parallelism to scan a region (default: 1/4 of cpu cores).
-# - 0: using the default value (1/4 of cpu cores).
-# - 1: scan in current thread.
-# - n: scan in parallelism n.
-scan_parallelism = 0
-# Capacity of the channel to send data from parallel scan tasks to the main task (default 32).
-parallel_scan_channel_size = 32
-# Whether to allow stale WAL entries read during replay.
-allow_stale_entries = false
 
-[region_engine.mito.inverted_index]
-# Whether to create the index on flush.
-# - "auto": automatically
-# - "disable": never
-create_on_flush = "auto"
-# Whether to create the index on compaction.
-# - "auto": automatically
-# - "disable": never
-create_on_compaction = "auto"
-# Whether to apply the index on query
-# - "auto": automatically
-# - "disable": never
-apply_on_query = "auto"
-# Memory threshold for performing an external sort during index creation.
-# Setting to empty will disable external sorting, forcing all sorting operations to happen in memory.
-mem_threshold_on_create = "64M"
-# File system path to store intermediate files for external sorting (default `{data_home}/index_intermediate`).
-intermediate_path = ""
-
-[region_engine.mito.memtable]
-# Memtable type.
-# - "experimental": experimental memtable
-# - "time_series": time-series memtable (deprecated)
-type = "experimental"
-# The max number of keys in one shard.
-index_max_keys_per_shard = 8192
-# The max rows of data inside the actively writing buffer in one shard.
-data_freeze_threshold = 32768
-# Max dictionary bytes.
-fork_dictionary_bytes = "1GiB"
+# Procedure storage options.
+[procedure]
+# Procedure max retry time.
+max_retry_times = 3
+# Initial retry delay of procedures, increases exponentially
+retry_delay = "500ms"
 
 # Log options
 # [logging]
@@ -262,25 +143,3 @@ fork_dictionary_bytes = "1GiB"
 # dir = "/tmp/greptimedb/logs"
 # Specify the log level [info | debug | error | warn]
 # level = "info"
-# whether enable tracing, default is false
-# enable_otlp_tracing = false
-# tracing exporter endpoint with format `ip:port`, we use grpc oltp as exporter, default endpoint is `localhost:4317`
-# otlp_endpoint = "localhost:4317"
-# Whether to append logs to stdout. Defaults to true.
-# append_stdout = true
-# The percentage of tracing will be sampled and exported. Valid range `[0, 1]`, 1 means all traces are sampled, 0 means all traces are not sampled, the default value is 1. ratio > 1 are treated as 1. Fractions < 0 are treated as 0
-# [logging.tracing_sample_ratio]
-# default_ratio = 0.0
-
-# Standalone export the metrics generated by itself
-# encoded to Prometheus remote-write format
-# and send to Prometheus remote-write compatible receiver (e.g. send to `greptimedb` itself)
-# This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape.
-# [export_metrics]
-# whether enable export metrics, default is false
-# enable = false
-# The interval of export metrics
-# write_interval = "30s"
-# for `standalone`, `self_import` is recommend to collect metrics generated by itself
-# [export_metrics.self_import]
-# db = "information_schema"

docker/buildx/ubuntu/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:20.04 as builder
+FROM ubuntu:22.04 as builder
 
 ARG CARGO_PROFILE
 ARG FEATURES
@@ -7,11 +7,6 @@ ARG OUTPUT_DIR
 ENV LANG en_US.utf8
 WORKDIR /greptimedb
 
-# Add PPA for Python 3.10.
-RUN apt-get update && \
-    DEBIAN_FRONTEND=noninteractive apt-get install -y software-properties-common && \
-    add-apt-repository ppa:deadsnakes/ppa -y
-
 # Install dependencies.
 RUN --mount=type=cache,target=/var/cache/apt \
     apt-get update && apt-get install -y \

docker/ci/ubuntu/Dockerfile

@@ -1,11 +1,5 @@
 FROM ubuntu:22.04
 
-# The root path under which contains all the dependencies to build this Dockerfile.
-ARG DOCKER_BUILD_ROOT=.
-# The binary name of GreptimeDB executable.
-# Defaults to "greptime", but sometimes in other projects it might be different.
-ARG TARGET_BIN=greptime
-
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     ca-certificates \
     python3.10 \
@@ -13,16 +7,14 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     python3-pip \
     curl
 
-COPY $DOCKER_BUILD_ROOT/docker/python/requirements.txt /etc/greptime/requirements.txt
+COPY ./docker/python/requirements.txt /etc/greptime/requirements.txt
 
 RUN python3 -m pip install -r /etc/greptime/requirements.txt
 
 ARG TARGETARCH
 
-ADD $TARGETARCH/$TARGET_BIN /greptime/bin/
+ADD $TARGETARCH/greptime /greptime/bin/
 
 ENV PATH /greptime/bin/:$PATH
 
-ENV TARGET_BIN=$TARGET_BIN
-
-ENTRYPOINT ["sh", "-c", "exec $TARGET_BIN \"$@\"", "--"]
+ENTRYPOINT ["greptime"]

docker/dev-builder/android/Dockerfile

@@ -1,41 +0,0 @@
-FROM --platform=linux/amd64 saschpe/android-ndk:34-jdk17.0.8_7-ndk25.2.9519653-cmake3.22.1
-
-ENV LANG en_US.utf8
-WORKDIR /greptimedb
-
-# Rename libunwind to libgcc
-RUN cp ${NDK_ROOT}/toolchains/llvm/prebuilt/linux-x86_64/lib64/clang/14.0.7/lib/linux/aarch64/libunwind.a ${NDK_ROOT}/toolchains/llvm/prebuilt/linux-x86_64/lib64/clang/14.0.7/lib/linux/aarch64/libgcc.a
-
-# Install dependencies.
-RUN apt-get update && apt-get install -y \
-    libssl-dev \
-    protobuf-compiler \
-    curl \
-    git \
-    build-essential \
-    pkg-config \
-    python3 \
-    python3-dev \
-    python3-pip \
-    && pip3 install --upgrade pip \
-    && pip3 install pyarrow
-
-# Trust workdir
-RUN git config --global --add safe.directory /greptimedb
-
-# Install Rust.
-SHELL ["/bin/bash", "-c"]
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --no-modify-path --default-toolchain none -y
-ENV PATH /root/.cargo/bin/:$PATH
-
-# Add android toolchains
-ARG RUST_TOOLCHAIN
-RUN rustup toolchain install ${RUST_TOOLCHAIN}
-RUN rustup target add aarch64-linux-android
-
-# Install cargo-ndk
-RUN cargo install cargo-ndk
-ENV ANDROID_NDK_HOME $NDK_ROOT
-
-# Builder entrypoint.
-CMD ["cargo", "ndk", "--platform", "23", "-t", "aarch64-linux-android", "build", "--bin", "greptime", "--profile", "release", "--no-default-features"]

docker/dev-builder/centos/Dockerfile

@@ -26,5 +26,4 @@ ARG RUST_TOOLCHAIN
 RUN rustup toolchain install ${RUST_TOOLCHAIN}
 
 # Install nextest.
-RUN cargo install cargo-binstall --locked
-RUN cargo binstall cargo-nextest --no-confirm
+RUN cargo install cargo-nextest --locked

docker/dev-builder/ubuntu/Dockerfile

@@ -1,16 +1,8 @@
-FROM ubuntu:20.04
-
-# The root path under which contains all the dependencies to build this Dockerfile.
-ARG DOCKER_BUILD_ROOT=.
+FROM ubuntu:22.04
 
 ENV LANG en_US.utf8
 WORKDIR /greptimedb
 
-# Add PPA for Python 3.10.
-RUN apt-get update && \
-    DEBIAN_FRONTEND=noninteractive apt-get install -y software-properties-common && \
-    add-apt-repository ppa:deadsnakes/ppa -y
-
 # Install dependencies.
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     libssl-dev \
@@ -22,28 +14,13 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     build-essential \
     pkg-config \
     python3.10 \
-    python3.10-dev
+    python3.10-dev \
+    python3-pip
 
-# Remove Python 3.8 and install pip.
-RUN apt-get -y purge python3.8 && \
-    apt-get -y autoremove && \
-    ln -s /usr/bin/python3.10 /usr/bin/python3 && \
-    curl -sS https://bootstrap.pypa.io/get-pip.py | python3.10
-
-# Silence all `safe.directory` warnings, to avoid the "detect dubious repository" error when building with submodules.
-# Disabling the safe directory check here won't pose extra security issues, because in our usage for this dev build
-# image, we use it solely on our own environment (that github action's VM, or ECS created dynamically by ourselves),
-# and the repositories are pulled from trusted sources (still us, of course). Doing so does not violate the intention
-# of the Git's addition to the "safe.directory" at the first place (see the commit message here:
-# https://github.com/git/git/commit/8959555cee7ec045958f9b6dd62e541affb7e7d9).
-# There's also another solution to this, that we add the desired submodules to the safe directory, instead of using 
-# wildcard here. However, that requires the git's config files and the submodules all owned by the very same user.
-# It's troublesome to do this since the dev build runs in Docker, which is under user "root"; while outside the Docker,
-# it can be a different user that have prepared the submodules.
-RUN git config --global --add safe.directory *
+RUN git config --global --add safe.directory /greptimedb
 
 # Install Python dependencies.
-COPY $DOCKER_BUILD_ROOT/docker/python/requirements.txt /etc/greptime/requirements.txt
+COPY ./docker/python/requirements.txt /etc/greptime/requirements.txt
 RUN python3 -m pip install -r /etc/greptime/requirements.txt
 
 # Install Rust.
@@ -56,5 +33,4 @@ ARG RUST_TOOLCHAIN
 RUN rustup toolchain install ${RUST_TOOLCHAIN}
 
 # Install nextest.
-RUN cargo install cargo-binstall --locked
-RUN cargo binstall cargo-nextest --no-confirm
+RUN cargo install cargo-nextest --locked

docker/dev-builder/ubuntu/Dockerfile-18.10

@@ -1,48 +0,0 @@
-# Use the legacy glibc 2.28.
-FROM ubuntu:18.10
-
-ENV LANG en_US.utf8
-WORKDIR /greptimedb
-
-# Use old-releases.ubuntu.com to avoid 404s: https://help.ubuntu.com/community/EOLUpgrades.
-RUN echo "deb http://old-releases.ubuntu.com/ubuntu/ cosmic main restricted universe multiverse\n\
-deb http://old-releases.ubuntu.com/ubuntu/ cosmic-updates main restricted universe multiverse\n\
-deb http://old-releases.ubuntu.com/ubuntu/ cosmic-security main restricted universe multiverse" > /etc/apt/sources.list
-
-# Install dependencies.
-RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
-    libssl-dev \
-    tzdata \
-    curl \
-    ca-certificates \
-    git \
-    build-essential \
-    unzip \
-    pkg-config
-
-# Install protoc.
-ENV PROTOC_VERSION=25.1
-RUN if [ "$(uname -m)" = "x86_64" ]; then \
-        PROTOC_ZIP=protoc-${PROTOC_VERSION}-linux-x86_64.zip; \
-    elif [ "$(uname -m)" = "aarch64" ]; then \
-        PROTOC_ZIP=protoc-${PROTOC_VERSION}-linux-aarch_64.zip; \
-    else \
-        echo "Unsupported architecture"; exit 1; \
-    fi && \
-    curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VERSION}/${PROTOC_ZIP} && \
-    unzip -o ${PROTOC_ZIP} -d /usr/local bin/protoc && \
-    unzip -o ${PROTOC_ZIP} -d /usr/local 'include/*' && \
-    rm -f ${PROTOC_ZIP}
-
-# Install Rust.
-SHELL ["/bin/bash", "-c"]
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --no-modify-path --default-toolchain none -y
-ENV PATH /root/.cargo/bin/:$PATH
-
-# Install Rust toolchains.
-ARG RUST_TOOLCHAIN
-RUN rustup toolchain install ${RUST_TOOLCHAIN}
-
-# Install nextest.
-RUN cargo install cargo-binstall --locked
-RUN cargo binstall cargo-nextest --no-confirm

docs/benchmarks/tsbs/v0.4.0.md

@@ -1,61 +0,0 @@
-# TSBS benchmark - v0.4.0
-
-## Environment
-
-### Local
-|        |                                    |
-| ------ | ---------------------------------- |
-| CPU    | AMD Ryzen 7 7735HS (8 core 3.2GHz) |
-| Memory | 32GB                               |
-| Disk   | SOLIDIGM SSDPFKNU010TZ             |
-| OS     | Ubuntu 22.04.2 LTS                 |
-
-### Aliyun amd64
-
-|         |                |
-| ------- | -------------- |
-| Machine | ecs.g7.4xlarge |
-| CPU     | 16 core        |
-| Memory  | 64GB           |
-| Disk    | 100G           |
-| OS      | Ubuntu  22.04  |
-
-### Aliyun arm64
-
-|         |                   |
-| ------- | ----------------- |
-| Machine | ecs.g8y.4xlarge   |
-| CPU     | 16 core           |
-| Memory  | 64GB              |
-| Disk    | 100G              |
-| OS      | Ubuntu  22.04 ARM |
-
-
-## Write performance
-
-| Environment        | Ingest rate（rows/s） |
-| ------------------ | --------------------- |
-| Local              | 365280.60             |
-| Aliyun g7.4xlarge  | 341368.72             |
-| Aliyun g8y.4xlarge | 320907.29             |
-
-
-## Query performance
-
-| Query type            | Local (ms) | Aliyun g7.4xlarge (ms) | Aliyun g8y.4xlarge (ms) |
-| --------------------- | ---------- | ---------------------- | ----------------------- |
-| cpu-max-all-1         | 50.70      | 31.46                  | 47.61                   |
-| cpu-max-all-8         | 262.16     | 129.26                 | 152.43                  |
-| double-groupby-1      | 2512.71    | 1408.19                | 1586.10                 |
-| double-groupby-5      | 3896.15    | 2304.29                | 2585.29                 |
-| double-groupby-all    | 5404.67    | 3337.61                | 3773.91                 |
-| groupby-orderby-limit | 3786.98    | 2065.72                | 2312.57                 |
-| high-cpu-1            | 71.96      | 37.29                  | 54.01                   |
-| high-cpu-all          | 9468.75    | 7595.69                | 8467.46                 |
-| lastpoint             | 13379.43   | 11253.76               | 12949.40                |
-| single-groupby-1-1-1  | 20.72      | 12.16                  | 13.35                   |
-| single-groupby-1-1-12 | 28.53      | 15.67                  | 21.62                   |
-| single-groupby-1-8-1  | 72.23      | 37.90                  | 43.52                   |
-| single-groupby-5-1-1  | 26.75      | 15.59                  | 17.48                   |
-| single-groupby-5-1-12 | 45.41      | 22.90                  | 31.96                   |
-| single-groupby-5-8-1  | 107.96     | 59.76                  | 69.58                   |

docs/rfcs/2023-07-10-metric-engine.md

@@ -50,10 +50,10 @@ The concept "Table" in GreptimeDB is a bit "heavy" compared to other time-series
 	```
 
 The following parts will describe these implementation details:
-- How to route these metric region tables and how those table are distributed
-- How to maintain the schema and other metadata of the underlying mito engine table
-- How to maintain the schema of metric engine table
-- How the query goes
+    - How to route these metric region tables and how those table are distributed
+    - How to maintain the schema and other metadata of the underlying mito engine table
+    - How to maintain the schema of metric engine table
+    - How the query goes
 
 ## Routing
 

docs/rfcs/2023-11-03-inverted-index.md

@@ -1,113 +0,0 @@
----
-Feature Name: Inverted Index for SST File
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/2705
-Date: 2023-11-03
-Author: "Zhong Zhenchi <zhongzc_arch@outlook.com>"
----
-
-# Summary
-This RFC proposes an optimization towards the storage engine by introducing an inverted indexing methodology aimed at optimizing label selection queries specifically pertaining to Metrics with tag columns as the target for optimization.
-
-# Introduction
-In the current system setup, in the Mito Engine, the first column of Primary Keys has a Min-Max index, which significantly optimizes the outcome. However, there are limitations when it comes to other columns, primarily tags. This RFC suggests the implementation of an inverted index to provide enhanced filtering benefits to bridge these limitations and improve overall system performance.
-
-# Design Detail
-
-## Inverted Index
-
-The primary aim of the proposed inverted index is to optimize tag columns in the SST Parquet Files within the Mito Engine. The mapping and construction of an inverted index, from Tag Values to Row Groups, enables efficient logical structures that provide faster and more flexible queries.
-
-When scanning SST Files, pushed-down filters applied to a respective Tag's inverted index, determine the final Row Groups to be indexed and scanned, further bolstering the speed and efficiency of data retrieval processes.
-
-## Index Format
-
-The Inverted Index for each SST file follows the format shown below:
-
-```
-inverted_index₀ inverted_index₁ ... inverted_indexₙ footer
-```
-
-The structure inside each Inverted Index is as followed:
-
-```
-bitmap₀ bitmap₁ bitmap₂ ... bitmapₙ null_bitmap fst
-```
-
-The format is encapsulated by a footer:
-
-```
-footer_payload footer_payload_size
-```
-
-The `footer_payload` is presented in protobuf encoding of `InvertedIndexFooter`.
-
-The complete format is containerized in [Puffin](https://iceberg.apache.org/puffin-spec/) with the type defined as `greptime-inverted-index-v1`.
-
-## Protobuf Details
-
-The `InvertedIndexFooter` is defined in the following protobuf structure:
-
-```protobuf
-message InvertedIndexFooter {
-    repeated InvertedIndexMeta metas;
-}
-
-message InvertedIndexMeta {
-    string name;
-    uint64 row_count_in_group;
-    uint64 fst_offset;
-    uint64 fst_size;
-    uint64 null_bitmap_offset;
-    uint64 null_bitmap_size;
-    InvertedIndexStats stats;
-}
-
-message InvertedIndexStats {
-    uint64 null_count;
-    uint64 distinct_count;
-    bytes min_value;
-    bytes max_value;
-}
-```
-
-## Bitmap
-
-Bitmaps are used to represent indices of fixed-size groups. Rows are divided into groups of a fixed size, defined in the `InvertedIndexMeta` as `row_count_in_group`.
-
-For example, when `row_count_in_group` is `4096`, it means each group has `4096` rows. If there are a total of `10000` rows, there will be `3` groups in total. The first two groups will have `4096` rows each, and the last group will have `1808` rows. If the indexed values are found in row `200` and `9000`, they will correspond to groups `0` and `2`, respectively. Therefore, the bitmap should show `0` and `2`.
-
-Bitmap is implemented using [BitVec](https://docs.rs/bitvec/latest/bitvec/), selected due to its efficient representation of dense data arrays typical of indices of groups.
-
-
-## Finite State Transducer (FST)
-
-[FST](https://docs.rs/fst/latest/fst/) is a highly efficient data structure ideal for in-memory indexing. It represents ordered sets or maps where the keys are bytes. The choice of the FST effectively balances the need for performance, space efficiency, and the ability to perform complex analyses such as regular expression matching.
-
-The conventional usage of FST and `u64` values has been adapted to facilitate indirect indexing to row groups. As the row groups are represented as Bitmaps, we utilize the `u64` values split into bitmap's offset (higher 32 bits) and size (lower 32 bits) to represent the location of these Bitmaps. 
-
-## API Design
-
-Two APIs `InvertedIndexBuilder` for building indexes and  `InvertedIndexSearcher` for querying indexes are designed:
-
-```rust
-type Bytes = Vec<u8>;
-type GroupId = u64;
-
-trait InvertedIndexBuilder {
-    fn add(&mut self, name: &str, value: Option<&Bytes>, group_id: GroupId) -> Result<()>;
-    fn finish(&mut self) -> Result<()>;
-}
-
-enum Predicate {
-    Gt(Bytes),
-    GtEq(Bytes),
-    Lt(Bytes),
-    LtEq(Bytes),
-    InList(Vec<Bytes>),
-    RegexMatch(String),
-}
-
-trait InvertedIndexSearcher {
-    fn search(&mut self, name: &str, predicates: &[Predicate]) -> Result<impl IntoIterator<GroupId>>;
-}
-```

docs/rfcs/2023-11-07-region-migration.md

@@ -1,169 +0,0 @@
----
-Feature Name: Region Migration Procedure
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/2700
-Date: 2023-11-03
-Author: "Xu Wenkang <wenymedia@gmail.com>"
----
-
-# Summary
-This RFC proposes a way that brings the ability of Meta Server to move regions between the Datanodes.
-
-# Motivation
-Typically, We need this ability in the following scenarios:
-- Migrate hot-spot Regions to idle Datanode
-- Move the failure Regions to an available Datanode
-
-# Details
-
-```mermaid
-flowchart TD
-    style Start fill:#85CB90,color:#fff
-    style End fill:#85CB90,color:#fff
-    style SelectCandidate fill:#F38488,color:#fff
-    style OpenCandidate fill:#F38488,color:#fff
-    style UpdateMetadataDown fill:#F38488,color:#fff
-    style UpdateMetadataUp fill:#F38488,color:#fff
-    style UpdateMetadataRollback fill:#F38488,color:#fff
-    style DowngradeLeader fill:#F38488,color:#fff
-    style UpgradeCandidate fill:#F38488,color:#fff
-
-    Start[Start] 
-    SelectCandidate[Select Candidate] 
-    UpdateMetadataDown["`Update Metadata(Down)
-        1. Downgrade Leader
-    `"]
-    DowngradeLeader["`Downgrade Leader
-    1. Become Follower
-    2. Return **last_entry_id**
-    `"]
-    UpgradeCandidate["`Upgrade Candidate
-    1. Replay to **last_entry_id**
-    2. Become Leader
-    `"]
-    UpdateMetadataUp["`Update Metadata(Up)
-        1. Switch Leader
-        2.1. Remove Old Leader(Opt.)
-        2.2. Move Old Leader to Follower(Opt.)
-    `"]
-    UpdateMetadataRollback["`Update Metadata(Rollback)
-        1. Upgrade old Leader
-    `"]
-    End
-    AnyCandidate{Available?}
-    OpenCandidate["Open Candidate"]
-    CloseOldLeader["Close Old Leader"]
-
-    Start 
-    --> SelectCandidate
-    --> AnyCandidate
-    --> |Yes| UpdateMetadataDown 
-    --> I1["Invalid Frontend Cache"]
-    --> DowngradeLeader 
-    --> UpgradeCandidate
-    --> UpdateMetadataUp
-    --> I2["Invalid Frontend Cache"]
-    --> End
-    
-    UpgradeCandidate
-    --> UpdateMetadataRollback
-    --> I3["Invalid Frontend Cache"]
-    --> End
-
-    I2 
-    --> CloseOldLeader
-    --> End
-
-    AnyCandidate 
-    --> |No| OpenCandidate
-    --> UpdateMetadataDown
-```
-
-**Only the red nodes will persist state after it has succeeded**, and other nodes won't persist state. (excluding the Start and End nodes).
-
-## Steps
-
-**The persistent context:** It's shared in each step and available after recovering. It will only be updated/stored after the Red node has succeeded.
-
-Values: 
-- `region_id`: The target leader region.
-- `peer`: The target datanode.
-- `close_old_leader`: Indicates whether close the region. 
-- `leader_may_unreachable`: It's used to support the failover procedure.
-
-**The Volatile context:** It's shared in each step and available in executing (including retrying). It will be dropped if the procedure runner crashes.
-
-### Select Candidate
-
-The Persistent state: Selected Candidate Region.
-
-### Update Metadata(Down)
-
-**The Persistent context:**
-- The (latest/updated) `version` of `TableRouteValue`, It will be used in the step of `Update Metadata(Up)`.
-
-### Downgrade Leader
-This step sends an instruction via heartbeat and performs:
-1. Downgrades leader region.
-2. Retrieves the `last_entry_id` (if available).
-
-If the target leader region is not found: 
-- Sets `close_old_leader` to true.
-- Sets `leader_may_unreachable` to true.
-
-If the target Datanode is unreachable:
-- Waits for region lease expired.
-- Sets `close_old_leader` to true.
-- Sets `leader_may_unreachable` to true.
-
-**The Persistent context:**
-None
-
-**The Persistent state:** 
-- `last_entry_id`
-
-*Passes to next step.
-
-
-### Upgrade Candidate
-This step sends an instruction via heartbeat and performs:
-1. Replays the WAL to latest(`last_entry_id`).
-2. Upgrades the candidate region.
-
-If the target region is not found: 
-- Rollbacks.
-- Notifies the failover detector if `leader_may_unreachable` == true.
-- Exits procedure.
-
-If the target Datanode is unreachable:
-- Rollbacks.
-- Notifies the failover detector if `leader_may_unreachable` == true.
-- Exits procedure.
-
-**The Persistent context:**
-None
-
-### Update Metadata(Up)
-This step performs
-1. Switches Leader.
-2. Removes Old Leader(Opt.).
-3. Moves Old Leader to follower(Opt.).
-
-The `TableRouteValue` version should equal the `TableRouteValue`'s `version` in Persistent context. Otherwise, verifies whether `TableRouteValue` already updated.
-
-**The Persistent context:**
-None
-
-### Close Old Leader(Opt.)
-This step sends a close region instruction via heartbeat.
-
-If the target leader region is not found: 
-- Ignore.
-
-If the target Datanode is unreachable: 
-- Ignore.
-
-### Open Candidate(Opt.)
-This step sends an open region instruction via heartbeat and waits for conditions to be met (typically, the condition is that the `last_entry_id` of the Candidate Region is very close to that of the Leader Region or the latest).
-
-If the target Datanode is unreachable: 
-- Exits procedure.

docs/rfcs/2023-12-22-enclose-column-id.md

@@ -1,44 +0,0 @@
----
-Feature Name: Enclose Column Id
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/2982
-Date: 2023-12-22
-Author: "Ruihang Xia <waynestxia@gmail.com>"
----
-
-# Summary
-This RFC proposes to enclose the usage of `ColumnId` into the region engine only.
-
-# Motivation
-`ColumnId` is an identifier for columns. It's assigned by meta server, stored in `TableInfo` and `RegionMetadata` and used in region engine to distinguish columns.
-
-At present, Both Frontend, Datanode and Metasrv are aware of `ColumnId` but it's only used in region engine. Thus this RFC proposes to remove it from Frontend (mainly used in `TableInfo`) and Metasrv.
-
-# Details
-
-`ColumnId` is used widely on both read and write paths. Removing it from Frontend and Metasrv implies several things:
-
-- A column may have different column id in different regions.
-- A column is identified by its name in all components.
-- Column order in the region engine is not restricted, i.e., no need to be in the same order with table info.
-
-The first thing doesn't matter IMO. This concept doesn't exist anymore outside of region server, and each region is autonomous and independent -- the only guarantee it should hold is those columns exist. But if we consider region repartition, where the SST file would be re-assign to different regions, things would become a bit more complicated. A possible solution is store the relation between name and ColumnId in the manifest, but it's out of the scope of this RFC. We can likely give a workaround by introducing a indirection mapping layer of different version of partitions.
-
-And more importantly, we can still assume columns have the same column ids across regions. We have procedure to maintain consistency between regions and the region engine should ensure alterations are idempotent. So it is possible that region repartition doesn't need to consider column ids or other region metadata in the future.
-
-Users write and query column by their names, not by ColumnId or something else. The second point also means to change the column reference in ScanRequest from index to name. This change can hugely alleviate the misuse of the column index, which has given us many surprises.
-
-And for the last one, column order only matters in table info. This order is used in user-faced table structure operation, like add column, describe column or as the default order of INSERT clause. None of them is connected with the order in storage.
-
-# Drawback
-Firstly, this is a breaking change. Delivering this change requires a full upgrade of the cluster. Secondly, this change may introduce some performance regression. For example, we have to pass the full table name in the `ScanRequest` instead of the `ColumnId`. But this influence is very limited, since the column index is only used in the region engine.
-
-# Alternatives
-
-There are two alternatives from the perspective of "what can be used as the column identifier":
-
-- Index of column to the table schema
-- `ColumnId` of that column
-
-The first one is what we are using now. By choosing this way, it's required to keep the column order in the region engine the same as the table info. This is not hard to achieve, but it's a bit annoying. And things become tricky when there is internal column or different schemas like those stored in file format. And this is the initial purpose of this RFC, which is trying to decouple the table schema and region schema.
-
-The second one, in other hand, requires the `ColumnId` should be identical in all regions and `TableInfo`. It has the same drawback with the previous alternative, that the `TableInfo` and `RegionMetadata` are tighted together. Another point is that the `ColumnId` is assigned by the Metasrv, who doesn't need it but have to maintain it. And this also limits the functionality of `ColumnId`, by taking the ability of assigning it from concrete region engine.

docs/rfcs/2024-01-17-dataflow-framework.md

@@ -1,97 +0,0 @@
----
-Feature Name: Dataflow Framework
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/3187
-Date: 2024-01-17
-Author: "Discord9 <discord9@163.com>"
----
-
-# Summary
-This RFC proposes a Lightweight Module for executing continuous aggregation queries on a stream of data.
-
-# Motivation
-Being able to do continuous aggregation is a very powerful tool. It allows you to do things like:
-1. downsample data from i.e. 1 milliseconds to 1 second
-2. calculate the average of a stream of data
-3. Keeping a sliding window of data in memory
-In order to do those things while maintaining a low memory footprint, you need to be able to manage the data in a smart way. Hence, we only store necessary data in memory, and send/recv data deltas to/from the client.
-
-# Details
-
-## System boundary / What it's and isn't
-- GreptimeFlow provides a way to perform continuous aggregation over time-series data.
-- It's not a complete streaming-processing system. Only a must subset functionalities are provided.
-- Flow can process a configured range of fresh data. Data exceeding this range will be dropped directly. Thus it cannot handle random datasets (random on timestamp).
-- Both sliding windows (e.g., latest 5m from present) and fixed windows (every 5m from some time) are supported. And these two are the major targeting scenarios.
-- Flow can handle most aggregate operators within one table(i.e. Sum, avg, min, max and comparison operators). But others (join, trigger, txn etc.) are not the target feature.
-
-## Framework
-- Greptime Flow's is built on top of [Hydroflow](https://github.com/hydro-project/hydroflow).
-- We have three choices for the Dataflow/Streaming process framework for our simple continuous aggregation feature:
-1. Based on the timely/differential dataflow crate that [materialize](https://github.com/MaterializeInc/materialize) based on. Later, it's proved too obscure for a simple usage, and is hard to customize memory usage control.
-2. Based on a simple dataflow framework that we write from ground up, like what [arroyo](https://www.arroyo.dev/) or [risingwave](https://www.risingwave.dev/) did, for example the core streaming logic of [arroyo](https://github.com/ArroyoSystems/arroyo/blob/master/arroyo-datastream/src/lib.rs) only takes up to 2000 line of codes. However, it means maintaining another layer of dataflow framework, which might seem easy in the beginning, but I fear it might be too burdensome to maintain once we need more features.
-3. Based on a simple and lower level dataflow framework that someone else write, like [hydroflow](https://github.com/hydro-project/hydroflow), this approach combines the best of both worlds. Firstly, it boasts ease of comprehension and customization. Secondly, the dataflow framework offers precisely the necessary features for crafting uncomplicated single-node dataflow programs while delivering decent performance.
-
-Hence, we choose the third option, and use a simple logical plan that's anagonistic to the underlying dataflow framework, as it only describe how the dataflow graph should be doing, not how it do that. And we built operator in hydroflow to execute the plan. And the result hydroflow graph is wrapped in a engine that only support data in/out and tick event to flush and compute the result. This provide a thin middle layer that's easy to maintain and allow switching to other dataflow framework if necessary.
-
-## Deploy mode and protocol
-- Greptime Flow is an independent streaming compute component. It can be used either within a standalone node or as a dedicated node at the same level as frontend in distributed mode.
-- It accepts insert request Rows, which is used between frontend and datanode.
-- New flow job is submitted in the format of modified SQL query like snowflake do, like: `CREATE TASK avg_over_5m WINDOW_SIZE = "5m" AS SELECT avg(value) FROM table WHERE time > now() - 5m GROUP BY time(1m)`. Flow job then got stored in MetaSrv.
-- It also persists results in the format of Rows to frontend.
-- The query plan uses Substrait as codec format. It's the same with GreptimeDB's query engine.
-- Greptime Flow needs a WAL for recovering. It's possible to reuse datanode's.
-
-The workflow is shown in the following diagram
-```mermaid
-graph TB
-subgraph Flownode["Flownode"]
-    subgraph Dataflows
-        df1("Dataflow_1")
-        df2("Dataflow_2")
-    end
-end
-subgraph Frontend["Frontend"]
-    newLines["Mirror Insert
-Create Task From Query
-Write result from flow node"]
-end
-
-subgraph Datanode["Datanode"]
-end
-
-User --> Frontend
-Frontend -->|Register Task| Metasrv
-Metasrv -->|Read Task Metadata| Frontend
-Frontend -->|Create Task| Flownode
-
-Frontend -->|Mirror Insert| Flownode
-Flownode -->|Write back| Frontend
-
-Frontend --> Datanode
-Datanode --> Frontend
-
-```
-
-## Lifecycle of data
-- New data is inserted into frontend like before. Frontend will mirror insert request to Flow node if there is configured flow job.
-- Depending on the timestamp of incoming data, flow will either drop it (outdated data) or process it (fresh data).
-- Greptime Flow will periodically write results back to the result table through frontend.
-- Those result will then be written into a result table stored in datanode.
-- A small table of intermediate state is kept in memory, which is used to calculate the result.
-## Supported operations
-- Greptime Flow accepts a configurable "materialize window", data point exceeds that time window is discarded.
-- Data within that "materialize window" is queryable and updateable.
-- Greptime Flow can handle partitioning, if and only if the input query can be transformed to a fully partitioned plan according to the existing commutative rules. Otherwise the corresponding flow job has to be calculated in a single node.
-- Notice that Greptime Flow has to see all the data belongs to one partition.
-- Deletion and duplicate insertion are not supported at early stage.
-## Miscellaneous 
-- Greptime Flow can translate SQL to it's own plan, however only a selected few aggregate function is supported for now, like min/max/sum/count/avg
-- Greptime Flow's operator is configurable in terms of the size of the materialize window, whether to allow delay of incoming data etc., so simplest operator can choose to not tolerate any delay to save memory.
-
-# Future Work
-- Support UDF that can do one-to-one mapping. Preferably, we can reuse the UDF mechanism in GreptimeDB.
-- Support join operator.
-- Design syntax for config operator for different materialize window and delay tolerance.
-- Support cross partition merge operator that allows complex query plan that not necessary accord with partitioning rule to communicate between nodes and create final materialize result.
-- Duplicate insertion, which can be reverted easily within the current framework, so supporting it could be easy
-- Deletion within "materialize window", this requires operators like min/max to store all inputs within materialize window, which might require further optimization.

docs/rfcs/2024-02-21-multi-dimension-partition-rule/rfc.md

@@ -1,101 +0,0 @@
----
-Feature Name:  Multi-dimension Partition Rule
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/3351
-Date: 2024-02-21
-Author: "Ruihang Xia <waynestxia@gmail.com>"
----
-
-# Summary
-
-A new region partition scheme that runs on multiple dimensions of the key space. The partition rule is defined by a set of simple expressions on the partition key columns.
-
-# Motivation
-
-The current partition rule is from MySQL's [`RANGE Partition`](https://dev.mysql.com/doc/refman/8.0/en/partitioning-range.html), which is based on a single dimension. It is sort of a [Hilbert Curve](https://en.wikipedia.org/wiki/Hilbert_curve) and pick several point on the curve to divide the space. It is neither easy to understand how the data get partitioned nor flexible enough to handle complex partitioning requirements.
-
-Considering the future requirements like region repartitioning or autonomous rebalancing, where both workload and partition may change frequently. Here proposes a new region partition scheme that uses a set of simple expressions on the partition key columns to divide the key space.
-
-# Details
-
-## Partition rule
-
-First, we define a simple expression that can be used to define the partition rule. The simple expression is a binary expression expression on the partition key columns that can be evaluated to a boolean value. The binary operator is limited to comparison operators only, like `=`, `!=`, `>`, `>=`, `<`, `<=`. And the operands are limited either literal value or partition column.
-
-Example of valid simple expressions are $`col_A = 10`$, $`col_A \gt 10 \& col_B \gt 20`$ or $`col_A \ne 10`$.
-
-Those expressions can be used as predicates to divide the key space into different regions. The following example have two partition columns `Col A` and `Col B`, and four partitioned regions.
-
-```math
-\left\{\begin{aligned}
- 
-&col_A \le 10 &Region_1 \\
-&10 \lt col_A \& col_A \le 20 &Region_2 \\
-&20 \lt col_A \space \& \space col_B \lt 100 &Region_3 \\
-&20 \lt col_A \space \& \space col_B \ge 100 &Region_4
-
-\end{aligned}\right\}
-```
-
-An advantage of this scheme is that it is easy to understand how the data get partitioned. The above example can be visualized in a 2D space (two partition column is involved in the example).
-
-![example](2d-example.png)
-
-Here each expression draws a line in the 2D space. Managing data partitioning becomes a matter of drawing lines in the key space.
-
-To make it easy to use, there is a "default region" which catches all the data that doesn't match any of previous expressions. The default region exist by default and do not need to specify. It is also possible to remove this default region if the DB finds it is not necessary.
-
-## SQL interface
-
-The SQL interface is in response to two parts: specifying the partition columns and the partition rule. Thouth we are targeting an autonomous system, it's still allowed to give some bootstrap rules or hints on creating table.
-
-Partition column is specified by `PARTITION ON COLUMNS` sub-clause in `CREATE TABLE`:
-
-```sql
-CREATE TABLE t (...)
-PARTITION ON COLUMNS (...) ();
-```
-
-Two following brackets are for partition columns and partition rule respectively.
-
-Columns provided here are only used as an allow-list of how the partition rule can be defined. Which means (a) the sequence between columns doesn't matter, (b) the columns provided here are not necessarily being used in the partition rule.
-
-The partition rule part is a list of comma-separated simple expressions. Expressions here are not corresponding to region, as they might be changed by system to fit various workload.
-
-A full example of `CREATE TABLE` with partition rule is:
-
-```sql
-CREATE TABLE IF NOT EXISTS demo (
-  a STRING,
-  b STRING,
-  c STRING,
-  d STRING,
-  ts TIMESTAMP,
-  memory DOUBLE,
-  TIME INDEX (ts),
-  PRIMARY KEY (a, b, c, d)
-)
-PARTITION ON COLUMNS (c, b, a) (
-  a < 10,
-  10 >= a AND a < 20,
-  20 >= a AND b < 100,
-  20 >= a AND b > 100
-)
-```
-
-## Combine with storage
-
-Examining columns separately suits our columnar storage very well in two aspects.
-
-1. The simple expression can be pushed down to storage and file format, and is likely to hit existing index. Makes pruning operation very efficient.
-
-2. Columns in columnar storage are not tightly coupled like in the traditional row storages, which means we can easily add or remove columns from partition rule without much impact (like a global reshuffle) on data.
-
-The data file itself can be "projected" to the key space as a polyhedron, it is guaranteed that each plane is in parallel with some coordinate planes (in a 2D scenario, this is saying that all the files can be projected to a rectangle). Thus partition or repartition also only need to consider related columns.
-
-![sst-project](sst-project.png)
-
-An additional limitation is that considering how the index works and how we organize the primary keys at present, the partition columns are limited to be a subset of primary keys for better performance.
-
-# Drawbacks
-
-This is a breaking change.

grafana/README.md

@@ -1,10 +0,0 @@
-Grafana dashboard for GreptimeDB
---------------------------------
-
-GreptimeDB's official Grafana dashboard.
-
-Status notify: we are still working on this config. It's expected to change frequently in the recent days. Please feel free to submit your feedback and/or contribution to this dashboard 🤗
-
-# How to use
-
-Open Grafana Dashboard page, choose `New` -> `Import`. And upload `greptimedb.json` file.

licenserc.toml

@@ -1,24 +0,0 @@
-# Copyright 2023 Greptime Team
-#
-# Licensed 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.
-
-headerPath = "Apache-2.0.txt"
-
-includes = [
-    "*.rs",
-    "*.py",
-]
-
-[properties]
-inceptionYear = 2023
-copyrightOwner = "Greptime Team"

rust-toolchain.toml

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "nightly-2023-12-19"
+channel = "nightly-2023-08-07"

scripts/fetch-dashboard-assets.sh

@@ -1,7 +1,8 @@
 #!/usr/bin/env bash
 
 # This script is used to download built dashboard assets from the "GreptimeTeam/dashboard" repository.
-set -ex
+
+set -e -x
 
 declare -r SCRIPT_DIR=$(cd $(dirname ${0}) >/dev/null 2>&1 && pwd)
 declare -r ROOT_DIR=$(dirname ${SCRIPT_DIR})
@@ -12,34 +13,13 @@ RELEASE_VERSION="$(cat $STATIC_DIR/VERSION | tr -d '\t\r\n ')"
 
 echo "Downloading assets to dir: $OUT_DIR"
 cd $OUT_DIR
-
-if [[ -z "$GITHUB_PROXY_URL" ]]; then
-  GITHUB_URL="https://github.com"
-else
-  GITHUB_URL="${GITHUB_PROXY_URL%/}"
-fi
-
-function retry_fetch() {
-    local url=$1
-    local filename=$2
-
-    curl --connect-timeout 10 --retry 3 -fsSL $url --output $filename || {
-        echo "Failed to download $url"
-        echo "You may try to set http_proxy and https_proxy environment variables."
-        if [[ -z "$GITHUB_PROXY_URL" ]]; then
-          echo "You may try to set GITHUB_PROXY_URL=http://mirror.ghproxy.com/"
-        fi
-        exit 1
-     }
-}
-
 # Download the SHA256 checksum attached to the release. To verify the integrity
 # of the download, this checksum will be used to check the download tar file
 # containing the built dashboard assets.
-retry_fetch "${GITHUB_URL}/GreptimeTeam/dashboard/releases/download/${RELEASE_VERSION}/sha256.txt" sha256.txt
+curl -Ls https://github.com/GreptimeTeam/dashboard/releases/download/$RELEASE_VERSION/sha256.txt --output sha256.txt
 
 # Download the tar file containing the built dashboard assets.
-retry_fetch "${GITHUB_URL}/GreptimeTeam/dashboard/releases/download/$RELEASE_VERSION/build.tar.gz" build.tar.gz
+curl -L https://github.com/GreptimeTeam/dashboard/releases/download/$RELEASE_VERSION/build.tar.gz --output build.tar.gz
 
 # Verify the checksums match; exit if they don't.
 case "$(uname -s)" in

src/api/Cargo.toml

@@ -4,20 +4,14 @@ version.workspace = true
 edition.workspace = true
 license.workspace = true
 
-[lints]
-workspace = true
-
 [dependencies]
-common-base.workspace = true
-common-decimal.workspace = true
-common-error.workspace = true
-common-macro.workspace = true
-common-time.workspace = true
-datatypes.workspace = true
+common-base = { workspace = true }
+common-error = { workspace = true }
+common-time = { workspace = true }
+datatypes = { workspace = true }
 greptime-proto.workspace = true
-paste = "1.0"
 prost.workspace = true
-snafu.workspace = true
+snafu = { version = "0.7", features = ["backtraces"] }
 tonic.workspace = true
 
 [build-dependencies]

src/api/src/error.rs

@@ -16,24 +16,17 @@ use std::any::Any;
 
 use common_error::ext::ErrorExt;
 use common_error::status_code::StatusCode;
-use common_macro::stack_trace_debug;
 use datatypes::prelude::ConcreteDataType;
 use snafu::prelude::*;
 use snafu::Location;
 
 pub type Result<T> = std::result::Result<T, Error>;
 
-#[derive(Snafu)]
+#[derive(Debug, Snafu)]
 #[snafu(visibility(pub))]
-#[stack_trace_debug]
 pub enum Error {
     #[snafu(display("Unknown proto column datatype: {}", datatype))]
-    UnknownColumnDataType {
-        datatype: i32,
-        location: Location,
-        #[snafu(source)]
-        error: prost::DecodeError,
-    },
+    UnknownColumnDataType { datatype: i32, location: Location },
 
     #[snafu(display("Failed to create column datatype from {:?}", from))]
     IntoColumnDataType {
@@ -41,14 +34,22 @@ pub enum Error {
         location: Location,
     },
 
-    #[snafu(display("Failed to convert column default constraint, column: {}", column))]
+    #[snafu(display(
+        "Failed to convert column default constraint, column: {}, source: {}",
+        column,
+        source
+    ))]
     ConvertColumnDefaultConstraint {
         column: String,
         location: Location,
         source: datatypes::error::Error,
     },
 
-    #[snafu(display("Invalid column default constraint, column: {}", column))]
+    #[snafu(display(
+        "Invalid column default constraint, column: {}, source: {}",
+        column,
+        source
+    ))]
     InvalidColumnDefaultConstraint {
         column: String,
         location: Location,

src/api/src/v1/column_def.rs

@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
-
-use datatypes::schema::{ColumnDefaultConstraint, ColumnSchema, COMMENT_KEY};
+use datatypes::schema::{ColumnDefaultConstraint, ColumnSchema};
 use snafu::ResultExt;
 
 use crate::error::{self, Result};
@@ -22,10 +20,7 @@ use crate::helper::ColumnDataTypeWrapper;
 use crate::v1::ColumnDef;
 
 pub fn try_as_column_schema(column_def: &ColumnDef) -> Result<ColumnSchema> {
-    let data_type = ColumnDataTypeWrapper::try_new(
-        column_def.data_type,
-        column_def.datatype_extension.clone(),
-    )?;
+    let data_type = ColumnDataTypeWrapper::try_new(column_def.datatype)?;
 
     let constraint = if column_def.default_constraint.is_empty() {
         None
@@ -39,17 +34,9 @@ pub fn try_as_column_schema(column_def: &ColumnDef) -> Result<ColumnSchema> {
         )
     };
 
-    let mut metadata = HashMap::new();
-    if !column_def.comment.is_empty() {
-        metadata.insert(COMMENT_KEY.to_string(), column_def.comment.clone());
-    }
-
-    Ok(
-        ColumnSchema::new(&column_def.name, data_type.into(), column_def.is_nullable)
-            .with_default_constraint(constraint)
-            .context(error::InvalidColumnDefaultConstraintSnafu {
-                column: &column_def.name,
-            })?
-            .with_metadata(metadata),
-    )
+    ColumnSchema::new(&column_def.name, data_type.into(), column_def.is_nullable)
+        .with_default_constraint(constraint)
+        .context(error::InvalidColumnDefaultConstraintSnafu {
+            column: &column_def.name,
+        })
 }

src/auth/Cargo.toml

@@ -4,18 +4,16 @@ version.workspace = true
 edition.workspace = true
 license.workspace = true
 
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
 [features]
 default = []
 testing = []
 
-[lints]
-workspace = true
-
 [dependencies]
 api.workspace = true
 async-trait.workspace = true
 common-error.workspace = true
-common-macro.workspace = true
 digest = "0.10"
 hex = { version = "0.4" }
 secrecy = { version = "0.8", features = ["serde", "alloc"] }

src/auth/src/common.rs

@@ -4,7 +4,7 @@
 // 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
+// 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,
@@ -26,7 +26,7 @@ use crate::{UserInfoRef, UserProviderRef};
 
 pub(crate) const DEFAULT_USERNAME: &str = "greptime";
 
-/// construct a [`UserInfo`](crate::user_info::UserInfo) impl with name
+/// construct a [`UserInfo`] impl with name
 /// use default username `greptime` if None is provided
 pub fn userinfo_by_name(username: Option<String>) -> UserInfoRef {
     DefaultUserInfo::with_name(username.unwrap_or_else(|| DEFAULT_USERNAME.to_string()))

src/auth/src/error.rs

@@ -4,7 +4,7 @@
 // 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
+// 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,
@@ -14,12 +14,10 @@
 
 use common_error::ext::{BoxedError, ErrorExt};
 use common_error::status_code::StatusCode;
-use common_macro::stack_trace_debug;
 use snafu::{Location, Snafu};
 
-#[derive(Snafu)]
+#[derive(Debug, Snafu)]
 #[snafu(visibility(pub))]
-#[stack_trace_debug]
 pub enum Error {
     #[snafu(display("Invalid config value: {}, {}", value, msg))]
     InvalidConfig { value: String, msg: String },
@@ -30,14 +28,13 @@ pub enum Error {
     #[snafu(display("Internal state error: {}", msg))]
     InternalState { msg: String },
 
-    #[snafu(display("IO error"))]
+    #[snafu(display("IO error, source: {}", source))]
     Io {
-        #[snafu(source)]
-        error: std::io::Error,
+        source: std::io::Error,
         location: Location,
     },
 
-    #[snafu(display("Auth failed"))]
+    #[snafu(display("Auth failed, source: {}", source))]
     AuthBackend {
         location: Location,
         source: BoxedError,

src/auth/src/lib.rs

@@ -4,7 +4,7 @@
 // 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
+// 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,

src/auth/src/permission.rs

@@ -4,7 +4,7 @@
 // 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
+// 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,

src/auth/src/tests.rs

@@ -4,14 +4,13 @@
 // 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
+// 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.
-
 use secrecy::ExposeSecret;
 
 use crate::error::{

src/auth/src/user_info.rs

@@ -4,7 +4,7 @@
 // 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
+// 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,

src/auth/src/user_provider.rs

@@ -4,7 +4,7 @@
 // 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
+// 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,
@@ -22,15 +22,15 @@ use crate::UserInfoRef;
 pub trait UserProvider: Send + Sync {
     fn name(&self) -> &str;
 
-    /// Checks whether a user is valid and allowed to access the database.
+    /// [`authenticate`] checks whether a user is valid and allowed to access the database.
     async fn authenticate(&self, id: Identity<'_>, password: Password<'_>) -> Result<UserInfoRef>;
 
-    /// Checks whether a connection request
+    /// [`authorize`] checks whether a connection request
     /// from a certain user to a certain catalog/schema is legal.
-    /// This method should be called after [authenticate()](UserProvider::authenticate()).
+    /// This method should be called after [`authenticate`].
     async fn authorize(&self, catalog: &str, schema: &str, user_info: &UserInfoRef) -> Result<()>;
 
-    /// Combination of [authenticate()](UserProvider::authenticate()) and [authorize()](UserProvider::authorize()).
+    /// [`auth`] is a combination of [`authenticate`] and [`authorize`].
     /// In most cases it's preferred for both convenience and performance.
     async fn auth(
         &self,

src/auth/tests/mod.rs

@@ -4,7 +4,7 @@
 // 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
+// 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,

src/catalog/Cargo.toml

@@ -7,53 +7,46 @@ license.workspace = true
 [features]
 testing = []
 
-[lints]
-workspace = true
-
 [dependencies]
-api.workspace = true
+api = { workspace = true }
 arc-swap = "1.0"
-arrow.workspace = true
 arrow-schema.workspace = true
 async-stream.workspace = true
 async-trait = "0.1"
-common-catalog.workspace = true
-common-error.workspace = true
-common-grpc.workspace = true
-common-macro.workspace = true
-common-meta.workspace = true
-common-query.workspace = true
-common-recordbatch.workspace = true
-common-runtime.workspace = true
-common-telemetry.workspace = true
-common-time.workspace = true
-common-version.workspace = true
-dashmap.workspace = true
+common-catalog = { workspace = true }
+common-error = { workspace = true }
+common-grpc = { workspace = true }
+common-meta = { workspace = true }
+common-query = { workspace = true }
+common-recordbatch = { workspace = true }
+common-runtime = { workspace = true }
+common-telemetry = { workspace = true }
+common-time = { workspace = true }
+dashmap = "5.4"
 datafusion.workspace = true
-datatypes.workspace = true
+datatypes = { workspace = true }
 futures = "0.3"
 futures-util.workspace = true
-itertools.workspace = true
 lazy_static.workspace = true
-meta-client.workspace = true
-moka = { workspace = true, features = ["future", "sync"] }
+meta-client = { workspace = true }
+metrics.workspace = true
+moka = { version = "0.11", features = ["future"] }
 parking_lot = "0.12"
-partition.workspace = true
-paste = "1.0"
-prometheus.workspace = true
 regex.workspace = true
 serde.workspace = true
-serde_json.workspace = true
-session.workspace = true
-snafu.workspace = true
-store-api.workspace = true
-table.workspace = true
+serde_json = "1.0"
+session = { workspace = true }
+snafu = { version = "0.7", features = ["backtraces"] }
+store-api = { workspace = true }
+table = { workspace = true }
 tokio.workspace = true
 
 [dev-dependencies]
 catalog = { workspace = true, features = ["testing"] }
 chrono.workspace = true
-common-test-util.workspace = true
-log-store.workspace = true
-object-store.workspace = true
+common-test-util = { workspace = true }
+log-store = { workspace = true }
+mito = { workspace = true, features = ["test"] }
+object-store = { workspace = true }
+storage = { workspace = true }
 tokio.workspace = true

src/catalog/src/error.rs

@@ -17,56 +17,54 @@ use std::fmt::Debug;
 
 use common_error::ext::{BoxedError, ErrorExt};
 use common_error::status_code::StatusCode;
-use common_macro::stack_trace_debug;
 use datafusion::error::DataFusionError;
 use datatypes::prelude::ConcreteDataType;
 use snafu::{Location, Snafu};
-use table::metadata::TableId;
 use tokio::task::JoinError;
 
-#[derive(Snafu)]
+use crate::DeregisterTableRequest;
+
+#[derive(Debug, Snafu)]
 #[snafu(visibility(pub))]
-#[stack_trace_debug]
 pub enum Error {
-    #[snafu(display("Failed to list catalogs"))]
+    #[snafu(display("Failed to list catalogs, source: {}", source))]
     ListCatalogs {
         location: Location,
         source: BoxedError,
     },
 
-    #[snafu(display("Failed to list {}'s schemas", catalog))]
+    #[snafu(display("Failed to list {}'s schemas, source: {}", catalog, source))]
     ListSchemas {
         location: Location,
         catalog: String,
         source: BoxedError,
     },
 
-    #[snafu(display("Failed to list {}.{}'s tables", catalog, schema))]
-    ListTables {
-        location: Location,
-        catalog: String,
-        schema: String,
-        source: BoxedError,
-    },
-
-    #[snafu(display("Failed to re-compile script due to internal error"))]
+    #[snafu(display(
+        "Failed to re-compile script due to internal error, source: {}",
+        source
+    ))]
     CompileScriptInternal {
         location: Location,
         source: BoxedError,
     },
-    #[snafu(display("Failed to open system catalog table"))]
+    #[snafu(display("Failed to open system catalog table, source: {}", source))]
     OpenSystemCatalog {
         location: Location,
         source: table::error::Error,
     },
 
-    #[snafu(display("Failed to create system catalog table"))]
+    #[snafu(display("Failed to create system catalog table, source: {}", source))]
     CreateSystemCatalog {
         location: Location,
         source: table::error::Error,
     },
 
-    #[snafu(display("Failed to create table, table info: {}", table_info))]
+    #[snafu(display(
+        "Failed to create table, table info: {}, source: {}",
+        table_info,
+        source
+    ))]
     CreateTable {
         table_info: String,
         location: Location,
@@ -100,14 +98,13 @@ pub enum Error {
     #[snafu(display("Catalog value is not present"))]
     EmptyValue { location: Location },
 
-    #[snafu(display("Failed to deserialize value"))]
+    #[snafu(display("Failed to deserialize value, source: {}", source))]
     ValueDeserialize {
-        #[snafu(source)]
-        error: serde_json::error::Error,
+        source: serde_json::error::Error,
         location: Location,
     },
 
-    #[snafu(display("Table engine not found: {}", engine_name))]
+    #[snafu(display("Table engine not found: {}, source: {}", engine_name, source))]
     TableEngineNotFound {
         engine_name: String,
         location: Location,
@@ -145,18 +142,15 @@ pub enum Error {
     #[snafu(display("Operation {} not supported", op))]
     NotSupported { op: String, location: Location },
 
-    #[snafu(display("Failed to open table {table_id}"))]
+    #[snafu(display("Failed to open table, table info: {}, source: {}", table_info, source))]
     OpenTable {
-        table_id: TableId,
+        table_info: String,
         location: Location,
         source: table::error::Error,
     },
 
-    #[snafu(display("Failed to open table in parallel"))]
-    ParallelOpenTable {
-        #[snafu(source)]
-        error: JoinError,
-    },
+    #[snafu(display("Failed to open table in parallel, source: {}", source))]
+    ParallelOpenTable { source: JoinError },
 
     #[snafu(display("Table not found while opening table, table info: {}", table_info))]
     TableNotFound {
@@ -164,64 +158,78 @@ pub enum Error {
         location: Location,
     },
 
-    #[snafu(display("Failed to find table partitions"))]
-    FindPartitions { source: partition::error::Error },
-
-    #[snafu(display("Failed to find region routes"))]
-    FindRegionRoutes { source: partition::error::Error },
-
     #[snafu(display("Failed to read system catalog table records"))]
     ReadSystemCatalog {
         location: Location,
         source: common_recordbatch::error::Error,
     },
 
-    #[snafu(display("Failed to create recordbatch"))]
+    #[snafu(display("Failed to create recordbatch, source: {}", source))]
     CreateRecordBatch {
         location: Location,
         source: common_recordbatch::error::Error,
     },
 
-    #[snafu(display("Failed to insert table creation record to system catalog"))]
+    #[snafu(display(
+        "Failed to insert table creation record to system catalog, source: {}",
+        source
+    ))]
     InsertCatalogRecord {
         location: Location,
         source: table::error::Error,
     },
 
-    #[snafu(display("Failed to scan system catalog table"))]
+    #[snafu(display(
+        "Failed to deregister table, request: {:?}, source: {}",
+        request,
+        source
+    ))]
+    DeregisterTable {
+        request: DeregisterTableRequest,
+        location: Location,
+        source: table::error::Error,
+    },
+
+    #[snafu(display("Illegal catalog manager state: {}", msg))]
+    IllegalManagerState { location: Location, msg: String },
+
+    #[snafu(display("Failed to scan system catalog table, source: {}", source))]
     SystemCatalogTableScan {
         location: Location,
         source: table::error::Error,
     },
 
-    #[snafu(display("Internal error"))]
+    #[snafu(display("{source}"))]
     Internal {
         location: Location,
         source: BoxedError,
     },
 
-    #[snafu(display("Failed to upgrade weak catalog manager reference"))]
+    #[snafu(display(
+        "Failed to upgrade weak catalog manager reference. location: {}",
+        location
+    ))]
     UpgradeWeakCatalogManagerRef { location: Location },
 
-    #[snafu(display("Failed to execute system catalog table scan"))]
+    #[snafu(display("Failed to execute system catalog table scan, source: {}", source))]
     SystemCatalogTableScanExec {
         location: Location,
         source: common_query::error::Error,
     },
 
-    #[snafu(display("Cannot parse catalog value"))]
+    #[snafu(display("Cannot parse catalog value, source: {}", source))]
     InvalidCatalogValue {
         location: Location,
         source: common_catalog::error::Error,
     },
 
-    #[snafu(display("Failed to perform metasrv operation"))]
+    #[snafu(display("Failed to perform metasrv operation, source: {}", source))]
     MetaSrv {
         location: Location,
         source: meta_client::error::Error,
     },
 
-    #[snafu(display("Invalid table info in catalog"))]
+    #[snafu(display("Invalid table info in catalog, source: {}", source))]
     InvalidTableInfoInCatalog {
         location: Location,
         source: datatypes::error::Error,
@@ -230,14 +238,17 @@ pub enum Error {
     #[snafu(display("Illegal access to catalog: {} and schema: {}", catalog, schema))]
     QueryAccessDenied { catalog: String, schema: String },
 
-    #[snafu(display("DataFusion error"))]
+    #[snafu(display("Invalid system table definition: {err_msg}"))]
+    InvalidSystemTableDef { err_msg: String, location: Location },
+
+    #[snafu(display("{}: {}", msg, source))]
     Datafusion {
-        #[snafu(source)]
-        error: DataFusionError,
+        msg: String,
+        source: DataFusionError,
         location: Location,
     },
 
-    #[snafu(display("Table schema mismatch"))]
+    #[snafu(display("Table schema mismatch, source: {}", source))]
     TableSchemaMismatch {
         location: Location,
         source: table::error::Error,
@@ -246,17 +257,11 @@ pub enum Error {
     #[snafu(display("A generic error has occurred, msg: {}", msg))]
     Generic { msg: String, location: Location },
 
-    #[snafu(display("Table metadata manager error"))]
+    #[snafu(display("Table metadata manager error: {}", source))]
     TableMetadataManager {
         source: common_meta::error::Error,
         location: Location,
     },
-
-    #[snafu(display("Get null from table cache, key: {}", key))]
-    TableCacheNotGet { key: String, location: Location },
-
-    #[snafu(display("Failed to get table cache, err: {}", err_msg))]
-    GetTableCache { err_msg: String },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -266,14 +271,13 @@ impl ErrorExt for Error {
         match self {
             Error::InvalidKey { .. }
             | Error::SchemaNotFound { .. }
+            | Error::TableNotFound { .. }
+            | Error::IllegalManagerState { .. }
             | Error::CatalogNotFound { .. }
-            | Error::FindPartitions { .. }
-            | Error::FindRegionRoutes { .. }
             | Error::InvalidEntryType { .. }
+            | Error::InvalidSystemTableDef { .. }
             | Error::ParallelOpenTable { .. } => StatusCode::Unexpected,
 
-            Error::TableNotFound { .. } => StatusCode::TableNotFound,
-
             Error::SystemCatalog { .. }
             | Error::EmptyValue { .. }
             | Error::ValueDeserialize { .. } => StatusCode::StorageUnavailable,
@@ -293,15 +297,16 @@ impl ErrorExt for Error {
                 StatusCode::InvalidArguments
             }
 
-            Error::ListCatalogs { source, .. }
-            | Error::ListSchemas { source, .. }
-            | Error::ListTables { source, .. } => source.status_code(),
+            Error::ListCatalogs { source, .. } | Error::ListSchemas { source, .. } => {
+                source.status_code()
+            }
 
             Error::OpenSystemCatalog { source, .. }
             | Error::CreateSystemCatalog { source, .. }
             | Error::InsertCatalogRecord { source, .. }
             | Error::OpenTable { source, .. }
             | Error::CreateTable { source, .. }
+            | Error::DeregisterTable { source, .. }
             | Error::TableSchemaMismatch { source, .. } => source.status_code(),
 
             Error::MetaSrv { source, .. } => source.status_code(),
@@ -317,7 +322,6 @@ impl ErrorExt for Error {
             Error::QueryAccessDenied { .. } => StatusCode::AccessDenied,
             Error::Datafusion { .. } => StatusCode::EngineExecuteQuery,
             Error::TableMetadataManager { source, .. } => source.status_code(),
-            Error::TableCacheNotGet { .. } | Error::GetTableCache { .. } => StatusCode::Internal,
         }
     }
 
@@ -357,7 +361,7 @@ mod tests {
         assert_eq!(
             StatusCode::StorageUnavailable,
             Error::SystemCatalog {
-                msg: String::default(),
+                msg: "".to_string(),
                 location: Location::generate(),
             }
             .status_code()

src/catalog/src/information_schema.rs

@@ -13,27 +13,16 @@
 // limitations under the License.
 
 mod columns;
-mod key_column_usage;
-mod memory_table;
-mod partitions;
-mod predicate;
-mod region_peers;
-mod runtime_metrics;
-pub mod schemata;
-mod table_names;
-pub mod tables;
+mod tables;
 
 use std::collections::HashMap;
 use std::sync::{Arc, Weak};
 
-use common_catalog::consts::{self, DEFAULT_CATALOG_NAME, INFORMATION_SCHEMA_NAME};
+use common_catalog::consts::INFORMATION_SCHEMA_NAME;
 use common_error::ext::BoxedError;
-use common_recordbatch::{RecordBatchStreamWrapper, SendableRecordBatchStream};
+use common_recordbatch::{RecordBatchStreamAdaptor, SendableRecordBatchStream};
 use datatypes::schema::SchemaRef;
 use futures_util::StreamExt;
-use lazy_static::lazy_static;
-use paste::paste;
-pub(crate) use predicate::Predicates;
 use snafu::ResultExt;
 use store_api::data_source::DataSource;
 use store_api::storage::{ScanRequest, TableId};
@@ -43,150 +32,46 @@ use table::metadata::{
 };
 use table::thin_table::{ThinTable, ThinTableAdapter};
 use table::TableRef;
-pub use table_names::*;
 
 use self::columns::InformationSchemaColumns;
 use crate::error::Result;
-use crate::information_schema::key_column_usage::InformationSchemaKeyColumnUsage;
-use crate::information_schema::memory_table::{get_schema_columns, MemoryTable};
-use crate::information_schema::partitions::InformationSchemaPartitions;
-use crate::information_schema::region_peers::InformationSchemaRegionPeers;
-use crate::information_schema::runtime_metrics::InformationSchemaMetrics;
-use crate::information_schema::schemata::InformationSchemaSchemata;
 use crate::information_schema::tables::InformationSchemaTables;
 use crate::CatalogManager;
 
-lazy_static! {
-    // Memory tables in `information_schema`.
-    static ref MEMORY_TABLES: &'static [&'static str] = &[
-        ENGINES,
-        COLUMN_PRIVILEGES,
-        COLUMN_STATISTICS,
-        CHARACTER_SETS,
-        COLLATIONS,
-        COLLATION_CHARACTER_SET_APPLICABILITY,
-        CHECK_CONSTRAINTS,
-        EVENTS,
-        FILES,
-        OPTIMIZER_TRACE,
-        PARAMETERS,
-        PROFILING,
-        REFERENTIAL_CONSTRAINTS,
-        ROUTINES,
-        SCHEMA_PRIVILEGES,
-        TABLE_PRIVILEGES,
-        TRIGGERS,
-        GLOBAL_STATUS,
-        SESSION_STATUS,
-        PARTITIONS,
-    ];
-}
+pub const TABLES: &str = "tables";
+pub const COLUMNS: &str = "columns";
 
-macro_rules! setup_memory_table {
-    ($name: expr) => {
-        paste! {
-            {
-                let (schema, columns) = get_schema_columns($name);
-                Some(Arc::new(MemoryTable::new(
-                    consts::[<INFORMATION_SCHEMA_ $name  _TABLE_ID>],
-                    $name,
-                    schema,
-                    columns
-                )) as _)
-            }
-        }
-    };
-}
-
-/// The `information_schema` tables info provider.
 pub struct InformationSchemaProvider {
     catalog_name: String,
     catalog_manager: Weak<dyn CatalogManager>,
-    tables: HashMap<String, TableRef>,
 }
 
 impl InformationSchemaProvider {
     pub fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
-        let mut provider = Self {
+        Self {
             catalog_name,
             catalog_manager,
-            tables: HashMap::new(),
-        };
-
-        provider.build_tables();
-
-        provider
+        }
     }
 
-    /// Returns table names in the order of table id.
-    pub fn table_names(&self) -> Vec<String> {
-        let mut tables = self.tables.values().clone().collect::<Vec<_>>();
+    /// Build a map of [TableRef] in information schema.
+    /// Including `tables` and `columns`.
+    pub fn build(
+        catalog_name: String,
+        catalog_manager: Weak<dyn CatalogManager>,
+    ) -> HashMap<String, TableRef> {
+        let provider = Self::new(catalog_name, catalog_manager);
 
-        tables.sort_by(|t1, t2| {
-            t1.table_info()
-                .table_id()
-                .partial_cmp(&t2.table_info().table_id())
-                .unwrap()
-        });
-        tables
-            .into_iter()
-            .map(|t| t.table_info().name.clone())
-            .collect()
+        let mut schema = HashMap::new();
+        schema.insert(TABLES.to_owned(), provider.table(TABLES).unwrap());
+        schema.insert(COLUMNS.to_owned(), provider.table(COLUMNS).unwrap());
+        schema
     }
 
-    /// Returns a map of [TableRef] in information schema.
-    pub fn tables(&self) -> &HashMap<String, TableRef> {
-        assert!(!self.tables.is_empty());
-
-        &self.tables
-    }
-
-    /// Returns the [TableRef] by table name.
     pub fn table(&self, name: &str) -> Option<TableRef> {
-        self.tables.get(name).cloned()
-    }
-
-    fn build_tables(&mut self) {
-        let mut tables = HashMap::new();
-
-        // Carefully consider the tables that may expose sensitive cluster configurations,
-        // authentication details, and other critical information.
-        // Only put these tables under `greptime` catalog to prevent info leak.
-        if self.catalog_name == DEFAULT_CATALOG_NAME {
-            tables.insert(
-                RUNTIME_METRICS.to_string(),
-                self.build_table(RUNTIME_METRICS).unwrap(),
-            );
-            tables.insert(
-                BUILD_INFO.to_string(),
-                self.build_table(BUILD_INFO).unwrap(),
-            );
-            tables.insert(
-                REGION_PEERS.to_string(),
-                self.build_table(REGION_PEERS).unwrap(),
-            );
-        }
-
-        tables.insert(TABLES.to_string(), self.build_table(TABLES).unwrap());
-        tables.insert(SCHEMATA.to_string(), self.build_table(SCHEMATA).unwrap());
-        tables.insert(COLUMNS.to_string(), self.build_table(COLUMNS).unwrap());
-        tables.insert(
-            KEY_COLUMN_USAGE.to_string(),
-            self.build_table(KEY_COLUMN_USAGE).unwrap(),
-        );
-
-        // Add memory tables
-        for name in MEMORY_TABLES.iter() {
-            tables.insert((*name).to_string(), self.build_table(name).expect(name));
-        }
-
-        self.tables = tables;
-    }
-
-    fn build_table(&self, name: &str) -> Option<TableRef> {
         self.information_table(name).map(|table| {
             let table_info = Self::table_info(self.catalog_name.clone(), &table);
-            let filter_pushdown = FilterPushDownType::Inexact;
+            let filter_pushdown = FilterPushDownType::Unsupported;
             let thin_table = ThinTable::new(table_info, filter_pushdown);
 
             let data_source = Arc::new(InformationTableDataSource::new(table));
@@ -204,45 +89,6 @@ impl InformationSchemaProvider {
                 self.catalog_name.clone(),
                 self.catalog_manager.clone(),
             )) as _),
-            ENGINES => setup_memory_table!(ENGINES),
-            COLUMN_PRIVILEGES => setup_memory_table!(COLUMN_PRIVILEGES),
-            COLUMN_STATISTICS => setup_memory_table!(COLUMN_STATISTICS),
-            BUILD_INFO => setup_memory_table!(BUILD_INFO),
-            CHARACTER_SETS => setup_memory_table!(CHARACTER_SETS),
-            COLLATIONS => setup_memory_table!(COLLATIONS),
-            COLLATION_CHARACTER_SET_APPLICABILITY => {
-                setup_memory_table!(COLLATION_CHARACTER_SET_APPLICABILITY)
-            }
-            CHECK_CONSTRAINTS => setup_memory_table!(CHECK_CONSTRAINTS),
-            EVENTS => setup_memory_table!(EVENTS),
-            FILES => setup_memory_table!(FILES),
-            OPTIMIZER_TRACE => setup_memory_table!(OPTIMIZER_TRACE),
-            PARAMETERS => setup_memory_table!(PARAMETERS),
-            PROFILING => setup_memory_table!(PROFILING),
-            REFERENTIAL_CONSTRAINTS => setup_memory_table!(REFERENTIAL_CONSTRAINTS),
-            ROUTINES => setup_memory_table!(ROUTINES),
-            SCHEMA_PRIVILEGES => setup_memory_table!(SCHEMA_PRIVILEGES),
-            TABLE_PRIVILEGES => setup_memory_table!(TABLE_PRIVILEGES),
-            TRIGGERS => setup_memory_table!(TRIGGERS),
-            GLOBAL_STATUS => setup_memory_table!(GLOBAL_STATUS),
-            SESSION_STATUS => setup_memory_table!(SESSION_STATUS),
-            KEY_COLUMN_USAGE => Some(Arc::new(InformationSchemaKeyColumnUsage::new(
-                self.catalog_name.clone(),
-                self.catalog_manager.clone(),
-            )) as _),
-            SCHEMATA => Some(Arc::new(InformationSchemaSchemata::new(
-                self.catalog_name.clone(),
-                self.catalog_manager.clone(),
-            )) as _),
-            RUNTIME_METRICS => Some(Arc::new(InformationSchemaMetrics::new())),
-            PARTITIONS => Some(Arc::new(InformationSchemaPartitions::new(
-                self.catalog_name.clone(),
-                self.catalog_manager.clone(),
-            )) as _),
-            REGION_PEERS => Some(Arc::new(InformationSchemaRegionPeers::new(
-                self.catalog_name.clone(),
-                self.catalog_manager.clone(),
-            )) as _),
             _ => None,
         }
     }
@@ -256,9 +102,9 @@ impl InformationSchemaProvider {
             .unwrap();
         let table_info = TableInfoBuilder::default()
             .table_id(table.table_id())
-            .name(table.table_name().to_string())
+            .name(table.table_name().to_owned())
             .catalog_name(catalog_name)
-            .schema_name(INFORMATION_SCHEMA_NAME.to_string())
+            .schema_name(INFORMATION_SCHEMA_NAME.to_owned())
             .meta(table_meta)
             .table_type(table.table_type())
             .build()
@@ -274,7 +120,7 @@ trait InformationTable {
 
     fn schema(&self) -> SchemaRef;
 
-    fn to_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream>;
+    fn to_stream(&self) -> Result<SendableRecordBatchStream>;
 
     fn table_type(&self) -> TableType {
         TableType::Temporary
@@ -308,7 +154,7 @@ impl DataSource for InformationTableDataSource {
         &self,
         request: ScanRequest,
     ) -> std::result::Result<SendableRecordBatchStream, BoxedError> {
-        let projection = request.projection.clone();
+        let projection = request.projection;
         let projected_schema = match &projection {
             Some(projection) => self.try_project(projection)?,
             None => self.table.schema(),
@@ -316,7 +162,7 @@ impl DataSource for InformationTableDataSource {
 
         let stream = self
             .table
-            .to_stream(request)
+            .to_stream()
             .map_err(BoxedError::new)
             .context(TablesRecordBatchSnafu)
             .map_err(BoxedError::new)?
@@ -325,13 +171,11 @@ impl DataSource for InformationTableDataSource {
                 None => batch,
             });
 
-        let stream = RecordBatchStreamWrapper {
+        let stream = RecordBatchStreamAdaptor {
             schema: projected_schema,
             stream: Box::pin(stream),
             output_ordering: None,
-            metrics: Default::default(),
         };
-
         Ok(Box::pin(stream))
     }
 }

src/catalog/src/information_schema/columns.rs

@@ -16,8 +16,8 @@ use std::sync::{Arc, Weak};
 
 use arrow_schema::SchemaRef as ArrowSchemaRef;
 use common_catalog::consts::{
-    INFORMATION_SCHEMA_COLUMNS_TABLE_ID, SEMANTIC_TYPE_FIELD, SEMANTIC_TYPE_PRIMARY_KEY,
-    SEMANTIC_TYPE_TIME_INDEX,
+    INFORMATION_SCHEMA_COLUMNS_TABLE_ID, INFORMATION_SCHEMA_NAME, SEMANTIC_TYPE_FIELD,
+    SEMANTIC_TYPE_PRIMARY_KEY, SEMANTIC_TYPE_TIME_INDEX,
 };
 use common_error::ext::BoxedError;
 use common_query::physical_plan::TaskContext;
@@ -29,17 +29,15 @@ use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatc
 use datatypes::prelude::{ConcreteDataType, DataType};
 use datatypes::scalars::ScalarVectorBuilder;
 use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::value::Value;
 use datatypes::vectors::{StringVectorBuilder, VectorRef};
-use futures::TryStreamExt;
 use snafu::{OptionExt, ResultExt};
-use store_api::storage::{ScanRequest, TableId};
+use store_api::storage::TableId;
 
-use super::{InformationTable, COLUMNS};
+use super::tables::InformationSchemaTables;
+use super::{InformationTable, COLUMNS, TABLES};
 use crate::error::{
     CreateRecordBatchSnafu, InternalSnafu, Result, UpgradeWeakCatalogManagerRefSnafu,
 };
-use crate::information_schema::Predicates;
 use crate::CatalogManager;
 
 pub(super) struct InformationSchemaColumns {
@@ -54,11 +52,6 @@ const TABLE_NAME: &str = "table_name";
 const COLUMN_NAME: &str = "column_name";
 const DATA_TYPE: &str = "data_type";
 const SEMANTIC_TYPE: &str = "semantic_type";
-const COLUMN_DEFAULT: &str = "column_default";
-const IS_NULLABLE: &str = "is_nullable";
-const COLUMN_TYPE: &str = "column_type";
-const COLUMN_COMMENT: &str = "column_comment";
-const INIT_CAPACITY: usize = 42;
 
 impl InformationSchemaColumns {
     pub(super) fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
@@ -77,10 +70,6 @@ impl InformationSchemaColumns {
             ColumnSchema::new(COLUMN_NAME, ConcreteDataType::string_datatype(), false),
             ColumnSchema::new(DATA_TYPE, ConcreteDataType::string_datatype(), false),
             ColumnSchema::new(SEMANTIC_TYPE, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(COLUMN_DEFAULT, ConcreteDataType::string_datatype(), true),
-            ColumnSchema::new(IS_NULLABLE, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(COLUMN_TYPE, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(COLUMN_COMMENT, ConcreteDataType::string_datatype(), true),
         ]))
     }
 
@@ -106,14 +95,14 @@ impl InformationTable for InformationSchemaColumns {
         self.schema.clone()
     }
 
-    fn to_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream> {
+    fn to_stream(&self) -> Result<SendableRecordBatchStream> {
         let schema = self.schema.arrow_schema().clone();
         let mut builder = self.builder();
         let stream = Box::pin(DfRecordBatchStreamAdapter::new(
             schema,
             futures::stream::once(async move {
                 builder
-                    .make_columns(Some(request))
+                    .make_tables()
                     .await
                     .map(|x| x.into_df_record_batch())
                     .map_err(Into::into)
@@ -138,11 +127,6 @@ struct InformationSchemaColumnsBuilder {
     column_names: StringVectorBuilder,
     data_types: StringVectorBuilder,
     semantic_types: StringVectorBuilder,
-
-    column_defaults: StringVectorBuilder,
-    is_nullables: StringVectorBuilder,
-    column_types: StringVectorBuilder,
-    column_comments: StringVectorBuilder,
 }
 
 impl InformationSchemaColumnsBuilder {
@@ -155,34 +139,55 @@ impl InformationSchemaColumnsBuilder {
             schema,
             catalog_name,
             catalog_manager,
-            catalog_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            schema_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            table_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            column_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            data_types: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            semantic_types: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            column_defaults: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            is_nullables: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            column_types: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            column_comments: StringVectorBuilder::with_capacity(INIT_CAPACITY),
+            catalog_names: StringVectorBuilder::with_capacity(42),
+            schema_names: StringVectorBuilder::with_capacity(42),
+            table_names: StringVectorBuilder::with_capacity(42),
+            column_names: StringVectorBuilder::with_capacity(42),
+            data_types: StringVectorBuilder::with_capacity(42),
+            semantic_types: StringVectorBuilder::with_capacity(42),
         }
     }
 
-    /// Construct the `information_schema.columns` virtual table
-    async fn make_columns(&mut self, request: Option<ScanRequest>) -> Result<RecordBatch> {
+    /// Construct the `information_schema.tables` virtual table
+    async fn make_tables(&mut self) -> Result<RecordBatch> {
         let catalog_name = self.catalog_name.clone();
         let catalog_manager = self
             .catalog_manager
             .upgrade()
             .context(UpgradeWeakCatalogManagerRefSnafu)?;
-        let predicates = Predicates::from_scan_request(&request);
 
         for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            let mut stream = catalog_manager.tables(&catalog_name, &schema_name).await;
-
-            while let Some(table) = stream.try_next().await? {
-                let keys = &table.table_info().meta.primary_key_indices;
-                let schema = table.schema();
+            if !catalog_manager
+                .schema_exist(&catalog_name, &schema_name)
+                .await?
+            {
+                continue;
+            }
+            for table_name in catalog_manager
+                .table_names(&catalog_name, &schema_name)
+                .await?
+            {
+                let (keys, schema) = if let Some(table) = catalog_manager
+                    .table(&catalog_name, &schema_name, &table_name)
+                    .await?
+                {
+                    let keys = &table.table_info().meta.primary_key_indices;
+                    let schema = table.schema();
+                    (keys.clone(), schema)
+                } else {
+                    // TODO: this specific branch is only a workaround for FrontendCatalogManager.
+                    if schema_name == INFORMATION_SCHEMA_NAME {
+                        if table_name == COLUMNS {
+                            (vec![], InformationSchemaColumns::schema())
+                        } else if table_name == TABLES {
+                            (vec![], InformationSchemaTables::schema())
+                        } else {
+                            continue;
+                        }
+                    } else {
+                        continue;
+                    }
+                };
 
                 for (idx, column) in schema.column_schemas().iter().enumerate() {
                     let semantic_type = if column.is_time_index() {
@@ -192,14 +197,13 @@ impl InformationSchemaColumnsBuilder {
                     } else {
                         SEMANTIC_TYPE_FIELD
                     };
-
                     self.add_column(
-                        &predicates,
                         &catalog_name,
                         &schema_name,
-                        &table.table_info().name,
+                        &table_name,
+                        &column.name,
+                        column.data_type.name(),
                         semantic_type,
-                        column,
                     );
                 }
             }
@@ -210,48 +214,19 @@ impl InformationSchemaColumnsBuilder {
 
     fn add_column(
         &mut self,
-        predicates: &Predicates,
         catalog_name: &str,
         schema_name: &str,
         table_name: &str,
+        column_name: &str,
+        data_type: &str,
         semantic_type: &str,
-        column_schema: &ColumnSchema,
     ) {
-        let data_type = &column_schema.data_type.name();
-
-        let row = [
-            (TABLE_CATALOG, &Value::from(catalog_name)),
-            (TABLE_SCHEMA, &Value::from(schema_name)),
-            (TABLE_NAME, &Value::from(table_name)),
-            (COLUMN_NAME, &Value::from(column_schema.name.as_str())),
-            (DATA_TYPE, &Value::from(data_type.as_str())),
-            (SEMANTIC_TYPE, &Value::from(semantic_type)),
-        ];
-
-        if !predicates.eval(&row) {
-            return;
-        }
-
         self.catalog_names.push(Some(catalog_name));
         self.schema_names.push(Some(schema_name));
         self.table_names.push(Some(table_name));
-        self.column_names.push(Some(&column_schema.name));
+        self.column_names.push(Some(column_name));
         self.data_types.push(Some(data_type));
         self.semantic_types.push(Some(semantic_type));
-        self.column_defaults.push(
-            column_schema
-                .default_constraint()
-                .map(|s| format!("{}", s))
-                .as_deref(),
-        );
-        if column_schema.is_nullable() {
-            self.is_nullables.push(Some("Yes"));
-        } else {
-            self.is_nullables.push(Some("No"));
-        }
-        self.column_types.push(Some(data_type));
-        self.column_comments
-            .push(column_schema.column_comment().map(|x| x.as_ref()));
     }
 
     fn finish(&mut self) -> Result<RecordBatch> {
@@ -262,12 +237,7 @@ impl InformationSchemaColumnsBuilder {
             Arc::new(self.column_names.finish()),
             Arc::new(self.data_types.finish()),
             Arc::new(self.semantic_types.finish()),
-            Arc::new(self.column_defaults.finish()),
-            Arc::new(self.is_nullables.finish()),
-            Arc::new(self.column_types.finish()),
-            Arc::new(self.column_comments.finish()),
         ];
-
         RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
     }
 }
@@ -284,7 +254,7 @@ impl DfPartitionStream for InformationSchemaColumns {
             schema,
             futures::stream::once(async move {
                 builder
-                    .make_columns(None)
+                    .make_tables()
                     .await
                     .map(|x| x.into_df_record_batch())
                     .map_err(Into::into)

src/catalog/src/information_schema/key_column_usage.rs

@@ -1,345 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-use std::sync::{Arc, Weak};
-
-use arrow_schema::SchemaRef as ArrowSchemaRef;
-use common_catalog::consts::INFORMATION_SCHEMA_KEY_COLUMN_USAGE_TABLE_ID;
-use common_error::ext::BoxedError;
-use common_query::physical_plan::TaskContext;
-use common_recordbatch::adapter::RecordBatchStreamAdapter;
-use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
-use datafusion::physical_plan::stream::RecordBatchStreamAdapter as DfRecordBatchStreamAdapter;
-use datafusion::physical_plan::streaming::PartitionStream as DfPartitionStream;
-use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatchStream;
-use datatypes::prelude::{ConcreteDataType, MutableVector, ScalarVectorBuilder, VectorRef};
-use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::value::Value;
-use datatypes::vectors::{ConstantVector, StringVector, StringVectorBuilder, UInt32VectorBuilder};
-use snafu::{OptionExt, ResultExt};
-use store_api::storage::{ScanRequest, TableId};
-
-use super::KEY_COLUMN_USAGE;
-use crate::error::{
-    CreateRecordBatchSnafu, InternalSnafu, Result, UpgradeWeakCatalogManagerRefSnafu,
-};
-use crate::information_schema::{InformationTable, Predicates};
-use crate::CatalogManager;
-
-const CONSTRAINT_SCHEMA: &str = "constraint_schema";
-const CONSTRAINT_NAME: &str = "constraint_name";
-const TABLE_CATALOG: &str = "table_catalog";
-const TABLE_SCHEMA: &str = "table_schema";
-const TABLE_NAME: &str = "table_name";
-const COLUMN_NAME: &str = "column_name";
-const ORDINAL_POSITION: &str = "ordinal_position";
-const INIT_CAPACITY: usize = 42;
-
-/// The virtual table implementation for `information_schema.KEY_COLUMN_USAGE`.
-pub(super) struct InformationSchemaKeyColumnUsage {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
-}
-
-impl InformationSchemaKeyColumnUsage {
-    pub(super) fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
-        Self {
-            schema: Self::schema(),
-            catalog_name,
-            catalog_manager,
-        }
-    }
-
-    pub(crate) fn schema() -> SchemaRef {
-        Arc::new(Schema::new(vec![
-            ColumnSchema::new(
-                "constraint_catalog",
-                ConcreteDataType::string_datatype(),
-                false,
-            ),
-            ColumnSchema::new(
-                CONSTRAINT_SCHEMA,
-                ConcreteDataType::string_datatype(),
-                false,
-            ),
-            ColumnSchema::new(CONSTRAINT_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_CATALOG, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_SCHEMA, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(COLUMN_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(ORDINAL_POSITION, ConcreteDataType::uint32_datatype(), false),
-            ColumnSchema::new(
-                "position_in_unique_constraint",
-                ConcreteDataType::uint32_datatype(),
-                true,
-            ),
-            ColumnSchema::new(
-                "referenced_table_schema",
-                ConcreteDataType::string_datatype(),
-                true,
-            ),
-            ColumnSchema::new(
-                "referenced_table_name",
-                ConcreteDataType::string_datatype(),
-                true,
-            ),
-            ColumnSchema::new(
-                "referenced_column_name",
-                ConcreteDataType::string_datatype(),
-                true,
-            ),
-        ]))
-    }
-
-    fn builder(&self) -> InformationSchemaKeyColumnUsageBuilder {
-        InformationSchemaKeyColumnUsageBuilder::new(
-            self.schema.clone(),
-            self.catalog_name.clone(),
-            self.catalog_manager.clone(),
-        )
-    }
-}
-
-impl InformationTable for InformationSchemaKeyColumnUsage {
-    fn table_id(&self) -> TableId {
-        INFORMATION_SCHEMA_KEY_COLUMN_USAGE_TABLE_ID
-    }
-
-    fn table_name(&self) -> &'static str {
-        KEY_COLUMN_USAGE
-    }
-
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    fn to_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream> {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        let stream = Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_key_column_usage(Some(request))
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ));
-        Ok(Box::pin(
-            RecordBatchStreamAdapter::try_new(stream)
-                .map_err(BoxedError::new)
-                .context(InternalSnafu)?,
-        ))
-    }
-}
-
-/// Builds the `information_schema.KEY_COLUMN_USAGE` table row by row
-///
-/// Columns are based on <https://dev.mysql.com/doc/refman/8.2/en/information-schema-key-column-usage-table.html>
-struct InformationSchemaKeyColumnUsageBuilder {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
-
-    constraint_catalog: StringVectorBuilder,
-    constraint_schema: StringVectorBuilder,
-    constraint_name: StringVectorBuilder,
-    table_catalog: StringVectorBuilder,
-    table_schema: StringVectorBuilder,
-    table_name: StringVectorBuilder,
-    column_name: StringVectorBuilder,
-    ordinal_position: UInt32VectorBuilder,
-    position_in_unique_constraint: UInt32VectorBuilder,
-}
-
-impl InformationSchemaKeyColumnUsageBuilder {
-    fn new(
-        schema: SchemaRef,
-        catalog_name: String,
-        catalog_manager: Weak<dyn CatalogManager>,
-    ) -> Self {
-        Self {
-            schema,
-            catalog_name,
-            catalog_manager,
-            constraint_catalog: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            constraint_schema: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            constraint_name: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            table_catalog: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            table_schema: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            table_name: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            column_name: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            ordinal_position: UInt32VectorBuilder::with_capacity(INIT_CAPACITY),
-            position_in_unique_constraint: UInt32VectorBuilder::with_capacity(INIT_CAPACITY),
-        }
-    }
-
-    /// Construct the `information_schema.KEY_COLUMN_USAGE` virtual table
-    async fn make_key_column_usage(&mut self, request: Option<ScanRequest>) -> Result<RecordBatch> {
-        let catalog_name = self.catalog_name.clone();
-        let catalog_manager = self
-            .catalog_manager
-            .upgrade()
-            .context(UpgradeWeakCatalogManagerRefSnafu)?;
-        let predicates = Predicates::from_scan_request(&request);
-
-        let mut primary_constraints = vec![];
-
-        for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            if !catalog_manager
-                .schema_exists(&catalog_name, &schema_name)
-                .await?
-            {
-                continue;
-            }
-
-            for table_name in catalog_manager
-                .table_names(&catalog_name, &schema_name)
-                .await?
-            {
-                if let Some(table) = catalog_manager
-                    .table(&catalog_name, &schema_name, &table_name)
-                    .await?
-                {
-                    let keys = &table.table_info().meta.primary_key_indices;
-                    let schema = table.schema();
-
-                    for (idx, column) in schema.column_schemas().iter().enumerate() {
-                        if column.is_time_index() {
-                            self.add_key_column_usage(
-                                &predicates,
-                                &schema_name,
-                                "TIME INDEX",
-                                &schema_name,
-                                &table_name,
-                                &column.name,
-                                1, //always 1 for time index
-                            );
-                        }
-                        if keys.contains(&idx) {
-                            primary_constraints.push((
-                                schema_name.clone(),
-                                table_name.clone(),
-                                column.name.clone(),
-                            ));
-                        }
-                        // TODO(dimbtp): foreign key constraint not supported yet
-                    }
-                } else {
-                    unreachable!();
-                }
-            }
-        }
-
-        for (i, (schema_name, table_name, column_name)) in
-            primary_constraints.into_iter().enumerate()
-        {
-            self.add_key_column_usage(
-                &predicates,
-                &schema_name,
-                "PRIMARY",
-                &schema_name,
-                &table_name,
-                &column_name,
-                i as u32 + 1,
-            );
-        }
-
-        self.finish()
-    }
-
-    // TODO(dimbtp): Foreign key constraint has not `None` value for last 4
-    // fields, but it is not supported yet.
-    #[allow(clippy::too_many_arguments)]
-    fn add_key_column_usage(
-        &mut self,
-        predicates: &Predicates,
-        constraint_schema: &str,
-        constraint_name: &str,
-        table_schema: &str,
-        table_name: &str,
-        column_name: &str,
-        ordinal_position: u32,
-    ) {
-        let row = [
-            (CONSTRAINT_SCHEMA, &Value::from(constraint_schema)),
-            (CONSTRAINT_NAME, &Value::from(constraint_name)),
-            (TABLE_SCHEMA, &Value::from(table_schema)),
-            (TABLE_NAME, &Value::from(table_name)),
-            (COLUMN_NAME, &Value::from(column_name)),
-            (ORDINAL_POSITION, &Value::from(ordinal_position)),
-        ];
-
-        if !predicates.eval(&row) {
-            return;
-        }
-
-        self.constraint_catalog.push(Some("def"));
-        self.constraint_schema.push(Some(constraint_schema));
-        self.constraint_name.push(Some(constraint_name));
-        self.table_catalog.push(Some("def"));
-        self.table_schema.push(Some(table_schema));
-        self.table_name.push(Some(table_name));
-        self.column_name.push(Some(column_name));
-        self.ordinal_position.push(Some(ordinal_position));
-        self.position_in_unique_constraint.push(None);
-    }
-
-    fn finish(&mut self) -> Result<RecordBatch> {
-        let rows_num = self.table_catalog.len();
-
-        let null_string_vector = Arc::new(ConstantVector::new(
-            Arc::new(StringVector::from(vec![None as Option<&str>])),
-            rows_num,
-        ));
-        let columns: Vec<VectorRef> = vec![
-            Arc::new(self.constraint_catalog.finish()),
-            Arc::new(self.constraint_schema.finish()),
-            Arc::new(self.constraint_name.finish()),
-            Arc::new(self.table_catalog.finish()),
-            Arc::new(self.table_schema.finish()),
-            Arc::new(self.table_name.finish()),
-            Arc::new(self.column_name.finish()),
-            Arc::new(self.ordinal_position.finish()),
-            Arc::new(self.position_in_unique_constraint.finish()),
-            null_string_vector.clone(),
-            null_string_vector.clone(),
-            null_string_vector,
-        ];
-        RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
-    }
-}
-
-impl DfPartitionStream for InformationSchemaKeyColumnUsage {
-    fn schema(&self) -> &ArrowSchemaRef {
-        self.schema.arrow_schema()
-    }
-
-    fn execute(&self, _: Arc<TaskContext>) -> DfSendableRecordBatchStream {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_key_column_usage(None)
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ))
-    }
-}

src/catalog/src/information_schema/memory_table.rs

@@ -1,214 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-mod tables;
-use std::sync::Arc;
-
-use arrow_schema::SchemaRef as ArrowSchemaRef;
-use common_error::ext::BoxedError;
-use common_query::physical_plan::TaskContext;
-use common_recordbatch::adapter::RecordBatchStreamAdapter;
-use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
-use datafusion::physical_plan::stream::RecordBatchStreamAdapter as DfRecordBatchStreamAdapter;
-use datafusion::physical_plan::streaming::PartitionStream as DfPartitionStream;
-use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatchStream;
-use datatypes::schema::SchemaRef;
-use datatypes::vectors::VectorRef;
-use snafu::ResultExt;
-use store_api::storage::{ScanRequest, TableId};
-pub use tables::get_schema_columns;
-
-use crate::error::{CreateRecordBatchSnafu, InternalSnafu, Result};
-use crate::information_schema::InformationTable;
-
-/// A memory table with specified schema and columns.
-pub(super) struct MemoryTable {
-    table_id: TableId,
-    table_name: &'static str,
-    schema: SchemaRef,
-    columns: Vec<VectorRef>,
-}
-
-impl MemoryTable {
-    /// Creates a memory table with table id, name, schema and columns.
-    pub(super) fn new(
-        table_id: TableId,
-        table_name: &'static str,
-        schema: SchemaRef,
-        columns: Vec<VectorRef>,
-    ) -> Self {
-        Self {
-            table_id,
-            table_name,
-            schema,
-            columns,
-        }
-    }
-
-    fn builder(&self) -> MemoryTableBuilder {
-        MemoryTableBuilder::new(self.schema.clone(), self.columns.clone())
-    }
-}
-
-impl InformationTable for MemoryTable {
-    fn table_id(&self) -> TableId {
-        self.table_id
-    }
-
-    fn table_name(&self) -> &'static str {
-        self.table_name
-    }
-
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    fn to_stream(&self, _request: ScanRequest) -> Result<SendableRecordBatchStream> {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        let stream = Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .memory_records()
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ));
-        Ok(Box::pin(
-            RecordBatchStreamAdapter::try_new(stream)
-                .map_err(BoxedError::new)
-                .context(InternalSnafu)?,
-        ))
-    }
-}
-
-struct MemoryTableBuilder {
-    schema: SchemaRef,
-    columns: Vec<VectorRef>,
-}
-
-impl MemoryTableBuilder {
-    fn new(schema: SchemaRef, columns: Vec<VectorRef>) -> Self {
-        Self { schema, columns }
-    }
-
-    /// Construct the `information_schema.{table_name}` virtual table
-    async fn memory_records(&mut self) -> Result<RecordBatch> {
-        if self.columns.is_empty() {
-            RecordBatch::new_empty(self.schema.clone()).context(CreateRecordBatchSnafu)
-        } else {
-            RecordBatch::new(self.schema.clone(), std::mem::take(&mut self.columns))
-                .context(CreateRecordBatchSnafu)
-        }
-    }
-}
-
-impl DfPartitionStream for MemoryTable {
-    fn schema(&self) -> &ArrowSchemaRef {
-        self.schema.arrow_schema()
-    }
-
-    fn execute(&self, _: Arc<TaskContext>) -> DfSendableRecordBatchStream {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .memory_records()
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use common_recordbatch::RecordBatches;
-    use datatypes::prelude::ConcreteDataType;
-    use datatypes::schema::{ColumnSchema, Schema};
-    use datatypes::vectors::StringVector;
-
-    use super::*;
-
-    #[tokio::test]
-    async fn test_memory_table() {
-        let schema = Arc::new(Schema::new(vec![
-            ColumnSchema::new("a", ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new("b", ConcreteDataType::string_datatype(), false),
-        ]));
-
-        let table = MemoryTable::new(
-            42,
-            "test",
-            schema.clone(),
-            vec![
-                Arc::new(StringVector::from(vec!["a1", "a2"])),
-                Arc::new(StringVector::from(vec!["b1", "b2"])),
-            ],
-        );
-
-        assert_eq!(42, table.table_id());
-        assert_eq!("test", table.table_name());
-        assert_eq!(schema, InformationTable::schema(&table));
-
-        let stream = table.to_stream(ScanRequest::default()).unwrap();
-
-        let batches = RecordBatches::try_collect(stream).await.unwrap();
-
-        assert_eq!(
-            "\
-+----+----+
-| a  | b  |
-+----+----+
-| a1 | b1 |
-| a2 | b2 |
-+----+----+",
-            batches.pretty_print().unwrap()
-        );
-    }
-
-    #[tokio::test]
-    async fn test_empty_memory_table() {
-        let schema = Arc::new(Schema::new(vec![
-            ColumnSchema::new("a", ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new("b", ConcreteDataType::string_datatype(), false),
-        ]));
-
-        let table = MemoryTable::new(42, "test", schema.clone(), vec![]);
-
-        assert_eq!(42, table.table_id());
-        assert_eq!("test", table.table_name());
-        assert_eq!(schema, InformationTable::schema(&table));
-
-        let stream = table.to_stream(ScanRequest::default()).unwrap();
-
-        let batches = RecordBatches::try_collect(stream).await.unwrap();
-
-        assert_eq!(
-            "\
-+---+---+
-| a | b |
-+---+---+
-+---+---+",
-            batches.pretty_print().unwrap()
-        );
-    }
-}

src/catalog/src/information_schema/memory_table/tables.rs

@@ -1,460 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-use std::sync::Arc;
-
-use common_catalog::consts::MITO_ENGINE;
-use datatypes::prelude::{ConcreteDataType, VectorRef};
-use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::vectors::{Int64Vector, StringVector};
-
-use crate::information_schema::table_names::*;
-
-/// Find the schema and columns by the table_name, only valid for memory tables.
-/// Safety: the user MUST ensure the table schema exists, panic otherwise.
-pub fn get_schema_columns(table_name: &str) -> (SchemaRef, Vec<VectorRef>) {
-    let (column_schemas, columns): (_, Vec<VectorRef>) = match table_name {
-        COLUMN_PRIVILEGES => (
-            string_columns(&[
-                "GRANTEE",
-                "TABLE_CATALOG",
-                "TABLE_SCHEMA",
-                "TABLE_NAME",
-                "COLUMN_NAME",
-                "PRIVILEGE_TYPE",
-                "IS_GRANTABLE",
-            ]),
-            vec![],
-        ),
-
-        COLUMN_STATISTICS => (
-            string_columns(&[
-                "SCHEMA_NAME",
-                "TABLE_NAME",
-                "COLUMN_NAME",
-                // TODO(dennis): It must be a JSON type, but we don't support it yet
-                "HISTOGRAM",
-            ]),
-            vec![],
-        ),
-
-        ENGINES => (
-            string_columns(&[
-                "ENGINE",
-                "SUPPORT",
-                "COMMENT",
-                "TRANSACTIONS",
-                "XA",
-                "SAVEPOINTS",
-            ]),
-            vec![
-                Arc::new(StringVector::from(vec![MITO_ENGINE])),
-                Arc::new(StringVector::from(vec!["DEFAULT"])),
-                Arc::new(StringVector::from(vec![
-                    "Storage engine for time-series data",
-                ])),
-                Arc::new(StringVector::from(vec!["NO"])),
-                Arc::new(StringVector::from(vec!["NO"])),
-                Arc::new(StringVector::from(vec!["NO"])),
-            ],
-        ),
-
-        BUILD_INFO => {
-            let build_info = common_version::build_info();
-            (
-                string_columns(&[
-                    "GIT_BRANCH",
-                    "GIT_COMMIT",
-                    "GIT_COMMIT_SHORT",
-                    "GIT_DIRTY",
-                    "PKG_VERSION",
-                ]),
-                vec![
-                    Arc::new(StringVector::from(vec![build_info.branch.to_string()])),
-                    Arc::new(StringVector::from(vec![build_info.commit.to_string()])),
-                    Arc::new(StringVector::from(vec![build_info
-                        .commit_short
-                        .to_string()])),
-                    Arc::new(StringVector::from(vec![build_info.dirty.to_string()])),
-                    Arc::new(StringVector::from(vec![build_info.version.to_string()])),
-                ],
-            )
-        }
-
-        CHARACTER_SETS => (
-            vec![
-                string_column("CHARACTER_SET_NAME"),
-                string_column("DEFAULT_COLLATE_NAME"),
-                string_column("DESCRIPTION"),
-                bigint_column("MAXLEN"),
-            ],
-            vec![
-                Arc::new(StringVector::from(vec!["utf8"])),
-                Arc::new(StringVector::from(vec!["utf8_bin"])),
-                Arc::new(StringVector::from(vec!["UTF-8 Unicode"])),
-                Arc::new(Int64Vector::from_slice([4])),
-            ],
-        ),
-
-        COLLATIONS => (
-            vec![
-                string_column("COLLATION_NAME"),
-                string_column("CHARACTER_SET_NAME"),
-                bigint_column("ID"),
-                string_column("IS_DEFAULT"),
-                string_column("IS_COMPILED"),
-                bigint_column("SORTLEN"),
-            ],
-            vec![
-                Arc::new(StringVector::from(vec!["utf8_bin"])),
-                Arc::new(StringVector::from(vec!["utf8"])),
-                Arc::new(Int64Vector::from_slice([1])),
-                Arc::new(StringVector::from(vec!["Yes"])),
-                Arc::new(StringVector::from(vec!["Yes"])),
-                Arc::new(Int64Vector::from_slice([1])),
-            ],
-        ),
-
-        COLLATION_CHARACTER_SET_APPLICABILITY => (
-            vec![
-                string_column("COLLATION_NAME"),
-                string_column("CHARACTER_SET_NAME"),
-            ],
-            vec![
-                Arc::new(StringVector::from(vec!["utf8_bin"])),
-                Arc::new(StringVector::from(vec!["utf8"])),
-            ],
-        ),
-
-        CHECK_CONSTRAINTS => (
-            string_columns(&[
-                "CONSTRAINT_CATALOG",
-                "CONSTRAINT_SCHEMA",
-                "CONSTRAINT_NAME",
-                "CHECK_CLAUSE",
-            ]),
-            // Not support check constraints yet
-            vec![],
-        ),
-
-        EVENTS => (
-            vec![
-                string_column("EVENT_CATALOG"),
-                string_column("EVENT_SCHEMA"),
-                string_column("EVENT_NAME"),
-                string_column("DEFINER"),
-                string_column("TIME_ZONE"),
-                string_column("EVENT_BODY"),
-                string_column("EVENT_DEFINITION"),
-                string_column("EVENT_TYPE"),
-                datetime_column("EXECUTE_AT"),
-                bigint_column("INTERVAL_VALUE"),
-                string_column("INTERVAL_FIELD"),
-                string_column("SQL_MODE"),
-                datetime_column("STARTS"),
-                datetime_column("ENDS"),
-                string_column("STATUS"),
-                string_column("ON_COMPLETION"),
-                datetime_column("CREATED"),
-                datetime_column("LAST_ALTERED"),
-                datetime_column("LAST_EXECUTED"),
-                string_column("EVENT_COMMENT"),
-                bigint_column("ORIGINATOR"),
-                string_column("CHARACTER_SET_CLIENT"),
-                string_column("COLLATION_CONNECTION"),
-                string_column("DATABASE_COLLATION"),
-            ],
-            vec![],
-        ),
-
-        FILES => (
-            vec![
-                bigint_column("FILE_ID"),
-                string_column("FILE_NAME"),
-                string_column("FILE_TYPE"),
-                string_column("TABLESPACE_NAME"),
-                string_column("TABLE_CATALOG"),
-                string_column("TABLE_SCHEMA"),
-                string_column("TABLE_NAME"),
-                string_column("LOGFILE_GROUP_NAME"),
-                bigint_column("LOGFILE_GROUP_NUMBER"),
-                string_column("ENGINE"),
-                string_column("FULLTEXT_KEYS"),
-                bigint_column("DELETED_ROWS"),
-                bigint_column("UPDATE_COUNT"),
-                bigint_column("FREE_EXTENTS"),
-                bigint_column("TOTAL_EXTENTS"),
-                bigint_column("EXTENT_SIZE"),
-                bigint_column("INITIAL_SIZE"),
-                bigint_column("MAXIMUM_SIZE"),
-                bigint_column("AUTOEXTEND_SIZE"),
-                datetime_column("CREATION_TIME"),
-                datetime_column("LAST_UPDATE_TIME"),
-                datetime_column("LAST_ACCESS_TIME"),
-                datetime_column("RECOVER_TIME"),
-                bigint_column("TRANSACTION_COUNTER"),
-                string_column("VERSION"),
-                string_column("ROW_FORMAT"),
-                bigint_column("TABLE_ROWS"),
-                bigint_column("AVG_ROW_LENGTH"),
-                bigint_column("DATA_LENGTH"),
-                bigint_column("MAX_DATA_LENGTH"),
-                bigint_column("INDEX_LENGTH"),
-                bigint_column("DATA_FREE"),
-                datetime_column("CREATE_TIME"),
-                datetime_column("UPDATE_TIME"),
-                datetime_column("CHECK_TIME"),
-                string_column("CHECKSUM"),
-                string_column("STATUS"),
-                string_column("EXTRA"),
-            ],
-            vec![],
-        ),
-
-        OPTIMIZER_TRACE => (
-            vec![
-                string_column("QUERY"),
-                string_column("TRACE"),
-                bigint_column("MISSING_BYTES_BEYOND_MAX_MEM_SIZE"),
-                bigint_column("INSUFFICIENT_PRIVILEGES"),
-            ],
-            vec![],
-        ),
-
-        // MySQL(https://dev.mysql.com/doc/refman/8.2/en/information-schema-parameters-table.html)
-        // has the spec that is different from
-        // PostgreSQL(https://www.postgresql.org/docs/current/infoschema-parameters.html).
-        // Follow `MySQL` spec here.
-        PARAMETERS => (
-            vec![
-                string_column("SPECIFIC_CATALOG"),
-                string_column("SPECIFIC_SCHEMA"),
-                string_column("SPECIFIC_NAME"),
-                bigint_column("ORDINAL_POSITION"),
-                string_column("PARAMETER_MODE"),
-                string_column("PARAMETER_NAME"),
-                string_column("DATA_TYPE"),
-                bigint_column("CHARACTER_MAXIMUM_LENGTH"),
-                bigint_column("CHARACTER_OCTET_LENGTH"),
-                bigint_column("NUMERIC_PRECISION"),
-                bigint_column("NUMERIC_SCALE"),
-                bigint_column("DATETIME_PRECISION"),
-                string_column("CHARACTER_SET_NAME"),
-                string_column("COLLATION_NAME"),
-                string_column("DTD_IDENTIFIER"),
-                string_column("ROUTINE_TYPE"),
-            ],
-            vec![],
-        ),
-
-        PROFILING => (
-            vec![
-                bigint_column("QUERY_ID"),
-                bigint_column("SEQ"),
-                string_column("STATE"),
-                bigint_column("DURATION"),
-                bigint_column("CPU_USER"),
-                bigint_column("CPU_SYSTEM"),
-                bigint_column("CONTEXT_VOLUNTARY"),
-                bigint_column("CONTEXT_INVOLUNTARY"),
-                bigint_column("BLOCK_OPS_IN"),
-                bigint_column("BLOCK_OPS_OUT"),
-                bigint_column("MESSAGES_SENT"),
-                bigint_column("MESSAGES_RECEIVED"),
-                bigint_column("PAGE_FAULTS_MAJOR"),
-                bigint_column("PAGE_FAULTS_MINOR"),
-                bigint_column("SWAPS"),
-                string_column("SOURCE_FUNCTION"),
-                string_column("SOURCE_FILE"),
-                bigint_column("SOURCE_LINE"),
-            ],
-            vec![],
-        ),
-
-        // TODO: _Must_ reimplement this table when foreign key constraint is supported.
-        REFERENTIAL_CONSTRAINTS => (
-            vec![
-                string_column("CONSTRAINT_CATALOG"),
-                string_column("CONSTRAINT_SCHEMA"),
-                string_column("CONSTRAINT_NAME"),
-                string_column("UNIQUE_CONSTRAINT_CATALOG"),
-                string_column("UNIQUE_CONSTRAINT_SCHEMA"),
-                string_column("UNIQUE_CONSTRAINT_NAME"),
-                string_column("MATCH_OPTION"),
-                string_column("UPDATE_RULE"),
-                string_column("DELETE_RULE"),
-                string_column("TABLE_NAME"),
-                string_column("REFERENCED_TABLE_NAME"),
-            ],
-            vec![],
-        ),
-
-        ROUTINES => (
-            vec![
-                string_column("SPECIFIC_NAME"),
-                string_column("ROUTINE_CATALOG"),
-                string_column("ROUTINE_SCHEMA"),
-                string_column("ROUTINE_NAME"),
-                string_column("ROUTINE_TYPE"),
-                string_column("DATA_TYPE"),
-                bigint_column("CHARACTER_MAXIMUM_LENGTH"),
-                bigint_column("CHARACTER_OCTET_LENGTH"),
-                bigint_column("NUMERIC_PRECISION"),
-                bigint_column("NUMERIC_SCALE"),
-                bigint_column("DATETIME_PRECISION"),
-                string_column("CHARACTER_SET_NAME"),
-                string_column("COLLATION_NAME"),
-                string_column("DTD_IDENTIFIER"),
-                string_column("ROUTINE_BODY"),
-                string_column("ROUTINE_DEFINITION"),
-                string_column("EXTERNAL_NAME"),
-                string_column("EXTERNAL_LANGUAGE"),
-                string_column("PARAMETER_STYLE"),
-                string_column("IS_DETERMINISTIC"),
-                string_column("SQL_DATA_ACCESS"),
-                string_column("SQL_PATH"),
-                string_column("SECURITY_TYPE"),
-                datetime_column("CREATED"),
-                datetime_column("LAST_ALTERED"),
-                string_column("SQL_MODE"),
-                string_column("ROUTINE_COMMENT"),
-                string_column("DEFINER"),
-                string_column("CHARACTER_SET_CLIENT"),
-                string_column("COLLATION_CONNECTION"),
-                string_column("DATABASE_COLLATION"),
-            ],
-            vec![],
-        ),
-
-        SCHEMA_PRIVILEGES => (
-            vec![
-                string_column("GRANTEE"),
-                string_column("TABLE_CATALOG"),
-                string_column("TABLE_SCHEMA"),
-                string_column("PRIVILEGE_TYPE"),
-                string_column("IS_GRANTABLE"),
-            ],
-            vec![],
-        ),
-
-        TABLE_PRIVILEGES => (
-            vec![
-                string_column("GRANTEE"),
-                string_column("TABLE_CATALOG"),
-                string_column("TABLE_SCHEMA"),
-                string_column("TABLE_NAME"),
-                string_column("PRIVILEGE_TYPE"),
-                string_column("IS_GRANTABLE"),
-            ],
-            vec![],
-        ),
-
-        TRIGGERS => (
-            vec![
-                string_column("TRIGGER_CATALOG"),
-                string_column("TRIGGER_SCHEMA"),
-                string_column("TRIGGER_NAME"),
-                string_column("EVENT_MANIPULATION"),
-                string_column("EVENT_OBJECT_CATALOG"),
-                string_column("EVENT_OBJECT_SCHEMA"),
-                string_column("EVENT_OBJECT_TABLE"),
-                bigint_column("ACTION_ORDER"),
-                string_column("ACTION_CONDITION"),
-                string_column("ACTION_STATEMENT"),
-                string_column("ACTION_ORIENTATION"),
-                string_column("ACTION_TIMING"),
-                string_column("ACTION_REFERENCE_OLD_TABLE"),
-                string_column("ACTION_REFERENCE_NEW_TABLE"),
-                string_column("ACTION_REFERENCE_OLD_ROW"),
-                string_column("ACTION_REFERENCE_NEW_ROW"),
-                datetime_column("CREATED"),
-                string_column("SQL_MODE"),
-                string_column("DEFINER"),
-                string_column("CHARACTER_SET_CLIENT"),
-                string_column("COLLATION_CONNECTION"),
-                string_column("DATABASE_COLLATION"),
-            ],
-            vec![],
-        ),
-
-        // TODO: Considering store internal metrics in `global_status` and
-        // `session_status` tables.
-        GLOBAL_STATUS => (
-            vec![
-                string_column("VARIABLE_NAME"),
-                string_column("VARIABLE_VALUE"),
-            ],
-            vec![],
-        ),
-
-        SESSION_STATUS => (
-            vec![
-                string_column("VARIABLE_NAME"),
-                string_column("VARIABLE_VALUE"),
-            ],
-            vec![],
-        ),
-
-        _ => unreachable!("Unknown table in information_schema: {}", table_name),
-    };
-
-    (Arc::new(Schema::new(column_schemas)), columns)
-}
-
-fn string_columns(names: &[&'static str]) -> Vec<ColumnSchema> {
-    names.iter().map(|name| string_column(name)).collect()
-}
-
-fn string_column(name: &str) -> ColumnSchema {
-    ColumnSchema::new(
-        str::to_lowercase(name),
-        ConcreteDataType::string_datatype(),
-        false,
-    )
-}
-
-fn bigint_column(name: &str) -> ColumnSchema {
-    ColumnSchema::new(
-        str::to_lowercase(name),
-        ConcreteDataType::int64_datatype(),
-        false,
-    )
-}
-
-fn datetime_column(name: &str) -> ColumnSchema {
-    ColumnSchema::new(
-        str::to_lowercase(name),
-        ConcreteDataType::datetime_datatype(),
-        false,
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_string_columns() {
-        let columns = ["a", "b", "c"];
-        let column_schemas = string_columns(&columns);
-
-        assert_eq!(3, column_schemas.len());
-        for (i, name) in columns.iter().enumerate() {
-            let cs = column_schemas.get(i).unwrap();
-
-            assert_eq!(*name, cs.name);
-            assert_eq!(ConcreteDataType::string_datatype(), cs.data_type);
-        }
-    }
-}

src/catalog/src/information_schema/partitions.rs

@@ -1,424 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-use core::pin::pin;
-use std::sync::{Arc, Weak};
-
-use arrow_schema::SchemaRef as ArrowSchemaRef;
-use common_catalog::consts::INFORMATION_SCHEMA_PARTITIONS_TABLE_ID;
-use common_error::ext::BoxedError;
-use common_query::physical_plan::TaskContext;
-use common_recordbatch::adapter::RecordBatchStreamAdapter;
-use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
-use common_time::datetime::DateTime;
-use datafusion::physical_plan::stream::RecordBatchStreamAdapter as DfRecordBatchStreamAdapter;
-use datafusion::physical_plan::streaming::PartitionStream as DfPartitionStream;
-use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatchStream;
-use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder, VectorRef};
-use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::value::Value;
-use datatypes::vectors::{
-    ConstantVector, DateTimeVector, DateTimeVectorBuilder, Int64Vector, Int64VectorBuilder,
-    MutableVector, StringVector, StringVectorBuilder, UInt64VectorBuilder,
-};
-use futures::{StreamExt, TryStreamExt};
-use partition::manager::PartitionInfo;
-use partition::partition::PartitionDef;
-use snafu::{OptionExt, ResultExt};
-use store_api::storage::{RegionId, ScanRequest, TableId};
-use table::metadata::{TableInfo, TableType};
-
-use super::PARTITIONS;
-use crate::error::{
-    CreateRecordBatchSnafu, FindPartitionsSnafu, InternalSnafu, Result,
-    UpgradeWeakCatalogManagerRefSnafu,
-};
-use crate::information_schema::{InformationTable, Predicates};
-use crate::kvbackend::KvBackendCatalogManager;
-use crate::CatalogManager;
-
-const TABLE_CATALOG: &str = "table_catalog";
-const TABLE_SCHEMA: &str = "table_schema";
-const TABLE_NAME: &str = "table_name";
-const PARTITION_NAME: &str = "partition_name";
-const PARTITION_EXPRESSION: &str = "partition_expression";
-/// The region id
-const GREPTIME_PARTITION_ID: &str = "greptime_partition_id";
-const INIT_CAPACITY: usize = 42;
-
-/// The `PARTITIONS` table provides information about partitioned tables.
-/// See https://dev.mysql.com/doc/refman/8.0/en/information-schema-partitions-table.html
-/// We provide an extral column `greptime_partition_id` for GreptimeDB region id.
-pub(super) struct InformationSchemaPartitions {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
-}
-
-impl InformationSchemaPartitions {
-    pub(super) fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
-        Self {
-            schema: Self::schema(),
-            catalog_name,
-            catalog_manager,
-        }
-    }
-
-    pub(crate) fn schema() -> SchemaRef {
-        Arc::new(Schema::new(vec![
-            ColumnSchema::new(TABLE_CATALOG, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_SCHEMA, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(PARTITION_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(
-                "subpartition_name",
-                ConcreteDataType::string_datatype(),
-                true,
-            ),
-            ColumnSchema::new(
-                "partition_ordinal_position",
-                ConcreteDataType::int64_datatype(),
-                true,
-            ),
-            ColumnSchema::new(
-                "subpartition_ordinal_position",
-                ConcreteDataType::int64_datatype(),
-                true,
-            ),
-            ColumnSchema::new(
-                "partition_method",
-                ConcreteDataType::string_datatype(),
-                true,
-            ),
-            ColumnSchema::new(
-                "subpartition_method",
-                ConcreteDataType::string_datatype(),
-                true,
-            ),
-            ColumnSchema::new(
-                PARTITION_EXPRESSION,
-                ConcreteDataType::string_datatype(),
-                true,
-            ),
-            ColumnSchema::new(
-                "subpartition_expression",
-                ConcreteDataType::string_datatype(),
-                true,
-            ),
-            ColumnSchema::new(
-                "partition_description",
-                ConcreteDataType::string_datatype(),
-                true,
-            ),
-            ColumnSchema::new("table_rows", ConcreteDataType::int64_datatype(), true),
-            ColumnSchema::new("avg_row_length", ConcreteDataType::int64_datatype(), true),
-            ColumnSchema::new("data_length", ConcreteDataType::int64_datatype(), true),
-            ColumnSchema::new("max_data_length", ConcreteDataType::int64_datatype(), true),
-            ColumnSchema::new("index_length", ConcreteDataType::int64_datatype(), true),
-            ColumnSchema::new("data_free", ConcreteDataType::int64_datatype(), true),
-            ColumnSchema::new("create_time", ConcreteDataType::datetime_datatype(), true),
-            ColumnSchema::new("update_time", ConcreteDataType::datetime_datatype(), true),
-            ColumnSchema::new("check_time", ConcreteDataType::datetime_datatype(), true),
-            ColumnSchema::new("checksum", ConcreteDataType::int64_datatype(), true),
-            ColumnSchema::new(
-                "partition_comment",
-                ConcreteDataType::string_datatype(),
-                true,
-            ),
-            ColumnSchema::new("nodegroup", ConcreteDataType::string_datatype(), true),
-            ColumnSchema::new("tablespace_name", ConcreteDataType::string_datatype(), true),
-            ColumnSchema::new(
-                GREPTIME_PARTITION_ID,
-                ConcreteDataType::uint64_datatype(),
-                true,
-            ),
-        ]))
-    }
-
-    fn builder(&self) -> InformationSchemaPartitionsBuilder {
-        InformationSchemaPartitionsBuilder::new(
-            self.schema.clone(),
-            self.catalog_name.clone(),
-            self.catalog_manager.clone(),
-        )
-    }
-}
-
-impl InformationTable for InformationSchemaPartitions {
-    fn table_id(&self) -> TableId {
-        INFORMATION_SCHEMA_PARTITIONS_TABLE_ID
-    }
-
-    fn table_name(&self) -> &'static str {
-        PARTITIONS
-    }
-
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    fn to_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream> {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        let stream = Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_partitions(Some(request))
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ));
-        Ok(Box::pin(
-            RecordBatchStreamAdapter::try_new(stream)
-                .map_err(BoxedError::new)
-                .context(InternalSnafu)?,
-        ))
-    }
-}
-
-struct InformationSchemaPartitionsBuilder {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
-
-    catalog_names: StringVectorBuilder,
-    schema_names: StringVectorBuilder,
-    table_names: StringVectorBuilder,
-    partition_names: StringVectorBuilder,
-    partition_ordinal_positions: Int64VectorBuilder,
-    partition_expressions: StringVectorBuilder,
-    create_times: DateTimeVectorBuilder,
-    partition_ids: UInt64VectorBuilder,
-}
-
-impl InformationSchemaPartitionsBuilder {
-    fn new(
-        schema: SchemaRef,
-        catalog_name: String,
-        catalog_manager: Weak<dyn CatalogManager>,
-    ) -> Self {
-        Self {
-            schema,
-            catalog_name,
-            catalog_manager,
-            catalog_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            schema_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            table_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            partition_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            partition_ordinal_positions: Int64VectorBuilder::with_capacity(INIT_CAPACITY),
-            partition_expressions: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            create_times: DateTimeVectorBuilder::with_capacity(INIT_CAPACITY),
-            partition_ids: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
-        }
-    }
-
-    /// Construct the `information_schema.partitions` virtual table
-    async fn make_partitions(&mut self, request: Option<ScanRequest>) -> Result<RecordBatch> {
-        let catalog_name = self.catalog_name.clone();
-        let catalog_manager = self
-            .catalog_manager
-            .upgrade()
-            .context(UpgradeWeakCatalogManagerRefSnafu)?;
-
-        let partition_manager = catalog_manager
-            .as_any()
-            .downcast_ref::<KvBackendCatalogManager>()
-            .map(|catalog_manager| catalog_manager.partition_manager());
-
-        let predicates = Predicates::from_scan_request(&request);
-
-        for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            let table_info_stream = catalog_manager
-                .tables(&catalog_name, &schema_name)
-                .await
-                .try_filter_map(|t| async move {
-                    let table_info = t.table_info();
-                    if table_info.table_type == TableType::Temporary {
-                        Ok(None)
-                    } else {
-                        Ok(Some(table_info))
-                    }
-                });
-
-            const BATCH_SIZE: usize = 128;
-
-            // Split table infos into chunks
-            let mut table_info_chunks = pin!(table_info_stream.ready_chunks(BATCH_SIZE));
-
-            while let Some(table_infos) = table_info_chunks.next().await {
-                let table_infos = table_infos.into_iter().collect::<Result<Vec<_>>>()?;
-                let table_ids: Vec<TableId> =
-                    table_infos.iter().map(|info| info.ident.table_id).collect();
-
-                let mut table_partitions = if let Some(partition_manager) = &partition_manager {
-                    partition_manager
-                        .batch_find_table_partitions(&table_ids)
-                        .await
-                        .context(FindPartitionsSnafu)?
-                } else {
-                    // Current node must be a standalone instance, contains only one partition by default.
-                    // TODO(dennis): change it when we support multi-regions for standalone.
-                    table_ids
-                        .into_iter()
-                        .map(|table_id| {
-                            (
-                                table_id,
-                                vec![PartitionInfo {
-                                    id: RegionId::new(table_id, 0),
-                                    partition: PartitionDef::new(vec![], vec![]),
-                                }],
-                            )
-                        })
-                        .collect()
-                };
-
-                for table_info in table_infos {
-                    let partitions = table_partitions
-                        .remove(&table_info.ident.table_id)
-                        .unwrap_or(vec![]);
-
-                    self.add_partitions(
-                        &predicates,
-                        &table_info,
-                        &catalog_name,
-                        &schema_name,
-                        &table_info.name,
-                        &partitions,
-                    );
-                }
-            }
-        }
-
-        self.finish()
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn add_partitions(
-        &mut self,
-        predicates: &Predicates,
-        table_info: &TableInfo,
-        catalog_name: &str,
-        schema_name: &str,
-        table_name: &str,
-        partitions: &[PartitionInfo],
-    ) {
-        let row = [
-            (TABLE_CATALOG, &Value::from(catalog_name)),
-            (TABLE_SCHEMA, &Value::from(schema_name)),
-            (TABLE_NAME, &Value::from(table_name)),
-        ];
-
-        if !predicates.eval(&row) {
-            return;
-        }
-
-        for (index, partition) in partitions.iter().enumerate() {
-            let partition_name = format!("p{index}");
-
-            self.catalog_names.push(Some(catalog_name));
-            self.schema_names.push(Some(schema_name));
-            self.table_names.push(Some(table_name));
-            self.partition_names.push(Some(&partition_name));
-            self.partition_ordinal_positions
-                .push(Some((index + 1) as i64));
-            let expressions = if partition.partition.partition_columns().is_empty() {
-                None
-            } else {
-                Some(partition.partition.to_string())
-            };
-
-            self.partition_expressions.push(expressions.as_deref());
-            self.create_times.push(Some(DateTime::from(
-                table_info.meta.created_on.timestamp_millis(),
-            )));
-            self.partition_ids.push(Some(partition.id.as_u64()));
-        }
-    }
-
-    fn finish(&mut self) -> Result<RecordBatch> {
-        let rows_num = self.catalog_names.len();
-
-        let null_string_vector = Arc::new(ConstantVector::new(
-            Arc::new(StringVector::from(vec![None as Option<&str>])),
-            rows_num,
-        ));
-        let null_i64_vector = Arc::new(ConstantVector::new(
-            Arc::new(Int64Vector::from(vec![None])),
-            rows_num,
-        ));
-        let null_datetime_vector = Arc::new(ConstantVector::new(
-            Arc::new(DateTimeVector::from(vec![None])),
-            rows_num,
-        ));
-        let partition_methods = Arc::new(ConstantVector::new(
-            Arc::new(StringVector::from(vec![Some("RANGE")])),
-            rows_num,
-        ));
-
-        let columns: Vec<VectorRef> = vec![
-            Arc::new(self.catalog_names.finish()),
-            Arc::new(self.schema_names.finish()),
-            Arc::new(self.table_names.finish()),
-            Arc::new(self.partition_names.finish()),
-            null_string_vector.clone(),
-            Arc::new(self.partition_ordinal_positions.finish()),
-            null_i64_vector.clone(),
-            partition_methods,
-            null_string_vector.clone(),
-            Arc::new(self.partition_expressions.finish()),
-            null_string_vector.clone(),
-            null_string_vector.clone(),
-            // TODO(dennis): rows and index statistics info
-            null_i64_vector.clone(),
-            null_i64_vector.clone(),
-            null_i64_vector.clone(),
-            null_i64_vector.clone(),
-            null_i64_vector.clone(),
-            null_i64_vector.clone(),
-            Arc::new(self.create_times.finish()),
-            // TODO(dennis): supports update_time
-            null_datetime_vector.clone(),
-            null_datetime_vector,
-            null_i64_vector,
-            null_string_vector.clone(),
-            null_string_vector.clone(),
-            null_string_vector,
-            Arc::new(self.partition_ids.finish()),
-        ];
-        RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
-    }
-}
-
-impl DfPartitionStream for InformationSchemaPartitions {
-    fn schema(&self) -> &ArrowSchemaRef {
-        self.schema.arrow_schema()
-    }
-
-    fn execute(&self, _: Arc<TaskContext>) -> DfSendableRecordBatchStream {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_partitions(None)
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ))
-    }
-}

src/catalog/src/information_schema/predicate.rs

@@ -1,609 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-use arrow::array::StringArray;
-use arrow::compute::kernels::comparison;
-use common_query::logical_plan::DfExpr;
-use datafusion::common::ScalarValue;
-use datafusion::logical_expr::expr::Like;
-use datafusion::logical_expr::Operator;
-use datatypes::value::Value;
-use store_api::storage::ScanRequest;
-
-type ColumnName = String;
-/// Predicate to filter `information_schema` tables stream,
-/// we only support these simple predicates currently.
-/// TODO(dennis): supports more predicate types.
-#[derive(Clone, PartialEq, Eq, Debug)]
-enum Predicate {
-    Eq(ColumnName, Value),
-    Like(ColumnName, String, bool),
-    NotEq(ColumnName, Value),
-    InList(ColumnName, Vec<Value>),
-    And(Box<Predicate>, Box<Predicate>),
-    Or(Box<Predicate>, Box<Predicate>),
-    Not(Box<Predicate>),
-}
-
-impl Predicate {
-    /// Evaluate the predicate with the row, returns:
-    /// - `None` when the predicate can't evaluate with the row.
-    /// - `Some(true)` when the predicate is satisfied,
-    /// - `Some(false)` when the predicate is not satisfied,
-    fn eval(&self, row: &[(&str, &Value)]) -> Option<bool> {
-        match self {
-            Predicate::Eq(c, v) => {
-                for (column, value) in row {
-                    if c != column {
-                        continue;
-                    }
-                    return Some(v == *value);
-                }
-            }
-            Predicate::Like(c, pattern, case_insensitive) => {
-                for (column, value) in row {
-                    if c != column {
-                        continue;
-                    }
-
-                    let Value::String(bs) = value else {
-                        continue;
-                    };
-
-                    return like_utf8(bs.as_utf8(), pattern, case_insensitive);
-                }
-            }
-            Predicate::NotEq(c, v) => {
-                for (column, value) in row {
-                    if c != column {
-                        continue;
-                    }
-                    return Some(v != *value);
-                }
-            }
-            Predicate::InList(c, values) => {
-                for (column, value) in row {
-                    if c != column {
-                        continue;
-                    }
-                    return Some(values.iter().any(|v| v == *value));
-                }
-            }
-            Predicate::And(left, right) => {
-                let left = left.eval(row);
-
-                // short-circuit
-                if matches!(left, Some(false)) {
-                    return Some(false);
-                }
-
-                return match (left, right.eval(row)) {
-                    (Some(left), Some(right)) => Some(left && right),
-                    (None, Some(false)) => Some(false),
-                    _ => None,
-                };
-            }
-            Predicate::Or(left, right) => {
-                let left = left.eval(row);
-
-                // short-circuit
-                if matches!(left, Some(true)) {
-                    return Some(true);
-                }
-
-                return match (left, right.eval(row)) {
-                    (Some(left), Some(right)) => Some(left || right),
-                    (None, Some(true)) => Some(true),
-                    _ => None,
-                };
-            }
-            Predicate::Not(p) => {
-                let Some(b) = p.eval(row) else {
-                    return None;
-                };
-
-                return Some(!b);
-            }
-        }
-
-        // Can't evaluate predicate with the row
-        None
-    }
-
-    /// Try to create a predicate from datafusion [`Expr`], return None if fails.
-    fn from_expr(expr: DfExpr) -> Option<Predicate> {
-        match expr {
-            // NOT expr
-            DfExpr::Not(expr) => {
-                let Some(p) = Self::from_expr(*expr) else {
-                    return None;
-                };
-
-                Some(Predicate::Not(Box::new(p)))
-            }
-            // expr LIKE pattern
-            DfExpr::Like(Like {
-                negated,
-                expr,
-                pattern,
-                case_insensitive,
-                ..
-            }) if is_column(&expr) && is_string_literal(&pattern) => {
-                // Safety: ensured by gurad
-                let DfExpr::Column(c) = *expr else {
-                    unreachable!();
-                };
-                let DfExpr::Literal(ScalarValue::Utf8(Some(pattern))) = *pattern else {
-                    unreachable!();
-                };
-
-                let p = Predicate::Like(c.name, pattern, case_insensitive);
-
-                if negated {
-                    Some(Predicate::Not(Box::new(p)))
-                } else {
-                    Some(p)
-                }
-            }
-            // left OP right
-            DfExpr::BinaryExpr(bin) => match (*bin.left, bin.op, *bin.right) {
-                // left == right
-                (DfExpr::Literal(scalar), Operator::Eq, DfExpr::Column(c))
-                | (DfExpr::Column(c), Operator::Eq, DfExpr::Literal(scalar)) => {
-                    let Ok(v) = Value::try_from(scalar) else {
-                        return None;
-                    };
-
-                    Some(Predicate::Eq(c.name, v))
-                }
-                // left != right
-                (DfExpr::Literal(scalar), Operator::NotEq, DfExpr::Column(c))
-                | (DfExpr::Column(c), Operator::NotEq, DfExpr::Literal(scalar)) => {
-                    let Ok(v) = Value::try_from(scalar) else {
-                        return None;
-                    };
-
-                    Some(Predicate::NotEq(c.name, v))
-                }
-                // left AND right
-                (left, Operator::And, right) => {
-                    let Some(left) = Self::from_expr(left) else {
-                        return None;
-                    };
-
-                    let Some(right) = Self::from_expr(right) else {
-                        return None;
-                    };
-
-                    Some(Predicate::And(Box::new(left), Box::new(right)))
-                }
-                // left OR right
-                (left, Operator::Or, right) => {
-                    let Some(left) = Self::from_expr(left) else {
-                        return None;
-                    };
-
-                    let Some(right) = Self::from_expr(right) else {
-                        return None;
-                    };
-
-                    Some(Predicate::Or(Box::new(left), Box::new(right)))
-                }
-                _ => None,
-            },
-            // [NOT] IN (LIST)
-            DfExpr::InList(list) => {
-                match (*list.expr, list.list, list.negated) {
-                    // column [NOT] IN (v1, v2, v3, ...)
-                    (DfExpr::Column(c), list, negated) if is_all_scalars(&list) => {
-                        let mut values = Vec::with_capacity(list.len());
-                        for scalar in list {
-                            // Safety: checked by `is_all_scalars`
-                            let DfExpr::Literal(scalar) = scalar else {
-                                unreachable!();
-                            };
-
-                            let Ok(value) = Value::try_from(scalar) else {
-                                return None;
-                            };
-
-                            values.push(value);
-                        }
-
-                        let predicate = Predicate::InList(c.name, values);
-
-                        if negated {
-                            Some(Predicate::Not(Box::new(predicate)))
-                        } else {
-                            Some(predicate)
-                        }
-                    }
-                    _ => None,
-                }
-            }
-            _ => None,
-        }
-    }
-}
-
-/// Perform SQL left LIKE right, return `None` if fail to evaluate.
-/// - `s` the target string
-/// - `pattern` the pattern just like '%abc'
-/// - `case_insensitive` whether to perform case-insensitive like or not.
-fn like_utf8(s: &str, pattern: &str, case_insensitive: &bool) -> Option<bool> {
-    let array = StringArray::from(vec![s]);
-    let patterns = StringArray::new_scalar(pattern);
-
-    let Ok(booleans) = (if *case_insensitive {
-        comparison::ilike(&array, &patterns)
-    } else {
-        comparison::like(&array, &patterns)
-    }) else {
-        return None;
-    };
-
-    // Safety: at least one value in result
-    Some(booleans.value(0))
-}
-
-fn is_string_literal(expr: &DfExpr) -> bool {
-    matches!(expr, DfExpr::Literal(ScalarValue::Utf8(Some(_))))
-}
-
-fn is_column(expr: &DfExpr) -> bool {
-    matches!(expr, DfExpr::Column(_))
-}
-
-/// A list of predicate
-pub struct Predicates {
-    predicates: Vec<Predicate>,
-}
-
-impl Predicates {
-    /// Try its best to create predicates from [`ScanRequest`].
-    pub fn from_scan_request(request: &Option<ScanRequest>) -> Predicates {
-        if let Some(request) = request {
-            let mut predicates = Vec::with_capacity(request.filters.len());
-
-            for filter in &request.filters {
-                if let Some(predicate) = Predicate::from_expr(filter.df_expr().clone()) {
-                    predicates.push(predicate);
-                }
-            }
-
-            Self { predicates }
-        } else {
-            Self {
-                predicates: Vec::new(),
-            }
-        }
-    }
-
-    /// Evaluate the predicates with the row.
-    /// returns true when all the predicates are satisfied or can't be evaluated.
-    pub fn eval(&self, row: &[(&str, &Value)]) -> bool {
-        // fast path
-        if self.predicates.is_empty() {
-            return true;
-        }
-
-        self.predicates
-            .iter()
-            .filter_map(|p| p.eval(row))
-            .all(|b| b)
-    }
-}
-
-/// Returns true when the values are all [`DfExpr::Literal`].
-fn is_all_scalars(list: &[DfExpr]) -> bool {
-    list.iter().all(|v| matches!(v, DfExpr::Literal(_)))
-}
-
-#[cfg(test)]
-mod tests {
-    use datafusion::common::{Column, ScalarValue};
-    use datafusion::logical_expr::expr::InList;
-    use datafusion::logical_expr::BinaryExpr;
-
-    use super::*;
-
-    #[test]
-    fn test_predicate_eval() {
-        let a_col = "a".to_string();
-        let b_col = "b".to_string();
-        let a_value = Value::from("a_value");
-        let b_value = Value::from("b_value");
-        let wrong_value = Value::from("wrong_value");
-
-        let a_row = [(a_col.as_str(), &a_value)];
-        let b_row = [("b", &wrong_value)];
-        let wrong_row = [(a_col.as_str(), &wrong_value)];
-
-        // Predicate::Eq
-        let p = Predicate::Eq(a_col.clone(), a_value.clone());
-        assert!(p.eval(&a_row).unwrap());
-        assert!(p.eval(&b_row).is_none());
-        assert!(!p.eval(&wrong_row).unwrap());
-
-        // Predicate::NotEq
-        let p = Predicate::NotEq(a_col.clone(), a_value.clone());
-        assert!(!p.eval(&a_row).unwrap());
-        assert!(p.eval(&b_row).is_none());
-        assert!(p.eval(&wrong_row).unwrap());
-
-        // Predicate::InList
-        let p = Predicate::InList(a_col.clone(), vec![a_value.clone(), b_value.clone()]);
-        assert!(p.eval(&a_row).unwrap());
-        assert!(p.eval(&b_row).is_none());
-        assert!(!p.eval(&wrong_row).unwrap());
-        assert!(p.eval(&[(&a_col, &b_value)]).unwrap());
-
-        let p1 = Predicate::Eq(a_col.clone(), a_value.clone());
-        let p2 = Predicate::Eq(b_col.clone(), b_value.clone());
-        let row = [(a_col.as_str(), &a_value), (b_col.as_str(), &b_value)];
-        let wrong_row = [(a_col.as_str(), &a_value), (b_col.as_str(), &wrong_value)];
-
-        //Predicate::And
-        let p = Predicate::And(Box::new(p1.clone()), Box::new(p2.clone()));
-        assert!(p.eval(&row).unwrap());
-        assert!(!p.eval(&wrong_row).unwrap());
-        assert!(p.eval(&[]).is_none());
-        assert!(p.eval(&[("c", &a_value)]).is_none());
-        assert!(!p
-            .eval(&[(a_col.as_str(), &b_value), (b_col.as_str(), &a_value)])
-            .unwrap());
-        assert!(!p
-            .eval(&[(a_col.as_str(), &b_value), (b_col.as_str(), &b_value)])
-            .unwrap());
-        assert!(p
-            .eval(&[(a_col.as_ref(), &a_value), ("c", &a_value)])
-            .is_none());
-        assert!(!p
-            .eval(&[(a_col.as_ref(), &b_value), ("c", &a_value)])
-            .unwrap());
-
-        //Predicate::Or
-        let p = Predicate::Or(Box::new(p1), Box::new(p2));
-        assert!(p.eval(&row).unwrap());
-        assert!(p.eval(&wrong_row).unwrap());
-        assert!(p.eval(&[]).is_none());
-        assert!(p.eval(&[("c", &a_value)]).is_none());
-        assert!(!p
-            .eval(&[(a_col.as_str(), &b_value), (b_col.as_str(), &a_value)])
-            .unwrap());
-        assert!(p
-            .eval(&[(a_col.as_str(), &b_value), (b_col.as_str(), &b_value)])
-            .unwrap());
-        assert!(p
-            .eval(&[(a_col.as_ref(), &a_value), ("c", &a_value)])
-            .unwrap());
-        assert!(p
-            .eval(&[(a_col.as_ref(), &b_value), ("c", &a_value)])
-            .is_none());
-    }
-
-    #[test]
-    fn test_predicate_like() {
-        // case insensitive
-        let expr = DfExpr::Like(Like {
-            negated: false,
-            expr: Box::new(column("a")),
-            pattern: Box::new(string_literal("%abc")),
-            case_insensitive: true,
-            escape_char: None,
-        });
-
-        let p = Predicate::from_expr(expr).unwrap();
-        assert!(
-            matches!(&p, Predicate::Like(c, pattern, case_insensitive) if
-                         c == "a"
-                         && pattern == "%abc"
-                         && *case_insensitive)
-        );
-
-        let match_row = [
-            ("a", &Value::from("hello AbC")),
-            ("b", &Value::from("b value")),
-        ];
-        let unmatch_row = [("a", &Value::from("bca")), ("b", &Value::from("b value"))];
-
-        assert!(p.eval(&match_row).unwrap());
-        assert!(!p.eval(&unmatch_row).unwrap());
-        assert!(p.eval(&[]).is_none());
-
-        // case sensitive
-        let expr = DfExpr::Like(Like {
-            negated: false,
-            expr: Box::new(column("a")),
-            pattern: Box::new(string_literal("%abc")),
-            case_insensitive: false,
-            escape_char: None,
-        });
-
-        let p = Predicate::from_expr(expr).unwrap();
-        assert!(
-            matches!(&p, Predicate::Like(c, pattern, case_insensitive) if
-                         c == "a"
-                         && pattern == "%abc"
-                         && !*case_insensitive)
-        );
-        assert!(!p.eval(&match_row).unwrap());
-        assert!(!p.eval(&unmatch_row).unwrap());
-        assert!(p.eval(&[]).is_none());
-
-        // not like
-        let expr = DfExpr::Like(Like {
-            negated: true,
-            expr: Box::new(column("a")),
-            pattern: Box::new(string_literal("%abc")),
-            case_insensitive: true,
-            escape_char: None,
-        });
-
-        let p = Predicate::from_expr(expr).unwrap();
-        assert!(!p.eval(&match_row).unwrap());
-        assert!(p.eval(&unmatch_row).unwrap());
-        assert!(p.eval(&[]).is_none());
-    }
-
-    fn column(name: &str) -> DfExpr {
-        DfExpr::Column(Column {
-            relation: None,
-            name: name.to_string(),
-        })
-    }
-
-    fn string_literal(v: &str) -> DfExpr {
-        DfExpr::Literal(ScalarValue::Utf8(Some(v.to_string())))
-    }
-
-    fn match_string_value(v: &Value, expected: &str) -> bool {
-        matches!(v, Value::String(bs) if bs.as_utf8() == expected)
-    }
-
-    fn match_string_values(vs: &[Value], expected: &[&str]) -> bool {
-        assert_eq!(vs.len(), expected.len());
-
-        let mut result = true;
-        for (i, v) in vs.iter().enumerate() {
-            result = result && match_string_value(v, expected[i]);
-        }
-
-        result
-    }
-
-    fn mock_exprs() -> (DfExpr, DfExpr) {
-        let expr1 = DfExpr::BinaryExpr(BinaryExpr {
-            left: Box::new(column("a")),
-            op: Operator::Eq,
-            right: Box::new(string_literal("a_value")),
-        });
-
-        let expr2 = DfExpr::BinaryExpr(BinaryExpr {
-            left: Box::new(column("b")),
-            op: Operator::NotEq,
-            right: Box::new(string_literal("b_value")),
-        });
-
-        (expr1, expr2)
-    }
-
-    #[test]
-    fn test_predicate_from_expr() {
-        let (expr1, expr2) = mock_exprs();
-
-        let p1 = Predicate::from_expr(expr1.clone()).unwrap();
-        assert!(matches!(&p1, Predicate::Eq(column, v) if column == "a"
-                         && match_string_value(v, "a_value")));
-
-        let p2 = Predicate::from_expr(expr2.clone()).unwrap();
-        assert!(matches!(&p2, Predicate::NotEq(column, v) if column == "b"
-                         && match_string_value(v, "b_value")));
-
-        let and_expr = DfExpr::BinaryExpr(BinaryExpr {
-            left: Box::new(expr1.clone()),
-            op: Operator::And,
-            right: Box::new(expr2.clone()),
-        });
-        let or_expr = DfExpr::BinaryExpr(BinaryExpr {
-            left: Box::new(expr1.clone()),
-            op: Operator::Or,
-            right: Box::new(expr2.clone()),
-        });
-        let not_expr = DfExpr::Not(Box::new(expr1.clone()));
-
-        let and_p = Predicate::from_expr(and_expr).unwrap();
-        assert!(matches!(and_p, Predicate::And(left, right) if *left == p1 && *right == p2));
-        let or_p = Predicate::from_expr(or_expr).unwrap();
-        assert!(matches!(or_p, Predicate::Or(left, right) if *left == p1 && *right == p2));
-        let not_p = Predicate::from_expr(not_expr).unwrap();
-        assert!(matches!(not_p, Predicate::Not(p) if *p == p1));
-
-        let inlist_expr = DfExpr::InList(InList {
-            expr: Box::new(column("a")),
-            list: vec![string_literal("a1"), string_literal("a2")],
-            negated: false,
-        });
-
-        let inlist_p = Predicate::from_expr(inlist_expr).unwrap();
-        assert!(matches!(&inlist_p, Predicate::InList(c, values) if c == "a"
-                         && match_string_values(values, &["a1", "a2"])));
-
-        let inlist_expr = DfExpr::InList(InList {
-            expr: Box::new(column("a")),
-            list: vec![string_literal("a1"), string_literal("a2")],
-            negated: true,
-        });
-        let inlist_p = Predicate::from_expr(inlist_expr).unwrap();
-        assert!(matches!(inlist_p, Predicate::Not(p) if
-                         matches!(&*p,
-                                  Predicate::InList(c, values) if c == "a"
-                                  && match_string_values(values, &["a1", "a2"]))));
-    }
-
-    #[test]
-    fn test_predicates_from_scan_request() {
-        let predicates = Predicates::from_scan_request(&None);
-        assert!(predicates.predicates.is_empty());
-
-        let (expr1, expr2) = mock_exprs();
-
-        let request = ScanRequest {
-            filters: vec![expr1.into(), expr2.into()],
-            ..Default::default()
-        };
-        let predicates = Predicates::from_scan_request(&Some(request));
-
-        assert_eq!(2, predicates.predicates.len());
-        assert!(
-            matches!(&predicates.predicates[0], Predicate::Eq(column, v) if column == "a"
-                     && match_string_value(v, "a_value"))
-        );
-        assert!(
-            matches!(&predicates.predicates[1], Predicate::NotEq(column, v) if column == "b"
-                     && match_string_value(v, "b_value"))
-        );
-    }
-
-    #[test]
-    fn test_predicates_eval_row() {
-        let wrong_row = [
-            ("a", &Value::from("a_value")),
-            ("b", &Value::from("b_value")),
-            ("c", &Value::from("c_value")),
-        ];
-        let row = [
-            ("a", &Value::from("a_value")),
-            ("b", &Value::from("not_b_value")),
-            ("c", &Value::from("c_value")),
-        ];
-        let c_row = [("c", &Value::from("c_value"))];
-
-        // test empty predicates, always returns true
-        let predicates = Predicates::from_scan_request(&None);
-        assert!(predicates.eval(&row));
-        assert!(predicates.eval(&wrong_row));
-        assert!(predicates.eval(&c_row));
-
-        let (expr1, expr2) = mock_exprs();
-        let request = ScanRequest {
-            filters: vec![expr1.into(), expr2.into()],
-            ..Default::default()
-        };
-        let predicates = Predicates::from_scan_request(&Some(request));
-        assert!(predicates.eval(&row));
-        assert!(!predicates.eval(&wrong_row));
-        assert!(predicates.eval(&c_row));
-    }
-}

src/catalog/src/information_schema/region_peers.rs

@@ -1,279 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-use core::pin::pin;
-use std::sync::{Arc, Weak};
-
-use arrow_schema::SchemaRef as ArrowSchemaRef;
-use common_catalog::consts::INFORMATION_SCHEMA_REGION_PEERS_TABLE_ID;
-use common_error::ext::BoxedError;
-use common_meta::rpc::router::RegionRoute;
-use common_query::physical_plan::TaskContext;
-use common_recordbatch::adapter::RecordBatchStreamAdapter;
-use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
-use datafusion::physical_plan::stream::RecordBatchStreamAdapter as DfRecordBatchStreamAdapter;
-use datafusion::physical_plan::streaming::PartitionStream as DfPartitionStream;
-use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatchStream;
-use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder, VectorRef};
-use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::value::Value;
-use datatypes::vectors::{Int64VectorBuilder, StringVectorBuilder, UInt64VectorBuilder};
-use futures::{StreamExt, TryStreamExt};
-use snafu::{OptionExt, ResultExt};
-use store_api::storage::{ScanRequest, TableId};
-use table::metadata::TableType;
-
-use super::REGION_PEERS;
-use crate::error::{
-    CreateRecordBatchSnafu, FindRegionRoutesSnafu, InternalSnafu, Result,
-    UpgradeWeakCatalogManagerRefSnafu,
-};
-use crate::information_schema::{InformationTable, Predicates};
-use crate::kvbackend::KvBackendCatalogManager;
-use crate::CatalogManager;
-
-const REGION_ID: &str = "region_id";
-const PEER_ID: &str = "peer_id";
-const PEER_ADDR: &str = "peer_addr";
-const IS_LEADER: &str = "is_leader";
-const STATUS: &str = "status";
-const DOWN_SECONDS: &str = "down_seconds";
-const INIT_CAPACITY: usize = 42;
-
-/// The `REGION_PEERS` table provides information about the region distribution and routes. Including fields:
-///
-/// - `region_id`: the region id
-/// - `peer_id`: the region storage datanode peer id
-/// - `peer_addr`: the region storage datanode peer address
-/// - `is_leader`: whether the peer is the leader
-/// - `status`: the region status, `ALIVE` or `DOWNGRADED`.
-/// - `down_seconds`: the duration of being offline, in seconds.
-///
-pub(super) struct InformationSchemaRegionPeers {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
-}
-
-impl InformationSchemaRegionPeers {
-    pub(super) fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
-        Self {
-            schema: Self::schema(),
-            catalog_name,
-            catalog_manager,
-        }
-    }
-
-    pub(crate) fn schema() -> SchemaRef {
-        Arc::new(Schema::new(vec![
-            ColumnSchema::new(REGION_ID, ConcreteDataType::uint64_datatype(), false),
-            ColumnSchema::new(PEER_ID, ConcreteDataType::uint64_datatype(), true),
-            ColumnSchema::new(PEER_ADDR, ConcreteDataType::string_datatype(), true),
-            ColumnSchema::new(IS_LEADER, ConcreteDataType::string_datatype(), true),
-            ColumnSchema::new(STATUS, ConcreteDataType::string_datatype(), true),
-            ColumnSchema::new(DOWN_SECONDS, ConcreteDataType::int64_datatype(), true),
-        ]))
-    }
-
-    fn builder(&self) -> InformationSchemaRegionPeersBuilder {
-        InformationSchemaRegionPeersBuilder::new(
-            self.schema.clone(),
-            self.catalog_name.clone(),
-            self.catalog_manager.clone(),
-        )
-    }
-}
-
-impl InformationTable for InformationSchemaRegionPeers {
-    fn table_id(&self) -> TableId {
-        INFORMATION_SCHEMA_REGION_PEERS_TABLE_ID
-    }
-
-    fn table_name(&self) -> &'static str {
-        REGION_PEERS
-    }
-
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    fn to_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream> {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        let stream = Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_region_peers(Some(request))
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ));
-        Ok(Box::pin(
-            RecordBatchStreamAdapter::try_new(stream)
-                .map_err(BoxedError::new)
-                .context(InternalSnafu)?,
-        ))
-    }
-}
-
-struct InformationSchemaRegionPeersBuilder {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
-
-    region_ids: UInt64VectorBuilder,
-    peer_ids: UInt64VectorBuilder,
-    peer_addrs: StringVectorBuilder,
-    is_leaders: StringVectorBuilder,
-    statuses: StringVectorBuilder,
-    down_seconds: Int64VectorBuilder,
-}
-
-impl InformationSchemaRegionPeersBuilder {
-    fn new(
-        schema: SchemaRef,
-        catalog_name: String,
-        catalog_manager: Weak<dyn CatalogManager>,
-    ) -> Self {
-        Self {
-            schema,
-            catalog_name,
-            catalog_manager,
-            region_ids: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
-            peer_ids: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
-            peer_addrs: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            is_leaders: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            statuses: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            down_seconds: Int64VectorBuilder::with_capacity(INIT_CAPACITY),
-        }
-    }
-
-    /// Construct the `information_schema.region_peers` virtual table
-    async fn make_region_peers(&mut self, request: Option<ScanRequest>) -> Result<RecordBatch> {
-        let catalog_name = self.catalog_name.clone();
-        let catalog_manager = self
-            .catalog_manager
-            .upgrade()
-            .context(UpgradeWeakCatalogManagerRefSnafu)?;
-
-        let partition_manager = catalog_manager
-            .as_any()
-            .downcast_ref::<KvBackendCatalogManager>()
-            .map(|catalog_manager| catalog_manager.partition_manager());
-
-        let predicates = Predicates::from_scan_request(&request);
-
-        for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            let table_id_stream = catalog_manager
-                .tables(&catalog_name, &schema_name)
-                .await
-                .try_filter_map(|t| async move {
-                    let table_info = t.table_info();
-                    if table_info.table_type == TableType::Temporary {
-                        Ok(None)
-                    } else {
-                        Ok(Some(table_info.ident.table_id))
-                    }
-                });
-
-            const BATCH_SIZE: usize = 128;
-
-            // Split table ids into chunks
-            let mut table_id_chunks = pin!(table_id_stream.ready_chunks(BATCH_SIZE));
-
-            while let Some(table_ids) = table_id_chunks.next().await {
-                let table_ids = table_ids.into_iter().collect::<Result<Vec<_>>>()?;
-
-                let table_routes = if let Some(partition_manager) = &partition_manager {
-                    partition_manager
-                        .batch_find_region_routes(&table_ids)
-                        .await
-                        .context(FindRegionRoutesSnafu)?
-                } else {
-                    table_ids.into_iter().map(|id| (id, vec![])).collect()
-                };
-
-                for routes in table_routes.values() {
-                    self.add_region_peers(&predicates, routes);
-                }
-            }
-        }
-
-        self.finish()
-    }
-
-    fn add_region_peers(&mut self, predicates: &Predicates, routes: &[RegionRoute]) {
-        for route in routes {
-            let region_id = route.region.id.as_u64();
-            let peer_id = route.leader_peer.clone().map(|p| p.id);
-            let peer_addr = route.leader_peer.clone().map(|p| p.addr);
-            let status = if let Some(status) = route.leader_status {
-                Some(status.as_ref().to_string())
-            } else {
-                // Alive by default
-                Some("ALIVE".to_string())
-            };
-
-            let row = [(REGION_ID, &Value::from(region_id))];
-
-            if !predicates.eval(&row) {
-                return;
-            }
-
-            // TODO(dennis): adds followers.
-            self.region_ids.push(Some(region_id));
-            self.peer_ids.push(peer_id);
-            self.peer_addrs.push(peer_addr.as_deref());
-            self.is_leaders.push(Some("Yes"));
-            self.statuses.push(status.as_deref());
-            self.down_seconds
-                .push(route.leader_down_millis().map(|m| m / 1000));
-        }
-    }
-
-    fn finish(&mut self) -> Result<RecordBatch> {
-        let columns: Vec<VectorRef> = vec![
-            Arc::new(self.region_ids.finish()),
-            Arc::new(self.peer_ids.finish()),
-            Arc::new(self.peer_addrs.finish()),
-            Arc::new(self.is_leaders.finish()),
-            Arc::new(self.statuses.finish()),
-            Arc::new(self.down_seconds.finish()),
-        ];
-        RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
-    }
-}
-
-impl DfPartitionStream for InformationSchemaRegionPeers {
-    fn schema(&self) -> &ArrowSchemaRef {
-        self.schema.arrow_schema()
-    }
-
-    fn execute(&self, _: Arc<TaskContext>) -> DfSendableRecordBatchStream {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_region_peers(None)
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ))
-    }
-}

src/catalog/src/information_schema/runtime_metrics.rs

@@ -1,250 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-use std::sync::Arc;
-
-use arrow_schema::SchemaRef as ArrowSchemaRef;
-use common_catalog::consts::INFORMATION_SCHEMA_RUNTIME_METRICS_TABLE_ID;
-use common_error::ext::BoxedError;
-use common_query::physical_plan::TaskContext;
-use common_recordbatch::adapter::RecordBatchStreamAdapter;
-use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
-use common_time::util::current_time_millis;
-use datafusion::physical_plan::stream::RecordBatchStreamAdapter as DfRecordBatchStreamAdapter;
-use datafusion::physical_plan::streaming::PartitionStream as DfPartitionStream;
-use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatchStream;
-use datatypes::prelude::{ConcreteDataType, MutableVector};
-use datatypes::scalars::ScalarVectorBuilder;
-use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::vectors::{
-    ConstantVector, Float64VectorBuilder, StringVector, StringVectorBuilder,
-    TimestampMillisecondVector, VectorRef,
-};
-use itertools::Itertools;
-use snafu::ResultExt;
-use store_api::storage::{ScanRequest, TableId};
-
-use super::{InformationTable, RUNTIME_METRICS};
-use crate::error::{CreateRecordBatchSnafu, InternalSnafu, Result};
-
-pub(super) struct InformationSchemaMetrics {
-    schema: SchemaRef,
-}
-
-const METRIC_NAME: &str = "metric_name";
-const METRIC_VALUE: &str = "value";
-const METRIC_LABELS: &str = "labels";
-const NODE: &str = "node";
-const NODE_TYPE: &str = "node_type";
-const TIMESTAMP: &str = "timestamp";
-
-/// The `information_schema.runtime_metrics` virtual table.
-/// It provides the GreptimeDB runtime metrics for the users by SQL.
-impl InformationSchemaMetrics {
-    pub(super) fn new() -> Self {
-        Self {
-            schema: Self::schema(),
-        }
-    }
-
-    fn schema() -> SchemaRef {
-        Arc::new(Schema::new(vec![
-            ColumnSchema::new(METRIC_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(METRIC_VALUE, ConcreteDataType::float64_datatype(), false),
-            ColumnSchema::new(METRIC_LABELS, ConcreteDataType::string_datatype(), true),
-            ColumnSchema::new(NODE, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(NODE_TYPE, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(
-                TIMESTAMP,
-                ConcreteDataType::timestamp_millisecond_datatype(),
-                false,
-            ),
-        ]))
-    }
-
-    fn builder(&self) -> InformationSchemaMetricsBuilder {
-        InformationSchemaMetricsBuilder::new(self.schema.clone())
-    }
-}
-
-impl InformationTable for InformationSchemaMetrics {
-    fn table_id(&self) -> TableId {
-        INFORMATION_SCHEMA_RUNTIME_METRICS_TABLE_ID
-    }
-
-    fn table_name(&self) -> &'static str {
-        RUNTIME_METRICS
-    }
-
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    fn to_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream> {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        let stream = Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_metrics(Some(request))
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ));
-        Ok(Box::pin(
-            RecordBatchStreamAdapter::try_new(stream)
-                .map_err(BoxedError::new)
-                .context(InternalSnafu)?,
-        ))
-    }
-}
-
-struct InformationSchemaMetricsBuilder {
-    schema: SchemaRef,
-
-    metric_names: StringVectorBuilder,
-    metric_values: Float64VectorBuilder,
-    metric_labels: StringVectorBuilder,
-}
-
-impl InformationSchemaMetricsBuilder {
-    fn new(schema: SchemaRef) -> Self {
-        Self {
-            schema,
-            metric_names: StringVectorBuilder::with_capacity(42),
-            metric_values: Float64VectorBuilder::with_capacity(42),
-            metric_labels: StringVectorBuilder::with_capacity(42),
-        }
-    }
-
-    fn add_metric(&mut self, metric_name: &str, labels: String, metric_value: f64) {
-        self.metric_names.push(Some(metric_name));
-        self.metric_values.push(Some(metric_value));
-        self.metric_labels.push(Some(&labels));
-    }
-
-    async fn make_metrics(&mut self, _request: Option<ScanRequest>) -> Result<RecordBatch> {
-        let metric_families = prometheus::gather();
-
-        let write_request =
-            common_telemetry::metric::convert_metric_to_write_request(metric_families, None, 0);
-
-        for ts in write_request.timeseries {
-            //Safety: always has `__name__` label
-            let metric_name = ts
-                .labels
-                .iter()
-                .find_map(|label| {
-                    if label.name == "__name__" {
-                        Some(label.value.clone())
-                    } else {
-                        None
-                    }
-                })
-                .unwrap();
-
-            self.add_metric(
-                &metric_name,
-                ts.labels
-                    .into_iter()
-                    .filter_map(|label| {
-                        if label.name == "__name__" {
-                            None
-                        } else {
-                            Some(format!("{}={}", label.name, label.value))
-                        }
-                    })
-                    .join(", "),
-                // Safety: always has a sample
-                ts.samples[0].value,
-            );
-        }
-
-        self.finish()
-    }
-
-    fn finish(&mut self) -> Result<RecordBatch> {
-        let rows_num = self.metric_names.len();
-        let unknowns = Arc::new(ConstantVector::new(
-            Arc::new(StringVector::from(vec!["unknown"])),
-            rows_num,
-        ));
-        let timestamps = Arc::new(ConstantVector::new(
-            Arc::new(TimestampMillisecondVector::from_slice([
-                current_time_millis(),
-            ])),
-            rows_num,
-        ));
-
-        let columns: Vec<VectorRef> = vec![
-            Arc::new(self.metric_names.finish()),
-            Arc::new(self.metric_values.finish()),
-            Arc::new(self.metric_labels.finish()),
-            // TODO(dennis): supports node and node_type for cluster
-            unknowns.clone(),
-            unknowns,
-            timestamps,
-        ];
-
-        RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
-    }
-}
-
-impl DfPartitionStream for InformationSchemaMetrics {
-    fn schema(&self) -> &ArrowSchemaRef {
-        self.schema.arrow_schema()
-    }
-
-    fn execute(&self, _: Arc<TaskContext>) -> DfSendableRecordBatchStream {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_metrics(None)
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use common_recordbatch::RecordBatches;
-
-    use super::*;
-
-    #[tokio::test]
-    async fn test_make_metrics() {
-        let metrics = InformationSchemaMetrics::new();
-
-        let stream = metrics.to_stream(ScanRequest::default()).unwrap();
-
-        let batches = RecordBatches::try_collect(stream).await.unwrap();
-
-        let result_literal = batches.pretty_print().unwrap();
-
-        assert!(result_literal.contains(METRIC_NAME));
-        assert!(result_literal.contains(METRIC_VALUE));
-        assert!(result_literal.contains(METRIC_LABELS));
-        assert!(result_literal.contains(NODE));
-        assert!(result_literal.contains(NODE_TYPE));
-        assert!(result_literal.contains(TIMESTAMP));
-    }
-}

src/catalog/src/information_schema/schemata.rs

@@ -1,222 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-use std::sync::{Arc, Weak};
-
-use arrow_schema::SchemaRef as ArrowSchemaRef;
-use common_catalog::consts::INFORMATION_SCHEMA_SCHEMATA_TABLE_ID;
-use common_error::ext::BoxedError;
-use common_query::physical_plan::TaskContext;
-use common_recordbatch::adapter::RecordBatchStreamAdapter;
-use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
-use datafusion::physical_plan::stream::RecordBatchStreamAdapter as DfRecordBatchStreamAdapter;
-use datafusion::physical_plan::streaming::PartitionStream as DfPartitionStream;
-use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatchStream;
-use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder, VectorRef};
-use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::value::Value;
-use datatypes::vectors::StringVectorBuilder;
-use snafu::{OptionExt, ResultExt};
-use store_api::storage::{ScanRequest, TableId};
-
-use super::SCHEMATA;
-use crate::error::{
-    CreateRecordBatchSnafu, InternalSnafu, Result, UpgradeWeakCatalogManagerRefSnafu,
-};
-use crate::information_schema::{InformationTable, Predicates};
-use crate::CatalogManager;
-
-pub const CATALOG_NAME: &str = "catalog_name";
-pub const SCHEMA_NAME: &str = "schema_name";
-const DEFAULT_CHARACTER_SET_NAME: &str = "default_character_set_name";
-const DEFAULT_COLLATION_NAME: &str = "default_collation_name";
-const INIT_CAPACITY: usize = 42;
-
-/// The `information_schema.schemata` table implementation.
-pub(super) struct InformationSchemaSchemata {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
-}
-
-impl InformationSchemaSchemata {
-    pub(super) fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
-        Self {
-            schema: Self::schema(),
-            catalog_name,
-            catalog_manager,
-        }
-    }
-
-    pub(crate) fn schema() -> SchemaRef {
-        Arc::new(Schema::new(vec![
-            ColumnSchema::new(CATALOG_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(SCHEMA_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(
-                DEFAULT_CHARACTER_SET_NAME,
-                ConcreteDataType::string_datatype(),
-                false,
-            ),
-            ColumnSchema::new(
-                DEFAULT_COLLATION_NAME,
-                ConcreteDataType::string_datatype(),
-                false,
-            ),
-            ColumnSchema::new("sql_path", ConcreteDataType::string_datatype(), true),
-        ]))
-    }
-
-    fn builder(&self) -> InformationSchemaSchemataBuilder {
-        InformationSchemaSchemataBuilder::new(
-            self.schema.clone(),
-            self.catalog_name.clone(),
-            self.catalog_manager.clone(),
-        )
-    }
-}
-
-impl InformationTable for InformationSchemaSchemata {
-    fn table_id(&self) -> TableId {
-        INFORMATION_SCHEMA_SCHEMATA_TABLE_ID
-    }
-
-    fn table_name(&self) -> &'static str {
-        SCHEMATA
-    }
-
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    fn to_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream> {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        let stream = Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_schemata(Some(request))
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ));
-        Ok(Box::pin(
-            RecordBatchStreamAdapter::try_new(stream)
-                .map_err(BoxedError::new)
-                .context(InternalSnafu)?,
-        ))
-    }
-}
-
-/// Builds the `information_schema.schemata` table row by row
-///
-/// Columns are based on <https://docs.pingcap.com/tidb/stable/information-schema-schemata>
-struct InformationSchemaSchemataBuilder {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
-
-    catalog_names: StringVectorBuilder,
-    schema_names: StringVectorBuilder,
-    charset_names: StringVectorBuilder,
-    collation_names: StringVectorBuilder,
-    sql_paths: StringVectorBuilder,
-}
-
-impl InformationSchemaSchemataBuilder {
-    fn new(
-        schema: SchemaRef,
-        catalog_name: String,
-        catalog_manager: Weak<dyn CatalogManager>,
-    ) -> Self {
-        Self {
-            schema,
-            catalog_name,
-            catalog_manager,
-            catalog_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            schema_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            charset_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            collation_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            sql_paths: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-        }
-    }
-
-    /// Construct the `information_schema.schemata` virtual table
-    async fn make_schemata(&mut self, request: Option<ScanRequest>) -> Result<RecordBatch> {
-        let catalog_name = self.catalog_name.clone();
-        let catalog_manager = self
-            .catalog_manager
-            .upgrade()
-            .context(UpgradeWeakCatalogManagerRefSnafu)?;
-        let predicates = Predicates::from_scan_request(&request);
-
-        for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            self.add_schema(&predicates, &catalog_name, &schema_name);
-        }
-
-        self.finish()
-    }
-
-    fn add_schema(&mut self, predicates: &Predicates, catalog_name: &str, schema_name: &str) {
-        let row = [
-            (CATALOG_NAME, &Value::from(catalog_name)),
-            (SCHEMA_NAME, &Value::from(schema_name)),
-            (DEFAULT_CHARACTER_SET_NAME, &Value::from("utf8")),
-            (DEFAULT_COLLATION_NAME, &Value::from("utf8_bin")),
-        ];
-
-        if !predicates.eval(&row) {
-            return;
-        }
-
-        self.catalog_names.push(Some(catalog_name));
-        self.schema_names.push(Some(schema_name));
-        self.charset_names.push(Some("utf8"));
-        self.collation_names.push(Some("utf8_bin"));
-        self.sql_paths.push(None);
-    }
-
-    fn finish(&mut self) -> Result<RecordBatch> {
-        let columns: Vec<VectorRef> = vec![
-            Arc::new(self.catalog_names.finish()),
-            Arc::new(self.schema_names.finish()),
-            Arc::new(self.charset_names.finish()),
-            Arc::new(self.collation_names.finish()),
-            Arc::new(self.sql_paths.finish()),
-        ];
-        RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
-    }
-}
-
-impl DfPartitionStream for InformationSchemaSchemata {
-    fn schema(&self) -> &ArrowSchemaRef {
-        self.schema.arrow_schema()
-    }
-
-    fn execute(&self, _: Arc<TaskContext>) -> DfSendableRecordBatchStream {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_schemata(None)
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ))
-    }
-}

src/catalog/src/information_schema/table_names.rs

@@ -1,43 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-/// All table names in `information_schema`.
-
-pub const TABLES: &str = "tables";
-pub const COLUMNS: &str = "columns";
-pub const ENGINES: &str = "engines";
-pub const COLUMN_PRIVILEGES: &str = "column_privileges";
-pub const COLUMN_STATISTICS: &str = "column_statistics";
-pub const BUILD_INFO: &str = "build_info";
-pub const CHARACTER_SETS: &str = "character_sets";
-pub const COLLATIONS: &str = "collations";
-pub const COLLATION_CHARACTER_SET_APPLICABILITY: &str = "collation_character_set_applicability";
-pub const CHECK_CONSTRAINTS: &str = "check_constraints";
-pub const EVENTS: &str = "events";
-pub const FILES: &str = "files";
-pub const SCHEMATA: &str = "schemata";
-pub const KEY_COLUMN_USAGE: &str = "key_column_usage";
-pub const OPTIMIZER_TRACE: &str = "optimizer_trace";
-pub const PARAMETERS: &str = "parameters";
-pub const PROFILING: &str = "profiling";
-pub const REFERENTIAL_CONSTRAINTS: &str = "referential_constraints";
-pub const ROUTINES: &str = "routines";
-pub const SCHEMA_PRIVILEGES: &str = "schema_privileges";
-pub const TABLE_PRIVILEGES: &str = "table_privileges";
-pub const TRIGGERS: &str = "triggers";
-pub const GLOBAL_STATUS: &str = "global_status";
-pub const SESSION_STATUS: &str = "session_status";
-pub const RUNTIME_METRICS: &str = "runtime_metrics";
-pub const PARTITIONS: &str = "partitions";
-pub const REGION_PEERS: &str = "greptime_region_peers";

src/catalog/src/information_schema/tables.rs

@@ -15,7 +15,10 @@
 use std::sync::{Arc, Weak};
 
 use arrow_schema::SchemaRef as ArrowSchemaRef;
-use common_catalog::consts::INFORMATION_SCHEMA_TABLES_TABLE_ID;
+use common_catalog::consts::{
+    INFORMATION_SCHEMA_COLUMNS_TABLE_ID, INFORMATION_SCHEMA_NAME,
+    INFORMATION_SCHEMA_TABLES_TABLE_ID,
+};
 use common_error::ext::BoxedError;
 use common_query::physical_plan::TaskContext;
 use common_recordbatch::adapter::RecordBatchStreamAdapter;
@@ -25,28 +28,18 @@ use datafusion::physical_plan::streaming::PartitionStream as DfPartitionStream;
 use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatchStream;
 use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder, VectorRef};
 use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::value::Value;
 use datatypes::vectors::{StringVectorBuilder, UInt32VectorBuilder};
-use futures::TryStreamExt;
 use snafu::{OptionExt, ResultExt};
-use store_api::storage::{ScanRequest, TableId};
+use store_api::storage::TableId;
 use table::metadata::TableType;
 
-use super::TABLES;
+use super::{COLUMNS, TABLES};
 use crate::error::{
     CreateRecordBatchSnafu, InternalSnafu, Result, UpgradeWeakCatalogManagerRefSnafu,
 };
-use crate::information_schema::{InformationTable, Predicates};
+use crate::information_schema::InformationTable;
 use crate::CatalogManager;
 
-pub const TABLE_CATALOG: &str = "table_catalog";
-pub const TABLE_SCHEMA: &str = "table_schema";
-pub const TABLE_NAME: &str = "table_name";
-pub const TABLE_TYPE: &str = "table_type";
-const TABLE_ID: &str = "table_id";
-const ENGINE: &str = "engine";
-const INIT_CAPACITY: usize = 42;
-
 pub(super) struct InformationSchemaTables {
     schema: SchemaRef,
     catalog_name: String,
@@ -64,12 +57,12 @@ impl InformationSchemaTables {
 
     pub(crate) fn schema() -> SchemaRef {
         Arc::new(Schema::new(vec![
-            ColumnSchema::new(TABLE_CATALOG, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_SCHEMA, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_TYPE, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_ID, ConcreteDataType::uint32_datatype(), true),
-            ColumnSchema::new(ENGINE, ConcreteDataType::string_datatype(), true),
+            ColumnSchema::new("table_catalog", ConcreteDataType::string_datatype(), false),
+            ColumnSchema::new("table_schema", ConcreteDataType::string_datatype(), false),
+            ColumnSchema::new("table_name", ConcreteDataType::string_datatype(), false),
+            ColumnSchema::new("table_type", ConcreteDataType::string_datatype(), false),
+            ColumnSchema::new("table_id", ConcreteDataType::uint32_datatype(), true),
+            ColumnSchema::new("engine", ConcreteDataType::string_datatype(), true),
         ]))
     }
 
@@ -95,14 +88,14 @@ impl InformationTable for InformationSchemaTables {
         self.schema.clone()
     }
 
-    fn to_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream> {
+    fn to_stream(&self) -> Result<SendableRecordBatchStream> {
         let schema = self.schema.arrow_schema().clone();
         let mut builder = self.builder();
         let stream = Box::pin(DfRecordBatchStreamAdapter::new(
             schema,
             futures::stream::once(async move {
                 builder
-                    .make_tables(Some(request))
+                    .make_tables()
                     .await
                     .map(|x| x.into_df_record_batch())
                     .map_err(Into::into)
@@ -142,48 +135,80 @@ impl InformationSchemaTablesBuilder {
             schema,
             catalog_name,
             catalog_manager,
-            catalog_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            schema_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            table_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            table_types: StringVectorBuilder::with_capacity(INIT_CAPACITY),
-            table_ids: UInt32VectorBuilder::with_capacity(INIT_CAPACITY),
-            engines: StringVectorBuilder::with_capacity(INIT_CAPACITY),
+            catalog_names: StringVectorBuilder::with_capacity(42),
+            schema_names: StringVectorBuilder::with_capacity(42),
+            table_names: StringVectorBuilder::with_capacity(42),
+            table_types: StringVectorBuilder::with_capacity(42),
+            table_ids: UInt32VectorBuilder::with_capacity(42),
+            engines: StringVectorBuilder::with_capacity(42),
         }
     }
 
     /// Construct the `information_schema.tables` virtual table
-    async fn make_tables(&mut self, request: Option<ScanRequest>) -> Result<RecordBatch> {
+    async fn make_tables(&mut self) -> Result<RecordBatch> {
         let catalog_name = self.catalog_name.clone();
         let catalog_manager = self
             .catalog_manager
             .upgrade()
             .context(UpgradeWeakCatalogManagerRefSnafu)?;
-        let predicates = Predicates::from_scan_request(&request);
 
         for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            let mut stream = catalog_manager.tables(&catalog_name, &schema_name).await;
+            if !catalog_manager
+                .schema_exist(&catalog_name, &schema_name)
+                .await?
+            {
+                continue;
+            }
 
-            while let Some(table) = stream.try_next().await? {
-                let table_info = table.table_info();
-                self.add_table(
-                    &predicates,
-                    &catalog_name,
-                    &schema_name,
-                    &table_info.name,
-                    table.table_type(),
-                    Some(table_info.ident.table_id),
-                    Some(&table_info.meta.engine),
-                );
+            for table_name in catalog_manager
+                .table_names(&catalog_name, &schema_name)
+                .await?
+            {
+                if let Some(table) = catalog_manager
+                    .table(&catalog_name, &schema_name, &table_name)
+                    .await?
+                {
+                    let table_info = table.table_info();
+                    self.add_table(
+                        &catalog_name,
+                        &schema_name,
+                        &table_name,
+                        table.table_type(),
+                        Some(table_info.ident.table_id),
+                        Some(&table_info.meta.engine),
+                    );
+                } else {
+                    // TODO: this specific branch is only a workaround for FrontendCatalogManager.
+                    if schema_name == INFORMATION_SCHEMA_NAME {
+                        if table_name == COLUMNS {
+                            self.add_table(
+                                &catalog_name,
+                                &schema_name,
+                                &table_name,
+                                TableType::Temporary,
+                                Some(INFORMATION_SCHEMA_COLUMNS_TABLE_ID),
+                                None,
+                            );
+                        } else if table_name == TABLES {
+                            self.add_table(
+                                &catalog_name,
+                                &schema_name,
+                                &table_name,
+                                TableType::Temporary,
+                                Some(INFORMATION_SCHEMA_TABLES_TABLE_ID),
+                                None,
+                            );
+                        }
+                    }
+                };
             }
         }
 
         self.finish()
     }
 
-    #[allow(clippy::too_many_arguments)]
     fn add_table(
         &mut self,
-        predicates: &Predicates,
         catalog_name: &str,
         schema_name: &str,
         table_name: &str,
@@ -191,27 +216,14 @@ impl InformationSchemaTablesBuilder {
         table_id: Option<u32>,
         engine: Option<&str>,
     ) {
-        let table_type = match table_type {
-            TableType::Base => "BASE TABLE",
-            TableType::View => "VIEW",
-            TableType::Temporary => "LOCAL TEMPORARY",
-        };
-
-        let row = [
-            (TABLE_CATALOG, &Value::from(catalog_name)),
-            (TABLE_SCHEMA, &Value::from(schema_name)),
-            (TABLE_NAME, &Value::from(table_name)),
-            (TABLE_TYPE, &Value::from(table_type)),
-        ];
-
-        if !predicates.eval(&row) {
-            return;
-        }
-
         self.catalog_names.push(Some(catalog_name));
         self.schema_names.push(Some(schema_name));
         self.table_names.push(Some(table_name));
-        self.table_types.push(Some(table_type));
+        self.table_types.push(Some(match table_type {
+            TableType::Base => "BASE TABLE",
+            TableType::View => "VIEW",
+            TableType::Temporary => "LOCAL TEMPORARY",
+        }));
         self.table_ids.push(table_id);
         self.engines.push(engine);
     }
@@ -241,7 +253,7 @@ impl DfPartitionStream for InformationSchemaTables {
             schema,
             futures::stream::once(async move {
                 builder
-                    .make_tables(None)
+                    .make_tables()
                     .await
                     .map(|x| x.into_df_record_batch())
                     .map_err(Into::into)

src/catalog/src/kvbackend/client.rs

@@ -1,601 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-use std::any::Any;
-use std::fmt::Debug;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-use std::usize;
-
-use common_error::ext::BoxedError;
-use common_meta::cache_invalidator::KvCacheInvalidator;
-use common_meta::error::Error::{CacheNotGet, GetKvCache};
-use common_meta::error::{CacheNotGetSnafu, Error, ExternalSnafu, Result};
-use common_meta::kv_backend::{KvBackend, KvBackendRef, TxnService};
-use common_meta::rpc::store::{
-    BatchDeleteRequest, BatchDeleteResponse, BatchGetRequest, BatchGetResponse, BatchPutRequest,
-    BatchPutResponse, CompareAndPutRequest, CompareAndPutResponse, DeleteRangeRequest,
-    DeleteRangeResponse, PutRequest, PutResponse, RangeRequest, RangeResponse,
-};
-use common_meta::rpc::KeyValue;
-use common_telemetry::debug;
-use meta_client::client::MetaClient;
-use moka::future::{Cache, CacheBuilder};
-use snafu::{OptionExt, ResultExt};
-
-use crate::metrics::{
-    METRIC_CATALOG_KV_BATCH_GET, METRIC_CATALOG_KV_GET, METRIC_CATALOG_KV_REMOTE_GET,
-};
-
-const DEFAULT_CACHE_MAX_CAPACITY: u64 = 10000;
-const DEFAULT_CACHE_TTL: Duration = Duration::from_secs(10 * 60);
-const DEFAULT_CACHE_TTI: Duration = Duration::from_secs(5 * 60);
-
-pub struct CachedMetaKvBackendBuilder {
-    cache_max_capacity: Option<u64>,
-    cache_ttl: Option<Duration>,
-    cache_tti: Option<Duration>,
-    meta_client: Arc<MetaClient>,
-}
-
-impl CachedMetaKvBackendBuilder {
-    pub fn new(meta_client: Arc<MetaClient>) -> Self {
-        Self {
-            cache_max_capacity: None,
-            cache_ttl: None,
-            cache_tti: None,
-            meta_client,
-        }
-    }
-
-    pub fn cache_max_capacity(mut self, cache_max_capacity: u64) -> Self {
-        self.cache_max_capacity.replace(cache_max_capacity);
-        self
-    }
-
-    pub fn cache_ttl(mut self, cache_ttl: Duration) -> Self {
-        self.cache_ttl.replace(cache_ttl);
-        self
-    }
-
-    pub fn cache_tti(mut self, cache_tti: Duration) -> Self {
-        self.cache_tti.replace(cache_tti);
-        self
-    }
-
-    pub fn build(self) -> CachedMetaKvBackend {
-        let cache_max_capacity = self
-            .cache_max_capacity
-            .unwrap_or(DEFAULT_CACHE_MAX_CAPACITY);
-        let cache_ttl = self.cache_ttl.unwrap_or(DEFAULT_CACHE_TTL);
-        let cache_tti = self.cache_tti.unwrap_or(DEFAULT_CACHE_TTI);
-
-        let cache = CacheBuilder::new(cache_max_capacity)
-            .time_to_live(cache_ttl)
-            .time_to_idle(cache_tti)
-            .build();
-
-        let kv_backend = Arc::new(MetaKvBackend {
-            client: self.meta_client,
-        });
-        let name = format!("CachedKvBackend({})", kv_backend.name());
-        let version = AtomicUsize::new(0);
-
-        CachedMetaKvBackend {
-            kv_backend,
-            cache,
-            name,
-            version,
-        }
-    }
-}
-
-pub type CacheBackend = Cache<Vec<u8>, KeyValue>;
-
-/// A wrapper of `MetaKvBackend` with cache support.
-///
-/// CachedMetaKvBackend is mainly used to read metadata information from Metasrv, and provides
-/// cache for get and batch_get. One way to trigger cache invalidation of CachedMetaKvBackend:
-/// when metadata information changes, Metasrv will broadcast a metadata invalidation request.
-///
-/// Therefore, it is recommended to use CachedMetaKvBackend to only read metadata related
-/// information. Note: If you read other information, you may read expired data, which depends on
-/// TTL and TTI for cache.
-pub struct CachedMetaKvBackend {
-    kv_backend: KvBackendRef,
-    cache: CacheBackend,
-    name: String,
-    version: AtomicUsize,
-}
-
-impl TxnService for CachedMetaKvBackend {
-    type Error = Error;
-}
-
-#[async_trait::async_trait]
-impl KvBackend for CachedMetaKvBackend {
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    async fn range(&self, req: RangeRequest) -> Result<RangeResponse> {
-        self.kv_backend.range(req).await
-    }
-
-    async fn put(&self, req: PutRequest) -> Result<PutResponse> {
-        let key = &req.key.clone();
-
-        let ret = self.kv_backend.put(req).await;
-
-        if ret.is_ok() {
-            self.invalidate_key(key).await;
-        }
-
-        ret
-    }
-
-    async fn batch_put(&self, req: BatchPutRequest) -> Result<BatchPutResponse> {
-        let keys = req
-            .kvs
-            .iter()
-            .map(|kv| kv.key().to_vec())
-            .collect::<Vec<_>>();
-
-        let resp = self.kv_backend.batch_put(req).await;
-
-        if resp.is_ok() {
-            for key in keys {
-                self.invalidate_key(&key).await;
-            }
-        }
-
-        resp
-    }
-
-    async fn batch_get(&self, req: BatchGetRequest) -> Result<BatchGetResponse> {
-        let _timer = METRIC_CATALOG_KV_BATCH_GET.start_timer();
-
-        let mut kvs = Vec::with_capacity(req.keys.len());
-        let mut miss_keys = Vec::with_capacity(req.keys.len());
-
-        for key in req.keys {
-            if let Some(val) = self.cache.get(&key).await {
-                kvs.push(val);
-            } else {
-                miss_keys.push(key);
-            }
-        }
-
-        let batch_get_req = BatchGetRequest::new().with_keys(miss_keys.clone());
-
-        let pre_version = self.version();
-
-        let unhit_kvs = self.kv_backend.batch_get(batch_get_req).await?.kvs;
-
-        for kv in unhit_kvs.iter() {
-            self.cache.insert(kv.key().to_vec(), kv.clone()).await;
-        }
-
-        if !self.validate_version(pre_version) {
-            for key in miss_keys.iter() {
-                self.cache.invalidate(key).await;
-            }
-        }
-
-        kvs.extend(unhit_kvs);
-
-        Ok(BatchGetResponse { kvs })
-    }
-
-    async fn compare_and_put(&self, req: CompareAndPutRequest) -> Result<CompareAndPutResponse> {
-        let key = &req.key.clone();
-
-        let ret = self.kv_backend.compare_and_put(req).await;
-
-        if ret.is_ok() {
-            self.invalidate_key(key).await;
-        }
-
-        ret
-    }
-
-    async fn delete_range(&self, mut req: DeleteRangeRequest) -> Result<DeleteRangeResponse> {
-        let prev_kv = req.prev_kv;
-
-        req.prev_kv = true;
-        let resp = self.kv_backend.delete_range(req).await;
-        match resp {
-            Ok(mut resp) => {
-                for prev_kv in resp.prev_kvs.iter() {
-                    self.invalidate_key(prev_kv.key()).await;
-                }
-
-                if !prev_kv {
-                    resp.prev_kvs = vec![];
-                }
-                Ok(resp)
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    async fn batch_delete(&self, mut req: BatchDeleteRequest) -> Result<BatchDeleteResponse> {
-        let prev_kv = req.prev_kv;
-
-        req.prev_kv = true;
-        let resp = self.kv_backend.batch_delete(req).await;
-        match resp {
-            Ok(mut resp) => {
-                for prev_kv in resp.prev_kvs.iter() {
-                    self.invalidate_key(prev_kv.key()).await;
-                }
-
-                if !prev_kv {
-                    resp.prev_kvs = vec![];
-                }
-                Ok(resp)
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    async fn get(&self, key: &[u8]) -> Result<Option<KeyValue>> {
-        let _timer = METRIC_CATALOG_KV_GET.start_timer();
-
-        let pre_version = Arc::new(Mutex::new(None));
-
-        let init = async {
-            let version_clone = pre_version.clone();
-            let _timer = METRIC_CATALOG_KV_REMOTE_GET.start_timer();
-
-            version_clone.lock().unwrap().replace(self.version());
-
-            self.kv_backend.get(key).await.map(|val| {
-                val.with_context(|| CacheNotGetSnafu {
-                    key: String::from_utf8_lossy(key),
-                })
-            })?
-        };
-
-        // currently moka doesn't have `optionally_try_get_with_by_ref`
-        // TODO(fys): change to moka method when available
-        // https://github.com/moka-rs/moka/issues/254
-        let ret = match self.cache.try_get_with_by_ref(key, init).await {
-            Ok(val) => Ok(Some(val)),
-            Err(e) => match e.as_ref() {
-                CacheNotGet { .. } => Ok(None),
-                _ => Err(e),
-            },
-        }
-        .map_err(|e| GetKvCache {
-            err_msg: e.to_string(),
-        });
-
-        // "cache.invalidate_key" and "cache.try_get_with_by_ref" are not mutually exclusive. So we need
-        // to use the version mechanism to prevent expired data from being put into the cache.
-        if pre_version
-            .lock()
-            .unwrap()
-            .as_ref()
-            .map_or(false, |v| !self.validate_version(*v))
-        {
-            self.cache.invalidate(key).await;
-        }
-
-        ret
-    }
-}
-
-#[async_trait::async_trait]
-impl KvCacheInvalidator for CachedMetaKvBackend {
-    async fn invalidate_key(&self, key: &[u8]) {
-        self.create_new_version();
-        self.cache.invalidate(key).await;
-        debug!("invalidated cache key: {}", String::from_utf8_lossy(key));
-    }
-}
-
-impl CachedMetaKvBackend {
-    // only for test
-    #[cfg(test)]
-    fn wrap(kv_backend: KvBackendRef) -> Self {
-        let cache = CacheBuilder::new(DEFAULT_CACHE_MAX_CAPACITY)
-            .time_to_live(DEFAULT_CACHE_TTL)
-            .time_to_idle(DEFAULT_CACHE_TTI)
-            .build();
-
-        let name = format!("CachedKvBackend({})", kv_backend.name());
-        Self {
-            kv_backend,
-            cache,
-            name,
-            version: AtomicUsize::new(0),
-        }
-    }
-
-    pub fn cache(&self) -> &CacheBackend {
-        &self.cache
-    }
-
-    fn version(&self) -> usize {
-        self.version.load(Ordering::Relaxed)
-    }
-
-    fn validate_version(&self, pre_version: usize) -> bool {
-        self.version() == pre_version
-    }
-
-    fn create_new_version(&self) -> usize {
-        self.version.fetch_add(1, Ordering::Relaxed) + 1
-    }
-}
-
-#[derive(Debug)]
-pub struct MetaKvBackend {
-    pub client: Arc<MetaClient>,
-}
-
-impl TxnService for MetaKvBackend {
-    type Error = Error;
-}
-
-/// Implement `KvBackend` trait for `MetaKvBackend` instead of opendal's `Accessor` since
-/// `MetaClient`'s range method can return both keys and values, which can reduce IO overhead
-/// comparing to `Accessor`'s list and get method.
-#[async_trait::async_trait]
-impl KvBackend for MetaKvBackend {
-    fn name(&self) -> &str {
-        "MetaKvBackend"
-    }
-
-    async fn range(&self, req: RangeRequest) -> Result<RangeResponse> {
-        self.client
-            .range(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)
-    }
-
-    async fn get(&self, key: &[u8]) -> Result<Option<KeyValue>> {
-        let mut response = self
-            .client
-            .range(RangeRequest::new().with_key(key))
-            .await
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)?;
-        Ok(response.take_kvs().get_mut(0).map(|kv| KeyValue {
-            key: kv.take_key(),
-            value: kv.take_value(),
-        }))
-    }
-
-    async fn batch_put(&self, req: BatchPutRequest) -> Result<BatchPutResponse> {
-        self.client
-            .batch_put(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)
-    }
-
-    async fn put(&self, req: PutRequest) -> Result<PutResponse> {
-        self.client
-            .put(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)
-    }
-
-    async fn delete_range(&self, req: DeleteRangeRequest) -> Result<DeleteRangeResponse> {
-        self.client
-            .delete_range(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)
-    }
-
-    async fn batch_delete(&self, req: BatchDeleteRequest) -> Result<BatchDeleteResponse> {
-        self.client
-            .batch_delete(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)
-    }
-
-    async fn batch_get(&self, req: BatchGetRequest) -> Result<BatchGetResponse> {
-        self.client
-            .batch_get(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)
-    }
-
-    async fn compare_and_put(
-        &self,
-        request: CompareAndPutRequest,
-    ) -> Result<CompareAndPutResponse> {
-        self.client
-            .compare_and_put(request)
-            .await
-            .map_err(BoxedError::new)
-            .context(ExternalSnafu)
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::any::Any;
-    use std::sync::atomic::{AtomicU32, Ordering};
-    use std::sync::Arc;
-
-    use async_trait::async_trait;
-    use common_meta::kv_backend::{KvBackend, TxnService};
-    use common_meta::rpc::store::{
-        BatchDeleteRequest, BatchDeleteResponse, BatchGetRequest, BatchGetResponse,
-        BatchPutRequest, BatchPutResponse, CompareAndPutRequest, CompareAndPutResponse,
-        DeleteRangeRequest, DeleteRangeResponse, PutRequest, PutResponse, RangeRequest,
-        RangeResponse,
-    };
-    use common_meta::rpc::KeyValue;
-    use dashmap::DashMap;
-
-    use super::CachedMetaKvBackend;
-
-    #[derive(Default)]
-    pub struct SimpleKvBackend {
-        inner_map: DashMap<Vec<u8>, Vec<u8>>,
-        get_execute_times: Arc<AtomicU32>,
-    }
-
-    impl TxnService for SimpleKvBackend {
-        type Error = common_meta::error::Error;
-    }
-
-    #[async_trait]
-    impl KvBackend for SimpleKvBackend {
-        fn name(&self) -> &str {
-            "SimpleKvBackend"
-        }
-
-        fn as_any(&self) -> &dyn Any {
-            self
-        }
-
-        async fn batch_get(&self, req: BatchGetRequest) -> Result<BatchGetResponse, Self::Error> {
-            let mut kvs = Vec::with_capacity(req.keys.len());
-            for key in req.keys.iter() {
-                if let Some(kv) = self.get(key).await? {
-                    kvs.push(kv);
-                }
-            }
-            Ok(BatchGetResponse { kvs })
-        }
-
-        async fn put(&self, req: PutRequest) -> Result<PutResponse, Self::Error> {
-            self.inner_map.insert(req.key, req.value);
-            // always return None as prev_kv, since we don't use it in this test.
-            Ok(PutResponse { prev_kv: None })
-        }
-
-        async fn get(&self, key: &[u8]) -> Result<Option<KeyValue>, Self::Error> {
-            self.get_execute_times
-                .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-            Ok(self.inner_map.get(key).map(|v| KeyValue {
-                key: key.to_vec(),
-                value: v.value().clone(),
-            }))
-        }
-
-        async fn range(&self, _req: RangeRequest) -> Result<RangeResponse, Self::Error> {
-            todo!()
-        }
-
-        async fn batch_put(&self, _req: BatchPutRequest) -> Result<BatchPutResponse, Self::Error> {
-            todo!()
-        }
-
-        async fn compare_and_put(
-            &self,
-            _req: CompareAndPutRequest,
-        ) -> Result<CompareAndPutResponse, Self::Error> {
-            todo!()
-        }
-
-        async fn delete_range(
-            &self,
-            _req: DeleteRangeRequest,
-        ) -> Result<DeleteRangeResponse, Self::Error> {
-            todo!()
-        }
-
-        async fn batch_delete(
-            &self,
-            _req: BatchDeleteRequest,
-        ) -> Result<BatchDeleteResponse, Self::Error> {
-            todo!()
-        }
-    }
-
-    #[tokio::test]
-    async fn test_cached_kv_backend() {
-        let simple_kv = Arc::new(SimpleKvBackend::default());
-        let get_execute_times = simple_kv.get_execute_times.clone();
-        let cached_kv = CachedMetaKvBackend::wrap(simple_kv);
-
-        add_some_vals(&cached_kv).await;
-
-        let batch_get_req = BatchGetRequest {
-            keys: vec![b"k1".to_vec(), b"k2".to_vec()],
-        };
-
-        assert_eq!(get_execute_times.load(Ordering::SeqCst), 0);
-
-        for _ in 0..10 {
-            let _batch_get_resp = cached_kv.batch_get(batch_get_req.clone()).await.unwrap();
-
-            assert_eq!(get_execute_times.load(Ordering::SeqCst), 2);
-        }
-
-        let batch_get_req = BatchGetRequest {
-            keys: vec![b"k1".to_vec(), b"k2".to_vec(), b"k3".to_vec()],
-        };
-
-        let _batch_get_resp = cached_kv.batch_get(batch_get_req.clone()).await.unwrap();
-
-        assert_eq!(get_execute_times.load(Ordering::SeqCst), 3);
-
-        for _ in 0..10 {
-            let _batch_get_resp = cached_kv.batch_get(batch_get_req.clone()).await.unwrap();
-
-            assert_eq!(get_execute_times.load(Ordering::SeqCst), 3);
-        }
-    }
-
-    async fn add_some_vals(kv_backend: &impl KvBackend) {
-        kv_backend
-            .put(PutRequest {
-                key: b"k1".to_vec(),
-                value: b"v1".to_vec(),
-                prev_kv: false,
-            })
-            .await
-            .unwrap();
-
-        kv_backend
-            .put(PutRequest {
-                key: b"k2".to_vec(),
-                value: b"v2".to_vec(),
-                prev_kv: false,
-            })
-            .await
-            .unwrap();
-
-        kv_backend
-            .put(PutRequest {
-                key: b"k3".to_vec(),
-                value: b"v3".to_vec(),
-                prev_kv: false,
-            })
-            .await
-            .unwrap();
-    }
-}

src/catalog/src/kvbackend/manager.rs

@@ -1,396 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed 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.
-
-use std::any::Any;
-use std::collections::BTreeSet;
-use std::sync::{Arc, Weak};
-use std::time::Duration;
-
-use async_stream::try_stream;
-use common_catalog::consts::{
-    DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, INFORMATION_SCHEMA_NAME, NUMBERS_TABLE_ID,
-};
-use common_catalog::format_full_table_name;
-use common_error::ext::BoxedError;
-use common_meta::cache_invalidator::{CacheInvalidator, CacheInvalidatorRef, Context};
-use common_meta::error::Result as MetaResult;
-use common_meta::key::catalog_name::CatalogNameKey;
-use common_meta::key::schema_name::SchemaNameKey;
-use common_meta::key::table_info::TableInfoValue;
-use common_meta::key::table_name::TableNameKey;
-use common_meta::key::{TableMetadataManager, TableMetadataManagerRef};
-use common_meta::kv_backend::KvBackendRef;
-use common_meta::table_name::TableName;
-use futures_util::stream::BoxStream;
-use futures_util::{StreamExt, TryStreamExt};
-use moka::future::{Cache as AsyncCache, CacheBuilder};
-use moka::sync::Cache;
-use partition::manager::{PartitionRuleManager, PartitionRuleManagerRef};
-use snafu::prelude::*;
-use table::dist_table::DistTable;
-use table::metadata::TableId;
-use table::table::numbers::{NumbersTable, NUMBERS_TABLE_NAME};
-use table::TableRef;
-
-use crate::error::Error::{GetTableCache, TableCacheNotGet};
-use crate::error::{
-    self as catalog_err, ListCatalogsSnafu, ListSchemasSnafu, ListTablesSnafu,
-    Result as CatalogResult, TableCacheNotGetSnafu, TableMetadataManagerSnafu,
-};
-use crate::information_schema::InformationSchemaProvider;
-use crate::CatalogManager;
-
-/// Access all existing catalog, schema and tables.
-///
-/// The result comes from two source, all the user tables are presented in
-/// a kv-backend which persists the metadata of a table. And system tables
-/// comes from `SystemCatalog`, which is static and read-only.
-#[derive(Clone)]
-pub struct KvBackendCatalogManager {
-    // TODO(LFC): Maybe use a real implementation for Standalone mode.
-    // Now we use `NoopKvCacheInvalidator` for Standalone mode. In Standalone mode, the KV backend
-    // is implemented by RaftEngine. Maybe we need a cache for it?
-    cache_invalidator: CacheInvalidatorRef,
-    partition_manager: PartitionRuleManagerRef,
-    table_metadata_manager: TableMetadataManagerRef,
-    /// A sub-CatalogManager that handles system tables
-    system_catalog: SystemCatalog,
-    table_cache: AsyncCache<String, TableRef>,
-}
-
-fn make_table(table_info_value: TableInfoValue) -> CatalogResult<TableRef> {
-    let table_info = table_info_value
-        .table_info
-        .try_into()
-        .context(catalog_err::InvalidTableInfoInCatalogSnafu)?;
-    Ok(DistTable::table(Arc::new(table_info)))
-}
-
-#[async_trait::async_trait]
-impl CacheInvalidator for KvBackendCatalogManager {
-    async fn invalidate_table_id(&self, ctx: &Context, table_id: TableId) -> MetaResult<()> {
-        self.cache_invalidator
-            .invalidate_table_id(ctx, table_id)
-            .await
-    }
-
-    async fn invalidate_table_name(&self, ctx: &Context, table_name: TableName) -> MetaResult<()> {
-        let table_cache_key = format_full_table_name(
-            &table_name.catalog_name,
-            &table_name.schema_name,
-            &table_name.table_name,
-        );
-        self.cache_invalidator
-            .invalidate_table_name(ctx, table_name)
-            .await?;
-        self.table_cache.invalidate(&table_cache_key).await;
-
-        Ok(())
-    }
-}
-
-const CATALOG_CACHE_MAX_CAPACITY: u64 = 128;
-const TABLE_CACHE_MAX_CAPACITY: u64 = 65536;
-const TABLE_CACHE_TTL: Duration = Duration::from_secs(10 * 60);
-const TABLE_CACHE_TTI: Duration = Duration::from_secs(5 * 60);
-
-impl KvBackendCatalogManager {
-    pub fn new(backend: KvBackendRef, cache_invalidator: CacheInvalidatorRef) -> Arc<Self> {
-        Arc::new_cyclic(|me| Self {
-            partition_manager: Arc::new(PartitionRuleManager::new(backend.clone())),
-            table_metadata_manager: Arc::new(TableMetadataManager::new(backend)),
-            cache_invalidator,
-            system_catalog: SystemCatalog {
-                catalog_manager: me.clone(),
-                catalog_cache: Cache::new(CATALOG_CACHE_MAX_CAPACITY),
-                information_schema_provider: Arc::new(InformationSchemaProvider::new(
-                    DEFAULT_CATALOG_NAME.to_string(),
-                    me.clone(),
-                )),
-            },
-            table_cache: CacheBuilder::new(TABLE_CACHE_MAX_CAPACITY)
-                .time_to_live(TABLE_CACHE_TTL)
-                .time_to_idle(TABLE_CACHE_TTI)
-                .build(),
-        })
-    }
-
-    pub fn partition_manager(&self) -> PartitionRuleManagerRef {
-        self.partition_manager.clone()
-    }
-
-    pub fn table_metadata_manager_ref(&self) -> &TableMetadataManagerRef {
-        &self.table_metadata_manager
-    }
-}
-
-#[async_trait::async_trait]
-impl CatalogManager for KvBackendCatalogManager {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    async fn catalog_names(&self) -> CatalogResult<Vec<String>> {
-        let stream = self
-            .table_metadata_manager
-            .catalog_manager()
-            .catalog_names()
-            .await;
-
-        let keys = stream
-            .try_collect::<Vec<_>>()
-            .await
-            .map_err(BoxedError::new)
-            .context(ListCatalogsSnafu)?;
-
-        Ok(keys)
-    }
-
-    async fn schema_names(&self, catalog: &str) -> CatalogResult<Vec<String>> {
-        let stream = self
-            .table_metadata_manager
-            .schema_manager()
-            .schema_names(catalog)
-            .await;
-        let mut keys = stream
-            .try_collect::<BTreeSet<_>>()
-            .await
-            .map_err(BoxedError::new)
-            .context(ListSchemasSnafu { catalog })?;
-
-        keys.extend(self.system_catalog.schema_names());
-
-        Ok(keys.into_iter().collect())
-    }
-
-    async fn table_names(&self, catalog: &str, schema: &str) -> CatalogResult<Vec<String>> {
-        let stream = self
-            .table_metadata_manager
-            .table_name_manager()
-            .tables(catalog, schema)
-            .await;
-        let mut tables = stream
-            .try_collect::<Vec<_>>()
-            .await
-            .map_err(BoxedError::new)
-            .context(ListTablesSnafu { catalog, schema })?
-            .into_iter()
-            .map(|(k, _)| k)
-            .collect::<Vec<_>>();
-        tables.extend_from_slice(&self.system_catalog.table_names(schema));
-
-        Ok(tables.into_iter().collect())
-    }
-
-    async fn catalog_exists(&self, catalog: &str) -> CatalogResult<bool> {
-        self.table_metadata_manager
-            .catalog_manager()
-            .exists(CatalogNameKey::new(catalog))
-            .await
-            .context(TableMetadataManagerSnafu)
-    }
-
-    async fn schema_exists(&self, catalog: &str, schema: &str) -> CatalogResult<bool> {
-        if self.system_catalog.schema_exist(schema) {
-            return Ok(true);
-        }
-
-        self.table_metadata_manager
-            .schema_manager()
-            .exists(SchemaNameKey::new(catalog, schema))
-            .await
-            .context(TableMetadataManagerSnafu)
-    }
-
-    async fn table_exists(&self, catalog: &str, schema: &str, table: &str) -> CatalogResult<bool> {
-        if self.system_catalog.table_exist(schema, table) {
-            return Ok(true);
-        }
-
-        let key = TableNameKey::new(catalog, schema, table);
-        self.table_metadata_manager
-            .table_name_manager()
-            .get(key)
-            .await
-            .context(TableMetadataManagerSnafu)
-            .map(|x| x.is_some())
-    }
-
-    async fn table(
-        &self,
-        catalog: &str,
-        schema: &str,
-        table_name: &str,
-    ) -> CatalogResult<Option<TableRef>> {
-        if let Some(table) = self.system_catalog.table(catalog, schema, table_name) {
-            return Ok(Some(table));
-        }
-
-        let init = async {
-            let table_name_key = TableNameKey::new(catalog, schema, table_name);
-            let Some(table_name_value) = self
-                .table_metadata_manager
-                .table_name_manager()
-                .get(table_name_key)
-                .await
-                .context(TableMetadataManagerSnafu)?
-            else {
-                return TableCacheNotGetSnafu {
-                    key: table_name_key.to_string(),
-                }
-                .fail();
-            };
-            let table_id = table_name_value.table_id();
-
-            let Some(table_info_value) = self
-                .table_metadata_manager
-                .table_info_manager()
-                .get(table_id)
-                .await
-                .context(TableMetadataManagerSnafu)?
-                .map(|v| v.into_inner())
-            else {
-                return TableCacheNotGetSnafu {
-                    key: table_name_key.to_string(),
-                }
-                .fail();
-            };
-            make_table(table_info_value)
-        };
-
-        match self
-            .table_cache
-            .try_get_with_by_ref(&format_full_table_name(catalog, schema, table_name), init)
-            .await
-        {
-            Ok(table) => Ok(Some(table)),
-            Err(err) => match err.as_ref() {
-                TableCacheNotGet { .. } => Ok(None),
-                _ => Err(err),
-            },
-        }
-        .map_err(|err| GetTableCache {
-            err_msg: err.to_string(),
-        })
-    }
-
-    async fn tables<'a>(
-        &'a self,
-        catalog: &'a str,
-        schema: &'a str,
-    ) -> BoxStream<'a, CatalogResult<TableRef>> {
-        let sys_tables = try_stream!({
-            // System tables
-            let sys_table_names = self.system_catalog.table_names(schema);
-            for table_name in sys_table_names {
-                if let Some(table) = self.system_catalog.table(catalog, schema, &table_name) {
-                    yield table;
-                }
-            }
-        });
-
-        let table_id_stream = self
-            .table_metadata_manager
-            .table_name_manager()
-            .tables(catalog, schema)
-            .await
-            .map_ok(|(_, v)| v.table_id());
-        const BATCH_SIZE: usize = 128;
-        let user_tables = try_stream!({
-            // Split table ids into chunks
-            let mut table_id_chunks = table_id_stream.ready_chunks(BATCH_SIZE);
-
-            while let Some(table_ids) = table_id_chunks.next().await {
-                let table_ids = table_ids
-                    .into_iter()
-                    .collect::<Result<Vec<_>, _>>()
-                    .map_err(BoxedError::new)
-                    .context(ListTablesSnafu { catalog, schema })?;
-
-                let table_info_values = self
-                    .table_metadata_manager
-                    .table_info_manager()
-                    .batch_get(&table_ids)
-                    .await
-                    .context(TableMetadataManagerSnafu)?;
-
-                for table_info_value in table_info_values.into_values() {
-                    yield make_table(table_info_value)?;
-                }
-            }
-        });
-
-        Box::pin(sys_tables.chain(user_tables))
-    }
-}
-
-// TODO: This struct can hold a static map of all system tables when
-// the upper layer (e.g., procedure) can inform the catalog manager
-// a new catalog is created.
-/// Existing system tables:
-/// - public.numbers
-/// - information_schema.{tables}
-#[derive(Clone)]
-struct SystemCatalog {
-    catalog_manager: Weak<KvBackendCatalogManager>,
-    catalog_cache: Cache<String, Arc<InformationSchemaProvider>>,
-    information_schema_provider: Arc<InformationSchemaProvider>,
-}
-
-impl SystemCatalog {
-    fn schema_names(&self) -> Vec<String> {
-        vec![INFORMATION_SCHEMA_NAME.to_string()]
-    }
-
-    fn table_names(&self, schema: &str) -> Vec<String> {
-        if schema == INFORMATION_SCHEMA_NAME {
-            self.information_schema_provider.table_names()
-        } else if schema == DEFAULT_SCHEMA_NAME {
-            vec![NUMBERS_TABLE_NAME.to_string()]
-        } else {
-            vec![]
-        }
-    }
-
-    fn schema_exist(&self, schema: &str) -> bool {
-        schema == INFORMATION_SCHEMA_NAME
-    }
-
-    fn table_exist(&self, schema: &str, table: &str) -> bool {
-        if schema == INFORMATION_SCHEMA_NAME {
-            self.information_schema_provider.table(table).is_some()
-        } else if schema == DEFAULT_SCHEMA_NAME {
-            table == NUMBERS_TABLE_NAME
-        } else {
-            false
-        }
-    }
-
-    fn table(&self, catalog: &str, schema: &str, table_name: &str) -> Option<TableRef> {
-        if schema == INFORMATION_SCHEMA_NAME {
-            let information_schema_provider =
-                self.catalog_cache.get_with_by_ref(catalog, move || {
-                    Arc::new(InformationSchemaProvider::new(
-                        catalog.to_string(),
-                        self.catalog_manager.clone(),
-                    ))
-                });
-            information_schema_provider.table(table_name)
-        } else if schema == DEFAULT_SCHEMA_NAME && table_name == NUMBERS_TABLE_NAME {
-            Some(NumbersTable::table(NUMBERS_TABLE_ID))
-        } else {
-            None
-        }
-    }
-}

src/catalog/src/lib.rs

@@ -12,43 +12,84 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#![feature(trait_upcasting)]
 #![feature(assert_matches)]
 #![feature(try_blocks)]
 
 use std::any::Any;
+use std::collections::HashMap;
 use std::fmt::{Debug, Formatter};
 use std::sync::Arc;
 
-use futures::future::BoxFuture;
-use futures_util::stream::BoxStream;
-use table::metadata::TableId;
+use api::v1::meta::{RegionStat, TableIdent, TableName};
+use common_telemetry::{info, warn};
+use snafu::ResultExt;
+use table::engine::{EngineContext, TableEngineRef};
+use table::metadata::{TableId, TableType};
 use table::requests::CreateTableRequest;
 use table::TableRef;
 
-use crate::error::Result;
+use crate::error::{CreateTableSnafu, Result};
 
 pub mod error;
 pub mod information_schema;
-pub mod kvbackend;
-pub mod memory;
+pub mod local;
 mod metrics;
+pub mod remote;
+pub mod system;
 pub mod table_source;
+pub mod tables;
 
 #[async_trait::async_trait]
 pub trait CatalogManager: Send + Sync {
     fn as_any(&self) -> &dyn Any;
 
+    /// Starts a catalog manager.
+    async fn start(&self) -> Result<()>;
+
+    /// Registers a catalog to catalog manager, returns whether the catalog exist before.
+    async fn register_catalog(self: Arc<Self>, name: String) -> Result<bool>;
+
+    /// Register a schema with catalog name and schema name. Retuens whether the
+    /// schema registered.
+    ///
+    /// # Errors
+    ///
+    /// This method will/should fail if catalog not exist
+    async fn register_schema(&self, request: RegisterSchemaRequest) -> Result<bool>;
+
+    /// Deregisters a database within given catalog/schema to catalog manager
+    async fn deregister_schema(&self, request: DeregisterSchemaRequest) -> Result<bool>;
+
+    /// Registers a table within given catalog/schema to catalog manager,
+    /// returns whether the table registered.
+    ///
+    /// # Errors
+    ///
+    /// This method will/should fail if catalog or schema not exist
+    async fn register_table(&self, request: RegisterTableRequest) -> Result<bool>;
+
+    /// Deregisters a table within given catalog/schema to catalog manager
+    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<()>;
+
+    /// Rename a table to [RenameTableRequest::new_table_name], returns whether the table is renamed.
+    async fn rename_table(&self, request: RenameTableRequest) -> Result<bool>;
+
+    /// Register a system table, should be called before starting the manager.
+    async fn register_system_table(&self, request: RegisterSystemTableRequest)
+        -> error::Result<()>;
+
     async fn catalog_names(&self) -> Result<Vec<String>>;
 
     async fn schema_names(&self, catalog: &str) -> Result<Vec<String>>;
 
     async fn table_names(&self, catalog: &str, schema: &str) -> Result<Vec<String>>;
 
-    async fn catalog_exists(&self, catalog: &str) -> Result<bool>;
+    async fn catalog_exist(&self, catalog: &str) -> Result<bool>;
 
-    async fn schema_exists(&self, catalog: &str, schema: &str) -> Result<bool>;
+    async fn schema_exist(&self, catalog: &str, schema: &str) -> Result<bool>;
 
-    async fn table_exists(&self, catalog: &str, schema: &str, table: &str) -> Result<bool>;
+    async fn table_exist(&self, catalog: &str, schema: &str, table: &str) -> Result<bool>;
 
     /// Returns the table by catalog, schema and table name.
     async fn table(
@@ -57,20 +98,12 @@ pub trait CatalogManager: Send + Sync {
         schema: &str,
         table_name: &str,
     ) -> Result<Option<TableRef>>;
-
-    /// Returns all tables with a stream by catalog and schema.
-    async fn tables<'a>(
-        &'a self,
-        catalog: &'a str,
-        schema: &'a str,
-    ) -> BoxStream<'a, Result<TableRef>>;
 }
 
 pub type CatalogManagerRef = Arc<dyn CatalogManager>;
 
 /// Hook called after system table opening.
-pub type OpenSystemTableHook =
-    Box<dyn Fn(TableRef) -> BoxFuture<'static, Result<()>> + Send + Sync>;
+pub type OpenSystemTableHook = Arc<dyn Fn(TableRef) -> Result<()> + Send + Sync>;
 
 /// Register system table request:
 /// - When system table is already created and registered, the hook will be called
@@ -129,3 +162,120 @@ pub struct RegisterSchemaRequest {
     pub catalog: String,
     pub schema: String,
 }
+
+pub(crate) async fn handle_system_table_request<'a, M: CatalogManager>(
+    manager: &'a M,
+    engine: TableEngineRef,
+    sys_table_requests: &'a mut Vec<RegisterSystemTableRequest>,
+) -> Result<()> {
+    for req in sys_table_requests.drain(..) {
+        let catalog_name = &req.create_table_request.catalog_name;
+        let schema_name = &req.create_table_request.schema_name;
+        let table_name = &req.create_table_request.table_name;
+        let table_id = req.create_table_request.id;
+
+        let table = manager.table(catalog_name, schema_name, table_name).await?;
+        let table = if let Some(table) = table {
+            table
+        } else {
+            let table = engine
+                .create_table(&EngineContext::default(), req.create_table_request.clone())
+                .await
+                .with_context(|_| CreateTableSnafu {
+                    table_info: common_catalog::format_full_table_name(
+                        catalog_name,
+                        schema_name,
+                        table_name,
+                    ),
+                })?;
+            let _ = manager
+                .register_table(RegisterTableRequest {
+                    catalog: catalog_name.clone(),
+                    schema: schema_name.clone(),
+                    table_name: table_name.clone(),
+                    table_id,
+                    table: table.clone(),
+                })
+                .await?;
+            info!("Created and registered system table: {table_name}");
+            table
+        };
+        if let Some(hook) = req.open_hook {
+            (hook)(table)?;
+        }
+    }
+    Ok(())
+}
+
+/// The stat of regions in the datanode node.
+/// The number of regions can be got from len of vec.
+///
+/// Ignores any errors occurred during iterating regions. The intention of this method is to
+/// collect region stats that will be carried in Datanode's heartbeat to Metasrv, so it's a
+/// "try our best" job.
+pub async fn datanode_stat(catalog_manager: &CatalogManagerRef) -> (u64, Vec<RegionStat>) {
+    let mut region_number: u64 = 0;
+    let mut region_stats = Vec::new();
+
+    let Ok(catalog_names) = catalog_manager.catalog_names().await else {
+        return (region_number, region_stats);
+    };
+    for catalog_name in catalog_names {
+        let Ok(schema_names) = catalog_manager.schema_names(&catalog_name).await else {
+            continue;
+        };
+        for schema_name in schema_names {
+            let Ok(table_names) = catalog_manager
+                .table_names(&catalog_name, &schema_name)
+                .await
+            else {
+                continue;
+            };
+            for table_name in table_names {
+                let Ok(Some(table)) = catalog_manager
+                    .table(&catalog_name, &schema_name, &table_name)
+                    .await
+                else {
+                    continue;
+                };
+
+                if table.table_type() != TableType::Base {
+                    continue;
+                }
+
+                let table_info = table.table_info();
+                let region_numbers = &table_info.meta.region_numbers;
+                region_number += region_numbers.len() as u64;
+
+                let engine = &table_info.meta.engine;
+                let table_id = table_info.ident.table_id;
+
+                match table.region_stats() {
+                    Ok(stats) => {
+                        let stats = stats.into_iter().map(|stat| RegionStat {
+                            region_id: stat.region_id,
+                            table_ident: Some(TableIdent {
+                                table_id,
+                                table_name: Some(TableName {
+                                    catalog_name: catalog_name.clone(),
+                                    schema_name: schema_name.clone(),
+                                    table_name: table_name.clone(),
+                                }),
+                                engine: engine.clone(),
+                            }),
+                            approximate_bytes: stat.disk_usage_bytes as i64,
+                            attrs: HashMap::from([("engine_name".to_owned(), engine.clone())]),
+                            ..Default::default()
+                        });
+
+                        region_stats.extend(stats);
+                    }
+                    Err(e) => {
+                        warn!("Failed to get region status, err: {:?}", e);
+                    }
+                };
+            }
+        }
+    }
+    (region_number, region_stats)
+}

src/catalog/src/local.rs

@@ -13,5 +13,7 @@
 // limitations under the License.
 
 pub mod manager;
+pub mod memory;
 
-pub use manager::{new_memory_catalog_manager, MemoryCatalogManager};
+pub use manager::LocalCatalogManager;
+pub use memory::{new_memory_catalog_manager, MemoryCatalogManager};