fix: static assets path prefix

.cargo/config.toml

@@ -12,9 +12,4 @@ rustflags = [
     "-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",
 ]

.config/nextest.toml

@@ -1,3 +1,2 @@
 [profile.default]
 slow-timeout = { period = "60s", terminate-after = 3, grace-period = "30s" }
-retries = { backoff = "exponential", count = 3, delay = "10s", jitter = true }

.dockerignore

@@ -20,3 +20,6 @@ out/
 
 # Rust
 target/
+
+# Git
+.git

.env.example

@@ -3,19 +3,8 @@ GT_S3_BUCKET=S3 bucket
 GT_S3_ACCESS_KEY_ID=S3 access key id
 GT_S3_ACCESS_KEY=S3 secret access key
 GT_S3_ENDPOINT_URL=S3 endpoint url
-GT_S3_REGION=S3 region
 # Settings for oss test
 GT_OSS_BUCKET=OSS bucket
 GT_OSS_ACCESS_KEY_ID=OSS access key id
 GT_OSS_ACCESS_KEY=OSS access key
 GT_OSS_ENDPOINT=OSS endpoint
-# Settings for azblob test
-GT_AZBLOB_CONTAINER=AZBLOB container
-GT_AZBLOB_ACCOUNT_NAME=AZBLOB account name
-GT_AZBLOB_ACCOUNT_KEY=AZBLOB account key
-GT_AZBLOB_ENDPOINT=AZBLOB endpoint
-# Settings for gcs test 
-GT_GCS_BUCKET = GCS bucket 
-GT_GCS_SCOPE  = GCS scope
-GT_GCS_CREDENTIAL_PATH = GCS credential path 
-GT_GCS_ENDPOINT = GCS end point

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -81,5 +81,6 @@ body:
         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.
+      render: bash
     validations:
       required: true

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

@@ -1,93 +0,0 @@
-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-greptime-binary/action.yml

@@ -1,67 +0,0 @@
-name: Build greptime binary
-description: Build and upload the single linux artifact
-inputs:
-  base-image:
-    description: Base image to build greptime
-    required: true
-  features:
-    description: Cargo features to build
-    required: true
-  cargo-profile:
-    description: Cargo profile to build
-    required: true
-  artifacts-dir:
-    description: Directory to store artifacts
-    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'
-  working-dir:
-    description: Working directory to build the artifacts
-    required: false
-    default: .
-runs:
-  using: composite
-  steps:
-    - name: Build greptime binary
-      shell: bash
-      run: |
-        cd ${{ inputs.working-dir }} && \
-        make build-by-dev-builder \
-          CARGO_PROFILE=${{ inputs.cargo-profile }} \
-          FEATURES=${{ inputs.features }} \
-          BASE_IMAGE=${{ inputs.base-image }}
-
-    - name: Upload artifacts
-      uses: ./.github/actions/upload-artifacts
-      with:
-        artifacts-dir: ${{ inputs.artifacts-dir }}
-        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

@@ -1,104 +0,0 @@
-name: Build greptime images
-description: Build and push greptime images
-inputs:
-  image-registry:
-    description: The image registry to store the images
-    required: true
-  image-registry-username:
-    description: The username to login to the image registry
-    required: true
-  image-registry-password:
-    description: The password to login to the image registry
-    required: true
-  amd64-artifact-name:
-    description: The name of the amd64 artifact for building images
-    required: true
-  arm64-artifact-name:
-    description: The name of the arm64 artifact for building images
-    required: false
-    default: ""
-  image-namespace:
-    description: The namespace of the image registry to store the images
-    required: true
-  image-name:
-    description: The name of the image to build
-    required: true
-  image-tag:
-    description: The tag of the image to build
-    required: true
-  docker-file:
-    description: The path to the Dockerfile to build
-    required: true
-  platforms:
-    description: The supported platforms to build the image
-    required: true
-  push-latest-tag:
-    description: Whether to push the latest tag
-    required: false
-    default: 'true'
-runs:
-  using: composite
-  steps:
-    - name: Login to image registry
-      uses: docker/login-action@v2
-      with:
-        registry: ${{ inputs.image-registry }}
-        username: ${{ inputs.image-registry-username }}
-        password: ${{ inputs.image-registry-password }}
-
-    - name: Set up qemu for multi-platform builds
-      uses: docker/setup-qemu-action@v2
-
-    - name: Set up buildx
-      uses: docker/setup-buildx-action@v2
-
-    - name: Download amd64 artifacts
-      uses: actions/download-artifact@v3
-      with:
-        name: ${{ inputs.amd64-artifact-name }}
-
-    - name: Unzip the amd64 artifacts
-      shell: bash
-      run: |
-        tar xvf ${{ inputs.amd64-artifact-name }}.tar.gz && \
-        rm ${{ inputs.amd64-artifact-name }}.tar.gz && \
-        rm -rf amd64 && \
-        mv ${{ inputs.amd64-artifact-name }} amd64
-
-    - name: Download arm64 artifacts
-      uses: actions/download-artifact@v3
-      if: ${{ inputs.arm64-artifact-name }}
-      with:
-        name: ${{ inputs.arm64-artifact-name }}
-
-    - name: Unzip the arm64 artifacts
-      shell: bash
-      if: ${{ inputs.arm64-artifact-name }}
-      run: |
-        tar xvf ${{ inputs.arm64-artifact-name }}.tar.gz && \
-        rm ${{ inputs.arm64-artifact-name }}.tar.gz && \
-        rm -rf arm64 && \
-        mv ${{ inputs.arm64-artifact-name }} arm64
-
-    - name: Build and push images(without latest) for amd64 and arm64
-      if: ${{ inputs.push-latest-tag == 'false' }}
-      uses: docker/build-push-action@v3
-      with:
-        context: .
-        file: ${{ inputs.docker-file }}
-        push: true
-        platforms: ${{ inputs.platforms }}
-        tags: |
-          ${{ inputs.image-registry }}/${{ inputs.image-namespace }}/${{ inputs.image-name }}:${{ inputs.image-tag }}
-
-    - name: Build and push images for amd64 and arm64
-      if: ${{ inputs.push-latest-tag == 'true' }}
-      uses: docker/build-push-action@v3
-      with:
-        context: .
-        file: ${{ inputs.docker-file }}
-        push: true
-        platforms: ${{ inputs.platforms }}
-        tags: |
-          ${{ inputs.image-registry }}/${{ inputs.image-namespace }}/${{ inputs.image-name }}:latest
-          ${{ inputs.image-registry }}/${{ inputs.image-namespace }}/${{ inputs.image-name }}:${{ inputs.image-tag }}

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

@@ -1,62 +0,0 @@
-name: Group for building greptimedb images
-description: Group for building greptimedb images
-inputs:
-  image-registry:
-    description: The image registry to store the images
-    required: true
-  image-namespace:
-    description: The namespace of the image registry to store the images
-    required: true
-  image-name:
-    description: The name of the image to build
-    required: false
-    default: greptimedb
-  image-registry-username:
-    description: The username to login to the image registry
-    required: true
-  image-registry-password:
-    description: The password to login to the image registry
-    required: true
-  version:
-    description: Version of the artifact
-    required: true
-  push-latest-tag:
-    description: Whether to push the latest tag
-    required: false
-    default: 'true'
-  dev-mode:
-    description: Enable dev mode, only build standard greptime
-    required: false
-    default: 'false'
-runs:
-  using: composite
-  steps:
-    - name: Build and push standard images to dockerhub
-      uses: ./.github/actions/build-greptime-images
-      with: # The image will be used as '${{ inputs.image-registry }}/${{ inputs.image-namespace }}/${{ inputs.image-name }}:${{ inputs.version }}'
-        image-registry: ${{ inputs.image-registry }}
-        image-namespace: ${{ inputs.image-namespace }}
-        image-registry-username: ${{ inputs.image-registry-username }}
-        image-registry-password: ${{ inputs.image-registry-password }}
-        image-name: ${{ inputs.image-name }}
-        image-tag: ${{ inputs.version }}
-        docker-file: docker/ci/ubuntu/Dockerfile
-        amd64-artifact-name: greptime-linux-amd64-pyo3-${{ inputs.version }}
-        arm64-artifact-name: greptime-linux-arm64-pyo3-${{ inputs.version }}
-        platforms: linux/amd64,linux/arm64
-        push-latest-tag: ${{ inputs.push-latest-tag }}
-
-    - name: Build and push centos images to dockerhub
-      if: ${{ inputs.dev-mode == 'false' }}
-      uses: ./.github/actions/build-greptime-images
-      with:
-        image-registry: ${{ inputs.image-registry }}
-        image-namespace: ${{ inputs.image-namespace }}
-        image-registry-username: ${{ inputs.image-registry-username }}
-        image-registry-password: ${{ inputs.image-registry-password }}
-        image-name: ${{ inputs.image-name }}-centos
-        image-tag: ${{ inputs.version }}
-        docker-file: docker/ci/centos/Dockerfile
-        amd64-artifact-name: greptime-linux-amd64-centos-${{ inputs.version }}
-        platforms: linux/amd64
-        push-latest-tag: ${{ inputs.push-latest-tag }}

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

@@ -1,116 +0,0 @@
-name: Build linux artifacts
-description: Build linux artifacts
-inputs:
-  arch:
-    description: Architecture to build
-    required: true
-  cargo-profile:
-    description: Cargo profile to build
-    required: true
-  version:
-    description: Version of the artifact
-    required: true
-  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
-    default: .
-runs:
-  using: composite
-  steps:
-    - name: Run integration test
-      if: ${{ inputs.disable-run-tests == 'false' }}
-      shell: bash
-      # NOTE: If the BUILD_JOBS > 4, it's always OOM in EC2 instance.
-      run: |
-        cd ${{ inputs.working-dir }} && \
-        make run-it-in-container BUILD_JOBS=4
-
-    - name: Upload sqlness logs
-      if: ${{ failure() && inputs.disable-run-tests == 'false' }} # Only upload logs when the integration tests failed.
-      uses: actions/upload-artifact@v3
-      with:
-        name: sqlness-logs
-        path: /tmp/greptime-*.log
-        retention-days: 3
-
-    - name: Build standard greptime
-      uses: ./.github/actions/build-greptime-binary
-      with:
-        base-image: ubuntu
-        features: pyo3_backend,servers/dashboard
-        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
-      if: ${{ inputs.dev-mode == 'false' }}
-      uses: ./.github/actions/build-greptime-binary
-      with:
-        base-image: ubuntu
-        features: servers/dashboard
-        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.
-      shell: bash
-      run: |
-        rm -rf ./target/
-
-    - name: Build greptime on centos base image
-      uses: ./.github/actions/build-greptime-binary
-      if: ${{ inputs.arch == 'amd64' && inputs.dev-mode == 'false' }} # Only build centos7 base image for amd64.
-      with:
-        base-image: centos
-        features: servers/dashboard
-        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 }}

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

@@ -1,105 +0,0 @@
-name: Build macos artifacts
-description: Build macos 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
-  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:
-    - name: Cache cargo assets
-      id: cache
-      uses: actions/cache@v3
-      with:
-        path: |
-          ~/.cargo/bin/
-          ~/.cargo/registry/index/
-          ~/.cargo/registry/cache/
-          ~/.cargo/git/db/
-          target/
-        key: ${{ inputs.arch }}-build-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-    - name: Install protoc
-      shell: bash
-      run: |
-        brew install protobuf
-
-    - name: Install rust toolchain
-      uses: dtolnay/rust-toolchain@master
-      with:
-        toolchain: ${{ inputs.rust-toolchain }}
-        targets: ${{ inputs.arch }}
-
-    - name: Start etcd # For integration tests.
-      if: ${{ inputs.disable-run-tests == 'false' }}
-      shell: bash
-      run: |
-        brew install etcd && \
-        brew services start etcd
-
-    - 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: bash
-      run: |
-        make test sqlness-test
-
-    - name: Upload sqlness logs
-      if: ${{ failure() }} # Only upload logs when the integration tests failed.
-      uses: actions/upload-artifact@v3
-      with:
-        name: sqlness-logs
-        path: /tmp/greptime-*.log
-        retention-days: 3
-
-    - name: Build greptime binary
-      shell: bash
-      run: |
-        make build \
-        CARGO_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 }}
-        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/release-artifacts/action.yml

@@ -1,50 +0,0 @@
-name: Release artifacts
-description: Release artifacts
-inputs:
-  version:
-    description: Version to release
-    required: true
-runs:
-  using: composite
-  steps:
-    # Download artifacts from previous jobs, the artifacts will be downloaded to:
-    # ${WORKING_DIR}
-    #   |- greptime-darwin-amd64-pyo3-v0.5.0/greptime-darwin-amd64-pyo3-v0.5.0.tar.gz
-    #   |- greptime-darwin-amd64-pyo3-v0.5.0.sha256sum/greptime-darwin-amd64-pyo3-v0.5.0.sha256sum
-    #   |- greptime-darwin-amd64-v0.5.0/greptime-darwin-amd64-v0.5.0.tar.gz
-    #   |- greptime-darwin-amd64-v0.5.0.sha256sum/greptime-darwin-amd64-v0.5.0.sha256sum
-    #   ...
-    - name: Download artifacts
-      uses: actions/download-artifact@v3
-
-    - name: Create git tag for release
-      if: ${{ github.event_name != 'push' }} # Meaning this is a scheduled or manual workflow.
-      shell: bash
-      run: |
-        git tag ${{ inputs.version }}
-
-    # Only publish release when the release tag is like v1.0.0, v1.0.1, v1.0.2, etc.
-    - name: Set release arguments
-      shell: bash
-      run: |
-        if [[ "${{ inputs.version }}" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-          echo "prerelease=false" >> $GITHUB_ENV
-          echo "makeLatest=true" >> $GITHUB_ENV
-          echo "generateReleaseNotes=false" >> $GITHUB_ENV
-        else
-          echo "prerelease=true" >> $GITHUB_ENV
-          echo "makeLatest=false" >> $GITHUB_ENV
-          echo "generateReleaseNotes=true" >> $GITHUB_ENV
-        fi
-
-    - name: Publish release
-      uses: ncipollo/release-action@v1
-      with:
-        name: "Release ${{ inputs.version }}"
-        prerelease: ${{ env.prerelease }}
-        makeLatest: ${{ env.makeLatest }}
-        tag: ${{ inputs.version }}
-        generateReleaseNotes: ${{ env.generateReleaseNotes }}
-        allowUpdates: true
-        artifacts: |
-          **/greptime-*/*

.github/actions/start-runner/action.yml

@@ -1,67 +0,0 @@
-name: Start EC2 runner
-description: Start EC2 runner
-inputs:
-  runner:
-    description: The linux runner name
-    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
-  github-token:
-    description: The GitHub token to clone private repository
-    required: false
-    default: ""
-  image-id:
-    description: The EC2 image id
-    required: true
-  security-group-id:
-    description: The EC2 security group id
-    required: true
-  subnet-id:
-    description: The EC2 subnet id
-    required: true
-outputs:
-  label:
-    description: "label"
-    value: ${{ steps.start-linux-arm64-ec2-runner.outputs.label || inputs.runner }}
-  ec2-instance-id:
-    description: "ec2-instance-id"
-    value: ${{ steps.start-linux-arm64-ec2-runner.outputs.ec2-instance-id }}
-runs:
-  using: composite
-  steps:
-    - name: Configure AWS credentials
-      if: startsWith(inputs.runner, 'ec2')
-      uses: aws-actions/configure-aws-credentials@v2
-      with:
-        aws-access-key-id: ${{ inputs.aws-access-key-id }}
-        aws-secret-access-key: ${{ inputs.aws-secret-access-key }}
-        aws-region: ${{ inputs.aws-region }}
-
-    # The EC2 runner will use the following format:
-    # <vm-type>-<instance-type>-<arch>
-    # like 'ec2-c6a.4xlarge-amd64'.
-    - name: Get EC2 instance type
-      if: startsWith(inputs.runner, 'ec2')
-      id: get-ec2-instance-type
-      shell: bash
-      run: |
-        echo "instance-type=$(echo ${{ inputs.runner }} | cut -d'-' -f2)" >> $GITHUB_OUTPUT
-
-    - name: Start EC2 runner
-      if: startsWith(inputs.runner, 'ec2')
-      uses: machulav/ec2-github-runner@v2
-      id: start-linux-arm64-ec2-runner
-      with:
-        mode: start
-        ec2-image-id: ${{ inputs.image-id }}
-        ec2-instance-type: ${{ steps.get-ec2-instance-type.outputs.instance-type }}
-        subnet-id: ${{ inputs.subnet-id }}
-        security-group-id: ${{ inputs.security-group-id }}
-        github-token: ${{ inputs.github-token }}

.github/actions/stop-runner/action.yml

@@ -1,41 +0,0 @@
-name: Stop EC2 runner
-description: Stop EC2 runner
-inputs:
-  label:
-    description: The linux runner name
-    required: true
-  ec2-instance-id:
-    description: The EC2 instance id
-    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
-  github-token:
-    description: The GitHub token to clone private repository
-    required: false
-    default: ""
-runs:
-  using: composite
-  steps:
-    - name: Configure AWS credentials
-      if: ${{ inputs.label && inputs.ec2-instance-id }}
-      uses: aws-actions/configure-aws-credentials@v2
-      with:
-        aws-access-key-id: ${{ inputs.aws-access-key-id }}
-        aws-secret-access-key: ${{ inputs.aws-secret-access-key }}
-        aws-region: ${{ inputs.aws-region }}
-
-    - name: Stop EC2 runner
-      if: ${{ inputs.label && inputs.ec2-instance-id }}
-      uses: machulav/ec2-github-runner@v2
-      with:
-        mode: stop
-        label: ${{ inputs.label }}
-        ec2-instance-id: ${{ inputs.ec2-instance-id }}
-        github-token: ${{ inputs.github-token }}

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

@@ -1,125 +0,0 @@
-name: Upload artifacts
-description: Upload artifacts
-inputs:
-  artifacts-dir:
-    description: Directory to store artifacts
-    required: true
-  target-file:
-    description: The path of the target artifact
-    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
-    default: .
-runs:
-  using: composite
-  steps:
-    - name: Create artifacts directory
-      working-directory: ${{ inputs.working-dir }}
-      shell: bash
-      run: |
-        mkdir -p ${{ 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
-    # greptime-linux-amd64-pyo3-v0.3.0.tar.gz
-    #   greptime-linux-amd64-pyo3-v0.3.0
-    #   └── greptime
-    - name: Compress artifacts and calculate checksum
-      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
-
-    # 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@v3' to download the artifacts, it will be automatically unzipped.
-    - name: Upload artifacts
-      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@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/scripts/create-version.sh

@@ -1,68 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-# - If it's a tag push release, the version is the tag name(${{ github.ref_name }});
-# - If it's a scheduled release, the version is '${{ env.NEXT_RELEASE_VERSION }}-nightly-$buildTime', like 'v0.2.0-nightly-20230313';
-# - If it's a manual release, the version is '${{ env.NEXT_RELEASE_VERSION }}-$(git rev-parse --short HEAD)-YYYYMMDDSS', like 'v0.2.0-e5b243c-2023071245';
-# - If it's a nightly build, the version is 'nightly-YYYYMMDD-$(git rev-parse --short HEAD)', like 'nightly-20230712-e5b243c'.
-# create_version ${GIHUB_EVENT_NAME} ${NEXT_RELEASE_VERSION} ${NIGHTLY_RELEASE_PREFIX}
-function create_version() {
-  # Read from envrionment variables.
-  if [ -z "$GITHUB_EVENT_NAME" ]; then
-      echo "GITHUB_EVENT_NAME is empty"
-      exit 1
-  fi
-
-  if [ -z "$NEXT_RELEASE_VERSION" ]; then
-      echo "NEXT_RELEASE_VERSION is empty"
-      exit 1
-  fi
-
-  if [ -z "$NIGHTLY_RELEASE_PREFIX" ]; then
-      echo "NIGHTLY_RELEASE_PREFIX is empty"
-      exit 1
-  fi
-
-  # Reuse $NEXT_RELEASE_VERSION to identify whether it's a nightly build.
-  # It will be like 'nigtly-20230808-7d0d8dc6'.
-  if [ "$NEXT_RELEASE_VERSION" = nightly ]; then
-    echo "$NIGHTLY_RELEASE_PREFIX-$(date "+%Y%m%d")-$(git rev-parse --short HEAD)"
-    exit 0
-  fi
-
-  # Reuse $NEXT_RELEASE_VERSION to identify whether it's a dev build.
-  # It will be like 'dev-2023080819-f0e7216c'.
-  if [ "$NEXT_RELEASE_VERSION" = dev ]; then
-    if [ -z "$COMMIT_SHA" ]; then
-      echo "COMMIT_SHA is empty in dev build"
-      exit 1
-    fi
-    echo "dev-$(date "+%Y%m%d-%s")-$(echo "$COMMIT_SHA" | cut -c1-8)"
-    exit 0
-  fi
-
-  # Note: Only output 'version=xxx' to stdout when everything is ok, so that it can be used in GitHub Actions Outputs.
-  if [ "$GITHUB_EVENT_NAME" = push ]; then
-    if [ -z "$GITHUB_REF_NAME" ]; then
-      echo "GITHUB_REF_NAME is empty in push event"
-      exit 1
-    fi
-    echo "$GITHUB_REF_NAME"
-  elif [ "$GITHUB_EVENT_NAME" = workflow_dispatch ]; then
-    echo "$NEXT_RELEASE_VERSION-$(git rev-parse --short HEAD)-$(date "+%Y%m%d-%s")"
-  elif [ "$GITHUB_EVENT_NAME" = schedule ]; then
-    echo "$NEXT_RELEASE_VERSION-$NIGHTLY_RELEASE_PREFIX-$(date "+%Y%m%d")"
-  else
-    echo "Unsupported GITHUB_EVENT_NAME: $GITHUB_EVENT_NAME"
-    exit 1
-  fi
-}
-
-# You can run as following examples:
-#  GITHUB_EVENT_NAME=push NEXT_RELEASE_VERSION=v0.4.0 NIGHTLY_RELEASE_PREFIX=nigtly GITHUB_REF_NAME=v0.3.0 ./create-version.sh
-#  GITHUB_EVENT_NAME=workflow_dispatch NEXT_RELEASE_VERSION=v0.4.0 NIGHTLY_RELEASE_PREFIX=nigtly ./create-version.sh
-#  GITHUB_EVENT_NAME=schedule NEXT_RELEASE_VERSION=v0.4.0 NIGHTLY_RELEASE_PREFIX=nigtly ./create-version.sh
-#  GITHUB_EVENT_NAME=schedule NEXT_RELEASE_VERSION=nightly NIGHTLY_RELEASE_PREFIX=nigtly ./create-version.sh
-#  GITHUB_EVENT_NAME=workflow_dispatch COMMIT_SHA=f0e7216c4bb6acce9b29a21ec2d683be2e3f984a NEXT_RELEASE_VERSION=dev NIGHTLY_RELEASE_PREFIX=nigtly ./create-version.sh
-create_version

.github/workflows/apidoc.yml

@@ -13,7 +13,7 @@ on:
 name: Build API docs
 
 env:
-  RUST_TOOLCHAIN: nightly-2023-08-07
+  RUST_TOOLCHAIN: nightly-2023-02-26
 
 jobs:
   apidoc:

.github/workflows/dev-build.yml

@@ -1,344 +0,0 @@
-# Development build only build the debug version of the artifacts manually.
-name: GreptimeDB Development Build
-
-on:
-  workflow_dispatch: # Allows you to run this workflow manually.
-    inputs:
-      repository:
-        description: The public repository to build
-        required: false
-        default: GreptimeTeam/greptimedb
-      commit: # Note: We only pull the source code and use the current workflow to build the artifacts.
-        description: The commit to build
-        required: true
-      linux_amd64_runner:
-        type: choice
-        description: The runner uses to build linux-amd64 artifacts
-        default: ec2-c6i.4xlarge-amd64
-        options:
-          - 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
-          - ec2-c6i.8xlarge-amd64 # 32C64G
-          - ec2-c6i.16xlarge-amd64 # 64C128G
-      linux_arm64_runner:
-        type: choice
-        description: The runner uses to build linux-arm64 artifacts
-        default: ec2-c6g.4xlarge-arm64
-        options:
-          - ec2-c6g.xlarge-arm64 # 4C8G
-          - ec2-c6g.2xlarge-arm64 # 8C16G
-          - ec2-c6g.4xlarge-arm64 # 16C32G
-          - ec2-c6g.8xlarge-arm64 # 32C64G
-          - ec2-c6g.16xlarge-arm64 # 64C128G
-      skip_test:
-        description: Do not run integration tests during the build
-        type: boolean
-        default: true
-      build_linux_amd64_artifacts:
-        type: boolean
-        description: Build linux-amd64 artifacts
-        required: false
-        default: true
-      build_linux_arm64_artifacts:
-        type: boolean
-        description: Build linux-arm64 artifacts
-        required: false
-        default: true
-      release_images:
-        type: boolean
-        description: Build and push images to DockerHub and ACR
-        required: false
-        default: true
-
-# Use env variables to control all the release process.
-env:
-  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 }}
-
-  # Always use 'dev' to indicate it's the dev build.
-  NEXT_RELEASE_VERSION: dev
-
-  NIGHTLY_RELEASE_PREFIX: nightly
-
-  # Use the different image name to avoid conflict with the release images.
-  IMAGE_NAME: greptimedb-dev
-
-  # The source code will check out in the following path: '${WORKING_DIR}/dev/greptime'.
-  CHECKOUT_GREPTIMEDB_PATH: dev/greptimedb
-
-jobs:
-  allocate-runners:
-    name: Allocate runners
-    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    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 }}
-
-      # The following EC2 resource id will be used for resource releasing.
-      linux-amd64-ec2-runner-label: ${{ steps.start-linux-amd64-runner.outputs.label }}
-      linux-amd64-ec2-runner-instance-id: ${{ steps.start-linux-amd64-runner.outputs.ec2-instance-id }}
-      linux-arm64-ec2-runner-label: ${{ steps.start-linux-arm64-runner.outputs.label }}
-      linux-arm64-ec2-runner-instance-id: ${{ steps.start-linux-arm64-runner.outputs.ec2-instance-id }}
-
-      # The 'version' use as the global tag name of the release workflow.
-      version: ${{ steps.create-version.outputs.version }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Create version
-        id: create-version
-        run: |
-          version=$(./.github/scripts/create-version.sh) && \
-          echo $version && \
-          echo "version=$version" >> $GITHUB_OUTPUT
-        env:
-          GITHUB_EVENT_NAME: ${{ github.event_name }}
-          GITHUB_REF_NAME: ${{ github.ref_name }}
-          COMMIT_SHA: ${{ inputs.commit }}
-          NEXT_RELEASE_VERSION: ${{ env.NEXT_RELEASE_VERSION }}
-          NIGHTLY_RELEASE_PREFIX: ${{ env.NIGHTLY_RELEASE_PREFIX }}
-
-      - name: Allocate linux-amd64 runner
-        if: ${{ inputs.build_linux_amd64_artifacts || github.event_name == 'schedule' }}
-        uses: ./.github/actions/start-runner
-        id: start-linux-amd64-runner
-        with:
-          runner: ${{ inputs.linux_amd64_runner || vars.DEFAULT_AMD64_RUNNER }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.EC2_RUNNER_REGION }}
-          github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
-          image-id: ${{ vars.EC2_RUNNER_LINUX_AMD64_IMAGE_ID }}
-          security-group-id: ${{ vars.EC2_RUNNER_SECURITY_GROUP_ID }}
-          subnet-id: ${{ vars.EC2_RUNNER_SUBNET_ID }}
-
-      - name: Allocate linux-arm64 runner
-        if: ${{ inputs.build_linux_arm64_artifacts || github.event_name == 'schedule' }}
-        uses: ./.github/actions/start-runner
-        id: start-linux-arm64-runner
-        with:
-          runner: ${{ inputs.linux_arm64_runner || vars.DEFAULT_ARM64_RUNNER }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.EC2_RUNNER_REGION }}
-          github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
-          image-id: ${{ vars.EC2_RUNNER_LINUX_ARM64_IMAGE_ID }}
-          security-group-id: ${{ vars.EC2_RUNNER_SECURITY_GROUP_ID }}
-          subnet-id: ${{ vars.EC2_RUNNER_SUBNET_ID }}
-
-  build-linux-amd64-artifacts:
-    name: Build linux-amd64 artifacts
-    if: ${{ inputs.build_linux_amd64_artifacts || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-    ]
-    runs-on: ${{ needs.allocate-runners.outputs.linux-amd64-runner }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Checkout greptimedb
-        uses: actions/checkout@v3
-        with:
-          repository: ${{ inputs.repository }}
-          ref: ${{ inputs.commit }}
-          path: ${{ env.CHECKOUT_GREPTIMEDB_PATH }}
-
-      - uses: ./.github/actions/build-linux-artifacts
-        with:
-          arch: amd64
-          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:
-    name: Build linux-arm64 artifacts
-    if: ${{ inputs.build_linux_arm64_artifacts || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-    ]
-    runs-on: ${{ needs.allocate-runners.outputs.linux-arm64-runner }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Checkout greptimedb
-        uses: actions/checkout@v3
-        with:
-          repository: ${{ inputs.repository }}
-          ref: ${{ inputs.commit }}
-          path: ${{ env.CHECKOUT_GREPTIMEDB_PATH }}
-
-      - uses: ./.github/actions/build-linux-artifacts
-        with:
-          arch: arm64
-          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:
-    name: Build and push images to DockerHub
-    if: ${{ inputs.release_images || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-      build-linux-arm64-artifacts,
-    ]
-    runs-on: ubuntu-latest
-    outputs:
-      build-result: ${{ steps.set-build-result.outputs.build-result }}
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Build and push images to dockerhub
-        uses: ./.github/actions/build-images
-        with:
-          image-registry: docker.io
-          image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          image-name: ${{ env.IMAGE_NAME }}
-          image-registry-username: ${{ secrets.DOCKERHUB_USERNAME }}
-          image-registry-password: ${{ secrets.DOCKERHUB_TOKEN }}
-          version: ${{ needs.allocate-runners.outputs.version }}
-          push-latest-tag: false # Don't push the latest tag to registry.
-          dev-mode: true # Only build the standard images.
-
-      - name: Set build result
-        id: set-build-result
-        run: |
-          echo "build-result=success" >> $GITHUB_OUTPUT
-
-  release-images-to-acr:
-    name: Build and push images to ACR
-    if: ${{ inputs.release_images || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-      build-linux-arm64-artifacts,
-    ]
-    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@v3
-        with:
-          fetch-depth: 0
-
-      - name: Build and push images to ACR
-        uses: ./.github/actions/build-images
-        with:
-          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 }}
-          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-latest
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-    ]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Stop EC2 runner
-        uses: ./.github/actions/stop-runner
-        with:
-          label: ${{ needs.allocate-runners.outputs.linux-amd64-ec2-runner-label }}
-          ec2-instance-id: ${{ needs.allocate-runners.outputs.linux-amd64-ec2-runner-instance-id }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.EC2_RUNNER_REGION }}
-          github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
-
-  stop-linux-arm64-runner: # It's always run as the last job in the workflow to make sure that the runner is released.
-    name: Stop linux-arm64 runner
-    # Only run this job when the runner is allocated.
-    if: ${{ always() }}
-    runs-on: ubuntu-latest
-    needs: [
-      allocate-runners,
-      build-linux-arm64-artifacts,
-    ]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Stop EC2 runner
-        uses: ./.github/actions/stop-runner
-        with:
-          label: ${{ needs.allocate-runners.outputs.linux-arm64-ec2-runner-label }}
-          ec2-instance-id: ${{ needs.allocate-runners.outputs.linux-arm64-ec2-runner-instance-id }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          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
-    ]
-    runs-on: ubuntu-latest
-    env:
-      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_DEVELOP_CHANNEL }}
-    steps:
-      - 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 nightly build failed 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 failed, please check 'https://github.com/GreptimeTeam/greptimedb/actions/workflows/${{ env.NEXT_RELEASE_VERSION }}-build.yml'."}

.github/workflows/develop.yml

@@ -1,5 +1,4 @@
 on:
-  merge_group:
   pull_request:
     types: [opened, synchronize, reopened, ready_for_review]
     paths-ignore:
@@ -24,12 +23,8 @@ on:
 
 name: CI
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
 env:
-  RUST_TOOLCHAIN: nightly-2023-08-07
+  RUST_TOOLCHAIN: nightly-2023-02-26
 
 jobs:
   typos:
@@ -55,7 +50,7 @@ jobs:
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
       - name: Run cargo check
-        run: cargo check --locked --workspace --all-targets
+        run: cargo check --workspace --all-targets
 
   toml:
     name: Toml Check
@@ -66,22 +61,62 @@ jobs:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: stable
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
       - name: Install taplo
-        run: cargo +stable install taplo-cli --version ^0.8 --locked
+        run: cargo install taplo-cli --version ^0.8 --locked
       - name: Run taplo
-        run: taplo format --check
+        run: taplo format --check --option "indent_string=    "
+
+  # Use coverage to run test.
+  # test:
+  #   name: Test Suite
+  #   if: github.event.pull_request.draft == false
+  #   runs-on: ubuntu-latest
+  #   timeout-minutes: 60
+  #   steps:
+  #     - uses: actions/checkout@v3
+  #     - name: Cache LLVM and Clang
+  #       id: cache-llvm
+  #       uses: actions/cache@v3
+  #       with:
+  #         path: ./llvm
+  #         key: llvm
+  #     - uses: arduino/setup-protoc@v1
+  #       with:
+  #         repo-token: ${{ secrets.GITHUB_TOKEN }}
+  #     - uses: KyleMayes/install-llvm-action@v1
+  #       with:
+  #         version: "14.0"
+  #         cached: ${{ steps.cache-llvm.outputs.cache-hit }}
+  #     - uses: dtolnay/rust-toolchain@master
+  #       with:
+  #         toolchain: ${{ env.RUST_TOOLCHAIN }}
+  #     - name: Rust Cache
+  #       uses: Swatinem/rust-cache@v2
+  #     - name: Cleanup disk
+  #       uses: curoky/cleanup-disk-action@v2.0
+  #       with:
+  #         retain: 'rust,llvm'
+  #     - name: Install latest nextest release
+  #       uses: taiki-e/install-action@nextest
+  #     - name: Run tests
+  #       run: cargo nextest run
+  #       env:
+  #         CARGO_BUILD_RUSTFLAGS: "-C link-arg=-fuse-ld=lld"
+  #         RUST_BACKTRACE: 1
+  #         GT_S3_BUCKET: ${{ secrets.S3_BUCKET }}
+  #         GT_S3_ACCESS_KEY_ID: ${{ secrets.S3_ACCESS_KEY_ID }}
+  #         GT_S3_ACCESS_KEY: ${{ secrets.S3_ACCESS_KEY }}
+  #         UNITTEST_LOG_DIR: "__unittest_logs"
 
   sqlness:
     name: Sqlness Test
     if: github.event.pull_request.draft == false
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-latest-8-cores, windows-latest-8-cores ]
+    runs-on: ubuntu-latest-8-cores
     timeout-minutes: 60
+    needs: [clippy]
     steps:
       - uses: actions/checkout@v3
       - uses: arduino/setup-protoc@v1
@@ -92,14 +127,24 @@ jobs:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
+      - name: Run etcd
+        run: |
+          ETCD_VER=v3.5.7
+          DOWNLOAD_URL=https://github.com/etcd-io/etcd/releases/download
+          curl -L ${DOWNLOAD_URL}/${ETCD_VER}/etcd-${ETCD_VER}-linux-amd64.tar.gz -o /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
+          mkdir -p /tmp/etcd-download
+          tar xzvf /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz -C /tmp/etcd-download --strip-components=1
+          rm -f /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
+
+          sudo cp -a /tmp/etcd-download/etcd* /usr/local/bin/
+          nohup etcd >/tmp/etcd.log 2>&1 &
       - name: Run sqlness
-        run: cargo sqlness
+        run: cargo sqlness && ls /tmp
       - name: Upload sqlness logs
-        if: always()
         uses: actions/upload-artifact@v3
         with:
           name: sqlness-logs
-          path: ${{ runner.temp }}/greptime-*.log
+          path: /tmp/greptime-*.log
           retention-days: 3
 
   fmt:
@@ -144,6 +189,7 @@ jobs:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest-8-cores
     timeout-minutes: 60
+    needs: [clippy]
     steps:
       - uses: actions/checkout@v3
       - uses: arduino/setup-protoc@v1
@@ -170,7 +216,7 @@ jobs:
       - 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
+        run: cargo llvm-cov nextest --workspace --lcov --output-path lcov.info -F pyo3_backend
         env:
           CARGO_BUILD_RUSTFLAGS: "-C link-arg=-fuse-ld=lld"
           RUST_BACKTRACE: 1
@@ -178,7 +224,6 @@ jobs:
           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: Codecov upload
         uses: codecov/codecov-action@v2
@@ -188,43 +233,3 @@ jobs:
           flags: rust
           fail_ci_if_error: false
           verbose: true
-
-  test-on-windows:
-    if: github.event.pull_request.draft == false
-    runs-on: windows-latest-8-cores
-    timeout-minutes: 60
-    steps:
-      - run: git config --global core.autocrlf false
-      - uses: actions/checkout@v3
-      - uses: arduino/setup-protoc@v1
-        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@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/docs.yml

@@ -1,5 +1,4 @@
 on:
-  merge_group:
   pull_request:
     types: [opened, synchronize, reopened, ready_for_review]
     paths:
@@ -28,13 +27,6 @@ name: CI
 # https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/defining-the-mergeability-of-pull-requests/troubleshooting-required-status-checks#handling-skipped-but-required-checks
 
 jobs:
-  typos:
-    name: Spell Check with Typos
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: crate-ci/typos@v1.13.10
-
   check:
     name: Check
     if: github.event.pull_request.draft == false
@@ -61,10 +53,3 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - run: 'echo "No action required"'
-
-  sqlness:
-    name: Sqlness Test
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    steps:
-      - run: 'echo "No action required"'

.github/workflows/nightly-build.yml

@@ -1,311 +0,0 @@
-# Nightly build only do the following things:
-# 1. Run integration tests;
-# 2. Build binaries and images for linux-amd64 and linux-arm64 platform;
-name: GreptimeDB Nightly Build
-
-on:
-  schedule:
-    # Trigger at 00:00(UTC) on every day-of-week from Monday through Friday.
-    - cron: '0 0 * * 1-5'
-  workflow_dispatch: # Allows you to run this workflow manually.
-    inputs:
-      linux_amd64_runner:
-        type: choice
-        description: The runner uses to build linux-amd64 artifacts
-        default: ec2-c6i.2xlarge-amd64
-        options:
-          - 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
-          - ec2-c6i.8xlarge-amd64 # 32C64G
-          - ec2-c6i.16xlarge-amd64 # 64C128G
-      linux_arm64_runner:
-        type: choice
-        description: The runner uses to build linux-arm64 artifacts
-        default: ec2-c6g.2xlarge-arm64
-        options:
-          - ec2-c6g.xlarge-arm64 # 4C8G
-          - ec2-c6g.2xlarge-arm64 # 8C16G
-          - ec2-c6g.4xlarge-arm64 # 16C32G
-          - ec2-c6g.8xlarge-arm64 # 32C64G
-          - ec2-c6g.16xlarge-arm64 # 64C128G
-      skip_test:
-        description: Do not run integration tests during the build
-        type: boolean
-        default: true
-      build_linux_amd64_artifacts:
-        type: boolean
-        description: Build linux-amd64 artifacts
-        required: false
-        default: false
-      build_linux_arm64_artifacts:
-        type: boolean
-        description: Build linux-arm64 artifacts
-        required: false
-        default: false
-      release_images:
-        type: boolean
-        description: Build and push images to DockerHub and ACR
-        required: false
-        default: false
-
-# Use env variables to control all the release process.
-env:
-  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 }}
-
-  # Always use 'nightly' to indicate it's the nightly build.
-  NEXT_RELEASE_VERSION: nightly
-
-  NIGHTLY_RELEASE_PREFIX: nightly
-
-jobs:
-  allocate-runners:
-    name: Allocate runners
-    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    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 }}
-
-      # The following EC2 resource id will be used for resource releasing.
-      linux-amd64-ec2-runner-label: ${{ steps.start-linux-amd64-runner.outputs.label }}
-      linux-amd64-ec2-runner-instance-id: ${{ steps.start-linux-amd64-runner.outputs.ec2-instance-id }}
-      linux-arm64-ec2-runner-label: ${{ steps.start-linux-arm64-runner.outputs.label }}
-      linux-arm64-ec2-runner-instance-id: ${{ steps.start-linux-arm64-runner.outputs.ec2-instance-id }}
-
-      # The 'version' use as the global tag name of the release workflow.
-      version: ${{ steps.create-version.outputs.version }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Create version
-        id: create-version
-        run: |
-          version=$(./.github/scripts/create-version.sh) && \
-          echo $version && \
-          echo "version=$version" >> $GITHUB_OUTPUT
-        env:
-          GITHUB_EVENT_NAME: ${{ github.event_name }}
-          GITHUB_REF_NAME: ${{ github.ref_name }}
-          NEXT_RELEASE_VERSION: ${{ env.NEXT_RELEASE_VERSION }}
-          NIGHTLY_RELEASE_PREFIX: ${{ env.NIGHTLY_RELEASE_PREFIX }}
-
-      - name: Allocate linux-amd64 runner
-        if: ${{ inputs.build_linux_amd64_artifacts || github.event_name == 'schedule' }}
-        uses: ./.github/actions/start-runner
-        id: start-linux-amd64-runner
-        with:
-          runner: ${{ inputs.linux_amd64_runner || vars.DEFAULT_AMD64_RUNNER }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.EC2_RUNNER_REGION }}
-          github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
-          image-id: ${{ vars.EC2_RUNNER_LINUX_AMD64_IMAGE_ID }}
-          security-group-id: ${{ vars.EC2_RUNNER_SECURITY_GROUP_ID }}
-          subnet-id: ${{ vars.EC2_RUNNER_SUBNET_ID }}
-
-      - name: Allocate linux-arm64 runner
-        if: ${{ inputs.build_linux_arm64_artifacts || github.event_name == 'schedule' }}
-        uses: ./.github/actions/start-runner
-        id: start-linux-arm64-runner
-        with:
-          runner: ${{ inputs.linux_arm64_runner || vars.DEFAULT_ARM64_RUNNER }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.EC2_RUNNER_REGION }}
-          github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
-          image-id: ${{ vars.EC2_RUNNER_LINUX_ARM64_IMAGE_ID }}
-          security-group-id: ${{ vars.EC2_RUNNER_SECURITY_GROUP_ID }}
-          subnet-id: ${{ vars.EC2_RUNNER_SUBNET_ID }}
-
-  build-linux-amd64-artifacts:
-    name: Build linux-amd64 artifacts
-    if: ${{ inputs.build_linux_amd64_artifacts || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-    ]
-    runs-on: ${{ needs.allocate-runners.outputs.linux-amd64-runner }}
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - uses: ./.github/actions/build-linux-artifacts
-        with:
-          arch: amd64
-          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
-    if: ${{ inputs.build_linux_arm64_artifacts || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-    ]
-    runs-on: ${{ needs.allocate-runners.outputs.linux-arm64-runner }}
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - uses: ./.github/actions/build-linux-artifacts
-        with:
-          arch: arm64
-          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
-    if: ${{ inputs.release_images || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-      build-linux-arm64-artifacts,
-    ]
-    runs-on: ubuntu-latest
-    outputs:
-      nightly-build-result: ${{ steps.set-nightly-build-result.outputs.nightly-build-result }}
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Build and push images to dockerhub
-        uses: ./.github/actions/build-images
-        with:
-          image-registry: docker.io
-          image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          image-registry-username: ${{ secrets.DOCKERHUB_USERNAME }}
-          image-registry-password: ${{ secrets.DOCKERHUB_TOKEN }}
-          version: ${{ needs.allocate-runners.outputs.version }}
-          push-latest-tag: false # Don't push the latest tag to registry.
-
-      - name: Set nightly build result
-        id: set-nightly-build-result
-        run: |
-          echo "nightly-build-result=success" >> $GITHUB_OUTPUT
-
-  release-images-to-acr:
-    name: Build and push images to ACR
-    if: ${{ inputs.release_images || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-      build-linux-arm64-artifacts,
-    ]
-    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@v3
-        with:
-          fetch-depth: 0
-
-      - name: Build and push images to ACR
-        uses: ./.github/actions/build-images
-        with:
-          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 }}
-          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-latest
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-    ]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Stop EC2 runner
-        uses: ./.github/actions/stop-runner
-        with:
-          label: ${{ needs.allocate-runners.outputs.linux-amd64-ec2-runner-label }}
-          ec2-instance-id: ${{ needs.allocate-runners.outputs.linux-amd64-ec2-runner-instance-id }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.EC2_RUNNER_REGION }}
-          github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
-
-  stop-linux-arm64-runner: # It's always run as the last job in the workflow to make sure that the runner is released.
-    name: Stop linux-arm64 runner
-    # Only run this job when the runner is allocated.
-    if: ${{ always() }}
-    runs-on: ubuntu-latest
-    needs: [
-      allocate-runners,
-      build-linux-arm64-artifacts,
-    ]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Stop EC2 runner
-        uses: ./.github/actions/stop-runner
-        with:
-          label: ${{ needs.allocate-runners.outputs.linux-arm64-ec2-runner-label }}
-          ec2-instance-id: ${{ needs.allocate-runners.outputs.linux-arm64-ec2-runner-instance-id }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          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
-    ]
-    runs-on: ubuntu-latest
-    env:
-      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_DEVELOP_CHANNEL }}
-    steps:
-      - name: Notifiy nightly build successful result
-        uses: slackapi/slack-github-action@v1.23.0
-        if: ${{ needs.release-images-to-dockerhub.outputs.nightly-build-result == 'success' }}
-        with:
-          payload: |
-            {"text": "GreptimeDB's ${{ env.NEXT_RELEASE_VERSION }} build has completed successfully."}
-
-      - name: Notifiy nightly build failed result
-        uses: slackapi/slack-github-action@v1.23.0
-        if: ${{ needs.release-images-to-dockerhub.outputs.nightly-build-result != 'success' }}
-        with:
-          payload: |
-            {"text": "GreptimeDB's ${{ env.NEXT_RELEASE_VERSION }} build has failed, please check 'https://github.com/GreptimeTeam/greptimedb/actions/workflows/${{ env.NEXT_RELEASE_VERSION }}-build.yml'."}

.github/workflows/release.yml

@@ -1,8 +1,3 @@
-name: Release
-
-# There are two kinds of formal release:
-# 1. The tag('v*.*.*') push release: the release workflow will be triggered by the tag push event.
-# 2. The scheduled release(the version will be '${{ env.NEXT_RELEASE_VERSION }}-nightly-YYYYMMDD'): the release workflow will be triggered by the schedule event.
 on:
   push:
     tags:
@@ -10,386 +5,339 @@ on:
   schedule:
     # At 00:00 on Monday.
     - cron: '0 0 * * 1'
-  workflow_dispatch: # Allows you to run this workflow manually.
-    # Notes: The GitHub Actions ONLY support 10 inputs, and it's already used up.
-    inputs:
-      linux_amd64_runner:
-        type: choice
-        description: The runner uses to build linux-amd64 artifacts
-        default: ec2-c6i.4xlarge-amd64
-        options:
-          - 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
-          - ec2-c6i.8xlarge-amd64 # 32C64G
-          - ec2-c6i.16xlarge-amd64 # 64C128G
-      linux_arm64_runner:
-        type: choice
-        description: The runner uses to build linux-arm64 artifacts
-        default: ec2-c6g.4xlarge-arm64
-        options:
-          - ec2-c6g.xlarge-arm64 # 4C8G
-          - ec2-c6g.2xlarge-arm64 # 8C16G
-          - ec2-c6g.4xlarge-arm64 # 16C32G
-          - ec2-c6g.8xlarge-arm64 # 32C64G
-          - ec2-c6g.16xlarge-arm64 # 64C128G
-      macos_runner:
-        type: choice
-        description: The runner uses to build macOS artifacts
-        default: macos-latest
-        options:
-          - macos-latest
-      skip_test:
-        description: Do not run integration tests during the build
-        type: boolean
-        default: true
-      build_linux_amd64_artifacts:
-        type: boolean
-        description: Build linux-amd64 artifacts
-        required: false
-        default: false
-      build_linux_arm64_artifacts:
-        type: boolean
-        description: Build linux-arm64 artifacts
-        required: false
-        default: false
-      build_macos_artifacts:
-        type: boolean
-        description: Build macos artifacts
-        required: false
-        default: false
-      release_artifacts:
-        type: boolean
-        description: Create GitHub release and upload artifacts
-        required: false
-        default: false
-      release_images:
-        type: boolean
-        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
+  # Mannually trigger only builds binaries.
+  workflow_dispatch:
+
+name: Release
 
-# Use env variables to control all the release process.
 env:
-  # The arguments of building greptime.
-  RUST_TOOLCHAIN: nightly-2023-08-07
+  RUST_TOOLCHAIN: nightly-2023-02-26
+
+  SCHEDULED_BUILD_VERSION_PREFIX: v0.2.0
+
+  SCHEDULED_PERIOD: nightly
+
   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 }}
-
-  # 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.4.0
+  ## FIXME(zyy17): Enable it after the tests are stabled.
+  DISABLE_RUN_TESTS: true
 
 jobs:
-  allocate-runners:
-    name: Allocate runners
-    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    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 }}
-
-      # The following EC2 resource id will be used for resource releasing.
-      linux-amd64-ec2-runner-label: ${{ steps.start-linux-amd64-runner.outputs.label }}
-      linux-amd64-ec2-runner-instance-id: ${{ steps.start-linux-amd64-runner.outputs.ec2-instance-id }}
-      linux-arm64-ec2-runner-label: ${{ steps.start-linux-arm64-runner.outputs.label }}
-      linux-arm64-ec2-runner-instance-id: ${{ steps.start-linux-arm64-runner.outputs.ec2-instance-id }}
-
-      # The 'version' use as the global tag name of the release workflow.
-      version: ${{ steps.create-version.outputs.version }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      # The create-version will create a global variable named 'version' in the global workflows.
-      # - If it's a tag push release, the version is the tag name(${{ github.ref_name }});
-      # - If it's a scheduled release, the version is '${{ env.NEXT_RELEASE_VERSION }}-nightly-$buildTime', like v0.2.0-nigthly-20230313;
-      # - If it's a manual release, the version is '${{ env.NEXT_RELEASE_VERSION }}-<short-git-sha>-YYYYMMDDSS', like v0.2.0-e5b243c-2023071245;
-      - name: Create version
-        id: create-version
-        run: |
-          echo "version=$(./.github/scripts/create-version.sh)" >> $GITHUB_OUTPUT
-        env:
-          GITHUB_EVENT_NAME: ${{ github.event_name }}
-          GITHUB_REF_NAME: ${{ github.ref_name }}
-          NEXT_RELEASE_VERSION: ${{ env.NEXT_RELEASE_VERSION }}
-          NIGHTLY_RELEASE_PREFIX: ${{ env.NIGHTLY_RELEASE_PREFIX }}
-
-      - name: Allocate linux-amd64 runner
-        if: ${{ inputs.build_linux_amd64_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
-        uses: ./.github/actions/start-runner
-        id: start-linux-amd64-runner
-        with:
-          runner: ${{ inputs.linux_amd64_runner || vars.DEFAULT_AMD64_RUNNER }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.EC2_RUNNER_REGION }}
-          github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
-          image-id: ${{ vars.EC2_RUNNER_LINUX_AMD64_IMAGE_ID }}
-          security-group-id: ${{ vars.EC2_RUNNER_SECURITY_GROUP_ID }}
-          subnet-id: ${{ vars.EC2_RUNNER_SUBNET_ID }}
-
-      - name: Allocate linux-arm64 runner
-        if: ${{ inputs.build_linux_arm64_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
-        uses: ./.github/actions/start-runner
-        id: start-linux-arm64-runner
-        with:
-          runner: ${{ inputs.linux_arm64_runner || vars.DEFAULT_ARM64_RUNNER }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.EC2_RUNNER_REGION }}
-          github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
-          image-id: ${{ vars.EC2_RUNNER_LINUX_ARM64_IMAGE_ID }}
-          security-group-id: ${{ vars.EC2_RUNNER_SECURITY_GROUP_ID }}
-          subnet-id: ${{ vars.EC2_RUNNER_SUBNET_ID }}
-
-  build-linux-amd64-artifacts:
-    name: Build linux-amd64 artifacts
-    if: ${{ inputs.build_linux_amd64_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-    ]
-    runs-on: ${{ needs.allocate-runners.outputs.linux-amd64-runner }}
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - uses: ./.github/actions/build-linux-artifacts
-        with:
-          arch: amd64
-          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
-    if: ${{ inputs.build_linux_arm64_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-    ]
-    runs-on: ${{ needs.allocate-runners.outputs.linux-arm64-runner }}
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - uses: ./.github/actions/build-linux-artifacts
-        with:
-          arch: arm64
-          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
+  build:
+    name: Build binary
     strategy:
-      fail-fast: false
       matrix:
+        # The file format is greptime-<os>-<arch>
         include:
-          - os: ${{ needs.allocate-runners.outputs.macos-runner }}
-            arch: aarch64-apple-darwin
-            features: servers/dashboard
-            artifacts-dir-prefix: greptime-darwin-arm64
-          - os: ${{ needs.allocate-runners.outputs.macos-runner }}
-            arch: aarch64-apple-darwin
-            features: pyo3_backend,servers/dashboard
-            artifacts-dir-prefix: greptime-darwin-arm64-pyo3
-          - os: ${{ needs.allocate-runners.outputs.macos-runner }}
-            features: servers/dashboard
-            arch: x86_64-apple-darwin
-            artifacts-dir-prefix: greptime-darwin-amd64
-          - os: ${{ needs.allocate-runners.outputs.macos-runner }}
-            features: pyo3_backend,servers/dashboard
-            arch: x86_64-apple-darwin
-            artifacts-dir-prefix: greptime-darwin-amd64-pyo3
+          - arch: x86_64-unknown-linux-gnu
+            os: ubuntu-2004-16-cores
+            file: greptime-linux-amd64
+            continue-on-error: false
+            opts: "-F servers/dashboard"
+          - arch: aarch64-unknown-linux-gnu
+            os: ubuntu-2004-16-cores
+            file: greptime-linux-arm64
+            continue-on-error: false
+            opts: "-F servers/dashboard"
+          - arch: aarch64-apple-darwin
+            os: macos-latest
+            file: greptime-darwin-arm64
+            continue-on-error: false
+            opts: "-F servers/dashboard"
+          - arch: x86_64-apple-darwin
+            os: macos-latest
+            file: greptime-darwin-amd64
+            continue-on-error: false
+            opts: "-F servers/dashboard"
+          - arch: x86_64-unknown-linux-gnu
+            os: ubuntu-2004-16-cores
+            file: greptime-linux-amd64-pyo3
+            continue-on-error: false
+            opts: "-F pyo3_backend,servers/dashboard"
+          - arch: aarch64-unknown-linux-gnu
+            os: ubuntu-2004-16-cores
+            file: greptime-linux-arm64-pyo3
+            continue-on-error: false
+            opts: "-F pyo3_backend,servers/dashboard"
+          - arch: aarch64-apple-darwin
+            os: macos-latest
+            file: greptime-darwin-arm64-pyo3
+            continue-on-error: false
+            opts: "-F pyo3_backend,servers/dashboard"
+          - arch: x86_64-apple-darwin
+            os: macos-latest
+            file: greptime-darwin-amd64-pyo3
+            continue-on-error: false
+            opts: "-F pyo3_backend,servers/dashboard"
     runs-on: ${{ matrix.os }}
-    needs: [
-      allocate-runners,
-    ]
-    if: ${{ inputs.build_macos_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
+    continue-on-error: ${{ matrix.continue-on-error }}
+    if: github.repository == 'GreptimeTeam/greptimedb'
     steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - uses: ./.github/actions/build-macos-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 }}
-          release-to-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
-          artifacts-dir: ${{ matrix.artifacts-dir-prefix }}-${{ needs.allocate-runners.outputs.version }}
-          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
-    if: ${{ inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-      build-linux-arm64-artifacts,
-    ]
-    runs-on: ubuntu-2004-16-cores
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Build and push images to dockerhub
-        uses: ./.github/actions/build-images
-        with:
-          image-registry: docker.io
-          image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          image-registry-username: ${{ secrets.DOCKERHUB_USERNAME }}
-          image-registry-password: ${{ secrets.DOCKERHUB_TOKEN }}
-          version: ${{ needs.allocate-runners.outputs.version }}
-
-  release-images-to-acr:
-    name: Build and push images to ACR
-    if: ${{ inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-      build-linux-arm64-artifacts,
-    ]
-    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@v3
-        with:
-          fetch-depth: 0
-
-      - name: Build and push images to ACR
-        uses: ./.github/actions/build-images
-        with:
-          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 }}
-
-  release-artifacts:
-    name: Create GitHub release and upload artifacts
-    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,
-      release-images-to-dockerhub,
-    ]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - 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
+      - name: Checkout sources
         uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
 
-      - name: Build and push dev builder image
-        uses: ./.github/actions/build-dev-builder-image
+      - name: Cache cargo assets
+        id: cache
+        uses: actions/cache@v3
         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 }}
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ matrix.arch }}-build-cargo-${{ hashFiles('**/Cargo.lock') }}
 
-  ### 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.
-  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() }}
+      - name: Install Protoc for linux
+        if: contains(matrix.arch, 'linux') && endsWith(matrix.arch, '-gnu')
+        run: | # Make sure the protoc is >= 3.15
+          wget https://github.com/protocolbuffers/protobuf/releases/download/v21.9/protoc-21.9-linux-x86_64.zip
+          unzip protoc-21.9-linux-x86_64.zip -d protoc
+          sudo cp protoc/bin/protoc /usr/local/bin/
+          sudo cp -r protoc/include/google /usr/local/include/
+
+      - name: Install Protoc for macos
+        if: contains(matrix.arch, 'darwin')
+        run: |
+          brew install protobuf
+
+      - name: Install etcd for linux
+        if: contains(matrix.arch, 'linux') && endsWith(matrix.arch, '-gnu')
+        run: |
+          ETCD_VER=v3.5.7
+          DOWNLOAD_URL=https://github.com/etcd-io/etcd/releases/download
+          curl -L ${DOWNLOAD_URL}/${ETCD_VER}/etcd-${ETCD_VER}-linux-amd64.tar.gz -o /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
+          mkdir -p /tmp/etcd-download
+          tar xzvf /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz -C /tmp/etcd-download --strip-components=1
+          rm -f /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
+
+          sudo cp -a /tmp/etcd-download/etcd* /usr/local/bin/
+          nohup etcd >/tmp/etcd.log 2>&1 &
+
+      - name: Install etcd for macos
+        if: contains(matrix.arch, 'darwin')
+        run: |
+          brew install etcd
+          brew services start etcd
+
+      - name: Install dependencies for linux
+        if: contains(matrix.arch, 'linux') && endsWith(matrix.arch, '-gnu')
+        run: |
+          sudo apt-get -y update
+          sudo apt-get -y install libssl-dev pkg-config g++-aarch64-linux-gnu gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu wget
+
+      # FIXME(zyy17): Should we specify the version of python when building binary for darwin?
+      - name: Compile Python 3.10.10 from source for linux
+        if: contains(matrix.arch, 'linux') && contains(matrix.opts, 'pyo3_backend')
+        run: |
+          sudo chmod +x ./docker/aarch64/compile-python.sh
+          sudo ./docker/aarch64/compile-python.sh ${{ matrix.arch }}
+
+      - name: Install rust toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
+          targets: ${{ matrix.arch }}
+
+      - name: Output package versions
+        run: protoc --version ; cargo version ; rustc --version ; gcc --version ; g++ --version
+
+      - name: Run tests
+        if: env.DISABLE_RUN_TESTS == 'false'
+        run: make unit-test integration-test sqlness-test
+
+      - name: Run cargo build with pyo3 for aarch64-linux
+        if: contains(matrix.arch, 'aarch64-unknown-linux-gnu') && contains(matrix.opts, 'pyo3_backend')
+        run: |
+          # TODO(zyy17): We should make PYO3_CROSS_LIB_DIR configurable.
+          export PYTHON_INSTALL_PATH_AMD64=${PWD}/python-3.10.10/amd64
+          export LD_LIBRARY_PATH=$PYTHON_INSTALL_PATH_AMD64/lib:$LD_LIBRARY_PATH
+          export LIBRARY_PATH=$PYTHON_INSTALL_PATH_AMD64/lib:$LIBRARY_PATH
+          export PATH=$PYTHON_INSTALL_PATH_AMD64/bin:$PATH
+
+          export PYO3_CROSS_LIB_DIR=${PWD}/python-3.10.10/aarch64
+          echo "PYO3_CROSS_LIB_DIR: $PYO3_CROSS_LIB_DIR"
+          alias python=$PYTHON_INSTALL_PATH_AMD64/bin/python3
+          alias pip=$PYTHON_INSTALL_PATH_AMD64/bin/python3-pip
+
+          cargo build --profile ${{ env.CARGO_PROFILE }} --locked --target ${{ matrix.arch }} ${{ matrix.opts }}
+
+      - name: Run cargo build with pyo3 for amd64-linux
+        if: contains(matrix.arch, 'x86_64-unknown-linux-gnu') && contains(matrix.opts, 'pyo3_backend')
+        run: |
+          export PYTHON_INSTALL_PATH_AMD64=${PWD}/python-3.10.10/amd64
+          export LD_LIBRARY_PATH=$PYTHON_INSTALL_PATH_AMD64/lib:$LD_LIBRARY_PATH
+          export LIBRARY_PATH=$PYTHON_INSTALL_PATH_AMD64/lib:$LIBRARY_PATH
+          export PATH=$PYTHON_INSTALL_PATH_AMD64/bin:$PATH
+
+          echo "implementation=CPython" >> pyo3.config
+          echo "version=3.10" >> pyo3.config
+          echo "implementation=CPython" >> pyo3.config
+          echo "shared=true" >> pyo3.config
+          echo "abi3=true" >> pyo3.config
+          echo "lib_name=python3.10" >> pyo3.config
+          echo "lib_dir=$PYTHON_INSTALL_PATH_AMD64/lib" >> pyo3.config
+          echo "executable=$PYTHON_INSTALL_PATH_AMD64/bin/python3" >> pyo3.config
+          echo "pointer_width=64" >> pyo3.config
+          echo "build_flags=" >> pyo3.config
+          echo "suppress_build_script_link_lines=false" >> pyo3.config
+
+          cat pyo3.config
+          export PYO3_CONFIG_FILE=${PWD}/pyo3.config
+          alias python=$PYTHON_INSTALL_PATH_AMD64/bin/python3
+          alias pip=$PYTHON_INSTALL_PATH_AMD64/bin/python3-pip
+
+          cargo build --profile ${{ env.CARGO_PROFILE }} --locked --target ${{ matrix.arch }} ${{ matrix.opts }}
+
+      - name: Run cargo build
+        if: contains(matrix.arch, 'darwin') || contains(matrix.opts, 'pyo3_backend') == false
+        run: cargo build --profile ${{ env.CARGO_PROFILE }} --locked --target ${{ matrix.arch }} ${{ matrix.opts }}
+
+      - name: Calculate checksum and rename binary
+        shell: bash
+        run: |
+          cd target/${{ matrix.arch }}/${{ env.CARGO_PROFILE }}
+          chmod +x greptime
+          tar -zcvf ${{ matrix.file }}.tgz greptime
+          echo $(shasum -a 256 ${{ matrix.file }}.tgz | cut -f1 -d' ') > ${{ matrix.file }}.sha256sum
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.file }}
+          path: target/${{ matrix.arch }}/${{ env.CARGO_PROFILE }}/${{ matrix.file }}.tgz
+
+      - name: Upload checksum of artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.file }}.sha256sum
+          path: target/${{ matrix.arch }}/${{ env.CARGO_PROFILE }}/${{ matrix.file }}.sha256sum
+
+  docker:
+    name: Build docker image
+    needs: [build]
     runs-on: ubuntu-latest
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-    ]
+    if: github.repository == 'GreptimeTeam/greptimedb' && github.event_name != 'workflow_dispatch'
     steps:
-      - name: Checkout
+      - name: Checkout sources
         uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
 
-      - name: Stop EC2 runner
-        uses: ./.github/actions/stop-runner
+      - name: Login to Dockerhub
+        uses: docker/login-action@v2
         with:
-          label: ${{ needs.allocate-runners.outputs.linux-amd64-ec2-runner-label }}
-          ec2-instance-id: ${{ needs.allocate-runners.outputs.linux-amd64-ec2-runner-instance-id }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.EC2_RUNNER_REGION }}
-          github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-  stop-linux-arm64-runner: # It's always run as the last job in the workflow to make sure that the runner is released.
-    name: Stop linux-arm64 runner
-    # Only run this job when the runner is allocated.
-    if: ${{ always() }}
+      - name: Configure scheduled build image tag # the tag would be ${SCHEDULED_BUILD_VERSION_PREFIX}-YYYYMMDD-${SCHEDULED_PERIOD}
+        shell: bash
+        if: github.event_name == 'schedule'
+        run: |
+          buildTime=`date "+%Y%m%d"`
+          SCHEDULED_BUILD_VERSION=${{ env.SCHEDULED_BUILD_VERSION_PREFIX }}-$buildTime-${{ env.SCHEDULED_PERIOD }}
+          echo "IMAGE_TAG=${SCHEDULED_BUILD_VERSION:1}" >> $GITHUB_ENV
+
+      - name: Configure tag # If the release tag is v0.1.0, then the image version tag will be 0.1.0.
+        shell: bash
+        if: github.event_name != 'schedule'
+        run: |
+          VERSION=${{ github.ref_name }}
+          echo "IMAGE_TAG=${VERSION:1}" >> $GITHUB_ENV
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Download amd64 binary
+        uses: actions/download-artifact@v3
+        with:
+          name: greptime-linux-amd64-pyo3
+          path: amd64
+
+      - name: Unzip the amd64 artifacts
+        run: |
+          tar xvf amd64/greptime-linux-amd64-pyo3.tgz -C amd64/ && rm amd64/greptime-linux-amd64-pyo3.tgz
+          cp -r amd64 docker/ci
+
+      - name: Download arm64 binary
+        id: download-arm64
+        uses: actions/download-artifact@v3
+        with:
+          name: greptime-linux-arm64-pyo3
+          path: arm64
+
+      - name: Unzip the arm64 artifacts
+        id: unzip-arm64
+        if: success() || steps.download-arm64.conclusion == 'success'
+        run: |
+          tar xvf arm64/greptime-linux-arm64-pyo3.tgz -C arm64/ && rm arm64/greptime-linux-arm64-pyo3.tgz
+          cp -r arm64 docker/ci
+
+      - name: Build and push all
+        uses: docker/build-push-action@v3
+        if: success() || steps.unzip-arm64.conclusion == 'success' # Build and push all platform if unzip-arm64 succeeds
+        with:
+          context: ./docker/ci/
+          file: ./docker/ci/Dockerfile
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: |
+            greptime/greptimedb:latest
+            greptime/greptimedb:${{ env.IMAGE_TAG }}
+
+      - name: Build and push amd64 only
+        uses: docker/build-push-action@v3
+        if: success() || steps.download-arm64.conclusion == 'failure' # Only build and push amd64 platform if download-arm64 fails
+        with:
+          context: ./docker/ci/
+          file: ./docker/ci/Dockerfile
+          push: true
+          platforms: linux/amd64
+          tags: |
+            greptime/greptimedb:latest
+            greptime/greptimedb:${{ env.IMAGE_TAG }}
+
+  release:
+    name: Release artifacts
+    # Release artifacts only when all the artifacts are built successfully.
+    needs: [build,docker]
     runs-on: ubuntu-latest
-    needs: [
-      allocate-runners,
-      build-linux-arm64-artifacts,
-    ]
+    if: github.repository == 'GreptimeTeam/greptimedb' && github.event_name != 'workflow_dispatch'
     steps:
-      - name: Checkout
+      - name: Checkout sources
         uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
 
-      - name: Stop EC2 runner
-        uses: ./.github/actions/stop-runner
+      - name: Download artifacts
+        uses: actions/download-artifact@v3
+
+      - name: Configure scheduled build version # the version would be ${SCHEDULED_BUILD_VERSION_PREFIX}-${SCHEDULED_PERIOD}-YYYYMMDD, like v0.2.0-nigthly-20230313.
+        shell: bash
+        if: github.event_name == 'schedule'
+        run: |
+          buildTime=`date "+%Y%m%d"`
+          SCHEDULED_BUILD_VERSION=${{ env.SCHEDULED_BUILD_VERSION_PREFIX }}-${{ env.SCHEDULED_PERIOD }}-$buildTime
+          echo "SCHEDULED_BUILD_VERSION=${SCHEDULED_BUILD_VERSION}" >> $GITHUB_ENV
+
+      - name: Create scheduled build git tag
+        if: github.event_name == 'schedule'
+        run: |
+          git tag ${{ env.SCHEDULED_BUILD_VERSION }}
+
+      - name: Publish scheduled release # configure the different release title and tags.
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'schedule'
         with:
-          label: ${{ needs.allocate-runners.outputs.linux-arm64-ec2-runner-label }}
-          ec2-instance-id: ${{ needs.allocate-runners.outputs.linux-arm64-ec2-runner-instance-id }}
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.EC2_RUNNER_REGION }}
-          github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
+          name: "Release ${{ env.SCHEDULED_BUILD_VERSION }}"
+          tag_name: ${{ env.SCHEDULED_BUILD_VERSION }}
+          generate_release_notes: true
+          files: |
+            **/greptime-*
+
+      - name: Publish release
+        uses: softprops/action-gh-release@v1
+        if: github.event_name != 'schedule'
+        with:
+          name: "Release ${{ github.ref_name }}"
+          files: |
+            **/greptime-*

.gitignore

@@ -1,8 +1,6 @@
 # Generated by Cargo
 # will have compiled files and executables
 /target/
-# also ignore if it's a symbolic link
-/target
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
@@ -41,8 +39,3 @@ benchmarks/data
 # dashboard files
 !/src/servers/dashboard/VERSION
 /src/servers/dashboard/*
-
-# Vscode workspace
-*.code-workspace
-
-venv/

CONTRIBUTING.md

@@ -107,6 +107,6 @@ The core team will be thrilled if you participate in any way you like. When you
 
 Also, see some extra GreptimeDB content:
 
-- [GreptimeDB Docs](https://docs.greptime.com/)
-- [Learn GreptimeDB](https://greptime.com/product/db)
+- [GreptimeDB Docs](https://greptime.com/docs)
+- [Learn GreptimeDB](https://greptime.com/products/db)
 - [Greptime Inc. Website](https://greptime.com)

Cargo.toml

@@ -2,7 +2,6 @@
 members = [
     "benchmarks",
     "src/api",
-    "src/auth",
     "src/catalog",
     "src/client",
     "src/cmd",
@@ -12,13 +11,10 @@ members = [
     "src/common/error",
     "src/common/function",
     "src/common/function-macro",
-    "src/common/greptimedb-telemetry",
     "src/common/grpc",
     "src/common/grpc-expr",
     "src/common/mem-prof",
-    "src/common/meta",
     "src/common/procedure",
-    "src/common/procedure-test",
     "src/common/query",
     "src/common/recordbatch",
     "src/common/runtime",
@@ -26,7 +22,6 @@ members = [
     "src/common/telemetry",
     "src/common/test-util",
     "src/common/time",
-    "src/common/version",
     "src/datanode",
     "src/datatypes",
     "src/file-table-engine",
@@ -35,7 +30,6 @@ members = [
     "src/meta-client",
     "src/meta-srv",
     "src/mito",
-    "src/mito2",
     "src/object-store",
     "src/partition",
     "src/promql",
@@ -46,117 +40,46 @@ members = [
     "src/sql",
     "src/storage",
     "src/store-api",
-    "src/flow",
     "src/table",
     "src/table-procedure",
     "tests-integration",
     "tests/runner",
 ]
-resolver = "2"
 
 [workspace.package]
-version = "0.4.0-nightly"
+version = "0.2.0"
 edition = "2021"
 license = "Apache-2.0"
 
 [workspace.dependencies]
-arrow = { version = "43.0" }
-etcd-client = "0.11"
-arrow-array = "43.0"
-arrow-flight = "43.0"
-arrow-schema = { version = "43.0", features = ["serde"] }
+arrow = { version = "37.0" }
+arrow-array = "37.0"
+arrow-flight = "37.0"
+arrow-schema = { version = "37.0", features = ["serde"] }
 async-stream = "0.3"
 async-trait = "0.1"
 chrono = { version = "0.4", features = ["serde"] }
-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"
+datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
+datafusion-common = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
+datafusion-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
+datafusion-optimizer = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
+datafusion-physical-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
+datafusion-sql = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
 futures = "0.3"
 futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "4a277f27caa035a801d5b9c020a0449777736614" }
-humantime-serde = "1.1"
-itertools = "0.10"
-lazy_static = "1.4"
-once_cell = "1.18"
-opentelemetry-proto = { version = "0.2", features = ["gen-tonic", "metrics"] }
-parquet = "43.0"
+parquet = "37.0"
 paste = "1.0"
 prost = "0.11"
 rand = "0.8"
-regex = "1.8"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 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"] }
+sqlparser = "0.33"
 tempfile = "3"
-tokio = { version = "1.28", features = ["full"] }
-tokio-util = { version = "0.7", features = ["io-util", "compat"] }
-toml = "0.7"
+tokio = { version = "1.24.2", features = ["full"] }
+tokio-util = { version = "0.7", features = ["io-util"] }
 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" }
-catalog = { path = "src/catalog" }
-client = { path = "src/client" }
-cmd = { path = "src/cmd" }
-common-base = { path = "src/common/base" }
-common-catalog = { path = "src/common/catalog" }
-common-datasource = { path = "src/common/datasource" }
-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-mem-prof = { path = "src/common/mem-prof" }
-common-meta = { path = "src/common/meta" }
-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" }
-datanode = { path = "src/datanode" }
-datatypes = { path = "src/datatypes" }
-file-table-engine = { path = "src/file-table-engine" }
-frontend = { path = "src/frontend" }
-log-store = { path = "src/log-store" }
-meta-client = { path = "src/meta-client" }
-meta-srv = { path = "src/meta-srv" }
-mito = { path = "src/mito" }
-mito2 = { path = "src/mito2" }
-object-store = { path = "src/object-store" }
-partition = { path = "src/partition" }
-promql = { path = "src/promql" }
-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" }
-table = { path = "src/table" }
-table-procedure = { path = "src/table-procedure" }
-
-[workspace.dependencies.meter-macros]
-git = "https://github.com/GreptimeTeam/greptime-meter.git"
-rev = "abbd357c1e193cd270ea65ee7652334a150b628f"
 
 [profile.release]
 debug = true

Cross.toml

@@ -1,7 +0,0 @@
-[build]
-pre-build = [
-    "dpkg --add-architecture $CROSS_DEB_ARCH",
-    "apt update && apt install -y unzip zlib1g-dev zlib1g-dev:$CROSS_DEB_ARCH",
-    "curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v3.15.8/protoc-3.15.8-linux-x86_64.zip && unzip protoc-3.15.8-linux-x86_64.zip -d /usr/",
-    "chmod a+x /usr/bin/protoc && chmod -R a+rx /usr/include/google",
-]

Makefile

@@ -1,77 +1,15 @@
-# The arguments for building images.
-CARGO_PROFILE ?=
-FEATURES ?=
-TARGET_DIR ?=
-TARGET ?=
-CARGO_BUILD_OPTS := --locked
-IMAGE_REGISTRY ?= docker.io
-IMAGE_NAMESPACE ?= greptime
+IMAGE_REGISTRY ?= greptimedb
 IMAGE_TAG ?= latest
-BUILDX_MULTI_PLATFORM_BUILD ?= false
-BUILDX_BUILDER_NAME ?= gtbuilder
-BASE_IMAGE ?= ubuntu
-RUST_TOOLCHAIN ?= $(shell cat rust-toolchain.toml | grep channel | cut -d'"' -f2)
-CARGO_REGISTRY_CACHE ?= ${HOME}/.cargo/registry
-ARCH := $(shell uname -m | sed 's/x86_64/amd64/' | sed 's/aarch64/arm64/')
-OUTPUT_DIR := $(shell if [ "$(RELEASE)" = "true" ]; then echo "release"; elif [ ! -z "$(CARGO_PROFILE)" ]; then echo "$(CARGO_PROFILE)" ; else echo "debug"; fi)
-
-# The arguments for running integration tests.
-ETCD_VERSION ?= v3.5.9
-ETCD_IMAGE ?= quay.io/coreos/etcd:${ETCD_VERSION}
-RETRY_COUNT ?= 3
-NEXTEST_OPTS := --retries ${RETRY_COUNT}
-BUILD_JOBS ?= $(shell which nproc 1>/dev/null && expr $$(nproc) / 2) # If nproc is not available, we don't set the build jobs.
-ifeq ($(BUILD_JOBS), 0) # If the number of cores is less than 2, set the build jobs to 1.
-  BUILD_JOBS := 1
-endif
-
-ifneq ($(strip $(BUILD_JOBS)),)
-	NEXTEST_OPTS += --build-jobs=${BUILD_JOBS}
-endif
-
-ifneq ($(strip $(CARGO_PROFILE)),)
-	CARGO_BUILD_OPTS += --profile ${CARGO_PROFILE}
-endif
-
-ifneq ($(strip $(FEATURES)),)
-	CARGO_BUILD_OPTS += --features ${FEATURES}
-endif
-
-ifneq ($(strip $(TARGET_DIR)),)
-	CARGO_BUILD_OPTS += --target-dir ${TARGET_DIR}
-endif
-
-ifneq ($(strip $(TARGET)),)
-	CARGO_BUILD_OPTS += --target ${TARGET}
-endif
-
-ifneq ($(strip $(RELEASE)),)
-	CARGO_BUILD_OPTS += --release
-endif
-
-ifeq ($(BUILDX_MULTI_PLATFORM_BUILD), true)
-	BUILDX_MULTI_PLATFORM_BUILD_OPTS := --platform linux/amd64,linux/arm64 --push
-else
-	BUILDX_MULTI_PLATFORM_BUILD_OPTS := -o type=docker
-endif
 
 ##@ Build
 
 .PHONY: build
 build: ## Build debug version greptime.
-	cargo build ${CARGO_BUILD_OPTS}
+	cargo build
 
-.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_PROFILE=${CARGO_PROFILE} \
-	FEATURES=${FEATURES} \
-	TARGET_DIR=${TARGET_DIR} \
-	TARGET=${TARGET} \
-	RELEASE=${RELEASE}
+.PHONY: release
+release:  ## Build release version greptime.
+	cargo build --release
 
 .PHONY: clean
 clean: ## Clean the project.
@@ -83,46 +21,25 @@ fmt: ## Format all the Rust code.
 
 .PHONY: fmt-toml
 fmt-toml: ## Format all TOML files.
-	taplo format
+	taplo format --option "indent_string=    "
 
 .PHONY: check-toml
 check-toml: ## Check all TOML files.
-	taplo format --check
+	taplo format --check --option "indent_string=    "
 
 .PHONY: docker-image
-docker-image: build-by-dev-builder ## Build docker image.
-	mkdir -p ${ARCH} && \
-	cp ./target/${OUTPUT_DIR}/greptime ${ARCH}/greptime && \
-	docker build -f docker/ci/${BASE_IMAGE}/Dockerfile -t ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/greptimedb:${IMAGE_TAG} . && \
-	rm -r ${ARCH}
-
-.PHONY: docker-image-buildx
-docker-image-buildx: multi-platform-buildx ## Build docker image by buildx.
-	docker buildx build --builder ${BUILDX_BUILDER_NAME} \
-	  --build-arg="CARGO_PROFILE=${CARGO_PROFILE}" \
-	  --build-arg="FEATURES=${FEATURES}" \
-	  --build-arg="OUTPUT_DIR=${OUTPUT_DIR}" \
-	  -f docker/buildx/${BASE_IMAGE}/Dockerfile \
-	  -t ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/greptimedb:${IMAGE_TAG} ${BUILDX_MULTI_PLATFORM_BUILD_OPTS} .
-
-.PHONY: dev-builder
-dev-builder: multi-platform-buildx ## Build dev-builder image.
-	docker buildx build --builder ${BUILDX_BUILDER_NAME} \
-	--build-arg="RUST_TOOLCHAIN=${RUST_TOOLCHAIN}" \
-	-f docker/dev-builder/${BASE_IMAGE}/Dockerfile \
-	-t ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/dev-builder-${BASE_IMAGE}:${IMAGE_TAG} ${BUILDX_MULTI_PLATFORM_BUILD_OPTS} .
-
-.PHONY: multi-platform-buildx
-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
+docker-image: ## Build docker image.
+	docker build --network host -f docker/Dockerfile -t ${IMAGE_REGISTRY}:${IMAGE_TAG} .
 
 ##@ Test
-test: nextest ## Run unit and integration tests.
-	cargo nextest run ${NEXTEST_OPTS}
 
-.PHONY: nextest ## Install nextest tools.
-nextest:
-	cargo --list | grep nextest || cargo install cargo-nextest --locked
+.PHONY: unit-test
+unit-test: ## Run unit test.
+	cargo test --workspace
+
+.PHONY: integration-test
+integration-test: ## Run integation test.
+	cargo test integration
 
 .PHONY: sqlness-test
 sqlness-test: ## Run sqlness test.
@@ -134,27 +51,12 @@ check: ## Cargo check all the targets.
 
 .PHONY: clippy
 clippy: ## Check clippy rules.
-	cargo clippy --workspace --all-targets -F pyo3_backend -- -D warnings
+	cargo clippy --workspace --all-targets -- -D warnings
 
 .PHONY: fmt-check
 fmt-check: ## Check code format.
 	cargo fmt --all -- --check
 
-.PHONY: start-etcd
-start-etcd: ## Start single node etcd for testing purpose.
-	docker run --rm -d --network=host -p 2379-2380:2379-2380 ${ETCD_IMAGE}
-
-.PHONY: stop-etcd
-stop-etcd: ## Stop single node etcd for testing purpose.
-	docker stop $$(docker ps -q --filter ancestor=${ETCD_IMAGE})
-
-.PHONY: run-it-in-container
-run-it-in-container: start-etcd ## Run integration tests in dev-builder.
-	docker run --network=host \
-	-v ${PWD}:/greptimedb -v ${CARGO_REGISTRY_CACHE}:/root/.cargo/registry -v /tmp:/tmp \
-	-w /greptimedb ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/dev-builder-${BASE_IMAGE}:latest \
-	make test sqlness-test BUILD_JOBS=${BUILD_JOBS}
-
 ##@ General
 
 # The help target prints out all targets with their descriptions organized
@@ -170,4 +72,4 @@ run-it-in-container: start-etcd ## Run integration tests in dev-builder.
 
 .PHONY: help
 help: ## Display help messages.
-	@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n  make \033[36m<target>\033[0m\n"} /^[a-zA-Z_0-9-]+:.*?##/ { printf "  \033[36m%-30s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST)
+	@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n  make \033[36m<target>\033[0m\n"} /^[a-zA-Z_0-9-]+:.*?##/ { printf "  \033[36m%-20s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST)

README.md

@@ -47,10 +47,6 @@ for years. Based on their best-practices, GreptimeDB is born to give you:
 
 ## Quick Start
 
-### [GreptimePlay](https://greptime.com/playground)
-
-Try out the features of GreptimeDB right from your browser.
-
 ### Build
 
 #### Build from Source
@@ -96,22 +92,64 @@ 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](https://docs.greptime.com/getting-started/overview#install-greptimedb) for more installation options and [operations info](https://docs.greptime.com/user-guide/operations/overview).
+For more startup options, greptimedb's **distributed mode** and information
+about Kubernetes deployment, check our [docs](https://docs.greptime.com/).
 
-### Get started
+### Connect
 
-Read the [complete getting started guide](https://docs.greptime.com/getting-started/overview#connect) on our [official document site](https://docs.greptime.com/).
+1. Connect to GreptimeDB via standard [MySQL
+   client](https://dev.mysql.com/downloads/mysql/):
 
-To write and query data, GreptimeDB is compatible with multiple [protocols and clients](https://docs.greptime.com/user-guide/clients/overview).
+   ```
+   # The standalone instance listen on port 4002 by default.
+   mysql -h 127.0.0.1 -P 4002
+   ```
+
+2. Create table:
+
+   ```SQL
+   CREATE TABLE monitor (
+     host STRING,
+     ts TIMESTAMP,
+     cpu DOUBLE DEFAULT 0,
+     memory DOUBLE,
+     TIME INDEX (ts),
+     PRIMARY KEY(host)) ENGINE=mito WITH(regions=1);
+   ```
+
+3. Insert some data:
+
+   ```SQL
+   INSERT INTO monitor(host, cpu, memory, ts) VALUES ('host1', 66.6, 1024, 1660897955000);
+   INSERT INTO monitor(host, cpu, memory, ts) VALUES ('host2', 77.7, 2048, 1660897956000);
+   INSERT INTO monitor(host, cpu, memory, ts) VALUES ('host3', 88.8, 4096, 1660897957000);
+   ```
+
+4. Query the data:
+
+   ```SQL
+   SELECT * FROM monitor;
+   ```
+
+   ```TEXT
+   +-------+---------------------+------+--------+
+   | host  | ts                  | cpu  | memory |
+   +-------+---------------------+------+--------+
+   | host1 | 2022-08-19 08:32:35 | 66.6 |   1024 |
+   | host2 | 2022-08-19 08:32:36 | 77.7 |   2048 |
+   | host3 | 2022-08-19 08:32:37 | 88.8 |   4096 |
+   +-------+---------------------+------+--------+
+   3 rows in set (0.01 sec)
+   ```
+
+You can always cleanup test database by removing `/tmp/greptimedb`.
 
 ## Resources
 
 ### 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. 
-  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.
+- [Pre-built Binaries](https://github.com/GreptimeTeam/greptimedb/releases):
+  For Linux and macOS, you can easily download pre-built binaries 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
   Docker images, this is the easiest way to try GreptimeDB. By default it runs CPython script with `pyo3_backend` enabled.
 - [`gtctl`](https://github.com/GreptimeTeam/gtctl): the command-line tool for
@@ -119,7 +157,7 @@ To write and query data, GreptimeDB is compatible with multiple [protocols and c
 
 ### Documentation
 
-- GreptimeDB [User Guide](https://docs.greptime.com/user-guide/concepts/overview)
+- GreptimeDB [User Guide](https://docs.greptime.com/user-guide/concepts.html)
 - GreptimeDB [Developer
   Guide](https://docs.greptime.com/developer-guide/overview.html)
 - GreptimeDB [internal code document](https://greptimedb.rs)
@@ -129,12 +167,8 @@ To write and query data, GreptimeDB is compatible with multiple [protocols and c
 
 ### SDK
 
-- [GreptimeDB C++ Client](https://github.com/GreptimeTeam/greptimedb-client-cpp)
-- [GreptimeDB Erlang Client](https://github.com/GreptimeTeam/greptimedb-client-erl)
-- [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 Java
+  Client](https://github.com/GreptimeTeam/greptimedb-client-java)
 
 ## Project Status
 

benchmarks/Cargo.toml

@@ -7,8 +7,8 @@ license.workspace = true
 [dependencies]
 arrow.workspace = true
 clap = { version = "4.0", features = ["derive"] }
-client = { workspace = true }
+client = { path = "../src/client" }
 indicatif = "0.17.1"
-itertools.workspace = true
+itertools = "0.10.5"
 parquet.workspace = true
 tokio.workspace = true

benchmarks/src/bin/nyc-taxi.rs

@@ -26,9 +26,7 @@ use arrow::datatypes::{DataType, Float64Type, Int64Type};
 use arrow::record_batch::RecordBatch;
 use clap::Parser;
 use client::api::v1::column::Values;
-use client::api::v1::{
-    Column, ColumnDataType, ColumnDef, CreateTableExpr, InsertRequest, InsertRequests,
-};
+use client::api::v1::{Column, ColumnDataType, ColumnDef, CreateTableExpr, InsertRequest};
 use client::{Client, Database, DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
@@ -109,12 +107,8 @@ async fn write_data(
             columns,
             row_count,
         };
-        let requests = InsertRequests {
-            inserts: vec![request],
-        };
-
         let now = Instant::now();
-        let _ = db.insert(requests).await.unwrap();
+        db.insert(request).await.unwrap();
         let elapsed = now.elapsed();
         total_rpc_elapsed_ms += elapsed.as_millis();
         progress_bar.inc(row_count as _);
@@ -370,23 +364,26 @@ fn create_table_expr() -> CreateTableExpr {
         primary_keys: vec!["VendorID".to_string()],
         create_if_not_exists: false,
         table_options: Default::default(),
-        region_numbers: vec![0],
+        region_ids: vec![0],
         table_id: None,
         engine: "mito".to_string(),
     }
 }
 
 fn query_set() -> HashMap<String, String> {
-    HashMap::from([
-        (
-            "count_all".to_string(), 
-            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"),
-        )
-    ])
+    let mut ret = HashMap::new();
+
+    ret.insert(
+        "count_all".to_string(),
+        format!("SELECT COUNT(*) FROM {TABLE_NAME};"),
+    );
+
+    ret.insert(
+        "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")
+    );
+
+    ret
 }
 
 async fn do_write(args: &Args, db: &Database) {
@@ -411,8 +408,7 @@ async fn do_write(args: &Args, db: &Database) {
             let db = db.clone();
             let mpb = multi_progress_bar.clone();
             let pb_style = progress_bar_style.clone();
-            let _ = write_jobs
-                .spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
+            write_jobs.spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
         }
     }
     while write_jobs.join_next().await.is_some() {
@@ -421,8 +417,7 @@ async fn do_write(args: &Args, db: &Database) {
             let db = db.clone();
             let mpb = multi_progress_bar.clone();
             let pb_style = progress_bar_style.clone();
-            let _ = write_jobs
-                .spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
+            write_jobs.spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
         }
     }
 }

config/datanode.example.toml

@@ -11,10 +11,6 @@ rpc_hostname = "127.0.0.1"
 # The number of gRPC server worker threads, 8 by default.
 rpc_runtime_size = 8
 
-[heartbeat]
-# Interval for sending heartbeat messages to the Metasrv in milliseconds, 5000 by default.
-interval_millis = 5000
-
 # Metasrv client options.
 [meta_client_options]
 # Metasrv address list.
@@ -28,21 +24,17 @@ tcp_nodelay = true
 
 # WAL options, see `standalone.example.toml`.
 [wal]
-# WAL data directory
-# dir = "/tmp/greptimedb/wal"
-file_size = "256MB"
-purge_threshold = "4GB"
+dir = "/tmp/greptimedb/wal"
+file_size = "1GB"
+purge_threshold = "50GB"
 purge_interval = "10m"
 read_batch_size = 128
 sync_write = false
 
 # Storage options, see `standalone.example.toml`.
 [storage]
-# The working home directory.
-data_home = "/tmp/greptimedb/"
 type = "File"
-# TTL for all tables. Disabled by default.
-# global_ttl = "7d"
+data_dir = "/tmp/greptimedb/data/"
 
 # Compaction options, see `standalone.example.toml`.
 [storage.compaction]
@@ -56,29 +48,13 @@ max_purge_tasks = 32
 # 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.
-global_write_buffer_size = "1GB"
+gc_duration = '30s'
+# Whether to try creating a manifest checkpoint on region opening
+checkpoint_on_startup = false
 
 # Procedure storage options, see `standalone.example.toml`.
-[procedure]
-max_retry_times = 3
-retry_delay = "500ms"
-
-# Log options
-# [logging]
-# Specify logs directory.
-# dir = "/tmp/greptimedb/logs"
-# Specify the log level [info | debug | error | warn]
-# level = "info"
+# [procedure.store]
+# type = "File"
+# data_dir = "/tmp/greptimedb/procedure/"
+# max_retry_times = 3
+# retry_delay = "500ms"

config/frontend.example.toml

@@ -1,17 +1,10 @@
 # Node running mode, see `standalone.example.toml`.
 mode = "distributed"
 
-[heartbeat]
-# 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_options]
 addr = "127.0.0.1:4000"
 timeout = "30s"
-body_limit = "64MB"
 
 # gRPC server options, see `standalone.example.toml`.
 [grpc_options]
@@ -49,28 +42,17 @@ runtime_size = 2
 [influxdb_options]
 enable = true
 
-# Prometheus remote storage options, see `standalone.example.toml`.
-[prom_store_options]
+# Prometheus protocol options, see `standalone.example.toml`.
+[prometheus_options]
 enable = true
 
+# Prometheus protocol options, see `standalone.example.toml`.
+[prom_options]
+addr = "127.0.0.1:4004"
+
 # Metasrv client options, see `datanode.example.toml`.
 [meta_client_options]
 metasrv_addrs = ["127.0.0.1:3002"]
 timeout_millis = 3000
-# DDL timeouts options.
-ddl_timeout_millis = 10000
 connect_timeout_millis = 5000
 tcp_nodelay = true
-
-# Log options, see `standalone.example.toml`
-# [logging]
-# dir = "/tmp/greptimedb/logs"
-# level = "info"
-
-# Datanode options.
-[datanode]
-# Datanode client options.
-[datanode.client]
-timeout = "10s"
-connect_timeout = "10s"
-tcp_nodelay = true

config/metasrv.example.toml

@@ -1,5 +1,3 @@
-# The working home directory.
-data_home = "/tmp/metasrv/"
 # The bind address of metasrv, "127.0.0.1:3002" by default.
 bind_addr = "127.0.0.1:3002"
 # The communication server address for frontend and datanode to connect to metasrv,  "127.0.0.1:3002" by default for localhost.
@@ -15,25 +13,3 @@ datanode_lease_secs = 15
 selector = "LeaseBased"
 # Store data in memory, false by default.
 use_memory_store = false
-# Whether to enable greptimedb telemetry, true by default.
-enable_telemetry = true
-
-# Log options, see `standalone.example.toml`
-# [logging]
-# dir = "/tmp/greptimedb/logs"
-# level = "info"
-
-# Procedure storage options.
-[procedure]
-# Procedure max retry time.
-max_retry_times = 12
-# Initial retry delay of procedures, increases exponentially
-retry_delay = "500ms"
-
-# # Datanode options.
-# [datanode]
-# # Datanode client options.
-# [datanode.client_options]
-# timeout_millis = 10000
-# connect_timeout_millis = 10000
-# tcp_nodelay = true

config/standalone.example.toml

@@ -2,8 +2,6 @@
 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
 
 # HTTP server options.
 [http_options]
@@ -11,9 +9,6 @@ enable_telemetry = true
 addr = "127.0.0.1:4000"
 # HTTP request timeout, 30s by default.
 timeout = "30s"
-# HTTP request body limit, 64Mb by default.
-# the following units are supported: B, KB, KiB, MB, MiB, GB, GiB, TB, TiB, PB, PiB
-body_limit = "64MB"
 
 # gRPC server options.
 [grpc_options]
@@ -71,19 +66,24 @@ runtime_size = 2
 # Whether to enable InfluxDB protocol in HTTP API, true by default.
 enable = true
 
-# Prometheus remote storage options
-[prom_store_options]
+# Prometheus protocol options.
+[prometheus_options]
 # Whether to enable Prometheus remote write and read in HTTP API, true by default.
 enable = true
 
+# Prom protocol options.
+[prom_options]
+# Prometheus API server address, "127.0.0.1:4004" by default.
+addr = "127.0.0.1:4004"
+
 # WAL options.
 [wal]
-# WAL data directory
-# dir = "/tmp/greptimedb/wal"
+# WAL data directory.
+dir = "/tmp/greptimedb/wal"
 # WAL file size in bytes.
-file_size = "256MB"
-# WAL purge threshold.
-purge_threshold = "4GB"
+file_size = "1GB"
+# WAL purge threshold in bytes.
+purge_threshold = "50GB"
 # WAL purge interval in seconds.
 purge_interval = "10m"
 # WAL read batch size.
@@ -93,12 +93,10 @@ sync_write = false
 
 # Storage options.
 [storage]
-# The working home directory.
-data_home = "/tmp/greptimedb/"
 # Storage type.
 type = "File"
-# TTL for all tables. Disabled by default.
-# global_ttl = "7d"
+# Data directory, "/tmp/greptimedb/data" by default.
+data_dir = "/tmp/greptimedb/data/"
 
 # Compaction options.
 [storage.compaction]
@@ -115,31 +113,18 @@ max_purge_tasks = 32
 # 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.
-global_write_buffer_size = "1GB"
+gc_duration = '30s'
+# Whether to try creating a manifest checkpoint on region opening
+checkpoint_on_startup = false
 
 # 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]
-# Specify logs directory.
-# dir = "/tmp/greptimedb/logs"
-# Specify the log level [info | debug | error | warn]
-# level = "info"
+# Uncomment to enable.
+# [procedure.store]
+# # Storage type.
+# type = "File"
+# # Procedure data path.
+# data_dir = "/tmp/greptimedb/procedure/"
+# # Procedure max retry time.
+# max_retry_times = 3
+# # Initial retry delay of procedures, increases exponentially
+# retry_delay = "500ms"

docker/Dockerfile

@@ -0,0 +1,36 @@
+FROM ubuntu:22.04 as builder
+
+ENV LANG en_US.utf8
+WORKDIR /greptimedb
+
+# Install dependencies.
+RUN apt-get update && apt-get install -y \
+    libssl-dev \
+    protobuf-compiler \
+    curl \
+    build-essential \
+    pkg-config \
+    python3 \
+    python3-dev \
+    && pip install pyarrow
+
+# 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
+
+# Build the project in release mode.
+COPY . .
+RUN cargo build --release
+
+# Export the binary to the clean image.
+# TODO(zyy17): Maybe should use the more secure container image.
+FROM ubuntu:22.04 as base
+
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get -y install ca-certificates
+
+WORKDIR /greptime
+COPY --from=builder /greptimedb/target/release/greptime /greptime/bin/
+ENV PATH /greptime/bin/:$PATH
+
+ENTRYPOINT ["greptime"]

docker/aarch64/Dockerfile

@@ -0,0 +1,57 @@
+FROM ubuntu:22.04 as builder
+
+ENV LANG en_US.utf8
+WORKDIR /greptimedb
+
+# Install dependencies.
+RUN apt-get update && apt-get install -y \
+    libssl-dev \
+    protobuf-compiler \
+    curl \
+    build-essential \
+    pkg-config \
+    wget
+
+# 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 cross platform toolchain
+RUN apt-get -y update && \
+    apt-get -y install g++-aarch64-linux-gnu gcc-aarch64-linux-gnu && \
+    apt-get install binutils-aarch64-linux-gnu
+
+COPY ./docker/aarch64/compile-python.sh ./docker/aarch64/
+RUN chmod +x ./docker/aarch64/compile-python.sh && \
+    ./docker/aarch64/compile-python.sh
+
+COPY ./rust-toolchain.toml .
+# Install rustup target for cross compiling.
+RUN rustup target add aarch64-unknown-linux-gnu
+COPY . .
+# Update dependency, using separate `RUN` to separate cache
+RUN cargo fetch
+
+# This three env var is set in script, so I set it manually in dockerfile.
+ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib/
+ENV LIBRARY_PATH=$LIBRARY_PATH:/usr/local/lib/
+ENV PY_INSTALL_PATH=/greptimedb/python_arm64_build
+
+# Set the environment variable for cross compiling and compile it
+# cross compiled python is `python3` in path, but pyo3 need `python` in path so alias it
+# Build the project in release mode.
+RUN export PYO3_CROSS_LIB_DIR=$PY_INSTALL_PATH/lib && \ 
+    alias python=python3 && \
+    cargo build --target aarch64-unknown-linux-gnu --release -F pyo3_backend
+
+# Exporting the binary to the clean image
+FROM ubuntu:22.04 as base
+
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get -y install ca-certificates
+
+WORKDIR /greptime
+COPY --from=builder /greptimedb/target/aarch64-unknown-linux-gnu/release/greptime /greptime/bin/
+ENV PATH /greptime/bin/:$PATH
+
+ENTRYPOINT ["greptime"]

docker/aarch64/compile-python.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+
+set -e
+
+# this script will download Python source code, compile it, and install it to /usr/local/lib
+# then use this python to compile cross-compiled python for aarch64
+ARCH=$1
+PYTHON_VERSION=3.10.10
+PYTHON_SOURCE_DIR=Python-${PYTHON_VERSION}
+PYTHON_INSTALL_PATH_AMD64=${PWD}/python-${PYTHON_VERSION}/amd64
+PYTHON_INSTALL_PATH_AARCH64=${PWD}/python-${PYTHON_VERSION}/aarch64
+
+function download_python_source_code() {
+  wget https://www.python.org/ftp/python/$PYTHON_VERSION/Python-$PYTHON_VERSION.tgz
+  tar -xvf Python-$PYTHON_VERSION.tgz
+}
+
+function compile_for_amd64_platform() {
+  mkdir -p "$PYTHON_INSTALL_PATH_AMD64"
+
+  echo "Compiling for amd64 platform..."
+
+  ./configure \
+    --prefix="$PYTHON_INSTALL_PATH_AMD64" \
+    --enable-shared \
+    ac_cv_pthread_is_default=no ac_cv_pthread=yes ac_cv_cxx_thread=yes \
+    ac_cv_have_long_long_format=yes \
+    --disable-ipv6 ac_cv_file__dev_ptmx=no ac_cv_file__dev_ptc=no
+
+  make
+  make install
+}
+
+# explain Python compile options here a bit:s
+# --enable-shared: enable building a shared Python library (default is no) but we do need it for calling from rust
+# CC, CXX, AR, LD, RANLIB: set the compiler, archiver, linker, and ranlib programs to use
+# build: the machine you are building on, host: the machine you will run the compiled program on
+# --with-system-ffi: build _ctypes module using an installed ffi library, see Doc/library/ctypes.rst, not used in here TODO: could remove
+# ac_cv_pthread_is_default=no ac_cv_pthread=yes ac_cv_cxx_thread=yes:
+# allow cross-compiled python to have -pthread set for CXX, see https://github.com/python/cpython/pull/22525
+# ac_cv_have_long_long_format=yes: target platform supports long long type
+# disable-ipv6: disable ipv6 support, we don't need it in here
+# ac_cv_file__dev_ptmx=no ac_cv_file__dev_ptc=no: disable pty support, we don't need it in here
+function compile_for_aarch64_platform() {
+  export LD_LIBRARY_PATH=$PYTHON_INSTALL_PATH_AMD64/lib:$LD_LIBRARY_PATH
+  export LIBRARY_PATH=$PYTHON_INSTALL_PATH_AMD64/lib:$LIBRARY_PATH
+  export PATH=$PYTHON_INSTALL_PATH_AMD64/bin:$PATH
+
+  mkdir -p "$PYTHON_INSTALL_PATH_AARCH64"
+
+  echo "Compiling for aarch64 platform..."
+  echo "LD_LIBRARY_PATH: $LD_LIBRARY_PATH"
+  echo "LIBRARY_PATH: $LIBRARY_PATH"
+  echo "PATH: $PATH"
+
+  ./configure --build=x86_64-linux-gnu --host=aarch64-linux-gnu \
+    --prefix="$PYTHON_INSTALL_PATH_AARCH64" --enable-optimizations \
+    CC=aarch64-linux-gnu-gcc \
+    CXX=aarch64-linux-gnu-g++ \
+    AR=aarch64-linux-gnu-ar \
+    LD=aarch64-linux-gnu-ld \
+    RANLIB=aarch64-linux-gnu-ranlib \
+    --enable-shared \
+    ac_cv_pthread_is_default=no ac_cv_pthread=yes ac_cv_cxx_thread=yes \
+    ac_cv_have_long_long_format=yes \
+    --disable-ipv6 ac_cv_file__dev_ptmx=no ac_cv_file__dev_ptc=no
+
+  make
+  make altinstall
+}
+
+# Main script starts here.
+download_python_source_code
+
+# Enter the python source code directory.
+cd $PYTHON_SOURCE_DIR || exit 1
+
+# Build local python first, then build cross-compiled python.
+compile_for_amd64_platform
+
+# Clean the build directory.
+make clean && make distclean
+
+# Cross compile python for aarch64.
+if [ "$ARCH" = "aarch64-unknown-linux-gnu" ]; then
+  compile_for_aarch64_platform
+fi

docker/buildx/centos/Dockerfile

@@ -1,54 +0,0 @@
-FROM centos:7 as builder
-
-ARG CARGO_PROFILE
-ARG FEATURES
-ARG OUTPUT_DIR
-
-ENV LANG en_US.utf8
-WORKDIR /greptimedb
-
-# Install dependencies
-RUN ulimit -n 1024000 && yum groupinstall -y 'Development Tools'
-RUN yum install -y epel-release  \
-    openssl \
-    openssl-devel  \
-    centos-release-scl  \
-    rh-python38  \
-    rh-python38-python-devel \
-    which
-
-# Install protoc
-RUN curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v3.15.8/protoc-3.15.8-linux-x86_64.zip
-RUN unzip protoc-3.15.8-linux-x86_64.zip -d /usr/local/
-
-# 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 /opt/rh/rh-python38/root/usr/bin:/usr/local/bin:/root/.cargo/bin/:$PATH
-
-# Build the project in release mode.
-RUN --mount=target=.,rw \
-    --mount=type=cache,target=/root/.cargo/registry \
-    make build \
-    CARGO_PROFILE=${CARGO_PROFILE} \
-    FEATURES=${FEATURES} \
-    TARGET_DIR=/out/target
-
-# Export the binary to the clean image.
-FROM centos:7 as base
-
-ARG OUTPUT_DIR
-
-RUN yum install -y epel-release \
-    openssl \
-    openssl-devel  \
-    centos-release-scl  \
-    rh-python38  \
-    rh-python38-python-devel \
-    which
-
-WORKDIR /greptime
-COPY --from=builder /out/target/${OUTPUT_DIR}/greptime /greptime/bin/
-ENV PATH /greptime/bin/:$PATH
-
-ENTRYPOINT ["greptime"]

docker/buildx/ubuntu/Dockerfile

@@ -1,57 +0,0 @@
-FROM ubuntu:22.04 as builder
-
-ARG CARGO_PROFILE
-ARG FEATURES
-ARG OUTPUT_DIR
-
-ENV LANG en_US.utf8
-WORKDIR /greptimedb
-
-# Install dependencies.
-RUN --mount=type=cache,target=/var/cache/apt \
-    apt-get update && apt-get install -y \
-    libssl-dev \
-    protobuf-compiler \
-    curl \
-    git \
-    build-essential \
-    pkg-config \
-    python3.10 \
-    python3.10-dev \
-    python3-pip
-
-# 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
-
-# Build the project in release mode.
-RUN --mount=target=. \
-    --mount=type=cache,target=/root/.cargo/registry \
-    make build \
-    CARGO_PROFILE=${CARGO_PROFILE} \
-    FEATURES=${FEATURES} \
-    TARGET_DIR=/out/target
-
-# Export the binary to the clean image.
-# TODO(zyy17): Maybe should use the more secure container image.
-FROM ubuntu:22.04 as base
-
-ARG OUTPUT_DIR
-
-RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get \
-    -y install ca-certificates \
-    python3.10 \
-    python3.10-dev \
-    python3-pip \
-    curl
-
-COPY ./docker/python/requirements.txt /etc/greptime/requirements.txt
-
-RUN python3 -m pip install -r /etc/greptime/requirements.txt
-
-WORKDIR /greptime
-COPY --from=builder /out/target/${OUTPUT_DIR}/greptime /greptime/bin/
-ENV PATH /greptime/bin/:$PATH
-
-ENTRYPOINT ["greptime"]

docker/ci/Dockerfile

@@ -4,10 +4,9 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     ca-certificates \
     python3.10 \
     python3.10-dev \
-    python3-pip \
-    curl
+    python3-pip
 
-COPY ./docker/python/requirements.txt /etc/greptime/requirements.txt
+COPY requirements.txt /etc/greptime/requirements.txt
 
 RUN python3 -m pip install -r /etc/greptime/requirements.txt
 

docker/ci/centos/Dockerfile

@@ -1,16 +0,0 @@
-FROM centos:7
-
-RUN yum install -y epel-release \
-    openssl \
-    openssl-devel  \
-    centos-release-scl  \
-    rh-python38  \
-    rh-python38-python-devel
-
-ARG TARGETARCH
-
-ADD $TARGETARCH/greptime /greptime/bin/
-
-ENV PATH /greptime/bin/:$PATH
-
-ENTRYPOINT ["greptime"]

docker/dev-builder/centos/Dockerfile

@@ -1,29 +0,0 @@
-FROM centos:7 as builder
-
-ENV LANG en_US.utf8
-
-# Install dependencies
-RUN ulimit -n 1024000 && yum groupinstall -y 'Development Tools'
-RUN yum install -y epel-release  \
-    openssl \
-    openssl-devel  \
-    centos-release-scl  \
-    rh-python38  \
-    rh-python38-python-devel \
-    which
-
-# Install protoc
-RUN curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v3.15.8/protoc-3.15.8-linux-x86_64.zip
-RUN unzip protoc-3.15.8-linux-x86_64.zip -d /usr/local/
-
-# 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 /opt/rh/rh-python38/root/usr/bin:/usr/local/bin:/root/.cargo/bin/:$PATH
-
-# Install Rust toolchains.
-ARG RUST_TOOLCHAIN
-RUN rustup toolchain install ${RUST_TOOLCHAIN}
-
-# Install nextest.
-RUN cargo install cargo-nextest --locked

docker/dev-builder/ubuntu/Dockerfile

@@ -1,36 +0,0 @@
-FROM ubuntu:22.04
-
-ENV LANG en_US.utf8
-WORKDIR /greptimedb
-
-# Install dependencies.
-RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
-    libssl-dev \
-    tzdata \
-    protobuf-compiler \
-    curl \
-    ca-certificates \
-    git \
-    build-essential \
-    pkg-config \
-    python3.10 \
-    python3.10-dev \
-    python3-pip
-
-RUN git config --global --add safe.directory /greptimedb
-
-# Install Python dependencies.
-COPY ./docker/python/requirements.txt /etc/greptime/requirements.txt
-RUN python3 -m pip install -r /etc/greptime/requirements.txt
-
-# 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-nextest --locked

docs/benchmarks/tsbs/v0.3.2.md

@@ -1,39 +0,0 @@
-# TSBS benchmark - v0.3.2
-
-## Environment
-
-|     |     |
-| --- | --- |
-| CPU | AMD Ryzen 7 7735HS (8 core 3.2GHz) |
-| Memory | 32GB |
-| Disk | SOLIDIGM SSDPFKNU010TZ |
-| OS | Ubuntu 22.04.2 LTS |
-
-
-## Write performance
-
-| Write buffer size | Ingest rate（rows/s） |
-| --- | --- |
-| 512M | 139583.04 |
-| 32M | 279250.52 |
-
-
-## Query performance
-
-| Query type  | v0.3.2 write buffer 32M (ms) | v0.3.2 write buffer 512M (ms) | v0.3.1 write buffer 32M (ms) |
-| --- | --- | --- | --- |
-| cpu-max-all-1 | 921.12 | 241.23 | 553.63 |
-| cpu-max-all-8 | 2657.66 | 502.78 | 3308.41 |
-| double-groupby-1 | 28238.85 | 27367.42 | 52148.22 |
-| double-groupby-5 | 33094.65 | 32421.89 | 56762.37 |
-| double-groupby-all | 38565.89 | 38635.52 | 59596.80 |
-| groupby-orderby-limit | 23321.60 | 22423.55 | 53983.23 |
-| high-cpu-1 | 1167.04 | 254.15 | 832.41 |
-| high-cpu-all | 32814.08 | 29906.94 | 62853.12 |
-| lastpoint | 192045.05 | 153575.42 | NA   |
-| single-groupby-1-1-1 | 63.97 | 87.35 | 92.66 |
-| single-groupby-1-1-12 | 666.24 | 326.98 | 781.50 |
-| single-groupby-1-8-1 | 225.29 | 137.97 |281.95 |
-| single-groupby-5-1-1 | 70.40 | 81.64 | 86.15 |
-| single-groupby-5-1-12 | 722.75 | 356.01 | 805.18 |
-| single-groupby-5-8-1 | 285.60 | 115.88 | 326.29 |

docs/rfcs/2023-05-09-distributed-planner.md

@@ -1,137 +0,0 @@
----
-Feature Name: distributed-planner
-Tracking Issue: TBD
-Date: 2023-05-09
-Author: "Ruihang Xia <waynestxia@gmail.com>"
----
-
-Distributed Planner
--------------------
-# Summary
-Enhance the logical planner with aware of distributed, multi-region table topology. To achieve "push computation down" execution rather than the current "pull data up" manner.
-
-# Motivation
-Query distributively can leverage the advantage of GreptimeDB's architecture to process large dataset that exceeds the capacity of a single node, or accelerate the query execution by executing it in parallel. This task includes two sub-tasks
-  - Be able to transform the plan that can push as much as possible computation down to data source.
-  - Be able to handle pipeline breaker (like `Join` or `Sort`) on multiple computation nodes.
-This is a relatively complex topic. To keep this RFC concentrated I'll focus on the first one.
-
-# Details
-## Background: Partition and Region
-GreptimeDB supports table partitioning, where the partition rule is set during table creation. Each partition can be further divided into one or more physical storage units known as "regions". Both partitions and regions are divided based on rows:
-``` text
-┌────────────────────────────────────┐
-│                                    │
-│               Table                │
-│                                    │
-└─────┬────────────┬────────────┬────┘
-      │            │            │
-      │            │            │
-┌─────▼────┐ ┌─────▼────┐ ┌─────▼────┐
-│ Region 1 │ │ Region 2 │ │ Region 3 │
-└──────────┘ └──────────┘ └──────────┘
-  Row 1~10     Row 11~20    Row 21~30
-```
-General speaking, region is the minimum element of data distribution, and we can also use it as the unit to distribute computation. This can greatly simplify the routing logic of this distributed planner, by always schedule the computation to the node that currently opening the corresponding region. And is also easy to scale more node for computing since GreptimeDB's data is persisted on shared storage backend like S3. But this is a bit beyond the scope of this specific topic.
-## Background: Commutativity
-Commutativity is an attribute that describes whether two operation can exchange their apply order: $P1(P2(R)) \Leftrightarrow P2(P1(R))$. If the equation keeps, we can transform one expression into another form without changing its result. This is useful on rewriting SQL expression, and is the theoretical basis of this RFC.
-
-Take this SQL as an example
-
-``` sql
-SELECT a FROM t WHERE a > 10;
-```
-
-As we know projection and filter are commutative (todo: latex), it can be translated to the following two identical plan trees:
-
-```text
-┌─────────────┐       ┌─────────────┐
-│Projection(a)│       │Filter(a>10) │
-└──────▲──────┘       └──────▲──────┘
-       │                     │
-┌──────┴──────┐       ┌──────┴──────┐
-│Filter(a>10) │       │Projection(a)│
-└──────▲──────┘       └──────▲──────┘
-       │                     │
-┌──────┴──────┐       ┌──────┴──────┐
-│  TableScan  │       │  TableScan  │
-└─────────────┘       └─────────────┘
-```
-
-## Merge Operation
-
-This RFC proposes to add a new expression node `MergeScan` to merge result from several regions in the frontend. It wrap the abstraction of remote data and execution, and expose a `TableScan` interface to upper level.
-
-``` text
-        ▲
-        │
-┌───────┼───────┐
-│       │       │
-│    ┌──┴──┐    │
-│    └──▲──┘    │
-│       │       │
-│    ┌──┴──┐    │
-│    └──▲──┘    │    ┌─────────────────────────────┐
-│       │       │    │                             │
-│  ┌────┴────┐  │    │ ┌──────────┐ ┌───┐    ┌───┐ │
-│  │MergeScan◄──┼────┤ │ Region 1 │ │   │ .. │   │ │
-│  └─────────┘  │    │ └──────────┘ └───┘    └───┘ │
-│               │    │                             │
-└─Frontend──────┘    └─Remote-Sources──────────────┘
-```
-This merge operation simply chains all the the underlying remote data sources and return `RecordBatch`, just like a coalesce op. And each remote sources is a gRPC query to datanode via the substrait logical plan interface. The plan is transformed and divided from the original query that comes to frontend.
-
-## Commutativity of MergeScan
-
-Obviously, The position of `MergeScan` is the key of the distributed plan. The more closer to the underlying `TableScan`, the less computation is taken by datanodes. Thus the goal is to pull the `MergeScan` up as more as possible. The word "pull up" means exchange `MergeScan` with its parent node in the plan tree, which means we should check the commutativity between the existing expression nodes and the `MergeScan`. Here I classify all the possibility into five categories:
-
-- Commutative: $P1(P2(R)) \Leftrightarrow P2(P1(R))$
-  - filter
-  - projection
-  - operations that match the partition key
-- Partial Commutative: $P1(P2(R)) \Leftrightarrow P1(P2(P1(R)))$
-  - $min(R) \rightarrow min(MERGE(min(R)))$
-  - $max(R) \rightarrow max(MERGE(max(R)))$
-- Conditional Commutative: $P1(P2(R)) \Leftrightarrow P3(P2(P1(R)))$
-  - $count(R) \rightarrow sum(count(R))$
-- Transformed Commutative: $P1(P2(R)) \Leftrightarrow P1(P3(R)) \Leftrightarrow P3(P1(R))$
-  - $avg(R) \rightarrow sum(R)/count(R)$
-- Non-commutative
-  - sort
-  - join
-  - percentile
-## Steps to plan
-After establishing the set of commutative relations for all expressions, we can begin transforming the logical plan. There are four steps:
-
-  - Add a merge node before table scan
-  - Evaluate commutativity in a bottom-up way, stop at the first non-commutative node
-  - Divide the TableScan to scan over partitions
-  - Execute
-
-First insert the `MergeScan` on top of the bottom `TableScan` node. Then examine the commutativity start from the `MergeScan` node transform the plan tree based on the result. Stop this process on the first non-commutative node.
-``` text
-                  ┌─────────────┐   ┌─────────────┐
-                  │    Sort     │   │    Sort     │
-                  └──────▲──────┘   └──────▲──────┘
-                         │                 │
-┌─────────────┐   ┌──────┴──────┐   ┌──────┴──────┐
-│    Sort     │   │Projection(a)│   │  MergeScan  │
-└──────▲──────┘   └──────▲──────┘   └──────▲──────┘
-       │                 │                 │
-┌──────┴──────┐   ┌──────┴──────┐   ┌──────┴──────┐
-│Projection(a)│   │  MergeScan  │   │Projection(a)│
-└──────▲──────┘   └──────▲──────┘   └──────▲──────┘
-       │                 │                 │
-┌──────┴──────┐   ┌──────┴──────┐   ┌──────┴──────┐
-│  TableScan  │   │  TableScan  │   │  TableScan  │
-└─────────────┘   └─────────────┘   └─────────────┘
-      (a)               (b)               (c)
-```
-Then in the physical planning phase, convert the sub-tree below `MergeScan` into a remote query request and dispatch to all the regions. And let the `MergeScan` to receive the results and feed to it parent node.
-
-To simplify the overall complexity, any error in the procedure will lead to a failure to the entire query, and cancel all other parts.
-# Alternatives
-## Spill
-If only consider the ability of processing large dataset, we can enable DataFusion's spill ability to temporary persist intermediate data into disk, like the "swap" memory. But this will lead to a super slow performance and very large write amplification.
-# Future Work
-As described in the `Motivation` section we can further explore the distributed planner on the physical execution level, by introducing mechanism like Spark's shuffle to improve parallelism and reduce intermediate pipeline breaker's stage.

docs/rfcs/2023-07-06-table-engine-refactor.md

@@ -1,303 +0,0 @@
----
-Feature Name: table-engine-refactor
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/1869
-Date: 2023-07-06
-Author: "Yingwen <realevenyag@gmail.com>"
----
-
-Refactor Table Engine
-----------------------
-
-# Summary
-Refactor table engines to address several historical tech debts.
-
-# Motivation
-Both `Frontend` and `Datanode` have to deal with multiple regions in a table. This results in code duplication and additional burden to the `Datanode`.
-
-Before:
-
-
-```mermaid
-graph TB
-
-subgraph Frontend["Frontend"]
-    subgraph MyTable
-        A("region 0, 2 -> Datanode0")
-        B("region 1, 3 -> Datanode1")
-    end
-end
-
-MyTable --> MetaSrv
-MetaSrv --> ETCD
-
-MyTable-->TableEngine0
-MyTable-->TableEngine1
-
-subgraph Datanode0
-    Procedure0("procedure")
-    TableEngine0("table engine")
-    region0
-    region2
-    mytable0("my_table")
-
-    Procedure0-->mytable0
-    TableEngine0-->mytable0
-    mytable0-->region0
-    mytable0-->region2
-end
-
-
-subgraph Datanode1
-    Procedure1("procedure")
-    TableEngine1("table engine")
-    region1
-    region3
-    mytable1("my_table")
-
-    Procedure1-->mytable1
-    TableEngine1-->mytable1
-    mytable1-->region1
-    mytable1-->region3
-end
-
-
-subgraph manifest["table manifest"]
-    M0("my_table")
-    M1("regions: [0, 1, 2, 3]")
-end
-
-mytable1-->manifest
-mytable0-->manifest
-
-RegionManifest0("region manifest 0")
-RegionManifest1("region manifest 1")
-RegionManifest2("region manifest 2")
-RegionManifest3("region manifest 3")
-region0-->RegionManifest0
-region1-->RegionManifest1
-region2-->RegionManifest2
-region3-->RegionManifest3
-```
-
-`Datanodes` can update the same manifest file for a table as regions are assigned to different nodes in the cluster. We also have to run procedures on `Datanode` to ensure the table manifest is consistent with region manifests. "Table" in a `Datanode` is a subset of the table's regions. The `Datanode` is much closer to `RegionServer` in `HBase` which only deals with regions.
-
-In cluster mode, we store table metadata in etcd and table manifest. The table manifest becomes redundant. We can remove the table manifest if we refactor the table engines to region engines that only care about regions. What's more, we don't need to run those procedures on `Datanode`.
-
-After:
-```mermaid
-graph TB
-
-subgraph Frontend["Frontend"]
-    direction LR
-    subgraph MyTable
-        A("region 0, 2 -> Datanode0")
-        B("region 1, 3 -> Datanode1")
-    end
-end
-
-MyTable --> MetaSrv
-MetaSrv --> ETCD
-
-MyTable-->RegionEngine
-MyTable-->RegionEngine1
-
-subgraph Datanode0
-    RegionEngine("region engine")
-    region0
-    region2
-    RegionEngine-->region0
-    RegionEngine-->region2
-end
-
-
-subgraph Datanode1
-    RegionEngine1("region engine")
-    region1
-    region3
-    RegionEngine1-->region1
-    RegionEngine1-->region3
-end
-
-RegionManifest0("region manifest 0")
-RegionManifest1("region manifest 1")
-RegionManifest2("region manifest 2")
-RegionManifest3("region manifest 3")
-region0-->RegionManifest0
-region1-->RegionManifest1
-region2-->RegionManifest2
-region3-->RegionManifest3
-```
-This RFC proposes to refactor table engines into region engines as a first step to make the `Datanode` acts like a `RegionServer`.
-
-
-# Details
-## Overview
-
-We plan to refactor the `TableEngine` trait into `RegionEngine` gradually. This RFC focuses on the `mito` engine as it is the default table engine and the most complicated engine.
-
-Currently, we built `MitoEngine` upon `StorageEngine` that manages regions of the `mito` engine. Since `MitoEngine` becomes a region engine, we could combine `StorageEngine` with `MitoEngine` to simplify our code structure.
-
-The chart below shows the overall architecture of the `MitoEngine`.
-
-```mermaid
-classDiagram
-class MitoEngine~LogStore~ {
-    -WorkerGroup workers
-}
-class MitoRegion {
-    +VersionControlRef version_control
-    -RegionId region_id
-    -String manifest_dir
-    -AtomicI64 last_flush_millis
-    +region_id() RegionId
-    +scan() ChunkReaderImpl
-}
-class RegionMap {
-    -HashMap&lt;RegionId, MitoRegionRef&gt; regions
-}
-class ChunkReaderImpl
-
-class WorkerGroup {
-    -Vec~RegionWorker~ workers
-}
-class RegionWorker {
-    -RegionMap regions
-    -Sender sender
-    -JoinHandle handle
-}
-class RegionWorkerThread~LogStore~ {
-    -RegionMap regions
-    -Receiver receiver
-    -Wal~LogStore~ wal
-    -ObjectStore object_store
-    -MemtableBuilderRef memtable_builder
-    -FlushSchedulerRef~LogStore~ flush_scheduler
-    -FlushStrategy flush_strategy
-    -CompactionSchedulerRef~LogStore~ compaction_scheduler
-    -FilePurgerRef file_purger
-}
-class Wal~LogStore~ {
-    -LogStore log_store
-}
-class MitoConfig
-
-MitoEngine~LogStore~ o-- MitoConfig
-MitoEngine~LogStore~ o-- MitoRegion
-MitoEngine~LogStore~ o-- WorkerGroup
-MitoRegion o-- VersionControl
-MitoRegion -- ChunkReaderImpl
-WorkerGroup o-- RegionWorker
-RegionWorker o-- RegionMap
-RegionWorker -- RegionWorkerThread~LogStore~
-RegionWorkerThread~LogStore~ o-- RegionMap
-RegionWorkerThread~LogStore~ o-- Wal~LogStore~
-```
-
-We replace the `RegionWriter` with `RegionWorker` to process write requests and DDL requests.
-
-
-## Metadata
-We also merge region's metadata with table's metadata. It should make metadata much easier to maintain.
-```mermaid
-classDiagram
-class VersionControl {
-    -CowCell~Version~ version
-    -AtomicU64 committed_sequence
-}
-class Version {
-    -RegionMetadataRef metadata
-    -MemtableVersionRef memtables
-    -LevelMetasRef ssts
-    -SequenceNumber flushed_sequence
-    -ManifestVersion manifest_version
-}
-class MemtableVersion {
-    -MemtableRef mutable
-    -Vec~MemtableRef~ immutables
-    +mutable_memtable() MemtableRef
-    +immutable_memtables() &[MemtableRef]
-    +freeze_mutable(MemtableRef new_mutable) MemtableVersion
-}
-class LevelMetas {
-    -LevelMetaVec levels
-    -AccessLayerRef sst_layer
-    -FilePurgerRef file_purger
-    -Option~i64~ compaction_time_window
-}
-class LevelMeta {
-    -Level level
-    -HashMap&lt;FileId, FileHandle&gt; files
-}
-class FileHandle {
-    -FileMeta meta
-    -bool compacting
-    -AtomicBool deleted
-    -AccessLayerRef sst_layer
-    -FilePurgerRef file_purger
-}
-class FileMeta {
-    +RegionId region_id
-    +FileId file_id
-    +Option&lt;Timestamp, Timestamp&gt; time_range
-    +Level level
-    +u64 file_size
-}
-
-VersionControl o-- Version
-Version o-- RegionMetadata
-Version o-- MemtableVersion
-Version o-- LevelMetas
-LevelMetas o-- LevelMeta
-LevelMeta o-- FileHandle
-FileHandle o-- FileMeta
-
-class RegionMetadata {
-    +RegionId region_id
-    +VersionNumber version
-    +SchemaRef table_schema
-    +Vec~usize~ primary_key_indices
-    +Vec~usize~ value_indices
-    +ColumnId next_column_id
-    +TableOptions region_options
-    +DateTime~Utc~ created_on
-    +RegionSchemaRef region_schema
-}
-class RegionSchema {
-    -SchemaRef user_schema
-    -StoreSchemaRef store_schema
-    -ColumnsMetadataRef columns
-}
-class Schema
-class StoreSchema {
-    -Vec~ColumnMetadata~ columns
-    -SchemaRef schema
-    -usize row_key_end
-    -usize user_column_end
-}
-class ColumnsMetadata {
-    -Vec~ColumnMetadata~ columns
-    -HashMap&lt;String, usize&gt; name_to_col_index
-    -usize row_key_end
-    -usize timestamp_key_index
-    -usize user_column_end
-}
-class ColumnMetadata
-
-RegionMetadata o-- RegionSchema
-RegionMetadata o-- Schema
-RegionSchema o-- StoreSchema
-RegionSchema o-- Schema
-RegionSchema o-- ColumnsMetadata
-StoreSchema o-- ColumnsMetadata
-StoreSchema o-- Schema
-StoreSchema o-- ColumnMetadata
-ColumnsMetadata o-- ColumnMetadata
-```
-
-# Drawback
-This is a breaking change.
-
-# Future Work
-- Rename `TableEngine` to `RegionEngine`
-- Simplify schema relationship in the `mito` engine
-- Refactor the `Datanode` into a `RegionServer`.

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

@@ -1,202 +0,0 @@
----
-Feature Name: metric-engine
-Tracking Issue: TBD
-Date: 2023-07-10
-Author: "Ruihang Xia <waynestxia@gmail.com>"
----
-
-# Summary
-
-A new metric engine that can significantly enhance our ability to handle the tremendous number of small tables in scenarios like Prometheus metrics, by leveraging a synthetic wide table that offers storage and metadata multiplexing capabilities over the existing engine.
-
-# Motivation
-
-The concept "Table" in GreptimeDB is a bit "heavy" compared to other time-series storage like Prometheus or VictoriaMetrics. This has lots of disadvantages in aspects from performance, footprint, and storage to cost.
-
-# Details
-
-## Top level description
-
-- User Interface
-
-    This feature will add a new type of storage engine. It might be available to be an option like `with ENGINE=mito` or an internal interface like auto create table on Prometheus remote write. From the user side, there is no difference from tables in mito engine. All the DDL like `CREATE`, `ALTER` and DML like `SELECT` should be supported.
-
-- Implementation Overlook
-
-    This new engine doesn't re-implement low level components like file R/W etc. It's a wrapper layer over the existing mito engine, with extra storage and metadata multiplexing capabilities. I.e., it expose multiple table based on one mito engine table like this:
-	``` plaintext
-	   ┌───────────────┐ ┌───────────────┐ ┌───────────────┐
-	   │ Metric Engine │ │ Metric Engine │ │ Metric Engine │
-	   │   Table 1     │ │   Table 2     │ │   Table 3     │
-	   └───────────────┘ └───────────────┘ └───────────────┘
-	           ▲               ▲                   ▲
-	           │               │                   │
-	           └───────────────┼───────────────────┘
-	                           │
-	                 ┌─────────┴────────┐
-	                 │ Metric Region    │
-	                 │   Engine         │
-	                 │    ┌─────────────┤
-	                 │    │ Mito Region │
-	                 │    │   Engine    │
-	                 └────▲─────────────┘
-	                      │
-	                      │
-	                ┌─────┴───────────────┐
-	                │                     │
-	                │  Mito Engine Table  │
-	                │                     │
-	                └─────────────────────┘
-	```
-
-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
-
-## Routing
-
-Before this change, the region route rule was based on a group of partition keys. Relation of physical table to region is one-to-many.
-
-``` rust
-  pub struct PartitionDef {
-      partition_columns: Vec<String>,
-      partition_bounds: Vec<PartitionBound>,
-  }
-```
-
-And for metric engine tables, the key difference is we split the concept of "physical table" and "logical table". Like the previous ASCII chart, multiple logical tables are based on one physical table. The relationship of logical table to region becomes many-to-many. Thus, we must include the table name (of logical table) into partition rules.
-
-Consider the partition/route interface is a generic map of string array to region id, all we need to do is to insert logical table name into the request:
-
-``` rust
-  fn route(request: Vec<String>) -> RegionId;
-```
-
-The next question is, where to do this conversion? The basic idea is to dispatch different routing behavior based on the engine type. Since we have all the necessary information in frontend, it's a good place to do that. And can leave meta server untouched. The essential change is to associate engine type with route rule.
-
-## Physical Region Schema
-
-The idea "physical wide table" is to perform column-level multiplexing. I.e., map all logical columns to physical columns by their names.
-
-```
-   ┌────────────┐      ┌────────────┐         ┌────────────┐
-   │   Table 1  │      │   Table 2  │         │   Table 3  │
-   ├───┬────┬───┤      ├───┬────┬───┤         ├───┬────┬───┤
-   │C1 │ C2 │ C3│      │C1 │ C3 │ C5├──────┐  │C2 │ C4 │ C6│
-   └─┬─┴──┬─┴─┬─┘ ┌────┴───┴──┬─┴───┘      │  └─┬─┴──┬─┴─┬─┘
-     │    │   │   │           │            │    │    │   │
-     │    │   │   │           └──────────┐ │    │    │   │
-     │    │   │   │                      │ │    │    │   │
-     │    │   │   │  ┌─────────────────┐ │ │    │    │   │
-     │    │   │   │  │ Physical Table  │ │ │    │    │   │
-     │    │   │   │  ├──┬──┬──┬──┬──┬──┘ │ │    │    │   │
-     └────x───x───┴─►│C1│C2│C3│C4│C5│C6◄─┼─x────x────x───┘
-          │   │      └──┘▲─┘▲─┴─▲└─▲└──┘ │ │    │    │
-          │   │          │  │   │  │     │ │    │    │
-          ├───x──────────┘  ├───x──x─────┘ │    │    │
-          │   │             │   │  │       │    │    │
-          │   └─────────────┘   │  └───────┘    │    │
-          │                     │               │    │
-          └─────────────────────x───────────────┘    │
-                                │                    │
-                                └────────────────────┘
-```
-
-This approach is very straightforward but has one problem. It only works when two columns have different semantic type (time index, tag or field) or data types but with the same name. E.g., `CREATE TABLE t1 (c1 timestamp(3) TIME INDEX)` and `CREATE TABLE t2 (c1 STRING PRIMARY KEY)`.
-
-One possible workaround is to prefix each column with its data type and semantic type, like `_STRING_PK_c1`. However, considering the primary goal at present is to support data from monitoring metrics like Prometheus remote write, it's acceptable not to support this at first because data types are often simple and limited here.
-
-
-The next point is changing the physical table's schema. This is only needed when creating a new logical table or altering the existing table. Typically speaking, table creating and altering are explicit. We only need to emit an add column request to underlying physical table on processing logical table's DDL. GreptimeDB can create or alter table automatically on some protocols, but the internal logic is the same.
-
-Also for simplicity, we don't support shrinking the underlying table at first. This can be achieved by introducing mechanism on the physical column.
-
-Frontend needs not to keep physical table's schema.
-
-## Metadata of physical regions
-
-Those metric engine regions need to store extra metadata like the schema of logical table or all logical table's name. That information is relatively simple and can be stored in a format like key-value pair. For now, we have to use another physical mito region for metadata. This involves an issue with region scheduling. Since we don't have the ability to perform affinity scheduling, the initial version will just assume the data region and metadata region are in the same instance. See alternatives - other storage for physical region's metadata for possible future improvement.
-
-Here is the schema of metadata region and how we would use it. The `CREATE TABLE` clause of metadata region looks like the following. Notice that it wouldn't be actually created by SQL.
-
-``` sql
-  CREATE TABLE metadata(
-  	ts timestamp time index,
-    	key string primary key,
-    	value string
-  );
-```
-
-The `ts` field is just a placeholder -- for the constraints that a mito region must contain a time index field. It will always be `0`. The other two fields `key` and `value` will be used as a k-v storage. It contains two group of key
-    - `__table_<TABLE_NAME>` is used for marking table existence. It doesn't have value.
-    - `__column_<TABLE_NAME>_<COLUMN_NAME>` is used for marking table existence, the value is column's semantic type.
-
-## Physical region implementation
-
-This RFC proposes to add a new region implementation named "MetricRegion". As showed in the first chart, it's wrapped over the existing mito region. This section will describe the implementation details. Firstly, here is a chart shows how the region hierarchy looks like:
-
-```plaintext
- ┌───────────────────────┐
- │ Metric Region         │
- │                       │
- │   ┌────────┬──────────┤
- │   │ Mito   │ Mito     │
- │   │ Region │ Region   │
- │   │ for    │ for      │
- │   │ Data   │ Metadata │
- └───┴────────┴──────────┘
-```
-
-All upper levels only see the Metric Region. E.g., Meta Server schedules on this region, or Frontend routes requests to this Metrics Region's id. To be scheduled (open or close etc.), Metric Region needs to implement its own procedures. Most of those procedures can be simply assembled from underlying Mito Regions', but those related to data like alter or drop will have its own new logic.
-
-Another point is region id. Since the region id is used widely from meta server to persisted state, it's better to keep it unchanged. This means we can't use the same id for two regions, but one for each. To achieve this, this RFC proposes a concept named "region id group". A region id group is a group of region ids that are bound for different purposes. Like the two underlying regions here. 
-
-This preserves the first 8 bits of the `u32` region number for grouping. Each group has one main id (the first one) and other sub ids (the rest non-zero ids). All components other than the region implementation itself doesn't aware of the existence of region id group. They only see the main id. The region implementation is in response of managing and using the region id group.
-
-```plaintext
-63                                  31         23                  0
-┌────────────────────────────────────┬──────────┬──────────────────┐
-│          Table Id(32)              │ Group(8) │ Region Number(24)│
-└────────────────────────────────────┴──────────┴──────────────────┘
-                                            Region Id(32)
-```
-
-## Routing in meta server
-
-From previous sections, we can conclude the following points about routing:
-- Each "logical table" has its own, universe unique table id.
-- Logical table doesn't have physical region, they share the same physical region with other logical tables.
-- Route rule of logical table's is a strict subset of physical table's.
-
-To associate the logical table with physical region, we need to specify necessary information in the create table request. Specifically, the table type and its parent table. This require to change our gRPC proto's definition. And once meta recognize the table to create is a logical table, it will use the parent table's region to create route entry.
-
-And to reduce the consumption of region failover (which need to update the physical table route info), we'd better to split the current route table structure into two parts:
-
-```rust
-region_route: Map<TableName, [RegionId]>,
-node_route: Map<RegionId, NodeId>,
-```
-
-By doing this on each failover the meta server only needs to update the second `node_route` map and leave the first one untouched.
-
-## Query
-
-Like other existing components, a user query always starts in the frontend. In the planning phase, frontend needs to fetch related schemas of the queried table. This part is the same. I.e., changes in this RFC don't affect components above the `Table` abstraction.
-
-# Alternatives
-
-## Other routing method
-
-We can also do this "special" route rule in the meta server. But there is no difference with the proposed method.
-
-## Other storage for physical region's metadata
-
-Once we have implemented the "region family" that allows multiple physical schemas exist in one region, we can store the metadata and table data into one region.
-
-Before that, we can also let the `MetricRegion` holds a `KvBackend` to access the storage layer directly. But this breaks the abstraction in some way.
-
-# Drawbacks
-
-Since the physical storage is mixed together. It's hard to do fine-grained operations in table level. Like configuring TTL, memtable size or compaction strategy in table level. Or define different partition rules for different tables. For scenarios like this, it's better to move the table out of metrics engine and "upgrade" it to a normal mito engine table. This requires a migration process in a low cost. And we have to ensure data consistency during the migration, which may require a out-of-service period.

docs/rfcs/2023-08-04-tabie-trait-refactor.md

@@ -1,175 +0,0 @@
----
-Feature Name: table-trait-refactor
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/2065
-Date: 2023-08-04
-Author: "Ruihang Xia <waynestxia@gmail.com>"
----
-
-Refactor Table Trait
---------------------
-
-# Summary
-Refactor `Table` trait to adapt the new region server architecture and make code more straightforward.
-
-# Motivation
-The `Table` is designed in the background of both frontend and datanode keeping the same concepts. And all the operations are served by a `Table`. However, in our practice, we found that not all the operations are suitable to be served by a `Table`. For example, the `Table` doesn't hold actual physical data itself, thus operations like write or alter are simply a proxy over underlying regions. And in the recent refactor to datanode ([rfc table-engine-refactor](./2023-07-06-table-engine-refactor.md)), we are changing datanode to region server that is only aware of `Region` things. This also calls for a refactor to the `Table` trait.
-
-# Details
-
-## Definitions
-
-The current `Table` trait contains the following methods:
-```rust
-pub trait Table {
-    /// Get a reference to the schema for this table
-    fn schema(&self) -> SchemaRef;
-
-    /// Get a reference to the table info.
-    fn table_info(&self) -> TableInfoRef;
-
-    /// Get the type of this table for metadata/catalog purposes.
-    fn table_type(&self) -> TableType;
-
-    /// Insert values into table.
-    ///
-    /// Returns number of inserted rows.
-    async fn insert(&self, _request: InsertRequest) -> Result<usize>;
-
-    /// Generate a record batch stream for querying.
-    async fn scan_to_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream>;
-
-    /// Tests whether the table provider can make use of any or all filter expressions
-    /// to optimise data retrieval.
-    fn supports_filters_pushdown(&self, filters: &[&Expr]) -> Result<Vec<FilterPushDownType>>;
-
-    /// Alter table.
-    async fn alter(&self, _context: AlterContext, _request: &AlterTableRequest) -> Result<()>;
-
-    /// Delete rows in the table.
-    ///
-    /// Returns number of deleted rows.
-    async fn delete(&self, _request: DeleteRequest) -> Result<usize>;
-
-    /// Flush table.
-    ///
-    /// Options:
-    /// - region_number: specify region to flush.
-    /// - wait: Whether to wait until flush is done.
-    async fn flush(&self, region_number: Option<RegionNumber>, wait: Option<bool>) -> Result<()>;
-
-    /// Close the table.
-    async fn close(&self, _regions: &[RegionNumber]) -> Result<()>;
-
-    /// Get region stats in this table.
-    fn region_stats(&self) -> Result<Vec<RegionStat>>;
-
-    /// Return true if contains the region
-    fn contains_region(&self, _region: RegionNumber) -> Result<bool>;
-
-    /// Get statistics for this table, if available
-    fn statistics(&self) -> Option<TableStatistics>;
-
-    async fn compact(&self, region_number: Option<RegionNumber>, wait: Option<bool>) -> Result<()>;
-}
-```
-
-We can divide those methods into three categories from the perspective of functionality:
-
-|     Retrieve Metadata      | Manipulate Data |    Read Data     |
-| :------------------------: | :-------------: | :--------------: |
-|          `schema`          |    `insert`     | `scan_to_stream` |
-|        `table_info`        |     `alter`     |                  |
-|        `table_type`        |    `delete`     |                  |
-| `supports_filter_pushdown` |     `flush`     |                  |
-|       `region_stats`       |     `close`     |                  |
-|     `contains_region`      |    `compact`    |                  |
-|        `statistics`        |                 |                  |
-
-And considering most of the access to metadata happens in frontend, like route or query; and all the persisted data are stored in regions; while only the query engine needs to read data. We can divide the `Table` trait into three concepts:
-
-- struct `Table` provides metadata:
-    ```rust
-    impl Table {
-        /// Get a reference to the schema for this table
-        fn schema(&self) -> SchemaRef;
-
-        /// Get a reference to the table info.
-        fn table_info(&self) -> TableInfoRef;
-
-        /// Get the type of this table for metadata/catalog purposes.
-        fn table_type(&self) -> TableType;
-
-        /// Get statistics for this table, if available
-        fn statistics(&self) -> Option<TableStatistics>;
-
-        fn to_data_source(&self) -> DataSourceRef;
-    }
-    ```
-- Requests to region server
-  - `InsertRequest`
-  - `AlterRequest`
-  - `DeleteRequest`
-  - `FlushRequest`
-  - `CompactRequest`
-  - `CloseRequest`
-
-- trait `DataSource` provides data (`RecordBatch`)
-    ```rust
-    trait DataSource {
-        fn get_stream(&self, request: ScanRequest) -> Result<SendableRecordBatchStream>;
-    }
-    ```
-
-## Use `Table`
-
-`Table` will only be used in frontend. It's constructed from the `OpenTableRequest` or `CreateTableRequest`.
-
-`Table` also provides a method `to_data_source` to generate a `DataSource` from itself. But this method is only for non-`TableType::Base` tables (i.e., `TableType::View` and `TableType::Temporary`) because `TableType::Base` table doesn't hold actual data itself. Its `DataSource` should be constructed from the `Region` directly (in other words, it's a remote query).
-
-And it requires some extra information to construct a `DataSource`, named `TableSourceProvider`:
-
-```rust
-type TableFactory = Arc<dyn Fn() -> DataSourceRef>;
-
-pub enum TableSourceProvider {
-    Base,
-    View(LogicalPlan),
-    Temporary(TableFactory),
-}
-```
-
-## Use `DataSource`
-
-`DataSource` will be adapted to the `TableProvider` from DataFusion that can be `scan()`ed in a `TableScan` plan.
-
-In frontend this is done in the planning phase. And datanode will have one implementation for `Region` to generate record batch stream.
-
-## Interact with RegionServer
-
-Previously, persisted state change operations were through the old `Table` trait, like said before. Now they will come from the action source, like the procedure or protocol handler directly to the region server. E.g., on alter table, the corresponding procedure will generate its `AlterRequest` and send it to regions. Or write request will be split in frontend handler, and sent to regions. `Table` only provides necessary metadata like route information if needed, but not the necessary part anymore.
-
-## Implement temporary table
-
-Temporary table is a special table that doesn't revolves to any persistent physical region. Examples are:
-- the `Numbers` table for testing, which produces a record batch that contains 0-100 integers.
-- tables in information schema. It is an interface for querying catalog's metadata. The contents are generated on the fly with information from `CatalogManager`. The `CatalogManager` can be held in `TableFactory`.
-- Function table that produces data generated by a formula or a function. Like something that always `sin(current_timestamp())`.
-
-## Relationship among those components
-
-Here is a diagram to show the relationship among those components, and how they interact with each other.
-
-```mermaid
-erDiagram
-    CatalogManager ||--|{ Table : manages
-    Table ||--|{ DataStream : generates
-    Table ||--|{ Region : routes
-    Region ||--|{ DataStream : implements
-    DataStream }|..|| QueryEngine : adapts-to
-    Procedure ||--|{ Region : requests
-    Protocol ||--|{ Region : writes
-    Protocol ||--|{ QueryEngine : queries
-```
-
-# Drawback
-This is a breaking change.

docs/rfcs/2023-08-13-metadata-txn.md

@@ -1,90 +0,0 @@
----
-Feature Name: Update Metadata in single transaction
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/1715
-Date: 2023-08-13
-Author: "Feng Yangsen <fengys1996@gmail.com>, Xu Wenkang <wenymedia@gmail.com>"
----
-
-# Summary
-Update Metadata in single transaction.
-
-# Motivation
-Currently, multiple transactions are involved during the procedure. This implementation is inefficient, and it's hard to make data consistent. Therefore, We can update multiple metadata in a single transaction.
-
-# Details 
-Now we have the following table metadata keys:
-
-**TableInfo** 
-```rust
-// __table_info/{table_id}
-pub struct TableInfoKey {
-    table_id: TableId,
-}
-
-pub struct TableInfoValue {
-    pub table_info: RawTableInfo,
-    version: u64,
-}
-```
-
-**TableRoute** 
-```rust
-// __table_route/{table_id}
-pub struct NextTableRouteKey {
-    table_id: TableId,
-}
-
-pub struct TableRoute {
-    pub region_routes: Vec<RegionRoute>,
-}
-```
-**DatanodeTable**
-```rust
-// __table_route/{datanode_id}/{table_id}
-pub struct DatanodeTableKey {
-    datanode_id: DatanodeId,
-    table_id: TableId,
-}
-
-pub struct DatanodeTableValue {
-    pub table_id: TableId,
-    pub regions: Vec<RegionNumber>,
-    version: u64,
-}
-```
-
-**TableNameKey**
-```rust
-// __table_name/{CatalogName}/{SchemaName}/{TableName}
-pub struct TableNameKey<'a> {
-    pub catalog: &'a str,
-    pub schema: &'a str,
-    pub table: &'a str,
-}
-
-pub struct TableNameValue {
-    table_id: TableId,
-}
-```
-
-These table metadata only updates in the following operations.
-
-## Region Failover
-It needs to update `TableRoute` key and `DatanodeTable` keys. If the `TableRoute` equals the Snapshot of `TableRoute` submitting the Failover task, then we can safely update these keys.
-
-After submitting Failover tasks to acquire locks for execution, the `TableRoute` may be updated by another task. After acquiring the lock, we can get the latest `TableRoute` again and then execute it if needed.
-
-## Create Table DDL
-Creates all of the above keys. `TableRoute`, `TableInfo`, should be empty.
-
-The **TableNameKey**'s lock will be held by the procedure framework.
-## Drop Table DDL
-
-`TableInfoKey` and `NextTableRouteKey` will be added with  `__removed-` prefix, and the other above keys will be deleted.  The transaction will not compare any keys.
-## Alter Table DDL
-
-1. Rename table, updates `TableInfo` and `TableName`. Compares `TableInfo`, and the new `TableNameKey` should be empty, and TableInfo should equal the Snapshot when submitting DDL.
-
-The old and new **TableNameKey**'s lock will be held by the procedure framework.
-
-2. Alter table, updates `TableInfo`. `TableInfo` should equal the Snapshot when submitting DDL.

docs/schema-structs.md

@@ -1,527 +0,0 @@
-# Schema Structs
-
-# Common Schemas
-The `datatypes` crate defines the elementary schema struct to describe the metadata.
-
-## ColumnSchema
-[ColumnSchema](https://github.com/GreptimeTeam/greptimedb/blob/9fa871a3fad07f583dc1863a509414da393747f8/src/datatypes/src/schema/column_schema.rs#L36) represents the metadata of a column. It is equivalent to arrow's [Field](https://docs.rs/arrow/latest/arrow/datatypes/struct.Field.html) with additional metadata such as default constraint and whether the column is a time index. The time index is the column with a `TIME INDEX` constraint of a table. We can convert the `ColumnSchema` into an arrow `Field` and convert the `Field` back to the `ColumnSchema` without losing metadata.
-
-```rust
-pub struct ColumnSchema {
-    pub name: String,
-    pub data_type: ConcreteDataType,
-    is_nullable: bool,
-    is_time_index: bool,
-    default_constraint: Option<ColumnDefaultConstraint>,
-    metadata: Metadata,
-}
-```
-
-## Schema
-[Schema](https://github.com/GreptimeTeam/greptimedb/blob/9fa871a3fad07f583dc1863a509414da393747f8/src/datatypes/src/schema.rs#L38) is an ordered sequence of `ColumnSchema`. It is equivalent to arrow's [Schema](https://docs.rs/arrow/latest/arrow/datatypes/struct.Schema.html) with additional metadata including the index of the time index column and the version of this schema. Same as `ColumnSchema`, we can convert our `Schema` from/to arrow's `Schema`.
-
-```rust
-use arrow::datatypes::Schema as ArrowSchema;
-
-pub struct Schema {
-    column_schemas: Vec<ColumnSchema>,
-    name_to_index: HashMap<String, usize>,
-    arrow_schema: Arc<ArrowSchema>,
-    timestamp_index: Option<usize>,
-    version: u32,
-}
-
-pub type SchemaRef = Arc<Schema>;
-```
-
-We alias `Arc<Schema>` as `SchemaRef` since it is used frequently. Mostly, we use our `ColumnSchema` and `Schema` structs instead of Arrow's `Field` and `Schema` unless we need to invoke third-party libraries (like DataFusion or ArrowFlight) that rely on Arrow.
-
-## RawSchema
-`Schema` contains fields like a map from column names to their indices in the `ColumnSchema` sequences and a cached arrow `Schema`. We can construct these fields from the `ColumnSchema` sequences thus we don't want to serialize them. This is why we don't derive `Serialize` and `Deserialize` for `Schema`. We introduce a new struct [RawSchema](https://github.com/GreptimeTeam/greptimedb/blob/9fa871a3fad07f583dc1863a509414da393747f8/src/datatypes/src/schema/raw.rs#L24) which keeps all required fields of a `Schema` and derives the serialization traits. To serialize a `Schema`, we need to convert it into a `RawSchema` first and serialize the `RawSchema`.
-
-```rust
-pub struct RawSchema {
-    pub column_schemas: Vec<ColumnSchema>,
-    pub timestamp_index: Option<usize>,
-    pub version: u32,
-}
-```
-
-We want to keep the `Schema` simple and avoid putting too much business-related metadata in it as many different structs or traits rely on it.
-
-# Schema of the Table
-A table maintains its schema in [TableMeta](https://github.com/GreptimeTeam/greptimedb/blob/9fa871a3fad07f583dc1863a509414da393747f8/src/table/src/metadata.rs#L97).
-```rust
-pub struct TableMeta {
-    pub schema: SchemaRef,
-    pub primary_key_indices: Vec<usize>,
-    pub value_indices: Vec<usize>,
-    // ...
-}
-```
-
-The order of columns in `TableMeta::schema` is the same as the order specified in the `CREATE TABLE` statement which users use to create this table.
-
-The field `primary_key_indices` stores indices of primary key columns. The field `value_indices` records the indices of value columns (non-primary key and time index, we sometimes call them field columns).
-
-Suppose we create a table with the following SQL
-```sql
-CREATE TABLE cpu (
-    ts TIMESTAMP,
-    host STRING,
-    usage_user DOUBLE,
-    usage_system DOUBLE,
-    datacenter STRING,
-    TIME INDEX (ts),
-    PRIMARY KEY(datacenter, host)) ENGINE=mito WITH(regions=1);
-```
-
-Then the table's `TableMeta` may look like this:
-```json
-{
-    "schema":{
-        "column_schemas":[
-            "ts",
-            "host",
-            "usage_user",
-            "usage_system",
-            "datacenter"
-        ],
-        "time_index":0,
-        "version":0
-    },
-    "primary_key_indices":[
-        4,
-        1
-    ],
-    "value_indices":[
-        2,
-        3
-    ]
-}
-```
-
-
-# Schemas of the storage engine
-We split a table into one or more units with the same schema and then store these units in the storage engine. Each unit is a region in the storage engine.
-
-The storage engine maintains schemas of regions in more complicated ways because it
-- adds internal columns that are invisible to users to store additional metadata for each row
-- provides a data model similar to the key-value model so it organizes columns in a different order
-- maintains additional metadata like column id or column family
-
-So the storage engine defines several schema structs:
-- RegionSchema
-- StoreSchema
-- ProjectedSchema
-
-## RegionSchema
-A [RegionSchema](https://github.com/GreptimeTeam/greptimedb/blob/9fa871a3fad07f583dc1863a509414da393747f8/src/storage/src/schema/region.rs#L37) describes the schema of a region.
-
-```rust
-pub struct RegionSchema {
-    user_schema: SchemaRef,
-    store_schema: StoreSchemaRef,
-    columns: ColumnsMetadataRef,
-}
-```
-
-Each region reserves some columns called `internal columns` for internal usage:
-- `__sequence`, sequence number of a row
-- `__op_type`, operation type of a row, such as `PUT` or `DELETE`
-- `__version`, user-specified version of a row, reserved but not used. We might remove this in the future
-
-The table engine can't see the `__sequence` and `__op_type` columns, so the `RegionSchema` itself maintains two internal schemas:
-- User schema, a `Schema` struct that doesn't have internal columns
-- Store schema, a `StoreSchema` struct that has internal columns
-
-The `ColumnsMetadata` struct keeps metadata about all columns but most time we only need to use metadata in user schema and store schema, so we just ignore it. We may remove this struct in the future.
-
-`RegionSchema` organizes columns in the following order:
-```
-key columns, timestamp, [__version,] value columns, __sequence, __op_type
-```
-
-We can ignore the `__version` column because it is disabled now:
-
-```
-key columns, timestamp, value columns, __sequence, __op_type
-```
-
-Key columns are columns of a table's primary key. Timestamp is the time index column. A region sorts all rows by key columns, timestamp, sequence, and op type.
-
-So the `RegionSchema` of our `cpu` table above looks like this:
-```json
-{
-    "user_schema":[
-        "datacenter",
-        "host",
-        "ts",
-        "usage_user",
-        "usage_system"
-    ],
-    "store_schema":[
-        "datacenter",
-        "host",
-        "ts",
-        "usage_user",
-        "usage_system",
-        "__sequence",
-        "__op_type"
-    ]
-}
-```
-
-## StoreSchema
-As described above, a [StoreSchema](https://github.com/GreptimeTeam/greptimedb/blob/9fa871a3fad07f583dc1863a509414da393747f8/src/storage/src/schema/store.rs#L36) is a schema that knows all internal columns.
-```rust
-struct StoreSchema {
-    columns: Vec<ColumnMetadata>,
-    schema: SchemaRef,
-    row_key_end: usize,
-    user_column_end: usize,
-}
-```
-
-The columns in the `columns` and `schema` fields have the same order. The `ColumnMetadata` has metadata like column id, column family id, and comment. The `StoreSchema` also stores this metadata in `StoreSchema::schema`, so we can convert the `StoreSchema` between arrow's `Schema`. We use this feature to persist the `StoreSchema` in the SST since our SST format is `Parquet`, which can take arrow's `Schema` as its schema.
-
-The `StoreSchema` of the region above is similar to this:
-```json
-{
-    "schema":{
-        "column_schemas":[
-            "datacenter",
-            "host",
-            "ts",
-            "usage_user",
-            "usage_system",
-            "__sequence",
-            "__op_type"
-        ],
-        "time_index":2,
-        "version":0
-    },
-    "row_key_end":3,
-    "user_column_end":5
-}
-```
-
-The key and timestamp columns form row keys of rows. We put them together so we can use `row_key_end` to get indices of all row key columns. Similarly, we can use the `user_column_end` to get indices of all user columns (non-internal columns).
-```rust
-impl StoreSchema {
-    #[inline]
-    pub(crate) fn row_key_indices(&self) -> impl Iterator<Item = usize> {
-        0..self.row_key_end
-    }
-
-    #[inline]
-    pub(crate) fn value_indices(&self) -> impl Iterator<Item = usize> {
-        self.row_key_end..self.user_column_end
-    }
-}
-```
-
-Another useful feature of `StoreSchema` is that we ensure it always contains key columns, a timestamp column, and internal columns because we need them to perform merge, deduplication, and delete. Projection on `StoreSchema` only projects value columns.
-
-## ProjectedSchema
-To support arbitrary projection, we introduce the [ProjectedSchema](https://github.com/GreptimeTeam/greptimedb/blob/9fa871a3fad07f583dc1863a509414da393747f8/src/storage/src/schema/projected.rs#L106).
-```rust
-pub struct ProjectedSchema {
-    projection: Option<Projection>,
-    schema_to_read: StoreSchemaRef,
-    projected_user_schema: SchemaRef,
-}
-```
-
-We need to handle many cases while doing projection:
-- The columns' order of table and region is different
-- The projection can be in arbitrary order, e.g. `select usage_user, host from cpu` and `select host, usage_user from cpu` have different projection order
-- We support `ALTER TABLE` so data files may have different schemas.
-
-### Projection
-Let's take an example to see how projection works. Suppose we want to select `ts`, `usage_system` from the `cpu` table.
-
-```sql
-CREATE TABLE cpu (
-    ts TIMESTAMP,
-    host STRING,
-    usage_user DOUBLE,
-    usage_system DOUBLE,
-    datacenter STRING,
-    TIME INDEX (ts),
-    PRIMARY KEY(datacenter, host)) ENGINE=mito WITH(regions=1);
-
-select ts, usage_system from cpu;
-```
-
-The query engine uses the projection `[0, 3]` to scan the table. However, columns in the region have a different order, so the table engine adjusts the projection to `2, 4`.
-```json
-{
-    "user_schema":[
-        "datacenter",
-        "host",
-        "ts",
-        "usage_user",
-        "usage_system"
-    ],
-}
-```
-
-As you can see, the output order is still `[ts, usage_system]`. This is the schema users can see after projection so we call it `projected user schema`.
-
-But the storage engine also needs to read key columns, a timestamp column, and internal columns. So we maintain a `StoreSchema` after projection in the `ProjectedSchema`.
-
-The `Projection` struct is a helper struct to help compute the projected user schema and store schema.
-
-So we can construct the following `ProjectedSchema`:
-```json
-{
-    "schema_to_read":{
-        "schema":{
-            "column_schemas":[
-                "datacenter",
-                "host",
-                "ts",
-                "usage_system",
-                "__sequence",
-                "__op_type"
-            ],
-            "time_index":2,
-            "version":0
-        },
-        "row_key_end":3,
-        "user_column_end":4
-    },
-    "projected_user_schema":{
-        "column_schemas":[
-            "ts",
-            "usage_system"
-        ],
-        "time_index":0
-    }
-}
-```
-
-As you can see, `schema_to_read` doesn't contain the column `usage_user` that is not intended to be read (not in projection).
-
-### ReadAdapter
-As mentioned above, we can alter a table so the underlying files (SSTs) and memtables in the storage engine may have different schemas.
-
-To simplify the logic of `ProjectedSchema`, we handle the difference between schemas before projection (constructing the `ProjectedSchema`). We introduce [ReadAdapter](https://github.com/GreptimeTeam/greptimedb/blob/9fa871a3fad07f583dc1863a509414da393747f8/src/storage/src/schema/compat.rs#L90) that adapts rows with different source schemas to the same expected schema.
-
-So we can always use the current `RegionSchema` of the region to construct the `ProjectedSchema`, and then create a `ReadAdapter` for each memtable or SST.
-```rust
-#[derive(Debug)]
-pub struct ReadAdapter {
-    source_schema: StoreSchemaRef,
-    dest_schema: ProjectedSchemaRef,
-    indices_in_result: Vec<Option<usize>>,
-    is_source_needed: Vec<bool>,
-}
-```
-
-For each column required by `dest_schema`, `indices_in_result` stores the index of that column in the row read from the source memtable or SST. If the source row doesn't contain that column, the index is `None`.
-
-The field `is_source_needed` stores whether a column in the source memtable or SST is needed.
-
-Suppose we add a new column `usage_idle` to the table `cpu`.
-```sql
-ALTER TABLE cpu ADD COLUMN usage_idle DOUBLE;
-```
-
-The new `StoreSchema` becomes:
-```json
-{
-    "schema":{
-        "column_schemas":[
-            "datacenter",
-            "host",
-            "ts",
-            "usage_user",
-            "usage_system",
-            "usage_idle",
-            "__sequence",
-            "__op_type"
-        ],
-        "time_index":2,
-        "version":1
-    },
-    "row_key_end":3,
-    "user_column_end":6
-}
-```
-
-Note that we bump the version of the schema to 1.
-
-If we want to select `ts`, `usage_system`, and `usage_idle`. While reading from the old schema, the storage engine creates a `ReadAdapter` like this:
-```json
-{
-    "source_schema":{
-        "schema":{
-            "column_schemas":[
-                "datacenter",
-                "host",
-                "ts",
-                "usage_user",
-                "usage_system",
-                "__sequence",
-                "__op_type"
-            ],
-            "time_index":2,
-            "version":0
-        },
-        "row_key_end":3,
-        "user_column_end":5
-    },
-    "dest_schema":{
-        "schema_to_read":{
-            "schema":{
-                "column_schemas":[
-                    "datacenter",
-                    "host",
-                    "ts",
-                    "usage_system",
-                    "usage_idle",
-                    "__sequence",
-                    "__op_type"
-                ],
-                "time_index":2,
-                "version":1
-            },
-            "row_key_end":3,
-            "user_column_end":5
-        },
-        "projected_user_schema":{
-            "column_schemas":[
-                "ts",
-                "usage_system",
-                "usage_idle"
-            ],
-            "time_index":0
-        }
-    },
-    "indices_in_result":[
-        0,
-        1,
-        2,
-        3,
-        null,
-        4,
-        5
-    ],
-    "is_source_needed":[
-        true,
-        true,
-        true,
-        false,
-        true,
-        true,
-        true
-    ]
-}
-```
-
-We don't need to read `usage_user` so `is_source_needed[3]` is false. The old schema doesn't have column `usage_idle` so `indices_in_result[4]` is `null` and the `ReadAdapter` needs to insert a null column to the output row so the output schema still contains `usage_idle`.
-
-The figure below shows the relationship between `RegionSchema`, `StoreSchema`, `ProjectedSchema`, and `ReadAdapter`.
-
-```text
-                   ┌──────────────────────────────┐
-                   │                              │
-                   │    ┌────────────────────┐    │
-                   │    │    store_schema    │    │
-                   │    │                    │    │
-                   │    │     StoreSchema    │    │
-                   │    │      version 1     │    │
-                   │    └────────────────────┘    │
-                   │                              │
-                   │    ┌────────────────────┐    │
-                   │    │     user_schema    │    │
-                   │    └────────────────────┘    │
-                   │                              │
-                   │         RegionSchema         │
-                   │                              │
-                   └──────────────┬───────────────┘
-                                  │
-                                  │
-                                  │
-                   ┌──────────────▼───────────────┐
-                   │                              │
-                   │ ┌──────────────────────────┐ │
-                   │ │     schema_to_read       │ │
-                   │ │                          │ │
-                   │ │  StoreSchema (projected) │ │
-                   │ │       version 1          │ │
-                   │ └──────────────────────────┘ │
-               ┌───┤                              ├───┐
-               │   │ ┌──────────────────────────┐ │   │
-               │   │ │  projected_user_schema   │ │   │
-               │   │ └──────────────────────────┘ │   │
-               │   │                              │   │
-               │   │       ProjectedSchema        │   │
-  dest schema  │   └──────────────────────────────┘   │   dest schema
-               │                                      │
-               │                                      │
-        ┌──────▼───────┐                      ┌───────▼──────┐
-        │              │                      │              │
-        │  ReadAdapter │                      │  ReadAdapter │
-        │              │                      │              │
-        └──────▲───────┘                      └───────▲──────┘
-               │                                      │
-               │                                      │
-source schema  │                                      │  source schema
-               │                                      │
-       ┌───────┴─────────┐                   ┌────────┴────────┐
-       │                 │                   │                 │
-       │ ┌─────────────┐ │                   │ ┌─────────────┐ │
-       │ │             │ │                   │ │             │ │
-       │ │ StoreSchema │ │                   │ │ StoreSchema │ │
-       │ │             │ │                   │ │             │ │
-       │ │  version 0  │ │                   │ │  version 1  │ │
-       │ │             │ │                   │ │             │ │
-       │ └─────────────┘ │                   │ └─────────────┘ │
-       │                 │                   │                 │
-       │      SST 0      │                   │      SST 1      │
-       │                 │                   │                 │
-       └─────────────────┘                   └─────────────────┘
-```
-
-# Conversion
-This figure shows the conversion between schemas:
-```text
-              ┌─────────────┐     schema                      From             ┌─────────────┐
-              │             ├──────────────────┐  ┌────────────────────────────►             │
-              │  TableMeta  │                  │  │                            │  RawSchema  │
-              │             │                  │  │  ┌─────────────────────────┤             │
-              └─────────────┘                  │  │  │        TryFrom          └─────────────┘
-                                               │  │  │
-                                               │  │  │
-                                               │  │  │
-                                               │  │  │
-                                               │  │  │
-    ┌───────────────────┐                ┌─────▼──┴──▼──┐   arrow_schema()    ┌─────────────────┐
-    │                   │                │              ├─────────────────────►                 │
-    │  ColumnsMetadata  │          ┌─────►    Schema    │                     │   ArrowSchema   ├──┐
-    │                   │          │     │              ◄─────────────────────┤                 │  │
-    └────┬───────────▲──┘          │     └───▲───▲──────┘       TryFrom       └─────────────────┘  │
-         │           │             │         │   │                                                 │
-         │           │             │         │   └────────────────────────────────────────┐        │
-         │           │             │         │                                            │        │
-         │   columns │    user_schema()      │                                            │        │
-         │           │             │         │ projected_user_schema()                 schema()    │
-         │           │             │         │                                            │        │
-         │       ┌───┴─────────────┴─┐       │                 ┌────────────────────┐     │        │
-columns  │       │                   │       └─────────────────┤                    │     │        │  TryFrom
-         │       │    RegionSchema   │                         │   ProjectedSchema  │     │        │
-         │       │                   ├─────────────────────────►                    │     │        │
-         │       └─────────────────┬─┘  ProjectedSchema::new() └──────────────────┬─┘     │        │
-         │                         │                                              │       │        │
-         │                         │                                              │       │        │
-         │                         │                                              │       │        │
-         │                         │                                              │       │        │
-    ┌────▼────────────────────┐    │               store_schema()            ┌────▼───────┴──┐     │
-    │                         │    └─────────────────────────────────────────►               │     │
-    │   Vec<ColumnMetadata>   │                                              │  StoreSchema  ◄─────┘
-    │                         ◄──────────────────────────────────────────────┤               │
-    └─────────────────────────┘                     columns                  └───────────────┘
-```

rust-toolchain.toml

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

scripts/fetch-dashboard-assets.sh

@@ -2,17 +2,14 @@
 
 # This script is used to download built dashboard assets from the "GreptimeTeam/dashboard" repository.
 
-set -e -x
+set -e
 
 declare -r SCRIPT_DIR=$(cd $(dirname ${0}) >/dev/null 2>&1 && pwd)
 declare -r ROOT_DIR=$(dirname ${SCRIPT_DIR})
 declare -r STATIC_DIR="$ROOT_DIR/src/servers/dashboard"
-OUT_DIR="${1:-$SCRIPT_DIR}"
 
-RELEASE_VERSION="$(cat $STATIC_DIR/VERSION | tr -d '\t\r\n ')"
+RELEASE_VERSION="$(cat $STATIC_DIR/VERSION)"
 
-echo "Downloading assets to dir: $OUT_DIR"
-cd $OUT_DIR
 # 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.

scripts/install.sh

@@ -51,26 +51,13 @@ get_os_type
 get_arch_type
 
 if [ -n "${OS_TYPE}" ] && [ -n "${ARCH_TYPE}" ]; then
-    # Use the latest nightly version.
-    if [ "${VERSION}" = "latest" ]; then
-        VERSION=$(curl -s -XGET "https://api.github.com/repos/${GITHUB_ORG}/${GITHUB_REPO}/releases" | grep tag_name | grep nightly | cut -d: -f 2 | sed 's/.*"\(.*\)".*/\1/' | uniq | sort -r | head -n 1)
-        if [ -z "${VERSION}" ]; then
-            echo "Failed to get the latest version."
-            exit 1
-        fi
-    fi
-
     echo "Downloading ${BIN}, OS: ${OS_TYPE}, Arch: ${ARCH_TYPE}, Version: ${VERSION}"
-    PACKAGE_NAME="${BIN}-${OS_TYPE}-${ARCH_TYPE}-${VERSION}.tar.gz"
 
-    if [ -n "${PACKAGE_NAME}" ]; then
-      wget "https://github.com/${GITHUB_ORG}/${GITHUB_REPO}/releases/download/${VERSION}/${PACKAGE_NAME}"
-
-      # Extract the binary and clean the rest.
-      tar xvf "${PACKAGE_NAME}" && \
-      mv "${PACKAGE_NAME%.tar.gz}/${BIN}" "${PWD}" && \
-      rm -r "${PACKAGE_NAME}" && \
-      rm -r "${PACKAGE_NAME%.tar.gz}" && \
-      echo "Run './${BIN} --help' to get started"
+    if [ "${VERSION}" = "latest" ]; then
+        wget "https://github.com/${GITHUB_ORG}/${GITHUB_REPO}/releases/latest/download/${BIN}-${OS_TYPE}-${ARCH_TYPE}.tgz"
+    else
+        wget "https://github.com/${GITHUB_ORG}/${GITHUB_REPO}/releases/download/${VERSION}/${BIN}-${OS_TYPE}-${ARCH_TYPE}.tgz"
     fi
+
+    tar xvf ${BIN}-${OS_TYPE}-${ARCH_TYPE}.tgz && rm ${BIN}-${OS_TYPE}-${ARCH_TYPE}.tgz && echo "Run './${BIN} --help' to get started"
 fi

src/api/Cargo.toml

@@ -5,17 +5,15 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-common-base = { workspace = true }
-common-error = { workspace = true }
-common-time = { workspace = true }
-datatypes = { workspace = true }
-greptime-proto.workspace = true
+arrow-flight.workspace = true
+common-base = { path = "../common/base" }
+common-error = { path = "../common/error" }
+common-time = { path = "../common/time" }
+datatypes = { path = "../datatypes" }
+greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "0bebe5f69c91cdfbce85cb8f45f9fcd28185261c" }
 prost.workspace = true
 snafu = { version = "0.7", features = ["backtraces"] }
 tonic.workspace = true
 
 [build-dependencies]
 tonic-build = "0.9"
-
-[dev-dependencies]
-paste = "1.0"

src/api/src/error.rs

@@ -15,7 +15,7 @@
 use std::any::Any;
 
 use common_error::ext::ErrorExt;
-use common_error::status_code::StatusCode;
+use common_error::prelude::StatusCode;
 use datatypes::prelude::ConcreteDataType;
 use snafu::prelude::*;
 use snafu::Location;
@@ -41,7 +41,7 @@ pub enum Error {
     ))]
     ConvertColumnDefaultConstraint {
         column: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: datatypes::error::Error,
     },
 
@@ -52,7 +52,7 @@ pub enum Error {
     ))]
     InvalidColumnDefaultConstraint {
         column: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: datatypes::error::Error,
     },
 }

src/api/src/lib.rs

@@ -15,7 +15,7 @@
 pub mod error;
 pub mod helper;
 
-pub mod prom_store {
+pub mod prometheus {
     pub mod remote {
         pub use greptime_proto::prometheus::remote::*;
     }
@@ -23,5 +23,4 @@ pub mod prom_store {
 
 pub mod v1;
 
-pub use greptime_proto;
 pub use prost::DecodeError;

src/auth/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "auth"
-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 = []
-
-[dependencies]
-api.workspace = true
-async-trait.workspace = true
-common-error.workspace = true
-digest = "0.10"
-hex = { version = "0.4" }
-secrecy = { version = "0.8", features = ["serde", "alloc"] }
-sha1 = "0.10"
-snafu.workspace = true
-sql.workspace = true
-tokio.workspace = true
-
-[dev-dependencies]
-common-test-util.workspace = true

src/auth/src/common.rs

@@ -1,147 +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 digest::Digest;
-use secrecy::SecretString;
-use sha1::Sha1;
-use snafu::{ensure, OptionExt};
-
-use crate::error::{IllegalParamSnafu, InvalidConfigSnafu, Result, UserPasswordMismatchSnafu};
-use crate::user_info::DefaultUserInfo;
-use crate::user_provider::static_user_provider::{StaticUserProvider, STATIC_USER_PROVIDER};
-use crate::{UserInfoRef, UserProviderRef};
-
-pub(crate) const DEFAULT_USERNAME: &str = "greptime";
-
-/// 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()))
-}
-
-pub fn user_provider_from_option(opt: &String) -> Result<UserProviderRef> {
-    let (name, content) = opt.split_once(':').context(InvalidConfigSnafu {
-        value: opt.to_string(),
-        msg: "UserProviderOption must be in format `<option>:<value>`",
-    })?;
-    match name {
-        STATIC_USER_PROVIDER => {
-            let provider =
-                StaticUserProvider::try_from(content).map(|p| Arc::new(p) as UserProviderRef)?;
-            Ok(provider)
-        }
-        _ => InvalidConfigSnafu {
-            value: name.to_string(),
-            msg: "Invalid UserProviderOption",
-        }
-        .fail(),
-    }
-}
-
-type Username<'a> = &'a str;
-type HostOrIp<'a> = &'a str;
-
-#[derive(Debug, Clone)]
-pub enum Identity<'a> {
-    UserId(Username<'a>, Option<HostOrIp<'a>>),
-}
-
-pub type HashedPassword<'a> = &'a [u8];
-pub type Salt<'a> = &'a [u8];
-
-/// Authentication information sent by the client.
-pub enum Password<'a> {
-    PlainText(SecretString),
-    MysqlNativePassword(HashedPassword<'a>, Salt<'a>),
-    PgMD5(HashedPassword<'a>, Salt<'a>),
-}
-
-pub fn auth_mysql(
-    auth_data: HashedPassword,
-    salt: Salt,
-    username: &str,
-    save_pwd: &[u8],
-) -> Result<()> {
-    ensure!(
-        auth_data.len() == 20,
-        IllegalParamSnafu {
-            msg: "Illegal mysql password length"
-        }
-    );
-    // ref: https://github.com/mysql/mysql-server/blob/a246bad76b9271cb4333634e954040a970222e0a/sql/auth/password.cc#L62
-    let hash_stage_2 = double_sha1(save_pwd);
-    let tmp = sha1_two(salt, &hash_stage_2);
-    // xor auth_data and tmp
-    let mut xor_result = [0u8; 20];
-    for i in 0..20 {
-        xor_result[i] = auth_data[i] ^ tmp[i];
-    }
-    let candidate_stage_2 = sha1_one(&xor_result);
-    if candidate_stage_2 == hash_stage_2 {
-        Ok(())
-    } else {
-        UserPasswordMismatchSnafu {
-            username: username.to_string(),
-        }
-        .fail()
-    }
-}
-
-fn sha1_two(input_1: &[u8], input_2: &[u8]) -> Vec<u8> {
-    let mut hasher = Sha1::new();
-    hasher.update(input_1);
-    hasher.update(input_2);
-    hasher.finalize().to_vec()
-}
-
-fn sha1_one(data: &[u8]) -> Vec<u8> {
-    let mut hasher = Sha1::new();
-    hasher.update(data);
-    hasher.finalize().to_vec()
-}
-
-fn double_sha1(data: &[u8]) -> Vec<u8> {
-    sha1_one(&sha1_one(data))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_sha() {
-        let sha_1_answer: Vec<u8> = vec![
-            124, 74, 141, 9, 202, 55, 98, 175, 97, 229, 149, 32, 148, 61, 194, 100, 148, 248, 148,
-            27,
-        ];
-        let sha_1 = sha1_one("123456".as_bytes());
-        assert_eq!(sha_1, sha_1_answer);
-
-        let double_sha1_answer: Vec<u8> = vec![
-            107, 180, 131, 126, 183, 67, 41, 16, 94, 228, 86, 141, 218, 125, 198, 126, 210, 202,
-            42, 217,
-        ];
-        let double_sha1 = double_sha1("123456".as_bytes());
-        assert_eq!(double_sha1, double_sha1_answer);
-
-        let sha1_2_answer: Vec<u8> = vec![
-            132, 115, 215, 211, 99, 186, 164, 206, 168, 152, 217, 192, 117, 47, 240, 252, 142, 244,
-            37, 204,
-        ];
-        let sha1_2 = sha1_two("123456".as_bytes(), "654321".as_bytes());
-        assert_eq!(sha1_2, sha1_2_answer);
-    }
-}

src/auth/src/lib.rs

@@ -1,34 +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 common;
-pub mod error;
-mod permission;
-mod user_info;
-mod user_provider;
-
-#[cfg(feature = "testing")]
-pub mod tests;
-
-pub use common::{
-    auth_mysql, user_provider_from_option, userinfo_by_name, HashedPassword, Identity, Password,
-};
-pub use permission::{PermissionChecker, PermissionReq, PermissionResp};
-pub use user_info::UserInfo;
-pub use user_provider::UserProvider;
-
-/// pub type alias
-pub type UserInfoRef = std::sync::Arc<dyn UserInfo>;
-pub type UserProviderRef = std::sync::Arc<dyn UserProvider>;
-pub type PermissionCheckerRef = std::sync::Arc<dyn PermissionChecker>;

src/auth/src/permission.rs

@@ -1,64 +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::fmt::Debug;
-
-use api::v1::greptime_request::Request;
-use sql::statements::statement::Statement;
-
-use crate::error::{PermissionDeniedSnafu, Result};
-use crate::{PermissionCheckerRef, UserInfoRef};
-
-#[derive(Debug, Clone)]
-pub enum PermissionReq<'a> {
-    GrpcRequest(&'a Request),
-    SqlStatement(&'a Statement),
-    PromQuery,
-    Opentsdb,
-    LineProtocol,
-    PromStoreWrite,
-    PromStoreRead,
-    Otlp,
-}
-
-#[derive(Debug)]
-pub enum PermissionResp {
-    Allow,
-    Reject,
-}
-
-pub trait PermissionChecker: Send + Sync {
-    fn check_permission(
-        &self,
-        user_info: Option<UserInfoRef>,
-        req: PermissionReq,
-    ) -> Result<PermissionResp>;
-}
-
-impl PermissionChecker for Option<&PermissionCheckerRef> {
-    fn check_permission(
-        &self,
-        user_info: Option<UserInfoRef>,
-        req: PermissionReq,
-    ) -> Result<PermissionResp> {
-        match self {
-            Some(checker) => match checker.check_permission(user_info, req) {
-                Ok(PermissionResp::Reject) => PermissionDeniedSnafu.fail(),
-                Ok(PermissionResp::Allow) => Ok(PermissionResp::Allow),
-                Err(e) => Err(e),
-            },
-            None => Ok(PermissionResp::Allow),
-        }
-    }
-}

src/auth/src/user_info.rs

@@ -1,47 +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::Arc;
-
-use crate::UserInfoRef;
-
-pub trait UserInfo: Debug + Sync + Send {
-    fn as_any(&self) -> &dyn Any;
-    fn username(&self) -> &str;
-}
-
-#[derive(Debug)]
-pub(crate) struct DefaultUserInfo {
-    username: String,
-}
-
-impl DefaultUserInfo {
-    pub(crate) fn with_name(username: impl Into<String>) -> UserInfoRef {
-        Arc::new(Self {
-            username: username.into(),
-        })
-    }
-}
-
-impl UserInfo for DefaultUserInfo {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn username(&self) -> &str {
-        self.username.as_str()
-    }
-}

src/auth/src/user_provider.rs

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

src/auth/tests/mod.rs

@@ -1,61 +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.
-
-#![feature(assert_matches)]
-use std::assert_matches::assert_matches;
-use std::sync::Arc;
-
-use api::v1::greptime_request::Request;
-use auth::error::Error::InternalState;
-use auth::{PermissionChecker, PermissionCheckerRef, PermissionReq, PermissionResp, UserInfoRef};
-use sql::statements::show::{ShowDatabases, ShowKind};
-use sql::statements::statement::Statement;
-
-struct DummyPermissionChecker;
-
-impl PermissionChecker for DummyPermissionChecker {
-    fn check_permission(
-        &self,
-        _user_info: Option<UserInfoRef>,
-        req: PermissionReq,
-    ) -> auth::error::Result<PermissionResp> {
-        match req {
-            PermissionReq::GrpcRequest(_) => Ok(PermissionResp::Allow),
-            PermissionReq::SqlStatement(_) => Ok(PermissionResp::Reject),
-            _ => Err(InternalState {
-                msg: "testing".to_string(),
-            }),
-        }
-    }
-}
-
-#[test]
-fn test_permission_checker() {
-    let checker: PermissionCheckerRef = Arc::new(DummyPermissionChecker);
-
-    let grpc_result = checker.check_permission(
-        None,
-        PermissionReq::GrpcRequest(&Request::Query(Default::default())),
-    );
-    assert_matches!(grpc_result, Ok(PermissionResp::Allow));
-
-    let sql_result = checker.check_permission(
-        None,
-        PermissionReq::SqlStatement(&Statement::ShowDatabases(ShowDatabases::new(ShowKind::All))),
-    );
-    assert_matches!(sql_result, Ok(PermissionResp::Reject));
-
-    let err_result = checker.check_permission(None, PermissionReq::Opentsdb);
-    assert_matches!(err_result, Err(InternalState { msg }) if msg == "testing");
-}

src/catalog/Cargo.toml

@@ -4,49 +4,43 @@ version.workspace = true
 edition.workspace = true
 license.workspace = true
 
-[features]
-testing = []
-
 [dependencies]
-api = { workspace = true }
+api = { path = "../api" }
 arc-swap = "1.0"
 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-meta = { workspace = true }
-common-query = { workspace = true }
-common-recordbatch = { workspace = true }
-common-runtime = { workspace = true }
-common-telemetry = { workspace = true }
-common-time = { workspace = true }
+backoff = { version = "0.4", features = ["tokio"] }
+common-catalog = { path = "../common/catalog" }
+common-error = { path = "../common/error" }
+common-grpc = { path = "../common/grpc" }
+common-query = { path = "../common/query" }
+common-recordbatch = { path = "../common/recordbatch" }
+common-runtime = { path = "../common/runtime" }
+common-telemetry = { path = "../common/telemetry" }
+common-time = { path = "../common/time" }
 dashmap = "5.4"
 datafusion.workspace = true
-datatypes = { workspace = true }
+datatypes = { path = "../datatypes" }
 futures = "0.3"
 futures-util.workspace = true
-lazy_static.workspace = true
-meta-client = { workspace = true }
-metrics.workspace = true
-moka = { version = "0.11", features = ["future"] }
+lazy_static = "1.4"
+meta-client = { path = "../meta-client" }
 parking_lot = "0.12"
-regex.workspace = true
-serde.workspace = true
+regex = "1.6"
+serde = "1.0"
 serde_json = "1.0"
-session = { workspace = true }
+session = { path = "../session" }
 snafu = { version = "0.7", features = ["backtraces"] }
-store-api = { workspace = true }
-table = { workspace = true }
+storage = { path = "../storage" }
+table = { path = "../table" }
 tokio.workspace = true
 
 [dev-dependencies]
-catalog = { workspace = true, features = ["testing"] }
+common-test-util = { path = "../common/test-util" }
 chrono.workspace = true
-common-test-util = { workspace = true }
-log-store = { workspace = true }
-mito = { workspace = true, features = ["test"] }
-object-store = { workspace = true }
-storage = { workspace = true }
+log-store = { path = "../log-store" }
+mito = { path = "../mito", features = ["test"] }
+object-store = { path = "../object-store" }
+storage = { path = "../storage" }
 tokio.workspace = true

src/catalog/src/datafusion.rs

@@ -12,4 +12,4 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-pub mod scheduler;
+pub mod catalog_adapter;

src/catalog/src/datafusion/catalog_adapter.rs

@@ -0,0 +1,318 @@
+// 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.
+
+//! Catalog adapter between datafusion and greptime query engine.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use common_error::prelude::BoxedError;
+use datafusion::catalog::catalog::{
+    CatalogList as DfCatalogList, CatalogProvider as DfCatalogProvider,
+};
+use datafusion::catalog::schema::SchemaProvider as DfSchemaProvider;
+use datafusion::datasource::TableProvider as DfTableProvider;
+use datafusion::error::Result as DataFusionResult;
+use snafu::ResultExt;
+use table::table::adapter::{DfTableProviderAdapter, TableAdapter};
+use table::TableRef;
+
+use crate::error::{self, Result, SchemaProviderOperationSnafu};
+use crate::{
+    CatalogListRef, CatalogProvider, CatalogProviderRef, SchemaProvider, SchemaProviderRef,
+};
+
+pub struct DfCatalogListAdapter {
+    catalog_list: CatalogListRef,
+}
+
+impl DfCatalogListAdapter {
+    pub fn new(catalog_list: CatalogListRef) -> DfCatalogListAdapter {
+        DfCatalogListAdapter { catalog_list }
+    }
+}
+
+impl DfCatalogList for DfCatalogListAdapter {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn register_catalog(
+        &self,
+        name: String,
+        catalog: Arc<dyn DfCatalogProvider>,
+    ) -> Option<Arc<dyn DfCatalogProvider>> {
+        let catalog_adapter = Arc::new(CatalogProviderAdapter {
+            df_catalog_provider: catalog,
+        });
+        self.catalog_list
+            .register_catalog(name, catalog_adapter)
+            .expect("datafusion does not accept fallible catalog access") // TODO(hl): datafusion register catalog does not handles errors
+            .map(|catalog_provider| Arc::new(DfCatalogProviderAdapter { catalog_provider }) as _)
+    }
+
+    fn catalog_names(&self) -> Vec<String> {
+        // TODO(hl): datafusion register catalog does not handles errors
+        self.catalog_list
+            .catalog_names()
+            .expect("datafusion does not accept fallible catalog access")
+    }
+
+    fn catalog(&self, name: &str) -> Option<Arc<dyn DfCatalogProvider>> {
+        self.catalog_list
+            .catalog(name)
+            .expect("datafusion does not accept fallible catalog access") // TODO(hl): datafusion register catalog does not handles errors
+            .map(|catalog_provider| Arc::new(DfCatalogProviderAdapter { catalog_provider }) as _)
+    }
+}
+
+/// Datafusion's CatalogProvider ->  greptime CatalogProvider
+struct CatalogProviderAdapter {
+    df_catalog_provider: Arc<dyn DfCatalogProvider>,
+}
+
+impl CatalogProvider for CatalogProviderAdapter {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema_names(&self) -> Result<Vec<String>> {
+        Ok(self.df_catalog_provider.schema_names())
+    }
+
+    fn register_schema(
+        &self,
+        _name: String,
+        _schema: SchemaProviderRef,
+    ) -> Result<Option<SchemaProviderRef>> {
+        todo!("register_schema is not supported in Datafusion catalog provider")
+    }
+
+    fn schema(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>> {
+        Ok(self
+            .df_catalog_provider
+            .schema(name)
+            .map(|df_schema_provider| Arc::new(SchemaProviderAdapter { df_schema_provider }) as _))
+    }
+}
+
+///Greptime CatalogProvider -> datafusion's CatalogProvider
+struct DfCatalogProviderAdapter {
+    catalog_provider: CatalogProviderRef,
+}
+
+impl DfCatalogProvider for DfCatalogProviderAdapter {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema_names(&self) -> Vec<String> {
+        self.catalog_provider
+            .schema_names()
+            .expect("datafusion does not accept fallible catalog access")
+    }
+
+    fn schema(&self, name: &str) -> Option<Arc<dyn DfSchemaProvider>> {
+        self.catalog_provider
+            .schema(name)
+            .expect("datafusion does not accept fallible catalog access")
+            .map(|schema_provider| Arc::new(DfSchemaProviderAdapter { schema_provider }) as _)
+    }
+}
+
+/// Greptime SchemaProvider -> datafusion SchemaProvider
+struct DfSchemaProviderAdapter {
+    schema_provider: Arc<dyn SchemaProvider>,
+}
+
+#[async_trait]
+impl DfSchemaProvider for DfSchemaProviderAdapter {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn table_names(&self) -> Vec<String> {
+        self.schema_provider
+            .table_names()
+            .expect("datafusion does not accept fallible catalog access")
+    }
+
+    async fn table(&self, name: &str) -> Option<Arc<dyn DfTableProvider>> {
+        self.schema_provider
+            .table(name)
+            .await
+            .expect("datafusion does not accept fallible catalog access")
+            .map(|table| Arc::new(DfTableProviderAdapter::new(table)) as _)
+    }
+
+    fn register_table(
+        &self,
+        name: String,
+        table: Arc<dyn DfTableProvider>,
+    ) -> DataFusionResult<Option<Arc<dyn DfTableProvider>>> {
+        let table = Arc::new(TableAdapter::new(table)?);
+        match self.schema_provider.register_table(name, table)? {
+            Some(p) => Ok(Some(Arc::new(DfTableProviderAdapter::new(p)))),
+            None => Ok(None),
+        }
+    }
+
+    fn deregister_table(&self, name: &str) -> DataFusionResult<Option<Arc<dyn DfTableProvider>>> {
+        match self.schema_provider.deregister_table(name)? {
+            Some(p) => Ok(Some(Arc::new(DfTableProviderAdapter::new(p)))),
+            None => Ok(None),
+        }
+    }
+
+    fn table_exist(&self, name: &str) -> bool {
+        self.schema_provider
+            .table_exist(name)
+            .expect("datafusion does not accept fallible catalog access")
+    }
+}
+
+/// Datafusion SchemaProviderAdapter -> greptime SchemaProviderAdapter
+struct SchemaProviderAdapter {
+    df_schema_provider: Arc<dyn DfSchemaProvider>,
+}
+
+#[async_trait]
+impl SchemaProvider for SchemaProviderAdapter {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// Retrieves the list of available table names in this schema.
+    fn table_names(&self) -> Result<Vec<String>> {
+        Ok(self.df_schema_provider.table_names())
+    }
+
+    async fn table(&self, name: &str) -> Result<Option<TableRef>> {
+        let table = self.df_schema_provider.table(name).await;
+        let table = table.map(|table_provider| {
+            match table_provider
+                .as_any()
+                .downcast_ref::<DfTableProviderAdapter>()
+            {
+                Some(adapter) => adapter.table(),
+                None => {
+                    // TODO(yingwen): Avoid panic here.
+                    let adapter =
+                        TableAdapter::new(table_provider).expect("convert datafusion table");
+                    Arc::new(adapter) as _
+                }
+            }
+        });
+        Ok(table)
+    }
+
+    fn register_table(&self, name: String, table: TableRef) -> Result<Option<TableRef>> {
+        let table_provider = Arc::new(DfTableProviderAdapter::new(table.clone()));
+        Ok(self
+            .df_schema_provider
+            .register_table(name, table_provider)
+            .context(error::DatafusionSnafu {
+                msg: "Fail to register table to datafusion",
+            })
+            .map_err(BoxedError::new)
+            .context(SchemaProviderOperationSnafu)?
+            .map(|_| table))
+    }
+
+    fn rename_table(&self, _name: &str, _new_name: String) -> Result<TableRef> {
+        todo!()
+    }
+
+    fn deregister_table(&self, name: &str) -> Result<Option<TableRef>> {
+        self.df_schema_provider
+            .deregister_table(name)
+            .context(error::DatafusionSnafu {
+                msg: "Fail to deregister table from datafusion",
+            })
+            .map_err(BoxedError::new)
+            .context(SchemaProviderOperationSnafu)?
+            .map(|table| {
+                let adapter = TableAdapter::new(table)
+                    .context(error::TableSchemaMismatchSnafu)
+                    .map_err(BoxedError::new)
+                    .context(SchemaProviderOperationSnafu)?;
+                Ok(Arc::new(adapter) as _)
+            })
+            .transpose()
+    }
+
+    fn table_exist(&self, name: &str) -> Result<bool> {
+        Ok(self.df_schema_provider.table_exist(name))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use table::table::numbers::NumbersTable;
+
+    use super::*;
+    use crate::local::{new_memory_catalog_list, MemoryCatalogProvider, MemorySchemaProvider};
+
+    #[test]
+    #[should_panic]
+    pub fn test_register_schema() {
+        let adapter = CatalogProviderAdapter {
+            df_catalog_provider: Arc::new(
+                datafusion::catalog::catalog::MemoryCatalogProvider::new(),
+            ),
+        };
+
+        adapter
+            .register_schema(
+                "whatever".to_string(),
+                Arc::new(MemorySchemaProvider::new()),
+            )
+            .unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_register_table() {
+        let adapter = DfSchemaProviderAdapter {
+            schema_provider: Arc::new(MemorySchemaProvider::new()),
+        };
+
+        adapter
+            .register_table(
+                "test_table".to_string(),
+                Arc::new(DfTableProviderAdapter::new(Arc::new(
+                    NumbersTable::default(),
+                ))),
+            )
+            .unwrap();
+        adapter.table("test_table").await.unwrap();
+    }
+
+    #[test]
+    pub fn test_register_catalog() {
+        let catalog_list = DfCatalogListAdapter {
+            catalog_list: new_memory_catalog_list().unwrap(),
+        };
+        assert!(catalog_list
+            .register_catalog(
+                "test_catalog".to_string(),
+                Arc::new(DfCatalogProviderAdapter {
+                    catalog_provider: Arc::new(MemoryCatalogProvider::new()),
+                }),
+            )
+            .is_none());
+
+        catalog_list.catalog("test_catalog").unwrap();
+    }
+}

src/catalog/src/error.rs

@@ -16,47 +16,25 @@ use std::any::Any;
 use std::fmt::Debug;
 
 use common_error::ext::{BoxedError, ErrorExt};
-use common_error::status_code::StatusCode;
+use common_error::prelude::{Snafu, StatusCode};
 use datafusion::error::DataFusionError;
 use datatypes::prelude::ConcreteDataType;
-use snafu::{Location, Snafu};
-use tokio::task::JoinError;
+use snafu::Location;
 
 use crate::DeregisterTableRequest;
 
 #[derive(Debug, Snafu)]
 #[snafu(visibility(pub))]
 pub enum Error {
-    #[snafu(display("Failed to list catalogs, source: {}", source))]
-    ListCatalogs {
-        location: Location,
-        source: BoxedError,
-    },
-
-    #[snafu(display("Failed to list {}'s schemas, source: {}", catalog, source))]
-    ListSchemas {
-        location: Location,
-        catalog: String,
-        source: BoxedError,
-    },
-
-    #[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, source: {}", source))]
     OpenSystemCatalog {
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
     #[snafu(display("Failed to create system catalog table, source: {}", source))]
     CreateSystemCatalog {
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
@@ -67,7 +45,7 @@ pub enum Error {
     ))]
     CreateTable {
         table_info: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
@@ -107,7 +85,7 @@ pub enum Error {
     #[snafu(display("Table engine not found: {}, source: {}", engine_name, source))]
     TableEngineNotFound {
         engine_name: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
@@ -127,7 +105,7 @@ pub enum Error {
     #[snafu(display("Table `{}` already exists", table))]
     TableExists { table: String, location: Location },
 
-    #[snafu(display("Table not found: {}", table))]
+    #[snafu(display("Table `{}` not exist", table))]
     TableNotExist { table: String, location: Location },
 
     #[snafu(display("Schema {} already exists", schema))]
@@ -145,13 +123,10 @@ pub enum Error {
     #[snafu(display("Failed to open table, table info: {}, source: {}", table_info, source))]
     OpenTable {
         table_info: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
-    #[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 {
         table_info: String,
@@ -160,13 +135,13 @@ pub enum Error {
 
     #[snafu(display("Failed to read system catalog table records"))]
     ReadSystemCatalog {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_recordbatch::error::Error,
     },
 
     #[snafu(display("Failed to create recordbatch, source: {}", source))]
     CreateRecordBatch {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_recordbatch::error::Error,
     },
 
@@ -175,7 +150,7 @@ pub enum Error {
         source
     ))]
     InsertCatalogRecord {
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
@@ -186,7 +161,7 @@ pub enum Error {
     ))]
     DeregisterTable {
         request: DeregisterTableRequest,
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
@@ -195,49 +170,69 @@ pub enum Error {
 
     #[snafu(display("Failed to scan system catalog table, source: {}", source))]
     SystemCatalogTableScan {
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
+    #[snafu(display("Failure during SchemaProvider operation, source: {}", source))]
+    SchemaProviderOperation {
+        #[snafu(backtrace)]
+        source: BoxedError,
+    },
+
     #[snafu(display("{source}"))]
     Internal {
-        location: Location,
+        #[snafu(backtrace)]
         source: BoxedError,
     },
 
-    #[snafu(display(
-        "Failed to upgrade weak catalog manager reference. location: {}",
-        location
-    ))]
-    UpgradeWeakCatalogManagerRef { location: Location },
-
     #[snafu(display("Failed to execute system catalog table scan, source: {}", source))]
     SystemCatalogTableScanExec {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_query::error::Error,
     },
-
     #[snafu(display("Cannot parse catalog value, source: {}", source))]
     InvalidCatalogValue {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_catalog::error::Error,
     },
 
     #[snafu(display("Failed to perform metasrv operation, source: {}", source))]
     MetaSrv {
-        location: Location,
+        #[snafu(backtrace)]
         source: meta_client::error::Error,
     },
 
     #[snafu(display("Invalid table info in catalog, source: {}", source))]
     InvalidTableInfoInCatalog {
-        location: Location,
+        #[snafu(backtrace)]
         source: datatypes::error::Error,
     },
 
+    #[snafu(display("Failed to serialize or deserialize catalog entry: {}", source))]
+    CatalogEntrySerde {
+        #[snafu(backtrace)]
+        source: common_catalog::error::Error,
+    },
+
     #[snafu(display("Illegal access to catalog: {} and schema: {}", catalog, schema))]
     QueryAccessDenied { catalog: String, schema: String },
 
+    #[snafu(display(
+        "Failed to get region stats, catalog: {}, schema: {}, table: {}, source: {}",
+        catalog,
+        schema,
+        table,
+        source
+    ))]
+    RegionStats {
+        catalog: String,
+        schema: String,
+        table: String,
+        #[snafu(backtrace)]
+        source: table::error::Error,
+    },
+
     #[snafu(display("Invalid system table definition: {err_msg}"))]
     InvalidSystemTableDef { err_msg: String, location: Location },
 
@@ -250,18 +245,9 @@ pub enum Error {
 
     #[snafu(display("Table schema mismatch, source: {}", source))]
     TableSchemaMismatch {
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
-
-    #[snafu(display("A generic error has occurred, msg: {}", msg))]
-    Generic { msg: String, location: Location },
-
-    #[snafu(display("Table metadata manager error: {}", source))]
-    TableMetadataManager {
-        source: common_meta::error::Error,
-        location: Location,
-    },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -275,21 +261,20 @@ impl ErrorExt for Error {
             | Error::IllegalManagerState { .. }
             | Error::CatalogNotFound { .. }
             | Error::InvalidEntryType { .. }
-            | Error::InvalidSystemTableDef { .. }
-            | Error::ParallelOpenTable { .. } => StatusCode::Unexpected,
+            | Error::InvalidSystemTableDef { .. } => StatusCode::Unexpected,
 
             Error::SystemCatalog { .. }
             | Error::EmptyValue { .. }
             | Error::ValueDeserialize { .. } => StatusCode::StorageUnavailable,
 
-            Error::Generic { .. }
-            | Error::SystemCatalogTypeMismatch { .. }
-            | Error::UpgradeWeakCatalogManagerRef { .. } => StatusCode::Internal,
+            Error::SystemCatalogTypeMismatch { .. } => StatusCode::Internal,
 
-            Error::ReadSystemCatalog { source, .. } | Error::CreateRecordBatch { source, .. } => {
+            Error::ReadSystemCatalog { source, .. } | Error::CreateRecordBatch { source } => {
+                source.status_code()
+            }
+            Error::InvalidCatalogValue { source, .. } | Error::CatalogEntrySerde { source } => {
                 source.status_code()
             }
-            Error::InvalidCatalogValue { source, .. } => source.status_code(),
 
             Error::TableExists { .. } => StatusCode::TableAlreadyExists,
             Error::TableNotExist { .. } => StatusCode::TableNotFound,
@@ -297,31 +282,26 @@ impl ErrorExt for Error {
                 StatusCode::InvalidArguments
             }
 
-            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::RegionStats { source, .. }
+            | Error::TableSchemaMismatch { source } => source.status_code(),
 
             Error::MetaSrv { source, .. } => source.status_code(),
-            Error::SystemCatalogTableScan { source, .. } => source.status_code(),
-            Error::SystemCatalogTableScanExec { source, .. } => source.status_code(),
-            Error::InvalidTableInfoInCatalog { source, .. } => source.status_code(),
-
-            Error::CompileScriptInternal { source, .. } | Error::Internal { source, .. } => {
+            Error::SystemCatalogTableScan { source } => source.status_code(),
+            Error::SystemCatalogTableScanExec { source } => source.status_code(),
+            Error::InvalidTableInfoInCatalog { source } => source.status_code(),
+            Error::SchemaProviderOperation { source } | Error::Internal { source } => {
                 source.status_code()
             }
 
             Error::Unimplemented { .. } | Error::NotSupported { .. } => StatusCode::Unsupported,
             Error::QueryAccessDenied { .. } => StatusCode::AccessDenied,
             Error::Datafusion { .. } => StatusCode::EngineExecuteQuery,
-            Error::TableMetadataManager { source, .. } => source.status_code(),
         }
     }
 

src/catalog/src/helper.rs

@@ -0,0 +1,379 @@
+// 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::collections::HashMap;
+use std::fmt::{Display, Formatter};
+
+use common_catalog::error::{
+    DeserializeCatalogEntryValueSnafu, Error, InvalidCatalogSnafu, SerializeCatalogEntryValueSnafu,
+};
+use lazy_static::lazy_static;
+use regex::Regex;
+use serde::{Deserialize, Serialize, Serializer};
+use snafu::{ensure, OptionExt, ResultExt};
+use table::metadata::{RawTableInfo, TableId, TableVersion};
+
+pub const CATALOG_KEY_PREFIX: &str = "__c";
+pub const SCHEMA_KEY_PREFIX: &str = "__s";
+pub const TABLE_GLOBAL_KEY_PREFIX: &str = "__tg";
+pub const TABLE_REGIONAL_KEY_PREFIX: &str = "__tr";
+
+const ALPHANUMERICS_NAME_PATTERN: &str = "[a-zA-Z_][a-zA-Z0-9_]*";
+
+lazy_static! {
+    static ref CATALOG_KEY_PATTERN: Regex = Regex::new(&format!(
+        "^{CATALOG_KEY_PREFIX}-({ALPHANUMERICS_NAME_PATTERN})$"
+    ))
+    .unwrap();
+}
+
+lazy_static! {
+    static ref SCHEMA_KEY_PATTERN: Regex = Regex::new(&format!(
+        "^{SCHEMA_KEY_PREFIX}-({ALPHANUMERICS_NAME_PATTERN})-({ALPHANUMERICS_NAME_PATTERN})$"
+    ))
+    .unwrap();
+}
+
+lazy_static! {
+    static ref TABLE_GLOBAL_KEY_PATTERN: Regex = Regex::new(&format!(
+        "^{TABLE_GLOBAL_KEY_PREFIX}-({ALPHANUMERICS_NAME_PATTERN})-({ALPHANUMERICS_NAME_PATTERN})-({ALPHANUMERICS_NAME_PATTERN})$"
+    ))
+    .unwrap();
+}
+
+lazy_static! {
+    static ref TABLE_REGIONAL_KEY_PATTERN: Regex = Regex::new(&format!(
+        "^{TABLE_REGIONAL_KEY_PREFIX}-({ALPHANUMERICS_NAME_PATTERN})-({ALPHANUMERICS_NAME_PATTERN})-({ALPHANUMERICS_NAME_PATTERN})-([0-9]+)$"
+    ))
+    .unwrap();
+}
+
+pub fn build_catalog_prefix() -> String {
+    format!("{CATALOG_KEY_PREFIX}-")
+}
+
+pub fn build_schema_prefix(catalog_name: impl AsRef<str>) -> String {
+    format!("{SCHEMA_KEY_PREFIX}-{}-", catalog_name.as_ref())
+}
+
+pub fn build_table_global_prefix(
+    catalog_name: impl AsRef<str>,
+    schema_name: impl AsRef<str>,
+) -> String {
+    format!(
+        "{TABLE_GLOBAL_KEY_PREFIX}-{}-{}-",
+        catalog_name.as_ref(),
+        schema_name.as_ref()
+    )
+}
+
+pub fn build_table_regional_prefix(
+    catalog_name: impl AsRef<str>,
+    schema_name: impl AsRef<str>,
+) -> String {
+    format!(
+        "{}-{}-{}-",
+        TABLE_REGIONAL_KEY_PREFIX,
+        catalog_name.as_ref(),
+        schema_name.as_ref()
+    )
+}
+
+/// Table global info has only one key across all datanodes so it does not have `node_id` field.
+#[derive(Clone)]
+pub struct TableGlobalKey {
+    pub catalog_name: String,
+    pub schema_name: String,
+    pub table_name: String,
+}
+
+impl Display for TableGlobalKey {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(TABLE_GLOBAL_KEY_PREFIX)?;
+        f.write_str("-")?;
+        f.write_str(&self.catalog_name)?;
+        f.write_str("-")?;
+        f.write_str(&self.schema_name)?;
+        f.write_str("-")?;
+        f.write_str(&self.table_name)
+    }
+}
+
+impl TableGlobalKey {
+    pub fn parse<S: AsRef<str>>(s: S) -> Result<Self, Error> {
+        let key = s.as_ref();
+        let captures = TABLE_GLOBAL_KEY_PATTERN
+            .captures(key)
+            .context(InvalidCatalogSnafu { key })?;
+        ensure!(captures.len() == 4, InvalidCatalogSnafu { key });
+
+        Ok(Self {
+            catalog_name: captures[1].to_string(),
+            schema_name: captures[2].to_string(),
+            table_name: captures[3].to_string(),
+        })
+    }
+}
+
+/// Table global info contains necessary info for a datanode to create table regions, including
+/// table id, table meta(schema...), region id allocation across datanodes.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct TableGlobalValue {
+    /// Id of datanode that created the global table info kv. only for debugging.
+    pub node_id: u64,
+    /// Allocation of region ids across all datanodes.
+    pub regions_id_map: HashMap<u64, Vec<u32>>,
+    pub table_info: RawTableInfo,
+}
+
+impl TableGlobalValue {
+    pub fn table_id(&self) -> TableId {
+        self.table_info.ident.table_id
+    }
+}
+
+/// Table regional info that varies between datanode, so it contains a `node_id` field.
+pub struct TableRegionalKey {
+    pub catalog_name: String,
+    pub schema_name: String,
+    pub table_name: String,
+    pub node_id: u64,
+}
+
+impl Display for TableRegionalKey {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(TABLE_REGIONAL_KEY_PREFIX)?;
+        f.write_str("-")?;
+        f.write_str(&self.catalog_name)?;
+        f.write_str("-")?;
+        f.write_str(&self.schema_name)?;
+        f.write_str("-")?;
+        f.write_str(&self.table_name)?;
+        f.write_str("-")?;
+        f.serialize_u64(self.node_id)
+    }
+}
+
+impl TableRegionalKey {
+    pub fn parse<S: AsRef<str>>(s: S) -> Result<Self, Error> {
+        let key = s.as_ref();
+        let captures = TABLE_REGIONAL_KEY_PATTERN
+            .captures(key)
+            .context(InvalidCatalogSnafu { key })?;
+        ensure!(captures.len() == 5, InvalidCatalogSnafu { key });
+        let node_id = captures[4]
+            .to_string()
+            .parse()
+            .map_err(|_| InvalidCatalogSnafu { key }.build())?;
+        Ok(Self {
+            catalog_name: captures[1].to_string(),
+            schema_name: captures[2].to_string(),
+            table_name: captures[3].to_string(),
+            node_id,
+        })
+    }
+}
+
+/// Regional table info of specific datanode, including table version on that datanode and
+/// region ids allocated by metasrv.
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct TableRegionalValue {
+    pub version: TableVersion,
+    pub regions_ids: Vec<u32>,
+}
+
+pub struct CatalogKey {
+    pub catalog_name: String,
+}
+
+impl Display for CatalogKey {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(CATALOG_KEY_PREFIX)?;
+        f.write_str("-")?;
+        f.write_str(&self.catalog_name)
+    }
+}
+
+impl CatalogKey {
+    pub fn parse(s: impl AsRef<str>) -> Result<Self, Error> {
+        let key = s.as_ref();
+        let captures = CATALOG_KEY_PATTERN
+            .captures(key)
+            .context(InvalidCatalogSnafu { key })?;
+        ensure!(captures.len() == 2, InvalidCatalogSnafu { key });
+        Ok(Self {
+            catalog_name: captures[1].to_string(),
+        })
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CatalogValue;
+
+pub struct SchemaKey {
+    pub catalog_name: String,
+    pub schema_name: String,
+}
+
+impl Display for SchemaKey {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(SCHEMA_KEY_PREFIX)?;
+        f.write_str("-")?;
+        f.write_str(&self.catalog_name)?;
+        f.write_str("-")?;
+        f.write_str(&self.schema_name)
+    }
+}
+
+impl SchemaKey {
+    pub fn parse(s: impl AsRef<str>) -> Result<Self, Error> {
+        let key = s.as_ref();
+        let captures = SCHEMA_KEY_PATTERN
+            .captures(key)
+            .context(InvalidCatalogSnafu { key })?;
+        ensure!(captures.len() == 3, InvalidCatalogSnafu { key });
+        Ok(Self {
+            catalog_name: captures[1].to_string(),
+            schema_name: captures[2].to_string(),
+        })
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SchemaValue;
+
+macro_rules! define_catalog_value {
+    ( $($val_ty: ty), *) => {
+            $(
+                impl $val_ty {
+                    pub fn parse(s: impl AsRef<str>) -> Result<Self, Error> {
+                        serde_json::from_str(s.as_ref())
+                            .context(DeserializeCatalogEntryValueSnafu { raw: s.as_ref() })
+                    }
+
+                    pub fn from_bytes(bytes: impl AsRef<[u8]>) -> Result<Self, Error> {
+                         Self::parse(&String::from_utf8_lossy(bytes.as_ref()))
+                    }
+
+                    pub fn as_bytes(&self) -> Result<Vec<u8>, Error> {
+                        Ok(serde_json::to_string(self)
+                            .context(SerializeCatalogEntryValueSnafu)?
+                            .into_bytes())
+                    }
+                }
+            )*
+        }
+}
+
+define_catalog_value!(
+    TableRegionalValue,
+    TableGlobalValue,
+    CatalogValue,
+    SchemaValue
+);
+
+#[cfg(test)]
+mod tests {
+    use datatypes::prelude::ConcreteDataType;
+    use datatypes::schema::{ColumnSchema, RawSchema, Schema};
+    use table::metadata::{RawTableMeta, TableIdent, TableType};
+
+    use super::*;
+
+    #[test]
+    fn test_parse_catalog_key() {
+        let key = "__c-C";
+        let catalog_key = CatalogKey::parse(key).unwrap();
+        assert_eq!("C", catalog_key.catalog_name);
+        assert_eq!(key, catalog_key.to_string());
+    }
+
+    #[test]
+    fn test_parse_schema_key() {
+        let key = "__s-C-S";
+        let schema_key = SchemaKey::parse(key).unwrap();
+        assert_eq!("C", schema_key.catalog_name);
+        assert_eq!("S", schema_key.schema_name);
+        assert_eq!(key, schema_key.to_string());
+    }
+
+    #[test]
+    fn test_parse_table_key() {
+        let key = "__tg-C-S-T";
+        let entry = TableGlobalKey::parse(key).unwrap();
+        assert_eq!("C", entry.catalog_name);
+        assert_eq!("S", entry.schema_name);
+        assert_eq!("T", entry.table_name);
+        assert_eq!(key, &entry.to_string());
+    }
+
+    #[test]
+    fn test_build_prefix() {
+        assert_eq!("__c-", build_catalog_prefix());
+        assert_eq!("__s-CATALOG-", build_schema_prefix("CATALOG"));
+        assert_eq!(
+            "__tg-CATALOG-SCHEMA-",
+            build_table_global_prefix("CATALOG", "SCHEMA")
+        );
+    }
+
+    #[test]
+    fn test_serialize_schema() {
+        let schema = Schema::new(vec![ColumnSchema::new(
+            "name",
+            ConcreteDataType::string_datatype(),
+            true,
+        )]);
+
+        let meta = RawTableMeta {
+            schema: RawSchema::from(&schema),
+            engine: "mito".to_string(),
+            created_on: chrono::DateTime::default(),
+            primary_key_indices: vec![0, 1],
+            next_column_id: 3,
+            engine_options: Default::default(),
+            value_indices: vec![2, 3],
+            options: Default::default(),
+            region_numbers: vec![1],
+        };
+
+        let table_info = RawTableInfo {
+            ident: TableIdent {
+                table_id: 42,
+                version: 1,
+            },
+            name: "table_1".to_string(),
+            desc: Some("blah".to_string()),
+            catalog_name: "catalog_1".to_string(),
+            schema_name: "schema_1".to_string(),
+            meta,
+            table_type: TableType::Base,
+        };
+
+        let value = TableGlobalValue {
+            node_id: 0,
+            regions_id_map: HashMap::from([(0, vec![1, 2, 3])]),
+            table_info,
+        };
+        let serialized = serde_json::to_string(&value).unwrap();
+        let deserialized = TableGlobalValue::parse(serialized).unwrap();
+        assert_eq!(value, deserialized);
+    }
+
+    #[test]
+    fn test_table_global_value_compatibility() {
+        let s = r#"{"node_id":1,"regions_id_map":{"1":[0]},"table_info":{"ident":{"table_id":1098,"version":1},"name":"container_cpu_limit","desc":"Created on insertion","catalog_name":"greptime","schema_name":"dd","meta":{"schema":{"column_schemas":[{"name":"container_id","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"container_name","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"docker_image","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"host","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"image_name","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"image_tag","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"interval","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"runtime","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"short_image","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"type","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"dd_value","data_type":{"Float64":{}},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}},{"name":"ts","data_type":{"Timestamp":{"Millisecond":null}},"is_nullable":false,"is_time_index":true,"default_constraint":null,"metadata":{"greptime:time_index":"true"}},{"name":"git.repository_url","data_type":{"String":null},"is_nullable":true,"is_time_index":false,"default_constraint":null,"metadata":{}}],"timestamp_index":11,"version":1},"primary_key_indices":[0,1,2,3,4,5,6,7,8,9,12],"value_indices":[10,11],"engine":"mito","next_column_id":12,"region_numbers":[],"engine_options":{},"options":{},"created_on":"1970-01-01T00:00:00Z"},"table_type":"Base"}}"#;
+        TableGlobalValue::parse(s).unwrap();
+    }
+}

src/catalog/src/information_schema.rs

@@ -12,170 +12,69 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-mod columns;
 mod tables;
 
-use std::collections::HashMap;
-use std::sync::{Arc, Weak};
+use std::any::Any;
+use std::sync::Arc;
 
-use common_catalog::consts::INFORMATION_SCHEMA_NAME;
-use common_error::ext::BoxedError;
-use common_recordbatch::{RecordBatchStreamAdaptor, SendableRecordBatchStream};
-use datatypes::schema::SchemaRef;
-use futures_util::StreamExt;
+use async_trait::async_trait;
+use datafusion::datasource::streaming::{PartitionStream, StreamingTable};
 use snafu::ResultExt;
-use store_api::data_source::DataSource;
-use store_api::storage::{ScanRequest, TableId};
-use table::error::{SchemaConversionSnafu, TablesRecordBatchSnafu};
-use table::metadata::{
-    FilterPushDownType, TableInfoBuilder, TableInfoRef, TableMetaBuilder, TableType,
-};
-use table::thin_table::{ThinTable, ThinTableAdapter};
+use table::table::adapter::TableAdapter;
 use table::TableRef;
 
-use self::columns::InformationSchemaColumns;
-use crate::error::Result;
+use crate::error::{DatafusionSnafu, Result, TableSchemaMismatchSnafu};
 use crate::information_schema::tables::InformationSchemaTables;
-use crate::CatalogManager;
+use crate::{CatalogProviderRef, SchemaProvider};
 
-pub const TABLES: &str = "tables";
-pub const COLUMNS: &str = "columns";
+const TABLES: &str = "tables";
 
-pub struct InformationSchemaProvider {
+pub(crate) struct InformationSchemaProvider {
     catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
+    catalog_provider: CatalogProviderRef,
 }
 
 impl InformationSchemaProvider {
-    pub fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
+    pub(crate) fn new(catalog_name: String, catalog_provider: CatalogProviderRef) -> Self {
         Self {
             catalog_name,
-            catalog_manager,
+            catalog_provider,
         }
     }
+}
 
-    /// 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);
-
-        let mut schema = HashMap::new();
-        schema.insert(TABLES.to_owned(), provider.table(TABLES).unwrap());
-        schema.insert(COLUMNS.to_owned(), provider.table(COLUMNS).unwrap());
-        schema
+#[async_trait]
+impl SchemaProvider for InformationSchemaProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
     }
 
-    pub fn 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::Unsupported;
-            let thin_table = ThinTable::new(table_info, filter_pushdown);
-
-            let data_source = Arc::new(InformationTableDataSource::new(table));
-            Arc::new(ThinTableAdapter::new(thin_table, data_source)) as _
-        })
+    fn table_names(&self) -> Result<Vec<String>> {
+        Ok(vec![TABLES.to_string()])
     }
 
-    fn information_table(&self, name: &str) -> Option<InformationTableRef> {
-        match name.to_ascii_lowercase().as_str() {
-            TABLES => Some(Arc::new(InformationSchemaTables::new(
+    async fn table(&self, name: &str) -> Result<Option<TableRef>> {
+        let table = if name.eq_ignore_ascii_case(TABLES) {
+            Arc::new(InformationSchemaTables::new(
                 self.catalog_name.clone(),
-                self.catalog_manager.clone(),
-            )) as _),
-            COLUMNS => Some(Arc::new(InformationSchemaColumns::new(
-                self.catalog_name.clone(),
-                self.catalog_manager.clone(),
-            )) as _),
-            _ => None,
-        }
-    }
-
-    fn table_info(catalog_name: String, table: &InformationTableRef) -> TableInfoRef {
-        let table_meta = TableMetaBuilder::default()
-            .schema(table.schema())
-            .primary_key_indices(vec![])
-            .next_column_id(0)
-            .build()
-            .unwrap();
-        let table_info = TableInfoBuilder::default()
-            .table_id(table.table_id())
-            .name(table.table_name().to_owned())
-            .catalog_name(catalog_name)
-            .schema_name(INFORMATION_SCHEMA_NAME.to_owned())
-            .meta(table_meta)
-            .table_type(table.table_type())
-            .build()
-            .unwrap();
-        Arc::new(table_info)
-    }
-}
-
-trait InformationTable {
-    fn table_id(&self) -> TableId;
-
-    fn table_name(&self) -> &'static str;
-
-    fn schema(&self) -> SchemaRef;
-
-    fn to_stream(&self) -> Result<SendableRecordBatchStream>;
-
-    fn table_type(&self) -> TableType {
-        TableType::Temporary
-    }
-}
-
-type InformationTableRef = Arc<dyn InformationTable + Send + Sync>;
-
-struct InformationTableDataSource {
-    table: InformationTableRef,
-}
-
-impl InformationTableDataSource {
-    fn new(table: InformationTableRef) -> Self {
-        Self { table }
-    }
-
-    fn try_project(&self, projection: &[usize]) -> std::result::Result<SchemaRef, BoxedError> {
-        let schema = self
-            .table
-            .schema()
-            .try_project(projection)
-            .context(SchemaConversionSnafu)
-            .map_err(BoxedError::new)?;
-        Ok(Arc::new(schema))
-    }
-}
-
-impl DataSource for InformationTableDataSource {
-    fn get_stream(
-        &self,
-        request: ScanRequest,
-    ) -> std::result::Result<SendableRecordBatchStream, BoxedError> {
-        let projection = request.projection;
-        let projected_schema = match &projection {
-            Some(projection) => self.try_project(projection)?,
-            None => self.table.schema(),
+                self.catalog_provider.clone(),
+            ))
+        } else {
+            return Ok(None);
         };
 
-        let stream = self
-            .table
-            .to_stream()
-            .map_err(BoxedError::new)
-            .context(TablesRecordBatchSnafu)
-            .map_err(BoxedError::new)?
-            .map(move |batch| match &projection {
-                Some(p) => batch.and_then(|b| b.try_project(p)),
-                None => batch,
-            });
+        let table = Arc::new(
+            StreamingTable::try_new(table.schema().clone(), vec![table]).with_context(|_| {
+                DatafusionSnafu {
+                    msg: format!("Failed to get InformationSchema table '{name}'"),
+                }
+            })?,
+        );
+        let table = TableAdapter::new(table).context(TableSchemaMismatchSnafu)?;
+        Ok(Some(Arc::new(table)))
+    }
 
-        let stream = RecordBatchStreamAdaptor {
-            schema: projected_schema,
-            stream: Box::pin(stream),
-            output_ordering: None,
-        };
-        Ok(Box::pin(stream))
+    fn table_exist(&self, name: &str) -> Result<bool> {
+        Ok(matches!(name.to_ascii_lowercase().as_str(), TABLES))
     }
 }

src/catalog/src/information_schema/columns.rs

@@ -1,264 +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_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;
-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, DataType};
-use datatypes::scalars::ScalarVectorBuilder;
-use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::vectors::{StringVectorBuilder, VectorRef};
-use snafu::{OptionExt, ResultExt};
-use store_api::storage::TableId;
-
-use super::tables::InformationSchemaTables;
-use super::{InformationTable, COLUMNS, TABLES};
-use crate::error::{
-    CreateRecordBatchSnafu, InternalSnafu, Result, UpgradeWeakCatalogManagerRefSnafu,
-};
-use crate::CatalogManager;
-
-pub(super) struct InformationSchemaColumns {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
-}
-
-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 DATA_TYPE: &str = "data_type";
-const SEMANTIC_TYPE: &str = "semantic_type";
-
-impl InformationSchemaColumns {
-    pub(super) fn new(catalog_name: String, catalog_manager: Weak<dyn CatalogManager>) -> Self {
-        Self {
-            schema: Self::schema(),
-            catalog_name,
-            catalog_manager,
-        }
-    }
-
-    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(COLUMN_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(DATA_TYPE, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(SEMANTIC_TYPE, ConcreteDataType::string_datatype(), false),
-        ]))
-    }
-
-    fn builder(&self) -> InformationSchemaColumnsBuilder {
-        InformationSchemaColumnsBuilder::new(
-            self.schema.clone(),
-            self.catalog_name.clone(),
-            self.catalog_manager.clone(),
-        )
-    }
-}
-
-impl InformationTable for InformationSchemaColumns {
-    fn table_id(&self) -> TableId {
-        INFORMATION_SCHEMA_COLUMNS_TABLE_ID
-    }
-
-    fn table_name(&self) -> &'static str {
-        COLUMNS
-    }
-
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    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()
-                    .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 InformationSchemaColumnsBuilder {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
-
-    catalog_names: StringVectorBuilder,
-    schema_names: StringVectorBuilder,
-    table_names: StringVectorBuilder,
-    column_names: StringVectorBuilder,
-    data_types: StringVectorBuilder,
-    semantic_types: StringVectorBuilder,
-}
-
-impl InformationSchemaColumnsBuilder {
-    fn new(
-        schema: SchemaRef,
-        catalog_name: String,
-        catalog_manager: Weak<dyn CatalogManager>,
-    ) -> Self {
-        Self {
-            schema,
-            catalog_name,
-            catalog_manager,
-            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.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)?;
-
-        for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            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() {
-                        SEMANTIC_TYPE_TIME_INDEX
-                    } else if keys.contains(&idx) {
-                        SEMANTIC_TYPE_PRIMARY_KEY
-                    } else {
-                        SEMANTIC_TYPE_FIELD
-                    };
-                    self.add_column(
-                        &catalog_name,
-                        &schema_name,
-                        &table_name,
-                        &column.name,
-                        column.data_type.name(),
-                        semantic_type,
-                    );
-                }
-            }
-        }
-
-        self.finish()
-    }
-
-    fn add_column(
-        &mut self,
-        catalog_name: &str,
-        schema_name: &str,
-        table_name: &str,
-        column_name: &str,
-        data_type: &str,
-        semantic_type: &str,
-    ) {
-        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_name));
-        self.data_types.push(Some(data_type));
-        self.semantic_types.push(Some(semantic_type));
-    }
-
-    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.table_names.finish()),
-            Arc::new(self.column_names.finish()),
-            Arc::new(self.data_types.finish()),
-            Arc::new(self.semantic_types.finish()),
-        ];
-        RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
-    }
-}
-
-impl DfPartitionStream for InformationSchemaColumns {
-    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_tables()
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ))
-    }
-}

src/catalog/src/information_schema/tables.rs

@@ -12,198 +12,106 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::sync::{Arc, Weak};
+use std::sync::Arc;
 
 use arrow_schema::SchemaRef as ArrowSchemaRef;
-use common_catalog::consts::{
-    INFORMATION_SCHEMA_COLUMNS_TABLE_ID, INFORMATION_SCHEMA_NAME,
-    INFORMATION_SCHEMA_TABLES_TABLE_ID,
-};
-use common_error::ext::BoxedError;
+use common_catalog::consts::INFORMATION_SCHEMA_NAME;
 use common_query::physical_plan::TaskContext;
-use common_recordbatch::adapter::RecordBatchStreamAdapter;
-use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
+use common_recordbatch::RecordBatch;
+use datafusion::datasource::streaming::PartitionStream as DfPartitionStream;
 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::vectors::{StringVectorBuilder, UInt32VectorBuilder};
-use snafu::{OptionExt, ResultExt};
-use store_api::storage::TableId;
+use datatypes::vectors::StringVectorBuilder;
+use snafu::ResultExt;
 use table::metadata::TableType;
 
-use super::{COLUMNS, TABLES};
-use crate::error::{
-    CreateRecordBatchSnafu, InternalSnafu, Result, UpgradeWeakCatalogManagerRefSnafu,
-};
-use crate::information_schema::InformationTable;
-use crate::CatalogManager;
+use crate::error::{CreateRecordBatchSnafu, Result};
+use crate::information_schema::TABLES;
+use crate::CatalogProviderRef;
 
 pub(super) struct InformationSchemaTables {
     schema: SchemaRef,
     catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
+    catalog_provider: CatalogProviderRef,
 }
 
 impl InformationSchemaTables {
-    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![
+    pub(super) fn new(catalog_name: String, catalog_provider: CatalogProviderRef) -> Self {
+        let schema = 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),
-        ]))
+        ]));
+        Self {
+            schema,
+            catalog_name,
+            catalog_provider,
+        }
     }
 
     fn builder(&self) -> InformationSchemaTablesBuilder {
         InformationSchemaTablesBuilder::new(
             self.schema.clone(),
             self.catalog_name.clone(),
-            self.catalog_manager.clone(),
+            self.catalog_provider.clone(),
         )
     }
 }
 
-impl InformationTable for InformationSchemaTables {
-    fn table_id(&self) -> TableId {
-        INFORMATION_SCHEMA_TABLES_TABLE_ID
-    }
-
-    fn table_name(&self) -> &'static str {
-        TABLES
-    }
-
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    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()
-                    .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.TABLE` table row by row
 ///
 /// Columns are based on <https://www.postgresql.org/docs/current/infoschema-columns.html>
 struct InformationSchemaTablesBuilder {
     schema: SchemaRef,
     catalog_name: String,
-    catalog_manager: Weak<dyn CatalogManager>,
+    catalog_provider: CatalogProviderRef,
 
     catalog_names: StringVectorBuilder,
     schema_names: StringVectorBuilder,
     table_names: StringVectorBuilder,
     table_types: StringVectorBuilder,
-    table_ids: UInt32VectorBuilder,
-    engines: StringVectorBuilder,
 }
 
 impl InformationSchemaTablesBuilder {
-    fn new(
-        schema: SchemaRef,
-        catalog_name: String,
-        catalog_manager: Weak<dyn CatalogManager>,
-    ) -> Self {
+    fn new(schema: SchemaRef, catalog_name: String, catalog_provider: CatalogProviderRef) -> Self {
         Self {
             schema,
             catalog_name,
-            catalog_manager,
+            catalog_provider,
             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) -> Result<RecordBatch> {
         let catalog_name = self.catalog_name.clone();
-        let catalog_manager = self
-            .catalog_manager
-            .upgrade()
-            .context(UpgradeWeakCatalogManagerRefSnafu)?;
 
-        for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            if !catalog_manager
-                .schema_exist(&catalog_name, &schema_name)
-                .await?
-            {
+        for schema_name in self.catalog_provider.schema_names()? {
+            if schema_name == INFORMATION_SCHEMA_NAME {
                 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 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,
-                            );
-                        }
-                    }
-                };
+            let Some(schema) = self.catalog_provider.schema(&schema_name)? else { continue };
+            for table_name in schema.table_names()? {
+                let Some(table) = schema.table(&table_name).await? else { continue };
+                self.add_table(&catalog_name, &schema_name, &table_name, table.table_type());
             }
         }
 
+        // Add a final list for the information schema tables themselves
+        self.add_table(
+            &catalog_name,
+            INFORMATION_SCHEMA_NAME,
+            TABLES,
+            TableType::View,
+        );
+
         self.finish()
     }
 
@@ -213,8 +121,6 @@ impl InformationSchemaTablesBuilder {
         schema_name: &str,
         table_name: &str,
         table_type: TableType,
-        table_id: Option<u32>,
-        engine: Option<&str>,
     ) {
         self.catalog_names.push(Some(catalog_name));
         self.schema_names.push(Some(schema_name));
@@ -224,8 +130,6 @@ impl InformationSchemaTablesBuilder {
             TableType::View => "VIEW",
             TableType::Temporary => "LOCAL TEMPORARY",
         }));
-        self.table_ids.push(table_id);
-        self.engines.push(engine);
     }
 
     fn finish(&mut self) -> Result<RecordBatch> {
@@ -234,8 +138,6 @@ impl InformationSchemaTablesBuilder {
             Arc::new(self.schema_names.finish()),
             Arc::new(self.table_names.finish()),
             Arc::new(self.table_types.finish()),
-            Arc::new(self.table_ids.finish()),
-            Arc::new(self.engines.finish()),
         ];
         RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
     }
@@ -247,7 +149,7 @@ impl DfPartitionStream for InformationSchemaTables {
     }
 
     fn execute(&self, _: Arc<TaskContext>) -> DfSendableRecordBatchStream {
-        let schema = self.schema.arrow_schema().clone();
+        let schema = self.schema().clone();
         let mut builder = self.builder();
         Box::pin(DfRecordBatchStreamAdapter::new(
             schema,

src/catalog/src/lib.rs

@@ -12,66 +12,95 @@
 // 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 api::v1::meta::{RegionStat, TableIdent, TableName};
+use api::v1::meta::{RegionStat, TableName};
 use common_telemetry::{info, warn};
 use snafu::ResultExt;
 use table::engine::{EngineContext, TableEngineRef};
-use table::metadata::{TableId, TableType};
+use table::metadata::TableId;
 use table::requests::CreateTableRequest;
 use table::TableRef;
 
 use crate::error::{CreateTableSnafu, Result};
+pub use crate::schema::{SchemaProvider, SchemaProviderRef};
 
+pub mod datafusion;
 pub mod error;
-pub mod information_schema;
+pub mod helper;
+pub(crate) mod information_schema;
 pub mod local;
-mod metrics;
 pub mod remote;
+pub mod schema;
 pub mod system;
 pub mod table_source;
 pub mod tables;
 
-#[async_trait::async_trait]
-pub trait CatalogManager: Send + Sync {
+/// Represent a list of named catalogs
+pub trait CatalogList: Sync + Send {
+    /// Returns the catalog list as [`Any`](std::any::Any)
+    /// so that it can be downcast to a specific implementation.
     fn as_any(&self) -> &dyn Any;
 
+    /// Adds a new catalog to this catalog list
+    /// If a catalog of the same name existed before, it is replaced in the list and returned.
+    fn register_catalog(
+        &self,
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Result<Option<CatalogProviderRef>>;
+
+    /// Retrieves the list of available catalog names
+    fn catalog_names(&self) -> Result<Vec<String>>;
+
+    /// Retrieves a specific catalog by name, provided it exists.
+    fn catalog(&self, name: &str) -> Result<Option<CatalogProviderRef>>;
+}
+
+/// Represents a catalog, comprising a number of named schemas.
+pub trait CatalogProvider: Sync + Send {
+    /// Returns the catalog provider as [`Any`](std::any::Any)
+    /// so that it can be downcast to a specific implementation.
+    fn as_any(&self) -> &dyn Any;
+
+    /// Retrieves the list of available schema names in this catalog.
+    fn schema_names(&self) -> Result<Vec<String>>;
+
+    /// Registers schema to this catalog.
+    fn register_schema(
+        &self,
+        name: String,
+        schema: SchemaProviderRef,
+    ) -> Result<Option<SchemaProviderRef>>;
+
+    /// Retrieves a specific schema from the catalog by name, provided it exists.
+    fn schema(&self, name: &str) -> Result<Option<SchemaProviderRef>>;
+}
+
+pub type CatalogListRef = Arc<dyn CatalogList>;
+pub type CatalogProviderRef = Arc<dyn CatalogProvider>;
+
+#[async_trait::async_trait]
+pub trait CatalogManager: CatalogList {
     /// 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>;
+    /// Registers a table within given catalog/schema to catalog manager,
+    /// returns whether the table registered.
+    async fn register_table(&self, request: RegisterTableRequest) -> Result<bool>;
+
+    /// Deregisters a table within given catalog/schema to catalog manager,
+    /// returns whether the table deregistered.
+    async fn deregister_table(&self, request: DeregisterTableRequest) -> 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>;
 
@@ -79,17 +108,7 @@ pub trait CatalogManager: Send + Sync {
     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_exist(&self, catalog: &str) -> Result<bool>;
-
-    async fn schema_exist(&self, catalog: &str, schema: &str) -> Result<bool>;
-
-    async fn table_exist(&self, catalog: &str, schema: &str, table: &str) -> Result<bool>;
+    fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>>;
 
     /// Returns the table by catalog, schema and table name.
     async fn table(
@@ -152,15 +171,17 @@ pub struct DeregisterTableRequest {
 }
 
 #[derive(Debug, Clone)]
-pub struct DeregisterSchemaRequest {
+pub struct RegisterSchemaRequest {
     pub catalog: String,
     pub schema: String,
 }
 
-#[derive(Debug, Clone)]
-pub struct RegisterSchemaRequest {
-    pub catalog: String,
-    pub schema: String,
+pub trait CatalogProviderFactory {
+    fn create(&self, catalog_name: String) -> CatalogProviderRef;
+}
+
+pub trait SchemaProviderFactory {
+    fn create(&self, catalog_name: String, schema_name: String) -> SchemaProviderRef;
 }
 
 pub(crate) async fn handle_system_table_request<'a, M: CatalogManager>(
@@ -188,7 +209,7 @@ pub(crate) async fn handle_system_table_request<'a, M: CatalogManager>(
                         table_name,
                     ),
                 })?;
-            let _ = manager
+            manager
                 .register_table(RegisterTableRequest {
                     catalog: catalog_name.clone(),
                     schema: schema_name.clone(),
@@ -217,54 +238,31 @@ pub async fn datanode_stat(catalog_manager: &CatalogManagerRef) -> (u64, Vec<Reg
     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);
-    };
+    let Ok(catalog_names) = catalog_manager.catalog_names() 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;
-        };
+        let Ok(Some(catalog)) = catalog_manager.catalog(&catalog_name) else { continue };
+
+        let Ok(schema_names) = catalog.schema_names() else { continue };
         for schema_name in schema_names {
-            let Ok(table_names) = catalog_manager
-                .table_names(&catalog_name, &schema_name)
-                .await
-            else {
-                continue;
-            };
+            let Ok(Some(schema)) = catalog.schema(&schema_name) else { continue };
+
+            let Ok(table_names) = schema.table_names() else { continue };
             for table_name in table_names {
-                let Ok(Some(table)) = catalog_manager
-                    .table(&catalog_name, &schema_name, &table_name)
-                    .await
-                else {
-                    continue;
-                };
+                let Ok(Some(table)) = schema.table(&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;
+                let region_numbers = &table.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(),
+                            table_name: Some(TableName {
+                                catalog_name: catalog_name.clone(),
+                                schema_name: schema_name.clone(),
+                                table_name: table_name.clone(),
                             }),
                             approximate_bytes: stat.disk_usage_bytes as i64,
-                            attrs: HashMap::from([("engine_name".to_owned(), engine.clone())]),
                             ..Default::default()
                         });
 

src/catalog/src/local.rs

@@ -16,4 +16,6 @@ pub mod manager;
 pub mod memory;
 
 pub use manager::LocalCatalogManager;
-pub use memory::{new_memory_catalog_manager, MemoryCatalogManager};
+pub use memory::{
+    new_memory_catalog_list, MemoryCatalogManager, MemoryCatalogProvider, MemorySchemaProvider,
+};

src/catalog/src/local/manager.rs

@@ -18,8 +18,7 @@ use std::sync::Arc;
 
 use common_catalog::consts::{
     DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, INFORMATION_SCHEMA_NAME, MIN_USER_TABLE_ID,
-    MITO_ENGINE, NUMBERS_TABLE_ID, SYSTEM_CATALOG_NAME, SYSTEM_CATALOG_TABLE_ID,
-    SYSTEM_CATALOG_TABLE_NAME,
+    MITO_ENGINE, SYSTEM_CATALOG_NAME, SYSTEM_CATALOG_TABLE_NAME,
 };
 use common_catalog::format_full_table_name;
 use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
@@ -27,13 +26,12 @@ use common_telemetry::{error, info};
 use datatypes::prelude::ScalarVector;
 use datatypes::vectors::{BinaryVector, UInt8Vector};
 use futures_util::lock::Mutex;
-use metrics::increment_gauge;
 use snafu::{ensure, OptionExt, ResultExt};
 use table::engine::manager::TableEngineManagerRef;
 use table::engine::EngineContext;
 use table::metadata::TableId;
 use table::requests::OpenTableRequest;
-use table::table::numbers::{NumbersTable, NUMBERS_TABLE_NAME};
+use table::table::numbers::NumbersTable;
 use table::table::TableIdProvider;
 use table::TableRef;
 
@@ -41,17 +39,18 @@ use crate::error::{
     self, CatalogNotFoundSnafu, IllegalManagerStateSnafu, OpenTableSnafu, ReadSystemCatalogSnafu,
     Result, SchemaExistsSnafu, SchemaNotFoundSnafu, SystemCatalogSnafu,
     SystemCatalogTypeMismatchSnafu, TableEngineNotFoundSnafu, TableExistsSnafu, TableNotExistSnafu,
-    TableNotFoundSnafu, UnimplementedSnafu,
+    TableNotFoundSnafu,
 };
-use crate::local::memory::MemoryCatalogManager;
+use crate::local::memory::{MemoryCatalogManager, MemoryCatalogProvider, MemorySchemaProvider};
 use crate::system::{
     decode_system_catalog, Entry, SystemCatalogTable, TableEntry, ENTRY_TYPE_INDEX, KEY_INDEX,
     VALUE_INDEX,
 };
 use crate::tables::SystemCatalog;
 use crate::{
-    handle_system_table_request, CatalogManager, DeregisterSchemaRequest, DeregisterTableRequest,
-    RegisterSchemaRequest, RegisterSystemTableRequest, RegisterTableRequest, RenameTableRequest,
+    handle_system_table_request, CatalogList, CatalogManager, CatalogProvider, CatalogProviderRef,
+    DeregisterTableRequest, RegisterSchemaRequest, RegisterSystemTableRequest,
+    RegisterTableRequest, RenameTableRequest, SchemaProvider, SchemaProviderRef,
 };
 
 /// A `CatalogManager` consists of a system catalog and a bunch of user catalogs.
@@ -74,11 +73,11 @@ impl LocalCatalogManager {
                 engine_name: MITO_ENGINE,
             })?;
         let table = SystemCatalogTable::new(engine.clone()).await?;
-        let memory_catalog_manager = crate::local::memory::new_memory_catalog_manager()?;
+        let memory_catalog_list = crate::local::memory::new_memory_catalog_list()?;
         let system_catalog = Arc::new(SystemCatalog::new(table));
         Ok(Self {
             system: system_catalog,
-            catalogs: memory_catalog_manager,
+            catalogs: memory_catalog_list,
             engine_manager,
             next_table_id: AtomicU32::new(MIN_USER_TABLE_ID),
             init_lock: Mutex::new(false),
@@ -89,7 +88,7 @@ impl LocalCatalogManager {
 
     /// Scan all entries from system catalog table
     pub async fn init(&self) -> Result<()> {
-        self.init_system_catalog().await?;
+        self.init_system_catalog()?;
         let system_records = self.system.information_schema.system.records().await?;
         let entries = self.collect_system_catalog_entries(system_records).await?;
         let max_table_id = self.handle_system_catalog_entries(entries).await?;
@@ -115,44 +114,27 @@ impl LocalCatalogManager {
         Ok(())
     }
 
-    async fn init_system_catalog(&self) -> Result<()> {
-        // register default catalog and default schema
+    fn init_system_catalog(&self) -> Result<()> {
+        let system_schema = Arc::new(MemorySchemaProvider::new());
+        system_schema.register_table(
+            SYSTEM_CATALOG_TABLE_NAME.to_string(),
+            self.system.information_schema.system.clone(),
+        )?;
+        let system_catalog = Arc::new(MemoryCatalogProvider::new());
+        system_catalog.register_schema(INFORMATION_SCHEMA_NAME.to_string(), system_schema)?;
         self.catalogs
-            .register_catalog_sync(DEFAULT_CATALOG_NAME.to_string())?;
-        self.catalogs.register_schema_sync(RegisterSchemaRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-        })?;
+            .register_catalog(SYSTEM_CATALOG_NAME.to_string(), system_catalog)?;
 
-        // register SystemCatalogTable
-        self.catalogs
-            .register_catalog_sync(SYSTEM_CATALOG_NAME.to_string())?;
-        self.catalogs.register_schema_sync(RegisterSchemaRequest {
-            catalog: SYSTEM_CATALOG_NAME.to_string(),
-            schema: INFORMATION_SCHEMA_NAME.to_string(),
-        })?;
-        let register_table_req = RegisterTableRequest {
-            catalog: SYSTEM_CATALOG_NAME.to_string(),
-            schema: INFORMATION_SCHEMA_NAME.to_string(),
-            table_name: SYSTEM_CATALOG_TABLE_NAME.to_string(),
-            table_id: SYSTEM_CATALOG_TABLE_ID,
-            table: self.system.information_schema.system.as_table_ref(),
-        };
-        self.catalogs.register_table(register_table_req).await?;
+        let default_catalog = Arc::new(MemoryCatalogProvider::new());
+        let default_schema = Arc::new(MemorySchemaProvider::new());
 
         // Add numbers table for test
-        let register_number_table_req = RegisterTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: NUMBERS_TABLE_NAME.to_string(),
-            table_id: NUMBERS_TABLE_ID,
-            table: NumbersTable::table(NUMBERS_TABLE_ID),
-        };
+        let table = Arc::new(NumbersTable::default());
+        default_schema.register_table("numbers".to_string(), table)?;
 
+        default_catalog.register_schema(DEFAULT_SCHEMA_NAME.to_string(), default_schema)?;
         self.catalogs
-            .register_table(register_number_table_req)
-            .await?;
-
+            .register_catalog(DEFAULT_CATALOG_NAME.to_string(), default_catalog)?;
         Ok(())
     }
 
@@ -224,25 +206,29 @@ impl LocalCatalogManager {
         for entry in entries {
             match entry {
                 Entry::Catalog(c) => {
-                    self.catalogs
-                        .register_catalog_sync(c.catalog_name.clone())?;
+                    self.catalogs.register_catalog_if_absent(
+                        c.catalog_name.clone(),
+                        Arc::new(MemoryCatalogProvider::new()),
+                    );
                     info!("Register catalog: {}", c.catalog_name);
                 }
                 Entry::Schema(s) => {
-                    let req = RegisterSchemaRequest {
-                        catalog: s.catalog_name.clone(),
-                        schema: s.schema_name.clone(),
-                    };
-                    let _ = self.catalogs.register_schema_sync(req)?;
+                    let catalog =
+                        self.catalogs
+                            .catalog(&s.catalog_name)?
+                            .context(CatalogNotFoundSnafu {
+                                catalog_name: &s.catalog_name,
+                            })?;
+                    catalog.register_schema(
+                        s.schema_name.clone(),
+                        Arc::new(MemorySchemaProvider::new()),
+                    )?;
                     info!("Registered schema: {:?}", s);
                 }
                 Entry::Table(t) => {
-                    max_table_id = max_table_id.max(t.table_id);
-                    if t.is_deleted {
-                        continue;
-                    }
                     self.open_and_register_table(&t).await?;
                     info!("Registered table: {:?}", t);
+                    max_table_id = max_table_id.max(t.table_id);
                 }
             }
         }
@@ -257,16 +243,25 @@ impl LocalCatalogManager {
     }
 
     async fn open_and_register_table(&self, t: &TableEntry) -> Result<()> {
-        self.check_catalog_schema_exist(&t.catalog_name, &t.schema_name)
-            .await?;
+        let catalog = self
+            .catalogs
+            .catalog(&t.catalog_name)?
+            .context(CatalogNotFoundSnafu {
+                catalog_name: &t.catalog_name,
+            })?;
+        let schema = catalog
+            .schema(&t.schema_name)?
+            .context(SchemaNotFoundSnafu {
+                catalog: &t.catalog_name,
+                schema: &t.schema_name,
+            })?;
 
         let context = EngineContext {};
-        let open_request = OpenTableRequest {
+        let request = OpenTableRequest {
             catalog_name: t.catalog_name.clone(),
             schema_name: t.schema_name.clone(),
             table_name: t.table_name.clone(),
             table_id: t.table_id,
-            region_numbers: vec![0],
         };
         let engine = self
             .engine_manager
@@ -275,8 +270,8 @@ impl LocalCatalogManager {
                 engine_name: &t.engine,
             })?;
 
-        let table_ref = engine
-            .open_table(&context, open_request)
+        let option = engine
+            .open_table(&context, request)
             .await
             .with_context(|_| OpenTableSnafu {
                 table_info: format!(
@@ -291,49 +286,34 @@ impl LocalCatalogManager {
                 ),
             })?;
 
-        let register_request = RegisterTableRequest {
-            catalog: t.catalog_name.clone(),
-            schema: t.schema_name.clone(),
-            table_name: t.table_name.clone(),
-            table_id: t.table_id,
-            table: table_ref,
-        };
-        let _ = self.catalogs.register_table(register_request).await?;
-
+        schema.register_table(t.table_name.clone(), option)?;
         Ok(())
     }
+}
 
-    async fn check_state(&self) -> Result<()> {
-        let started = self.init_lock.lock().await;
-        ensure!(
-            *started,
-            IllegalManagerStateSnafu {
-                msg: "Catalog manager not started",
-            }
-        );
-        Ok(())
+impl CatalogList for LocalCatalogManager {
+    fn as_any(&self) -> &dyn Any {
+        self
     }
 
-    async fn check_catalog_schema_exist(
+    fn register_catalog(
         &self,
-        catalog_name: &str,
-        schema_name: &str,
-    ) -> Result<()> {
-        if !self.catalogs.catalog_exist(catalog_name).await? {
-            return CatalogNotFoundSnafu { catalog_name }.fail()?;
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Result<Option<CatalogProviderRef>> {
+        self.catalogs.register_catalog(name, catalog)
+    }
+
+    fn catalog_names(&self) -> Result<Vec<String>> {
+        self.catalogs.catalog_names()
+    }
+
+    fn catalog(&self, name: &str) -> Result<Option<CatalogProviderRef>> {
+        if name.eq_ignore_ascii_case(SYSTEM_CATALOG_NAME) {
+            Ok(Some(self.system.clone()))
+        } else {
+            self.catalogs.catalog(name)
         }
-        if !self
-            .catalogs
-            .schema_exist(catalog_name, schema_name)
-            .await?
-        {
-            return SchemaNotFoundSnafu {
-                catalog: catalog_name,
-                schema: schema_name,
-            }
-            .fail()?;
-        }
-        Ok(())
     }
 }
 
@@ -353,21 +333,32 @@ impl CatalogManager for LocalCatalogManager {
     }
 
     async fn register_table(&self, request: RegisterTableRequest) -> Result<bool> {
-        self.check_state().await?;
+        let started = self.init_lock.lock().await;
 
-        let catalog_name = request.catalog.clone();
-        let schema_name = request.schema.clone();
+        ensure!(
+            *started,
+            IllegalManagerStateSnafu {
+                msg: "Catalog manager not started",
+            }
+        );
 
-        self.check_catalog_schema_exist(&catalog_name, &schema_name)
-            .await?;
+        let catalog_name = &request.catalog;
+        let schema_name = &request.schema;
+
+        let catalog = self
+            .catalogs
+            .catalog(catalog_name)?
+            .context(CatalogNotFoundSnafu { catalog_name })?;
+        let schema = catalog
+            .schema(schema_name)?
+            .with_context(|| SchemaNotFoundSnafu {
+                catalog: catalog_name,
+                schema: schema_name,
+            })?;
 
         {
             let _lock = self.register_lock.lock().await;
-            if let Some(existing) = self
-                .catalogs
-                .table(&request.catalog, &request.schema, &request.table_name)
-                .await?
-            {
+            if let Some(existing) = schema.table(&request.table_name).await? {
                 if existing.table_info().ident.table_id != request.table_id {
                     error!(
                         "Unexpected table register request: {:?}, existing: {:?}",
@@ -376,8 +367,8 @@ impl CatalogManager for LocalCatalogManager {
                     );
                     return TableExistsSnafu {
                         table: format_full_table_name(
-                            &catalog_name,
-                            &schema_name,
+                            catalog_name,
+                            schema_name,
                             &request.table_name,
                         ),
                     }
@@ -386,53 +377,57 @@ impl CatalogManager for LocalCatalogManager {
                 // Try to register table with same table id, just ignore.
                 Ok(false)
             } else {
-                // table does not exist
                 let engine = request.table.table_info().meta.engine.to_string();
-                let table_name = request.table_name.clone();
-                let table_id = request.table_id;
-                let _ = self.catalogs.register_table(request).await?;
-                let _ = self
-                    .system
+                // table does not exist
+                self.system
                     .register_table(
                         catalog_name.clone(),
                         schema_name.clone(),
-                        table_name,
-                        table_id,
+                        request.table_name.clone(),
+                        request.table_id,
                         engine,
                     )
                     .await?;
-                increment_gauge!(
-                    crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-                    1.0,
-                    &[crate::metrics::db_label(&catalog_name, &schema_name)],
-                );
+                schema.register_table(request.table_name, request.table)?;
                 Ok(true)
             }
         }
     }
 
     async fn rename_table(&self, request: RenameTableRequest) -> Result<bool> {
-        self.check_state().await?;
+        let started = self.init_lock.lock().await;
+
+        ensure!(
+            *started,
+            IllegalManagerStateSnafu {
+                msg: "Catalog manager not started",
+            }
+        );
 
         let catalog_name = &request.catalog;
         let schema_name = &request.schema;
 
-        self.check_catalog_schema_exist(catalog_name, schema_name)
-            .await?;
+        let catalog = self
+            .catalogs
+            .catalog(catalog_name)?
+            .context(CatalogNotFoundSnafu { catalog_name })?;
+
+        let schema = catalog
+            .schema(schema_name)?
+            .with_context(|| SchemaNotFoundSnafu {
+                catalog: catalog_name,
+                schema: schema_name,
+            })?;
+
+        let _lock = self.register_lock.lock().await;
         ensure!(
-            self.catalogs
-                .table(catalog_name, schema_name, &request.new_table_name)
-                .await?
-                .is_none(),
+            !schema.table_exist(&request.new_table_name)?,
             TableExistsSnafu {
                 table: &request.new_table_name
             }
         );
-
-        let _lock = self.register_lock.lock().await;
-        let old_table = self
-            .catalogs
-            .table(catalog_name, schema_name, &request.table_name)
+        let old_table = schema
+            .table(&request.table_name)
             .await?
             .context(TableNotExistSnafu {
                 table: &request.table_name,
@@ -440,8 +435,7 @@ impl CatalogManager for LocalCatalogManager {
 
         let engine = old_table.table_info().meta.engine.to_string();
         // rename table in system catalog
-        let _ = self
-            .system
+        self.system
             .register_table(
                 catalog_name.clone(),
                 schema_name.clone(),
@@ -451,11 +445,17 @@ impl CatalogManager for LocalCatalogManager {
             )
             .await?;
 
-        self.catalogs.rename_table(request).await
+        let renamed = schema
+            .rename_table(&request.table_name, request.new_table_name.clone())
+            .is_ok();
+        Ok(renamed)
     }
 
-    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<()> {
-        self.check_state().await?;
+    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<bool> {
+        {
+            let started = *self.init_lock.lock().await;
+            ensure!(started, IllegalManagerStateSnafu { msg: "not started" });
+        }
 
         {
             let _ = self.register_lock.lock().await;
@@ -476,63 +476,67 @@ impl CatalogManager for LocalCatalogManager {
                 .ident
                 .table_id;
 
-            self.system.deregister_table(&request, table_id).await?;
+            if !self.system.deregister_table(&request, table_id).await? {
+                return Ok(false);
+            }
+
             self.catalogs.deregister_table(request).await
         }
     }
 
     async fn register_schema(&self, request: RegisterSchemaRequest) -> Result<bool> {
-        self.check_state().await?;
-
+        let started = self.init_lock.lock().await;
+        ensure!(
+            *started,
+            IllegalManagerStateSnafu {
+                msg: "Catalog manager not started",
+            }
+        );
         let catalog_name = &request.catalog;
         let schema_name = &request.schema;
 
-        if !self.catalogs.catalog_exist(catalog_name).await? {
-            return CatalogNotFoundSnafu { catalog_name }.fail()?;
-        }
+        let catalog = self
+            .catalogs
+            .catalog(catalog_name)?
+            .context(CatalogNotFoundSnafu { catalog_name })?;
 
         {
             let _lock = self.register_lock.lock().await;
             ensure!(
-                !self
-                    .catalogs
-                    .schema_exist(catalog_name, schema_name)
-                    .await?,
+                catalog.schema(schema_name)?.is_none(),
                 SchemaExistsSnafu {
                     schema: schema_name,
                 }
             );
-            let _ = self
-                .system
-                .register_schema(request.catalog.clone(), schema_name.clone())
+            self.system
+                .register_schema(request.catalog, schema_name.clone())
                 .await?;
-            self.catalogs.register_schema_sync(request)
+            catalog.register_schema(request.schema, Arc::new(MemorySchemaProvider::new()))?;
+            Ok(true)
         }
     }
 
-    async fn deregister_schema(&self, _request: DeregisterSchemaRequest) -> Result<bool> {
-        UnimplementedSnafu {
-            operation: "deregister schema",
-        }
-        .fail()
-    }
-
     async fn register_system_table(&self, request: RegisterSystemTableRequest) -> Result<()> {
-        let catalog_name = request.create_table_request.catalog_name.clone();
-        let schema_name = request.create_table_request.schema_name.clone();
+        ensure!(
+            !*self.init_lock.lock().await,
+            IllegalManagerStateSnafu {
+                msg: "Catalog manager already started",
+            }
+        );
 
         let mut sys_table_requests = self.system_table_requests.lock().await;
         sys_table_requests.push(request);
-        increment_gauge!(
-            crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-            1.0,
-            &[crate::metrics::db_label(&catalog_name, &schema_name)],
-        );
+
         Ok(())
     }
 
-    async fn schema_exist(&self, catalog: &str, schema: &str) -> Result<bool> {
-        self.catalogs.schema_exist(catalog, schema).await
+    fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>> {
+        self.catalogs
+            .catalog(catalog)?
+            .context(CatalogNotFoundSnafu {
+                catalog_name: catalog,
+            })?
+            .schema(schema)
     }
 
     async fn table(
@@ -541,41 +545,17 @@ impl CatalogManager for LocalCatalogManager {
         schema_name: &str,
         table_name: &str,
     ) -> Result<Option<TableRef>> {
-        self.catalogs
-            .table(catalog_name, schema_name, table_name)
-            .await
-    }
-
-    async fn catalog_exist(&self, catalog: &str) -> Result<bool> {
-        if catalog.eq_ignore_ascii_case(SYSTEM_CATALOG_NAME) {
-            Ok(true)
-        } else {
-            self.catalogs.catalog_exist(catalog).await
-        }
-    }
-
-    async fn table_exist(&self, catalog: &str, schema: &str, table: &str) -> Result<bool> {
-        self.catalogs.table_exist(catalog, schema, table).await
-    }
-
-    async fn catalog_names(&self) -> Result<Vec<String>> {
-        self.catalogs.catalog_names().await
-    }
-
-    async fn schema_names(&self, catalog_name: &str) -> Result<Vec<String>> {
-        self.catalogs.schema_names(catalog_name).await
-    }
-
-    async fn table_names(&self, catalog_name: &str, schema_name: &str) -> Result<Vec<String>> {
-        self.catalogs.table_names(catalog_name, schema_name).await
-    }
-
-    async fn register_catalog(self: Arc<Self>, name: String) -> Result<bool> {
-        self.catalogs.clone().register_catalog(name).await
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
+        let catalog = self
+            .catalogs
+            .catalog(catalog_name)?
+            .context(CatalogNotFoundSnafu { catalog_name })?;
+        let schema = catalog
+            .schema(schema_name)?
+            .with_context(|| SchemaNotFoundSnafu {
+                catalog: catalog_name,
+                schema: schema_name,
+            })?;
+        schema.table(table_name).await
     }
 }
 
@@ -597,7 +577,6 @@ mod tests {
                 table_name: "T1".to_string(),
                 table_id: 1,
                 engine: MITO_ENGINE.to_string(),
-                is_deleted: false,
             }),
             Entry::Catalog(CatalogEntry {
                 catalog_name: "C2".to_string(),
@@ -619,7 +598,6 @@ mod tests {
                 table_name: "T2".to_string(),
                 table_id: 2,
                 engine: MITO_ENGINE.to_string(),
-                is_deleted: false,
             }),
         ];
         let res = LocalCatalogManager::sort_entries(vec);

src/catalog/src/local/memory.rs

@@ -16,35 +16,50 @@ use std::any::Any;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicU32, Ordering};
-use std::sync::{Arc, RwLock, Weak};
+use std::sync::{Arc, RwLock};
 
-use common_catalog::consts::{
-    DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, INFORMATION_SCHEMA_NAME, MIN_USER_TABLE_ID,
-};
-use metrics::{decrement_gauge, increment_gauge};
-use snafu::OptionExt;
+use async_trait::async_trait;
+use common_catalog::consts::MIN_USER_TABLE_ID;
+use common_telemetry::error;
+use snafu::{ensure, OptionExt};
 use table::metadata::TableId;
 use table::table::TableIdProvider;
 use table::TableRef;
 
 use crate::error::{
-    CatalogNotFoundSnafu, Result, SchemaNotFoundSnafu, TableExistsSnafu, TableNotFoundSnafu,
+    self, CatalogNotFoundSnafu, Result, SchemaNotFoundSnafu, TableExistsSnafu, TableNotFoundSnafu,
 };
-use crate::information_schema::InformationSchemaProvider;
+use crate::schema::SchemaProvider;
 use crate::{
-    CatalogManager, DeregisterSchemaRequest, DeregisterTableRequest, RegisterSchemaRequest,
-    RegisterSystemTableRequest, RegisterTableRequest, RenameTableRequest,
+    CatalogList, CatalogManager, CatalogProvider, CatalogProviderRef, DeregisterTableRequest,
+    RegisterSchemaRequest, RegisterSystemTableRequest, RegisterTableRequest, RenameTableRequest,
+    SchemaProviderRef,
 };
 
-type SchemaEntries = HashMap<String, HashMap<String, TableRef>>;
-
 /// Simple in-memory list of catalogs
 pub struct MemoryCatalogManager {
     /// Collection of catalogs containing schemas and ultimately Tables
-    pub catalogs: RwLock<HashMap<String, SchemaEntries>>,
+    pub catalogs: RwLock<HashMap<String, CatalogProviderRef>>,
     pub table_id: AtomicU32,
 }
 
+impl Default for MemoryCatalogManager {
+    fn default() -> Self {
+        let manager = Self {
+            table_id: AtomicU32::new(MIN_USER_TABLE_ID),
+            catalogs: Default::default(),
+        };
+        let default_catalog = Arc::new(MemoryCatalogProvider::new());
+        manager
+            .register_catalog("greptime".to_string(), default_catalog.clone())
+            .unwrap();
+        default_catalog
+            .register_schema("public".to_string(), Arc::new(MemorySchemaProvider::new()))
+            .unwrap();
+        manager
+    }
+}
+
 #[async_trait::async_trait]
 impl TableIdProvider for MemoryCatalogManager {
     async fn next_table_id(&self) -> table::error::Result<TableId> {
@@ -60,75 +75,70 @@ impl CatalogManager for MemoryCatalogManager {
     }
 
     async fn register_table(&self, request: RegisterTableRequest) -> Result<bool> {
-        self.register_table_sync(request)
+        let catalogs = self.catalogs.write().unwrap();
+        let catalog = catalogs
+            .get(&request.catalog)
+            .context(CatalogNotFoundSnafu {
+                catalog_name: &request.catalog,
+            })?
+            .clone();
+        let schema = catalog
+            .schema(&request.schema)?
+            .with_context(|| SchemaNotFoundSnafu {
+                catalog: &request.catalog,
+                schema: &request.schema,
+            })?;
+        schema
+            .register_table(request.table_name, request.table)
+            .map(|v| v.is_none())
     }
 
     async fn rename_table(&self, request: RenameTableRequest) -> Result<bool> {
-        let mut catalogs = self.catalogs.write().unwrap();
-        let schema = catalogs
-            .get_mut(&request.catalog)
-            .with_context(|| CatalogNotFoundSnafu {
+        let catalogs = self.catalogs.write().unwrap();
+        let catalog = catalogs
+            .get(&request.catalog)
+            .context(CatalogNotFoundSnafu {
                 catalog_name: &request.catalog,
             })?
-            .get_mut(&request.schema)
+            .clone();
+        let schema = catalog
+            .schema(&request.schema)?
             .with_context(|| SchemaNotFoundSnafu {
                 catalog: &request.catalog,
                 schema: &request.schema,
             })?;
-
-        // check old and new table names
-        if !schema.contains_key(&request.table_name) {
-            return TableNotFoundSnafu {
-                table_info: request.table_name.to_string(),
-            }
-            .fail()?;
-        }
-        if schema.contains_key(&request.new_table_name) {
-            return TableExistsSnafu {
-                table: &request.new_table_name,
-            }
-            .fail();
-        }
-
-        let table = schema.remove(&request.table_name).unwrap();
-        let _ = schema.insert(request.new_table_name, table);
-
-        Ok(true)
+        Ok(schema
+            .rename_table(&request.table_name, request.new_table_name)
+            .is_ok())
     }
 
-    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<()> {
-        self.deregister_table_sync(request)
+    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<bool> {
+        let catalogs = self.catalogs.write().unwrap();
+        let catalog = catalogs
+            .get(&request.catalog)
+            .context(CatalogNotFoundSnafu {
+                catalog_name: &request.catalog,
+            })?
+            .clone();
+        let schema = catalog
+            .schema(&request.schema)?
+            .with_context(|| SchemaNotFoundSnafu {
+                catalog: &request.catalog,
+                schema: &request.schema,
+            })?;
+        schema
+            .deregister_table(&request.table_name)
+            .map(|v| v.is_some())
     }
 
     async fn register_schema(&self, request: RegisterSchemaRequest) -> Result<bool> {
-        self.register_schema_sync(request)
-    }
-
-    async fn deregister_schema(&self, request: DeregisterSchemaRequest) -> Result<bool> {
-        let mut catalogs = self.catalogs.write().unwrap();
-        let schemas = catalogs
-            .get_mut(&request.catalog)
-            .with_context(|| CatalogNotFoundSnafu {
+        let catalogs = self.catalogs.write().unwrap();
+        let catalog = catalogs
+            .get(&request.catalog)
+            .context(CatalogNotFoundSnafu {
                 catalog_name: &request.catalog,
             })?;
-        let table_count = schemas
-            .remove(&request.schema)
-            .with_context(|| SchemaNotFoundSnafu {
-                catalog: &request.catalog,
-                schema: &request.schema,
-            })?
-            .len();
-        decrement_gauge!(
-            crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-            table_count as f64,
-            &[crate::metrics::db_label(&request.catalog, &request.schema)],
-        );
-
-        decrement_gauge!(
-            crate::metrics::METRIC_CATALOG_MANAGER_SCHEMA_COUNT,
-            1.0,
-            &[crate::metrics::db_label(&request.catalog, &request.schema)],
-        );
+        catalog.register_schema(request.schema, Arc::new(MemorySchemaProvider::new()))?;
         Ok(true)
     }
 
@@ -137,8 +147,13 @@ impl CatalogManager for MemoryCatalogManager {
         Ok(())
     }
 
-    async fn schema_exist(&self, catalog: &str, schema: &str) -> Result<bool> {
-        self.schema_exist_sync(catalog, schema)
+    fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>> {
+        let catalogs = self.catalogs.read().unwrap();
+        if let Some(c) = catalogs.get(catalog) {
+            c.schema(schema)
+        } else {
+            Ok(None)
+        }
     }
 
     async fn table(
@@ -147,359 +162,296 @@ impl CatalogManager for MemoryCatalogManager {
         schema: &str,
         table_name: &str,
     ) -> Result<Option<TableRef>> {
-        let result = try {
-            self.catalogs
-                .read()
-                .unwrap()
-                .get(catalog)?
-                .get(schema)?
-                .get(table_name)
-                .cloned()?
+        let catalog = {
+            let c = self.catalogs.read().unwrap();
+            let Some(c) = c.get(catalog) else { return Ok(None) };
+            c.clone()
         };
-        Ok(result)
-    }
-
-    async fn catalog_exist(&self, catalog: &str) -> Result<bool> {
-        self.catalog_exist_sync(catalog)
-    }
-
-    async fn table_exist(&self, catalog: &str, schema: &str, table: &str) -> Result<bool> {
-        let catalogs = self.catalogs.read().unwrap();
-        Ok(catalogs
-            .get(catalog)
-            .with_context(|| CatalogNotFoundSnafu {
-                catalog_name: catalog,
-            })?
-            .get(schema)
-            .with_context(|| SchemaNotFoundSnafu { catalog, schema })?
-            .contains_key(table))
-    }
-
-    async fn catalog_names(&self) -> Result<Vec<String>> {
-        Ok(self.catalogs.read().unwrap().keys().cloned().collect())
-    }
-
-    async fn schema_names(&self, catalog_name: &str) -> Result<Vec<String>> {
-        Ok(self
-            .catalogs
-            .read()
-            .unwrap()
-            .get(catalog_name)
-            .with_context(|| CatalogNotFoundSnafu { catalog_name })?
-            .keys()
-            .cloned()
-            .collect())
-    }
-
-    async fn table_names(&self, catalog_name: &str, schema_name: &str) -> Result<Vec<String>> {
-        Ok(self
-            .catalogs
-            .read()
-            .unwrap()
-            .get(catalog_name)
-            .with_context(|| CatalogNotFoundSnafu { catalog_name })?
-            .get(schema_name)
-            .with_context(|| SchemaNotFoundSnafu {
-                catalog: catalog_name,
-                schema: schema_name,
-            })?
-            .keys()
-            .cloned()
-            .collect())
-    }
-
-    async fn register_catalog(self: Arc<Self>, name: String) -> Result<bool> {
-        self.register_catalog_sync(name)
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
+        match catalog.schema(schema)? {
+            None => Ok(None),
+            Some(s) => s.table(table_name).await,
+        }
     }
 }
 
 impl MemoryCatalogManager {
-    /// Creates a manager with some default setups
-    /// (e.g. default catalog/schema and information schema)
-    pub fn with_default_setup() -> Arc<Self> {
-        let manager = Arc::new(Self {
-            table_id: AtomicU32::new(MIN_USER_TABLE_ID),
-            catalogs: Default::default(),
-        });
-
-        // Safety: default catalog/schema is registered in order so no CatalogNotFound error will occur
-        manager
-            .register_catalog_sync(DEFAULT_CATALOG_NAME.to_string())
-            .unwrap();
-        manager
-            .register_schema_sync(RegisterSchemaRequest {
-                catalog: DEFAULT_CATALOG_NAME.to_string(),
-                schema: DEFAULT_SCHEMA_NAME.to_string(),
-            })
-            .unwrap();
-
-        manager
-    }
-
-    fn schema_exist_sync(&self, catalog: &str, schema: &str) -> Result<bool> {
-        Ok(self
-            .catalogs
-            .read()
-            .unwrap()
-            .get(catalog)
-            .with_context(|| CatalogNotFoundSnafu {
-                catalog_name: catalog,
-            })?
-            .contains_key(schema))
-    }
-
-    fn catalog_exist_sync(&self, catalog: &str) -> Result<bool> {
-        Ok(self.catalogs.read().unwrap().get(catalog).is_some())
-    }
-
-    /// Registers a catalog if it does not exist and returns false if the schema exists.
-    pub fn register_catalog_sync(self: &Arc<Self>, name: String) -> Result<bool> {
+    /// Registers a catalog and return `None` if no catalog with the same name was already
+    /// registered, or `Some` with the previously registered catalog.
+    pub fn register_catalog_if_absent(
+        &self,
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Option<CatalogProviderRef> {
         let mut catalogs = self.catalogs.write().unwrap();
-
-        match catalogs.entry(name.clone()) {
-            Entry::Vacant(e) => {
-                let catalog = self.create_catalog_entry(name);
-                e.insert(catalog);
-                increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_CATALOG_COUNT, 1.0);
-                Ok(true)
+        let entry = catalogs.entry(name);
+        match entry {
+            Entry::Occupied(v) => Some(v.get().clone()),
+            Entry::Vacant(v) => {
+                v.insert(catalog);
+                None
             }
-            Entry::Occupied(_) => Ok(false),
         }
     }
+}
 
-    pub fn deregister_table_sync(&self, request: DeregisterTableRequest) -> Result<()> {
-        let mut catalogs = self.catalogs.write().unwrap();
-        let schema = catalogs
-            .get_mut(&request.catalog)
-            .with_context(|| CatalogNotFoundSnafu {
-                catalog_name: &request.catalog,
-            })?
-            .get_mut(&request.schema)
-            .with_context(|| SchemaNotFoundSnafu {
-                catalog: &request.catalog,
-                schema: &request.schema,
-            })?;
-        let result = schema.remove(&request.table_name);
-        if result.is_some() {
-            decrement_gauge!(
-                crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-                1.0,
-                &[crate::metrics::db_label(&request.catalog, &request.schema)],
-            );
-        }
-        Ok(())
+impl CatalogList for MemoryCatalogManager {
+    fn as_any(&self) -> &dyn Any {
+        self
     }
 
-    /// Registers a schema if it does not exist.
-    /// It returns an error if the catalog does not exist,
-    /// and returns false if the schema exists.
-    pub fn register_schema_sync(&self, request: RegisterSchemaRequest) -> Result<bool> {
+    fn register_catalog(
+        &self,
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Result<Option<CatalogProviderRef>> {
         let mut catalogs = self.catalogs.write().unwrap();
-        let catalog = catalogs
-            .get_mut(&request.catalog)
-            .with_context(|| CatalogNotFoundSnafu {
-                catalog_name: &request.catalog,
-            })?;
-
-        match catalog.entry(request.schema) {
-            Entry::Vacant(e) => {
-                e.insert(HashMap::new());
-                increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_SCHEMA_COUNT, 1.0);
-                Ok(true)
-            }
-            Entry::Occupied(_) => Ok(false),
-        }
+        Ok(catalogs.insert(name, catalog))
     }
 
-    /// Registers a schema and returns an error if the catalog or schema does not exist.
-    pub fn register_table_sync(&self, request: RegisterTableRequest) -> Result<bool> {
-        let mut catalogs = self.catalogs.write().unwrap();
-        let schema = catalogs
-            .get_mut(&request.catalog)
-            .with_context(|| CatalogNotFoundSnafu {
-                catalog_name: &request.catalog,
-            })?
-            .get_mut(&request.schema)
-            .with_context(|| SchemaNotFoundSnafu {
-                catalog: &request.catalog,
-                schema: &request.schema,
-            })?;
+    fn catalog_names(&self) -> Result<Vec<String>> {
+        let catalogs = self.catalogs.read().unwrap();
+        Ok(catalogs.keys().map(|s| s.to_string()).collect())
+    }
 
-        if schema.contains_key(&request.table_name) {
-            return TableExistsSnafu {
-                table: &request.table_name,
-            }
-            .fail();
+    fn catalog(&self, name: &str) -> Result<Option<CatalogProviderRef>> {
+        let catalogs = self.catalogs.read().unwrap();
+        Ok(catalogs.get(name).cloned())
+    }
+}
+
+impl Default for MemoryCatalogProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Simple in-memory implementation of a catalog.
+pub struct MemoryCatalogProvider {
+    schemas: RwLock<HashMap<String, Arc<dyn SchemaProvider>>>,
+}
+
+impl MemoryCatalogProvider {
+    /// Instantiates a new MemoryCatalogProvider with an empty collection of schemas.
+    pub fn new() -> Self {
+        Self {
+            schemas: RwLock::new(HashMap::new()),
         }
-        schema.insert(request.table_name, request.table);
-        increment_gauge!(
-            crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-            1.0,
-            &[crate::metrics::db_label(&request.catalog, &request.schema)],
+    }
+}
+
+impl CatalogProvider for MemoryCatalogProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema_names(&self) -> Result<Vec<String>> {
+        let schemas = self.schemas.read().unwrap();
+        Ok(schemas.keys().cloned().collect())
+    }
+
+    fn register_schema(
+        &self,
+        name: String,
+        schema: SchemaProviderRef,
+    ) -> Result<Option<SchemaProviderRef>> {
+        let mut schemas = self.schemas.write().unwrap();
+        ensure!(
+            !schemas.contains_key(&name),
+            error::SchemaExistsSnafu { schema: &name }
         );
-        Ok(true)
+        Ok(schemas.insert(name, schema))
     }
 
-    fn create_catalog_entry(self: &Arc<Self>, catalog: String) -> SchemaEntries {
-        let information_schema = InformationSchemaProvider::build(
-            catalog,
-            Arc::downgrade(self) as Weak<dyn CatalogManager>,
-        );
-        let mut catalog = HashMap::new();
-        catalog.insert(INFORMATION_SCHEMA_NAME.to_string(), information_schema);
-        catalog
+    fn schema(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>> {
+        let schemas = self.schemas.read().unwrap();
+        Ok(schemas.get(name).cloned())
+    }
+}
+
+/// Simple in-memory implementation of a schema.
+pub struct MemorySchemaProvider {
+    tables: RwLock<HashMap<String, TableRef>>,
+}
+
+impl MemorySchemaProvider {
+    /// Instantiates a new MemorySchemaProvider with an empty collection of tables.
+    pub fn new() -> Self {
+        Self {
+            tables: RwLock::new(HashMap::new()),
+        }
+    }
+}
+
+impl Default for MemorySchemaProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl SchemaProvider for MemorySchemaProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
     }
 
-    #[cfg(any(test, feature = "testing"))]
-    pub fn new_with_table(table: TableRef) -> Arc<Self> {
-        let manager = Self::with_default_setup();
-        let catalog = &table.table_info().catalog_name;
-        let schema = &table.table_info().schema_name;
+    fn table_names(&self) -> Result<Vec<String>> {
+        let tables = self.tables.read().unwrap();
+        Ok(tables.keys().cloned().collect())
+    }
 
-        if !manager.catalog_exist_sync(catalog).unwrap() {
-            manager.register_catalog_sync(catalog.to_string()).unwrap();
+    async fn table(&self, name: &str) -> Result<Option<TableRef>> {
+        let tables = self.tables.read().unwrap();
+        Ok(tables.get(name).cloned())
+    }
+
+    fn register_table(&self, name: String, table: TableRef) -> Result<Option<TableRef>> {
+        let mut tables = self.tables.write().unwrap();
+        if let Some(existing) = tables.get(name.as_str()) {
+            // if table with the same name but different table id exists, then it's a fatal bug
+            if existing.table_info().ident.table_id != table.table_info().ident.table_id {
+                error!(
+                    "Unexpected table register: {:?}, existing: {:?}",
+                    table.table_info(),
+                    existing.table_info()
+                );
+                return TableExistsSnafu { table: name }.fail()?;
+            }
+            Ok(Some(existing.clone()))
+        } else {
+            Ok(tables.insert(name, table))
         }
+    }
 
-        if !manager.schema_exist_sync(catalog, schema).unwrap() {
-            manager
-                .register_schema_sync(RegisterSchemaRequest {
-                    catalog: catalog.to_string(),
-                    schema: schema.to_string(),
-                })
-                .unwrap();
-        }
-
-        let request = RegisterTableRequest {
-            catalog: catalog.to_string(),
-            schema: schema.to_string(),
-            table_name: table.table_info().name.clone(),
-            table_id: table.table_info().ident.table_id,
-            table,
+    fn rename_table(&self, name: &str, new_name: String) -> Result<TableRef> {
+        let mut tables = self.tables.write().unwrap();
+        let Some(table) = tables.remove(name) else {
+            return TableNotFoundSnafu {
+                table_info: name.to_string(),
+            }
+                .fail()?;
         };
-        let _ = manager.register_table_sync(request).unwrap();
-        manager
+        let e = match tables.entry(new_name) {
+            Entry::Vacant(e) => e,
+            Entry::Occupied(e) => {
+                return TableExistsSnafu { table: e.key() }.fail();
+            }
+        };
+        e.insert(table.clone());
+        Ok(table)
+    }
+
+    fn deregister_table(&self, name: &str) -> Result<Option<TableRef>> {
+        let mut tables = self.tables.write().unwrap();
+        Ok(tables.remove(name))
+    }
+
+    fn table_exist(&self, name: &str) -> Result<bool> {
+        let tables = self.tables.read().unwrap();
+        Ok(tables.contains_key(name))
     }
 }
 
 /// Create a memory catalog list contains a numbers table for test
-pub fn new_memory_catalog_manager() -> Result<Arc<MemoryCatalogManager>> {
-    Ok(MemoryCatalogManager::with_default_setup())
+pub fn new_memory_catalog_list() -> Result<Arc<MemoryCatalogManager>> {
+    Ok(Arc::new(MemoryCatalogManager::default()))
 }
 
 #[cfg(test)]
 mod tests {
     use common_catalog::consts::*;
     use common_error::ext::ErrorExt;
-    use common_error::status_code::StatusCode;
-    use table::table::numbers::{NumbersTable, NUMBERS_TABLE_NAME};
+    use common_error::prelude::StatusCode;
+    use table::table::numbers::NumbersTable;
 
     use super::*;
 
     #[tokio::test]
     async fn test_new_memory_catalog_list() {
-        let catalog_list = new_memory_catalog_manager().unwrap();
+        let catalog_list = new_memory_catalog_list().unwrap();
+        let default_catalog = catalog_list.catalog(DEFAULT_CATALOG_NAME).unwrap().unwrap();
 
-        let register_request = RegisterTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: NUMBERS_TABLE_NAME.to_string(),
-            table_id: NUMBERS_TABLE_ID,
-            table: NumbersTable::table(NUMBERS_TABLE_ID),
-        };
-
-        let _ = catalog_list.register_table(register_request).await.unwrap();
-        let table = catalog_list
-            .table(
-                DEFAULT_CATALOG_NAME,
-                DEFAULT_SCHEMA_NAME,
-                NUMBERS_TABLE_NAME,
-            )
-            .await
-            .unwrap();
-        let _ = table.unwrap();
-        assert!(catalog_list
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, "not_exists")
-            .await
+        let default_schema = default_catalog
+            .schema(DEFAULT_SCHEMA_NAME)
             .unwrap()
-            .is_none());
+            .unwrap();
+
+        default_schema
+            .register_table("numbers".to_string(), Arc::new(NumbersTable::default()))
+            .unwrap();
+
+        let table = default_schema.table("numbers").await.unwrap();
+        assert!(table.is_some());
+        assert!(default_schema.table("not_exists").await.unwrap().is_none());
     }
 
     #[tokio::test]
-    async fn test_mem_manager_rename_table() {
-        let catalog = MemoryCatalogManager::with_default_setup();
-        let table_name = "test_table";
-        assert!(!catalog
-            .table_exist(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap());
+    async fn test_mem_provider() {
+        let provider = MemorySchemaProvider::new();
+        let table_name = "numbers";
+        assert!(!provider.table_exist(table_name).unwrap());
+        assert!(provider.deregister_table(table_name).unwrap().is_none());
+        let test_table = NumbersTable::default();
+        // register table successfully
+        assert!(provider
+            .register_table(table_name.to_string(), Arc::new(test_table))
+            .unwrap()
+            .is_none());
+        assert!(provider.table_exist(table_name).unwrap());
+        let other_table = NumbersTable::new(12);
+        let result = provider.register_table(table_name.to_string(), Arc::new(other_table));
+        let err = result.err().unwrap();
+        assert_eq!(StatusCode::TableAlreadyExists, err.status_code());
+    }
+
+    #[tokio::test]
+    async fn test_mem_provider_rename_table() {
+        let provider = MemorySchemaProvider::new();
+        let table_name = "num";
+        assert!(!provider.table_exist(table_name).unwrap());
+        let test_table: TableRef = Arc::new(NumbersTable::default());
         // register test table
-        let table_id = 2333;
-        let register_request = RegisterTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: table_name.to_string(),
-            table_id,
-            table: NumbersTable::table(table_id),
-        };
-        assert!(catalog.register_table(register_request).await.unwrap());
-        assert!(catalog
-            .table_exist(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap());
+        assert!(provider
+            .register_table(table_name.to_string(), test_table.clone())
+            .unwrap()
+            .is_none());
+        assert!(provider.table_exist(table_name).unwrap());
 
         // rename test table
-        let new_table_name = "test_table_renamed";
-        let rename_request = RenameTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: table_name.to_string(),
-            new_table_name: new_table_name.to_string(),
-            table_id,
-        };
-        let _ = catalog.rename_table(rename_request).await.unwrap();
+        let new_table_name = "numbers";
+        provider
+            .rename_table(table_name, new_table_name.to_string())
+            .unwrap();
 
         // test old table name not exist
-        assert!(!catalog
-            .table_exist(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap());
+        assert!(!provider.table_exist(table_name).unwrap());
+        assert!(provider.deregister_table(table_name).unwrap().is_none());
 
         // test new table name exists
-        assert!(catalog
-            .table_exist(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, new_table_name)
-            .await
-            .unwrap());
-        let registered_table = catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, new_table_name)
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(registered_table.table_info().ident.table_id, table_id);
+        assert!(provider.table_exist(new_table_name).unwrap());
+        let registered_table = provider.table(new_table_name).await.unwrap().unwrap();
+        assert_eq!(
+            registered_table.table_info().ident.table_id,
+            test_table.table_info().ident.table_id
+        );
 
-        let dup_register_request = RegisterTableRequest {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: new_table_name.to_string(),
-            table_id: table_id + 1,
-            table: NumbersTable::table(table_id + 1),
-        };
-        let result = catalog.register_table(dup_register_request).await;
+        let other_table = Arc::new(NumbersTable::new(2));
+        let result = provider.register_table(new_table_name.to_string(), other_table);
         let err = result.err().unwrap();
         assert_eq!(StatusCode::TableAlreadyExists, err.status_code());
     }
 
     #[tokio::test]
     async fn test_catalog_rename_table() {
-        let catalog = MemoryCatalogManager::with_default_setup();
-        let table_name = "num";
-        let table_id = 2333;
-        let table = NumbersTable::table(table_id);
+        let catalog = MemoryCatalogManager::default();
+        let schema = catalog
+            .schema(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME)
+            .unwrap()
+            .unwrap();
 
         // register table
+        let table_name = "num";
+        let table_id = 2333;
+        let table: TableRef = Arc::new(NumbersTable::new(table_id));
         let register_table_req = RegisterTableRequest {
             catalog: DEFAULT_CATALOG_NAME.to_string(),
             schema: DEFAULT_SCHEMA_NAME.to_string(),
@@ -508,11 +460,7 @@ mod tests {
             table,
         };
         assert!(catalog.register_table(register_table_req).await.unwrap());
-        assert!(catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap()
-            .is_some());
+        assert!(schema.table_exist(table_name).unwrap());
 
         // rename table
         let new_table_name = "numbers_new";
@@ -524,16 +472,8 @@ mod tests {
             table_id,
         };
         assert!(catalog.rename_table(rename_table_req).await.unwrap());
-        assert!(catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap()
-            .is_none());
-        assert!(catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, new_table_name)
-            .await
-            .unwrap()
-            .is_some());
+        assert!(!schema.table_exist(table_name).unwrap());
+        assert!(schema.table_exist(new_table_name).unwrap());
 
         let registered_table = catalog
             .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, new_table_name)
@@ -544,87 +484,51 @@ mod tests {
     }
 
     #[test]
-    pub fn test_register_catalog_sync() {
-        let list = MemoryCatalogManager::with_default_setup();
+    pub fn test_register_if_absent() {
+        let list = MemoryCatalogManager::default();
         assert!(list
-            .register_catalog_sync("test_catalog".to_string())
-            .unwrap());
-        assert!(!list
-            .register_catalog_sync("test_catalog".to_string())
-            .unwrap());
+            .register_catalog_if_absent(
+                "test_catalog".to_string(),
+                Arc::new(MemoryCatalogProvider::new())
+            )
+            .is_none());
+        list.register_catalog_if_absent(
+            "test_catalog".to_string(),
+            Arc::new(MemoryCatalogProvider::new()),
+        )
+        .unwrap();
+        list.as_any()
+            .downcast_ref::<MemoryCatalogManager>()
+            .unwrap();
     }
 
     #[tokio::test]
     pub async fn test_catalog_deregister_table() {
-        let catalog = MemoryCatalogManager::with_default_setup();
-        let table_name = "foo_table";
+        let catalog = MemoryCatalogManager::default();
+        let schema = catalog
+            .schema(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME)
+            .unwrap()
+            .unwrap();
 
         let register_table_req = RegisterTableRequest {
             catalog: DEFAULT_CATALOG_NAME.to_string(),
             schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: table_name.to_string(),
+            table_name: "numbers".to_string(),
             table_id: 2333,
-            table: NumbersTable::table(2333),
+            table: Arc::new(NumbersTable::default()),
         };
-        let _ = catalog.register_table(register_table_req).await.unwrap();
-        assert!(catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap()
-            .is_some());
+        catalog.register_table(register_table_req).await.unwrap();
+        assert!(schema.table_exist("numbers").unwrap());
 
         let deregister_table_req = DeregisterTableRequest {
             catalog: DEFAULT_CATALOG_NAME.to_string(),
             schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table_name: table_name.to_string(),
+            table_name: "numbers".to_string(),
         };
         catalog
             .deregister_table(deregister_table_req)
             .await
             .unwrap();
-        assert!(catalog
-            .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, table_name)
-            .await
-            .unwrap()
-            .is_none());
-    }
-
-    #[tokio::test]
-    async fn test_catalog_deregister_schema() {
-        let catalog = MemoryCatalogManager::with_default_setup();
-
-        // Registers a catalog, a schema, and a table.
-        let catalog_name = "foo_catalog".to_string();
-        let schema_name = "foo_schema".to_string();
-        let table_name = "foo_table".to_string();
-        let schema = RegisterSchemaRequest {
-            catalog: catalog_name.clone(),
-            schema: schema_name.clone(),
-        };
-        let table = RegisterTableRequest {
-            catalog: catalog_name.clone(),
-            schema: schema_name.clone(),
-            table_name,
-            table_id: 0,
-            table: NumbersTable::table(0),
-        };
-        catalog
-            .clone()
-            .register_catalog(catalog_name.clone())
-            .await
-            .unwrap();
-        catalog.register_schema(schema).await.unwrap();
-        catalog.register_table(table).await.unwrap();
-
-        let request = DeregisterSchemaRequest {
-            catalog: catalog_name.clone(),
-            schema: schema_name.clone(),
-        };
-
-        assert!(catalog.deregister_schema(request).await.unwrap());
-        assert!(!catalog
-            .schema_exist(&catalog_name, &schema_name)
-            .await
-            .unwrap());
+        assert!(!schema.table_exist("numbers").unwrap());
     }
 }

src/catalog/src/metrics.rs

@@ -1,29 +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 common_catalog::build_db_string;
-
-pub(crate) const METRIC_DB_LABEL: &str = "db";
-
-pub(crate) const METRIC_CATALOG_MANAGER_CATALOG_COUNT: &str = "catalog.catalog_count";
-pub(crate) const METRIC_CATALOG_MANAGER_SCHEMA_COUNT: &str = "catalog.schema_count";
-pub(crate) const METRIC_CATALOG_MANAGER_TABLE_COUNT: &str = "catalog.table_count";
-
-pub(crate) const METRIC_CATALOG_KV_REMOTE_GET: &str = "catalog.kv.get.remote";
-pub(crate) const METRIC_CATALOG_KV_GET: &str = "catalog.kv.get";
-
-#[inline]
-pub(crate) fn db_label(catalog: &str, schema: &str) -> (&'static str, String) {
-    (METRIC_DB_LABEL, build_db_string(catalog, schema))
-}

src/catalog/src/remote.rs

@@ -12,21 +12,120 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::fmt::Debug;
+use std::pin::Pin;
 use std::sync::Arc;
 
-pub use client::{CachedMetaKvBackend, MetaKvBackend};
-pub use manager::RemoteCatalogManager;
+pub use client::MetaKvBackend;
+use futures::Stream;
+use futures_util::StreamExt;
+pub use manager::{RemoteCatalogManager, RemoteCatalogProvider, RemoteSchemaProvider};
+
+use crate::error::Error;
 
 mod client;
 mod manager;
 
-#[cfg(feature = "testing")]
-pub mod mock;
-pub mod region_alive_keeper;
+#[derive(Debug, Clone)]
+pub struct Kv(pub Vec<u8>, pub Vec<u8>);
+
+pub type ValueIter<'a, E> = Pin<Box<dyn Stream<Item = Result<Kv, E>> + Send + 'a>>;
 
 #[async_trait::async_trait]
-pub trait KvCacheInvalidator: Send + Sync {
-    async fn invalidate_key(&self, key: &[u8]);
+pub trait KvBackend: Send + Sync {
+    fn range<'a, 'b>(&'a self, key: &[u8]) -> ValueIter<'b, Error>
+    where
+        'a: 'b;
+
+    async fn set(&self, key: &[u8], val: &[u8]) -> Result<(), Error>;
+
+    /// Compare and set value of key. `expect` is the expected value, if backend's current value associated
+    /// with key is the same as `expect`, the value will be updated to `val`.
+    ///
+    /// - If the compare-and-set operation successfully updated value, this method will return an `Ok(Ok())`
+    /// - If associated value is not the same as `expect`, no value will be updated and an `Ok(Err(Vec<u8>))`
+    /// will be returned, the `Err(Vec<u8>)` indicates the current associated value of key.
+    /// - If any error happens during operation, an `Err(Error)` will be returned.
+    async fn compare_and_set(
+        &self,
+        key: &[u8],
+        expect: &[u8],
+        val: &[u8],
+    ) -> Result<Result<(), Option<Vec<u8>>>, Error>;
+
+    async fn delete_range(&self, key: &[u8], end: &[u8]) -> Result<(), Error>;
+
+    async fn delete(&self, key: &[u8]) -> Result<(), Error> {
+        self.delete_range(key, &[]).await
+    }
+
+    /// Default get is implemented based on `range` method.
+    async fn get(&self, key: &[u8]) -> Result<Option<Kv>, Error> {
+        let mut iter = self.range(key);
+        while let Some(r) = iter.next().await {
+            let kv = r?;
+            if kv.0 == key {
+                return Ok(Some(kv));
+            }
+        }
+        return Ok(None);
+    }
 }
 
-pub type KvCacheInvalidatorRef = Arc<dyn KvCacheInvalidator>;
+pub type KvBackendRef = Arc<dyn KvBackend>;
+
+#[cfg(test)]
+mod tests {
+    use async_stream::stream;
+
+    use super::*;
+
+    struct MockKvBackend {}
+
+    #[async_trait::async_trait]
+    impl KvBackend for MockKvBackend {
+        fn range<'a, 'b>(&'a self, _key: &[u8]) -> ValueIter<'b, Error>
+        where
+            'a: 'b,
+        {
+            Box::pin(stream!({
+                for i in 0..3 {
+                    yield Ok(Kv(
+                        i.to_string().as_bytes().to_vec(),
+                        i.to_string().as_bytes().to_vec(),
+                    ))
+                }
+            }))
+        }
+
+        async fn set(&self, _key: &[u8], _val: &[u8]) -> Result<(), Error> {
+            unimplemented!()
+        }
+
+        async fn compare_and_set(
+            &self,
+            _key: &[u8],
+            _expect: &[u8],
+            _val: &[u8],
+        ) -> Result<Result<(), Option<Vec<u8>>>, Error> {
+            unimplemented!()
+        }
+
+        async fn delete_range(&self, _key: &[u8], _end: &[u8]) -> Result<(), Error> {
+            unimplemented!()
+        }
+    }
+
+    #[tokio::test]
+    async fn test_get() {
+        let backend = MockKvBackend {};
+        let result = backend.get(0.to_string().as_bytes()).await;
+        assert_eq!(0.to_string().as_bytes(), result.unwrap().unwrap().0);
+        let result = backend.get(1.to_string().as_bytes()).await;
+        assert_eq!(1.to_string().as_bytes(), result.unwrap().unwrap().0);
+        let result = backend.get(2.to_string().as_bytes()).await;
+        assert_eq!(2.to_string().as_bytes(), result.unwrap().unwrap().0);
+        let result = backend.get(3.to_string().as_bytes()).await;
+        assert!(result.unwrap().is_none());
+    }
+}

src/catalog/src/remote/client.rs

@@ -12,321 +12,97 @@
 // 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::Arc;
-use std::time::Duration;
 
-use common_error::ext::BoxedError;
-use common_meta::error::Error::{CacheNotGet, GetKvCache};
-use common_meta::error::{CacheNotGetSnafu, Error, MetaSrvSnafu, Result};
-use common_meta::kv_backend::{KvBackend, KvBackendRef, TxnService};
-use common_meta::rpc::store::{
-    BatchDeleteRequest, BatchDeleteResponse, BatchGetRequest, BatchGetResponse, BatchPutRequest,
-    BatchPutResponse, CompareAndPutRequest, CompareAndPutResponse, DeleteRangeRequest,
-    DeleteRangeResponse, MoveValueRequest, MoveValueResponse, PutRequest, PutResponse,
-    RangeRequest, RangeResponse,
-};
-use common_meta::rpc::KeyValue;
-use common_telemetry::timer;
+use async_stream::stream;
+use common_telemetry::info;
 use meta_client::client::MetaClient;
-use moka::future::{Cache, CacheBuilder};
-use snafu::{OptionExt, ResultExt};
-
-use super::KvCacheInvalidator;
-use crate::metrics::{METRIC_CATALOG_KV_GET, METRIC_CATALOG_KV_REMOTE_GET};
-
-const CACHE_MAX_CAPACITY: u64 = 10000;
-const CACHE_TTL_SECOND: u64 = 10 * 60;
-const CACHE_TTI_SECOND: u64 = 5 * 60;
-
-pub type CacheBackendRef = Arc<Cache<Vec<u8>, KeyValue>>;
-
-pub struct CachedMetaKvBackend {
-    kv_backend: KvBackendRef,
-    cache: CacheBackendRef,
-    name: String,
-}
-
-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> {
-        self.kv_backend.batch_get(req).await
-    }
-
-    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 move_value(&self, req: MoveValueRequest) -> Result<MoveValueResponse> {
-        let from_key = &req.from_key.clone();
-        let to_key = &req.to_key.clone();
-
-        let ret = self.kv_backend.move_value(req).await;
-
-        if ret.is_ok() {
-            self.invalidate_key(from_key).await;
-            self.invalidate_key(to_key).await;
-        }
-
-        ret
-    }
-
-    async fn get(&self, key: &[u8]) -> Result<Option<KeyValue>> {
-        let _timer = timer!(METRIC_CATALOG_KV_GET);
-
-        let init = async {
-            let _timer = timer!(METRIC_CATALOG_KV_REMOTE_GET);
-            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
-        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(),
-        })
-    }
-}
-
-#[async_trait::async_trait]
-impl KvCacheInvalidator for CachedMetaKvBackend {
-    async fn invalidate_key(&self, key: &[u8]) {
-        self.cache.invalidate(key).await
-    }
-}
-
-impl CachedMetaKvBackend {
-    pub fn new(client: Arc<MetaClient>) -> Self {
-        let kv_backend = Arc::new(MetaKvBackend { client });
-        Self::wrap(kv_backend)
-    }
-
-    pub fn wrap(kv_backend: KvBackendRef) -> Self {
-        let cache = Arc::new(
-            CacheBuilder::new(CACHE_MAX_CAPACITY)
-                .time_to_live(Duration::from_secs(CACHE_TTL_SECOND))
-                .time_to_idle(Duration::from_secs(CACHE_TTI_SECOND))
-                .build(),
-        );
-
-        let name = format!("CachedKvBackend({})", kv_backend.name());
-        Self {
-            kv_backend,
-            cache,
-            name,
-        }
-    }
-
-    pub fn cache(&self) -> &CacheBackendRef {
-        &self.cache
-    }
-}
+use meta_client::rpc::{CompareAndPutRequest, DeleteRangeRequest, PutRequest, RangeRequest};
+use snafu::ResultExt;
 
+use crate::error::{Error, MetaSrvSnafu};
+use crate::remote::{Kv, KvBackend, ValueIter};
 #[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"
+    fn range<'a, 'b>(&'a self, key: &[u8]) -> ValueIter<'b, Error>
+    where
+        'a: 'b,
+    {
+        let key = key.to_vec();
+        Box::pin(stream!({
+            let mut resp = self
+                .client
+                .range(RangeRequest::new().with_prefix(key))
+                .await
+                .context(MetaSrvSnafu)?;
+            let kvs = resp.take_kvs();
+            for mut kv in kvs.into_iter() {
+                yield Ok(Kv(kv.take_key(), kv.take_value()))
+            }
+        }))
     }
 
-    async fn range(&self, req: RangeRequest) -> Result<RangeResponse> {
-        self.client
-            .range(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(MetaSrvSnafu)
-    }
-
-    async fn get(&self, key: &[u8]) -> Result<Option<KeyValue>> {
+    async fn get(&self, key: &[u8]) -> Result<Option<Kv>, Error> {
         let mut response = self
             .client
             .range(RangeRequest::new().with_key(key))
             .await
-            .map_err(BoxedError::new)
             .context(MetaSrvSnafu)?;
-        Ok(response.take_kvs().get_mut(0).map(|kv| KeyValue {
-            key: kv.take_key(),
-            value: kv.take_value(),
-        }))
+        Ok(response
+            .take_kvs()
+            .get_mut(0)
+            .map(|kv| Kv(kv.take_key(), kv.take_value())))
     }
 
-    async fn batch_put(&self, req: BatchPutRequest) -> Result<BatchPutResponse> {
-        self.client
-            .batch_put(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(MetaSrvSnafu)
+    async fn set(&self, key: &[u8], val: &[u8]) -> Result<(), Error> {
+        let req = PutRequest::new()
+            .with_key(key.to_vec())
+            .with_value(val.to_vec());
+        let _ = self.client.put(req).await.context(MetaSrvSnafu)?;
+        Ok(())
     }
 
-    async fn put(&self, req: PutRequest) -> Result<PutResponse> {
-        self.client
-            .put(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(MetaSrvSnafu)
+    async fn delete_range(&self, key: &[u8], end: &[u8]) -> Result<(), Error> {
+        let req = DeleteRangeRequest::new().with_range(key.to_vec(), end.to_vec());
+        let resp = self.client.delete_range(req).await.context(MetaSrvSnafu)?;
+        info!(
+            "Delete range, key: {}, end: {}, deleted: {}",
+            String::from_utf8_lossy(key),
+            String::from_utf8_lossy(end),
+            resp.deleted()
+        );
+
+        Ok(())
     }
 
-    async fn delete_range(&self, req: DeleteRangeRequest) -> Result<DeleteRangeResponse> {
-        self.client
-            .delete_range(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(MetaSrvSnafu)
-    }
-
-    async fn batch_delete(&self, req: BatchDeleteRequest) -> Result<BatchDeleteResponse> {
-        self.client
-            .batch_delete(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(MetaSrvSnafu)
-    }
-
-    async fn batch_get(&self, req: BatchGetRequest) -> Result<BatchGetResponse> {
-        self.client
-            .batch_get(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(MetaSrvSnafu)
-    }
-
-    async fn compare_and_put(
+    async fn compare_and_set(
         &self,
-        request: CompareAndPutRequest,
-    ) -> Result<CompareAndPutResponse> {
-        self.client
+        key: &[u8],
+        expect: &[u8],
+        val: &[u8],
+    ) -> Result<Result<(), Option<Vec<u8>>>, Error> {
+        let request = CompareAndPutRequest::new()
+            .with_key(key.to_vec())
+            .with_expect(expect.to_vec())
+            .with_value(val.to_vec());
+        let mut response = self
+            .client
             .compare_and_put(request)
             .await
-            .map_err(BoxedError::new)
-            .context(MetaSrvSnafu)
-    }
-
-    async fn move_value(&self, req: MoveValueRequest) -> Result<MoveValueResponse> {
-        self.client
-            .move_value(req)
-            .await
-            .map_err(BoxedError::new)
-            .context(MetaSrvSnafu)
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
+            .context(MetaSrvSnafu)?;
+        if response.is_success() {
+            Ok(Ok(()))
+        } else {
+            Ok(Err(response.take_prev_kv().map(|v| v.value().to_vec())))
+        }
     }
 }

src/catalog/src/remote/mock.rs

@@ -1,128 +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::collections::HashMap;
-use std::sync::{Arc, RwLock as StdRwLock};
-
-use common_recordbatch::RecordBatch;
-use datatypes::data_type::ConcreteDataType;
-use datatypes::schema::{ColumnSchema, Schema};
-use datatypes::vectors::StringVector;
-use table::engine::{CloseTableResult, EngineContext, TableEngine};
-use table::metadata::TableId;
-use table::requests::{
-    AlterTableRequest, CloseTableRequest, CreateTableRequest, DropTableRequest, OpenTableRequest,
-    TruncateTableRequest,
-};
-use table::test_util::MemTable;
-use table::TableRef;
-
-#[derive(Default)]
-pub struct MockTableEngine {
-    tables: StdRwLock<HashMap<TableId, TableRef>>,
-}
-
-#[async_trait::async_trait]
-impl TableEngine for MockTableEngine {
-    fn name(&self) -> &str {
-        "MockTableEngine"
-    }
-
-    /// Create a table with only one column
-    async fn create_table(
-        &self,
-        _ctx: &EngineContext,
-        request: CreateTableRequest,
-    ) -> table::Result<TableRef> {
-        let table_id = request.id;
-
-        let schema = Arc::new(Schema::new(vec![ColumnSchema::new(
-            "name",
-            ConcreteDataType::string_datatype(),
-            true,
-        )]));
-
-        let data = vec![Arc::new(StringVector::from(vec!["a", "b", "c"])) as _];
-        let record_batch = RecordBatch::new(schema, data).unwrap();
-        let table: TableRef = Arc::new(MemTable::new_with_catalog(
-            &request.table_name,
-            record_batch,
-            table_id,
-            request.catalog_name,
-            request.schema_name,
-            vec![0],
-        )) as Arc<_>;
-
-        let mut tables = self.tables.write().unwrap();
-        let _ = tables.insert(table_id, table.clone() as TableRef);
-        Ok(table)
-    }
-
-    async fn open_table(
-        &self,
-        _ctx: &EngineContext,
-        request: OpenTableRequest,
-    ) -> table::Result<Option<TableRef>> {
-        Ok(self.tables.read().unwrap().get(&request.table_id).cloned())
-    }
-
-    async fn alter_table(
-        &self,
-        _ctx: &EngineContext,
-        _request: AlterTableRequest,
-    ) -> table::Result<TableRef> {
-        unimplemented!()
-    }
-
-    fn get_table(
-        &self,
-        _ctx: &EngineContext,
-        table_id: TableId,
-    ) -> table::Result<Option<TableRef>> {
-        Ok(self.tables.read().unwrap().get(&table_id).cloned())
-    }
-
-    fn table_exists(&self, _ctx: &EngineContext, table_id: TableId) -> bool {
-        self.tables.read().unwrap().contains_key(&table_id)
-    }
-
-    async fn drop_table(
-        &self,
-        _ctx: &EngineContext,
-        _request: DropTableRequest,
-    ) -> table::Result<bool> {
-        unimplemented!()
-    }
-
-    async fn close_table(
-        &self,
-        _ctx: &EngineContext,
-        request: CloseTableRequest,
-    ) -> table::Result<CloseTableResult> {
-        let _ = self.tables.write().unwrap().remove(&request.table_id);
-        Ok(CloseTableResult::Released(vec![]))
-    }
-
-    async fn close(&self) -> table::Result<()> {
-        Ok(())
-    }
-
-    async fn truncate_table(
-        &self,
-        _ctx: &EngineContext,
-        _request: TruncateTableRequest,
-    ) -> table::Result<bool> {
-        Ok(true)
-    }
-}

src/catalog/src/remote/region_alive_keeper.rs

@@ -1,867 +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::collections::HashMap;
-use std::future::Future;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use common_meta::error::InvalidProtoMsgSnafu;
-use common_meta::heartbeat::handler::{
-    HandleControl, HeartbeatResponseHandler, HeartbeatResponseHandlerContext,
-};
-use common_meta::ident::TableIdent;
-use common_meta::RegionIdent;
-use common_telemetry::{debug, error, info, warn};
-use snafu::{OptionExt, ResultExt};
-use store_api::storage::RegionNumber;
-use table::engine::manager::TableEngineManagerRef;
-use table::engine::{CloseTableResult, EngineContext, TableEngineRef};
-use table::metadata::TableId;
-use table::requests::CloseTableRequest;
-use table::TableRef;
-use tokio::sync::{mpsc, oneshot, Mutex};
-use tokio::task::JoinHandle;
-use tokio::time::{Duration, Instant};
-
-use crate::error::{Result, TableEngineNotFoundSnafu};
-use crate::local::MemoryCatalogManager;
-use crate::DeregisterTableRequest;
-
-/// [RegionAliveKeepers] manages all [RegionAliveKeeper] in a scope of tables.
-pub struct RegionAliveKeepers {
-    table_engine_manager: TableEngineManagerRef,
-    keepers: Arc<Mutex<HashMap<TableId, Arc<RegionAliveKeeper>>>>,
-    heartbeat_interval_millis: u64,
-    started: AtomicBool,
-
-    /// The epoch when [RegionAliveKeepers] is created. It's used to get a monotonically non-decreasing
-    /// elapsed time when submitting heartbeats to Metasrv (because [Instant] is monotonically
-    /// non-decreasing). The heartbeat request will carry the duration since this epoch, and the
-    /// duration acts like an "invariant point" for region's keep alive lease.
-    epoch: Instant,
-}
-
-impl RegionAliveKeepers {
-    pub fn new(
-        table_engine_manager: TableEngineManagerRef,
-        heartbeat_interval_millis: u64,
-    ) -> Self {
-        Self {
-            table_engine_manager,
-            keepers: Arc::new(Mutex::new(HashMap::new())),
-            heartbeat_interval_millis,
-            started: AtomicBool::new(false),
-            epoch: Instant::now(),
-        }
-    }
-
-    pub async fn find_keeper(&self, table_id: TableId) -> Option<Arc<RegionAliveKeeper>> {
-        self.keepers.lock().await.get(&table_id).cloned()
-    }
-
-    pub async fn register_table(
-        &self,
-        table_ident: TableIdent,
-        table: TableRef,
-        catalog_manager: Arc<MemoryCatalogManager>,
-    ) -> Result<()> {
-        let table_id = table_ident.table_id;
-        let keeper = self.find_keeper(table_id).await;
-        if keeper.is_some() {
-            return Ok(());
-        }
-
-        let table_engine = self
-            .table_engine_manager
-            .engine(&table_ident.engine)
-            .context(TableEngineNotFoundSnafu {
-                engine_name: &table_ident.engine,
-            })?;
-
-        let keeper = Arc::new(RegionAliveKeeper::new(
-            table_engine,
-            catalog_manager,
-            table_ident.clone(),
-            self.heartbeat_interval_millis,
-        ));
-        for r in table.table_info().meta.region_numbers.iter() {
-            keeper.register_region(*r).await;
-        }
-
-        let mut keepers = self.keepers.lock().await;
-        let _ = keepers.insert(table_id, keeper.clone());
-
-        if self.started.load(Ordering::Relaxed) {
-            keeper.start().await;
-
-            info!("RegionAliveKeeper for table {table_ident} is started!");
-        } else {
-            info!("RegionAliveKeeper for table {table_ident} is registered but not started yet!");
-        }
-        Ok(())
-    }
-
-    pub async fn deregister_table(
-        &self,
-        table_ident: &TableIdent,
-    ) -> Option<Arc<RegionAliveKeeper>> {
-        let table_id = table_ident.table_id;
-        self.keepers.lock().await.remove(&table_id).map(|x| {
-            info!("Deregister RegionAliveKeeper for table {table_ident}");
-            x
-        })
-    }
-
-    pub async fn register_region(&self, region_ident: &RegionIdent) {
-        let table_id = region_ident.table_ident.table_id;
-        let Some(keeper) = self.find_keeper(table_id).await else {
-            // Alive keeper could be affected by lagging msg, just warn and ignore.
-            warn!("Alive keeper for region {region_ident} is not found!");
-            return;
-        };
-        keeper.register_region(region_ident.region_number).await
-    }
-
-    pub async fn deregister_region(&self, region_ident: &RegionIdent) {
-        let table_id = region_ident.table_ident.table_id;
-        let Some(keeper) = self.find_keeper(table_id).await else {
-            // Alive keeper could be affected by lagging msg, just warn and ignore.
-            warn!("Alive keeper for region {region_ident} is not found!");
-            return;
-        };
-        let _ = keeper.deregister_region(region_ident.region_number).await;
-    }
-
-    pub async fn start(&self) {
-        let keepers = self.keepers.lock().await;
-        for keeper in keepers.values() {
-            keeper.start().await;
-        }
-        self.started.store(true, Ordering::Relaxed);
-
-        info!(
-            "RegionAliveKeepers for tables {:?} are started!",
-            keepers.keys().map(|x| x.to_string()).collect::<Vec<_>>(),
-        );
-    }
-
-    pub fn epoch(&self) -> Instant {
-        self.epoch
-    }
-}
-
-#[async_trait]
-impl HeartbeatResponseHandler for RegionAliveKeepers {
-    fn is_acceptable(&self, ctx: &HeartbeatResponseHandlerContext) -> bool {
-        !ctx.response.region_leases.is_empty()
-    }
-
-    async fn handle(
-        &self,
-        ctx: &mut HeartbeatResponseHandlerContext,
-    ) -> common_meta::error::Result<HandleControl> {
-        let leases = ctx.response.region_leases.drain(..).collect::<Vec<_>>();
-        for lease in leases {
-            let table_ident: TableIdent = match lease
-                .table_ident
-                .context(InvalidProtoMsgSnafu {
-                    err_msg: "'table_ident' is missing in RegionLease",
-                })
-                .and_then(|x| x.try_into())
-            {
-                Ok(x) => x,
-                Err(e) => {
-                    error!(e; "");
-                    continue;
-                }
-            };
-
-            let table_id = table_ident.table_id;
-            let Some(keeper) = self.keepers.lock().await.get(&table_id).cloned() else {
-                // Alive keeper could be affected by lagging msg, just warn and ignore.
-                warn!("Alive keeper for table {table_ident} is not found!");
-                continue;
-            };
-
-            let start_instant = self.epoch + Duration::from_millis(lease.duration_since_epoch);
-            let deadline = start_instant + Duration::from_secs(lease.lease_seconds);
-            keeper.keep_lived(lease.regions, deadline).await;
-        }
-        Ok(HandleControl::Continue)
-    }
-}
-
-/// [RegionAliveKeeper] starts a countdown for each region in a table. When deadline is reached,
-/// the region will be closed.
-/// The deadline is controlled by Metasrv. It works like "lease" for regions: a Datanode submits its
-/// opened regions to Metasrv, in heartbeats. If Metasrv decides some region could be resided in this
-/// Datanode, it will "extend" the region's "lease", with a deadline for [RegionAliveKeeper] to
-/// countdown.
-pub struct RegionAliveKeeper {
-    catalog_manager: Arc<MemoryCatalogManager>,
-    table_engine: TableEngineRef,
-    table_ident: TableIdent,
-    countdown_task_handles: Arc<Mutex<HashMap<RegionNumber, Arc<CountdownTaskHandle>>>>,
-    heartbeat_interval_millis: u64,
-    started: AtomicBool,
-}
-
-impl RegionAliveKeeper {
-    fn new(
-        table_engine: TableEngineRef,
-        catalog_manager: Arc<MemoryCatalogManager>,
-        table_ident: TableIdent,
-        heartbeat_interval_millis: u64,
-    ) -> Self {
-        Self {
-            catalog_manager,
-            table_engine,
-            table_ident,
-            countdown_task_handles: Arc::new(Mutex::new(HashMap::new())),
-            heartbeat_interval_millis,
-            started: AtomicBool::new(false),
-        }
-    }
-
-    async fn find_handle(&self, region: &RegionNumber) -> Option<Arc<CountdownTaskHandle>> {
-        self.countdown_task_handles
-            .lock()
-            .await
-            .get(region)
-            .cloned()
-    }
-
-    async fn register_region(&self, region: RegionNumber) {
-        if self.find_handle(&region).await.is_some() {
-            return;
-        }
-
-        let countdown_task_handles = Arc::downgrade(&self.countdown_task_handles);
-        let on_task_finished = async move {
-            if let Some(x) = countdown_task_handles.upgrade() {
-                let _ = x.lock().await.remove(&region);
-            } // Else the countdown task handles map could be dropped because the keeper is dropped.
-        };
-        let catalog_manager = self.catalog_manager.clone();
-        let ident = self.table_ident.clone();
-        let handle = Arc::new(CountdownTaskHandle::new(
-            self.table_engine.clone(),
-            self.table_ident.clone(),
-            region,
-            move |result: Option<CloseTableResult>| {
-                if matches!(result, Some(CloseTableResult::Released(_))) {
-                    let result = catalog_manager.deregister_table_sync(DeregisterTableRequest {
-                        catalog: ident.catalog.to_string(),
-                        schema: ident.schema.to_string(),
-                        table_name: ident.table.to_string(),
-                    });
-
-                    info!(
-                        "Deregister table: {} after countdown task finished, result: {result:?}",
-                        ident.table_id
-                    );
-                } else {
-                    debug!("Countdown task returns: {result:?}");
-                }
-                on_task_finished
-            },
-        ));
-
-        let mut handles = self.countdown_task_handles.lock().await;
-        let _ = handles.insert(region, handle.clone());
-
-        if self.started.load(Ordering::Relaxed) {
-            handle.start(self.heartbeat_interval_millis).await;
-
-            info!(
-                "Region alive countdown for region {region} in table {} is started!",
-                self.table_ident
-            );
-        } else {
-            info!(
-                "Region alive countdown for region {region} in table {} is registered but not started yet!",
-                self.table_ident
-            );
-        }
-    }
-
-    async fn deregister_region(&self, region: RegionNumber) -> Option<Arc<CountdownTaskHandle>> {
-        self.countdown_task_handles
-            .lock()
-            .await
-            .remove(&region)
-            .map(|x| {
-                info!(
-                    "Deregister alive countdown for region {region} in table {}",
-                    self.table_ident
-                );
-                x
-            })
-    }
-
-    async fn start(&self) {
-        let handles = self.countdown_task_handles.lock().await;
-        for handle in handles.values() {
-            handle.start(self.heartbeat_interval_millis).await;
-        }
-
-        self.started.store(true, Ordering::Relaxed);
-        info!(
-            "Region alive countdowns for regions {:?} in table {} are started!",
-            handles.keys().copied().collect::<Vec<_>>(),
-            self.table_ident
-        );
-    }
-
-    async fn keep_lived(&self, designated_regions: Vec<RegionNumber>, deadline: Instant) {
-        for region in designated_regions {
-            if let Some(handle) = self.find_handle(&region).await {
-                handle.reset_deadline(deadline).await;
-            }
-            // Else the region alive keeper might be triggered by lagging messages, we can safely ignore it.
-        }
-    }
-
-    pub async fn deadline(&self, region: RegionNumber) -> Option<Instant> {
-        let mut deadline = None;
-        if let Some(handle) = self.find_handle(&region).await {
-            let (s, r) = oneshot::channel();
-            if handle.tx.send(CountdownCommand::Deadline(s)).await.is_ok() {
-                deadline = r.await.ok()
-            }
-        }
-        deadline
-    }
-
-    pub fn table_ident(&self) -> &TableIdent {
-        &self.table_ident
-    }
-}
-
-#[derive(Debug)]
-enum CountdownCommand {
-    Start(u64),
-    Reset(Instant),
-    Deadline(oneshot::Sender<Instant>),
-}
-
-struct CountdownTaskHandle {
-    tx: mpsc::Sender<CountdownCommand>,
-    handler: JoinHandle<()>,
-    table_ident: TableIdent,
-    region: RegionNumber,
-}
-
-impl CountdownTaskHandle {
-    /// Creates a new [CountdownTaskHandle] and starts the countdown task.
-    /// # Params
-    /// - `on_task_finished`: a callback to be invoked when the task is finished. Note that it will not
-    ///   be invoked if the task is cancelled (by dropping the handle). This is because we want something
-    ///   meaningful to be done when the task is finished, e.g. deregister the handle from the map.
-    ///   While dropping the handle does not necessarily mean the task is finished.
-    fn new<Fut>(
-        table_engine: TableEngineRef,
-        table_ident: TableIdent,
-        region: RegionNumber,
-        on_task_finished: impl FnOnce(Option<CloseTableResult>) -> Fut + Send + 'static,
-    ) -> Self
-    where
-        Fut: Future<Output = ()> + Send,
-    {
-        let (tx, rx) = mpsc::channel(1024);
-
-        let mut countdown_task = CountdownTask {
-            table_engine,
-            table_ident: table_ident.clone(),
-            region,
-            rx,
-        };
-        let handler = common_runtime::spawn_bg(async move {
-            let result = countdown_task.run().await;
-            on_task_finished(result).await;
-        });
-
-        Self {
-            tx,
-            handler,
-            table_ident,
-            region,
-        }
-    }
-
-    async fn start(&self, heartbeat_interval_millis: u64) {
-        if let Err(e) = self
-            .tx
-            .send(CountdownCommand::Start(heartbeat_interval_millis))
-            .await
-        {
-            warn!(
-                "Failed to start region alive keeper countdown: {e}. \
-                Maybe the task is stopped due to region been closed."
-            );
-        }
-    }
-
-    async fn reset_deadline(&self, deadline: Instant) {
-        if let Err(e) = self.tx.send(CountdownCommand::Reset(deadline)).await {
-            warn!(
-                "Failed to reset region alive keeper deadline: {e}. \
-                Maybe the task is stopped due to region been closed."
-            );
-        }
-    }
-}
-
-impl Drop for CountdownTaskHandle {
-    fn drop(&mut self) {
-        debug!(
-            "Aborting region alive countdown task for region {} in table {}",
-            self.region, self.table_ident,
-        );
-        self.handler.abort();
-    }
-}
-
-struct CountdownTask {
-    table_engine: TableEngineRef,
-    table_ident: TableIdent,
-    region: RegionNumber,
-    rx: mpsc::Receiver<CountdownCommand>,
-}
-
-impl CountdownTask {
-    // returns true if
-    async fn run(&mut self) -> Option<CloseTableResult> {
-        // 30 years. See `Instant::far_future`.
-        let far_future = Instant::now() + Duration::from_secs(86400 * 365 * 30);
-
-        // Make sure the alive countdown is not gonna happen before heartbeat task is started (the
-        // "start countdown" command will be sent from heartbeat task).
-        let countdown = tokio::time::sleep_until(far_future);
-        tokio::pin!(countdown);
-
-        let region = &self.region;
-        let table_ident = &self.table_ident;
-        loop {
-            tokio::select! {
-                command = self.rx.recv() => {
-                    match command {
-                        Some(CountdownCommand::Start(heartbeat_interval_millis)) => {
-                            // Set first deadline in 4 heartbeats (roughly after 20 seconds from now if heartbeat
-                            // interval is set to default 5 seconds), to make Datanode and Metasrv more tolerable to
-                            // network or other jitters during startup.
-                            let first_deadline = Instant::now() + Duration::from_millis(heartbeat_interval_millis) * 4;
-                            countdown.set(tokio::time::sleep_until(first_deadline));
-                        },
-                        Some(CountdownCommand::Reset(deadline)) => {
-                            if countdown.deadline() < deadline {
-                                debug!(
-                                    "Reset deadline of region {region} of table {table_ident} to approximately {} seconds later",
-                                    (deadline - Instant::now()).as_secs_f32(),
-                                );
-                                countdown.set(tokio::time::sleep_until(deadline));
-                            }
-                            // Else the countdown could be either:
-                            // - not started yet;
-                            // - during startup protection;
-                            // - received a lagging heartbeat message.
-                            // All can be safely ignored.
-                        },
-                        None => {
-                            info!(
-                                "The handle of countdown task for region {region} of table {table_ident} \
-                                is dropped, RegionAliveKeeper out."
-                            );
-                            break;
-                        },
-                        Some(CountdownCommand::Deadline(tx)) => {
-                            let _ = tx.send(countdown.deadline());
-                        }
-                    }
-                }
-                () = &mut countdown => {
-                    let result = self.close_region().await;
-                    warn!(
-                        "Region {region} of table {table_ident} is closed, result: {result:?}. \
-                        RegionAliveKeeper out.",
-                    );
-                    return Some(result);
-                }
-            }
-        }
-        None
-    }
-
-    async fn close_region(&self) -> CloseTableResult {
-        let ctx = EngineContext::default();
-        let region = self.region;
-        let table_ident = &self.table_ident;
-        loop {
-            let request = CloseTableRequest {
-                catalog_name: table_ident.catalog.clone(),
-                schema_name: table_ident.schema.clone(),
-                table_name: table_ident.table.clone(),
-                table_id: table_ident.table_id,
-                region_numbers: vec![region],
-                flush: true,
-            };
-            match self.table_engine.close_table(&ctx, request).await {
-                Ok(result) => return result,
-                // If region is failed to close, immediately retry. Maybe we should panic instead?
-                Err(e) => error!(e;
-                    "Failed to close region {region} of table {table_ident}. \
-                    For the integrity of data, retry closing and retry without wait.",
-                ),
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::sync::atomic::{AtomicBool, Ordering};
-    use std::sync::Arc;
-
-    use api::v1::meta::{HeartbeatResponse, RegionLease};
-    use common_meta::heartbeat::mailbox::HeartbeatMailbox;
-    use datatypes::schema::RawSchema;
-    use table::engine::manager::MemoryTableEngineManager;
-    use table::engine::TableEngine;
-    use table::requests::{CreateTableRequest, TableOptions};
-    use table::test_util::EmptyTable;
-
-    use super::*;
-    use crate::remote::mock::MockTableEngine;
-
-    async fn prepare_keepers() -> (TableIdent, RegionAliveKeepers) {
-        let table_engine = Arc::new(MockTableEngine::default());
-        let table_engine_manager = Arc::new(MemoryTableEngineManager::new(table_engine));
-        let keepers = RegionAliveKeepers::new(table_engine_manager, 5000);
-
-        let catalog = "my_catalog";
-        let schema = "my_schema";
-        let table = "my_table";
-        let table_ident = TableIdent {
-            catalog: catalog.to_string(),
-            schema: schema.to_string(),
-            table: table.to_string(),
-            table_id: 1,
-            engine: "MockTableEngine".to_string(),
-        };
-        let table = Arc::new(EmptyTable::new(CreateTableRequest {
-            id: 1,
-            catalog_name: catalog.to_string(),
-            schema_name: schema.to_string(),
-            table_name: table.to_string(),
-            desc: None,
-            schema: RawSchema {
-                column_schemas: vec![],
-                timestamp_index: None,
-                version: 0,
-            },
-            region_numbers: vec![1, 2, 3],
-            primary_key_indices: vec![],
-            create_if_not_exists: false,
-            table_options: TableOptions::default(),
-            engine: "MockTableEngine".to_string(),
-        }));
-        let catalog_manager = MemoryCatalogManager::new_with_table(table.clone());
-        keepers
-            .register_table(table_ident.clone(), table, catalog_manager)
-            .await
-            .unwrap();
-        assert!(keepers
-            .keepers
-            .lock()
-            .await
-            .contains_key(&table_ident.table_id));
-
-        (table_ident, keepers)
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_handle_heartbeat_response() {
-        let (table_ident, keepers) = prepare_keepers().await;
-
-        keepers.start().await;
-        let startup_protection_until = Instant::now() + Duration::from_secs(21);
-
-        let duration_since_epoch = (Instant::now() - keepers.epoch).as_millis() as _;
-        let lease_seconds = 100;
-        let response = HeartbeatResponse {
-            region_leases: vec![RegionLease {
-                table_ident: Some(table_ident.clone().into()),
-                regions: vec![1, 3], // Not extending region 2's lease time.
-                duration_since_epoch,
-                lease_seconds,
-            }],
-            ..Default::default()
-        };
-        let keep_alive_until = keepers.epoch
-            + Duration::from_millis(duration_since_epoch)
-            + Duration::from_secs(lease_seconds);
-
-        let (tx, _) = mpsc::channel(8);
-        let mailbox = Arc::new(HeartbeatMailbox::new(tx));
-        let mut ctx = HeartbeatResponseHandlerContext::new(mailbox, response);
-
-        assert!(keepers.handle(&mut ctx).await.unwrap() == HandleControl::Continue);
-
-        // sleep to wait for background task spawned in `handle`
-        tokio::time::sleep(Duration::from_secs(1)).await;
-
-        async fn test(
-            keeper: &Arc<RegionAliveKeeper>,
-            region_number: RegionNumber,
-            startup_protection_until: Instant,
-            keep_alive_until: Instant,
-            is_kept_live: bool,
-        ) {
-            let deadline = keeper.deadline(region_number).await.unwrap();
-            if is_kept_live {
-                assert!(deadline > startup_protection_until && deadline == keep_alive_until);
-            } else {
-                assert!(deadline <= startup_protection_until);
-            }
-        }
-
-        let keeper = &keepers
-            .keepers
-            .lock()
-            .await
-            .get(&table_ident.table_id)
-            .cloned()
-            .unwrap();
-
-        // Test region 1 and 3 is kept lived. Their deadlines are updated to desired instant.
-        test(keeper, 1, startup_protection_until, keep_alive_until, true).await;
-        test(keeper, 3, startup_protection_until, keep_alive_until, true).await;
-
-        // Test region 2 is not kept lived. It's deadline is not updated: still during startup protection period.
-        test(keeper, 2, startup_protection_until, keep_alive_until, false).await;
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_region_alive_keepers() {
-        let (table_ident, keepers) = prepare_keepers().await;
-
-        keepers
-            .register_region(&RegionIdent {
-                cluster_id: 1,
-                datanode_id: 1,
-                table_ident: table_ident.clone(),
-                region_number: 4,
-            })
-            .await;
-
-        keepers.start().await;
-        for keeper in keepers.keepers.lock().await.values() {
-            let regions = {
-                let handles = keeper.countdown_task_handles.lock().await;
-                handles.keys().copied().collect::<Vec<_>>()
-            };
-            for region in regions {
-                // assert countdown tasks are started
-                let deadline = keeper.deadline(region).await.unwrap();
-                assert!(deadline <= Instant::now() + Duration::from_secs(20));
-            }
-        }
-
-        keepers
-            .deregister_region(&RegionIdent {
-                cluster_id: 1,
-                datanode_id: 1,
-                table_ident: table_ident.clone(),
-                region_number: 1,
-            })
-            .await;
-        let mut regions = keepers
-            .find_keeper(table_ident.table_id)
-            .await
-            .unwrap()
-            .countdown_task_handles
-            .lock()
-            .await
-            .keys()
-            .copied()
-            .collect::<Vec<_>>();
-        regions.sort();
-        assert_eq!(regions, vec![2, 3, 4]);
-
-        let keeper = keepers.deregister_table(&table_ident).await.unwrap();
-        assert!(Arc::try_unwrap(keeper).is_ok(), "keeper is not dropped");
-        assert!(keepers.keepers.lock().await.is_empty());
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_region_alive_keeper() {
-        let table_engine = Arc::new(MockTableEngine::default());
-        let table_ident = TableIdent {
-            catalog: "my_catalog".to_string(),
-            schema: "my_schema".to_string(),
-            table: "my_table".to_string(),
-            table_id: 1024,
-            engine: "mito".to_string(),
-        };
-        let catalog_manager = MemoryCatalogManager::with_default_setup();
-        let keeper = RegionAliveKeeper::new(table_engine, catalog_manager, table_ident, 1000);
-
-        let region = 1;
-        assert!(keeper.find_handle(&region).await.is_none());
-        keeper.register_region(region).await;
-        let _ = keeper.find_handle(&region).await.unwrap();
-
-        let ten_seconds_later = || Instant::now() + Duration::from_secs(10);
-
-        keeper.keep_lived(vec![1, 2, 3], ten_seconds_later()).await;
-        assert!(keeper.find_handle(&2).await.is_none());
-        assert!(keeper.find_handle(&3).await.is_none());
-
-        let far_future = Instant::now() + Duration::from_secs(86400 * 365 * 29);
-        // assert if keeper is not started, keep_lived is of no use
-        assert!(keeper.deadline(region).await.unwrap() > far_future);
-
-        keeper.start().await;
-        keeper.keep_lived(vec![1, 2, 3], ten_seconds_later()).await;
-        // assert keep_lived works if keeper is started
-        assert!(keeper.deadline(region).await.unwrap() <= ten_seconds_later());
-
-        let handle = keeper.deregister_region(region).await.unwrap();
-        assert!(Arc::try_unwrap(handle).is_ok(), "handle is not dropped");
-        assert!(keeper.find_handle(&region).await.is_none());
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_countdown_task_handle() {
-        let table_engine = Arc::new(MockTableEngine::default());
-        let table_ident = TableIdent {
-            catalog: "my_catalog".to_string(),
-            schema: "my_schema".to_string(),
-            table: "my_table".to_string(),
-            table_id: 1024,
-            engine: "mito".to_string(),
-        };
-        let finished = Arc::new(AtomicBool::new(false));
-        let finished_clone = finished.clone();
-        let handle = CountdownTaskHandle::new(
-            table_engine.clone(),
-            table_ident.clone(),
-            1,
-            |_| async move { finished_clone.store(true, Ordering::Relaxed) },
-        );
-        let tx = handle.tx.clone();
-
-        // assert countdown task is running
-        tx.send(CountdownCommand::Start(5000)).await.unwrap();
-        assert!(!finished.load(Ordering::Relaxed));
-
-        drop(handle);
-        tokio::time::sleep(Duration::from_secs(1)).await;
-
-        // assert countdown task is stopped
-        assert!(tx
-            .try_send(CountdownCommand::Reset(
-                Instant::now() + Duration::from_secs(10)
-            ))
-            .is_err());
-        // assert `on_task_finished` is not called (because the task is aborted by the handle's drop)
-        assert!(!finished.load(Ordering::Relaxed));
-
-        let finished = Arc::new(AtomicBool::new(false));
-        let finished_clone = finished.clone();
-        let handle = CountdownTaskHandle::new(table_engine, table_ident, 1, |_| async move {
-            finished_clone.store(true, Ordering::Relaxed)
-        });
-        handle.tx.send(CountdownCommand::Start(100)).await.unwrap();
-        tokio::time::sleep(Duration::from_secs(1)).await;
-        // assert `on_task_finished` is called when task is finished normally
-        assert!(finished.load(Ordering::Relaxed));
-    }
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_countdown_task_run() {
-        let ctx = &EngineContext::default();
-        let catalog = "my_catalog";
-        let schema = "my_schema";
-        let table = "my_table";
-        let table_id = 1;
-        let request = CreateTableRequest {
-            id: table_id,
-            catalog_name: catalog.to_string(),
-            schema_name: schema.to_string(),
-            table_name: table.to_string(),
-            desc: None,
-            schema: RawSchema {
-                column_schemas: vec![],
-                timestamp_index: None,
-                version: 0,
-            },
-            region_numbers: vec![],
-            primary_key_indices: vec![],
-            create_if_not_exists: false,
-            table_options: TableOptions::default(),
-            engine: "mito".to_string(),
-        };
-
-        let table_engine = Arc::new(MockTableEngine::default());
-        let _ = table_engine.create_table(ctx, request).await.unwrap();
-
-        let table_ident = TableIdent {
-            catalog: catalog.to_string(),
-            schema: schema.to_string(),
-            table: table.to_string(),
-            table_id,
-            engine: "mito".to_string(),
-        };
-        let (tx, rx) = mpsc::channel(10);
-        let mut task = CountdownTask {
-            table_engine: table_engine.clone(),
-            table_ident,
-            region: 1,
-            rx,
-        };
-        let _handle = common_runtime::spawn_bg(async move {
-            task.run().await;
-        });
-
-        async fn deadline(tx: &mpsc::Sender<CountdownCommand>) -> Instant {
-            let (s, r) = oneshot::channel();
-            tx.send(CountdownCommand::Deadline(s)).await.unwrap();
-            r.await.unwrap()
-        }
-
-        // if countdown task is not started, its deadline is set to far future
-        assert!(deadline(&tx).await > Instant::now() + Duration::from_secs(86400 * 365 * 29));
-
-        // start countdown in 250ms * 4 = 1s
-        tx.send(CountdownCommand::Start(250)).await.unwrap();
-        // assert deadline is correctly set
-        assert!(deadline(&tx).await <= Instant::now() + Duration::from_secs(1));
-
-        // reset countdown in 1.5s
-        tx.send(CountdownCommand::Reset(
-            Instant::now() + Duration::from_millis(1500),
-        ))
-        .await
-        .unwrap();
-
-        // assert the table is closed after deadline is reached
-        assert!(table_engine.table_exists(ctx, table_id));
-        // spare 500ms for the task to close the table
-        tokio::time::sleep(Duration::from_millis(2000)).await;
-        assert!(!table_engine.table_exists(ctx, table_id));
-    }
-}

src/catalog/src/schema.rs

@@ -0,0 +1,69 @@
+// 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::sync::Arc;
+
+use async_trait::async_trait;
+use table::TableRef;
+
+use crate::error::{NotSupportedSnafu, Result};
+
+/// Represents a schema, comprising a number of named tables.
+#[async_trait]
+pub trait SchemaProvider: Sync + Send {
+    /// Returns the schema provider as [`Any`](std::any::Any)
+    /// so that it can be downcast to a specific implementation.
+    fn as_any(&self) -> &dyn Any;
+
+    /// Retrieves the list of available table names in this schema.
+    fn table_names(&self) -> Result<Vec<String>>;
+
+    /// Retrieves a specific table from the schema by name, provided it exists.
+    async fn table(&self, name: &str) -> Result<Option<TableRef>>;
+
+    /// If supported by the implementation, adds a new table to this schema.
+    /// If a table of the same name existed before, it returns "Table already exists" error.
+    fn register_table(&self, name: String, _table: TableRef) -> Result<Option<TableRef>> {
+        NotSupportedSnafu {
+            op: format!("register_table({name}, <table>)"),
+        }
+        .fail()
+    }
+
+    /// If supported by the implementation, renames an existing table from this schema and returns it.
+    /// If no table of that name exists, returns "Table not found" error.
+    fn rename_table(&self, name: &str, new_name: String) -> Result<TableRef> {
+        NotSupportedSnafu {
+            op: format!("rename_table({name}, {new_name})"),
+        }
+        .fail()
+    }
+
+    /// If supported by the implementation, removes an existing table from this schema and returns it.
+    /// If no table of that name exists, returns Ok(None).
+    fn deregister_table(&self, name: &str) -> Result<Option<TableRef>> {
+        NotSupportedSnafu {
+            op: format!("deregister_table({name})"),
+        }
+        .fail()
+    }
+
+    /// If supported by the implementation, checks the table exist in the schema provider or not.
+    /// If no matched table in the schema provider, return false.
+    /// Otherwise, return true.
+    fn table_exist(&self, name: &str) -> Result<bool>;
+}
+
+pub type SchemaProviderRef = Arc<dyn SchemaProvider>;

src/catalog/src/system.rs

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::any::Any;
 use std::collections::HashMap;
 use std::sync::Arc;
 
@@ -19,24 +20,26 @@ use common_catalog::consts::{
     DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, INFORMATION_SCHEMA_NAME, MITO_ENGINE,
     SYSTEM_CATALOG_NAME, SYSTEM_CATALOG_TABLE_ID, SYSTEM_CATALOG_TABLE_NAME,
 };
+use common_query::logical_plan::Expr;
+use common_query::physical_plan::{PhysicalPlanRef, SessionContext};
 use common_recordbatch::SendableRecordBatchStream;
-use common_telemetry::{debug, warn};
+use common_telemetry::debug;
 use common_time::util;
 use datatypes::prelude::{ConcreteDataType, ScalarVector, VectorRef};
-use datatypes::schema::{ColumnSchema, RawSchema};
+use datatypes::schema::{ColumnSchema, RawSchema, SchemaRef};
 use datatypes::vectors::{BinaryVector, TimestampMillisecondVector, UInt8Vector};
 use serde::{Deserialize, Serialize};
 use snafu::{ensure, OptionExt, ResultExt};
-use store_api::storage::ScanRequest;
 use table::engine::{EngineContext, TableEngineRef};
-use table::metadata::TableId;
-use table::requests::{CreateTableRequest, InsertRequest, OpenTableRequest, TableOptions};
-use table::TableRef;
+use table::metadata::{TableId, TableInfoRef};
+use table::requests::{
+    CreateTableRequest, DeleteRequest, InsertRequest, OpenTableRequest, TableOptions,
+};
+use table::{Table, TableRef};
 
 use crate::error::{
-    self, CreateSystemCatalogSnafu, DeregisterTableSnafu, EmptyValueSnafu, Error,
-    InsertCatalogRecordSnafu, InvalidEntryTypeSnafu, InvalidKeySnafu, OpenSystemCatalogSnafu,
-    Result, ValueDeserializeSnafu,
+    self, CreateSystemCatalogSnafu, EmptyValueSnafu, Error, InvalidEntryTypeSnafu, InvalidKeySnafu,
+    OpenSystemCatalogSnafu, Result, ValueDeserializeSnafu,
 };
 use crate::DeregisterTableRequest;
 
@@ -46,6 +49,39 @@ pub const VALUE_INDEX: usize = 3;
 
 pub struct SystemCatalogTable(TableRef);
 
+#[async_trait::async_trait]
+impl Table for SystemCatalogTable {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema(&self) -> SchemaRef {
+        self.0.schema()
+    }
+
+    async fn scan(
+        &self,
+        projection: Option<&Vec<usize>>,
+        filters: &[Expr],
+        limit: Option<usize>,
+    ) -> table::Result<PhysicalPlanRef> {
+        self.0.scan(projection, filters, limit).await
+    }
+
+    /// Insert values into table.
+    async fn insert(&self, request: InsertRequest) -> table::error::Result<usize> {
+        self.0.insert(request).await
+    }
+
+    fn table_info(&self) -> TableInfoRef {
+        self.0.table_info()
+    }
+
+    async fn delete(&self, request: DeleteRequest) -> table::Result<usize> {
+        self.0.delete(request).await
+    }
+}
+
 impl SystemCatalogTable {
     pub async fn new(engine: TableEngineRef) -> Result<Self> {
         let request = OpenTableRequest {
@@ -53,7 +89,6 @@ impl SystemCatalogTable {
             schema_name: INFORMATION_SCHEMA_NAME.to_string(),
             table_name: SYSTEM_CATALOG_TABLE_NAME.to_string(),
             table_id: SYSTEM_CATALOG_TABLE_ID,
-            region_numbers: vec![0],
         };
         let schema = build_system_catalog_schema();
         let ctx = EngineContext::default();
@@ -88,75 +123,19 @@ impl SystemCatalogTable {
         }
     }
 
-    pub async fn register_table(
-        &self,
-        catalog: String,
-        schema: String,
-        table_name: String,
-        table_id: TableId,
-        engine: String,
-    ) -> Result<usize> {
-        let insert_request =
-            build_table_insert_request(catalog, schema, table_name, table_id, engine);
-        self.0
-            .insert(insert_request)
-            .await
-            .context(InsertCatalogRecordSnafu)
-    }
-
-    pub(crate) async fn deregister_table(
-        &self,
-        request: &DeregisterTableRequest,
-        table_id: TableId,
-    ) -> Result<()> {
-        let deletion_request = build_table_deletion_request(request, table_id);
-        self.0
-            .insert(deletion_request)
-            .await
-            .map(|x| {
-                if x != 1 {
-                    let table = common_catalog::format_full_table_name(
-                        &request.catalog,
-                        &request.schema,
-                        &request.table_name
-                    );
-                    warn!("Failed to delete table record from information_schema, unexpected returned result: {x}, table: {table}");
-                }
-            })
-            .with_context(|_| DeregisterTableSnafu {
-                request: request.clone(),
-            })
-    }
-
-    pub async fn register_schema(&self, catalog: String, schema: String) -> Result<usize> {
-        let insert_request = build_schema_insert_request(catalog, schema);
-        self.0
-            .insert(insert_request)
-            .await
-            .context(InsertCatalogRecordSnafu)
-    }
-
     /// Create a stream of all entries inside system catalog table
     pub async fn records(&self) -> Result<SendableRecordBatchStream> {
         let full_projection = None;
-        let scan_req = ScanRequest {
-            sequence: None,
-            projection: full_projection,
-            filters: vec![],
-            output_ordering: None,
-            limit: None,
-        };
-        let stream = self
-            .0
-            .scan_to_stream(scan_req)
+        let ctx = SessionContext::new();
+        let scan = self
+            .scan(full_projection, &[], None)
             .await
             .context(error::SystemCatalogTableScanSnafu)?;
+        let stream = scan
+            .execute(0, ctx.task_ctx())
+            .context(error::SystemCatalogTableScanExecSnafu)?;
         Ok(stream)
     }
-
-    pub fn as_table_ref(&self) -> TableRef {
-        self.0.clone()
-    }
 }
 
 /// Build system catalog table schema.
@@ -222,50 +201,38 @@ pub fn build_table_insert_request(
     build_insert_request(
         EntryType::Table,
         entry_key.as_bytes(),
-        serde_json::to_string(&TableEntryValue {
-            table_name,
-            engine,
-            is_deleted: false,
-        })
-        .unwrap()
-        .as_bytes(),
+        serde_json::to_string(&TableEntryValue { table_name, engine })
+            .unwrap()
+            .as_bytes(),
     )
 }
 
 pub(crate) fn build_table_deletion_request(
     request: &DeregisterTableRequest,
     table_id: TableId,
-) -> InsertRequest {
-    let entry_key = format_table_entry_key(&request.catalog, &request.schema, table_id);
-    build_insert_request(
-        EntryType::Table,
-        entry_key.as_bytes(),
-        serde_json::to_string(&TableEntryValue {
-            table_name: "".to_string(),
-            engine: "".to_string(),
-            is_deleted: true,
-        })
-        .unwrap()
-        .as_bytes(),
-    )
+) -> DeleteRequest {
+    let table_key = format_table_entry_key(&request.catalog, &request.schema, table_id);
+    DeleteRequest {
+        key_column_values: build_primary_key_columns(EntryType::Table, table_key.as_bytes()),
+    }
 }
 
 fn build_primary_key_columns(entry_type: EntryType, key: &[u8]) -> HashMap<String, VectorRef> {
-    HashMap::from([
-        (
-            "entry_type".to_string(),
-            Arc::new(UInt8Vector::from_slice([entry_type as u8])) as VectorRef,
-        ),
-        (
-            "key".to_string(),
-            Arc::new(BinaryVector::from_slice(&[key])) as VectorRef,
-        ),
-        (
-            "timestamp".to_string(),
-            // Timestamp in key part is intentionally left to 0
-            Arc::new(TimestampMillisecondVector::from_slice([0])) as VectorRef,
-        ),
-    ])
+    let mut m = HashMap::with_capacity(3);
+    m.insert(
+        "entry_type".to_string(),
+        Arc::new(UInt8Vector::from_slice([entry_type as u8])) as _,
+    );
+    m.insert(
+        "key".to_string(),
+        Arc::new(BinaryVector::from_slice(&[key])) as _,
+    );
+    // Timestamp in key part is intentionally left to 0
+    m.insert(
+        "timestamp".to_string(),
+        Arc::new(TimestampMillisecondVector::from_slice([0])) as _,
+    );
+    m
 }
 
 pub fn build_schema_insert_request(catalog_name: String, schema_name: String) -> InsertRequest {
@@ -283,20 +250,20 @@ pub fn build_insert_request(entry_type: EntryType, key: &[u8], value: &[u8]) ->
     let primary_key_columns = build_primary_key_columns(entry_type, key);
 
     let mut columns_values = HashMap::with_capacity(6);
-    columns_values.extend(primary_key_columns);
+    columns_values.extend(primary_key_columns.into_iter());
 
-    let _ = columns_values.insert(
+    columns_values.insert(
         "value".to_string(),
         Arc::new(BinaryVector::from_slice(&[value])) as _,
     );
 
     let now = util::current_time_millis();
-    let _ = columns_values.insert(
+    columns_values.insert(
         "gmt_created".to_string(),
         Arc::new(TimestampMillisecondVector::from_slice([now])) as _,
     );
 
-    let _ = columns_values.insert(
+    columns_values.insert(
         "gmt_modified".to_string(),
         Arc::new(TimestampMillisecondVector::from_slice([now])) as _,
     );
@@ -366,7 +333,6 @@ pub fn decode_system_catalog(
                 table_name: table_meta.table_name,
                 table_id,
                 engine: table_meta.engine,
-                is_deleted: table_meta.is_deleted,
             }))
         }
     }
@@ -423,7 +389,6 @@ pub struct TableEntry {
     pub table_name: String,
     pub table_id: TableId,
     pub engine: String,
-    pub is_deleted: bool,
 }
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
@@ -432,19 +397,12 @@ pub struct TableEntryValue {
 
     #[serde(default = "mito_engine")]
     pub engine: String,
-
-    #[serde(default = "not_deleted")]
-    pub is_deleted: bool,
 }
 
 fn mito_engine() -> String {
     MITO_ENGINE.to_string()
 }
 
-fn not_deleted() -> bool {
-    false
-}
-
 #[cfg(test)]
 mod tests {
     use common_recordbatch::RecordBatches;
@@ -514,13 +472,14 @@ mod tests {
     }
 
     #[test]
+    #[should_panic]
     pub fn test_decode_mismatch() {
-        assert!(decode_system_catalog(
+        decode_system_catalog(
             Some(EntryType::Table as u8),
             Some("some_catalog.some_schema.42".as_bytes()),
             None,
         )
-        .is_err());
+        .unwrap();
     }
 
     #[test]
@@ -535,18 +494,17 @@ mod tests {
         let dir = create_temp_dir("system-table-test");
         let store_dir = dir.path().to_string_lossy();
         let mut builder = object_store::services::Fs::default();
-        let _ = builder.root(&store_dir);
+        builder.root(&store_dir);
         let object_store = ObjectStore::new(builder).unwrap().finish();
         let noop_compaction_scheduler = Arc::new(NoopCompactionScheduler::default());
         let table_engine = Arc::new(MitoEngine::new(
             EngineConfig::default(),
             EngineImpl::new(
                 StorageEngineConfig::default(),
-                Arc::new(NoopLogStore),
+                Arc::new(NoopLogStore::default()),
                 object_store.clone(),
                 noop_compaction_scheduler,
-            )
-            .unwrap(),
+            ),
             object_store,
         ));
         (dir, table_engine)
@@ -556,14 +514,14 @@ mod tests {
     async fn test_system_table_type() {
         let (_dir, table_engine) = prepare_table_engine().await;
         let system_table = SystemCatalogTable::new(table_engine).await.unwrap();
-        assert_eq!(Base, system_table.as_table_ref().table_type());
+        assert_eq!(Base, system_table.table_type());
     }
 
     #[tokio::test]
     async fn test_system_table_info() {
         let (_dir, table_engine) = prepare_table_engine().await;
         let system_table = SystemCatalogTable::new(table_engine).await.unwrap();
-        let info = system_table.as_table_ref().table_info();
+        let info = system_table.table_info();
         assert_eq!(TableType::Base, info.table_type);
         assert_eq!(SYSTEM_CATALOG_TABLE_NAME, info.name);
         assert_eq!(SYSTEM_CATALOG_TABLE_ID, info.ident.table_id);
@@ -576,16 +534,14 @@ mod tests {
         let (_, table_engine) = prepare_table_engine().await;
         let catalog_table = SystemCatalogTable::new(table_engine).await.unwrap();
 
-        let result = catalog_table
-            .register_table(
-                DEFAULT_CATALOG_NAME.to_string(),
-                DEFAULT_SCHEMA_NAME.to_string(),
-                "my_table".to_string(),
-                1,
-                MITO_ENGINE.to_string(),
-            )
-            .await
-            .unwrap();
+        let table_insertion = build_table_insert_request(
+            DEFAULT_CATALOG_NAME.to_string(),
+            DEFAULT_SCHEMA_NAME.to_string(),
+            "my_table".to_string(),
+            1,
+            MITO_ENGINE.to_string(),
+        );
+        let result = catalog_table.insert(table_insertion).await.unwrap();
         assert_eq!(result, 1);
 
         let records = catalog_table.records().await.unwrap();
@@ -595,15 +551,9 @@ mod tests {
         assert_eq!(batch.num_rows(), 1);
 
         let row = batch.rows().next().unwrap();
-        let Value::UInt8(entry_type) = row[0] else {
-            unreachable!()
-        };
-        let Value::Binary(key) = row[1].clone() else {
-            unreachable!()
-        };
-        let Value::Binary(value) = row[3].clone() else {
-            unreachable!()
-        };
+        let Value::UInt8(entry_type) = row[0] else { unreachable!() };
+        let Value::Binary(key) = row[1].clone() else { unreachable!() };
+        let Value::Binary(value) = row[3].clone() else { unreachable!() };
         let entry = decode_system_catalog(Some(entry_type), Some(&*key), Some(&*value)).unwrap();
         let expected = Entry::Table(TableEntry {
             catalog_name: DEFAULT_CATALOG_NAME.to_string(),
@@ -611,24 +561,22 @@ mod tests {
             table_name: "my_table".to_string(),
             table_id: 1,
             engine: MITO_ENGINE.to_string(),
-            is_deleted: false,
         });
         assert_eq!(entry, expected);
 
-        catalog_table
-            .deregister_table(
-                &DeregisterTableRequest {
-                    catalog: DEFAULT_CATALOG_NAME.to_string(),
-                    schema: DEFAULT_SCHEMA_NAME.to_string(),
-                    table_name: "my_table".to_string(),
-                },
-                1,
-            )
-            .await
-            .unwrap();
+        let table_deletion = build_table_deletion_request(
+            &DeregisterTableRequest {
+                catalog: DEFAULT_CATALOG_NAME.to_string(),
+                schema: DEFAULT_SCHEMA_NAME.to_string(),
+                table_name: "my_table".to_string(),
+            },
+            1,
+        );
+        let result = catalog_table.delete(table_deletion).await.unwrap();
+        assert_eq!(result, 1);
 
         let records = catalog_table.records().await.unwrap();
         let batches = RecordBatches::try_collect(records).await.unwrap().take();
-        assert_eq!(batches.len(), 1);
+        assert_eq!(batches.len(), 0);
     }
 }

src/catalog/src/table_source.rs

@@ -24,11 +24,14 @@ use session::context::QueryContext;
 use snafu::{ensure, OptionExt};
 use table::table::adapter::DfTableProviderAdapter;
 
-use crate::error::{QueryAccessDeniedSnafu, Result, TableNotExistSnafu};
-use crate::CatalogManagerRef;
+use crate::error::{
+    CatalogNotFoundSnafu, QueryAccessDeniedSnafu, Result, SchemaNotFoundSnafu, TableNotExistSnafu,
+};
+use crate::information_schema::InformationSchemaProvider;
+use crate::CatalogListRef;
 
 pub struct DfTableSourceProvider {
-    catalog_manager: CatalogManagerRef,
+    catalog_list: CatalogListRef,
     resolved_tables: HashMap<String, Arc<dyn TableSource>>,
     disallow_cross_schema_query: bool,
     default_catalog: String,
@@ -37,16 +40,16 @@ pub struct DfTableSourceProvider {
 
 impl DfTableSourceProvider {
     pub fn new(
-        catalog_manager: CatalogManagerRef,
+        catalog_list: CatalogListRef,
         disallow_cross_schema_query: bool,
         query_ctx: &QueryContext,
     ) -> Self {
         Self {
-            catalog_manager,
+            catalog_list,
             disallow_cross_schema_query,
             resolved_tables: HashMap::new(),
-            default_catalog: query_ctx.current_catalog().to_owned(),
-            default_schema: query_ctx.current_schema().to_owned(),
+            default_catalog: query_ctx.current_catalog(),
+            default_schema: query_ctx.current_schema(),
         }
     }
 
@@ -59,8 +62,7 @@ impl DfTableSourceProvider {
                 TableReference::Bare { .. } => (),
                 TableReference::Partial { schema, .. } => {
                     ensure!(
-                        schema.as_ref() == self.default_schema
-                            || schema.as_ref() == INFORMATION_SCHEMA_NAME,
+                        schema.as_ref() == self.default_schema,
                         QueryAccessDeniedSnafu {
                             catalog: &self.default_catalog,
                             schema: schema.as_ref(),
@@ -72,8 +74,7 @@ impl DfTableSourceProvider {
                 } => {
                     ensure!(
                         catalog.as_ref() == self.default_catalog
-                            && (schema.as_ref() == self.default_schema
-                                || schema.as_ref() == INFORMATION_SCHEMA_NAME),
+                            && schema.as_ref() == self.default_schema,
                         QueryAccessDeniedSnafu {
                             catalog: catalog.as_ref(),
                             schema: schema.as_ref()
@@ -101,18 +102,36 @@ impl DfTableSourceProvider {
         let schema_name = table_ref.schema.as_ref();
         let table_name = table_ref.table.as_ref();
 
-        let table = self
-            .catalog_manager
-            .table(catalog_name, schema_name, table_name)
+        let schema = if schema_name != INFORMATION_SCHEMA_NAME {
+            let catalog = self
+                .catalog_list
+                .catalog(catalog_name)?
+                .context(CatalogNotFoundSnafu { catalog_name })?;
+            catalog.schema(schema_name)?.context(SchemaNotFoundSnafu {
+                catalog: catalog_name,
+                schema: schema_name,
+            })?
+        } else {
+            let catalog_provider = self
+                .catalog_list
+                .catalog(catalog_name)?
+                .context(CatalogNotFoundSnafu { catalog_name })?;
+            Arc::new(InformationSchemaProvider::new(
+                catalog_name.to_string(),
+                catalog_provider,
+            ))
+        };
+        let table = schema
+            .table(table_name)
             .await?
             .with_context(|| TableNotExistSnafu {
                 table: format_full_table_name(catalog_name, schema_name, table_name),
             })?;
 
-        let provider = DfTableProviderAdapter::new(table);
-        let source = provider_as_source(Arc::new(provider));
-        let _ = self.resolved_tables.insert(resolved_name, source.clone());
-        Ok(source)
+        let table = DfTableProviderAdapter::new(table);
+        let table = provider_as_source(Arc::new(table));
+        self.resolved_tables.insert(resolved_name, table.clone());
+        Ok(table)
     }
 }
 
@@ -130,20 +149,20 @@ mod tests {
         let query_ctx = &QueryContext::with("greptime", "public");
 
         let table_provider =
-            DfTableSourceProvider::new(MemoryCatalogManager::with_default_setup(), true, query_ctx);
+            DfTableSourceProvider::new(Arc::new(MemoryCatalogManager::default()), true, query_ctx);
 
         let table_ref = TableReference::Bare {
             table: Cow::Borrowed("table_name"),
         };
         let result = table_provider.resolve_table_ref(table_ref);
-        let _ = result.unwrap();
+        assert!(result.is_ok());
 
         let table_ref = TableReference::Partial {
             schema: Cow::Borrowed("public"),
             table: Cow::Borrowed("table_name"),
         };
         let result = table_provider.resolve_table_ref(table_ref);
-        let _ = result.unwrap();
+        assert!(result.is_ok());
 
         let table_ref = TableReference::Partial {
             schema: Cow::Borrowed("wrong_schema"),
@@ -158,7 +177,7 @@ mod tests {
             table: Cow::Borrowed("table_name"),
         };
         let result = table_provider.resolve_table_ref(table_ref);
-        let _ = result.unwrap();
+        assert!(result.is_ok());
 
         let table_ref = TableReference::Full {
             catalog: Cow::Borrowed("wrong_catalog"),
@@ -167,25 +186,5 @@ mod tests {
         };
         let result = table_provider.resolve_table_ref(table_ref);
         assert!(result.is_err());
-
-        let table_ref = TableReference::Partial {
-            schema: Cow::Borrowed("information_schema"),
-            table: Cow::Borrowed("columns"),
-        };
-        let _ = table_provider.resolve_table_ref(table_ref).unwrap();
-
-        let table_ref = TableReference::Full {
-            catalog: Cow::Borrowed("greptime"),
-            schema: Cow::Borrowed("information_schema"),
-            table: Cow::Borrowed("columns"),
-        };
-        let _ = table_provider.resolve_table_ref(table_ref).unwrap();
-
-        let table_ref = TableReference::Full {
-            catalog: Cow::Borrowed("dummy"),
-            schema: Cow::Borrowed("information_schema"),
-            table: Cow::Borrowed("columns"),
-        };
-        assert!(table_provider.resolve_table_ref(table_ref).is_err());
     }
 }

src/catalog/src/tables.rs

@@ -14,17 +14,49 @@
 
 // The `tables` table in system catalog keeps a record of all tables created by user.
 
+use std::any::Any;
 use std::sync::Arc;
 
+use async_trait::async_trait;
+use common_catalog::consts::{INFORMATION_SCHEMA_NAME, SYSTEM_CATALOG_TABLE_NAME};
+use snafu::ResultExt;
 use table::metadata::TableId;
+use table::{Table, TableRef};
 
-use crate::system::SystemCatalogTable;
-use crate::DeregisterTableRequest;
+use crate::error::{self, Error, InsertCatalogRecordSnafu, Result as CatalogResult};
+use crate::system::{
+    build_schema_insert_request, build_table_deletion_request, build_table_insert_request,
+    SystemCatalogTable,
+};
+use crate::{CatalogProvider, DeregisterTableRequest, SchemaProvider, SchemaProviderRef};
 
 pub struct InformationSchema {
     pub system: Arc<SystemCatalogTable>,
 }
 
+#[async_trait]
+impl SchemaProvider for InformationSchema {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn table_names(&self) -> Result<Vec<String>, Error> {
+        Ok(vec![SYSTEM_CATALOG_TABLE_NAME.to_string()])
+    }
+
+    async fn table(&self, name: &str) -> Result<Option<TableRef>, Error> {
+        if name.eq_ignore_ascii_case(SYSTEM_CATALOG_TABLE_NAME) {
+            Ok(Some(self.system.clone()))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn table_exist(&self, name: &str) -> Result<bool, Error> {
+        Ok(name.eq_ignore_ascii_case(SYSTEM_CATALOG_TABLE_NAME))
+    }
+}
+
 pub struct SystemCatalog {
     pub information_schema: Arc<InformationSchema>,
 }
@@ -47,21 +79,27 @@ impl SystemCatalog {
         table_id: TableId,
         engine: String,
     ) -> crate::error::Result<usize> {
+        let request = build_table_insert_request(catalog, schema, table_name, table_id, engine);
         self.information_schema
             .system
-            .register_table(catalog, schema, table_name, table_id, engine)
+            .insert(request)
             .await
+            .context(InsertCatalogRecordSnafu)
     }
 
     pub(crate) async fn deregister_table(
         &self,
         request: &DeregisterTableRequest,
         table_id: TableId,
-    ) -> crate::error::Result<()> {
+    ) -> CatalogResult<bool> {
         self.information_schema
             .system
-            .deregister_table(request, table_id)
+            .delete(build_table_deletion_request(request, table_id))
             .await
+            .map(|x| x == 1)
+            .with_context(|_| error::DeregisterTableSnafu {
+                request: request.clone(),
+            })
     }
 
     pub async fn register_schema(
@@ -69,9 +107,37 @@ impl SystemCatalog {
         catalog: String,
         schema: String,
     ) -> crate::error::Result<usize> {
+        let request = build_schema_insert_request(catalog, schema);
         self.information_schema
             .system
-            .register_schema(catalog, schema)
+            .insert(request)
             .await
+            .context(InsertCatalogRecordSnafu)
+    }
+}
+
+impl CatalogProvider for SystemCatalog {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema_names(&self) -> Result<Vec<String>, Error> {
+        Ok(vec![INFORMATION_SCHEMA_NAME.to_string()])
+    }
+
+    fn register_schema(
+        &self,
+        _name: String,
+        _schema: SchemaProviderRef,
+    ) -> Result<Option<SchemaProviderRef>, Error> {
+        panic!("System catalog does not support registering schema!")
+    }
+
+    fn schema(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>, Error> {
+        if name.eq_ignore_ascii_case(INFORMATION_SCHEMA_NAME) {
+            Ok(Some(self.information_schema.clone()))
+        } else {
+            Ok(None)
+        }
     }
 }

src/catalog/tests/local_catalog_tests.rs

@@ -20,15 +20,14 @@ mod tests {
     use catalog::{CatalogManager, RegisterTableRequest, RenameTableRequest};
     use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
     use common_telemetry::{error, info};
-    use common_test_util::temp_dir::TempDir;
     use mito::config::EngineConfig;
     use table::engine::manager::MemoryTableEngineManager;
     use table::table::numbers::NumbersTable;
+    use table::TableRef;
     use tokio::sync::Mutex;
 
-    async fn create_local_catalog_manager(
-    ) -> Result<(TempDir, LocalCatalogManager), catalog::error::Error> {
-        let (dir, object_store) =
+    async fn create_local_catalog_manager() -> Result<LocalCatalogManager, catalog::error::Error> {
+        let (_dir, object_store) =
             mito::table::test_util::new_test_object_store("setup_mock_engine_and_table").await;
         let mock_engine = Arc::new(mito::table::test_util::MockMitoEngine::new(
             EngineConfig::default(),
@@ -38,22 +37,23 @@ mod tests {
         let engine_manager = Arc::new(MemoryTableEngineManager::new(mock_engine.clone()));
         let catalog_manager = LocalCatalogManager::try_new(engine_manager).await.unwrap();
         catalog_manager.start().await?;
-        Ok((dir, catalog_manager))
+        Ok(catalog_manager)
     }
 
     #[tokio::test]
     async fn test_rename_table() {
         common_telemetry::init_default_ut_logging();
-        let (_dir, catalog_manager) = create_local_catalog_manager().await.unwrap();
+        let catalog_manager = create_local_catalog_manager().await.unwrap();
         // register table
         let table_name = "test_table";
         let table_id = 42;
+        let table = Arc::new(NumbersTable::new(table_id));
         let request = RegisterTableRequest {
             catalog: DEFAULT_CATALOG_NAME.to_string(),
             schema: DEFAULT_SCHEMA_NAME.to_string(),
             table_name: table_name.to_string(),
             table_id,
-            table: NumbersTable::table(table_id),
+            table: table.clone(),
         };
         assert!(catalog_manager.register_table(request).await.unwrap());
 
@@ -81,13 +81,13 @@ mod tests {
 
     #[tokio::test]
     async fn test_duplicate_register() {
-        let (_dir, catalog_manager) = create_local_catalog_manager().await.unwrap();
+        let catalog_manager = create_local_catalog_manager().await.unwrap();
         let request = RegisterTableRequest {
             catalog: DEFAULT_CATALOG_NAME.to_string(),
             schema: DEFAULT_SCHEMA_NAME.to_string(),
             table_name: "test_table".to_string(),
             table_id: 42,
-            table: NumbersTable::table(42),
+            table: Arc::new(NumbersTable::new(42)),
         };
         assert!(catalog_manager
             .register_table(request.clone())
@@ -103,7 +103,7 @@ mod tests {
                 schema: DEFAULT_SCHEMA_NAME.to_string(),
                 table_name: "test_table".to_string(),
                 table_id: 43,
-                table: NumbersTable::table(43),
+                table: Arc::new(NumbersTable::new(43)),
             })
             .await
             .unwrap_err();
@@ -118,11 +118,10 @@ mod tests {
     fn test_concurrent_register() {
         common_telemetry::init_default_ut_logging();
         let rt = Arc::new(tokio::runtime::Builder::new_multi_thread().build().unwrap());
-        let (_dir, catalog_manager) =
-            rt.block_on(async { create_local_catalog_manager().await.unwrap() });
-        let catalog_manager = Arc::new(catalog_manager);
+        let catalog_manager =
+            Arc::new(rt.block_on(async { create_local_catalog_manager().await.unwrap() }));
 
-        let succeed = Arc::new(Mutex::new(None));
+        let succeed: Arc<Mutex<Option<TableRef>>> = Arc::new(Mutex::new(None));
 
         let mut handles = Vec::with_capacity(8);
         for i in 0..8 {
@@ -130,21 +129,20 @@ mod tests {
             let succeed = succeed.clone();
             let handle = rt.spawn(async move {
                 let table_id = 42 + i;
-                let table = NumbersTable::table(table_id);
-                let table_info = table.table_info();
+                let table = Arc::new(NumbersTable::new(table_id));
                 let req = RegisterTableRequest {
                     catalog: DEFAULT_CATALOG_NAME.to_string(),
                     schema: DEFAULT_SCHEMA_NAME.to_string(),
                     table_name: "test_table".to_string(),
                     table_id,
-                    table,
+                    table: table.clone(),
                 };
                 match catalog.register_table(req).await {
                     Ok(res) => {
                         if res {
                             let mut succeed = succeed.lock().await;
                             info!("Successfully registered table: {}", table_id);
-                            *succeed = Some(table_info);
+                            *succeed = Some(table);
                         }
                     }
                     Err(_) => {
@@ -160,7 +158,7 @@ mod tests {
                 handle.await.unwrap();
             }
             let guard = succeed.lock().await;
-            let table_info = guard.as_ref().unwrap();
+            let table = guard.as_ref().unwrap();
             let table_registered = catalog_manager
                 .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, "test_table")
                 .await
@@ -168,7 +166,7 @@ mod tests {
                 .unwrap();
             assert_eq!(
                 table_registered.table_info().ident.table_id,
-                table_info.ident.table_id
+                table.table_info().ident.table_id
             );
         });
     }

src/catalog/tests/mock.rs

@@ -0,0 +1,228 @@
+// 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::collections::btree_map::Entry;
+use std::collections::{BTreeMap, HashMap};
+use std::fmt::{Display, Formatter};
+use std::str::FromStr;
+use std::sync::Arc;
+
+use async_stream::stream;
+use catalog::error::Error;
+use catalog::remote::{Kv, KvBackend, ValueIter};
+use common_recordbatch::RecordBatch;
+use common_telemetry::logging::info;
+use datatypes::data_type::ConcreteDataType;
+use datatypes::schema::{ColumnSchema, Schema};
+use datatypes::vectors::StringVector;
+use serde::Serializer;
+use table::engine::{EngineContext, TableEngine, TableReference};
+use table::metadata::TableId;
+use table::requests::{AlterTableRequest, CreateTableRequest, DropTableRequest, OpenTableRequest};
+use table::test_util::MemTable;
+use table::TableRef;
+use tokio::sync::RwLock;
+
+#[derive(Default)]
+pub struct MockKvBackend {
+    map: RwLock<BTreeMap<Vec<u8>, Vec<u8>>>,
+}
+
+impl Display for MockKvBackend {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        futures::executor::block_on(async {
+            let map = self.map.read().await;
+            for (k, v) in map.iter() {
+                f.serialize_str(&String::from_utf8_lossy(k))?;
+                f.serialize_str(" -> ")?;
+                f.serialize_str(&String::from_utf8_lossy(v))?;
+                f.serialize_str("\n")?;
+            }
+            Ok(())
+        })
+    }
+}
+
+#[async_trait::async_trait]
+impl KvBackend for MockKvBackend {
+    fn range<'a, 'b>(&'a self, key: &[u8]) -> ValueIter<'b, Error>
+    where
+        'a: 'b,
+    {
+        let prefix = key.to_vec();
+        let prefix_string = String::from_utf8_lossy(&prefix).to_string();
+        Box::pin(stream!({
+            let maps = self.map.read().await.clone();
+            for (k, v) in maps.range(prefix.clone()..) {
+                let key_string = String::from_utf8_lossy(k).to_string();
+                let matches = key_string.starts_with(&prefix_string);
+                if matches {
+                    yield Ok(Kv(k.clone(), v.clone()))
+                } else {
+                    info!("Stream finished");
+                    return;
+                }
+            }
+        }))
+    }
+
+    async fn set(&self, key: &[u8], val: &[u8]) -> Result<(), Error> {
+        let mut map = self.map.write().await;
+        map.insert(key.to_vec(), val.to_vec());
+        Ok(())
+    }
+
+    async fn compare_and_set(
+        &self,
+        key: &[u8],
+        expect: &[u8],
+        val: &[u8],
+    ) -> Result<Result<(), Option<Vec<u8>>>, Error> {
+        let mut map = self.map.write().await;
+        let existing = map.entry(key.to_vec());
+        match existing {
+            Entry::Vacant(e) => {
+                if expect.is_empty() {
+                    e.insert(val.to_vec());
+                    Ok(Ok(()))
+                } else {
+                    Ok(Err(None))
+                }
+            }
+            Entry::Occupied(mut existing) => {
+                if existing.get() == expect {
+                    existing.insert(val.to_vec());
+                    Ok(Ok(()))
+                } else {
+                    Ok(Err(Some(existing.get().clone())))
+                }
+            }
+        }
+    }
+
+    async fn delete_range(&self, key: &[u8], end: &[u8]) -> Result<(), Error> {
+        let start = key.to_vec();
+        let end = end.to_vec();
+        let range = start..end;
+
+        let mut map = self.map.write().await;
+        map.retain(|k, _| !range.contains(k));
+        Ok(())
+    }
+}
+
+#[derive(Default)]
+pub struct MockTableEngine {
+    tables: RwLock<HashMap<String, TableRef>>,
+}
+
+#[async_trait::async_trait]
+impl TableEngine for MockTableEngine {
+    fn name(&self) -> &str {
+        "MockTableEngine"
+    }
+
+    /// Create a table with only one column
+    async fn create_table(
+        &self,
+        _ctx: &EngineContext,
+        request: CreateTableRequest,
+    ) -> table::Result<TableRef> {
+        let table_name = request.table_name.clone();
+        let catalog_name = request.catalog_name.clone();
+        let schema_name = request.schema_name.clone();
+
+        let default_table_id = "0".to_owned();
+        let table_id = TableId::from_str(
+            request
+                .table_options
+                .extra_options
+                .get("table_id")
+                .unwrap_or(&default_table_id),
+        )
+        .unwrap();
+        let schema = Arc::new(Schema::new(vec![ColumnSchema::new(
+            "name",
+            ConcreteDataType::string_datatype(),
+            true,
+        )]));
+
+        let data = vec![Arc::new(StringVector::from(vec!["a", "b", "c"])) as _];
+        let record_batch = RecordBatch::new(schema, data).unwrap();
+        let table: TableRef = Arc::new(MemTable::new_with_catalog(
+            &table_name,
+            record_batch,
+            table_id,
+            catalog_name,
+            schema_name,
+            vec![0],
+        )) as Arc<_>;
+
+        let mut tables = self.tables.write().await;
+        tables.insert(table_name, table.clone() as TableRef);
+        Ok(table)
+    }
+
+    async fn open_table(
+        &self,
+        _ctx: &EngineContext,
+        request: OpenTableRequest,
+    ) -> table::Result<Option<TableRef>> {
+        Ok(self.tables.read().await.get(&request.table_name).cloned())
+    }
+
+    async fn alter_table(
+        &self,
+        _ctx: &EngineContext,
+        _request: AlterTableRequest,
+    ) -> table::Result<TableRef> {
+        unimplemented!()
+    }
+
+    fn get_table(
+        &self,
+        _ctx: &EngineContext,
+        table_ref: &TableReference,
+    ) -> table::Result<Option<TableRef>> {
+        futures::executor::block_on(async {
+            Ok(self
+                .tables
+                .read()
+                .await
+                .get(&table_ref.to_string())
+                .cloned())
+        })
+    }
+
+    fn table_exists(&self, _ctx: &EngineContext, table_ref: &TableReference) -> bool {
+        futures::executor::block_on(async {
+            self.tables
+                .read()
+                .await
+                .contains_key(&table_ref.to_string())
+        })
+    }
+
+    async fn drop_table(
+        &self,
+        _ctx: &EngineContext,
+        _request: DropTableRequest,
+    ) -> table::Result<bool> {
+        unimplemented!()
+    }
+
+    async fn close(&self) -> table::Result<()> {
+        Ok(())
+    }
+}

src/catalog/tests/remote_catalog_tests.rs

@@ -14,147 +14,99 @@
 
 #![feature(assert_matches)]
 
+mod mock;
+
 #[cfg(test)]
 mod tests {
     use std::assert_matches::assert_matches;
     use std::collections::HashSet;
     use std::sync::Arc;
-    use std::time::Duration;
 
-    use catalog::remote::mock::MockTableEngine;
-    use catalog::remote::region_alive_keeper::RegionAliveKeepers;
-    use catalog::remote::{CachedMetaKvBackend, RemoteCatalogManager};
-    use catalog::{CatalogManager, RegisterSchemaRequest, RegisterTableRequest};
-    use common_catalog::consts::{
-        DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, INFORMATION_SCHEMA_NAME, MITO_ENGINE,
+    use catalog::helper::{CatalogKey, CatalogValue, SchemaKey, SchemaValue};
+    use catalog::remote::{
+        KvBackend, KvBackendRef, RemoteCatalogManager, RemoteCatalogProvider, RemoteSchemaProvider,
     };
-    use common_meta::helper::CatalogValue;
-    use common_meta::ident::TableIdent;
-    use common_meta::key::catalog_name::CatalogNameKey;
-    use common_meta::key::TableMetadataManager;
-    use common_meta::kv_backend::memory::MemoryKvBackend;
-    use common_meta::kv_backend::KvBackend;
-    use common_meta::rpc::store::{CompareAndPutRequest, PutRequest};
+    use catalog::{CatalogList, CatalogManager, RegisterTableRequest};
+    use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, MITO_ENGINE};
     use datatypes::schema::RawSchema;
-    use table::engine::manager::{MemoryTableEngineManager, TableEngineManagerRef};
+    use futures_util::StreamExt;
+    use table::engine::manager::MemoryTableEngineManager;
     use table::engine::{EngineContext, TableEngineRef};
     use table::requests::CreateTableRequest;
-    use table::test_util::EmptyTable;
-    use tokio::time::Instant;
 
-    struct TestingComponents {
-        catalog_manager: Arc<RemoteCatalogManager>,
-        table_engine_manager: TableEngineManagerRef,
-        region_alive_keepers: Arc<RegionAliveKeepers>,
-    }
-
-    impl TestingComponents {
-        fn table_engine(&self) -> TableEngineRef {
-            self.table_engine_manager.engine(MITO_ENGINE).unwrap()
-        }
-    }
+    use crate::mock::{MockKvBackend, MockTableEngine};
 
     #[tokio::test]
-    async fn test_cached_backend() {
-        let backend = CachedMetaKvBackend::wrap(Arc::new(MemoryKvBackend::default()));
+    async fn test_backend() {
+        common_telemetry::init_default_ut_logging();
+        let backend = MockKvBackend::default();
 
-        let default_catalog_key = CatalogNameKey::new(DEFAULT_CATALOG_NAME).to_string();
-
-        let req = PutRequest::new()
-            .with_key(default_catalog_key.as_bytes())
-            .with_value(CatalogValue.as_bytes().unwrap());
-        backend.put(req).await.unwrap();
-
-        let ret = backend.get(b"__catalog_name/greptime").await.unwrap();
-        let _ = ret.unwrap();
-
-        let req = CompareAndPutRequest::new()
-            .with_key(b"__catalog_name/greptime".to_vec())
-            .with_expect(CatalogValue.as_bytes().unwrap())
-            .with_value(b"123".to_vec());
-        let _ = backend.compare_and_put(req).await.unwrap();
-
-        let ret = backend.get(b"__catalog_name/greptime").await.unwrap();
-        assert_eq!(b"123", ret.as_ref().unwrap().value.as_slice());
-
-        let req = PutRequest::new()
-            .with_key(b"__catalog_name/greptime".to_vec())
-            .with_value(b"1234".to_vec());
-        let _ = backend.put(req).await;
-
-        let ret = backend.get(b"__catalog_name/greptime").await.unwrap();
-        assert_eq!(b"1234", ret.unwrap().value.as_slice());
+        let default_catalog_key = CatalogKey {
+            catalog_name: DEFAULT_CATALOG_NAME.to_string(),
+        }
+        .to_string();
 
         backend
-            .delete(b"__catalog_name/greptime", false)
+            .set(
+                default_catalog_key.as_bytes(),
+                &CatalogValue {}.as_bytes().unwrap(),
+            )
             .await
             .unwrap();
 
-        let ret = backend.get(b"__catalog_name/greptime").await.unwrap();
-        assert!(ret.is_none());
+        let schema_key = SchemaKey {
+            catalog_name: DEFAULT_CATALOG_NAME.to_string(),
+            schema_name: DEFAULT_SCHEMA_NAME.to_string(),
+        }
+        .to_string();
+        backend
+            .set(schema_key.as_bytes(), &SchemaValue {}.as_bytes().unwrap())
+            .await
+            .unwrap();
+
+        let mut iter = backend.range("__c-".as_bytes());
+        let mut res = HashSet::new();
+        while let Some(r) = iter.next().await {
+            let kv = r.unwrap();
+            res.insert(String::from_utf8_lossy(&kv.0).to_string());
+        }
+        assert_eq!(
+            vec!["__c-greptime".to_string()],
+            res.into_iter().collect::<Vec<_>>()
+        );
     }
 
-    async fn prepare_components(node_id: u64) -> TestingComponents {
-        let backend = Arc::new(MemoryKvBackend::default());
-
-        let req = PutRequest::new()
-            .with_key(b"__catalog_name/greptime".to_vec())
-            .with_value(b"".to_vec());
-        backend.put(req).await.unwrap();
-
-        let req = PutRequest::new()
-            .with_key(b"__schema_name/greptime-public".to_vec())
-            .with_value(b"".to_vec());
-        backend.put(req).await.unwrap();
-
-        let cached_backend = Arc::new(CachedMetaKvBackend::wrap(backend));
-
+    async fn prepare_components(
+        node_id: u64,
+    ) -> (KvBackendRef, TableEngineRef, Arc<RemoteCatalogManager>) {
+        let backend = Arc::new(MockKvBackend::default()) as KvBackendRef;
         let table_engine = Arc::new(MockTableEngine::default());
         let engine_manager = Arc::new(MemoryTableEngineManager::alias(
             MITO_ENGINE.to_string(),
-            table_engine,
+            table_engine.clone(),
         ));
-
-        let region_alive_keepers = Arc::new(RegionAliveKeepers::new(engine_manager.clone(), 5000));
-
-        let catalog_manager = RemoteCatalogManager::new(
-            engine_manager.clone(),
-            node_id,
-            region_alive_keepers.clone(),
-            Arc::new(TableMetadataManager::new(cached_backend)),
-        );
+        let catalog_manager = RemoteCatalogManager::new(engine_manager, node_id, backend.clone());
         catalog_manager.start().await.unwrap();
-
-        TestingComponents {
-            catalog_manager: Arc::new(catalog_manager),
-            table_engine_manager: engine_manager,
-            region_alive_keepers,
-        }
+        (backend, table_engine, Arc::new(catalog_manager))
     }
 
     #[tokio::test]
     async fn test_remote_catalog_default() {
         common_telemetry::init_default_ut_logging();
         let node_id = 42;
-        let TestingComponents {
-            catalog_manager, ..
-        } = prepare_components(node_id).await;
+        let (_, _, catalog_manager) = prepare_components(node_id).await;
         assert_eq!(
             vec![DEFAULT_CATALOG_NAME.to_string()],
-            catalog_manager.catalog_names().await.unwrap()
+            catalog_manager.catalog_names().unwrap()
         );
 
-        let mut schema_names = catalog_manager
-            .schema_names(DEFAULT_CATALOG_NAME)
-            .await
+        let default_catalog = catalog_manager
+            .catalog(DEFAULT_CATALOG_NAME)
+            .unwrap()
             .unwrap();
-        schema_names.sort_unstable();
         assert_eq!(
-            vec![
-                INFORMATION_SCHEMA_NAME.to_string(),
-                DEFAULT_SCHEMA_NAME.to_string()
-            ],
-            schema_names
+            vec![DEFAULT_SCHEMA_NAME.to_string()],
+            default_catalog.schema_names().unwrap()
         );
     }
 
@@ -162,16 +114,14 @@ mod tests {
     async fn test_remote_catalog_register_nonexistent() {
         common_telemetry::init_default_ut_logging();
         let node_id = 42;
-        let components = prepare_components(node_id).await;
-
+        let (_, table_engine, catalog_manager) = prepare_components(node_id).await;
         // register a new table with an nonexistent catalog
         let catalog_name = "nonexistent_catalog".to_string();
         let schema_name = "nonexistent_schema".to_string();
         let table_name = "fail_table".to_string();
         // this schema has no effect
         let table_schema = RawSchema::new(vec![]);
-        let table = components
-            .table_engine()
+        let table = table_engine
             .create_table(
                 &EngineContext {},
                 CreateTableRequest {
@@ -197,7 +147,7 @@ mod tests {
             table_id: 1,
             table,
         };
-        let res = components.catalog_manager.register_table(reg_req).await;
+        let res = catalog_manager.register_table(reg_req).await;
 
         // because nonexistent_catalog does not exist yet.
         assert_matches!(
@@ -209,21 +159,21 @@ mod tests {
     #[tokio::test]
     async fn test_register_table() {
         let node_id = 42;
-        let components = prepare_components(node_id).await;
-        let mut schema_names = components
-            .catalog_manager
-            .schema_names(DEFAULT_CATALOG_NAME)
-            .await
+        let (_, table_engine, catalog_manager) = prepare_components(node_id).await;
+        let default_catalog = catalog_manager
+            .catalog(DEFAULT_CATALOG_NAME)
+            .unwrap()
             .unwrap();
-        schema_names.sort_unstable();
         assert_eq!(
-            vec![
-                INFORMATION_SCHEMA_NAME.to_string(),
-                DEFAULT_SCHEMA_NAME.to_string(),
-            ],
-            schema_names
+            vec![DEFAULT_SCHEMA_NAME.to_string()],
+            default_catalog.schema_names().unwrap()
         );
 
+        let default_schema = default_catalog
+            .schema(DEFAULT_SCHEMA_NAME)
+            .unwrap()
+            .unwrap();
+
         // register a new table with an nonexistent catalog
         let catalog_name = DEFAULT_CATALOG_NAME.to_string();
         let schema_name = DEFAULT_SCHEMA_NAME.to_string();
@@ -231,8 +181,7 @@ mod tests {
         let table_id = 1;
         // this schema has no effect
         let table_schema = RawSchema::new(vec![]);
-        let table = components
-            .table_engine()
+        let table = table_engine
             .create_table(
                 &EngineContext {},
                 CreateTableRequest {
@@ -258,46 +207,35 @@ mod tests {
             table_id,
             table,
         };
-        assert!(components
-            .catalog_manager
-            .register_table(reg_req)
-            .await
-            .unwrap());
-        assert_eq!(
-            vec![table_name],
-            components
-                .catalog_manager
-                .table_names(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME)
-                .await
-                .unwrap()
-        );
+        assert!(catalog_manager.register_table(reg_req).await.unwrap());
+        assert_eq!(vec![table_name], default_schema.table_names().unwrap());
     }
 
     #[tokio::test]
     async fn test_register_catalog_schema_table() {
         let node_id = 42;
-        let components = prepare_components(node_id).await;
+        let (backend, table_engine, catalog_manager) = prepare_components(node_id).await;
 
         let catalog_name = "test_catalog".to_string();
         let schema_name = "nonexistent_schema".to_string();
+        let catalog = Arc::new(RemoteCatalogProvider::new(
+            catalog_name.clone(),
+            backend.clone(),
+            node_id,
+        ));
 
         // register catalog to catalog manager
-        assert!(components
-            .catalog_manager
-            .clone()
-            .register_catalog(catalog_name.clone())
-            .await
-            .is_ok());
+        catalog_manager
+            .register_catalog(catalog_name.clone(), catalog)
+            .unwrap();
         assert_eq!(
-            HashSet::<String>::from_iter(vec![
-                DEFAULT_CATALOG_NAME.to_string(),
-                catalog_name.clone()
-            ]),
-            HashSet::from_iter(components.catalog_manager.catalog_names().await.unwrap())
+            HashSet::<String>::from_iter(
+                vec![DEFAULT_CATALOG_NAME.to_string(), catalog_name.clone()].into_iter()
+            ),
+            HashSet::from_iter(catalog_manager.catalog_names().unwrap().into_iter())
         );
 
-        let table_to_register = components
-            .table_engine()
+        let table_to_register = table_engine
             .create_table(
                 &EngineContext {},
                 CreateTableRequest {
@@ -326,128 +264,33 @@ mod tests {
         };
         // this register will fail since schema does not exist yet
         assert_matches!(
-            components
-                .catalog_manager
+            catalog_manager
                 .register_table(reg_req.clone())
                 .await
                 .unwrap_err(),
             catalog::error::Error::SchemaNotFound { .. }
         );
 
-        let register_schema_request = RegisterSchemaRequest {
-            catalog: catalog_name.to_string(),
-            schema: schema_name.to_string(),
-        };
-        assert!(components
-            .catalog_manager
-            .register_schema(register_schema_request)
-            .await
-            .expect("Register schema should not fail"));
-        assert!(components
-            .catalog_manager
-            .register_table(reg_req)
-            .await
-            .unwrap());
+        let new_catalog = catalog_manager
+            .catalog(&catalog_name)
+            .unwrap()
+            .expect("catalog should exist since it's already registered");
+        let schema = Arc::new(RemoteSchemaProvider::new(
+            catalog_name.clone(),
+            schema_name.clone(),
+            node_id,
+            backend.clone(),
+        ));
+
+        let prev = new_catalog
+            .register_schema(schema_name.clone(), schema.clone())
+            .expect("Register schema should not fail");
+        assert!(prev.is_none());
+        assert!(catalog_manager.register_table(reg_req).await.unwrap());
 
         assert_eq!(
-            HashSet::from([schema_name.clone(), INFORMATION_SCHEMA_NAME.to_string()]),
-            components
-                .catalog_manager
-                .schema_names(&catalog_name)
-                .await
-                .unwrap()
-                .into_iter()
-                .collect()
+            HashSet::from([schema_name.clone()]),
+            new_catalog.schema_names().unwrap().into_iter().collect()
         )
     }
-
-    #[tokio::test]
-    async fn test_register_table_before_and_after_region_alive_keeper_started() {
-        let components = prepare_components(42).await;
-        let catalog_manager = &components.catalog_manager;
-        let region_alive_keepers = &components.region_alive_keepers;
-
-        let table_before = TableIdent {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table: "table_before".to_string(),
-            table_id: 1,
-            engine: MITO_ENGINE.to_string(),
-        };
-        let request = RegisterTableRequest {
-            catalog: table_before.catalog.clone(),
-            schema: table_before.schema.clone(),
-            table_name: table_before.table.clone(),
-            table_id: table_before.table_id,
-            table: Arc::new(EmptyTable::new(CreateTableRequest {
-                id: table_before.table_id,
-                catalog_name: table_before.catalog.clone(),
-                schema_name: table_before.schema.clone(),
-                table_name: table_before.table.clone(),
-                desc: None,
-                schema: RawSchema::new(vec![]),
-                region_numbers: vec![0],
-                primary_key_indices: vec![],
-                create_if_not_exists: false,
-                table_options: Default::default(),
-                engine: MITO_ENGINE.to_string(),
-            })),
-        };
-        assert!(catalog_manager.register_table(request).await.unwrap());
-
-        let keeper = region_alive_keepers
-            .find_keeper(table_before.table_id)
-            .await
-            .unwrap();
-        let deadline = keeper.deadline(0).await.unwrap();
-        let far_future = Instant::now() + Duration::from_secs(86400 * 365 * 29);
-        // assert region alive countdown is not started
-        assert!(deadline > far_future);
-
-        region_alive_keepers.start().await;
-
-        let table_after = TableIdent {
-            catalog: DEFAULT_CATALOG_NAME.to_string(),
-            schema: DEFAULT_SCHEMA_NAME.to_string(),
-            table: "table_after".to_string(),
-            table_id: 2,
-            engine: MITO_ENGINE.to_string(),
-        };
-        let request = RegisterTableRequest {
-            catalog: table_after.catalog.clone(),
-            schema: table_after.schema.clone(),
-            table_name: table_after.table.clone(),
-            table_id: table_after.table_id,
-            table: Arc::new(EmptyTable::new(CreateTableRequest {
-                id: table_after.table_id,
-                catalog_name: table_after.catalog.clone(),
-                schema_name: table_after.schema.clone(),
-                table_name: table_after.table.clone(),
-                desc: None,
-                schema: RawSchema::new(vec![]),
-                region_numbers: vec![0],
-                primary_key_indices: vec![],
-                create_if_not_exists: false,
-                table_options: Default::default(),
-                engine: MITO_ENGINE.to_string(),
-            })),
-        };
-        assert!(catalog_manager.register_table(request).await.unwrap());
-
-        let keeper = region_alive_keepers
-            .find_keeper(table_after.table_id)
-            .await
-            .unwrap();
-        let deadline = keeper.deadline(0).await.unwrap();
-        // assert countdown is started for the table registered after [RegionAliveKeepers] started
-        assert!(deadline <= Instant::now() + Duration::from_secs(20));
-
-        let keeper = region_alive_keepers
-            .find_keeper(table_before.table_id)
-            .await
-            .unwrap();
-        let deadline = keeper.deadline(0).await.unwrap();
-        // assert countdown is started for the table registered before [RegionAliveKeepers] started, too
-        assert!(deadline <= Instant::now() + Duration::from_secs(20));
-    }
 }

src/client/Cargo.toml

@@ -4,45 +4,37 @@ version.workspace = true
 edition.workspace = true
 license.workspace = true
 
-[features]
-testing = []
-
 [dependencies]
-api = { workspace = true }
+api = { path = "../api" }
 arrow-flight.workspace = true
 async-stream.workspace = true
-common-base = { 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-telemetry = { workspace = true }
-common-time = { workspace = true }
+common-base = { path = "../common/base" }
+common-catalog = { path = "../common/catalog" }
+common-error = { path = "../common/error" }
+common-grpc = { path = "../common/grpc" }
+common-grpc-expr = { path = "../common/grpc-expr" }
+common-query = { path = "../common/query" }
+common-recordbatch = { path = "../common/recordbatch" }
+common-time = { path = "../common/time" }
+common-telemetry = { path = "../common/telemetry" }
 datafusion.workspace = true
-datatypes = { workspace = true }
-derive_builder.workspace = true
+datatypes = { path = "../datatypes" }
 enum_dispatch = "0.3"
 futures-util.workspace = true
-moka = { version = "0.9", features = ["future"] }
 parking_lot = "0.12"
 prost.workspace = true
 rand.workspace = true
 snafu.workspace = true
-tokio-stream = { version = "0.1", features = ["net"] }
-tokio.workspace = true
 tonic.workspace = true
 
 [dev-dependencies]
-common-grpc-expr = { workspace = true }
-datanode = { workspace = true }
-derive-new = "0.5"
-prost.workspace = true
-substrait = { workspace = true }
+datanode = { path = "../datanode" }
+substrait = { path = "../common/substrait" }
+tokio.workspace = true
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+prost.workspace = true
 
 [dev-dependencies.substrait_proto]
 package = "substrait"
-version = "0.7"
+version = "0.4"

src/client/examples/logical.rs

@@ -63,7 +63,7 @@ async fn run() {
         create_if_not_exists: false,
         table_options: Default::default(),
         table_id: Some(TableId { id: 1024 }),
-        region_numbers: vec![0],
+        region_ids: vec![0],
         engine: MITO_ENGINE.to_string(),
     };
 
@@ -73,7 +73,7 @@ async fn run() {
 
     let logical = mock_logical_plan();
     event!(Level::INFO, "plan size: {:#?}", logical.len());
-    let result = db.logical_plan(logical, None).await.unwrap();
+    let result = db.logical_plan(logical).await.unwrap();
 
     event!(Level::INFO, "result: {:#?}", result);
 }

src/client/examples/stream_ingest.rs

@@ -1,182 +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 api::v1::*;
-use client::{Client, Database, DEFAULT_SCHEMA_NAME};
-use derive_new::new;
-use tracing::{error, info};
-
-fn main() {
-    tracing::subscriber::set_global_default(tracing_subscriber::FmtSubscriber::builder().finish())
-        .unwrap();
-
-    run();
-}
-
-#[tokio::main]
-async fn run() {
-    let greptimedb_endpoint =
-        std::env::var("GREPTIMEDB_ENDPOINT").unwrap_or_else(|_| "localhost:4001".to_owned());
-
-    let greptimedb_dbname =
-        std::env::var("GREPTIMEDB_DBNAME").unwrap_or_else(|_| DEFAULT_SCHEMA_NAME.to_owned());
-
-    let grpc_client = Client::with_urls(vec![&greptimedb_endpoint]);
-
-    let client = Database::new_with_dbname(greptimedb_dbname, grpc_client);
-
-    let stream_inserter = client.streaming_inserter().unwrap();
-
-    if let Err(e) = stream_inserter
-        .insert(vec![to_insert_request(weather_records_1())])
-        .await
-    {
-        error!("Error: {e}");
-    }
-
-    if let Err(e) = stream_inserter
-        .insert(vec![to_insert_request(weather_records_2())])
-        .await
-    {
-        error!("Error: {e}");
-    }
-
-    let result = stream_inserter.finish().await;
-
-    match result {
-        Ok(rows) => {
-            info!("Rows written: {rows}");
-        }
-        Err(e) => {
-            error!("Error: {e}");
-        }
-    };
-}
-
-#[derive(new)]
-struct WeatherRecord {
-    timestamp_millis: i64,
-    collector: String,
-    temperature: f32,
-    humidity: i32,
-}
-
-fn weather_records_1() -> Vec<WeatherRecord> {
-    vec![
-        WeatherRecord::new(1686109527000, "c1".to_owned(), 26.4, 15),
-        WeatherRecord::new(1686023127000, "c1".to_owned(), 29.3, 20),
-        WeatherRecord::new(1685936727000, "c1".to_owned(), 31.8, 13),
-        WeatherRecord::new(1686109527000, "c2".to_owned(), 20.4, 67),
-        WeatherRecord::new(1686023127000, "c2".to_owned(), 18.0, 74),
-        WeatherRecord::new(1685936727000, "c2".to_owned(), 19.2, 81),
-    ]
-}
-
-fn weather_records_2() -> Vec<WeatherRecord> {
-    vec![
-        WeatherRecord::new(1686109527001, "c3".to_owned(), 26.4, 15),
-        WeatherRecord::new(1686023127002, "c3".to_owned(), 29.3, 20),
-        WeatherRecord::new(1685936727003, "c3".to_owned(), 31.8, 13),
-        WeatherRecord::new(1686109527004, "c4".to_owned(), 20.4, 67),
-        WeatherRecord::new(1686023127005, "c4".to_owned(), 18.0, 74),
-        WeatherRecord::new(1685936727006, "c4".to_owned(), 19.2, 81),
-    ]
-}
-
-/// This function generates some random data and bundle them into a
-/// `InsertRequest`.
-///
-/// Data structure:
-///
-/// - `ts`: a timestamp column
-/// - `collector`: a tag column
-/// - `temperature`: a value field of f32
-/// - `humidity`: a value field of i32
-///
-fn to_insert_request(records: Vec<WeatherRecord>) -> InsertRequest {
-    // convert records into columns
-    let rows = records.len();
-
-    // transpose records into columns
-    let (timestamp_millis, collectors, temp, humidity) = records.into_iter().fold(
-        (
-            Vec::with_capacity(rows),
-            Vec::with_capacity(rows),
-            Vec::with_capacity(rows),
-            Vec::with_capacity(rows),
-        ),
-        |mut acc, rec| {
-            acc.0.push(rec.timestamp_millis);
-            acc.1.push(rec.collector);
-            acc.2.push(rec.temperature);
-            acc.3.push(rec.humidity);
-
-            acc
-        },
-    );
-
-    let columns = vec![
-        // timestamp column: `ts`
-        Column {
-            column_name: "ts".to_owned(),
-            values: Some(column::Values {
-                ts_millisecond_values: timestamp_millis,
-                ..Default::default()
-            }),
-            semantic_type: SemanticType::Timestamp as i32,
-            datatype: ColumnDataType::TimestampMillisecond as i32,
-            ..Default::default()
-        },
-        // tag column: collectors
-        Column {
-            column_name: "collector".to_owned(),
-            values: Some(column::Values {
-                string_values: collectors.into_iter().collect(),
-                ..Default::default()
-            }),
-            semantic_type: SemanticType::Tag as i32,
-            datatype: ColumnDataType::String as i32,
-            ..Default::default()
-        },
-        // field column: temperature
-        Column {
-            column_name: "temperature".to_owned(),
-            values: Some(column::Values {
-                f32_values: temp,
-                ..Default::default()
-            }),
-            semantic_type: SemanticType::Field as i32,
-            datatype: ColumnDataType::Float32 as i32,
-            ..Default::default()
-        },
-        // field column: humidity
-        Column {
-            column_name: "humidity".to_owned(),
-            values: Some(column::Values {
-                i32_values: humidity,
-                ..Default::default()
-            }),
-            semantic_type: SemanticType::Field as i32,
-            datatype: ColumnDataType::Int32 as i32,
-            ..Default::default()
-        },
-    ];
-
-    InsertRequest {
-        table_name: "weather_demo".to_owned(),
-        columns,
-        row_count: rows as u32,
-        ..Default::default()
-    }
-}

src/client/src/client.rs

@@ -16,8 +16,6 @@ use std::sync::Arc;
 
 use api::v1::greptime_database_client::GreptimeDatabaseClient;
 use api::v1::health_check_client::HealthCheckClient;
-use api::v1::prometheus_gateway_client::PrometheusGatewayClient;
-use api::v1::region::region_client::RegionClient as PbRegionClient;
 use api::v1::HealthCheckRequest;
 use arrow_flight::flight_service_client::FlightServiceClient;
 use common_grpc::channel_manager::ChannelManager;
@@ -83,6 +81,11 @@ impl Client {
         Default::default()
     }
 
+    pub fn with_manager(channel_manager: ChannelManager) -> Self {
+        let inner = Arc::new(Inner::with_manager(channel_manager));
+        Self { inner }
+    }
+
     pub fn with_urls<U, A>(urls: A) -> Self
     where
         U: AsRef<str>,
@@ -153,20 +156,10 @@ impl Client {
         })
     }
 
-    pub(crate) fn raw_region_client(&self) -> Result<PbRegionClient<Channel>> {
-        let (_, channel) = self.find_channel()?;
-        Ok(PbRegionClient::new(channel))
-    }
-
-    pub fn make_prometheus_gateway_client(&self) -> Result<PrometheusGatewayClient<Channel>> {
-        let (_, channel) = self.find_channel()?;
-        Ok(PrometheusGatewayClient::new(channel))
-    }
-
     pub async fn health_check(&self) -> Result<()> {
         let (_, channel) = self.find_channel()?;
         let mut client = HealthCheckClient::new(channel);
-        let _ = client.health_check(HealthCheckRequest {}).await?;
+        client.health_check(HealthCheckRequest {}).await?;
         Ok(())
     }
 }

src/client/src/database.rs

@@ -17,24 +17,23 @@ use api::v1::ddl_request::Expr as DdlExpr;
 use api::v1::greptime_request::Request;
 use api::v1::query_request::Query;
 use api::v1::{
-    AlterExpr, AuthHeader, CompactTableExpr, CreateTableExpr, DdlRequest, DeleteRequests,
-    DropTableExpr, FlushTableExpr, GreptimeRequest, InsertRequests, PromRangeQuery, QueryRequest,
-    RequestHeader, RowInsertRequests, TruncateTableExpr,
+    greptime_response, AffectedRows, AlterExpr, AuthHeader, CreateTableExpr, DdlRequest,
+    DropTableExpr, FlushTableExpr, GreptimeRequest, InsertRequest, PromRangeQuery, QueryRequest,
+    RequestHeader,
 };
-use arrow_flight::Ticket;
-use async_stream::stream;
-use common_error::ext::{BoxedError, ErrorExt};
-use common_grpc::flight::{FlightDecoder, FlightMessage};
+use arrow_flight::{FlightData, Ticket};
+use common_error::prelude::*;
+use common_grpc::flight::{flight_messages_to_recordbatches, FlightDecoder, FlightMessage};
 use common_query::Output;
-use common_recordbatch::error::ExternalSnafu;
-use common_recordbatch::RecordBatchStreamAdaptor;
-use common_telemetry::{logging, timer};
-use futures_util::StreamExt;
+use common_telemetry::logging;
+use futures_util::{TryFutureExt, TryStreamExt};
 use prost::Message;
 use snafu::{ensure, ResultExt};
 
-use crate::error::{ConvertFlightDataSnafu, Error, IllegalFlightMessagesSnafu, ServerSnafu};
-use crate::{error, from_grpc_response, metrics, Client, Result, StreamInserter};
+use crate::error::{
+    ConvertFlightDataSnafu, IllegalDatabaseResponseSnafu, IllegalFlightMessagesSnafu,
+};
+use crate::{error, Client, Result};
 
 #[derive(Clone, Debug, Default)]
 pub struct Database {
@@ -57,9 +56,8 @@ impl Database {
         Self {
             catalog: catalog.into(),
             schema: schema.into(),
-            dbname: "".to_string(),
             client,
-            ctx: FlightContext::default(),
+            ..Default::default()
         }
     }
 
@@ -72,11 +70,9 @@ impl Database {
     /// environment
     pub fn new_with_dbname(dbname: impl Into<String>, client: Client) -> Self {
         Self {
-            catalog: "".to_string(),
-            schema: "".to_string(),
             dbname: dbname.into(),
             client,
-            ctx: FlightContext::default(),
+            ..Default::default()
         }
     }
 
@@ -110,86 +106,40 @@ impl Database {
         });
     }
 
-    pub async fn insert(&self, requests: InsertRequests) -> Result<u32> {
-        let _timer = timer!(metrics::METRIC_GRPC_INSERT);
-        self.handle(Request::Inserts(requests)).await
-    }
-
-    pub async fn row_insert(&self, requests: RowInsertRequests) -> Result<u32> {
-        let _timer = timer!(metrics::METRIC_GRPC_INSERT);
-        self.handle(Request::RowInserts(requests)).await
-    }
-
-    pub fn streaming_inserter(&self) -> Result<StreamInserter> {
-        self.streaming_inserter_with_channel_size(65536)
-    }
-
-    pub fn streaming_inserter_with_channel_size(
-        &self,
-        channel_size: usize,
-    ) -> Result<StreamInserter> {
-        let client = self.client.make_database_client()?.inner;
-
-        let stream_inserter = StreamInserter::new(
-            client,
-            self.dbname().to_string(),
-            self.ctx.auth_header.clone(),
-            channel_size,
-        );
-
-        Ok(stream_inserter)
-    }
-
-    pub async fn delete(&self, request: DeleteRequests) -> Result<u32> {
-        let _timer = timer!(metrics::METRIC_GRPC_DELETE);
-        self.handle(Request::Deletes(request)).await
-    }
-
-    async fn handle(&self, request: Request) -> Result<u32> {
+    pub async fn insert(&self, request: InsertRequest) -> Result<u32> {
         let mut client = self.client.make_database_client()?.inner;
-        let request = self.to_rpc_request(request, None);
-        let response = client.handle(request).await?.into_inner();
-        from_grpc_response(response)
-    }
-
-    #[inline]
-    fn to_rpc_request(&self, request: Request, trace_id: Option<u64>) -> GreptimeRequest {
-        GreptimeRequest {
+        let request = GreptimeRequest {
             header: Some(RequestHeader {
                 catalog: self.catalog.clone(),
                 schema: self.schema.clone(),
                 authorization: self.ctx.auth_header.clone(),
                 dbname: self.dbname.clone(),
-                trace_id,
-                span_id: None,
             }),
-            request: Some(request),
-        }
+            request: Some(Request::Insert(request)),
+        };
+        let response = client
+            .handle(request)
+            .await?
+            .into_inner()
+            .response
+            .context(IllegalDatabaseResponseSnafu {
+                err_msg: "GreptimeResponse is empty",
+            })?;
+        let greptime_response::Response::AffectedRows(AffectedRows { value }) = response;
+        Ok(value)
     }
 
     pub async fn sql(&self, sql: &str) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_SQL);
-        self.do_get(
-            Request::Query(QueryRequest {
-                query: Some(Query::Sql(sql.to_string())),
-            }),
-            None,
-        )
+        self.do_get(Request::Query(QueryRequest {
+            query: Some(Query::Sql(sql.to_string())),
+        }))
         .await
     }
 
-    pub async fn logical_plan(
-        &self,
-        logical_plan: Vec<u8>,
-        trace_id: Option<u64>,
-    ) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_LOGICAL_PLAN);
-        self.do_get(
-            Request::Query(QueryRequest {
-                query: Some(Query::LogicalPlan(logical_plan)),
-            }),
-            trace_id,
-        )
+    pub async fn logical_plan(&self, logical_plan: Vec<u8>) -> Result<Output> {
+        self.do_get(Request::Query(QueryRequest {
+            query: Some(Query::LogicalPlan(logical_plan)),
+        }))
         .await
     }
 
@@ -200,172 +150,111 @@ impl Database {
         end: &str,
         step: &str,
     ) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_PROMQL_RANGE_QUERY);
-        self.do_get(
-            Request::Query(QueryRequest {
-                query: Some(Query::PromRangeQuery(PromRangeQuery {
-                    query: promql.to_string(),
-                    start: start.to_string(),
-                    end: end.to_string(),
-                    step: step.to_string(),
-                })),
-            }),
-            None,
-        )
+        self.do_get(Request::Query(QueryRequest {
+            query: Some(Query::PromRangeQuery(PromRangeQuery {
+                query: promql.to_string(),
+                start: start.to_string(),
+                end: end.to_string(),
+                step: step.to_string(),
+            })),
+        }))
         .await
     }
 
     pub async fn create(&self, expr: CreateTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_CREATE_TABLE);
-        self.do_get(
-            Request::Ddl(DdlRequest {
-                expr: Some(DdlExpr::CreateTable(expr)),
-            }),
-            None,
-        )
+        self.do_get(Request::Ddl(DdlRequest {
+            expr: Some(DdlExpr::CreateTable(expr)),
+        }))
         .await
     }
 
     pub async fn alter(&self, expr: AlterExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_ALTER);
-        self.do_get(
-            Request::Ddl(DdlRequest {
-                expr: Some(DdlExpr::Alter(expr)),
-            }),
-            None,
-        )
+        self.do_get(Request::Ddl(DdlRequest {
+            expr: Some(DdlExpr::Alter(expr)),
+        }))
         .await
     }
 
     pub async fn drop_table(&self, expr: DropTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_DROP_TABLE);
-        self.do_get(
-            Request::Ddl(DdlRequest {
-                expr: Some(DdlExpr::DropTable(expr)),
-            }),
-            None,
-        )
+        self.do_get(Request::Ddl(DdlRequest {
+            expr: Some(DdlExpr::DropTable(expr)),
+        }))
         .await
     }
 
     pub async fn flush_table(&self, expr: FlushTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_FLUSH_TABLE);
-        self.do_get(
-            Request::Ddl(DdlRequest {
-                expr: Some(DdlExpr::FlushTable(expr)),
-            }),
-            None,
-        )
+        self.do_get(Request::Ddl(DdlRequest {
+            expr: Some(DdlExpr::FlushTable(expr)),
+        }))
         .await
     }
 
-    pub async fn compact_table(&self, expr: CompactTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_COMPACT_TABLE);
-        self.do_get(
-            Request::Ddl(DdlRequest {
-                expr: Some(DdlExpr::CompactTable(expr)),
+    async fn do_get(&self, request: Request) -> Result<Output> {
+        let request = GreptimeRequest {
+            header: Some(RequestHeader {
+                catalog: self.catalog.clone(),
+                schema: self.schema.clone(),
+                authorization: self.ctx.auth_header.clone(),
+                dbname: self.dbname.clone(),
             }),
-            None,
-        )
-        .await
-    }
-
-    pub async fn truncate_table(&self, expr: TruncateTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_TRUNCATE_TABLE);
-        self.do_get(
-            Request::Ddl(DdlRequest {
-                expr: Some(DdlExpr::TruncateTable(expr)),
-            }),
-            None,
-        )
-        .await
-    }
-
-    async fn do_get(&self, request: Request, trace_id: Option<u64>) -> Result<Output> {
-        // FIXME(paomian): should be added some labels for metrics
-        let _timer = timer!(metrics::METRIC_GRPC_DO_GET);
-        let request = self.to_rpc_request(request, trace_id);
+            request: Some(request),
+        };
         let request = Ticket {
             ticket: request.encode_to_vec().into(),
         };
 
         let mut client = self.client.make_flight_client()?;
 
-        let response = client.mut_inner().do_get(request).await.map_err(|e| {
-            let tonic_code = e.code();
-            let e: error::Error = e.into();
-            let code = e.status_code();
-            let msg = e.to_string();
-            let error = Error::FlightGet {
-                tonic_code,
-                addr: client.addr().to_string(),
-                source: BoxedError::new(ServerSnafu { code, msg }.build()),
-            };
-            logging::error!(
-                "Failed to do Flight get, addr: {}, code: {}, source: {}",
-                client.addr(),
-                tonic_code,
-                error
+        // TODO(LFC): Streaming get flight data.
+        let flight_data: Vec<FlightData> = client
+            .mut_inner()
+            .do_get(request)
+            .and_then(|response| response.into_inner().try_collect())
+            .await
+            .map_err(|e| {
+                let tonic_code = e.code();
+                let e: error::Error = e.into();
+                let code = e.status_code();
+                let msg = e.to_string();
+                error::ServerSnafu { code, msg }
+                    .fail::<()>()
+                    .map_err(BoxedError::new)
+                    .context(error::FlightGetSnafu {
+                        tonic_code,
+                        addr: client.addr(),
+                    })
+                    .map_err(|error| {
+                        logging::error!(
+                            "Failed to do Flight get, addr: {}, code: {}, source: {}",
+                            client.addr(),
+                            tonic_code,
+                            error
+                        );
+                        error
+                    })
+                    .unwrap_err()
+            })?;
+
+        let decoder = &mut FlightDecoder::default();
+        let flight_messages = flight_data
+            .into_iter()
+            .map(|x| decoder.try_decode(x).context(ConvertFlightDataSnafu))
+            .collect::<Result<Vec<_>>>()?;
+
+        let output = if let Some(FlightMessage::AffectedRows(rows)) = flight_messages.get(0) {
+            ensure!(
+                flight_messages.len() == 1,
+                IllegalFlightMessagesSnafu {
+                    reason: "Expect 'AffectedRows' Flight messages to be one and only!"
+                }
             );
-            error
-        })?;
-
-        let flight_data_stream = response.into_inner();
-        let mut decoder = FlightDecoder::default();
-
-        let mut flight_message_stream = flight_data_stream.map(move |flight_data| {
-            flight_data
-                .map_err(Error::from)
-                .and_then(|data| decoder.try_decode(data).context(ConvertFlightDataSnafu))
-        });
-
-        let Some(first_flight_message) = flight_message_stream.next().await else {
-            return IllegalFlightMessagesSnafu {
-                reason: "Expect the response not to be empty",
-            }
-            .fail();
+            Output::AffectedRows(*rows)
+        } else {
+            let recordbatches = flight_messages_to_recordbatches(flight_messages)
+                .context(ConvertFlightDataSnafu)?;
+            Output::RecordBatches(recordbatches)
         };
-
-        let first_flight_message = first_flight_message?;
-
-        match first_flight_message {
-            FlightMessage::AffectedRows(rows) => {
-                ensure!(
-                    flight_message_stream.next().await.is_none(),
-                    IllegalFlightMessagesSnafu {
-                        reason: "Expect 'AffectedRows' Flight messages to be the one and the only!"
-                    }
-                );
-                Ok(Output::AffectedRows(rows))
-            }
-            FlightMessage::Recordbatch(_) => IllegalFlightMessagesSnafu {
-                reason: "The first flight message cannot be a RecordBatch message",
-            }
-            .fail(),
-            FlightMessage::Schema(schema) => {
-                let stream = Box::pin(stream!({
-                    while let Some(flight_message) = flight_message_stream.next().await {
-                        let flight_message = flight_message
-                            .map_err(BoxedError::new)
-                            .context(ExternalSnafu)?;
-                        let FlightMessage::Recordbatch(record_batch) = flight_message else {
-                            yield IllegalFlightMessagesSnafu {reason: "A Schema message must be succeeded exclusively by a set of RecordBatch messages"}
-                                        .fail()
-                                        .map_err(BoxedError::new)
-                                        .context(ExternalSnafu);
-                            break;
-                        };
-                        yield Ok(record_batch);
-                    }
-                }));
-                let record_batch_stream = RecordBatchStreamAdaptor {
-                    schema,
-                    stream,
-                    output_ordering: None,
-                };
-                Ok(Output::Stream(Box::pin(record_batch_stream)))
-            }
-        }
+        Ok(output)
     }
 }
 
@@ -376,11 +265,106 @@ pub struct FlightContext {
 
 #[cfg(test)]
 mod tests {
+    use std::sync::Arc;
+
+    use api::helper::ColumnDataTypeWrapper;
     use api::v1::auth_header::AuthScheme;
-    use api::v1::{AuthHeader, Basic};
+    use api::v1::{AuthHeader, Basic, Column};
+    use common_grpc::select::{null_mask, values};
+    use common_grpc_expr::column_to_vector;
+    use datatypes::prelude::{Vector, VectorRef};
+    use datatypes::vectors::{
+        BinaryVector, BooleanVector, DateTimeVector, DateVector, Float32Vector, Float64Vector,
+        Int16Vector, Int32Vector, Int64Vector, Int8Vector, StringVector, UInt16Vector,
+        UInt32Vector, UInt64Vector, UInt8Vector,
+    };
 
     use crate::database::FlightContext;
 
+    #[test]
+    fn test_column_to_vector() {
+        let mut column = create_test_column(Arc::new(BooleanVector::from(vec![true])));
+        column.datatype = -100;
+        let result = column_to_vector(&column, 1);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Column datatype error, source: Unknown proto column datatype: -100"
+        );
+
+        macro_rules! test_with_vector {
+            ($vector: expr) => {
+                let vector = Arc::new($vector);
+                let column = create_test_column(vector.clone());
+                let result = column_to_vector(&column, vector.len() as u32).unwrap();
+                assert_eq!(result, vector as VectorRef);
+            };
+        }
+
+        test_with_vector!(BooleanVector::from(vec![Some(true), None, Some(false)]));
+        test_with_vector!(Int8Vector::from(vec![Some(i8::MIN), None, Some(i8::MAX)]));
+        test_with_vector!(Int16Vector::from(vec![
+            Some(i16::MIN),
+            None,
+            Some(i16::MAX)
+        ]));
+        test_with_vector!(Int32Vector::from(vec![
+            Some(i32::MIN),
+            None,
+            Some(i32::MAX)
+        ]));
+        test_with_vector!(Int64Vector::from(vec![
+            Some(i64::MIN),
+            None,
+            Some(i64::MAX)
+        ]));
+        test_with_vector!(UInt8Vector::from(vec![Some(u8::MIN), None, Some(u8::MAX)]));
+        test_with_vector!(UInt16Vector::from(vec![
+            Some(u16::MIN),
+            None,
+            Some(u16::MAX)
+        ]));
+        test_with_vector!(UInt32Vector::from(vec![
+            Some(u32::MIN),
+            None,
+            Some(u32::MAX)
+        ]));
+        test_with_vector!(UInt64Vector::from(vec![
+            Some(u64::MIN),
+            None,
+            Some(u64::MAX)
+        ]));
+        test_with_vector!(Float32Vector::from(vec![
+            Some(f32::MIN),
+            None,
+            Some(f32::MAX)
+        ]));
+        test_with_vector!(Float64Vector::from(vec![
+            Some(f64::MIN),
+            None,
+            Some(f64::MAX)
+        ]));
+        test_with_vector!(BinaryVector::from(vec![
+            Some(b"".to_vec()),
+            None,
+            Some(b"hello".to_vec())
+        ]));
+        test_with_vector!(StringVector::from(vec![Some(""), None, Some("foo"),]));
+        test_with_vector!(DateVector::from(vec![Some(1), None, Some(3)]));
+        test_with_vector!(DateTimeVector::from(vec![Some(4), None, Some(6)]));
+    }
+
+    fn create_test_column(vector: VectorRef) -> Column {
+        let wrapper: ColumnDataTypeWrapper = vector.data_type().try_into().unwrap();
+        Column {
+            column_name: "test".to_string(),
+            semantic_type: 1,
+            values: Some(values(&[vector.clone()]).unwrap()),
+            null_mask: null_mask(&[vector.clone()], vector.len()),
+            datatype: wrapper.datatype() as i32,
+        }
+    }
+
     #[test]
     fn test_flight_ctx() {
         let mut ctx = FlightContext::default();

src/client/src/error.rs

@@ -13,11 +13,10 @@
 // limitations under the License.
 
 use std::any::Any;
+use std::str::FromStr;
 
-use common_error::ext::{BoxedError, ErrorExt};
-use common_error::status_code::StatusCode;
-use common_error::{GREPTIME_ERROR_CODE, GREPTIME_ERROR_MSG};
-use snafu::{Location, Snafu};
+use common_error::prelude::*;
+use snafu::Location;
 use tonic::{Code, Status};
 
 #[derive(Debug, Snafu)]
@@ -35,13 +34,13 @@ pub enum Error {
 
     #[snafu(display("Failed to convert FlightData, source: {}", source))]
     ConvertFlightData {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_grpc::Error,
     },
 
     #[snafu(display("Column datatype error, source: {}", source))]
     ColumnDataType {
-        location: Location,
+        #[snafu(backtrace)]
         source: api::error::Error,
     },
 
@@ -58,7 +57,7 @@ pub enum Error {
     ))]
     CreateChannel {
         addr: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: common_grpc::error::Error,
     },
 
@@ -68,9 +67,6 @@ pub enum Error {
 
     #[snafu(display("Illegal Database response: {err_msg}"))]
     IllegalDatabaseResponse { err_msg: String },
-
-    #[snafu(display("Failed to send request with streaming: {}", err_msg))]
-    ClientStreaming { err_msg: String, location: Location },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -81,12 +77,11 @@ impl ErrorExt for Error {
             Error::IllegalFlightMessages { .. }
             | Error::ColumnDataType { .. }
             | Error::MissingField { .. }
-            | Error::IllegalDatabaseResponse { .. }
-            | Error::ClientStreaming { .. } => StatusCode::Internal,
+            | Error::IllegalDatabaseResponse { .. } => StatusCode::Internal,
 
             Error::Server { code, .. } => *code,
             Error::FlightGet { source, .. } => source.status_code(),
-            Error::CreateChannel { source, .. } | Error::ConvertFlightData { source, .. } => {
+            Error::CreateChannel { source, .. } | Error::ConvertFlightData { source } => {
                 source.status_code()
             }
             Error::IllegalGrpcClientState { .. } => StatusCode::Unexpected,
@@ -106,18 +101,11 @@ impl From<Status> for Error {
                 .and_then(|v| String::from_utf8(v.as_bytes().to_vec()).ok())
         }
 
-        let code = get_metadata_value(&e, GREPTIME_ERROR_CODE)
-            .and_then(|s| {
-                if let Ok(code) = s.parse::<u32>() {
-                    StatusCode::from_u32(code)
-                } else {
-                    None
-                }
-            })
+        let code = get_metadata_value(&e, INNER_ERROR_CODE)
+            .and_then(|s| StatusCode::from_str(&s).ok())
             .unwrap_or(StatusCode::Unknown);
 
-        let msg =
-            get_metadata_value(&e, GREPTIME_ERROR_MSG).unwrap_or_else(|| e.message().to_string());
+        let msg = get_metadata_value(&e, INNER_ERROR_MSG).unwrap_or(e.to_string());
 
         Self::Server { code, msg }
     }

src/client/src/lib.rs

@@ -13,51 +13,13 @@
 // limitations under the License.
 
 mod client;
-pub mod client_manager;
 mod database;
-pub mod error;
+mod error;
 pub mod load_balance;
-mod metrics;
-pub mod region;
-mod stream_insert;
 
 pub use api;
-use api::v1::greptime_response::Response;
-use api::v1::{AffectedRows, GreptimeResponse};
 pub use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
-use common_error::status_code::StatusCode;
-use snafu::OptionExt;
 
 pub use self::client::Client;
 pub use self::database::Database;
 pub use self::error::{Error, Result};
-pub use self::stream_insert::StreamInserter;
-use crate::error::{IllegalDatabaseResponseSnafu, ServerSnafu};
-
-pub fn from_grpc_response(response: GreptimeResponse) -> Result<u32> {
-    let header = response.header.context(IllegalDatabaseResponseSnafu {
-        err_msg: "missing header",
-    })?;
-    let status = header.status.context(IllegalDatabaseResponseSnafu {
-        err_msg: "missing status",
-    })?;
-
-    if StatusCode::is_success(status.status_code) {
-        let res = response.response.context(IllegalDatabaseResponseSnafu {
-            err_msg: "missing response",
-        })?;
-        match res {
-            Response::AffectedRows(AffectedRows { value }) => Ok(value),
-        }
-    } else {
-        let status_code =
-            StatusCode::from_u32(status.status_code).context(IllegalDatabaseResponseSnafu {
-                err_msg: format!("invalid status: {:?}", status),
-            })?;
-        ServerSnafu {
-            code: status_code,
-            msg: status.err_msg,
-        }
-        .fail()
-    }
-}

src/client/src/load_balance.rs

@@ -60,7 +60,7 @@ mod tests {
         let random = Random;
         for _ in 0..100 {
             let peer = random.get_peer(&peers).unwrap();
-            assert!(all.contains(peer));
+            all.contains(peer);
         }
     }
 }

src/client/src/metrics.rs

@@ -1,28 +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.
-
-//! client metrics
-pub const METRIC_GRPC_CREATE_TABLE: &str = "grpc.create_table";
-pub const METRIC_GRPC_PROMQL_RANGE_QUERY: &str = "grpc.promql.range_query";
-pub const METRIC_GRPC_INSERT: &str = "grpc.insert";
-pub const METRIC_GRPC_DELETE: &str = "grpc.delete";
-pub const METRIC_GRPC_SQL: &str = "grpc.sql";
-pub const METRIC_GRPC_LOGICAL_PLAN: &str = "grpc.logical_plan";
-pub const METRIC_GRPC_ALTER: &str = "grpc.alter";
-pub const METRIC_GRPC_DROP_TABLE: &str = "grpc.drop_table";
-pub const METRIC_GRPC_FLUSH_TABLE: &str = "grpc.flush_table";
-pub const METRIC_GRPC_COMPACT_TABLE: &str = "grpc.compact_table";
-pub const METRIC_GRPC_TRUNCATE_TABLE: &str = "grpc.truncate_table";
-pub const METRIC_GRPC_DO_GET: &str = "grpc.do_get";
-pub(crate) const METRIC_REGION_REQUEST_GRPC: &str = "grpc.region_request";