fix: clippy errors

* fix: Fix several tests compile errors

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* fix: some compile errors in tests

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* fix: compile errors in frontend tests

* fix: compile errors in frontend tests

* test: Fix tests in api and common-query

* test: Fix test in sql crate

* fix: resolve substrait error

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* chore: add more test

* test: Fix tests in servers

* fix instance_test

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* test: Fix tests in tests-integration

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>
Co-authored-by: Lei, HUANG <mrsatangel@gmail.com>
Co-authored-by: evenyag <realevenyag@gmail.com>

.cargo/config.toml

@@ -1,5 +1,2 @@
 [target.aarch64-unknown-linux-gnu]
 linker = "aarch64-linux-gnu-gcc"
-
-[alias]
-sqlness = "run --bin sqlness-runner --"

.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

.editorconfig

@@ -1,10 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-indent_style = space
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[{Makefile,**.mk}]
-indent_style = tab

.env.example

@@ -2,25 +2,3 @@
 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
-# Settings for kafka wal test
-GT_KAFKA_ENDPOINTS = localhost:9092
-
-# Setting for fuzz tests
-GT_MYSQL_ADDR = localhost:4002

.github/CODEOWNERS

@@ -1,27 +0,0 @@
-# GreptimeDB CODEOWNERS
-
-# These owners will be the default owners for everything in the repo.
-
-* @GreptimeTeam/db-approver
-
-## [Module] Databse Engine
-/src/index @zhongzc
-/src/mito2 @evenyag @v0y4g3r @waynexia
-/src/query @evenyag
-
-## [Module] Distributed
-/src/common/meta @MichaelScofield
-/src/common/procedure @MichaelScofield
-/src/meta-client @MichaelScofield
-/src/meta-srv @MichaelScofield
-
-## [Module] Write Ahead Log
-/src/log-store @v0y4g3r
-/src/store-api @v0y4g3r
-
-## [Module] Metrics Engine
-/src/metric-engine @waynexia
-/src/promql @waynexia
-
-## [Module] Flow
-/src/flow @zhongzc @waynexia

.github/ISSUE_TEMPLATE/bug_report.yml

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

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

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

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

@@ -1,65 +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
-  working-dir:
-    description: Working directory to build the artifacts
-    required: false
-    default: .
-  build-android-artifacts:
-    description: Build android artifacts
-    required: false
-    default: 'false'
-runs:
-  using: composite
-  steps:
-    - name: Build greptime binary
-      shell: bash
-      if: ${{ inputs.build-android-artifacts == 'false' }}
-      run: |
-        cd ${{ inputs.working-dir }} && \
-        make build-by-dev-builder \
-          CARGO_PROFILE=${{ inputs.cargo-profile }} \
-          FEATURES=${{ inputs.features }} \
-          BASE_IMAGE=${{ inputs.base-image }}
-
-    - name: Upload artifacts
-      uses: ./.github/actions/upload-artifacts
-      if: ${{ inputs.build-android-artifacts == 'false' }}
-      env:
-        PROFILE_TARGET: ${{ inputs.cargo-profile == 'dev' && 'debug' || inputs.cargo-profile }}
-      with:
-        artifacts-dir: ${{ inputs.artifacts-dir }}
-        target-file: ./target/$PROFILE_TARGET/greptime
-        version: ${{ inputs.version }}
-        working-dir: ${{ inputs.working-dir }}
-
-    # TODO(zyy17): We can remove build-android-artifacts flag in the future.
-    - name: Build greptime binary
-      shell: bash
-      if: ${{ inputs.build-android-artifacts == 'true' }}
-      run: |
-        cd ${{ inputs.working-dir }} && make strip-android-bin
-
-    - name: Upload android artifacts
-      uses: ./.github/actions/upload-artifacts
-      if: ${{ inputs.build-android-artifacts == 'true' }}
-      with:
-        artifacts-dir: ${{ inputs.artifacts-dir }}
-        target-file: ./target/aarch64-linux-android/release/greptime
-        version: ${{ inputs.version }}
-        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@v4
-      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@v4
-      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,88 +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
-  dev-mode:
-    description: Enable dev mode, only build standard greptime
-    required: false
-    default: 'false'
-  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@v4
-      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 }}
-        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 }}
-        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 }}
-        working-dir: ${{ inputs.working-dir }}
-
-    - name: Build greptime on android base image
-      uses: ./.github/actions/build-greptime-binary
-      if: ${{ inputs.arch == 'amd64' && inputs.dev-mode == 'false' }} # Only build android base image on amd64.
-      with:
-        base-image: android
-        artifacts-dir: greptime-android-arm64-${{ inputs.version }}
-        version: ${{ inputs.version }}
-        working-dir: ${{ inputs.working-dir }}
-        build-android-artifacts: true

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

@@ -1,89 +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
-  artifacts-dir:
-    description: Directory to store artifacts
-    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@v4
-      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 }}

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

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

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

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

.github/actions/fuzz-test/action.yaml

@@ -1,13 +0,0 @@
-name: Fuzz Test
-description: 'Fuzz test given setup and service'
-inputs:
-  target:
-    description: "The fuzz target to test"
-runs:
-  using: composite
-  steps:
-  - name: Run Fuzz Test
-    shell: bash
-    run: cargo fuzz run ${{ inputs.target }} --fuzz-dir tests-fuzz -D -s none -- -max_total_time=120
-    env:
-      GT_MYSQL_ADDR: 127.0.0.1:4002

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

@@ -1,53 +0,0 @@
-name: Publish GitHub release
-description: Publish GitHub release
-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@v4
-
-    - 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
-          echo "omitBody=true" >> $GITHUB_ENV
-        else
-          echo "prerelease=true" >> $GITHUB_ENV
-          echo "makeLatest=false" >> $GITHUB_ENV
-          echo "generateReleaseNotes=true" >> $GITHUB_ENV
-          echo "omitBody=false" >> $GITHUB_ENV
-        fi
-
-    - name: Publish release
-      uses: ncipollo/release-action@v1
-      with:
-        name: "Release ${{ inputs.version }}"
-        prerelease: ${{ env.prerelease }}
-        makeLatest: ${{ env.makeLatest }}
-        tag: ${{ inputs.version }}
-        generateReleaseNotes: ${{ env.generateReleaseNotes }}
-        omitBody: ${{ env.omitBody }} # omitBody is true when the release is a official release.
-        allowUpdates: true
-        artifacts: |
-          **/greptime-*/*

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

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

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

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

.github/actions/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,64 +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: false
-  version:
-    description: Version of the artifact
-    required: true
-  working-dir:
-    description: Working directory to upload the artifacts
-    required: false
-    default: .
-runs:
-  using: composite
-  steps:
-    - name: Create artifacts directory
-      if: ${{ inputs.target-file != '' }}
-      working-directory: ${{ inputs.working-dir }}
-      shell: bash
-      run: |
-        mkdir -p ${{ inputs.artifacts-dir }} && \
-        cp ${{ inputs.target-file }} ${{ inputs.artifacts-dir }}
-
-    # 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 }}
-
-    - name: Calculate checksum
-      if: runner.os != 'Windows'
-      working-directory: ${{ inputs.working-dir }}
-      shell: bash
-      run: |
-        echo $(shasum -a 256 ${{ inputs.artifacts-dir }}.tar.gz | cut -f1 -d' ') > ${{ inputs.artifacts-dir }}.sha256sum
-
-    - name: Calculate checksum on Windows
-      if: runner.os == 'Windows'
-      working-directory: ${{ inputs.working-dir }}
-      shell: pwsh
-      run: Get-FileHash ${{ inputs.artifacts-dir }}.tar.gz -Algorithm SHA256 | select -ExpandProperty Hash > ${{ inputs.artifacts-dir }}.sha256sum
-
-    # Note: The artifacts will be double zip compressed(related issue: https://github.com/actions/upload-artifact/issues/39).
-    # However, when we use 'actions/download-artifact' to download the artifacts, it will be automatically unzipped.
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ inputs.artifacts-dir }}
-        path: ${{ inputs.working-dir }}/${{ inputs.artifacts-dir }}.tar.gz
-
-    - name: Upload checksum
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ inputs.artifacts-dir }}.sha256sum
-        path: ${{ inputs.working-dir }}/${{ inputs.artifacts-dir }}.sha256sum

.github/doc-label-config.yml

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

.github/pr-title-breaking-change-label-config.json

@@ -1,13 +0,0 @@
-{
-    "LABEL": {
-        "name": "breaking change",
-        "color": "D93F0B"
-    },
-    "CHECKS": {
-        "regexp": "^(?:(?!!:).)*$",
-        "ignoreLabels": [
-            "ignore-title"
-        ],
-        "alwaysPassCI": true
-    }
-}

.github/pr-title-checker-config.json

@@ -1,12 +1,10 @@
 {
-    "LABEL": {
-        "name": "Invalid PR Title",
-        "color": "B60205"
-    },
-    "CHECKS": {
-        "regexp": "^(feat|fix|test|refactor|chore|style|docs|perf|build|ci|revert)(\\(.*\\))?\\!?:.*",
-        "ignoreLabels": [
-            "ignore-title"
-        ]
-    }
+  "LABEL": {
+    "name": "Invalid PR Title",
+    "color": "B60205"
+  },
+  "CHECKS": {
+    "regexp": "^(feat|fix|test|refactor|chore|style|docs|perf|build|ci|revert)(\\(.*\\))?:.*",
+    "ignoreLabels" : ["ignore-title"]
+  }
 }

.github/pull_request_template.md

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

.github/scripts/copy-image.sh

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

.github/scripts/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/scripts/deploy-greptimedb.sh

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

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

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

.github/workflows/apidoc.yml

@@ -1,43 +0,0 @@
-on:
-  push:
-    branches:
-      - main
-    paths-ignore:
-      - 'docs/**'
-      - 'config/**'
-      - '**.md'
-      - '.dockerignore'
-      - 'docker/**'
-      - '.gitignore'
-
-name: Build API docs
-
-env:
-  RUST_TOOLCHAIN: nightly-2024-04-18
-
-jobs:
-  apidoc:
-    runs-on: ubuntu-20.04
-    steps:
-    - uses: actions/checkout@v4
-    - uses: arduino/setup-protoc@v3
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-    - uses: dtolnay/rust-toolchain@master
-      with:
-        toolchain: ${{ env.RUST_TOOLCHAIN }}
-    - run: cargo doc --workspace --no-deps --document-private-items
-    - run: |
-        cat <<EOF > target/doc/index.html
-        <!DOCTYPE html>
-        <html>
-        <head>
-        <meta http-equiv="refresh" content="0; url='greptime/'" />
-        </head>
-        <body></body></html>
-        EOF
-    - name: Publish dist directory
-      uses: JamesIves/github-pages-deploy-action@v4
-      with:
-        folder: target/doc
-        single-commit: true

.github/workflows/coverage.yml

@@ -0,0 +1,64 @@
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+    paths-ignore:
+      - 'docs/**'
+      - 'config/**'
+      - '**.md'
+      - '.dockerignore'
+      - 'docker/**'
+      - '.gitignore'
+  push:
+    branches:
+      - "main"
+      - "develop"
+    paths-ignore:
+      - 'docs/**'
+      - 'config/**'
+      - '**.md'
+      - '.dockerignore'
+      - 'docker/**'
+      - '.gitignore'
+  workflow_dispatch:
+
+name: Code coverage
+
+env:
+  RUST_TOOLCHAIN: nightly-2022-07-14
+
+jobs:
+  coverage:
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest-8-cores
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-protoc@v1
+      - name: Install 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 latest nextest release
+        uses: taiki-e/install-action@nextest
+      - 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
+        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 }}
+          UNITTEST_LOG_DIR: "__unittest_logs"
+      - name: Codecov upload
+        uses: codecov/codecov-action@v2
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: ./lcov.info
+          flags: rust
+          fail_ci_if_error: true
+          verbose: true

.github/workflows/dev-build.yml

@@ -1,345 +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-20.04
-          - ubuntu-20.04-8-cores
-          - ubuntu-20.04-16-cores
-          - ubuntu-20.04-32-cores
-          - ubuntu-20.04-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
-      cargo_profile:
-        type: choice
-        description: The cargo profile to use in building GreptimeDB.
-        default: nightly
-        options:
-          - dev
-          - release
-          - nightly
-
-# Use env variables to control all the release process.
-env:
-  CARGO_PROFILE: ${{ inputs.cargo_profile }}
-
-  # 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-20.04
-    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@v4
-        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@v4
-        with:
-          fetch-depth: 0
-
-      - name: Checkout greptimedb
-        uses: actions/checkout@v4
-        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 }}
-          dev-mode: true # Only build the standard greptime binary.
-          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@v4
-        with:
-          fetch-depth: 0
-
-      - name: Checkout greptimedb
-        uses: actions/checkout@v4
-        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 }}
-          dev-mode: true # Only build the standard greptime binary.
-          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-20.04
-    outputs:
-      build-result: ${{ steps.set-build-result.outputs.build-result }}
-    steps:
-      - uses: actions/checkout@v4
-        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-cn-artifacts:
-    name: Release artifacts to CN region
-    if: ${{ inputs.release_images || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-      release-images-to-dockerhub,
-    ]
-    runs-on: ubuntu-20.04
-    continue-on-error: true
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Release artifacts to CN region
-        uses: ./.github/actions/release-cn-artifacts
-        with:
-          src-image-registry: docker.io
-          src-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          src-image-name: ${{ env.IMAGE_NAME }}
-          dst-image-registry-username: ${{ secrets.ALICLOUD_USERNAME }}
-          dst-image-registry-password: ${{ secrets.ALICLOUD_PASSWORD }}
-          dst-image-registry: ${{ vars.ACR_IMAGE_REGISTRY }}
-          dst-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          version: ${{ needs.allocate-runners.outputs.version }}
-          aws-cn-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
-          aws-cn-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
-          aws-cn-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
-          aws-cn-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
-          dev-mode: true                     # Only build the standard images(exclude centos images).
-          push-latest-tag: false             # Don't push the latest tag to registry.
-          update-version-info: false         # Don't update the version info in S3.
-
-  stop-linux-amd64-runner: # It's always run as the last job in the workflow to make sure that the runner is released.
-    name: Stop linux-amd64 runner
-    # Only run this job when the runner is allocated.
-    if: ${{ always() }}
-    runs-on: ubuntu-20.04
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-    ]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        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-20.04
-    needs: [
-      allocate-runners,
-      build-linux-arm64-artifacts,
-    ]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        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-20.04
-    env:
-      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_DEVELOP_CHANNEL }}
-    steps:
-      - name: Notifiy dev build successful result
-        uses: slackapi/slack-github-action@v1.23.0
-        if: ${{ needs.release-images-to-dockerhub.outputs.build-result == 'success' }}
-        with:
-          payload: |
-            {"text": "GreptimeDB's ${{ env.NEXT_RELEASE_VERSION }} build has completed successfully."}
-
-      - name: Notifiy dev build failed result
-        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,17 +1,15 @@
 on:
-  merge_group:
   pull_request:
-    types: [ opened, synchronize, reopened, ready_for_review ]
+    types: [opened, synchronize, reopened, ready_for_review]
     paths-ignore:
       - 'docs/**'
       - 'config/**'
       - '**.md'
       - '.dockerignore'
       - 'docker/**'
-      - '.gitignore'
-      - 'grafana/**'
   push:
     branches:
+      - develop
       - main
     paths-ignore:
       - 'docs/**'
@@ -20,330 +18,124 @@ on:
       - '.dockerignore'
       - 'docker/**'
       - '.gitignore'
-      - 'grafana/**'
   workflow_dispatch:
 
 name: CI
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
 env:
-  RUST_TOOLCHAIN: nightly-2024-04-18
+  RUST_TOOLCHAIN: nightly-2022-07-14
 
 jobs:
-  check-typos-and-docs:
-    name: Check typos and docs
-    runs-on: ubuntu-20.04
+  typos:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: crate-ci/typos@v1.13.10
-      - name: Check the config docs
-        run: |
-          make config-docs && \
-          git diff --name-only --exit-code ./config/config.md  \
-          || (echo "'config/config.md' is not up-to-date, please run 'make config-docs'." && exit 1)
+      - uses: actions/checkout@v2
+      - uses: crate-ci/typos@v1.0.4
 
   check:
     name: Check
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ windows-latest, ubuntu-20.04 ]
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-protoc@v1
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          # Shares with `Clippy` job
-          shared-key: "check-lint"
       - name: Run cargo check
-        run: cargo check --locked --workspace --all-targets
+        run: cargo check --workspace --all-targets
 
   toml:
     name: Toml Check
-    runs-on: ubuntu-20.04
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: stable
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          shared-key: "check-toml"
-      - name: Install taplo
-        run: cargo +stable install taplo-cli --version ^0.9 --locked
-      - name: Run taplo
-        run: taplo format --check
-
-  build:
-    name: Build GreptimeDB binaries
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-20.04 ]
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_TOOLCHAIN }}
-      - uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          shared-key: "build-binaries"
-      - name: Build greptime binaries
-        shell: bash
-        run: cargo build --bin greptime --bin sqlness-runner
-      - name: Pack greptime binaries
-        shell: bash
-        run: |
-          mkdir bins && \
-          mv ./target/debug/greptime bins && \
-          mv ./target/debug/sqlness-runner bins
-      - name: Print greptime binaries info
-        run: ls -lh bins
-      - name: Upload artifacts
-        uses: ./.github/actions/upload-artifacts
-        with:
-          artifacts-dir: bins
-          version: current
-
-  fuzztest:
-    name: Fuzz Test
-    needs: build
+    if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target: [ "fuzz_create_table", "fuzz_alter_table", "fuzz_create_database" ]
+    timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          shared-key: "fuzz-test-targets"
-      - name: Set Rust Fuzz
-        shell: bash
-        run: |
-          sudo apt update && sudo apt install -y libfuzzer-14-dev
-          cargo install cargo-fuzz
-      - name: Download pre-built binaries
-        uses: actions/download-artifact@v4
-        with:
-          name: bins
-          path: .
-      - name: Unzip binaries
-        run: tar -xvf ./bins.tar.gz
-      - name: Run GreptimeDB
-        run: |
-          ./bins/greptime standalone start&
-      - name: Fuzz Test
-        uses: ./.github/actions/fuzz-test
-        env:
-          CUSTOM_LIBFUZZER_PATH: /usr/lib/llvm-14/lib/libFuzzer.a
-        with:
-          target: ${{ matrix.target }}
+      - name: Install taplo
+        run: cargo install taplo-cli --version ^0.8 --locked
+      - name: Run taplo
+        run: taplo format --check --option "indent_string=    "
 
-  sqlness:
-    name: Sqlness Test
-    needs: build
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-20.04 ]
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download pre-built binaries
-        uses: actions/download-artifact@v4
-        with:
-          name: bins
-          path: .
-      - name: Unzip binaries
-        run: tar -xvf ./bins.tar.gz
-      - name: Run sqlness
-        run: RUST_BACKTRACE=1 ./bins/sqlness-runner -c ./tests/cases --bins-dir ./bins
-      - name: Upload sqlness logs
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: sqlness-logs
-          path: /tmp/greptime-*.log
-          retention-days: 3
-
-  sqlness-kafka-wal:
-    name: Sqlness Test with Kafka Wal
-    needs: build
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-20.04 ]
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download pre-built binaries
-        uses: actions/download-artifact@v4
-        with:
-          name: bins
-          path: .
-      - name: Unzip binaries
-        run: tar -xvf ./bins.tar.gz
-      - name: Setup kafka server
-        working-directory: tests-integration/fixtures/kafka
-        run: docker compose -f docker-compose-standalone.yml up -d --wait
-      - name: Run sqlness
-        run: RUST_BACKTRACE=1 ./bins/sqlness-runner -w kafka -k 127.0.0.1:9092 -c ./tests/cases --bins-dir ./bins
-      - name: Upload sqlness logs
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: sqlness-logs-with-kafka-wal
-          path: /tmp/greptime-*.log
-          retention-days: 3
+  # 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
+  #     - 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"
 
   fmt:
     name: Rustfmt
-    runs-on: ubuntu-20.04
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-protoc@v1
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
           components: rustfmt
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          shared-key: "check-rust-fmt"
       - name: Run cargo fmt
         run: cargo fmt --all -- --check
 
   clippy:
     name: Clippy
-    runs-on: ubuntu-20.04
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/checkout@v3
+      - uses: arduino/setup-protoc@v1
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
           components: clippy
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
-        with:
-          # Shares across multiple jobs
-          # Shares with `Check` job
-          shared-key: "check-lint"
       - name: Run cargo clippy
-        run: cargo clippy --workspace --all-targets -- -D warnings
-
-  coverage:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-20.04-8-cores
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-      - uses: arduino/setup-protoc@v3
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - uses: KyleMayes/install-llvm-action@v1
-        with:
-          version: "14.0"
-      - name: Install toolchain
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_TOOLCHAIN }}
-          components: llvm-tools-preview
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          # Shares cross multiple jobs
-          shared-key: "coverage-test"
-      - name: Docker Cache
-        uses: ScribeMD/docker-cache@0.3.7
-        with:
-          key: docker-${{ runner.os }}-coverage
-      - name: Install latest nextest release
-        uses: taiki-e/install-action@nextest
-      - name: Install cargo-llvm-cov
-        uses: taiki-e/install-action@cargo-llvm-cov
-      - name: Install Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.10'
-      - name: Install PyArrow Package
-        run: pip install pyarrow
-      - name: Setup etcd server
-        working-directory: tests-integration/fixtures/etcd
-        run: docker compose -f docker-compose-standalone.yml up -d --wait
-      - name: Setup kafka server
-        working-directory: tests-integration/fixtures/kafka
-        run: docker compose -f docker-compose-standalone.yml up -d --wait
-      - name: Run nextest cases
-        run: cargo llvm-cov nextest --workspace --lcov --output-path lcov.info -F pyo3_backend -F dashboard
-        env:
-          CARGO_BUILD_RUSTFLAGS: "-C link-arg=-fuse-ld=lld"
-          RUST_BACKTRACE: 1
-          CARGO_INCREMENTAL: 0
-          GT_S3_BUCKET: ${{ vars.AWS_CI_TEST_BUCKET }}
-          GT_S3_ACCESS_KEY_ID: ${{ secrets.AWS_CI_TEST_ACCESS_KEY_ID }}
-          GT_S3_ACCESS_KEY: ${{ secrets.AWS_CI_TEST_SECRET_ACCESS_KEY }}
-          GT_S3_REGION: ${{ vars.AWS_CI_TEST_BUCKET_REGION }}
-          GT_ETCD_ENDPOINTS: http://127.0.0.1:2379
-          GT_KAFKA_ENDPOINTS: 127.0.0.1:9092
-          UNITTEST_LOG_DIR: "__unittest_logs"
-      - name: Codecov upload
-        uses: codecov/codecov-action@v4
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          files: ./lcov.info
-          flags: rust
-          fail_ci_if_error: false
-          verbose: true
-
-  compat:
-    name: Compatibility Test
-    needs: build
-    runs-on: ubuntu-20.04
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-      - name: Download pre-built binaries
-        uses: actions/download-artifact@v4
-        with:
-          name: bins
-          path: .
-      - name: Unzip binaries
-        run: |
-          mkdir -p ./bins/current
-          tar -xvf ./bins.tar.gz --strip-components=1 -C ./bins/current
-      - run: ./tests/compat/test-compat.sh 0.6.0
+        run: cargo clippy --workspace --all-targets -- -D warnings -D clippy::print_stdout -D clippy::print_stderr

.github/workflows/doc-issue.yml

@@ -1,4 +1,4 @@
-name: Create Issue in downstream repos
+name: Create Issue in docs repo on doc related changes
 
 on:
   issues:
@@ -11,10 +11,10 @@ on:
 jobs:
   doc_issue:
     if: github.event.label.name == 'doc update required'
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - name: create an issue in doc repo
-        uses: dacbd/create-issue-action@v1.2.1
+        uses: dacbd/create-issue-action@main
         with:
           owner: GreptimeTeam
           repo: docs
@@ -23,17 +23,3 @@ jobs:
           body: |
             A document change request is generated from
             ${{ github.event.issue.html_url || github.event.pull_request.html_url }}
-  cloud_issue:
-    if: github.event.label.name == 'cloud followup required'
-    runs-on: ubuntu-20.04
-    steps:
-      - name: create an issue in cloud repo
-        uses: dacbd/create-issue-action@v1.2.1
-        with:
-          owner: GreptimeTeam
-          repo: greptimedb-cloud
-          token: ${{ secrets.DOCS_REPO_TOKEN }}
-          title: Followup changes in ${{ github.event.issue.title || github.event.pull_request.title }}
-          body: |
-            A followup request is generated from
-            ${{ github.event.issue.html_url || github.event.pull_request.html_url }}

.github/workflows/doc-label.yml

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

.github/workflows/docs.yml

@@ -1,78 +0,0 @@
-on:
-  merge_group:
-  pull_request:
-    types: [opened, synchronize, reopened, ready_for_review]
-    paths:
-      - 'docs/**'
-      - 'config/**'
-      - '**.md'
-      - '.dockerignore'
-      - 'docker/**'
-      - '.gitignore'
-      - 'grafana/**'
-  push:
-    branches:
-      - main
-    paths:
-      - 'docs/**'
-      - 'config/**'
-      - '**.md'
-      - '.dockerignore'
-      - 'docker/**'
-      - '.gitignore'
-      - 'grafana/**'
-  workflow_dispatch:
-
-name: CI
-
-# To pass the required status check, see:
-# 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-20.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: crate-ci/typos@v1.13.10
-
-  check:
-    name: Check
-    runs-on: ubuntu-20.04
-    steps:
-      - run: 'echo "No action required"'
-
-  fmt:
-    name: Rustfmt
-    runs-on: ubuntu-20.04
-    steps:
-      - run: 'echo "No action required"'
-
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-20.04
-    steps:
-      - run: 'echo "No action required"'
-
-  coverage:
-    runs-on: ubuntu-20.04
-    steps:
-      - run: 'echo "No action required"'
-
-  sqlness:
-    name: Sqlness Test
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-20.04 ]
-    steps:
-      - run: 'echo "No action required"'
-
-  sqlness-kafka-wal:
-    name: Sqlness Test with Kafka Wal
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-20.04 ]
-    steps:
-      - run: 'echo "No action required"'

.github/workflows/license.yaml

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

.github/workflows/nightly-build.yml

@@ -1,309 +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-20.04
-          - ubuntu-20.04-8-cores
-          - ubuntu-20.04-16-cores
-          - ubuntu-20.04-32-cores
-          - ubuntu-20.04-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-20.04
-    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@v4
-        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@v4
-        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 }}
-
-  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@v4
-        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-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-20.04
-    outputs:
-      nightly-build-result: ${{ steps.set-nightly-build-result.outputs.nightly-build-result }}
-    steps:
-      - uses: actions/checkout@v4
-        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-cn-artifacts:
-    name: Release artifacts to CN region
-    if: ${{ inputs.release_images || github.event_name == 'schedule' }}
-    needs: [
-      allocate-runners,
-      release-images-to-dockerhub,
-    ]
-    runs-on: ubuntu-20.04
-    # When we push to ACR, it's easy to fail due to some unknown network issues.
-    # However, we don't want to fail the whole workflow because of this.
-    # The ACR have daily sync with DockerHub, so don't worry about the image not being updated.
-    continue-on-error: true
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Release artifacts to CN region
-        uses: ./.github/actions/release-cn-artifacts
-        with:
-          src-image-registry: docker.io
-          src-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          src-image-name: greptimedb
-          dst-image-registry-username: ${{ secrets.ALICLOUD_USERNAME }}
-          dst-image-registry-password: ${{ secrets.ALICLOUD_PASSWORD }}
-          dst-image-registry: ${{ vars.ACR_IMAGE_REGISTRY }}
-          dst-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          version: ${{ needs.allocate-runners.outputs.version }}
-          aws-cn-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
-          aws-cn-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
-          aws-cn-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
-          aws-cn-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
-          dev-mode: false
-          update-version-info: false  # Don't update version info in S3.
-          push-latest-tag: false      # Don't push the latest tag to registry.
-
-  stop-linux-amd64-runner: # It's always run as the last job in the workflow to make sure that the runner is released.
-    name: Stop linux-amd64 runner
-    # Only run this job when the runner is allocated.
-    if: ${{ always() }}
-    runs-on: ubuntu-20.04
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-    ]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        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-20.04
-    needs: [
-      allocate-runners,
-      build-linux-arm64-artifacts,
-    ]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        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-20.04
-    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/nightly-ci.yml

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

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

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

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

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

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

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

.github/workflows/release.yml

@@ -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,453 +5,222 @@ 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-20.04
-          - ubuntu-20.04-8-cores
-          - ubuntu-20.04-16-cores
-          - ubuntu-20.04-32-cores
-          - ubuntu-20.04-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
-      build_windows_artifacts:
-        type: boolean
-        description: Build Windows artifacts
-        required: false
-        default: false
-      publish_github_release:
-        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
+  workflow_dispatch:
+
+name: Release
 
-# Use env variables to control all the release process.
 env:
-  # The arguments of building greptime.
-  RUST_TOOLCHAIN: nightly-2024-04-18
-  CARGO_PROFILE: nightly
+  RUST_TOOLCHAIN: nightly-2022-07-14
 
-  # Controls whether to run tests, include unit-test, integration-test and sqlness.
-  DISABLE_RUN_TESTS: ${{ inputs.skip_test || vars.DEFAULT_SKIP_TEST }}
+  # FIXME(zyy17): Would be better to use `gh release list -L 1 | cut -f 3` to get the latest release version tag, but for a long time, we will stay at 'v0.1.0-alpha-*'.
+  SCHEDULED_BUILD_VERSION_PREFIX: v0.1.0-alpha
 
-  # The scheduled version is '${{ env.NEXT_RELEASE_VERSION }}-nightly-YYYYMMDD', like v0.2.0-nigthly-20230313;
-  NIGHTLY_RELEASE_PREFIX: nightly
-  # Note: The NEXT_RELEASE_VERSION should be modified manually by every formal release.
-  NEXT_RELEASE_VERSION: v0.8.0
+  # In the future, we can change SCHEDULED_PERIOD to nightly.
+  SCHEDULED_PERIOD: weekly
 
 jobs:
-  allocate-runners:
-    name: Allocate runners
-    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    runs-on: ubuntu-20.04
-    outputs:
-      linux-amd64-runner: ${{ steps.start-linux-amd64-runner.outputs.label }}
-      linux-arm64-runner: ${{ steps.start-linux-arm64-runner.outputs.label }}
-      macos-runner: ${{ inputs.macos_runner || vars.DEFAULT_MACOS_RUNNER }}
-      windows-runner: windows-latest-8-cores
-
-      # The following EC2 resource id will be used for resource releasing.
-      linux-amd64-ec2-runner-label: ${{ steps.start-linux-amd64-runner.outputs.label }}
-      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@v4
-        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@v4
-        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 }}
-
-  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@v4
-        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 }}
-
-  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-latest-16-cores
+            file: greptime-linux-amd64
+          - arch: aarch64-unknown-linux-gnu
+            os: ubuntu-latest-16-cores
+            file: greptime-linux-arm64
+          - arch: aarch64-apple-darwin
+            os: macos-latest
+            file: greptime-darwin-arm64
+          - arch: x86_64-apple-darwin
+            os: macos-latest
+            file: greptime-darwin-amd64
     runs-on: ${{ matrix.os }}
-    outputs:
-      build-macos-result: ${{ steps.set-build-macos-result.outputs.build-macos-result }}
-    needs: [
-      allocate-runners,
-    ]
-    if: ${{ inputs.build_macos_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
     steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
+      - name: Checkout sources
+        uses: actions/checkout@v3
 
-      - uses: ./.github/actions/build-macos-artifacts
+      - name: Cache cargo assets
+        id: cache
+        uses: actions/cache@v3
         with:
-          arch: ${{ matrix.arch }}
-          rust-toolchain: ${{ env.RUST_TOOLCHAIN }}
-          cargo-profile: ${{ env.CARGO_PROFILE }}
-          features: ${{ matrix.features }}
-          version: ${{ needs.allocate-runners.outputs.version }}
-          disable-run-tests: ${{ env.DISABLE_RUN_TESTS }}
-          artifacts-dir: ${{ matrix.artifacts-dir-prefix }}-${{ needs.allocate-runners.outputs.version }}
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ matrix.arch }}-build-cargo-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Set build macos result
-        id: set-build-macos-result
+      - 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: |
-          echo "build-macos-result=success" >> $GITHUB_OUTPUT    
+          brew install protobuf
 
-  build-windows-artifacts:
-    name: Build Windows artifacts
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ${{ needs.allocate-runners.outputs.windows-runner }}
-            arch: x86_64-pc-windows-msvc
-            features: servers/dashboard
-            artifacts-dir-prefix: greptime-windows-amd64
-          - os: ${{ needs.allocate-runners.outputs.windows-runner }}
-            arch: x86_64-pc-windows-msvc
-            features: pyo3_backend,servers/dashboard
-            artifacts-dir-prefix: greptime-windows-amd64-pyo3
-    runs-on: ${{ matrix.os }}
-    outputs:
-      build-windows-result: ${{ steps.set-build-windows-result.outputs.build-windows-result }}
-    needs: [
-      allocate-runners,
-    ]
-    if: ${{ inputs.build_windows_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
-    steps:
-      - run: git config --global core.autocrlf false
-
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - uses: ./.github/actions/build-windows-artifacts
-        with:
-          arch: ${{ matrix.arch }}
-          rust-toolchain: ${{ env.RUST_TOOLCHAIN }}
-          cargo-profile: ${{ env.CARGO_PROFILE }}
-          features: ${{ matrix.features }}
-          version: ${{ needs.allocate-runners.outputs.version }}
-          disable-run-tests: ${{ env.DISABLE_RUN_TESTS }}
-          artifacts-dir: ${{ matrix.artifacts-dir-prefix }}-${{ needs.allocate-runners.outputs.version }}
-
-      - name: Set build windows result
-        id: set-build-windows-result
+      - name: Install dependencies for linux
+        if: contains(matrix.arch, 'linux') && endsWith(matrix.arch, '-gnu')
         run: |
-          echo "build-windows-result=success" >> $Env:GITHUB_OUTPUT
+          sudo apt-get -y update
+          sudo apt-get -y install libssl-dev pkg-config g++-aarch64-linux-gnu gcc-aarch64-linux-gnu
 
-  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
-    outputs:
-      build-image-result: ${{ steps.set-build-image-result.outputs.build-image-result }}
-    steps:
-      - uses: actions/checkout@v4
+      - name: Install rust toolchain
+        uses: dtolnay/rust-toolchain@master
         with:
-          fetch-depth: 0
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
+          targets: ${{ matrix.arch }}
 
-      - 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 }}
+      - name: Output package versions
+        run: protoc --version ; cargo version ; rustc --version ; gcc --version ; g++ --version
 
-      - name: Set build image result
-        id: set-build-image-result
+      - name: Run cargo build
+        run: cargo build ${{ matrix.opts }} --release --locked --target ${{ matrix.arch }}
+
+      - name: Calculate checksum and rename binary
+        shell: bash
         run: |
-          echo "build-image-result=success" >> $GITHUB_OUTPUT    
+          cd target/${{ matrix.arch }}/release
+          chmod +x greptime
+          tar -zcvf ${{ matrix.file }}.tgz greptime
+          echo $(shasum -a 256 ${{ matrix.file }}.tgz | cut -f1 -d' ') > ${{ matrix.file }}.sha256sum
 
-  release-cn-artifacts:
-    name: Release artifacts to CN region
-    if: ${{ inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
-    needs: [ # The job have to wait for all the artifacts are built.
-      allocate-runners,
-      build-linux-amd64-artifacts,
-      build-linux-arm64-artifacts,
-      build-macos-artifacts,
-      build-windows-artifacts,
-      release-images-to-dockerhub,
-    ]
-    runs-on: ubuntu-20.04
-    # 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
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.file }}
+          path: target/${{ matrix.arch }}/release/${{ matrix.file }}.tgz
+
+      - name: Upload checksum of artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.file }}.sha256sum
+          path: target/${{ matrix.arch }}/release/${{ matrix.file }}.sha256sum
+  release:
+    name: Release artifacts
+    needs: [build]
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
+      - name: Checkout sources
+        uses: actions/checkout@v3
 
-      - name: Release artifacts to CN region
-        uses: ./.github/actions/release-cn-artifacts
-        with:
-          src-image-registry: docker.io
-          src-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          src-image-name: greptimedb
-          dst-image-registry-username: ${{ secrets.ALICLOUD_USERNAME }}
-          dst-image-registry-password: ${{ secrets.ALICLOUD_PASSWORD }}
-          dst-image-registry: ${{ vars.ACR_IMAGE_REGISTRY }}
-          dst-image-namespace: ${{ vars.IMAGE_NAMESPACE }}
-          version: ${{ needs.allocate-runners.outputs.version }}
-          aws-cn-s3-bucket: ${{ vars.AWS_RELEASE_BUCKET }}
-          aws-cn-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
-          aws-cn-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
-          aws-cn-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
-          dev-mode: false
-          update-version-info: true
-          push-latest-tag: true
+      - name: Download artifacts
+        uses: actions/download-artifact@v3
 
-  publish-github-release:
-    name: Create GitHub release and upload artifacts
-    if: ${{ inputs.publish_github_release || github.event_name == 'push' || github.event_name == 'schedule' }}
-    needs: [ # The job have to wait for all the artifacts are built.
-      allocate-runners,
-      build-linux-amd64-artifacts,
-      build-linux-arm64-artifacts,
-      build-macos-artifacts,
-      build-windows-artifacts,
-      release-images-to-dockerhub,
-    ]
-    runs-on: ubuntu-20.04
+      - name: Configure scheduled build version # the version would be ${SCHEDULED_BUILD_VERSION_PREFIX}-YYYYMMDD-${SCHEDULED_PERIOD}, like v0.1.0-alpha-20221119-weekly.
+        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 "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:
+          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-*
+
+  docker:
+    name: Build docker image
+    needs: [build]
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
+      - name: Checkout sources
+        uses: actions/checkout@v3
 
-      - name: Publish GitHub release
-        uses: ./.github/actions/publish-github-release
+      - name: Download amd64 binary
+        uses: actions/download-artifact@v3
         with:
-          version: ${{ needs.allocate-runners.outputs.version }}
+          name: greptime-linux-amd64
+          path: amd64
 
-  ### 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() }}
-    runs-on: ubuntu-20.04
-    needs: [
-      allocate-runners,
-      build-linux-amd64-artifacts,
-    ]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
+      - name: Unzip the amd64 artifacts
+        run: |
+          cd amd64
+          tar xvf greptime-linux-amd64.tgz
+          rm greptime-linux-amd64.tgz
 
-      - name: Stop EC2 runner
-        uses: ./.github/actions/stop-runner
+      - name: Download arm64 binary
+        uses: actions/download-artifact@v3
         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 }}
+          name: greptime-linux-arm64
+          path: arm64
 
-  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-20.04
-    needs: [
-      allocate-runners,
-      build-linux-arm64-artifacts,
-    ]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
+      - name: Unzip the arm64 artifacts
+        run: |
+          cd arm64
+          tar xvf greptime-linux-arm64.tgz
+          rm greptime-linux-arm64.tgz
 
-      - name: Stop EC2 runner
-        uses: ./.github/actions/stop-runner
+      - name: Login to UCloud Container Registry
+        uses: docker/login-action@v2
         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 }}
+          registry: uhub.service.ucloud.cn
+          username: ${{ secrets.UCLOUD_USERNAME }}
+          password: ${{ secrets.UCLOUD_PASSWORD }}
 
-  notification:
-    if: ${{ always() }} # Not requiring successful dependent jobs, always run.
-    name: Send notification to Greptime team
-    needs: [
-      release-images-to-dockerhub,
-      build-macos-artifacts,
-      build-windows-artifacts,
-    ]
-    runs-on: ubuntu-20.04
-    env:
-      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_DEVELOP_CHANNEL }}
-    steps:
-      - name: Notifiy release successful result
-        uses: slackapi/slack-github-action@v1.25.0
-        if: ${{ needs.release-images-to-dockerhub.outputs.build-image-result == 'success' && needs.build-windows-artifacts.outputs.build-windows-result == 'success' && needs.build-macos-artifacts.outputs.build-macos-result == 'success' }}
+      - name: Login to Dockerhub
+        uses: docker/login-action@v2
         with:
-          payload: |
-            {"text": "GreptimeDB's release version has completed successfully."}
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Notifiy release failed result
-        uses: slackapi/slack-github-action@v1.25.0
-        if: ${{ needs.release-images-to-dockerhub.outputs.build-image-result != 'success' || needs.build-windows-artifacts.outputs.build-windows-result != 'success' || needs.build-macos-artifacts.outputs.build-macos-result != 'success' }}
+      - 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: Build and push
+        uses: docker/build-push-action@v3
         with:
-          payload: |
-            {"text": "GreptimeDB's release version has failed, please check 'https://github.com/GreptimeTeam/greptimedb/actions/workflows/release.yml'."}
+          context: .
+          file: ./docker/ci/Dockerfile
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: |
+            greptime/greptimedb:latest
+            greptime/greptimedb:${{ env.IMAGE_TAG }}
+            uhub.service.ucloud.cn/greptime/greptimedb:latest
+            uhub.service.ucloud.cn/greptime/greptimedb:${{ env.IMAGE_TAG }}

.github/workflows/unassign.yml

@@ -1,21 +0,0 @@
-name: Auto Unassign
-on:
-  schedule:
-    - cron: '4 2 * * *'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  issues: write
-  pull-requests: write
-
-jobs:
-  auto-unassign:
-    name: Auto Unassign
-    runs-on: ubuntu-latest
-    steps:
-      - name: Auto Unassign
-        uses: tisonspieces/auto-unassign@main
-        with:
-          token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
-          repository: ${{ github.repository }}

.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
@@ -37,16 +35,3 @@ benchmarks/data
 
 # dotenv
 .env
-
-# dashboard files
-!/src/servers/dashboard/VERSION
-/src/servers/dashboard/*
-
-# Vscode workspace
-*.code-workspace
-
-venv/
-
-# Fuzz tests 
-tests-fuzz/artifacts/
-tests-fuzz/corpus/

.licenserc.yaml

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

.pre-commit-config.yaml

@@ -5,11 +5,11 @@ repos:
     -    id: conventional-pre-commit
          stages: [commit-msg]
 
-# -   repo: https://github.com/DevinR528/cargo-sort
-#     rev: e6a795bc6b2c0958f9ef52af4863bbd7cc17238f
-#     hooks:
-#     -    id: cargo-sort
-#          args: ["--workspace"]
+-   repo: https://github.com/DevinR528/cargo-sort
+    rev: e6a795bc6b2c0958f9ef52af4863bbd7cc17238f
+    hooks:
+    -    id: cargo-sort
+         args: ["--workspace"]
 
 -   repo: https://github.com/doublify/pre-commit-rust
     rev: v1.0

CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+info@greptime.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

CONTRIBUTING.md

@@ -1,8 +1,8 @@
-# Welcome 👋
+# Welcome!
 
 Thanks a lot for considering contributing to GreptimeDB. We believe people like you would make GreptimeDB a great product. We intend to build a community where individuals can have open talks, show respect for one another, and speak with true ❤️. Meanwhile, we are to keep transparency and make your effort count here.
 
-Please read the guidelines, and they can help you get started. Communicate with respect to developers maintaining and developing the project. In return, they should reciprocate that respect by addressing your issue, reviewing changes, as well as helping finalize and merge your pull requests.
+Read the guidelines, and they can help you get started. Communicate with respect to developers maintaining and developing the project. In return, they should reciprocate that respect by addressing your issue, reviewing changes, as well as helping finalize and merge your pull requests.
 
 Follow our [README](https://github.com/GreptimeTeam/greptimedb#readme) to get the whole picture of the project. To learn about the design of GreptimeDB, please refer to the [design docs](https://github.com/GrepTimeTeam/docs).
 
@@ -10,7 +10,7 @@ Follow our [README](https://github.com/GreptimeTeam/greptimedb#readme) to get th
 
 It can feel intimidating to contribute to a complex project, but it can also be exciting and fun. These general notes will help everyone participate in this communal activity.
 
-- Follow the [Code of Conduct](https://github.com/GreptimeTeam/greptimedb/blob/main/CODE_OF_CONDUCT.md)
+- Follow the [Code of Conduct](https://github.com/GreptimeTeam/greptimedb/blob/develop/CODE_OF_CONDUCT.md)
 - Small changes make huge differences. We will happily accept a PR making a single character change if it helps move forward. Don't wait to have everything working.
 - Check the closed issues before opening your issue.
 - Try to follow the existing style of the code.
@@ -21,12 +21,12 @@ Pull requests are great, but we accept all kinds of other help if you like. Such
 - Write tutorials or blog posts. Blog, speak about, or create tutorials about one of GreptimeDB's many features. Mention [@greptime](https://twitter.com/greptime) on Twitter and email info@greptime.com so we can give pointers and tips and help you spread the word by promoting your content on Greptime communication channels.
 - Improve the documentation. [Submit documentation](http://github.com/greptimeTeam/docs/) updates, enhancements, designs, or bug fixes, and fixing any spelling or grammar errors will be very much appreciated.
 - Present at meetups and conferences about your GreptimeDB projects. Your unique challenges and successes in building things with GreptimeDB can provide great speaking material. We'd love to review your talk abstract, so get in touch with us if you'd like some help!
-- Submitting bug reports. To report a bug or a security issue, you can [open a new GitHub issue](https://github.com/GrepTimeTeam/greptimedb/issues/new).
+- Submit bug reports. To report a bug or a security issue, you can [open a new GitHub issue](https://github.com/GrepTimeTeam/greptimedb/issues/new).
 - Speak up feature requests. Send feedback is a great way for us to understand your different use cases of GreptimeDB better. If you want to share your experience with GreptimeDB, or if you want to discuss any ideas, you can start a discussion on [GitHub discussions](https://github.com/GreptimeTeam/greptimedb/discussions), chat with the Greptime team on [Slack](https://greptime.com/slack), or you can tweet [@greptime](https://twitter.com/greptime) on Twitter.
 
 ## Code of Conduct
 
-Also, there are things that we are not looking for because they don't match the goals of the product or benefit the community. Please read [Code of Conduct](https://github.com/GreptimeTeam/greptimedb/blob/main/CODE_OF_CONDUCT.md); we hope everyone can keep good manners and become an honored member.
+Also, there are things that we are not looking for because they don't match the goals of the product or benefit the community. Please read [Code of Conduct](https://github.com/GreptimeTeam/greptimedb/blob/develop/CODE_OF_CONDUCT.md); we hope everyone can keep good manners and become an honored member.
 
 ## License
 
@@ -49,40 +49,40 @@ GreptimeDB uses the [Apache 2.0 license](https://github.com/GreptimeTeam/greptim
 ### Before PR
 
 - To ensure that community is free and confident in its ability to use your contributions, please sign the Contributor License Agreement (CLA) which will be incorporated in the pull request process.
-- Make sure all files have proper license header (running `docker run --rm -v $(pwd):/github/workspace ghcr.io/korandoru/hawkeye-native:v3 format` from the project root).
-- Make sure all your codes are formatted and follow the [coding style](https://pingcap.github.io/style-guide/rust/) and [style guide](http://github.com/greptimeTeam/docs/style-guide.md).
-- Make sure all unit tests are passed (using `cargo test --workspace` or [nextest](https://nexte.st/index.html) `cargo nextest run`).
-- Make sure all clippy warnings are fixed (you can check it locally by running `cargo clippy --workspace --all-targets -- -D warnings`).
+- Make sure all your codes are formatted and follow the [coding style](https://pingcap.github.io/style-guide/rust/).
+- Make sure all unit tests are passed.
+- Make sure all clippy warnings are fixed (you can check it locally by running `cargo clippy --workspace --all-targets -- -D warnings -D clippy::print_stdout -D clippy::print_stderr`).
 
 #### `pre-commit` Hooks
-
 You could setup the [`pre-commit`](https://pre-commit.com/#plugins) hooks to run these checks on every commit automatically.
 
 1. Install `pre-commit`
-
-        pip install pre-commit
-
-    or
-
-        brew install pre-commit
+```
+$ pip install pre-commit
+```
+or
+```
+$ brew install pre-commit
+```
 
 2. Install the `pre-commit` hooks
+```
+$ pre-commit install
+pre-commit installed at .git/hooks/pre-commit
 
-        $ pre-commit install
-        pre-commit installed at .git/hooks/pre-commit
+$ pre-commit install --hook-type commit-msg
+pre-commit installed at .git/hooks/commit-msg
 
-        $ pre-commit install --hook-type commit-msg
-        pre-commit installed at .git/hooks/commit-msg
+$ pre-commit install --hook-type pre-push
+pre-commit installed at .git/hooks/pre-pus
+```
 
-        $ pre-commit install --hook-type pre-push
-        pre-commit installed at .git/hooks/pre-push
-
-Now, `pre-commit` will run automatically on `git commit`.
+now `pre-commit` will run automatically on `git commit`.
 
 ### Title
 
 The titles of pull requests should be prefixed with category names listed in [Conventional Commits specification](https://www.conventionalcommits.org/en/v1.0.0)
-like `feat`/`fix`/`docs`, with a concise summary of code change following. AVOID using the last commit message as pull request title.
+like `feat`/`fix`/`docs`, with a concise summary of code change following. DO NOT use last commit message as pull request title.
 
 ### Description
 
@@ -101,13 +101,11 @@ of what you were trying to do and what went wrong. You can also reach for help i
 
 ## Community
 
-The core team will be thrilled if you would like to participate in any way you like. When you are stuck, try to ask for help by filing an issue, with a detailed description of what you were trying to do and what went wrong. If you have any questions or if you would like to get involved in our community, please check out:
-
+The core team will be thrilled if you participate in any way you like. When you are stuck, try ask for help by filing an issue, with a detailed description of what you were trying to do and what went wrong. If you have any questions or if you would like to get involved in our community, please check out:
 - [GreptimeDB Community Slack](https://greptime.com/slack)
 - [GreptimeDB Github Discussions](https://github.com/GreptimeTeam/greptimedb/discussions)
 
 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,237 +2,42 @@
 members = [
     "benchmarks",
     "src/api",
-    "src/auth",
     "src/catalog",
     "src/client",
     "src/cmd",
     "src/common/base",
     "src/common/catalog",
-    "src/common/config",
-    "src/common/datasource",
     "src/common/error",
     "src/common/function",
-    "src/common/macro",
-    "src/common/greptimedb-telemetry",
+    "src/common/function-macro",
     "src/common/grpc",
     "src/common/grpc-expr",
-    "src/common/mem-prof",
-    "src/common/meta",
-    "src/common/plugins",
-    "src/common/procedure",
-    "src/common/procedure-test",
     "src/common/query",
     "src/common/recordbatch",
     "src/common/runtime",
     "src/common/substrait",
     "src/common/telemetry",
-    "src/common/test-util",
     "src/common/time",
-    "src/common/decimal",
-    "src/common/version",
-    "src/common/wal",
     "src/datanode",
     "src/datatypes",
-    "src/file-engine",
-    "src/flow",
     "src/frontend",
     "src/log-store",
     "src/meta-client",
     "src/meta-srv",
-    "src/metric-engine",
-    "src/mito2",
+    "src/mito",
     "src/object-store",
-    "src/operator",
-    "src/partition",
-    "src/plugins",
     "src/promql",
-    "src/puffin",
     "src/query",
     "src/script",
     "src/servers",
     "src/session",
     "src/sql",
+    "src/storage",
     "src/store-api",
     "src/table",
-    "src/index",
-    "tests-fuzz",
     "tests-integration",
     "tests/runner",
 ]
-resolver = "2"
-
-[workspace.package]
-version = "0.7.2"
-edition = "2021"
-license = "Apache-2.0"
-
-[workspace.lints]
-clippy.print_stdout = "warn"
-clippy.print_stderr = "warn"
-clippy.implicit_clone = "warn"
-clippy.readonly_write_lock = "allow"
-rust.unknown_lints = "deny"
-# Remove this after https://github.com/PyO3/pyo3/issues/4094
-rust.non_local_definitions = "allow"
-
-[workspace.dependencies]
-# We turn off default-features for some dependencies here so the workspaces which inherit them can
-# selectively turn them on if needed, since we can override default-features = true (from false)
-# for the inherited dependency but cannot do the reverse (override from true to false).
-#
-# See for more detaiils: https://github.com/rust-lang/cargo/issues/11329
-ahash = { version = "0.8", features = ["compile-time-rng"] }
-aquamarine = "0.3"
-arrow = { version = "51.0.0", features = ["prettyprint"] }
-arrow-array = { version = "51.0.0", default-features = false, features = ["chrono-tz"] }
-arrow-flight = "51.0"
-arrow-ipc = { version = "51.0.0", default-features = false, features = ["lz4"] }
-arrow-schema = { version = "51.0", features = ["serde"] }
-async-stream = "0.3"
-async-trait = "0.1"
-axum = { version = "0.6", features = ["headers"] }
-base64 = "0.21"
-bigdecimal = "0.4.2"
-bitflags = "2.4.1"
-bytemuck = "1.12"
-bytes = { version = "1.5", features = ["serde"] }
-chrono = { version = "0.4", features = ["serde"] }
-clap = { version = "4.4", features = ["derive"] }
-dashmap = "5.4"
-datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "34eda15b73a9e278af8844b30ed2f1c21c10359c" }
-datafusion-common = { git = "https://github.com/apache/arrow-datafusion.git", rev = "34eda15b73a9e278af8844b30ed2f1c21c10359c" }
-datafusion-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "34eda15b73a9e278af8844b30ed2f1c21c10359c" }
-datafusion-functions = { git = "https://github.com/apache/arrow-datafusion.git", rev = "34eda15b73a9e278af8844b30ed2f1c21c10359c" }
-datafusion-optimizer = { git = "https://github.com/apache/arrow-datafusion.git", rev = "34eda15b73a9e278af8844b30ed2f1c21c10359c" }
-datafusion-physical-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "34eda15b73a9e278af8844b30ed2f1c21c10359c" }
-datafusion-sql = { git = "https://github.com/apache/arrow-datafusion.git", rev = "34eda15b73a9e278af8844b30ed2f1c21c10359c" }
-datafusion-substrait = { git = "https://github.com/apache/arrow-datafusion.git", rev = "34eda15b73a9e278af8844b30ed2f1c21c10359c" }
-derive_builder = "0.12"
-dotenv = "0.15"
-# TODO(LFC): Wait for https://github.com/etcdv3/etcd-client/pull/76
-etcd-client = { git = "https://github.com/MichaelScofield/etcd-client.git", rev = "4c371e9b3ea8e0a8ee2f9cbd7ded26e54a45df3b" }
-fst = "0.4.7"
-futures = "0.3"
-futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "73ac0207ab71dfea48f30259ffdb611501b5ecb8" }
-humantime = "2.1"
-humantime-serde = "1.1"
-itertools = "0.10"
-lazy_static = "1.4"
-meter-core = { git = "https://github.com/GreptimeTeam/greptime-meter.git", rev = "80b72716dcde47ec4161478416a5c6c21343364d" }
-mockall = "0.11.4"
-moka = "0.12"
-notify = "6.1"
-num_cpus = "1.16"
-once_cell = "1.18"
-opentelemetry-proto = { version = "0.5", features = [
-    "gen-tonic",
-    "metrics",
-    "trace",
-] }
-parquet = { version = "51.0.0", default-features = false, features = ["arrow", "async", "object_store"] }
-paste = "1.0"
-pin-project = "1.0"
-prometheus = { version = "0.13.3", features = ["process"] }
-prost = "0.12"
-raft-engine = { version = "0.4.1", default-features = false }
-rand = "0.8"
-regex = "1.8"
-regex-automata = { version = "0.4" }
-reqwest = { version = "0.11", default-features = false, features = [
-    "json",
-    "rustls-tls-native-roots",
-    "stream",
-    "multipart",
-] }
-rskafka = "0.5"
-rust_decimal = "1.33"
-schemars = "0.8"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = { version = "1.0", features = ["float_roundtrip"] }
-serde_with = "3"
-smallvec = { version = "1", features = ["serde"] }
-snafu = "0.7"
-sysinfo = "0.30"
-# on branch v0.44.x
-sqlparser = { git = "https://github.com/GreptimeTeam/sqlparser-rs.git", rev = "c919990bf62ad38d2b0c0a3bc90b26ad919d51b0", features = [
-    "visitor",
-] }
-strum = { version = "0.25", features = ["derive"] }
-tempfile = "3"
-tokio = { version = "1.36", features = ["full"] }
-tokio-stream = { version = "0.1" }
-tokio-util = { version = "0.7", features = ["io-util", "compat"] }
-toml = "0.8.8"
-tonic = { version = "0.11", features = ["tls"] }
-uuid = { version = "1.7", features = ["serde", "v4", "fast-rng"] }
-zstd = "0.13"
-
-## 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-config = { path = "src/common/config" }
-common-datasource = { path = "src/common/datasource" }
-common-decimal = { path = "src/common/decimal" }
-common-error = { path = "src/common/error" }
-common-function = { path = "src/common/function" }
-common-greptimedb-telemetry = { path = "src/common/greptimedb-telemetry" }
-common-grpc = { path = "src/common/grpc" }
-common-grpc-expr = { path = "src/common/grpc-expr" }
-common-macro = { path = "src/common/macro" }
-common-mem-prof = { path = "src/common/mem-prof" }
-common-meta = { path = "src/common/meta" }
-common-plugins = { path = "src/common/plugins" }
-common-procedure = { path = "src/common/procedure" }
-common-procedure-test = { path = "src/common/procedure-test" }
-common-query = { path = "src/common/query" }
-common-recordbatch = { path = "src/common/recordbatch" }
-common-runtime = { path = "src/common/runtime" }
-common-telemetry = { path = "src/common/telemetry" }
-common-test-util = { path = "src/common/test-util" }
-common-time = { path = "src/common/time" }
-common-version = { path = "src/common/version" }
-common-wal = { path = "src/common/wal" }
-datanode = { path = "src/datanode" }
-datatypes = { path = "src/datatypes" }
-file-engine = { path = "src/file-engine" }
-frontend = { path = "src/frontend" }
-index = { path = "src/index" }
-log-store = { path = "src/log-store" }
-meta-client = { path = "src/meta-client" }
-meta-srv = { path = "src/meta-srv" }
-metric-engine = { path = "src/metric-engine" }
-mito2 = { path = "src/mito2" }
-object-store = { path = "src/object-store" }
-operator = { path = "src/operator" }
-partition = { path = "src/partition" }
-plugins = { path = "src/plugins" }
-promql = { path = "src/promql" }
-puffin = { path = "src/puffin" }
-query = { path = "src/query" }
-script = { path = "src/script" }
-servers = { path = "src/servers" }
-session = { path = "src/session" }
-sql = { path = "src/sql" }
-store-api = { path = "src/store-api" }
-substrait = { path = "src/common/substrait" }
-table = { path = "src/table" }
-
-[workspace.dependencies.meter-macros]
-git = "https://github.com/GreptimeTeam/greptime-meter.git"
-rev = "80b72716dcde47ec4161478416a5c6c21343364d"
 
 [profile.release]
-debug = 1
-
-[profile.nightly]
-inherits = "release"
-strip = true
-lto = "thin"
-debug = false
-incremental = false
+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",
-]

LICENSE

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

Makefile

@@ -1,109 +1,15 @@
-# The arguments for building images.
-CARGO_PROFILE ?=
-FEATURES ?=
-TARGET_DIR ?=
-TARGET ?=
-BUILD_BIN ?= greptime
-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 $(BUILD_BIN)),)
-	CARGO_BUILD_OPTS += --bin ${BUILD_BIN}
-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
-
-ifneq ($(strip $(CARGO_BUILD_EXTRA_OPTS)),)
-	CARGO_BUILD_OPTS += ${CARGO_BUILD_EXTRA_OPTS}
-endif
 
 ##@ Build
 
 .PHONY: build
 build: ## Build debug version greptime.
-	cargo ${CARGO_EXTENSION} build ${CARGO_BUILD_OPTS}
+	cargo build
 
-.PHONY: build-by-dev-builder
-build-by-dev-builder: ## Build greptime by dev-builder.
-	docker run --network=host \
-	-v ${PWD}:/greptimedb -v ${CARGO_REGISTRY_CACHE}:/root/.cargo/registry \
-	-w /greptimedb ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/dev-builder-${BASE_IMAGE}:latest \
-	make build \
-	CARGO_EXTENSION="${CARGO_EXTENSION}" \
-	CARGO_PROFILE=${CARGO_PROFILE} \
-	FEATURES=${FEATURES} \
-	TARGET_DIR=${TARGET_DIR} \
-	TARGET=${TARGET} \
-	RELEASE=${RELEASE} \
-	CARGO_BUILD_EXTRA_OPTS="${CARGO_BUILD_EXTRA_OPTS}"
-
-.PHONY: build-android-bin
-build-android-bin: ## Build greptime binary for android.
-	docker run --network=host \
-	-v ${PWD}:/greptimedb -v ${CARGO_REGISTRY_CACHE}:/root/.cargo/registry \
-	-w /greptimedb ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/dev-builder-android:latest \
-	make build \
-	CARGO_EXTENSION="ndk --platform 23 -t aarch64-linux-android" \
-	CARGO_PROFILE=release \
-	FEATURES="${FEATURES}" \
-	TARGET_DIR="${TARGET_DIR}" \
-	TARGET="${TARGET}" \
-	RELEASE="${RELEASE}" \
-	CARGO_BUILD_EXTRA_OPTS="--bin greptime --no-default-features"
-
-.PHONY: strip-android-bin
-strip-android-bin: build-android-bin ## Strip greptime binary for android.
-	docker run --network=host \
-	-v ${PWD}:/greptimedb \
-	-w /greptimedb ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/dev-builder-android:latest \
-	bash -c '$${NDK_ROOT}/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-strip /greptimedb/target/aarch64-linux-android/release/greptime'
+.PHONY: release
+release:  ## Build release version greptime.
+	cargo build --release
 
 .PHONY: clean
 clean: ## Clean the project.
@@ -113,95 +19,36 @@ clean: ## Clean the project.
 fmt: ## Format all the Rust code.
 	cargo fmt --all
 
-.PHONY: fmt-toml
-fmt-toml: ## Format all TOML files.
-	taplo format
-
-.PHONY: check-toml
-check-toml: ## Check all TOML files.
-	taplo format --check
-
 .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
-.PHONY: test
-test: nextest ## Run unit and integration tests.
-	cargo nextest run ${NEXTEST_OPTS}
 
-.PHONY: nextest
-nextest: ## Install nextest tools.
-	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.
-	cargo sqlness
+	cargo run --bin sqlness-runner
 
 .PHONY: check
 check: ## Cargo check all the targets.
-	cargo check --workspace --all-targets --all-features
+	cargo check --workspace --all-targets
 
 .PHONY: clippy
 clippy: ## Check clippy rules.
-	cargo clippy --workspace --all-targets --all-features -- -D warnings
-
-.PHONY: fix-clippy
-fix-clippy: ## Fix clippy violations.
-	cargo clippy --workspace --all-targets --all-features --fix
+	cargo clippy --workspace --all-targets -- -D warnings -D clippy::print_stdout -D clippy::print_stderr
 
 .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}
-
-##@ Docs
-config-docs: ## Generate configuration documentation from toml files.
-	docker run --rm \
-    -v ${PWD}:/greptimedb \
-    -w /greptimedb/config \
-    toml2docs/toml2docs:latest \
-    -p '##' \
-    -t ./config-docs-template.md \
-    -o ./config.md
-
 ##@ General
 
 # The help target prints out all targets with their descriptions organized
@@ -217,4 +64,4 @@ config-docs: ## Generate configuration documentation from toml files.
 
 .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

@@ -1,190 +1,203 @@
 <p align="center">
   <picture>
-    <source media="(prefers-color-scheme: light)" srcset="https://cdn.jsdelivr.net/gh/GreptimeTeam/greptimedb@main/docs/logo-text-padding.png">
-    <source media="(prefers-color-scheme: dark)" srcset="https://cdn.jsdelivr.net/gh/GreptimeTeam/greptimedb@main/docs/logo-text-padding-dark.png">
-    <img alt="GreptimeDB Logo" src="https://cdn.jsdelivr.net/gh/GreptimeTeam/greptimedb@main/docs/logo-text-padding.png" width="400px">
+    <source media="(prefers-color-scheme: light)" srcset="/docs/logo-text-padding.png">
+    <source media="(prefers-color-scheme: dark)" srcset="/docs/logo-text-padding-dark.png">
+    <img alt="GreptimeDB Logo" src="/docs/logo-text-padding.png" width="400px">
   </picture>
 </p>
 
-<h1 align="center">Cloud-scale, Fast and Efficient Time Series Database</h1>
 
-<div align="center">
 <h3 align="center">
-  <a href="https://greptime.com/product/cloud">GreptimeCloud</a> |
-  <a href="https://docs.greptime.com/">User guide</a> |
-  <a href="https://greptimedb.rs/">API Docs</a> |
-  <a href="https://github.com/GreptimeTeam/greptimedb/issues/3412">Roadmap 2024</a>
-</h4>
+    The next-generation hybrid timeseries/analytics processing database in the cloud
+</h3>
 
-<a href="https://github.com/GreptimeTeam/greptimedb/releases/latest">
-<img src="https://img.shields.io/github/v/release/GreptimeTeam/greptimedb.svg" alt="Version"/>
-</a>
-<a href="https://github.com/GreptimeTeam/greptimedb/releases/latest">
-<img src="https://img.shields.io/github/release-date/GreptimeTeam/greptimedb.svg" alt="Releases"/>
-</a>
-<a href="https://hub.docker.com/r/greptime/greptimedb/">
-<img src="https://img.shields.io/docker/pulls/greptime/greptimedb.svg" alt="Docker Pulls"/>
-</a>
-<a href="https://github.com/GreptimeTeam/greptimedb/actions/workflows/develop.yml">
-<img src="https://github.com/GreptimeTeam/greptimedb/actions/workflows/develop.yml/badge.svg" alt="GitHub Actions"/>
-</a>
-<a href="https://codecov.io/gh/GrepTimeTeam/greptimedb">
-<img src="https://codecov.io/gh/GrepTimeTeam/greptimedb/branch/main/graph/badge.svg?token=FITFDI3J3C" alt="Codecov"/>
-</a>
-<a href="https://github.com/greptimeTeam/greptimedb/blob/main/LICENSE">
-<img src="https://img.shields.io/github/license/greptimeTeam/greptimedb" alt="License"/>
-</a>
+<p align="center">
+    <a href="https://codecov.io/gh/GrepTimeTeam/greptimedb"><img src="https://codecov.io/gh/GrepTimeTeam/greptimedb/branch/develop/graph/badge.svg?token=FITFDI3J3C"></img></a>
+    &nbsp;
+    <a href="https://github.com/GreptimeTeam/greptimedb/actions/workflows/develop.yml"><img src="https://github.com/GreptimeTeam/greptimedb/actions/workflows/develop.yml/badge.svg" alt="CI"></img></a>
+    &nbsp;
+    <a href="https://github.com/greptimeTeam/greptimedb/blob/develop/LICENSE"><img src="https://img.shields.io/github/license/greptimeTeam/greptimedb"></a>
+</p>
 
-<br/>
+<p align="center">
+    <a href="https://twitter.com/greptime"><img src="https://img.shields.io/badge/twitter-follow_us-1d9bf0.svg"></a>
+    &nbsp;
+    <a href="https://www.linkedin.com/company/greptime/"><img src="https://img.shields.io/badge/linkedin-connect_with_us-0a66c2.svg"></a>
+</p>
 
-<a href="https://greptime.com/slack">
-<img src="https://img.shields.io/badge/slack-GreptimeDB-0abd59?logo=slack&style=for-the-badge" alt="Slack"/>
-</a>
-<a href="https://twitter.com/greptime">
-<img src="https://img.shields.io/badge/twitter-follow_us-1d9bf0.svg?style=for-the-badge" alt="Twitter"/>
-</a>
-<a href="https://www.linkedin.com/company/greptime/">
-<img src="https://img.shields.io/badge/linkedin-connect_with_us-0a66c2.svg?style=for-the-badge" alt="LinkedIn"/>
-</a>
-</div>
+## What is GreptimeDB
 
-## Introduction
+GreptimeDB is an open-source time-series database with a special focus on
+scalability, analytical capabilities and efficiency. It's designed to work on
+infrastructure of the cloud era, and users benefit from its elasticity and commodity
+storage.
 
-**GreptimeDB** is an open-source time-series database focusing on efficiency, scalability, and analytical capabilities.
-Designed to work on infrastructure of the cloud era, GreptimeDB benefits users with its elasticity and commodity storage, offering a fast and cost-effective **alternative to InfluxDB** and a **long-term storage for Prometheus**.
+Our core developers have been building time-series data platform
+for years. Based on their best-practices, GreptimeDB is born to give you:
 
-## Why GreptimeDB
+- A standalone binary that scales to highly-available distributed cluster, providing a transparent experience for cluster users
+- Optimized columnar layout for handling time-series data; compacted, compressed, stored on various storage backends
+- Flexible index options, tackling high cardinality issues down
+- Distributed, parallel query execution, leveraging elastic computing resource
+- Native SQL, and Python scripting for advanced analytical scenarios
+- Widely adopted database protocols and APIs
+- Extensible table engine architecture for extensive workloads
 
-Our core developers have been building time-series data platforms for years. Based on our best-practices, GreptimeDB is born to give you:
+## Quick Start
 
-* **Easy horizontal scaling**
+### Build
 
-  Seamless scalability from a standalone binary at edge to a robust, highly available distributed cluster in cloud, with a transparent experience for both developers and administrators.
+#### Build from Source
 
-* **Analyzing time-series data**
+To compile GreptimeDB from source, you'll need:
 
-  Query your time-series data with SQL and PromQL. Use Python scripts to facilitate complex analytical tasks.
+- C/C++ Toolchain: provides basic tools for compiling and linking. This is
+  available as `build-essential` on ubuntu and similar name on other platforms.
+- Rust: the easiest way to install Rust is to use
+  [`rustup`](https://rustup.rs/), which will check our `rust-toolchain` file and
+  install correct Rust version for you.
+- Protobuf: `protoc` is required for compiling `.proto` files. `protobuf` is
+  available from major package manager on macos and linux distributions. You can
+  find an installation instructions [here](https://grpc.io/docs/protoc-installation/).
+  **Note that `protoc` version needs to be >= 3.15** because we have used the `optional`
+  keyword. You can check it with `protoc --version`.
 
-* **Cloud-native distributed database**
+#### Build with Docker
 
-  Fully open-source distributed cluster architecture that harnesses the power of cloud-native elastic computing resources.
+A docker image with necessary dependencies is provided:
 
-* **Performance and Cost-effective**
-
-  Flexible indexing capabilities and distributed, parallel-processing query engine, tackling high cardinality issues down. Optimized columnar layout for handling time-series data; compacted, compressed, and stored on various storage backends, particularly cloud object storage with 50x cost efficiency.
-
-* **Compatible with InfluxDB, Prometheus and more protocols**
-
-  Widely adopted database protocols and APIs, including MySQL, PostgreSQL, and Prometheus Remote Storage, etc. [Read more](https://docs.greptime.com/user-guide/clients/overview).
-
-## Try GreptimeDB
-
-### 1. [GreptimePlay](https://greptime.com/playground)
-
-Try out the features of GreptimeDB right from your browser.
-
-### 2. [GreptimeCloud](https://console.greptime.cloud/)
-
-Start instantly with a free cluster.
-
-### 3. Docker Image
-
-To install GreptimeDB locally, the recommended way is via Docker:
-
-```shell
-docker pull greptime/greptimedb
+```
+docker build --network host -f docker/Dockerfile -t greptimedb .
 ```
 
-Start a GreptimeDB container with:
+### Run
+
+Start GreptimeDB from source code, in standalone mode:
 
-```shell
-docker run --rm --name greptime --net=host greptime/greptimedb standalone start
 ```
-
-Read more about [Installation](https://docs.greptime.com/getting-started/installation/overview) on docs.
-
-## Getting Started
-
-* [Quickstart](https://docs.greptime.com/getting-started/quick-start/overview)
-* [Write Data](https://docs.greptime.com/user-guide/clients/overview)
-* [Query Data](https://docs.greptime.com/user-guide/query-data/overview)
-* [Operations](https://docs.greptime.com/user-guide/operations/overview)
-
-## Build
-
-Check the prerequisite:
-
-* [Rust toolchain](https://www.rust-lang.org/tools/install) (nightly)
-* [Protobuf compiler](https://grpc.io/docs/protoc-installation/) (>= 3.15)
-* Python toolchain (optional): Required only if built with PyO3 backend. More detail for compiling with PyO3 can be found in its [documentation](https://pyo3.rs/v0.18.1/building_and_distribution#configuring-the-python-version).
-
-Build GreptimeDB binary:
-
-```shell
-make
-```
-
-Run a standalone server:
-
-```shell
 cargo run -- standalone start
 ```
 
-## Extension
+Or if you built from docker:
 
-### Dashboard
+```
+docker run -p 4002:4002 -v "$(pwd):/tmp/greptimedb" greptime/greptimedb standalone start
+```
 
-- [The dashboard UI for GreptimeDB](https://github.com/GreptimeTeam/dashboard)
+For more startup options, greptimedb's **distributed mode** and information
+about Kubernetes deployment, check our [docs](https://docs.greptime.com/).
+
+### Connect
+
+1. Connect to GreptimeDB via standard [MySQL
+   client](https://dev.mysql.com/downloads/mysql/):
+
+   ```
+   # 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://github.com/GreptimeTeam/greptimedb/releases):
+  downloadable pre-built binaries for Linux and MacOS
+- [Docker Images](https://hub.docker.com/r/greptime/greptimedb): pre-built
+  Docker images
+- [`gtctl`](https://github.com/GreptimeTeam/gtctl): the command-line tool for
+  Kubernetes deployment
+
+### Documentation
+
+- GreptimeDB [User Guide](https://docs.greptime.com/user-guide/concepts.html)
+- GreptimeDB [Developer
+  Guide](https://docs.greptime.com/developer-guide/overview.html)
 
 ### SDK
 
-- [GreptimeDB Go Ingester](https://github.com/GreptimeTeam/greptimedb-ingester-go)
-- [GreptimeDB Java Ingester](https://github.com/GreptimeTeam/greptimedb-ingester-java)
-- [GreptimeDB C++ Ingester](https://github.com/GreptimeTeam/greptimedb-ingester-cpp)
-- [GreptimeDB Erlang Ingester](https://github.com/GreptimeTeam/greptimedb-ingester-erl)
-- [GreptimeDB Rust Ingester](https://github.com/GreptimeTeam/greptimedb-ingester-rust)
-- [GreptimeDB JavaScript Ingester](https://github.com/GreptimeTeam/greptimedb-ingester-js)
-
-### Grafana Dashboard
-
-Our official Grafana dashboard is available at [grafana](grafana/README.md) directory.
+- [GreptimeDB Java
+  Client](https://github.com/GreptimeTeam/greptimedb-client-java)
 
 ## Project Status
 
-The current version has not yet reached General Availability version standards.
-In line with our Greptime 2024 Roadmap, we plan to achieve a production-level
-version with the update to v1.0 in August. [[Join Force]](https://github.com/GreptimeTeam/greptimedb/issues/3412)
+This project is in its early stage and under heavy development. We move fast and
+break things. Benchmark on development branch may not represent its potential
+performance. We release pre-built binaries constantly for functional
+evaluation. Do not use it in production at the moment.
+
+For future plans, check out [GreptimeDB roadmap](https://github.com/GreptimeTeam/greptimedb/issues/669).
 
 ## Community
 
-Our core team is thrilled to see you participate in any ways you like. When you are stuck, try to
+Our core team is thrilled too see you participate in any ways you like. When you are stuck, try to
 ask for help by filling an issue with a detailed description of what you were trying to do
 and what went wrong. If you have any questions or if you would like to get involved in our
 community, please check out:
 
 - GreptimeDB Community on [Slack](https://greptime.com/slack)
-- GreptimeDB [GitHub Discussions forum](https://github.com/GreptimeTeam/greptimedb/discussions)
-- Greptime official [website](https://greptime.com)
+- GreptimeDB GitHub [Discussions](https://github.com/GreptimeTeam/greptimedb/discussions)
+- Greptime official [Website](https://greptime.com)
 
 In addition, you may:
 
-- View our official [Blog](https://greptime.com/blogs/)
+- View our official [Blog](https://greptime.com/blogs/index)
 - Connect us with [Linkedin](https://www.linkedin.com/company/greptime/)
 - Follow us on [Twitter](https://twitter.com/greptime)
 
 ## License
 
-GreptimeDB uses the [Apache License 2.0](https://apache.org/licenses/LICENSE-2.0.txt) to strike a balance between
+GreptimeDB uses the [Apache 2.0 license][1] to strike a balance between
 open contributions and allowing you to use the software however you want.
 
+[1]: <https://github.com/greptimeTeam/greptimedb/blob/develop/LICENSE>
+
 ## Contributing
 
-Please refer to [contribution guidelines](CONTRIBUTING.md) and [internal concepts docs](https://docs.greptime.com/contributor-guide/overview.html) for more information.
+Please refer to [contribution guidelines](CONTRIBUTING.md) for more information.
 
 ## Acknowledgement
-
-- GreptimeDB uses [Apache Arrow™](https://arrow.apache.org/) as the memory model and [Apache Parquet™](https://parquet.apache.org/) as the persistent file format.
-- GreptimeDB's query engine is powered by [Apache Arrow DataFusion™](https://arrow.apache.org/datafusion/).
-- [Apache OpenDAL™](https://opendal.apache.org) gives GreptimeDB a very general and elegant data access abstraction layer.
-- GreptimeDB's meta service is based on [etcd](https://etcd.io/).
+- GreptimeDB uses [Apache Arrow](https://arrow.apache.org/) as the memory model and [Apache Parquet](https://parquet.apache.org/) as the persistent file format.
+- GreptimeDB's query engine is powered by [Apache Arrow DataFusion](https://github.com/apache/arrow-datafusion).
+- [OpenDAL](https://github.com/datafuselabs/opendal) from [Datafuse Labs](https://github.com/datafuselabs) gives GreptimeDB a very general and elegant data access abstraction layer.
+- GreptimeDB’s meta service is based on [etcd](https://etcd.io/).
 - GreptimeDB uses [RustPython](https://github.com/RustPython/RustPython) for experimental embedded python scripting.

SECURITY.md

@@ -1,19 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-| Version | Supported          |
-| ------- | ------------------ |
-| >= v0.1.0 | :white_check_mark: |
-| < v0.1.0   | :x:                |
-
-## Reporting a Vulnerability
-
-We place great importance on the security of GreptimeDB code, software, 
-and cloud platform. If you come across a security vulnerability in GreptimeDB, 
-we kindly request that you inform us immediately. We will thoroughly investigate
-all valid reports and make every effort to resolve the issue promptly.
-
-To report any issues or vulnerabilities, please email us at info@greptime.com, rather than 
-posting publicly on GitHub. Be sure to provide us with the version identifier as well as details
-on how the vulnerability can be exploited.

benchmarks/Cargo.toml

@@ -1,38 +1,14 @@
 [package]
 name = "benchmarks"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-
-[lints]
-workspace = true
+version = "0.1.0"
+edition = "2021"
+license = "Apache-2.0"
 
 [dependencies]
-api.workspace = true
-arrow.workspace = true
-chrono.workspace = true
-clap.workspace = true
-client.workspace = true
-common-base.workspace = true
-common-telemetry.workspace = true
-common-wal.workspace = true
-dotenv.workspace = true
-futures.workspace = true
-futures-util.workspace = true
-humantime.workspace = true
-humantime-serde.workspace = true
+arrow = "26.0.0"
+clap = { version = "4.0", features = ["derive"] }
+client = { path = "../src/client" }
 indicatif = "0.17.1"
-itertools.workspace = true
-lazy_static.workspace = true
-log-store.workspace = true
-mito2.workspace = true
-num_cpus.workspace = true
-parquet.workspace = true
-prometheus.workspace = true
-rand.workspace = true
-rskafka.workspace = true
-serde.workspace = true
-store-api.workspace = true
-tokio.workspace = true
-toml.workspace = true
-uuid.workspace = true
+itertools = "0.10.5"
+parquet = "26.0.0"
+tokio = { version = "1.21", features = ["full"] }

benchmarks/README.md

@@ -1,11 +0,0 @@
-Benchmarkers for GreptimeDB
---------------------------------
-
-## Wal Benchmarker
-The wal benchmarker serves to evaluate the performance of GreptimeDB's Write-Ahead Log (WAL) component. It meticulously assesses the read/write performance of the WAL under diverse workloads generated by the benchmarker. 
-
-
-### How to use
-To compile the benchmarker, navigate to the `greptimedb/benchmarks` directory and execute `cargo build --release`. Subsequently, you'll find the compiled target located at `greptimedb/target/release/wal_bench`.
-
-The `./wal_bench -h` command reveals numerous arguments that the target accepts. Among these, a notable one is the `cfg-file` argument. By utilizing a configuration file in the TOML format, you can bypass the need to repeatedly specify cumbersome arguments.

benchmarks/config/wal_bench.example.toml

@@ -1,21 +0,0 @@
-# Refers to the documents of `Args` in benchmarks/src/wal.rs`.
-wal_provider = "kafka"
-bootstrap_brokers = ["localhost:9092"]
-num_workers = 10
-num_topics = 32
-num_regions = 1000
-num_scrapes = 1000
-num_rows = 5
-col_types = "ifs"
-max_batch_size = "512KB"
-linger = "1ms"
-backoff_init = "10ms"
-backoff_max = "1ms"
-backoff_base = 2
-backoff_deadline = "3s"
-compression = "zstd"
-rng_seed = 42
-skip_read = false
-skip_write = false
-random_topics = true
-report_metrics = false

benchmarks/src/bin/nyc-taxi.rs

@@ -1,10 +1,10 @@
-// Copyright 2023 Greptime Team
+// Copyright 2022 Greptime Team
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
-//     http://www.apache.org/licenses/LICENSE-2.0
+// http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ -15,28 +15,29 @@
 //! Use the taxi trip records from New York City dataset to bench. You can download the dataset from
 //! [here](https://www1.nyc.gov/site/tlc/about/tlc-trip-record-data.page).
 
+#![feature(once_cell)]
 #![allow(clippy::print_stdout)]
 
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::time::Instant;
 
-use arrow::array::{ArrayRef, PrimitiveArray, StringArray, TimestampMicrosecondArray};
+use arrow::array::{ArrayRef, PrimitiveArray, StringArray, TimestampNanosecondArray};
 use arrow::datatypes::{DataType, Float64Type, Int64Type};
 use arrow::record_batch::RecordBatch;
 use clap::Parser;
+use client::admin::Admin;
 use client::api::v1::column::Values;
-use client::api::v1::{
-    Column, ColumnDataType, ColumnDef, CreateTableExpr, InsertRequest, InsertRequests, SemanticType,
-};
-use client::{Client, Database, OutputData, DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
-use futures_util::TryStreamExt;
+use client::api::v1::{Column, ColumnDataType, ColumnDef, CreateExpr, InsertExpr};
+use client::{Client, Database, Select};
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
 use tokio::task::JoinSet;
 
+const DATABASE_NAME: &str = "greptime";
 const CATALOG_NAME: &str = "greptime";
 const SCHEMA_NAME: &str = "public";
+const TABLE_NAME: &str = "nyc_taxi";
 
 #[derive(Parser)]
 #[command(name = "NYC benchmark runner")]
@@ -63,7 +64,7 @@ struct Args {
     #[arg(long = "skip-read")]
     skip_read: bool,
 
-    #[arg(short, long, default_value_t = String::from("127.0.0.1:4001"))]
+    #[arg(short, long, default_value_t = String::from("127.0.0.1:3001"))]
     endpoint: String,
 }
 
@@ -74,12 +75,7 @@ fn get_file_list<P: AsRef<Path>>(path: P) -> Vec<PathBuf> {
         .collect()
 }
 
-fn new_table_name() -> String {
-    format!("nyc_taxi_{}", chrono::Utc::now().timestamp())
-}
-
 async fn write_data(
-    table_name: &str,
     batch_size: usize,
     db: &Database,
     path: PathBuf,
@@ -98,33 +94,31 @@ async fn write_data(
         .unwrap();
     let progress_bar = mpb.add(ProgressBar::new(row_num as _));
     progress_bar.set_style(pb_style);
-    progress_bar.set_message(format!("{path:?}"));
+    progress_bar.set_message(format!("{:?}", path));
 
     let mut total_rpc_elapsed_ms = 0;
 
     for record_batch in record_batch_reader {
         let record_batch = record_batch.unwrap();
-        if !is_record_batch_full(&record_batch) {
-            continue;
-        }
         let (columns, row_count) = convert_record_batch(record_batch);
-        let request = InsertRequest {
-            table_name: table_name.to_string(),
+        let insert_expr = InsertExpr {
+            schema_name: "public".to_string(),
+            table_name: TABLE_NAME.to_string(),
+            region_number: 0,
             columns,
             row_count,
         };
-        let requests = InsertRequests {
-            inserts: vec![request],
-        };
-
         let now = Instant::now();
-        db.insert(requests).await.unwrap();
+        db.insert(insert_expr).await.unwrap();
         let elapsed = now.elapsed();
         total_rpc_elapsed_ms += elapsed.as_millis();
         progress_bar.inc(row_count as _);
     }
 
-    progress_bar.finish_with_message(format!("file {path:?} done in {total_rpc_elapsed_ms}ms",));
+    progress_bar.finish_with_message(format!(
+        "file {:?} done in {}ms",
+        path, total_rpc_elapsed_ms
+    ));
     total_rpc_elapsed_ms
 }
 
@@ -135,23 +129,12 @@ fn convert_record_batch(record_batch: RecordBatch) -> (Vec<Column>, u32) {
     let mut columns = vec![];
 
     for (array, field) in record_batch.columns().iter().zip(fields.iter()) {
-        let (values, datatype) = build_values(array);
-        let semantic_type = match field.name().as_str() {
-            "VendorID" => SemanticType::Tag,
-            "tpep_pickup_datetime" => SemanticType::Timestamp,
-            _ => SemanticType::Field,
-        };
-
+        let values = build_values(array);
         let column = Column {
-            column_name: field.name().clone(),
+            column_name: field.name().to_owned(),
             values: Some(values),
-            null_mask: array
-                .to_data()
-                .nulls()
-                .map(|bitmap| bitmap.buffer().as_slice().to_vec())
-                .unwrap_or_default(),
-            datatype: datatype.into(),
-            semantic_type: semantic_type as i32,
+            null_mask: vec![],
+            // datatype and semantic_type are set to default
             ..Default::default()
         };
         columns.push(column);
@@ -160,7 +143,7 @@ fn convert_record_batch(record_batch: RecordBatch) -> (Vec<Column>, u32) {
     (columns, row_count as _)
 }
 
-fn build_values(column: &ArrayRef) -> (Values, ColumnDataType) {
+fn build_values(column: &ArrayRef) -> Values {
     match column.data_type() {
         DataType::Int64 => {
             let array = column
@@ -168,13 +151,10 @@ fn build_values(column: &ArrayRef) -> (Values, ColumnDataType) {
                 .downcast_ref::<PrimitiveArray<Int64Type>>()
                 .unwrap();
             let values = array.values();
-            (
-                Values {
-                    i64_values: values.to_vec(),
-                    ..Default::default()
-                },
-                ColumnDataType::Int64,
-            )
+            Values {
+                i64_values: values.to_vec(),
+                ..Default::default()
+            }
         }
         DataType::Float64 => {
             let array = column
@@ -182,254 +162,218 @@ fn build_values(column: &ArrayRef) -> (Values, ColumnDataType) {
                 .downcast_ref::<PrimitiveArray<Float64Type>>()
                 .unwrap();
             let values = array.values();
-            (
-                Values {
-                    f64_values: values.to_vec(),
-                    ..Default::default()
-                },
-                ColumnDataType::Float64,
-            )
+            Values {
+                f64_values: values.to_vec(),
+                ..Default::default()
+            }
         }
         DataType::Timestamp(_, _) => {
             let array = column
                 .as_any()
-                .downcast_ref::<TimestampMicrosecondArray>()
+                .downcast_ref::<TimestampNanosecondArray>()
                 .unwrap();
             let values = array.values();
-            (
-                Values {
-                    timestamp_microsecond_values: values.to_vec(),
-                    ..Default::default()
-                },
-                ColumnDataType::TimestampMicrosecond,
-            )
+            Values {
+                i64_values: values.to_vec(),
+                ..Default::default()
+            }
         }
         DataType::Utf8 => {
             let array = column.as_any().downcast_ref::<StringArray>().unwrap();
             let values = array.iter().filter_map(|s| s.map(String::from)).collect();
-            (
-                Values {
-                    string_values: values,
-                    ..Default::default()
-                },
-                ColumnDataType::String,
-            )
+            Values {
+                string_values: values,
+                ..Default::default()
+            }
         }
-        _ => unimplemented!(),
+        DataType::Null
+        | DataType::Boolean
+        | DataType::Int8
+        | DataType::Int16
+        | DataType::Int32
+        | DataType::UInt8
+        | DataType::UInt16
+        | DataType::UInt32
+        | DataType::UInt64
+        | DataType::Float16
+        | DataType::Float32
+        | DataType::Date32
+        | DataType::Date64
+        | DataType::Time32(_)
+        | DataType::Time64(_)
+        | DataType::Duration(_)
+        | DataType::Interval(_)
+        | DataType::Binary
+        | DataType::FixedSizeBinary(_)
+        | DataType::LargeBinary
+        | DataType::LargeUtf8
+        | DataType::List(_)
+        | DataType::FixedSizeList(_, _)
+        | DataType::LargeList(_)
+        | DataType::Struct(_)
+        | DataType::Union(_, _, _)
+        | DataType::Dictionary(_, _)
+        | DataType::Decimal128(_, _)
+        | DataType::Decimal256(_, _)
+        | DataType::Map(_, _) => todo!(),
     }
 }
 
-fn is_record_batch_full(batch: &RecordBatch) -> bool {
-    batch.columns().iter().all(|col| col.null_count() == 0)
-}
-
-fn create_table_expr(table_name: &str) -> CreateTableExpr {
-    CreateTableExpr {
-        catalog_name: CATALOG_NAME.to_string(),
-        schema_name: SCHEMA_NAME.to_string(),
-        table_name: table_name.to_string(),
-        desc: String::default(),
+fn create_table_expr() -> CreateExpr {
+    CreateExpr {
+        catalog_name: Some(CATALOG_NAME.to_string()),
+        schema_name: Some(SCHEMA_NAME.to_string()),
+        table_name: TABLE_NAME.to_string(),
+        desc: None,
         column_defs: vec![
             ColumnDef {
                 name: "VendorID".to_string(),
-                data_type: ColumnDataType::Int64 as i32,
+                datatype: ColumnDataType::Int64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Tag as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "tpep_pickup_datetime".to_string(),
-                data_type: ColumnDataType::TimestampMicrosecond as i32,
-                is_nullable: false,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Timestamp as i32,
-                comment: String::new(),
-                ..Default::default()
+                datatype: ColumnDataType::Int64 as i32,
+                is_nullable: true,
+                default_constraint: None,
             },
             ColumnDef {
                 name: "tpep_dropoff_datetime".to_string(),
-                data_type: ColumnDataType::TimestampMicrosecond as i32,
+                datatype: ColumnDataType::Int64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "passenger_count".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "trip_distance".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "RatecodeID".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "store_and_fwd_flag".to_string(),
-                data_type: ColumnDataType::String as i32,
+                datatype: ColumnDataType::String as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "PULocationID".to_string(),
-                data_type: ColumnDataType::Int64 as i32,
+                datatype: ColumnDataType::Int64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "DOLocationID".to_string(),
-                data_type: ColumnDataType::Int64 as i32,
+                datatype: ColumnDataType::Int64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "payment_type".to_string(),
-                data_type: ColumnDataType::Int64 as i32,
+                datatype: ColumnDataType::Int64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "fare_amount".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "extra".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "mta_tax".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "tip_amount".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "tolls_amount".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "improvement_surcharge".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "total_amount".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "congestion_surcharge".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
             ColumnDef {
                 name: "airport_fee".to_string(),
-                data_type: ColumnDataType::Float64 as i32,
+                datatype: ColumnDataType::Float64 as i32,
                 is_nullable: true,
-                default_constraint: vec![],
-                semantic_type: SemanticType::Field as i32,
-                comment: String::new(),
-                ..Default::default()
+                default_constraint: None,
             },
         ],
         time_index: "tpep_pickup_datetime".to_string(),
         primary_keys: vec!["VendorID".to_string()],
-        create_if_not_exists: true,
+        create_if_not_exists: false,
         table_options: Default::default(),
-        table_id: None,
-        engine: "mito".to_string(),
+        region_ids: vec![0],
+        table_id: Some(0),
     }
 }
 
-fn query_set(table_name: &str) -> 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"),
-        )
-    ])
+fn query_set() -> HashMap<String, String> {
+    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 {} GROUP BY passenger_count",TABLE_NAME)
+    );
+
+    ret
 }
 
-async fn do_write(args: &Args, db: &Database, table_name: &str) {
+async fn do_write(args: &Args, client: &Client) {
+    let admin = Admin::new("admin", client.clone());
+
     let mut file_list = get_file_list(args.path.clone().expect("Specify data path in argument"));
     let mut write_jobs = JoinSet::new();
 
-    let create_table_result = db.create(create_table_expr(table_name)).await;
-    println!("Create table result: {create_table_result:?}");
+    let create_table_result = admin.create(create_table_expr()).await;
+    println!("Create table result: {:?}", create_table_result);
 
     let progress_bar_style = ProgressStyle::with_template(
         "[{elapsed_precise}] {bar:60.cyan/blue} {pos:>7}/{len:7} {msg}",
@@ -443,47 +387,35 @@ async fn do_write(args: &Args, db: &Database, table_name: &str) {
     let batch_size = args.batch_size;
     for _ in 0..args.thread_num {
         if let Some(path) = file_list.pop() {
-            let db = db.clone();
+            let db = Database::new(DATABASE_NAME, client.clone());
             let mpb = multi_progress_bar.clone();
             let pb_style = progress_bar_style.clone();
-            let table_name = table_name.to_string();
-            let _ = write_jobs.spawn(async move {
-                write_data(&table_name, batch_size, &db, path, mpb, pb_style).await
-            });
+            write_jobs.spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
         }
     }
     while write_jobs.join_next().await.is_some() {
         file_progress.inc(1);
         if let Some(path) = file_list.pop() {
-            let db = db.clone();
+            let db = Database::new(DATABASE_NAME, client.clone());
             let mpb = multi_progress_bar.clone();
             let pb_style = progress_bar_style.clone();
-            let table_name = table_name.to_string();
-            let _ = write_jobs.spawn(async move {
-                write_data(&table_name, batch_size, &db, path, mpb, pb_style).await
-            });
+            write_jobs.spawn(async move { write_data(batch_size, &db, path, mpb, pb_style).await });
         }
     }
 }
 
-async fn do_query(num_iter: usize, db: &Database, table_name: &str) {
-    for (query_name, query) in query_set(table_name) {
-        println!("Running query: {query}");
+async fn do_query(num_iter: usize, db: &Database) {
+    for (query_name, query) in query_set() {
+        println!("Running query: {}", query);
         for i in 0..num_iter {
             let now = Instant::now();
-            let res = db.sql(&query).await.unwrap();
-            match res.data {
-                OutputData::AffectedRows(_) | OutputData::RecordBatches(_) => (),
-                OutputData::Stream(stream) => {
-                    stream.try_collect::<Vec<_>>().await.unwrap();
-                }
-            }
+            let _res = db.select(Select::Sql(query.clone())).await.unwrap();
             let elapsed = now.elapsed();
             println!(
                 "query {}, iteration {}: {}ms",
                 query_name,
                 i,
-                elapsed.as_millis(),
+                elapsed.as_millis()
             );
         }
     }
@@ -499,15 +431,14 @@ fn main() {
         .unwrap()
         .block_on(async {
             let client = Client::with_urls(vec![&args.endpoint]);
-            let db = Database::new(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, client);
-            let table_name = new_table_name();
 
             if !args.skip_write {
-                do_write(&args, &db, &table_name).await;
+                do_write(&args, &client).await;
             }
 
             if !args.skip_read {
-                do_query(args.iter_num, &db, &table_name).await;
+                let db = Database::new(DATABASE_NAME, client.clone());
+                do_query(args.iter_num, &db).await;
             }
         })
 }

benchmarks/src/bin/wal_bench.rs

@@ -1,326 +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(int_roundings)]
-
-use std::fs;
-use std::sync::Arc;
-use std::time::Instant;
-
-use api::v1::{ColumnDataType, ColumnSchema, SemanticType};
-use benchmarks::metrics;
-use benchmarks::wal_bench::{Args, Config, Region, WalProvider};
-use clap::Parser;
-use common_telemetry::info;
-use common_wal::config::kafka::common::BackoffConfig;
-use common_wal::config::kafka::DatanodeKafkaConfig as KafkaConfig;
-use common_wal::config::raft_engine::RaftEngineConfig;
-use common_wal::options::{KafkaWalOptions, WalOptions};
-use itertools::Itertools;
-use log_store::kafka::log_store::KafkaLogStore;
-use log_store::raft_engine::log_store::RaftEngineLogStore;
-use mito2::wal::Wal;
-use prometheus::{Encoder, TextEncoder};
-use rand::distributions::{Alphanumeric, DistString};
-use rand::rngs::SmallRng;
-use rand::SeedableRng;
-use rskafka::client::partition::Compression;
-use rskafka::client::ClientBuilder;
-use store_api::logstore::LogStore;
-use store_api::storage::RegionId;
-
-async fn run_benchmarker<S: LogStore>(cfg: &Config, topics: &[String], wal: Arc<Wal<S>>) {
-    let chunk_size = cfg.num_regions.div_ceil(cfg.num_workers);
-    let region_chunks = (0..cfg.num_regions)
-        .map(|id| {
-            build_region(
-                id as u64,
-                topics,
-                &mut SmallRng::seed_from_u64(cfg.rng_seed),
-                cfg,
-            )
-        })
-        .chunks(chunk_size as usize)
-        .into_iter()
-        .map(|chunk| Arc::new(chunk.collect::<Vec<_>>()))
-        .collect::<Vec<_>>();
-
-    let mut write_elapsed = 0;
-    let mut read_elapsed = 0;
-
-    if !cfg.skip_write {
-        info!("Benchmarking write ...");
-
-        let num_scrapes = cfg.num_scrapes;
-        let timer = Instant::now();
-        futures::future::join_all((0..cfg.num_workers).map(|i| {
-            let wal = wal.clone();
-            let regions = region_chunks[i as usize].clone();
-            tokio::spawn(async move {
-                for _ in 0..num_scrapes {
-                    let mut wal_writer = wal.writer();
-                    regions
-                        .iter()
-                        .for_each(|region| region.add_wal_entry(&mut wal_writer));
-                    wal_writer.write_to_wal().await.unwrap();
-                }
-            })
-        }))
-        .await;
-        write_elapsed += timer.elapsed().as_millis();
-    }
-
-    if !cfg.skip_read {
-        info!("Benchmarking read ...");
-
-        let timer = Instant::now();
-        futures::future::join_all((0..cfg.num_workers).map(|i| {
-            let wal = wal.clone();
-            let regions = region_chunks[i as usize].clone();
-            tokio::spawn(async move {
-                for region in regions.iter() {
-                    region.replay(&wal).await;
-                }
-            })
-        }))
-        .await;
-        read_elapsed = timer.elapsed().as_millis();
-    }
-
-    dump_report(cfg, write_elapsed, read_elapsed);
-}
-
-fn build_region(id: u64, topics: &[String], rng: &mut SmallRng, cfg: &Config) -> Region {
-    let wal_options = match cfg.wal_provider {
-        WalProvider::Kafka => {
-            assert!(!topics.is_empty());
-            WalOptions::Kafka(KafkaWalOptions {
-                topic: topics.get(id as usize % topics.len()).cloned().unwrap(),
-            })
-        }
-        WalProvider::RaftEngine => WalOptions::RaftEngine,
-    };
-    Region::new(
-        RegionId::from_u64(id),
-        build_schema(&parse_col_types(&cfg.col_types), rng),
-        wal_options,
-        cfg.num_rows,
-        cfg.rng_seed,
-    )
-}
-
-fn build_schema(col_types: &[ColumnDataType], mut rng: &mut SmallRng) -> Vec<ColumnSchema> {
-    col_types
-        .iter()
-        .map(|col_type| ColumnSchema {
-            column_name: Alphanumeric.sample_string(&mut rng, 5),
-            datatype: *col_type as i32,
-            semantic_type: SemanticType::Field as i32,
-            datatype_extension: None,
-        })
-        .chain(vec![ColumnSchema {
-            column_name: "ts".to_string(),
-            datatype: ColumnDataType::TimestampMillisecond as i32,
-            semantic_type: SemanticType::Tag as i32,
-            datatype_extension: None,
-        }])
-        .collect()
-}
-
-fn dump_report(cfg: &Config, write_elapsed: u128, read_elapsed: u128) {
-    let cost_report = format!(
-        "write costs: {} ms, read costs: {} ms",
-        write_elapsed, read_elapsed,
-    );
-
-    let total_written_bytes = metrics::METRIC_WAL_WRITE_BYTES_TOTAL.get() as u128;
-    let write_throughput = if write_elapsed > 0 {
-        (total_written_bytes * 1000).div_floor(write_elapsed)
-    } else {
-        0
-    };
-    let total_read_bytes = metrics::METRIC_WAL_READ_BYTES_TOTAL.get() as u128;
-    let read_throughput = if read_elapsed > 0 {
-        (total_read_bytes * 1000).div_floor(read_elapsed)
-    } else {
-        0
-    };
-
-    let throughput_report = format!(
-        "total written bytes: {} bytes, total read bytes: {} bytes, write throuput: {} bytes/s ({} mb/s), read throughput: {} bytes/s ({} mb/s)",
-        total_written_bytes,
-        total_read_bytes,
-        write_throughput,
-        write_throughput.div_floor(1 << 20),
-        read_throughput,
-        read_throughput.div_floor(1 << 20),
-    );
-
-    let metrics_report = if cfg.report_metrics {
-        let mut buffer = Vec::new();
-        let encoder = TextEncoder::new();
-        let metrics = prometheus::gather();
-        encoder.encode(&metrics, &mut buffer).unwrap();
-        String::from_utf8(buffer).unwrap()
-    } else {
-        String::new()
-    };
-
-    info!(
-        r#"
-Benchmark config: 
-{cfg:?}
-
-Benchmark report:
-{cost_report}
-{throughput_report}
-{metrics_report}"#
-    );
-}
-
-async fn create_topics(cfg: &Config) -> Vec<String> {
-    // Creates topics.
-    let client = ClientBuilder::new(cfg.bootstrap_brokers.clone())
-        .build()
-        .await
-        .unwrap();
-    let ctrl_client = client.controller_client().unwrap();
-    let (topics, tasks): (Vec<_>, Vec<_>) = (0..cfg.num_topics)
-        .map(|i| {
-            let topic = if cfg.random_topics {
-                format!(
-                    "greptime_wal_bench_topic_{}_{}",
-                    uuid::Uuid::new_v4().as_u128(),
-                    i
-                )
-            } else {
-                format!("greptime_wal_bench_topic_{}", i)
-            };
-            let task = ctrl_client.create_topic(
-                topic.clone(),
-                1,
-                cfg.bootstrap_brokers.len() as i16,
-                2000,
-            );
-            (topic, task)
-        })
-        .unzip();
-    // Must ignore errors since we allow topics being created more than once.
-    let _ = futures::future::try_join_all(tasks).await;
-
-    topics
-}
-
-fn parse_compression(comp: &str) -> Compression {
-    match comp {
-        "no" => Compression::NoCompression,
-        "gzip" => Compression::Gzip,
-        "lz4" => Compression::Lz4,
-        "snappy" => Compression::Snappy,
-        "zstd" => Compression::Zstd,
-        other => unreachable!("Unrecognized compression {other}"),
-    }
-}
-
-fn parse_col_types(col_types: &str) -> Vec<ColumnDataType> {
-    let parts = col_types.split('x').collect::<Vec<_>>();
-    assert!(parts.len() <= 2);
-
-    let pattern = parts[0];
-    let repeat = parts
-        .get(1)
-        .map(|r| r.parse::<usize>().unwrap())
-        .unwrap_or(1);
-
-    pattern
-        .chars()
-        .map(|c| match c {
-            'i' | 'I' => ColumnDataType::Int64,
-            'f' | 'F' => ColumnDataType::Float64,
-            's' | 'S' => ColumnDataType::String,
-            other => unreachable!("Cannot parse {other} as a column data type"),
-        })
-        .cycle()
-        .take(pattern.len() * repeat)
-        .collect()
-}
-
-fn main() {
-    // Sets the global logging to INFO and suppress loggings from rskafka other than ERROR and upper ones.
-    std::env::set_var("UNITTEST_LOG_LEVEL", "info,rskafka=error");
-    common_telemetry::init_default_ut_logging();
-
-    let args = Args::parse();
-    let cfg = if !args.cfg_file.is_empty() {
-        toml::from_str(&fs::read_to_string(&args.cfg_file).unwrap()).unwrap()
-    } else {
-        Config::from(args)
-    };
-
-    // Validates arguments.
-    if cfg.num_regions < cfg.num_workers {
-        panic!("num_regions must be greater than or equal to num_workers");
-    }
-    if cfg
-        .num_workers
-        .min(cfg.num_topics)
-        .min(cfg.num_regions)
-        .min(cfg.num_scrapes)
-        .min(cfg.max_batch_size.as_bytes() as u32)
-        .min(cfg.bootstrap_brokers.len() as u32)
-        == 0
-    {
-        panic!("Invalid arguments");
-    }
-
-    tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()
-        .unwrap()
-        .block_on(async {
-            match cfg.wal_provider {
-                WalProvider::Kafka => {
-                    let topics = create_topics(&cfg).await;
-                    let kafka_cfg = KafkaConfig {
-                        broker_endpoints: cfg.bootstrap_brokers.clone(),
-                        max_batch_size: cfg.max_batch_size,
-                        linger: cfg.linger,
-                        backoff: BackoffConfig {
-                            init: cfg.backoff_init,
-                            max: cfg.backoff_max,
-                            base: cfg.backoff_base,
-                            deadline: Some(cfg.backoff_deadline),
-                        },
-                        compression: parse_compression(&cfg.compression),
-                        ..Default::default()
-                    };
-                    let store = Arc::new(KafkaLogStore::try_new(&kafka_cfg).await.unwrap());
-                    let wal = Arc::new(Wal::new(store));
-                    run_benchmarker(&cfg, &topics, wal).await;
-                }
-                WalProvider::RaftEngine => {
-                    // The benchmarker assumes the raft engine directory exists.
-                    let store = RaftEngineLogStore::try_new(
-                        "/tmp/greptimedb/raft-engine-wal".to_string(),
-                        RaftEngineConfig::default(),
-                    )
-                    .await
-                    .map(Arc::new)
-                    .unwrap();
-                    let wal = Arc::new(Wal::new(store));
-                    run_benchmarker(&cfg, &[], wal).await;
-                }
-            }
-        });
-}

benchmarks/src/metrics.rs

@@ -1,39 +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 lazy_static::lazy_static;
-use prometheus::*;
-
-/// Logstore label.
-pub const LOGSTORE_LABEL: &str = "logstore";
-/// Operation type label.
-pub const OPTYPE_LABEL: &str = "optype";
-
-lazy_static! {
-    /// Counters of bytes of each operation on a logstore.
-    pub static ref METRIC_WAL_OP_BYTES_TOTAL: IntCounterVec = register_int_counter_vec!(
-        "greptime_bench_wal_op_bytes_total",
-        "wal operation bytes total",
-        &[OPTYPE_LABEL],
-    )
-    .unwrap();
-    /// Counter of bytes of the append_batch operation.
-    pub static ref METRIC_WAL_WRITE_BYTES_TOTAL: IntCounter = METRIC_WAL_OP_BYTES_TOTAL.with_label_values(
-        &["write"],
-    );
-    /// Counter of bytes of the read operation.
-    pub static ref METRIC_WAL_READ_BYTES_TOTAL: IntCounter = METRIC_WAL_OP_BYTES_TOTAL.with_label_values(
-        &["read"],
-    );
-}

benchmarks/src/wal_bench.rs

@@ -1,361 +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::mem::size_of;
-use std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-use api::v1::value::ValueData;
-use api::v1::{ColumnDataType, ColumnSchema, Mutation, OpType, Row, Rows, Value, WalEntry};
-use clap::{Parser, ValueEnum};
-use common_base::readable_size::ReadableSize;
-use common_wal::options::WalOptions;
-use futures::StreamExt;
-use mito2::wal::{Wal, WalWriter};
-use rand::distributions::{Alphanumeric, DistString, Uniform};
-use rand::rngs::SmallRng;
-use rand::{Rng, SeedableRng};
-use serde::{Deserialize, Serialize};
-use store_api::logstore::LogStore;
-use store_api::storage::RegionId;
-
-use crate::metrics;
-
-/// The wal provider.
-#[derive(Clone, ValueEnum, Default, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum WalProvider {
-    #[default]
-    RaftEngine,
-    Kafka,
-}
-
-#[derive(Parser)]
-pub struct Args {
-    /// The provided configuration file.
-    /// The example configuration file can be found at `greptimedb/benchmarks/config/wal_bench.example.toml`.
-    #[clap(long, short = 'c')]
-    pub cfg_file: String,
-
-    /// The wal provider.
-    #[clap(long, value_enum, default_value_t = WalProvider::default())]
-    pub wal_provider: WalProvider,
-
-    /// The advertised addresses of the kafka brokers.
-    /// If there're multiple bootstrap brokers, their addresses should be separated by comma, for e.g. "localhost:9092,localhost:9093".
-    #[clap(long, short = 'b', default_value = "localhost:9092")]
-    pub bootstrap_brokers: String,
-
-    /// The number of workers each running in a dedicated thread.
-    #[clap(long, default_value_t = num_cpus::get() as u32)]
-    pub num_workers: u32,
-
-    /// The number of kafka topics to be created.
-    #[clap(long, default_value_t = 32)]
-    pub num_topics: u32,
-
-    /// The number of regions.
-    #[clap(long, default_value_t = 1000)]
-    pub num_regions: u32,
-
-    /// The number of times each region is scraped.
-    #[clap(long, default_value_t = 1000)]
-    pub num_scrapes: u32,
-
-    /// The number of rows in each wal entry.
-    /// Each time a region is scraped, a wal entry containing will be produced.
-    #[clap(long, default_value_t = 5)]
-    pub num_rows: u32,
-
-    /// The column types of the schema for each region.
-    /// Currently, three column types are supported:
-    /// - i = ColumnDataType::Int64
-    /// - f = ColumnDataType::Float64
-    /// - s = ColumnDataType::String  
-    /// For e.g., "ifs" will be parsed as three columns: i64, f64, and string.
-    ///
-    /// Additionally, a "x" sign can be provided to repeat the column types for a given number of times.
-    /// For e.g., "iix2" will be parsed as 4 columns: i64, i64, i64, and i64.
-    /// This feature is useful if you want to specify many columns.
-    #[clap(long, default_value = "ifs")]
-    pub col_types: String,
-
-    /// The maximum size of a batch of kafka records.
-    /// The default value is 1mb.
-    #[clap(long, default_value = "512KB")]
-    pub max_batch_size: ReadableSize,
-
-    /// The minimum latency the kafka client issues a batch of kafka records.
-    /// However, a batch of kafka records would be immediately issued if a record cannot be fit into the batch.
-    #[clap(long, default_value = "1ms")]
-    pub linger: String,
-
-    /// The initial backoff delay of the kafka consumer.
-    #[clap(long, default_value = "10ms")]
-    pub backoff_init: String,
-
-    /// The maximum backoff delay of the kafka consumer.
-    #[clap(long, default_value = "1s")]
-    pub backoff_max: String,
-
-    /// The exponential backoff rate of the kafka consumer. The next back off = base * the current backoff.
-    #[clap(long, default_value_t = 2)]
-    pub backoff_base: u32,
-
-    /// The deadline of backoff. The backoff ends if the total backoff delay reaches the deadline.
-    #[clap(long, default_value = "3s")]
-    pub backoff_deadline: String,
-
-    /// The client-side compression algorithm for kafka records.
-    #[clap(long, default_value = "zstd")]
-    pub compression: String,
-
-    /// The seed of random number generators.
-    #[clap(long, default_value_t = 42)]
-    pub rng_seed: u64,
-
-    /// Skips the read phase, aka. region replay, if set to true.
-    #[clap(long, default_value_t = false)]
-    pub skip_read: bool,
-
-    /// Skips the write phase if set to true.
-    #[clap(long, default_value_t = false)]
-    pub skip_write: bool,
-
-    /// Randomly generates topic names if set to true.
-    /// Useful when you want to run the benchmarker without worrying about the topics created before.
-    #[clap(long, default_value_t = false)]
-    pub random_topics: bool,
-
-    /// Logs out the gathered prometheus metrics when the benchmarker ends.
-    #[clap(long, default_value_t = false)]
-    pub report_metrics: bool,
-}
-
-/// Benchmarker config.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Config {
-    pub wal_provider: WalProvider,
-    pub bootstrap_brokers: Vec<String>,
-    pub num_workers: u32,
-    pub num_topics: u32,
-    pub num_regions: u32,
-    pub num_scrapes: u32,
-    pub num_rows: u32,
-    pub col_types: String,
-    pub max_batch_size: ReadableSize,
-    #[serde(with = "humantime_serde")]
-    pub linger: Duration,
-    #[serde(with = "humantime_serde")]
-    pub backoff_init: Duration,
-    #[serde(with = "humantime_serde")]
-    pub backoff_max: Duration,
-    pub backoff_base: u32,
-    #[serde(with = "humantime_serde")]
-    pub backoff_deadline: Duration,
-    pub compression: String,
-    pub rng_seed: u64,
-    pub skip_read: bool,
-    pub skip_write: bool,
-    pub random_topics: bool,
-    pub report_metrics: bool,
-}
-
-impl From<Args> for Config {
-    fn from(args: Args) -> Self {
-        let cfg = Self {
-            wal_provider: args.wal_provider,
-            bootstrap_brokers: args
-                .bootstrap_brokers
-                .split(',')
-                .map(ToString::to_string)
-                .collect::<Vec<_>>(),
-            num_workers: args.num_workers.min(num_cpus::get() as u32),
-            num_topics: args.num_topics,
-            num_regions: args.num_regions,
-            num_scrapes: args.num_scrapes,
-            num_rows: args.num_rows,
-            col_types: args.col_types,
-            max_batch_size: args.max_batch_size,
-            linger: humantime::parse_duration(&args.linger).unwrap(),
-            backoff_init: humantime::parse_duration(&args.backoff_init).unwrap(),
-            backoff_max: humantime::parse_duration(&args.backoff_max).unwrap(),
-            backoff_base: args.backoff_base,
-            backoff_deadline: humantime::parse_duration(&args.backoff_deadline).unwrap(),
-            compression: args.compression,
-            rng_seed: args.rng_seed,
-            skip_read: args.skip_read,
-            skip_write: args.skip_write,
-            random_topics: args.random_topics,
-            report_metrics: args.report_metrics,
-        };
-
-        cfg
-    }
-}
-
-/// The region used for wal benchmarker.
-pub struct Region {
-    id: RegionId,
-    schema: Vec<ColumnSchema>,
-    wal_options: WalOptions,
-    next_sequence: AtomicU64,
-    next_entry_id: AtomicU64,
-    next_timestamp: AtomicI64,
-    rng: Mutex<Option<SmallRng>>,
-    num_rows: u32,
-}
-
-impl Region {
-    /// Creates a new region.
-    pub fn new(
-        id: RegionId,
-        schema: Vec<ColumnSchema>,
-        wal_options: WalOptions,
-        num_rows: u32,
-        rng_seed: u64,
-    ) -> Self {
-        Self {
-            id,
-            schema,
-            wal_options,
-            next_sequence: AtomicU64::new(1),
-            next_entry_id: AtomicU64::new(1),
-            next_timestamp: AtomicI64::new(1655276557000),
-            rng: Mutex::new(Some(SmallRng::seed_from_u64(rng_seed))),
-            num_rows,
-        }
-    }
-
-    /// Scrapes the region and adds the generated entry to wal.
-    pub fn add_wal_entry<S: LogStore>(&self, wal_writer: &mut WalWriter<S>) {
-        let mutation = Mutation {
-            op_type: OpType::Put as i32,
-            sequence: self
-                .next_sequence
-                .fetch_add(self.num_rows as u64, Ordering::Relaxed),
-            rows: Some(self.build_rows()),
-        };
-        let entry = WalEntry {
-            mutations: vec![mutation],
-        };
-        metrics::METRIC_WAL_WRITE_BYTES_TOTAL.inc_by(Self::entry_estimated_size(&entry) as u64);
-
-        wal_writer
-            .add_entry(
-                self.id,
-                self.next_entry_id.fetch_add(1, Ordering::Relaxed),
-                &entry,
-                &self.wal_options,
-            )
-            .unwrap();
-    }
-
-    /// Replays the region.
-    pub async fn replay<S: LogStore>(&self, wal: &Arc<Wal<S>>) {
-        let mut wal_stream = wal.scan(self.id, 0, &self.wal_options).unwrap();
-        while let Some(res) = wal_stream.next().await {
-            let (_, entry) = res.unwrap();
-            metrics::METRIC_WAL_READ_BYTES_TOTAL.inc_by(Self::entry_estimated_size(&entry) as u64);
-        }
-    }
-
-    /// Computes the estimated size in bytes of the entry.
-    pub fn entry_estimated_size(entry: &WalEntry) -> usize {
-        let wrapper_size = size_of::<WalEntry>()
-            + entry.mutations.capacity() * size_of::<Mutation>()
-            + size_of::<Rows>();
-
-        let rows = entry.mutations[0].rows.as_ref().unwrap();
-
-        let schema_size = rows.schema.capacity() * size_of::<ColumnSchema>()
-            + rows
-                .schema
-                .iter()
-                .map(|s| s.column_name.capacity())
-                .sum::<usize>();
-        let values_size = (rows.rows.capacity() * size_of::<Row>())
-            + rows
-                .rows
-                .iter()
-                .map(|r| r.values.capacity() * size_of::<Value>())
-                .sum::<usize>();
-
-        wrapper_size + schema_size + values_size
-    }
-
-    fn build_rows(&self) -> Rows {
-        let cols = self
-            .schema
-            .iter()
-            .map(|col_schema| {
-                let col_data_type = ColumnDataType::try_from(col_schema.datatype).unwrap();
-                self.build_col(&col_data_type, self.num_rows)
-            })
-            .collect::<Vec<_>>();
-
-        let rows = (0..self.num_rows)
-            .map(|i| {
-                let values = cols.iter().map(|col| col[i as usize].clone()).collect();
-                Row { values }
-            })
-            .collect();
-
-        Rows {
-            schema: self.schema.clone(),
-            rows,
-        }
-    }
-
-    fn build_col(&self, col_data_type: &ColumnDataType, num_rows: u32) -> Vec<Value> {
-        let mut rng_guard = self.rng.lock().unwrap();
-        let rng = rng_guard.as_mut().unwrap();
-        match col_data_type {
-            ColumnDataType::TimestampMillisecond => (0..num_rows)
-                .map(|_| {
-                    let ts = self.next_timestamp.fetch_add(1000, Ordering::Relaxed);
-                    Value {
-                        value_data: Some(ValueData::TimestampMillisecondValue(ts)),
-                    }
-                })
-                .collect(),
-            ColumnDataType::Int64 => (0..num_rows)
-                .map(|_| {
-                    let v = rng.sample(Uniform::new(0, 10_000));
-                    Value {
-                        value_data: Some(ValueData::I64Value(v)),
-                    }
-                })
-                .collect(),
-            ColumnDataType::Float64 => (0..num_rows)
-                .map(|_| {
-                    let v = rng.sample(Uniform::new(0.0, 5000.0));
-                    Value {
-                        value_data: Some(ValueData::F64Value(v)),
-                    }
-                })
-                .collect(),
-            ColumnDataType::String => (0..num_rows)
-                .map(|_| {
-                    let v = Alphanumeric.sample_string(rng, 10);
-                    Value {
-                        value_data: Some(ValueData::StringValue(v)),
-                    }
-                })
-                .collect(),
-            _ => unreachable!(),
-        }
-    }
-}

cliff.toml

@@ -1,127 +0,0 @@
-# https://git-cliff.org/docs/configuration
-
-[remote.github]
-owner = "GreptimeTeam"
-repo = "greptimedb"
-
-[changelog]
-header = ""
-footer = ""
-# template for the changelog body
-# https://keats.github.io/tera/docs/#introduction
-body = """
-# {{ version }}
-
-Release date: {{ timestamp | date(format="%B %d, %Y") }}
-
-{%- set breakings = commits | filter(attribute="breaking", value=true) -%}
-{%- if breakings | length > 0 %}
-
-## Breaking changes
-    {% for commit in breakings %}
-      * {{ commit.github.pr_title }}\
-        {% if commit.github.username %} by \
-          {% set author = commit.github.username -%}
-          [@{{ author }}](https://github.com/{{ author }})
-        {%- endif -%}
-        {% if commit.github.pr_number %} in \
-          {% set number = commit.github.pr_number -%}
-          [#{{ number }}]({{ self::remote_url() }}/pull/{{ number }})
-        {%- endif %}
-    {%- endfor %}
-{%- endif -%}
-
-{%- set grouped_commits = commits | filter(attribute="breaking", value=false) | group_by(attribute="group") -%}
-{% for group, commits in grouped_commits %}
-
-    ### {{ group | striptags | trim | upper_first }}
-    {% for commit in commits %}
-        * {{ commit.github.pr_title }}\
-            {% if commit.github.username %} by \
-              {% set author = commit.github.username -%}
-              [@{{ author }}](https://github.com/{{ author }})
-            {%- endif -%}
-            {% if commit.github.pr_number %} in \
-              {% set number = commit.github.pr_number -%}
-              [#{{ number }}]({{ self::remote_url() }}/pull/{{ number }})
-            {%- endif %}
-    {%- endfor -%}
-{% endfor %}
-
-{%- if github.contributors | filter(attribute="is_first_time", value=true) | length != 0 %}
-  {% raw %}\n{% endraw -%}
-  ## New Contributors
-{% endif -%}
-{% for contributor in github.contributors | filter(attribute="is_first_time", value=true) %}
-  * [@{{ contributor.username }}](https://github.com/{{ contributor.username }}) made their first contribution
-    {%- if contributor.pr_number %} in \
-      [#{{ contributor.pr_number }}]({{ self::remote_url() }}/pull/{{ contributor.pr_number }}) \
-    {%- endif %}
-{%- endfor -%}
-
-{% if github.contributors | length != 0 %}
-  {% raw %}\n{% endraw -%}
-## All Contributors
-
-We would like to thank the following contributors from the GreptimeDB community:
-
-{%- set contributors = github.contributors | sort(attribute="username") | map(attribute="username") -%}
-{%- set bots = ['dependabot[bot]'] %}
-
-{% for contributor in contributors %}
-{%- if bots is containing(contributor) -%}{% continue %}{%- endif -%}
-{%- if loop.first -%}
-  [@{{ contributor }}](https://github.com/{{ contributor }})
-{%- else -%}
-  , [@{{ contributor }}](https://github.com/{{ contributor }})
-{%- endif -%}
-{%- endfor %}
-{%- endif %}
-{% raw %}\n{% endraw %}
-
-{%- macro remote_url() -%}
-  https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}
-{%- endmacro -%}
-"""
-trim = true
-
-[git]
-# parse the commits based on https://www.conventionalcommits.org
-conventional_commits = true
-# filter out the commits that are not conventional
-filter_unconventional = true
-# process each line of a commit as an individual commit
-split_commits = false
-# regex for parsing and grouping commits
-commit_parsers = [
-  { message = "^feat", group = "<!-- 0 -->🚀 Features" },
-  { message = "^fix", group = "<!-- 1 -->🐛 Bug Fixes" },
-  { message = "^doc", group = "<!-- 3 -->📚 Documentation" },
-  { message = "^perf", group = "<!-- 4 -->⚡ Performance" },
-  { message = "^refactor", group = "<!-- 2 -->🚜 Refactor" },
-  { message = "^style", group = "<!-- 5 -->🎨 Styling" },
-  { message = "^test", group = "<!-- 6 -->🧪 Testing" },
-  { message = "^chore\\(release\\): prepare for", skip = true },
-  { message = "^chore\\(deps.*\\)", skip = true },
-  { message = "^chore\\(pr\\)", skip = true },
-  { message = "^chore\\(pull\\)", skip = true },
-  { message = "^chore|^ci", group = "<!-- 7 -->⚙️ Miscellaneous Tasks" },
-  { body = ".*security", group = "<!-- 8 -->🛡️ Security" },
-  { message = "^revert", group = "<!-- 9 -->◀️ Revert" },
-]
-# protect breaking changes from being skipped due to matching a skipping commit_parser
-protect_breaking_commits = false
-# filter out the commits that are not matched by commit parsers
-filter_commits = false
-# regex for matching git tags
-# tag_pattern = "v[0-9].*"
-# regex for skipping tags
-# skip_tags = ""
-# regex for ignoring tags
-ignore_tags = ".*-nightly-.*"
-# sort the tags topologically
-topo_order = false
-# sort the commits inside sections by oldest/newest order
-sort_commits = "oldest"
-# limit the number of commits included in the changelog.
-# limit_commits = 42

codecov.yml

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

config/config-docs-template.md

@@ -1,19 +0,0 @@
-# Configurations
-
-## Standalone Mode
-
-{{ toml2docs "./standalone.example.toml" }}
-
-## Cluster Mode
-
-### Frontend
-
-{{ toml2docs "./frontend.example.toml" }}
-
-### Metasrv
-
-{{ toml2docs "./metasrv.example.toml" }}
-
-### Datanode
-
-{{ toml2docs "./datanode.example.toml" }}

config/config.md

@@ -1,376 +0,0 @@
-# Configurations
-
-## Standalone Mode
-
-| Key | Type | Default | Descriptions |
-| --- | -----| ------- | ----------- |
-| `mode` | String | `standalone` | The running mode of the datanode. It can be `standalone` or `distributed`. |
-| `enable_telemetry` | Bool | `true` | Enable telemetry to collect anonymous usage data. |
-| `default_timezone` | String | `None` | The default timezone of the server. |
-| `http` | -- | -- | The HTTP server options. |
-| `http.addr` | String | `127.0.0.1:4000` | The address to bind the HTTP server. |
-| `http.timeout` | String | `30s` | HTTP request timeout. |
-| `http.body_limit` | String | `64MB` | HTTP request body limit.<br/>Support the following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`. |
-| `grpc` | -- | -- | The gRPC server options. |
-| `grpc.addr` | String | `127.0.0.1:4001` | The address to bind the gRPC server. |
-| `grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
-| `mysql` | -- | -- | MySQL server options. |
-| `mysql.enable` | Bool | `true` | Whether to enable. |
-| `mysql.addr` | String | `127.0.0.1:4002` | The addr to bind the MySQL server. |
-| `mysql.runtime_size` | Integer | `2` | The number of server worker threads. |
-| `mysql.tls` | -- | -- | -- |
-| `mysql.tls.mode` | String | `disable` | TLS mode, refer to https://www.postgresql.org/docs/current/libpq-ssl.html<br/>- `disable` (default value)<br/>- `prefer`<br/>- `require`<br/>- `verify-ca`<br/>- `verify-full` |
-| `mysql.tls.cert_path` | String | `None` | Certificate file path. |
-| `mysql.tls.key_path` | String | `None` | Private key file path. |
-| `mysql.tls.watch` | Bool | `false` | Watch for Certificate and key file change and auto reload |
-| `postgres` | -- | -- | PostgresSQL server options. |
-| `postgres.enable` | Bool | `true` | Whether to enable |
-| `postgres.addr` | String | `127.0.0.1:4003` | The addr to bind the PostgresSQL server. |
-| `postgres.runtime_size` | Integer | `2` | The number of server worker threads. |
-| `postgres.tls` | -- | -- | PostgresSQL server TLS options, see `mysql_options.tls` section. |
-| `postgres.tls.mode` | String | `disable` | TLS mode. |
-| `postgres.tls.cert_path` | String | `None` | Certificate file path. |
-| `postgres.tls.key_path` | String | `None` | Private key file path. |
-| `postgres.tls.watch` | Bool | `false` | Watch for Certificate and key file change and auto reload |
-| `opentsdb` | -- | -- | OpenTSDB protocol options. |
-| `opentsdb.enable` | Bool | `true` | Whether to enable |
-| `opentsdb.addr` | String | `127.0.0.1:4242` | OpenTSDB telnet API server address. |
-| `opentsdb.runtime_size` | Integer | `2` | The number of server worker threads. |
-| `influxdb` | -- | -- | InfluxDB protocol options. |
-| `influxdb.enable` | Bool | `true` | Whether to enable InfluxDB protocol in HTTP API. |
-| `prom_store` | -- | -- | Prometheus remote storage options |
-| `prom_store.enable` | Bool | `true` | Whether to enable Prometheus remote write and read in HTTP API. |
-| `prom_store.with_metric_engine` | Bool | `true` | Whether to store the data from Prometheus remote write in metric engine. |
-| `wal` | -- | -- | The WAL options. |
-| `wal.provider` | String | `raft_engine` | The provider of the WAL.<br/>- `raft_engine`: the wal is stored in the local file system by raft-engine.<br/>- `kafka`: it's remote wal that data is stored in Kafka. |
-| `wal.dir` | String | `None` | The directory to store the WAL files.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.file_size` | String | `256MB` | The size of the WAL segment file.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.purge_threshold` | String | `4GB` | The threshold of the WAL size to trigger a flush.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.purge_interval` | String | `10m` | The interval to trigger a flush.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.read_batch_size` | Integer | `128` | The read batch size.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.sync_write` | Bool | `false` | Whether to use sync write.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.enable_log_recycle` | Bool | `true` | Whether to reuse logically truncated log files.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.prefill_log_files` | Bool | `false` | Whether to pre-create log files on start up.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.sync_period` | String | `10s` | Duration for fsyncing log files.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.broker_endpoints` | Array | -- | The Kafka broker endpoints.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.max_batch_size` | String | `1MB` | The max size of a single producer batch.<br/>Warning: Kafka has a default limit of 1MB per message in a topic.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.linger` | String | `200ms` | The linger duration of a kafka batch producer.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.consumer_wait_timeout` | String | `100ms` | The consumer wait timeout.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.backoff_init` | String | `500ms` | The initial backoff delay.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.backoff_max` | String | `10s` | The maximum backoff delay.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.backoff_base` | Integer | `2` | The exponential backoff rate, i.e. next backoff = base * current backoff.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.backoff_deadline` | String | `5mins` | The deadline of retries.<br/>**It's only used when the provider is `kafka`**. |
-| `metadata_store` | -- | -- | Metadata storage options. |
-| `metadata_store.file_size` | String | `256MB` | Kv file size in bytes. |
-| `metadata_store.purge_threshold` | String | `4GB` | Kv purge threshold. |
-| `procedure` | -- | -- | Procedure storage options. |
-| `procedure.max_retry_times` | Integer | `3` | Procedure max retry time. |
-| `procedure.retry_delay` | String | `500ms` | Initial retry delay of procedures, increases exponentially |
-| `storage` | -- | -- | The data storage options. |
-| `storage.data_home` | String | `/tmp/greptimedb/` | The working home directory. |
-| `storage.type` | String | `File` | The storage type used to store the data.<br/>- `File`: the data is stored in the local file system.<br/>- `S3`: the data is stored in the S3 object storage.<br/>- `Gcs`: the data is stored in the Google Cloud Storage.<br/>- `Azblob`: the data is stored in the Azure Blob Storage.<br/>- `Oss`: the data is stored in the Aliyun OSS. |
-| `storage.cache_path` | String | `None` | Cache configuration for object storage such as 'S3' etc.<br/>The local file cache directory. |
-| `storage.cache_capacity` | String | `None` | The local file cache capacity in bytes. |
-| `storage.bucket` | String | `None` | The S3 bucket name.<br/>**It's only used when the storage type is `S3`, `Oss` and `Gcs`**. |
-| `storage.root` | String | `None` | The S3 data will be stored in the specified prefix, for example, `s3://${bucket}/${root}`.<br/>**It's only used when the storage type is `S3`, `Oss` and `Azblob`**. |
-| `storage.access_key_id` | String | `None` | The access key id of the aws account.<br/>It's **highly recommended** to use AWS IAM roles instead of hardcoding the access key id and secret key.<br/>**It's only used when the storage type is `S3` and `Oss`**. |
-| `storage.secret_access_key` | String | `None` | The secret access key of the aws account.<br/>It's **highly recommended** to use AWS IAM roles instead of hardcoding the access key id and secret key.<br/>**It's only used when the storage type is `S3`**. |
-| `storage.access_key_secret` | String | `None` | The secret access key of the aliyun account.<br/>**It's only used when the storage type is `Oss`**. |
-| `storage.account_name` | String | `None` | The account key of the azure account.<br/>**It's only used when the storage type is `Azblob`**. |
-| `storage.account_key` | String | `None` | The account key of the azure account.<br/>**It's only used when the storage type is `Azblob`**. |
-| `storage.scope` | String | `None` | The scope of the google cloud storage.<br/>**It's only used when the storage type is `Gcs`**. |
-| `storage.credential_path` | String | `None` | The credential path of the google cloud storage.<br/>**It's only used when the storage type is `Gcs`**. |
-| `storage.container` | String | `None` | The container of the azure account.<br/>**It's only used when the storage type is `Azblob`**. |
-| `storage.sas_token` | String | `None` | The sas token of the azure account.<br/>**It's only used when the storage type is `Azblob`**. |
-| `storage.endpoint` | String | `None` | The endpoint of the S3 service.<br/>**It's only used when the storage type is `S3`, `Oss`, `Gcs` and `Azblob`**. |
-| `storage.region` | String | `None` | The region of the S3 service.<br/>**It's only used when the storage type is `S3`, `Oss`, `Gcs` and `Azblob`**. |
-| `[[region_engine]]` | -- | -- | The region engine options. You can configure multiple region engines. |
-| `region_engine.mito` | -- | -- | The Mito engine options. |
-| `region_engine.mito.num_workers` | Integer | `8` | Number of region workers. |
-| `region_engine.mito.worker_channel_size` | Integer | `128` | Request channel size of each worker. |
-| `region_engine.mito.worker_request_batch_size` | Integer | `64` | Max batch size for a worker to handle requests. |
-| `region_engine.mito.manifest_checkpoint_distance` | Integer | `10` | Number of meta action updated to trigger a new checkpoint for the manifest. |
-| `region_engine.mito.compress_manifest` | Bool | `false` | Whether to compress manifest and checkpoint file by gzip (default false). |
-| `region_engine.mito.max_background_jobs` | Integer | `4` | Max number of running background jobs |
-| `region_engine.mito.auto_flush_interval` | String | `1h` | Interval to auto flush a region if it has not flushed yet. |
-| `region_engine.mito.global_write_buffer_size` | String | `1GB` | Global write buffer size for all regions. If not set, it's default to 1/8 of OS memory with a max limitation of 1GB. |
-| `region_engine.mito.global_write_buffer_reject_size` | String | `2GB` | Global write buffer size threshold to reject write requests. If not set, it's default to 2 times of `global_write_buffer_size` |
-| `region_engine.mito.sst_meta_cache_size` | String | `128MB` | Cache size for SST metadata. Setting it to 0 to disable the cache.<br/>If not set, it's default to 1/32 of OS memory with a max limitation of 128MB. |
-| `region_engine.mito.vector_cache_size` | String | `512MB` | Cache size for vectors and arrow arrays. Setting it to 0 to disable the cache.<br/>If not set, it's default to 1/16 of OS memory with a max limitation of 512MB. |
-| `region_engine.mito.page_cache_size` | String | `512MB` | Cache size for pages of SST row groups. Setting it to 0 to disable the cache.<br/>If not set, it's default to 1/16 of OS memory with a max limitation of 512MB. |
-| `region_engine.mito.sst_write_buffer_size` | String | `8MB` | Buffer size for SST writing. |
-| `region_engine.mito.scan_parallelism` | Integer | `0` | Parallelism to scan a region (default: 1/4 of cpu cores).<br/>- `0`: using the default value (1/4 of cpu cores).<br/>- `1`: scan in current thread.<br/>- `n`: scan in parallelism n. |
-| `region_engine.mito.parallel_scan_channel_size` | Integer | `32` | Capacity of the channel to send data from parallel scan tasks to the main task. |
-| `region_engine.mito.allow_stale_entries` | Bool | `false` | Whether to allow stale WAL entries read during replay. |
-| `region_engine.mito.inverted_index` | -- | -- | The options for inverted index in Mito engine. |
-| `region_engine.mito.inverted_index.create_on_flush` | String | `auto` | Whether to create the index on flush.<br/>- `auto`: automatically<br/>- `disable`: never |
-| `region_engine.mito.inverted_index.create_on_compaction` | String | `auto` | Whether to create the index on compaction.<br/>- `auto`: automatically<br/>- `disable`: never |
-| `region_engine.mito.inverted_index.apply_on_query` | String | `auto` | Whether to apply the index on query<br/>- `auto`: automatically<br/>- `disable`: never |
-| `region_engine.mito.inverted_index.mem_threshold_on_create` | String | `64M` | Memory threshold for performing an external sort during index creation.<br/>Setting to empty will disable external sorting, forcing all sorting operations to happen in memory. |
-| `region_engine.mito.inverted_index.intermediate_path` | String | `""` | File system path to store intermediate files for external sorting (default `{data_home}/index_intermediate`). |
-| `region_engine.mito.memtable` | -- | -- | -- |
-| `region_engine.mito.memtable.type` | String | `time_series` | Memtable type.<br/>- `time_series`: time-series memtable<br/>- `partition_tree`: partition tree memtable (experimental) |
-| `region_engine.mito.memtable.index_max_keys_per_shard` | Integer | `8192` | The max number of keys in one shard.<br/>Only available for `partition_tree` memtable. |
-| `region_engine.mito.memtable.data_freeze_threshold` | Integer | `32768` | The max rows of data inside the actively writing buffer in one shard.<br/>Only available for `partition_tree` memtable. |
-| `region_engine.mito.memtable.fork_dictionary_bytes` | String | `1GiB` | Max dictionary bytes.<br/>Only available for `partition_tree` memtable. |
-| `logging` | -- | -- | The logging options. |
-| `logging.dir` | String | `/tmp/greptimedb/logs` | The directory to store the log files. |
-| `logging.level` | String | `None` | The log level. Can be `info`/`debug`/`warn`/`error`. |
-| `logging.enable_otlp_tracing` | Bool | `false` | Enable OTLP tracing. |
-| `logging.otlp_endpoint` | String | `None` | The OTLP tracing endpoint. |
-| `logging.append_stdout` | Bool | `true` | Whether to append logs to stdout. |
-| `logging.tracing_sample_ratio` | -- | -- | The percentage of tracing will be sampled and exported.<br/>Valid range `[0, 1]`, 1 means all traces are sampled, 0 means all traces are not sampled, the default value is 1.<br/>ratio > 1 are treated as 1. Fractions < 0 are treated as 0 |
-| `logging.tracing_sample_ratio.default_ratio` | Float | `1.0` | -- |
-| `export_metrics` | -- | -- | The datanode can export its metrics and send to Prometheus compatible service (e.g. send to `greptimedb` itself) from remote-write API.<br/>This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape. |
-| `export_metrics.enable` | Bool | `false` | whether enable export metrics. |
-| `export_metrics.write_interval` | String | `30s` | The interval of export metrics. |
-| `export_metrics.self_import` | -- | -- | For `standalone` mode, `self_import` is recommend to collect metrics generated by itself |
-| `export_metrics.self_import.db` | String | `None` | -- |
-| `export_metrics.remote_write` | -- | -- | -- |
-| `export_metrics.remote_write.url` | String | `""` | The url the metrics send to. The url example can be: `http://127.0.0.1:4000/v1/prometheus/write?db=information_schema`. |
-| `export_metrics.remote_write.headers` | InlineTable | -- | HTTP headers of Prometheus remote-write carry. |
-
-
-## Cluster Mode
-
-### Frontend
-
-| Key | Type | Default | Descriptions |
-| --- | -----| ------- | ----------- |
-| `mode` | String | `standalone` | The running mode of the datanode. It can be `standalone` or `distributed`. |
-| `default_timezone` | String | `None` | The default timezone of the server. |
-| `heartbeat` | -- | -- | The heartbeat options. |
-| `heartbeat.interval` | String | `18s` | Interval for sending heartbeat messages to the metasrv. |
-| `heartbeat.retry_interval` | String | `3s` | Interval for retrying to send heartbeat messages to the metasrv. |
-| `http` | -- | -- | The HTTP server options. |
-| `http.addr` | String | `127.0.0.1:4000` | The address to bind the HTTP server. |
-| `http.timeout` | String | `30s` | HTTP request timeout. |
-| `http.body_limit` | String | `64MB` | HTTP request body limit.<br/>Support the following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`. |
-| `grpc` | -- | -- | The gRPC server options. |
-| `grpc.addr` | String | `127.0.0.1:4001` | The address to bind the gRPC server. |
-| `grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
-| `mysql` | -- | -- | MySQL server options. |
-| `mysql.enable` | Bool | `true` | Whether to enable. |
-| `mysql.addr` | String | `127.0.0.1:4002` | The addr to bind the MySQL server. |
-| `mysql.runtime_size` | Integer | `2` | The number of server worker threads. |
-| `mysql.tls` | -- | -- | -- |
-| `mysql.tls.mode` | String | `disable` | TLS mode, refer to https://www.postgresql.org/docs/current/libpq-ssl.html<br/>- `disable` (default value)<br/>- `prefer`<br/>- `require`<br/>- `verify-ca`<br/>- `verify-full` |
-| `mysql.tls.cert_path` | String | `None` | Certificate file path. |
-| `mysql.tls.key_path` | String | `None` | Private key file path. |
-| `mysql.tls.watch` | Bool | `false` | Watch for Certificate and key file change and auto reload |
-| `postgres` | -- | -- | PostgresSQL server options. |
-| `postgres.enable` | Bool | `true` | Whether to enable |
-| `postgres.addr` | String | `127.0.0.1:4003` | The addr to bind the PostgresSQL server. |
-| `postgres.runtime_size` | Integer | `2` | The number of server worker threads. |
-| `postgres.tls` | -- | -- | PostgresSQL server TLS options, see `mysql_options.tls` section. |
-| `postgres.tls.mode` | String | `disable` | TLS mode. |
-| `postgres.tls.cert_path` | String | `None` | Certificate file path. |
-| `postgres.tls.key_path` | String | `None` | Private key file path. |
-| `postgres.tls.watch` | Bool | `false` | Watch for Certificate and key file change and auto reload |
-| `opentsdb` | -- | -- | OpenTSDB protocol options. |
-| `opentsdb.enable` | Bool | `true` | Whether to enable |
-| `opentsdb.addr` | String | `127.0.0.1:4242` | OpenTSDB telnet API server address. |
-| `opentsdb.runtime_size` | Integer | `2` | The number of server worker threads. |
-| `influxdb` | -- | -- | InfluxDB protocol options. |
-| `influxdb.enable` | Bool | `true` | Whether to enable InfluxDB protocol in HTTP API. |
-| `prom_store` | -- | -- | Prometheus remote storage options |
-| `prom_store.enable` | Bool | `true` | Whether to enable Prometheus remote write and read in HTTP API. |
-| `prom_store.with_metric_engine` | Bool | `true` | Whether to store the data from Prometheus remote write in metric engine. |
-| `meta_client` | -- | -- | The metasrv client options. |
-| `meta_client.metasrv_addrs` | Array | -- | The addresses of the metasrv. |
-| `meta_client.timeout` | String | `3s` | Operation timeout. |
-| `meta_client.heartbeat_timeout` | String | `500ms` | Heartbeat timeout. |
-| `meta_client.ddl_timeout` | String | `10s` | DDL timeout. |
-| `meta_client.connect_timeout` | String | `1s` | Connect server timeout. |
-| `meta_client.tcp_nodelay` | Bool | `true` | `TCP_NODELAY` option for accepted connections. |
-| `meta_client.metadata_cache_max_capacity` | Integer | `100000` | The configuration about the cache of the metadata. |
-| `meta_client.metadata_cache_ttl` | String | `10m` | TTL of the metadata cache. |
-| `meta_client.metadata_cache_tti` | String | `5m` | -- |
-| `datanode` | -- | -- | Datanode options. |
-| `datanode.client` | -- | -- | Datanode client options. |
-| `datanode.client.timeout` | String | `10s` | -- |
-| `datanode.client.connect_timeout` | String | `10s` | -- |
-| `datanode.client.tcp_nodelay` | Bool | `true` | -- |
-| `logging` | -- | -- | The logging options. |
-| `logging.dir` | String | `/tmp/greptimedb/logs` | The directory to store the log files. |
-| `logging.level` | String | `None` | The log level. Can be `info`/`debug`/`warn`/`error`. |
-| `logging.enable_otlp_tracing` | Bool | `false` | Enable OTLP tracing. |
-| `logging.otlp_endpoint` | String | `None` | The OTLP tracing endpoint. |
-| `logging.append_stdout` | Bool | `true` | Whether to append logs to stdout. |
-| `logging.tracing_sample_ratio` | -- | -- | The percentage of tracing will be sampled and exported.<br/>Valid range `[0, 1]`, 1 means all traces are sampled, 0 means all traces are not sampled, the default value is 1.<br/>ratio > 1 are treated as 1. Fractions < 0 are treated as 0 |
-| `logging.tracing_sample_ratio.default_ratio` | Float | `1.0` | -- |
-| `export_metrics` | -- | -- | The datanode can export its metrics and send to Prometheus compatible service (e.g. send to `greptimedb` itself) from remote-write API.<br/>This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape. |
-| `export_metrics.enable` | Bool | `false` | whether enable export metrics. |
-| `export_metrics.write_interval` | String | `30s` | The interval of export metrics. |
-| `export_metrics.self_import` | -- | -- | For `standalone` mode, `self_import` is recommend to collect metrics generated by itself |
-| `export_metrics.self_import.db` | String | `None` | -- |
-| `export_metrics.remote_write` | -- | -- | -- |
-| `export_metrics.remote_write.url` | String | `""` | The url the metrics send to. The url example can be: `http://127.0.0.1:4000/v1/prometheus/write?db=information_schema`. |
-| `export_metrics.remote_write.headers` | InlineTable | -- | HTTP headers of Prometheus remote-write carry. |
-
-
-### Metasrv
-
-| Key | Type | Default | Descriptions |
-| --- | -----| ------- | ----------- |
-| `data_home` | String | `/tmp/metasrv/` | The working home directory. |
-| `bind_addr` | String | `127.0.0.1:3002` | The bind address of metasrv. |
-| `server_addr` | String | `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. |
-| `store_addr` | String | `127.0.0.1:2379` | Etcd server address. |
-| `selector` | String | `lease_based` | Datanode selector type.<br/>- `lease_based` (default value).<br/>- `load_based`<br/>For details, please see "https://docs.greptime.com/developer-guide/metasrv/selector". |
-| `use_memory_store` | Bool | `false` | Store data in memory. |
-| `enable_telemetry` | Bool | `true` | Whether to enable greptimedb telemetry. |
-| `store_key_prefix` | String | `""` | If it's not empty, the metasrv will store all data with this key prefix. |
-| `procedure` | -- | -- | Procedure storage options. |
-| `procedure.max_retry_times` | Integer | `12` | Procedure max retry time. |
-| `procedure.retry_delay` | String | `500ms` | Initial retry delay of procedures, increases exponentially |
-| `procedure.max_metadata_value_size` | String | `1500KiB` | Auto split large value<br/>GreptimeDB procedure uses etcd as the default metadata storage backend.<br/>The etcd the maximum size of any request is 1.5 MiB<br/>1500KiB = 1536KiB (1.5MiB) - 36KiB (reserved size of key)<br/>Comments out the `max_metadata_value_size`, for don't split large value (no limit). |
-| `failure_detector` | -- | -- | -- |
-| `failure_detector.threshold` | Float | `8.0` | -- |
-| `failure_detector.min_std_deviation` | String | `100ms` | -- |
-| `failure_detector.acceptable_heartbeat_pause` | String | `3000ms` | -- |
-| `failure_detector.first_heartbeat_estimate` | String | `1000ms` | -- |
-| `datanode` | -- | -- | Datanode options. |
-| `datanode.client` | -- | -- | Datanode client options. |
-| `datanode.client.timeout` | String | `10s` | -- |
-| `datanode.client.connect_timeout` | String | `10s` | -- |
-| `datanode.client.tcp_nodelay` | Bool | `true` | -- |
-| `wal` | -- | -- | -- |
-| `wal.provider` | String | `raft_engine` | -- |
-| `wal.broker_endpoints` | Array | -- | The broker endpoints of the Kafka cluster. |
-| `wal.num_topics` | Integer | `64` | Number of topics to be created upon start. |
-| `wal.selector_type` | String | `round_robin` | Topic selector type.<br/>Available selector types:<br/>- `round_robin` (default) |
-| `wal.topic_name_prefix` | String | `greptimedb_wal_topic` | A Kafka topic is constructed by concatenating `topic_name_prefix` and `topic_id`. |
-| `wal.replication_factor` | Integer | `1` | Expected number of replicas of each partition. |
-| `wal.create_topic_timeout` | String | `30s` | Above which a topic creation operation will be cancelled. |
-| `wal.backoff_init` | String | `500ms` | The initial backoff for kafka clients. |
-| `wal.backoff_max` | String | `10s` | The maximum backoff for kafka clients. |
-| `wal.backoff_base` | Integer | `2` | Exponential backoff rate, i.e. next backoff = base * current backoff. |
-| `wal.backoff_deadline` | String | `5mins` | Stop reconnecting if the total wait time reaches the deadline. If this config is missing, the reconnecting won't terminate. |
-| `logging` | -- | -- | The logging options. |
-| `logging.dir` | String | `/tmp/greptimedb/logs` | The directory to store the log files. |
-| `logging.level` | String | `None` | The log level. Can be `info`/`debug`/`warn`/`error`. |
-| `logging.enable_otlp_tracing` | Bool | `false` | Enable OTLP tracing. |
-| `logging.otlp_endpoint` | String | `None` | The OTLP tracing endpoint. |
-| `logging.append_stdout` | Bool | `true` | Whether to append logs to stdout. |
-| `logging.tracing_sample_ratio` | -- | -- | The percentage of tracing will be sampled and exported.<br/>Valid range `[0, 1]`, 1 means all traces are sampled, 0 means all traces are not sampled, the default value is 1.<br/>ratio > 1 are treated as 1. Fractions < 0 are treated as 0 |
-| `logging.tracing_sample_ratio.default_ratio` | Float | `1.0` | -- |
-| `export_metrics` | -- | -- | The datanode can export its metrics and send to Prometheus compatible service (e.g. send to `greptimedb` itself) from remote-write API.<br/>This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape. |
-| `export_metrics.enable` | Bool | `false` | whether enable export metrics. |
-| `export_metrics.write_interval` | String | `30s` | The interval of export metrics. |
-| `export_metrics.self_import` | -- | -- | For `standalone` mode, `self_import` is recommend to collect metrics generated by itself |
-| `export_metrics.self_import.db` | String | `None` | -- |
-| `export_metrics.remote_write` | -- | -- | -- |
-| `export_metrics.remote_write.url` | String | `""` | The url the metrics send to. The url example can be: `http://127.0.0.1:4000/v1/prometheus/write?db=information_schema`. |
-| `export_metrics.remote_write.headers` | InlineTable | -- | HTTP headers of Prometheus remote-write carry. |
-
-
-### Datanode
-
-| Key | Type | Default | Descriptions |
-| --- | -----| ------- | ----------- |
-| `mode` | String | `standalone` | The running mode of the datanode. It can be `standalone` or `distributed`. |
-| `node_id` | Integer | `None` | The datanode identifier and should be unique in the cluster. |
-| `require_lease_before_startup` | Bool | `false` | Start services after regions have obtained leases.<br/>It will block the datanode start if it can't receive leases in the heartbeat from metasrv. |
-| `init_regions_in_background` | Bool | `false` | Initialize all regions in the background during the startup.<br/>By default, it provides services after all regions have been initialized. |
-| `rpc_addr` | String | `127.0.0.1:3001` | The gRPC address of the datanode. |
-| `rpc_hostname` | String | `None` | The hostname of the datanode. |
-| `rpc_runtime_size` | Integer | `8` | The number of gRPC server worker threads. |
-| `rpc_max_recv_message_size` | String | `512MB` | The maximum receive message size for gRPC server. |
-| `rpc_max_send_message_size` | String | `512MB` | The maximum send message size for gRPC server. |
-| `enable_telemetry` | Bool | `true` | Enable telemetry to collect anonymous usage data. |
-| `heartbeat` | -- | -- | The heartbeat options. |
-| `heartbeat.interval` | String | `3s` | Interval for sending heartbeat messages to the metasrv. |
-| `heartbeat.retry_interval` | String | `3s` | Interval for retrying to send heartbeat messages to the metasrv. |
-| `meta_client` | -- | -- | The metasrv client options. |
-| `meta_client.metasrv_addrs` | Array | -- | The addresses of the metasrv. |
-| `meta_client.timeout` | String | `3s` | Operation timeout. |
-| `meta_client.heartbeat_timeout` | String | `500ms` | Heartbeat timeout. |
-| `meta_client.ddl_timeout` | String | `10s` | DDL timeout. |
-| `meta_client.connect_timeout` | String | `1s` | Connect server timeout. |
-| `meta_client.tcp_nodelay` | Bool | `true` | `TCP_NODELAY` option for accepted connections. |
-| `meta_client.metadata_cache_max_capacity` | Integer | `100000` | The configuration about the cache of the metadata. |
-| `meta_client.metadata_cache_ttl` | String | `10m` | TTL of the metadata cache. |
-| `meta_client.metadata_cache_tti` | String | `5m` | -- |
-| `wal` | -- | -- | The WAL options. |
-| `wal.provider` | String | `raft_engine` | The provider of the WAL.<br/>- `raft_engine`: the wal is stored in the local file system by raft-engine.<br/>- `kafka`: it's remote wal that data is stored in Kafka. |
-| `wal.dir` | String | `None` | The directory to store the WAL files.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.file_size` | String | `256MB` | The size of the WAL segment file.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.purge_threshold` | String | `4GB` | The threshold of the WAL size to trigger a flush.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.purge_interval` | String | `10m` | The interval to trigger a flush.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.read_batch_size` | Integer | `128` | The read batch size.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.sync_write` | Bool | `false` | Whether to use sync write.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.enable_log_recycle` | Bool | `true` | Whether to reuse logically truncated log files.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.prefill_log_files` | Bool | `false` | Whether to pre-create log files on start up.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.sync_period` | String | `10s` | Duration for fsyncing log files.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.broker_endpoints` | Array | -- | The Kafka broker endpoints.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.max_batch_size` | String | `1MB` | The max size of a single producer batch.<br/>Warning: Kafka has a default limit of 1MB per message in a topic.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.linger` | String | `200ms` | The linger duration of a kafka batch producer.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.consumer_wait_timeout` | String | `100ms` | The consumer wait timeout.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.backoff_init` | String | `500ms` | The initial backoff delay.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.backoff_max` | String | `10s` | The maximum backoff delay.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.backoff_base` | Integer | `2` | The exponential backoff rate, i.e. next backoff = base * current backoff.<br/>**It's only used when the provider is `kafka`**. |
-| `wal.backoff_deadline` | String | `5mins` | The deadline of retries.<br/>**It's only used when the provider is `kafka`**. |
-| `storage` | -- | -- | The data storage options. |
-| `storage.data_home` | String | `/tmp/greptimedb/` | The working home directory. |
-| `storage.type` | String | `File` | The storage type used to store the data.<br/>- `File`: the data is stored in the local file system.<br/>- `S3`: the data is stored in the S3 object storage.<br/>- `Gcs`: the data is stored in the Google Cloud Storage.<br/>- `Azblob`: the data is stored in the Azure Blob Storage.<br/>- `Oss`: the data is stored in the Aliyun OSS. |
-| `storage.cache_path` | String | `None` | Cache configuration for object storage such as 'S3' etc.<br/>The local file cache directory. |
-| `storage.cache_capacity` | String | `None` | The local file cache capacity in bytes. |
-| `storage.bucket` | String | `None` | The S3 bucket name.<br/>**It's only used when the storage type is `S3`, `Oss` and `Gcs`**. |
-| `storage.root` | String | `None` | The S3 data will be stored in the specified prefix, for example, `s3://${bucket}/${root}`.<br/>**It's only used when the storage type is `S3`, `Oss` and `Azblob`**. |
-| `storage.access_key_id` | String | `None` | The access key id of the aws account.<br/>It's **highly recommended** to use AWS IAM roles instead of hardcoding the access key id and secret key.<br/>**It's only used when the storage type is `S3` and `Oss`**. |
-| `storage.secret_access_key` | String | `None` | The secret access key of the aws account.<br/>It's **highly recommended** to use AWS IAM roles instead of hardcoding the access key id and secret key.<br/>**It's only used when the storage type is `S3`**. |
-| `storage.access_key_secret` | String | `None` | The secret access key of the aliyun account.<br/>**It's only used when the storage type is `Oss`**. |
-| `storage.account_name` | String | `None` | The account key of the azure account.<br/>**It's only used when the storage type is `Azblob`**. |
-| `storage.account_key` | String | `None` | The account key of the azure account.<br/>**It's only used when the storage type is `Azblob`**. |
-| `storage.scope` | String | `None` | The scope of the google cloud storage.<br/>**It's only used when the storage type is `Gcs`**. |
-| `storage.credential_path` | String | `None` | The credential path of the google cloud storage.<br/>**It's only used when the storage type is `Gcs`**. |
-| `storage.container` | String | `None` | The container of the azure account.<br/>**It's only used when the storage type is `Azblob`**. |
-| `storage.sas_token` | String | `None` | The sas token of the azure account.<br/>**It's only used when the storage type is `Azblob`**. |
-| `storage.endpoint` | String | `None` | The endpoint of the S3 service.<br/>**It's only used when the storage type is `S3`, `Oss`, `Gcs` and `Azblob`**. |
-| `storage.region` | String | `None` | The region of the S3 service.<br/>**It's only used when the storage type is `S3`, `Oss`, `Gcs` and `Azblob`**. |
-| `[[region_engine]]` | -- | -- | The region engine options. You can configure multiple region engines. |
-| `region_engine.mito` | -- | -- | The Mito engine options. |
-| `region_engine.mito.num_workers` | Integer | `8` | Number of region workers. |
-| `region_engine.mito.worker_channel_size` | Integer | `128` | Request channel size of each worker. |
-| `region_engine.mito.worker_request_batch_size` | Integer | `64` | Max batch size for a worker to handle requests. |
-| `region_engine.mito.manifest_checkpoint_distance` | Integer | `10` | Number of meta action updated to trigger a new checkpoint for the manifest. |
-| `region_engine.mito.compress_manifest` | Bool | `false` | Whether to compress manifest and checkpoint file by gzip (default false). |
-| `region_engine.mito.max_background_jobs` | Integer | `4` | Max number of running background jobs |
-| `region_engine.mito.auto_flush_interval` | String | `1h` | Interval to auto flush a region if it has not flushed yet. |
-| `region_engine.mito.global_write_buffer_size` | String | `1GB` | Global write buffer size for all regions. If not set, it's default to 1/8 of OS memory with a max limitation of 1GB. |
-| `region_engine.mito.global_write_buffer_reject_size` | String | `2GB` | Global write buffer size threshold to reject write requests. If not set, it's default to 2 times of `global_write_buffer_size` |
-| `region_engine.mito.sst_meta_cache_size` | String | `128MB` | Cache size for SST metadata. Setting it to 0 to disable the cache.<br/>If not set, it's default to 1/32 of OS memory with a max limitation of 128MB. |
-| `region_engine.mito.vector_cache_size` | String | `512MB` | Cache size for vectors and arrow arrays. Setting it to 0 to disable the cache.<br/>If not set, it's default to 1/16 of OS memory with a max limitation of 512MB. |
-| `region_engine.mito.page_cache_size` | String | `512MB` | Cache size for pages of SST row groups. Setting it to 0 to disable the cache.<br/>If not set, it's default to 1/16 of OS memory with a max limitation of 512MB. |
-| `region_engine.mito.sst_write_buffer_size` | String | `8MB` | Buffer size for SST writing. |
-| `region_engine.mito.scan_parallelism` | Integer | `0` | Parallelism to scan a region (default: 1/4 of cpu cores).<br/>- `0`: using the default value (1/4 of cpu cores).<br/>- `1`: scan in current thread.<br/>- `n`: scan in parallelism n. |
-| `region_engine.mito.parallel_scan_channel_size` | Integer | `32` | Capacity of the channel to send data from parallel scan tasks to the main task. |
-| `region_engine.mito.allow_stale_entries` | Bool | `false` | Whether to allow stale WAL entries read during replay. |
-| `region_engine.mito.inverted_index` | -- | -- | The options for inverted index in Mito engine. |
-| `region_engine.mito.inverted_index.create_on_flush` | String | `auto` | Whether to create the index on flush.<br/>- `auto`: automatically<br/>- `disable`: never |
-| `region_engine.mito.inverted_index.create_on_compaction` | String | `auto` | Whether to create the index on compaction.<br/>- `auto`: automatically<br/>- `disable`: never |
-| `region_engine.mito.inverted_index.apply_on_query` | String | `auto` | Whether to apply the index on query<br/>- `auto`: automatically<br/>- `disable`: never |
-| `region_engine.mito.inverted_index.mem_threshold_on_create` | String | `64M` | Memory threshold for performing an external sort during index creation.<br/>Setting to empty will disable external sorting, forcing all sorting operations to happen in memory. |
-| `region_engine.mito.inverted_index.intermediate_path` | String | `""` | File system path to store intermediate files for external sorting (default `{data_home}/index_intermediate`). |
-| `region_engine.mito.memtable` | -- | -- | -- |
-| `region_engine.mito.memtable.type` | String | `time_series` | Memtable type.<br/>- `time_series`: time-series memtable<br/>- `partition_tree`: partition tree memtable (experimental) |
-| `region_engine.mito.memtable.index_max_keys_per_shard` | Integer | `8192` | The max number of keys in one shard.<br/>Only available for `partition_tree` memtable. |
-| `region_engine.mito.memtable.data_freeze_threshold` | Integer | `32768` | The max rows of data inside the actively writing buffer in one shard.<br/>Only available for `partition_tree` memtable. |
-| `region_engine.mito.memtable.fork_dictionary_bytes` | String | `1GiB` | Max dictionary bytes.<br/>Only available for `partition_tree` memtable. |
-| `logging` | -- | -- | The logging options. |
-| `logging.dir` | String | `/tmp/greptimedb/logs` | The directory to store the log files. |
-| `logging.level` | String | `None` | The log level. Can be `info`/`debug`/`warn`/`error`. |
-| `logging.enable_otlp_tracing` | Bool | `false` | Enable OTLP tracing. |
-| `logging.otlp_endpoint` | String | `None` | The OTLP tracing endpoint. |
-| `logging.append_stdout` | Bool | `true` | Whether to append logs to stdout. |
-| `logging.tracing_sample_ratio` | -- | -- | The percentage of tracing will be sampled and exported.<br/>Valid range `[0, 1]`, 1 means all traces are sampled, 0 means all traces are not sampled, the default value is 1.<br/>ratio > 1 are treated as 1. Fractions < 0 are treated as 0 |
-| `logging.tracing_sample_ratio.default_ratio` | Float | `1.0` | -- |
-| `export_metrics` | -- | -- | The datanode can export its metrics and send to Prometheus compatible service (e.g. send to `greptimedb` itself) from remote-write API.<br/>This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape. |
-| `export_metrics.enable` | Bool | `false` | whether enable export metrics. |
-| `export_metrics.write_interval` | String | `30s` | The interval of export metrics. |
-| `export_metrics.self_import` | -- | -- | For `standalone` mode, `self_import` is recommend to collect metrics generated by itself |
-| `export_metrics.self_import.db` | String | `None` | -- |
-| `export_metrics.remote_write` | -- | -- | -- |
-| `export_metrics.remote_write.url` | String | `""` | The url the metrics send to. The url example can be: `http://127.0.0.1:4000/v1/prometheus/write?db=information_schema`. |
-| `export_metrics.remote_write.headers` | InlineTable | -- | HTTP headers of Prometheus remote-write carry. |

config/datanode.example.toml

@@ -1,430 +1,18 @@
-## The running mode of the datanode. It can be `standalone` or `distributed`.
-mode = "standalone"
-
-## The datanode identifier and should be unique in the cluster.
-## +toml2docs:none-default
 node_id = 42
-
-## Start services after regions have obtained leases.
-## It will block the datanode start if it can't receive leases in the heartbeat from metasrv.
-require_lease_before_startup = false
-
-## Initialize all regions in the background during the startup.
-## By default, it provides services after all regions have been initialized.
-init_regions_in_background = false
-
-## The gRPC address of the datanode.
-rpc_addr = "127.0.0.1:3001"
-
-## The hostname of the datanode.
-## +toml2docs:none-default
-rpc_hostname = "127.0.0.1"
-
-## The number of gRPC server worker threads.
+mode = 'distributed'
+rpc_addr = '127.0.0.1:3001'
+wal_dir = '/tmp/greptimedb/wal'
 rpc_runtime_size = 8
+mysql_addr = '127.0.0.1:4406'
+mysql_runtime_size = 4
+enable_memory_catalog = false
 
-## The maximum receive message size for gRPC server.
-rpc_max_recv_message_size = "512MB"
-
-## The maximum send message size for gRPC server.
-rpc_max_send_message_size = "512MB"
-
-## Enable telemetry to collect anonymous usage data.
-enable_telemetry = true
-
-## The heartbeat options.
-[heartbeat]
-## Interval for sending heartbeat messages to the metasrv.
-interval = "3s"
-
-## Interval for retrying to send heartbeat messages to the metasrv.
-retry_interval = "3s"
-
-## The metasrv client options.
-[meta_client]
-## The addresses of the metasrv.
-metasrv_addrs = ["127.0.0.1:3002"]
-
-## Operation timeout.
-timeout = "3s"
-
-## Heartbeat timeout.
-heartbeat_timeout = "500ms"
-
-## DDL timeout.
-ddl_timeout = "10s"
-
-## Connect server timeout.
-connect_timeout = "1s"
-
-## `TCP_NODELAY` option for accepted connections.
-tcp_nodelay = true
-
-## The configuration about the cache of the metadata.
-metadata_cache_max_capacity = 100000
-
-## TTL of the metadata cache.
-metadata_cache_ttl = "10m"
-
-# TTI of the metadata cache.
-metadata_cache_tti = "5m"
-
-## The WAL options.
-[wal]
-## The provider of the WAL.
-## - `raft_engine`: the wal is stored in the local file system by raft-engine.
-## - `kafka`: it's remote wal that data is stored in Kafka.
-provider = "raft_engine"
-
-## The directory to store the WAL files.
-## **It's only used when the provider is `raft_engine`**.
-## +toml2docs:none-default
-dir = "/tmp/greptimedb/wal"
-
-## The size of the WAL segment file.
-## **It's only used when the provider is `raft_engine`**.
-file_size = "256MB"
-
-## The threshold of the WAL size to trigger a flush.
-## **It's only used when the provider is `raft_engine`**.
-purge_threshold = "4GB"
-
-## The interval to trigger a flush.
-## **It's only used when the provider is `raft_engine`**.
-purge_interval = "10m"
-
-## The read batch size.
-## **It's only used when the provider is `raft_engine`**.
-read_batch_size = 128
-
-## Whether to use sync write.
-## **It's only used when the provider is `raft_engine`**.
-sync_write = false
-
-## Whether to reuse logically truncated log files.
-## **It's only used when the provider is `raft_engine`**.
-enable_log_recycle = true
-
-## Whether to pre-create log files on start up.
-## **It's only used when the provider is `raft_engine`**.
-prefill_log_files = false
-
-## Duration for fsyncing log files.
-## **It's only used when the provider is `raft_engine`**.
-sync_period = "10s"
-
-## The Kafka broker endpoints.
-## **It's only used when the provider is `kafka`**.
-broker_endpoints = ["127.0.0.1:9092"]
-
-## The max size of a single producer batch.
-## Warning: Kafka has a default limit of 1MB per message in a topic.
-## **It's only used when the provider is `kafka`**.
-max_batch_size = "1MB"
-
-## The linger duration of a kafka batch producer.
-## **It's only used when the provider is `kafka`**.
-linger = "200ms"
-
-## The consumer wait timeout.
-## **It's only used when the provider is `kafka`**.
-consumer_wait_timeout = "100ms"
-
-## The initial backoff delay.
-## **It's only used when the provider is `kafka`**.
-backoff_init = "500ms"
-
-## The maximum backoff delay.
-## **It's only used when the provider is `kafka`**.
-backoff_max = "10s"
-
-## The exponential backoff rate, i.e. next backoff = base * current backoff.
-## **It's only used when the provider is `kafka`**.
-backoff_base = 2
-
-## The deadline of retries.
-## **It's only used when the provider is `kafka`**.
-backoff_deadline = "5mins"
-
-# Example of using S3 as the storage.
-# [storage]
-# type = "S3"
-# bucket = "greptimedb"
-# root = "data"
-# access_key_id = "test"
-# secret_access_key = "123456"
-# endpoint = "https://s3.amazonaws.com"
-# region = "us-west-2"
-
-# Example of using Oss as the storage.
-# [storage]
-# type = "Oss"
-# bucket = "greptimedb"
-# root = "data"
-# access_key_id = "test"
-# access_key_secret = "123456"
-# endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
-
-# Example of using Azblob as the storage.
-# [storage]
-# type = "Azblob"
-# container = "greptimedb"
-# root = "data"
-# account_name = "test"
-# account_key = "123456"
-# endpoint = "https://greptimedb.blob.core.windows.net"
-# sas_token = ""
-
-# Example of using Gcs as the storage.
-# [storage]
-# type = "Gcs"
-# bucket = "greptimedb"
-# root = "data"
-# scope = "test"
-# credential_path = "123456"
-# endpoint = "https://storage.googleapis.com"
-
-## The data storage options.
 [storage]
-## The working home directory.
-data_home = "/tmp/greptimedb/"
+type = 'File'
+data_dir = '/tmp/greptimedb/data/'
 
-## The storage type used to store the data.
-## - `File`: the data is stored in the local file system.
-## - `S3`: the data is stored in the S3 object storage.
-## - `Gcs`: the data is stored in the Google Cloud Storage.
-## - `Azblob`: the data is stored in the Azure Blob Storage.
-## - `Oss`: the data is stored in the Aliyun OSS.
-type = "File"
-
-## Cache configuration for object storage such as 'S3' etc.
-## The local file cache directory.
-## +toml2docs:none-default
-cache_path = "/path/local_cache"
-
-## The local file cache capacity in bytes.
-## +toml2docs:none-default
-cache_capacity = "256MB"
-
-## The S3 bucket name.
-## **It's only used when the storage type is `S3`, `Oss` and `Gcs`**.
-## +toml2docs:none-default
-bucket = "greptimedb"
-
-## The S3 data will be stored in the specified prefix, for example, `s3://${bucket}/${root}`.
-## **It's only used when the storage type is `S3`, `Oss` and `Azblob`**.
-## +toml2docs:none-default
-root = "greptimedb"
-
-## The access key id of the aws account.
-## It's **highly recommended** to use AWS IAM roles instead of hardcoding the access key id and secret key.
-## **It's only used when the storage type is `S3` and `Oss`**.
-## +toml2docs:none-default
-access_key_id = "test"
-
-## The secret access key of the aws account.
-## It's **highly recommended** to use AWS IAM roles instead of hardcoding the access key id and secret key.
-## **It's only used when the storage type is `S3`**.
-## +toml2docs:none-default
-secret_access_key = "test"
-
-## The secret access key of the aliyun account.
-## **It's only used when the storage type is `Oss`**.
-## +toml2docs:none-default
-access_key_secret = "test"
-
-## The account key of the azure account.
-## **It's only used when the storage type is `Azblob`**.
-## +toml2docs:none-default
-account_name = "test"
-
-## The account key of the azure account.
-## **It's only used when the storage type is `Azblob`**.
-## +toml2docs:none-default
-account_key = "test"
-
-## The scope of the google cloud storage.
-## **It's only used when the storage type is `Gcs`**.
-## +toml2docs:none-default
-scope = "test"
-
-## The credential path of the google cloud storage.
-## **It's only used when the storage type is `Gcs`**.
-## +toml2docs:none-default
-credential_path = "test"
-
-## The container of the azure account.
-## **It's only used when the storage type is `Azblob`**.
-## +toml2docs:none-default
-container = "greptimedb"
-
-## The sas token of the azure account.
-## **It's only used when the storage type is `Azblob`**.
-## +toml2docs:none-default
-sas_token = ""
-
-## The endpoint of the S3 service.
-## **It's only used when the storage type is `S3`, `Oss`, `Gcs` and `Azblob`**.
-## +toml2docs:none-default
-endpoint = "https://s3.amazonaws.com"
-
-## The region of the S3 service.
-## **It's only used when the storage type is `S3`, `Oss`, `Gcs` and `Azblob`**.
-## +toml2docs:none-default
-region = "us-west-2"
-
-# Custom storage options
-# [[storage.providers]]
-# type = "S3"
-# [[storage.providers]]
-# type = "Gcs"
-
-## The region engine options. You can configure multiple region engines.
-[[region_engine]]
-
-## The Mito engine options.
-[region_engine.mito]
-
-## Number of region workers.
-num_workers = 8
-
-## Request channel size of each worker.
-worker_channel_size = 128
-
-## Max batch size for a worker to handle requests.
-worker_request_batch_size = 64
-
-## Number of meta action updated to trigger a new checkpoint for the manifest.
-manifest_checkpoint_distance = 10
-
-## Whether to compress manifest and checkpoint file by gzip (default false).
-compress_manifest = false
-
-## Max number of running background jobs
-max_background_jobs = 4
-
-## Interval to auto flush a region if it has not flushed yet.
-auto_flush_interval = "1h"
-
-## Global write buffer size for all regions. If not set, it's default to 1/8 of OS memory with a max limitation of 1GB.
-global_write_buffer_size = "1GB"
-
-## Global write buffer size threshold to reject write requests. If not set, it's default to 2 times of `global_write_buffer_size`
-global_write_buffer_reject_size = "2GB"
-
-## Cache size for SST metadata. Setting it to 0 to disable the cache.
-## If not set, it's default to 1/32 of OS memory with a max limitation of 128MB.
-sst_meta_cache_size = "128MB"
-
-## Cache size for vectors and arrow arrays. Setting it to 0 to disable the cache.
-## If not set, it's default to 1/16 of OS memory with a max limitation of 512MB.
-vector_cache_size = "512MB"
-
-## Cache size for pages of SST row groups. Setting it to 0 to disable the cache.
-## If not set, it's default to 1/16 of OS memory with a max limitation of 512MB.
-page_cache_size = "512MB"
-
-## Buffer size for SST writing.
-sst_write_buffer_size = "8MB"
-
-## Parallelism to scan a region (default: 1/4 of cpu cores).
-## - `0`: using the default value (1/4 of cpu cores).
-## - `1`: scan in current thread.
-## - `n`: scan in parallelism n.
-scan_parallelism = 0
-
-## Capacity of the channel to send data from parallel scan tasks to the main task.
-parallel_scan_channel_size = 32
-
-## Whether to allow stale WAL entries read during replay.
-allow_stale_entries = false
-
-## The options for inverted index in Mito engine.
-[region_engine.mito.inverted_index]
-
-## Whether to create the index on flush.
-## - `auto`: automatically
-## - `disable`: never
-create_on_flush = "auto"
-
-## Whether to create the index on compaction.
-## - `auto`: automatically
-## - `disable`: never
-create_on_compaction = "auto"
-
-## Whether to apply the index on query
-## - `auto`: automatically
-## - `disable`: never
-apply_on_query = "auto"
-
-## Memory threshold for performing an external sort during index creation.
-## Setting to empty will disable external sorting, forcing all sorting operations to happen in memory.
-mem_threshold_on_create = "64M"
-
-## File system path to store intermediate files for external sorting (default `{data_home}/index_intermediate`).
-intermediate_path = ""
-
-[region_engine.mito.memtable]
-## Memtable type.
-## - `time_series`: time-series memtable
-## - `partition_tree`: partition tree memtable (experimental)
-type = "time_series"
-
-## The max number of keys in one shard.
-## Only available for `partition_tree` memtable.
-index_max_keys_per_shard = 8192
-
-## The max rows of data inside the actively writing buffer in one shard.
-## Only available for `partition_tree` memtable.
-data_freeze_threshold = 32768
-
-## Max dictionary bytes.
-## Only available for `partition_tree` memtable.
-fork_dictionary_bytes = "1GiB"
-
-## The logging options.
-[logging]
-## The directory to store the log files.
-dir = "/tmp/greptimedb/logs"
-
-## The log level. Can be `info`/`debug`/`warn`/`error`.
-## +toml2docs:none-default
-level = "info"
-
-## Enable OTLP tracing.
-enable_otlp_tracing = false
-
-## The OTLP tracing endpoint.
-## +toml2docs:none-default
-otlp_endpoint = ""
-
-## Whether to append logs to stdout.
-append_stdout = true
-
-## The percentage of tracing will be sampled and exported.
-## Valid range `[0, 1]`, 1 means all traces are sampled, 0 means all traces are not sampled, the default value is 1.
-## ratio > 1 are treated as 1. Fractions < 0 are treated as 0
-[logging.tracing_sample_ratio]
-default_ratio = 1.0
-
-## The datanode can export its metrics and send to Prometheus compatible service (e.g. send to `greptimedb` itself) from remote-write API.
-## This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape.
-[export_metrics]
-
-## whether enable export metrics.
-enable = false
-
-## The interval of export metrics.
-write_interval = "30s"
-
-## For `standalone` mode, `self_import` is recommend to collect metrics generated by itself
-[export_metrics.self_import]
-## +toml2docs:none-default
-db = "information_schema"
-
-[export_metrics.remote_write]
-## The url the metrics send to. The url example can be: `http://127.0.0.1:4000/v1/prometheus/write?db=information_schema`.
-url = ""
-
-## HTTP headers of Prometheus remote-write carry.
-headers = { }
+[meta_client_opts]
+metasrv_addrs = ['127.0.0.1:3002']
+timeout_millis = 3000
+connect_timeout_millis = 5000
+tcp_nodelay = false

config/frontend.example.toml

@@ -1,192 +1,12 @@
-## The running mode of the datanode. It can be `standalone` or `distributed`.
-mode = "standalone"
+mode = 'distributed'
+datanode_rpc_addr = '127.0.0.1:3001'
 
-## The default timezone of the server.
-## +toml2docs:none-default
-default_timezone = "UTC"
-
-## The heartbeat options.
-[heartbeat]
-## Interval for sending heartbeat messages to the metasrv.
-interval = "18s"
-
-## Interval for retrying to send heartbeat messages to the metasrv.
-retry_interval = "3s"
-
-## The HTTP server options.
-[http]
-## The address to bind the HTTP server.
-addr = "127.0.0.1:4000"
-## HTTP request timeout.
+[http_options]
+addr = '127.0.0.1:4000'
 timeout = "30s"
-## HTTP request body limit.
-## Support the following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.
-body_limit = "64MB"
 
-## The gRPC server options.
-[grpc]
-## The address to bind the gRPC server.
-addr = "127.0.0.1:4001"
-## The number of server worker threads.
-runtime_size = 8
-
-## MySQL server options.
-[mysql]
-## Whether to enable.
-enable = true
-## The addr to bind the MySQL server.
-addr = "127.0.0.1:4002"
-## The number of server worker threads.
-runtime_size = 2
-
-# MySQL server TLS options.
-[mysql.tls]
-
-## TLS mode, refer to https://www.postgresql.org/docs/current/libpq-ssl.html
-## - `disable` (default value)
-## - `prefer`
-## - `require`
-## - `verify-ca`
-## - `verify-full`
-mode = "disable"
-
-## Certificate file path.
-## +toml2docs:none-default
-cert_path = ""
-
-## Private key file path.
-## +toml2docs:none-default
-key_path = ""
-
-## Watch for Certificate and key file change and auto reload
-watch = false
-
-## PostgresSQL server options.
-[postgres]
-## Whether to enable
-enable = true
-## The addr to bind the PostgresSQL server.
-addr = "127.0.0.1:4003"
-## The number of server worker threads.
-runtime_size = 2
-
-## PostgresSQL server TLS options, see `mysql_options.tls` section.
-[postgres.tls]
-## TLS mode.
-mode = "disable"
-
-## Certificate file path.
-## +toml2docs:none-default
-cert_path = ""
-
-## Private key file path.
-## +toml2docs:none-default
-key_path = ""
-
-## Watch for Certificate and key file change and auto reload
-watch = false
-
-## OpenTSDB protocol options.
-[opentsdb]
-## Whether to enable
-enable = true
-## OpenTSDB telnet API server address.
-addr = "127.0.0.1:4242"
-## The number of server worker threads.
-runtime_size = 2
-
-## InfluxDB protocol options.
-[influxdb]
-## Whether to enable InfluxDB protocol in HTTP API.
-enable = true
-
-## Prometheus remote storage options
-[prom_store]
-## Whether to enable Prometheus remote write and read in HTTP API.
-enable = true
-## Whether to store the data from Prometheus remote write in metric engine.
-with_metric_engine = true
-
-## The metasrv client options.
-[meta_client]
-## The addresses of the metasrv.
-metasrv_addrs = ["127.0.0.1:3002"]
-
-## Operation timeout.
-timeout = "3s"
-
-## Heartbeat timeout.
-heartbeat_timeout = "500ms"
-
-## DDL timeout.
-ddl_timeout = "10s"
-
-## Connect server timeout.
-connect_timeout = "1s"
-
-## `TCP_NODELAY` option for accepted connections.
-tcp_nodelay = true
-
-## The configuration about the cache of the metadata.
-metadata_cache_max_capacity = 100000
-
-## TTL of the metadata cache.
-metadata_cache_ttl = "10m"
-
-# TTI of the metadata cache.
-metadata_cache_tti = "5m"
-
-## Datanode options.
-[datanode]
-## Datanode client options.
-[datanode.client]
-timeout = "10s"
-connect_timeout = "10s"
-tcp_nodelay = true
-
-## The logging options.
-[logging]
-## The directory to store the log files.
-dir = "/tmp/greptimedb/logs"
-
-## The log level. Can be `info`/`debug`/`warn`/`error`.
-## +toml2docs:none-default
-level = "info"
-
-## Enable OTLP tracing.
-enable_otlp_tracing = false
-
-## The OTLP tracing endpoint.
-## +toml2docs:none-default
-otlp_endpoint = ""
-
-## Whether to append logs to stdout.
-append_stdout = true
-
-## The percentage of tracing will be sampled and exported.
-## Valid range `[0, 1]`, 1 means all traces are sampled, 0 means all traces are not sampled, the default value is 1.
-## ratio > 1 are treated as 1. Fractions < 0 are treated as 0
-[logging.tracing_sample_ratio]
-default_ratio = 1.0
-
-## The datanode can export its metrics and send to Prometheus compatible service (e.g. send to `greptimedb` itself) from remote-write API.
-## This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape.
-[export_metrics]
-
-## whether enable export metrics.
-enable = false
-
-## The interval of export metrics.
-write_interval = "30s"
-
-## For `standalone` mode, `self_import` is recommend to collect metrics generated by itself
-[export_metrics.self_import]
-## +toml2docs:none-default
-db = "information_schema"
-
-[export_metrics.remote_write]
-## The url the metrics send to. The url example can be: `http://127.0.0.1:4000/v1/prometheus/write?db=information_schema`.
-url = ""
-
-## HTTP headers of Prometheus remote-write carry.
-headers = { }
+[meta_client_opts]
+metasrv_addrs = ['127.0.0.1:3002']
+timeout_millis = 3000
+connect_timeout_millis = 5000
+tcp_nodelay = false

config/metasrv.example.toml

@@ -1,143 +1,4 @@
-## The working home directory.
-data_home = "/tmp/metasrv/"
-
-## The bind address of metasrv.
-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.
-server_addr = "127.0.0.1:3002"
-
-## Etcd server address.
-store_addr = "127.0.0.1:2379"
-
-## Datanode selector type.
-## - `lease_based` (default value).
-## - `load_based`
-## For details, please see "https://docs.greptime.com/developer-guide/metasrv/selector".
-selector = "lease_based"
-
-## Store data in memory.
-use_memory_store = false
-
-## Whether to enable greptimedb telemetry.
-enable_telemetry = true
-
-## If it's not empty, the metasrv will store all data with this key prefix.
-store_key_prefix = ""
-
-## Procedure storage options.
-[procedure]
-
-## Procedure max retry time.
-max_retry_times = 12
-
-## Initial retry delay of procedures, increases exponentially
-retry_delay = "500ms"
-
-## Auto split large value
-## GreptimeDB procedure uses etcd as the default metadata storage backend.
-## The etcd the maximum size of any request is 1.5 MiB
-## 1500KiB = 1536KiB (1.5MiB) - 36KiB (reserved size of key)
-## Comments out the `max_metadata_value_size`, for don't split large value (no limit).
-max_metadata_value_size = "1500KiB"
-
-# Failure detectors options.
-[failure_detector]
-threshold = 8.0
-min_std_deviation = "100ms"
-acceptable_heartbeat_pause = "3000ms"
-first_heartbeat_estimate = "1000ms"
-
-## Datanode options.
-[datanode]
-## Datanode client options.
-[datanode.client]
-timeout = "10s"
-connect_timeout = "10s"
-tcp_nodelay = true
-
-[wal]
-# Available wal providers:
-# - `raft_engine` (default): there're none raft-engine wal config since metasrv only involves in remote wal currently.
-# - `kafka`: metasrv **have to be** configured with kafka wal config when using kafka wal provider in datanode.
-provider = "raft_engine"
-
-# Kafka wal config.
-
-## The broker endpoints of the Kafka cluster.
-broker_endpoints = ["127.0.0.1:9092"]
-
-## Number of topics to be created upon start.
-num_topics = 64
-
-## Topic selector type.
-## Available selector types:
-## - `round_robin` (default)
-selector_type = "round_robin"
-
-## A Kafka topic is constructed by concatenating `topic_name_prefix` and `topic_id`.
-topic_name_prefix = "greptimedb_wal_topic"
-
-## Expected number of replicas of each partition.
-replication_factor = 1
-
-## Above which a topic creation operation will be cancelled.
-create_topic_timeout = "30s"
-## The initial backoff for kafka clients.
-backoff_init = "500ms"
-
-## The maximum backoff for kafka clients.
-backoff_max = "10s"
-
-## Exponential backoff rate, i.e. next backoff = base * current backoff.
-backoff_base = 2
-
-## Stop reconnecting if the total wait time reaches the deadline. If this config is missing, the reconnecting won't terminate.
-backoff_deadline = "5mins"
-
-## The logging options.
-[logging]
-## The directory to store the log files.
-dir = "/tmp/greptimedb/logs"
-
-## The log level. Can be `info`/`debug`/`warn`/`error`.
-## +toml2docs:none-default
-level = "info"
-
-## Enable OTLP tracing.
-enable_otlp_tracing = false
-
-## The OTLP tracing endpoint.
-## +toml2docs:none-default
-otlp_endpoint = ""
-
-## Whether to append logs to stdout.
-append_stdout = true
-
-## The percentage of tracing will be sampled and exported.
-## Valid range `[0, 1]`, 1 means all traces are sampled, 0 means all traces are not sampled, the default value is 1.
-## ratio > 1 are treated as 1. Fractions < 0 are treated as 0
-[logging.tracing_sample_ratio]
-default_ratio = 1.0
-
-## The datanode can export its metrics and send to Prometheus compatible service (e.g. send to `greptimedb` itself) from remote-write API.
-## This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape.
-[export_metrics]
-
-## whether enable export metrics.
-enable = false
-
-## The interval of export metrics.
-write_interval = "30s"
-
-## For `standalone` mode, `self_import` is recommend to collect metrics generated by itself
-[export_metrics.self_import]
-## +toml2docs:none-default
-db = "information_schema"
-
-[export_metrics.remote_write]
-## The url the metrics send to. The url example can be: `http://127.0.0.1:4000/v1/prometheus/write?db=information_schema`.
-url = ""
-
-## HTTP headers of Prometheus remote-write carry.
-headers = { }
+bind_addr = '127.0.0.1:3002'
+server_addr = '127.0.0.1:3002'
+store_addr = '127.0.0.1:2379'
+datanode_lease_secs = 15

config/standalone.example.toml

@@ -1,477 +1,36 @@
-## The running mode of the datanode. It can be `standalone` or `distributed`.
-mode = "standalone"
+node_id = 0
+mode = 'standalone'
+wal_dir = '/tmp/greptimedb/wal/'
+enable_memory_catalog = false
 
-## Enable telemetry to collect anonymous usage data.
-enable_telemetry = true
-
-## The default timezone of the server.
-## +toml2docs:none-default
-default_timezone = "UTC"
-
-## The HTTP server options.
-[http]
-## The address to bind the HTTP server.
-addr = "127.0.0.1:4000"
-## HTTP request timeout.
+[http_options]
+addr = '127.0.0.1:4000'
 timeout = "30s"
-## HTTP request body limit.
-## Support the following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.
-body_limit = "64MB"
 
-## The gRPC server options.
-[grpc]
-## The address to bind the gRPC server.
-addr = "127.0.0.1:4001"
-## The number of server worker threads.
+[storage]
+type = 'File'
+data_dir = '/tmp/greptimedb/data/'
+
+[grpc_options]
+addr = '127.0.0.1:4001'
 runtime_size = 8
 
-## MySQL server options.
-[mysql]
-## Whether to enable.
-enable = true
-## The addr to bind the MySQL server.
-addr = "127.0.0.1:4002"
-## The number of server worker threads.
+[mysql_options]
+addr = '127.0.0.1:4002'
 runtime_size = 2
 
-# MySQL server TLS options.
-[mysql.tls]
-
-## TLS mode, refer to https://www.postgresql.org/docs/current/libpq-ssl.html
-## - `disable` (default value)
-## - `prefer`
-## - `require`
-## - `verify-ca`
-## - `verify-full`
-mode = "disable"
-
-## Certificate file path.
-## +toml2docs:none-default
-cert_path = ""
-
-## Private key file path.
-## +toml2docs:none-default
-key_path = ""
-
-## Watch for Certificate and key file change and auto reload
-watch = false
-
-## PostgresSQL server options.
-[postgres]
-## Whether to enable
+[influxdb_options]
+enable = true
+
+[opentsdb_options]
+addr = '127.0.0.1:4242'
 enable = true
-## The addr to bind the PostgresSQL server.
-addr = "127.0.0.1:4003"
-## The number of server worker threads.
 runtime_size = 2
 
-## PostgresSQL server TLS options, see `mysql_options.tls` section.
-[postgres.tls]
-## TLS mode.
-mode = "disable"
-
-## Certificate file path.
-## +toml2docs:none-default
-cert_path = ""
-
-## Private key file path.
-## +toml2docs:none-default
-key_path = ""
-
-## Watch for Certificate and key file change and auto reload
-watch = false
-
-## OpenTSDB protocol options.
-[opentsdb]
-## Whether to enable
+[prometheus_options]
 enable = true
-## OpenTSDB telnet API server address.
-addr = "127.0.0.1:4242"
-## The number of server worker threads.
+
+[postgres_options]
+addr = '127.0.0.1:4003'
 runtime_size = 2
-
-## InfluxDB protocol options.
-[influxdb]
-## Whether to enable InfluxDB protocol in HTTP API.
-enable = true
-
-## Prometheus remote storage options
-[prom_store]
-## Whether to enable Prometheus remote write and read in HTTP API.
-enable = true
-## Whether to store the data from Prometheus remote write in metric engine.
-with_metric_engine = true
-
-## The WAL options.
-[wal]
-## The provider of the WAL.
-## - `raft_engine`: the wal is stored in the local file system by raft-engine.
-## - `kafka`: it's remote wal that data is stored in Kafka.
-provider = "raft_engine"
-
-## The directory to store the WAL files.
-## **It's only used when the provider is `raft_engine`**.
-## +toml2docs:none-default
-dir = "/tmp/greptimedb/wal"
-
-## The size of the WAL segment file.
-## **It's only used when the provider is `raft_engine`**.
-file_size = "256MB"
-
-## The threshold of the WAL size to trigger a flush.
-## **It's only used when the provider is `raft_engine`**.
-purge_threshold = "4GB"
-
-## The interval to trigger a flush.
-## **It's only used when the provider is `raft_engine`**.
-purge_interval = "10m"
-
-## The read batch size.
-## **It's only used when the provider is `raft_engine`**.
-read_batch_size = 128
-
-## Whether to use sync write.
-## **It's only used when the provider is `raft_engine`**.
-sync_write = false
-
-## Whether to reuse logically truncated log files.
-## **It's only used when the provider is `raft_engine`**.
-enable_log_recycle = true
-
-## Whether to pre-create log files on start up.
-## **It's only used when the provider is `raft_engine`**.
-prefill_log_files = false
-
-## Duration for fsyncing log files.
-## **It's only used when the provider is `raft_engine`**.
-sync_period = "10s"
-
-## The Kafka broker endpoints.
-## **It's only used when the provider is `kafka`**.
-broker_endpoints = ["127.0.0.1:9092"]
-
-## The max size of a single producer batch.
-## Warning: Kafka has a default limit of 1MB per message in a topic.
-## **It's only used when the provider is `kafka`**.
-max_batch_size = "1MB"
-
-## The linger duration of a kafka batch producer.
-## **It's only used when the provider is `kafka`**.
-linger = "200ms"
-
-## The consumer wait timeout.
-## **It's only used when the provider is `kafka`**.
-consumer_wait_timeout = "100ms"
-
-## The initial backoff delay.
-## **It's only used when the provider is `kafka`**.
-backoff_init = "500ms"
-
-## The maximum backoff delay.
-## **It's only used when the provider is `kafka`**.
-backoff_max = "10s"
-
-## The exponential backoff rate, i.e. next backoff = base * current backoff.
-## **It's only used when the provider is `kafka`**.
-backoff_base = 2
-
-## The deadline of retries.
-## **It's only used when the provider is `kafka`**.
-backoff_deadline = "5mins"
-
-## Metadata storage options.
-[metadata_store]
-## Kv file size in bytes.
-file_size = "256MB"
-## Kv purge threshold.
-purge_threshold = "4GB"
-
-## Procedure storage options.
-[procedure]
-## Procedure max retry time.
-max_retry_times = 3
-## Initial retry delay of procedures, increases exponentially
-retry_delay = "500ms"
-
-# Example of using S3 as the storage.
-# [storage]
-# type = "S3"
-# bucket = "greptimedb"
-# root = "data"
-# access_key_id = "test"
-# secret_access_key = "123456"
-# endpoint = "https://s3.amazonaws.com"
-# region = "us-west-2"
-
-# Example of using Oss as the storage.
-# [storage]
-# type = "Oss"
-# bucket = "greptimedb"
-# root = "data"
-# access_key_id = "test"
-# access_key_secret = "123456"
-# endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
-
-# Example of using Azblob as the storage.
-# [storage]
-# type = "Azblob"
-# container = "greptimedb"
-# root = "data"
-# account_name = "test"
-# account_key = "123456"
-# endpoint = "https://greptimedb.blob.core.windows.net"
-# sas_token = ""
-
-# Example of using Gcs as the storage.
-# [storage]
-# type = "Gcs"
-# bucket = "greptimedb"
-# root = "data"
-# scope = "test"
-# credential_path = "123456"
-# endpoint = "https://storage.googleapis.com"
-
-## The data storage options.
-[storage]
-## The working home directory.
-data_home = "/tmp/greptimedb/"
-
-## The storage type used to store the data.
-## - `File`: the data is stored in the local file system.
-## - `S3`: the data is stored in the S3 object storage.
-## - `Gcs`: the data is stored in the Google Cloud Storage.
-## - `Azblob`: the data is stored in the Azure Blob Storage.
-## - `Oss`: the data is stored in the Aliyun OSS.
-type = "File"
-
-## Cache configuration for object storage such as 'S3' etc.
-## The local file cache directory.
-## +toml2docs:none-default
-cache_path = "/path/local_cache"
-
-## The local file cache capacity in bytes.
-## +toml2docs:none-default
-cache_capacity = "256MB"
-
-## The S3 bucket name.
-## **It's only used when the storage type is `S3`, `Oss` and `Gcs`**.
-## +toml2docs:none-default
-bucket = "greptimedb"
-
-## The S3 data will be stored in the specified prefix, for example, `s3://${bucket}/${root}`.
-## **It's only used when the storage type is `S3`, `Oss` and `Azblob`**.
-## +toml2docs:none-default
-root = "greptimedb"
-
-## The access key id of the aws account.
-## It's **highly recommended** to use AWS IAM roles instead of hardcoding the access key id and secret key.
-## **It's only used when the storage type is `S3` and `Oss`**.
-## +toml2docs:none-default
-access_key_id = "test"
-
-## The secret access key of the aws account.
-## It's **highly recommended** to use AWS IAM roles instead of hardcoding the access key id and secret key.
-## **It's only used when the storage type is `S3`**.
-## +toml2docs:none-default
-secret_access_key = "test"
-
-## The secret access key of the aliyun account.
-## **It's only used when the storage type is `Oss`**.
-## +toml2docs:none-default
-access_key_secret = "test"
-
-## The account key of the azure account.
-## **It's only used when the storage type is `Azblob`**.
-## +toml2docs:none-default
-account_name = "test"
-
-## The account key of the azure account.
-## **It's only used when the storage type is `Azblob`**.
-## +toml2docs:none-default
-account_key = "test"
-
-## The scope of the google cloud storage.
-## **It's only used when the storage type is `Gcs`**.
-## +toml2docs:none-default
-scope = "test"
-
-## The credential path of the google cloud storage.
-## **It's only used when the storage type is `Gcs`**.
-## +toml2docs:none-default
-credential_path = "test"
-
-## The container of the azure account.
-## **It's only used when the storage type is `Azblob`**.
-## +toml2docs:none-default
-container = "greptimedb"
-
-## The sas token of the azure account.
-## **It's only used when the storage type is `Azblob`**.
-## +toml2docs:none-default
-sas_token = ""
-
-## The endpoint of the S3 service.
-## **It's only used when the storage type is `S3`, `Oss`, `Gcs` and `Azblob`**.
-## +toml2docs:none-default
-endpoint = "https://s3.amazonaws.com"
-
-## The region of the S3 service.
-## **It's only used when the storage type is `S3`, `Oss`, `Gcs` and `Azblob`**.
-## +toml2docs:none-default
-region = "us-west-2"
-
-# Custom storage options
-# [[storage.providers]]
-# type = "S3"
-# [[storage.providers]]
-# type = "Gcs"
-
-## The region engine options. You can configure multiple region engines.
-[[region_engine]]
-
-## The Mito engine options.
-[region_engine.mito]
-
-## Number of region workers.
-num_workers = 8
-
-## Request channel size of each worker.
-worker_channel_size = 128
-
-## Max batch size for a worker to handle requests.
-worker_request_batch_size = 64
-
-## Number of meta action updated to trigger a new checkpoint for the manifest.
-manifest_checkpoint_distance = 10
-
-## Whether to compress manifest and checkpoint file by gzip (default false).
-compress_manifest = false
-
-## Max number of running background jobs
-max_background_jobs = 4
-
-## Interval to auto flush a region if it has not flushed yet.
-auto_flush_interval = "1h"
-
-## Global write buffer size for all regions. If not set, it's default to 1/8 of OS memory with a max limitation of 1GB.
-global_write_buffer_size = "1GB"
-
-## Global write buffer size threshold to reject write requests. If not set, it's default to 2 times of `global_write_buffer_size`
-global_write_buffer_reject_size = "2GB"
-
-## Cache size for SST metadata. Setting it to 0 to disable the cache.
-## If not set, it's default to 1/32 of OS memory with a max limitation of 128MB.
-sst_meta_cache_size = "128MB"
-
-## Cache size for vectors and arrow arrays. Setting it to 0 to disable the cache.
-## If not set, it's default to 1/16 of OS memory with a max limitation of 512MB.
-vector_cache_size = "512MB"
-
-## Cache size for pages of SST row groups. Setting it to 0 to disable the cache.
-## If not set, it's default to 1/16 of OS memory with a max limitation of 512MB.
-page_cache_size = "512MB"
-
-## Buffer size for SST writing.
-sst_write_buffer_size = "8MB"
-
-## Parallelism to scan a region (default: 1/4 of cpu cores).
-## - `0`: using the default value (1/4 of cpu cores).
-## - `1`: scan in current thread.
-## - `n`: scan in parallelism n.
-scan_parallelism = 0
-
-## Capacity of the channel to send data from parallel scan tasks to the main task.
-parallel_scan_channel_size = 32
-
-## Whether to allow stale WAL entries read during replay.
-allow_stale_entries = false
-
-## The options for inverted index in Mito engine.
-[region_engine.mito.inverted_index]
-
-## Whether to create the index on flush.
-## - `auto`: automatically
-## - `disable`: never
-create_on_flush = "auto"
-
-## Whether to create the index on compaction.
-## - `auto`: automatically
-## - `disable`: never
-create_on_compaction = "auto"
-
-## Whether to apply the index on query
-## - `auto`: automatically
-## - `disable`: never
-apply_on_query = "auto"
-
-## Memory threshold for performing an external sort during index creation.
-## Setting to empty will disable external sorting, forcing all sorting operations to happen in memory.
-mem_threshold_on_create = "64M"
-
-## File system path to store intermediate files for external sorting (default `{data_home}/index_intermediate`).
-intermediate_path = ""
-
-[region_engine.mito.memtable]
-## Memtable type.
-## - `time_series`: time-series memtable
-## - `partition_tree`: partition tree memtable (experimental)
-type = "time_series"
-
-## The max number of keys in one shard.
-## Only available for `partition_tree` memtable.
-index_max_keys_per_shard = 8192
-
-## The max rows of data inside the actively writing buffer in one shard.
-## Only available for `partition_tree` memtable.
-data_freeze_threshold = 32768
-
-## Max dictionary bytes.
-## Only available for `partition_tree` memtable.
-fork_dictionary_bytes = "1GiB"
-
-## The logging options.
-[logging]
-## The directory to store the log files.
-dir = "/tmp/greptimedb/logs"
-
-## The log level. Can be `info`/`debug`/`warn`/`error`.
-## +toml2docs:none-default
-level = "info"
-
-## Enable OTLP tracing.
-enable_otlp_tracing = false
-
-## The OTLP tracing endpoint.
-## +toml2docs:none-default
-otlp_endpoint = ""
-
-## Whether to append logs to stdout.
-append_stdout = true
-
-## The percentage of tracing will be sampled and exported.
-## Valid range `[0, 1]`, 1 means all traces are sampled, 0 means all traces are not sampled, the default value is 1.
-## ratio > 1 are treated as 1. Fractions < 0 are treated as 0
-[logging.tracing_sample_ratio]
-default_ratio = 1.0
-
-## The datanode can export its metrics and send to Prometheus compatible service (e.g. send to `greptimedb` itself) from remote-write API.
-## This is only used for `greptimedb` to export its own metrics internally. It's different from prometheus scrape.
-[export_metrics]
-
-## whether enable export metrics.
-enable = false
-
-## The interval of export metrics.
-write_interval = "30s"
-
-## For `standalone` mode, `self_import` is recommend to collect metrics generated by itself
-[export_metrics.self_import]
-## +toml2docs:none-default
-db = "information_schema"
-
-[export_metrics.remote_write]
-## The url the metrics send to. The url example can be: `http://127.0.0.1:4000/v1/prometheus/write?db=information_schema`.
-url = ""
-
-## HTTP headers of Prometheus remote-write carry.
-headers = { }
+check_pwd = false

docker/Dockerfile

@@ -0,0 +1,31 @@
+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
+
+# 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
+
+WORKDIR /greptime
+COPY --from=builder /greptimedb/target/release/greptime /greptime/bin/
+ENV PATH /greptime/bin/:$PATH
+
+ENTRYPOINT ["greptime"]

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

@@ -0,0 +1,9 @@
+FROM ubuntu:22.04
+
+ARG TARGETARCH
+
+ADD $TARGETARCH/greptime /greptime/bin/
+
+ENV PATH /greptime/bin/:$PATH
+
+ENTRYPOINT ["greptime"]

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/ci/ubuntu/Dockerfile

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

docker/dev-builder/android/Dockerfile

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

docker/dev-builder/centos/Dockerfile

@@ -1,30 +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-binstall --locked
-RUN cargo binstall cargo-nextest --no-confirm

docker/dev-builder/ubuntu/Dockerfile

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

docker/dev-builder/ubuntu/Dockerfile-18.10

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

docker/python/requirements.txt

@@ -1,5 +0,0 @@
-numpy>=1.24.2
-pandas>=1.5.3
-pyarrow>=11.0.0
-requests>=2.28.2
-scipy>=1.10.1

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/benchmarks/tsbs/v0.4.0.md

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

docs/benchmarks/tsbs/v0.7.0.md

@@ -1,50 +0,0 @@
-# TSBS benchmark - v0.7.0
-
-## Environment
-
-### Local
-|        |                                    |
-| ------ | ---------------------------------- |
-| CPU    | AMD Ryzen 7 7735HS (8 core 3.2GHz) |
-| Memory | 32GB                               |
-| Disk   | SOLIDIGM SSDPFKNU010TZ             |
-| OS     | Ubuntu 22.04.2 LTS                 |
-
-### Amazon EC2
-
-|         |                |
-| ------- | -------------- |
-| Machine | c5d.2xlarge    |
-| CPU     | 8 core         |
-| Memory  | 16GB           |
-| Disk    | 50GB (GP3)     |
-| OS      | Ubuntu 22.04.1 |
-
-
-## Write performance
-
-| Environment        | Ingest rate (rows/s)  |
-| ------------------ | --------------------- |
-| Local              | 3695814.64            |
-| EC2 c5d.2xlarge    | 2987166.64            |
-
-
-## Query performance
-
-| Query type            | Local (ms) | EC2 c5d.2xlarge (ms)   |
-| --------------------- | ---------- | ---------------------- |
-| cpu-max-all-1         | 30.56      | 54.74                  |
-| cpu-max-all-8         | 52.69      | 70.50                  |
-| double-groupby-1      | 664.30     | 1366.63                |
-| double-groupby-5      | 1391.26    | 2141.71                |
-| double-groupby-all    | 2828.94    | 3389.59                |
-| groupby-orderby-limit | 718.92     | 1213.90                |
-| high-cpu-1            | 29.21      | 52.98                  |
-| high-cpu-all          | 5514.12    | 7194.91                |
-| lastpoint             | 7571.40    | 9423.41                |
-| single-groupby-1-1-1  | 19.09      | 7.77                   |
-| single-groupby-1-1-12 | 27.28      | 51.64                  |
-| single-groupby-1-8-1  | 31.85      | 11.64                  |
-| single-groupby-5-1-1  | 16.14      | 9.67                   |
-| single-groupby-5-1-12 | 27.21      | 53.62                  |
-| single-groupby-5-8-1  | 39.62      | 14.96                  |

docs/how-to/how-to-implement-sql-statement.md

@@ -1,74 +0,0 @@
-This document introduces how to implement SQL statements in GreptimeDB.
-
-The execution entry point for SQL statements locates at Frontend Instance. You can see it has
-implemented `SqlQueryHandler`:
-
-```rust
-impl SqlQueryHandler for Instance {
-    type Error = Error;
-
-    async fn do_query(&self, query: &str, query_ctx: QueryContextRef) -> Vec<Result<Output>> {
-        // ...
-    }
-}
-```
-
-Normally, when a SQL query arrives at GreptimeDB, the `do_query` method will be called. After some parsing work, the SQL
-will be feed into `StatementExecutor`:
-
-```rust
-// in Frontend Instance:
-self.statement_executor.execute_sql(stmt, query_ctx).await
-```
-
-That's where we handle our SQL statements. You can just create a new match arm for your statement there, then the
-statement is implemented for both GreptimeDB Standalone and Cluster. You can see how `DESCRIBE TABLE` is implemented as
-an example.
-
-Now, what if the statements should be handled differently for GreptimeDB Standalone and Cluster? You can see there's
-a `SqlStatementExecutor` field in `StatementExecutor`. Each GreptimeDB Standalone and Cluster has its own implementation
-of `SqlStatementExecutor`. If you are going to implement the statements differently in the two mode (
-like `CREATE TABLE`), you have to implement them in their own `SqlStatementExecutor`s.
-
-Summarize as the diagram below:
-
-```text
-                             SQL query                            
-                                |                                
-                                v                                
-                  +---------------------------+                  
-                  | SqlQueryHandler::do_query |                  
-                  +---------------------------+                  
-                                |                                
-                                | SQL parsing                    
-                                v                                
-               +--------------------------------+                
-               | StatementExecutor::execute_sql |                
-               +--------------------------------+                
-                                |                                
-                                | SQL execution                    
-                                v                                
-               +----------------------------------+                
-               | commonly handled statements like |
-               | "plan_exec" for selection or     |
-               +----------------------------------+                
-                       |                |                        
-        For Standalone |                | For Cluster          
-                       v                v                        
-+---------------------------+      +---------------------------+ 
-| SqlStatementExecutor impl |      | SqlStatementExecutor impl | 
-| in Datanode Instance      |      | in Frontend DistInstance  | 
-+---------------------------+      +---------------------------+ 
-```
-
-Note that some SQL statements can be executed in our QueryEngine, in the form of `LogicalPlan`. You can follow the
-invocation path down to the `QueryEngine` implementation from `StatementExecutor::plan_exec`. For now, there's only
-one `DatafusionQueryEngine` for both GreptimeDB Standalone and Cluster. That lone query engine works for both modes is
-because GreptimeDB read/write data through `Table` trait, and each mode has its own `Table` implementation.
-
-We don't have any bias towards whether statements should be handled in query engine or `StatementExecutor`. You can
-implement one kind of statement in both places. For example, `Insert` with selection is handled in query engine, because
-we can easily do the query part there. However, `Insert` without selection is not, for the cost of parsing statement
-to `LogicalPlan` is not neglectable. So generally if the SQL query is simple enough, you can handle it
-in `StatementExecutor`; otherwise if it is complex or has some part of selection, it should be parsed to `LogicalPlan`
-and handled in query engine.  

docs/rfcs/2022-12-20-promql-in-rust/rfc.md

@@ -1,175 +0,0 @@
----
-Feature Name: "promql-in-rust"
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/596
-Date: 2022-12-20
-Author: "Ruihang Xia <waynestxia@gmail.com>"
----
-
-Rewrite PromQL in Rust
-----------------------
-
-# Summary
-A Rust native implementation of PromQL, for GreptimeDB.
-
-# Motivation
-Prometheus and its query language PromQL prevails in the cloud-native observability area, which is an important scenario for time series database like GreptimeDB. We already have support for its remote read and write protocols. Users can now integrate GreptimeDB as the storage backend to existing Prometheus deployment, but cannot run PromQL query directly on GreptimeDB like SQL.
-
-This RFC proposes to add support for PromQL. Because it was created in Go, we can't use the existing code easily. For interoperability, performance and extendability, porting its logic to Rust is a good choice.
-
-# Details
-
-## Overview
-One of the goals is to make use of our existing basic operators, execution model and runtime to reduce the work. So the entire proposal is built on top of Apache Arrow DataFusion. The rewrote PromQL logic is manifested as `Expr` or `Execution Plan` in DataFusion. And both the intermediate data structure and the result is in the format of `Arrow`'s `RecordBatch`.
-
-The following sections are organized in a top-down manner. Starts with evaluation procedure. Then introduces the building blocks of our new PromQL operation. Follows by an explanation of data model. And end with an example logic plan.
-
-*This RFC is heavily related to Prometheus and PromQL. It won't repeat some basic concepts of them.*
-
-## Evaluation
-
-The original implementation is like an interpreter of parsed PromQL AST. It has two characteristics: (1) Operations are evaluated in place after they are parsed to AST. And some key parameters are separated from the AST because they do not present in the query, but come from other places like another field in the HTTP payload. (2) calculation is performed per timestamp. You can see this pattern many times:
-```go
-for ts := ev.startTimestamp; ts <= ev.endTimestamp; ts += ev.interval {}
-```
-
-These bring out two differences in the proposed implementation. First, to make it more general and clear, the evaluation procedure is reorganized into serval phases (and is the same as DataFusion's). And second, data are evaluated by time series (corresponding to "columnar calculation", if think timestamp as row number).
-
-```
-                                      Logic
-   Query             AST              Plan
- ─────────► Parser ───────► Logical ────────► Physical ────┐
-                            Planner           Planner      │
-                                                           │
- ◄───────────────────────────── Executor  ◄────────────────┘
-        Evaluation Result                     Execution
-                                                Plan
-```
-
-- Parser 
-
-    Provided by [`promql-parser`](https://github.com/GreptimeTeam/promql-parser) crate. Same as the original implementation.
-
-- Logical Planner
-
-    Generates a logical plan with all the needed parameters. It should accept something like `EvalStmt` in Go's implementation, which contains query time range, evaluation interval and lookback range.
-
-    Another important thing done here is assembling the logic plan, with all the operations baked into logically. Like what's the filter and time range to read, how the data then flows through a selector into a binary operation, etc. Or what's the output schema of every single step. The generated logic plan is deterministic without variables, and can be `EXPLAIN`ed clearly.
-
-- Physical Planner
-
-    This step converts a logic plan into evaluatable execution plan. There are not many special things like the previous step. Except when a query is going to be executed distributedly. In this case, a logic plan will be divided into serval parts and sent to serval nodes. One physical planner only sees its own part.
-
-- Executor
-
-    As its name shows, this step calculates data to result. And all new calculation logic, the implementation of PromQL in rust, is placed here. And the rewrote functions are using `RecordBatch` and `Array` from `Arrow` as the intermediate data structure.
-
-    Each "batch" contains only data from single time series. This is from the underlying storage implementation. Though it's not a requirement of this RFC, having this property can simplify some functions.
-    
-    Another thing to mention is the rewrote functions don't aware of timestamp or value columns, they are defined only based on the input data types. For example, `increase()` function in PromQL calculates the unbiased delta of data, its implementation here only does this single thing. Let's compare the signature of two implementations:
-
-    - Go
-        ```go
-        func funcIncrease(vals []parser.Value, args parser.Expressions) Vector {}
-        ```
-    - Rust
-        ```rust
-        fn prom_increase(input: Array) -> Array {}
-        ```
-
-    Some unimportant parameters are omitted. The original Go version only writes the logic for `Point`'s value, either float or histogram. But the proposed rewritten one accepts a generic `Array` as input, which can be any type that suits, from `i8` to `u64` to `TimestampNanosecond`.
-
-## Plan and Expression
-
-They are structures to express logic from PromQL. The proposed implementation is built on top of DataFusion, thus our plan and expression are in form of `ExtensionPlan` and `ScalarUDF`. The only difference between them in this context is the return type: plan returns a record batch while expression returns a single column.
-
-This RFC proposes to add four new plans, they are fundamental building blocks that mainly handle data selection logic in PromQL, for the following calculation expressions. 
-
-- `SeriesNormalize`
-
-    Sort data inside one series on the timestamp column, and bias "offset" if has. This plan usually comes after `TableScan` (or `TableScan` and `Filter`) plan.
-
-- `VectorManipulator` and `MatrixManipulator`
-
-    Corresponding to `InstantSelector` and `RangeSelector`. We don't calculate timestamp by timestamp, thus use "vector" instead of "instant", this image shows the difference. And "matrix" is another name for "range vector", for not confused with our "vector". The following section will detail how they are implemented using Arrow.
-
-    ![instant_and_vector](instant-and-vector.png)
-
-    Due to "interval" parameter in PromQL, data after "selector" (or "manipulator" here) are usually shorter than input. And we have to modify the entire record batch to shorten both timestamp, value and tag columns. So they are formed as plan.
-
-- `PromAggregator`
-
-    The carrier of aggregator expressions. This should not be very different from the DataFusion built-in `Aggregate` plan, except PromQL can use "group without" to do reverse selection.
-
-PromQL has around 70 expressions and functions. But luckily we can reuse lots of them from DataFusion. Like unary expression, binary expression and aggregator. We only need to implement those PromQL-specific expressions, like `rate` or `percentile`. The following table lists some typical functions in PromQL, and their signature in the proposed implementation. Other function should be the same.
-
-| Name               	| In Param(s)                                          	| Out Param(s) 	| Explain            	|
-|--------------------	|------------------------------------------------------	|--------------	|--------------------	|
-| instant_delta      	| Matrix T                                             	| Array T      	| idelta in PromQL   	|
-| increase           	| Matrix T                                             	| Array T      	| increase in PromQL 	|
-| extrapolate_factor 	| - Matrix T<br>- Array Timestamp<br>- Array Timestamp 	| Array T      	| *                   	|
-
-*: *`extrapolate_factor` is one of the "dark sides" in PromQL. In short it's a translation of this [paragraph](https://github.com/prometheus/prometheus/blob/0372e259baf014bbade3134fd79bcdfd8cbdef2c/promql/functions.go#L134-L159)*
-
-To reuse those common calculation logic, we can break them into serval expressions, and assemble in the logic planning phase. Like `rate()` in PromQL can be represented as `increase / extrapolate_factor`.
-
-## Data Model
-
-This part explains how data is represented. Following the data model in GreptimeDB, all the data are stored as table, with tag columns, timestamp column and value column. Table to record batch is very straightforward. So an instant vector can be thought of as a row (though as said before, we don't use instant vectors) in the table. Given four basic types in PromQL: scalar, string, instant vector and range vector, only the last "range vector" need some tricks to adapt our columnar calculation.
-
-Range vector is some sort of matrix, it's consisted of small one-dimension vectors, with each being an input of range function. And, applying range function to a range vector can be thought of kind of convolution.
-
-![range-vector-with-matrix](range-vector-with-matrix.png)
-
-(Left is an illustration of range vector. Notice the Y-axis has no meaning, it's just put different pieces separately. The right side is an imagined "matrix" as range function. Multiplying the left side to it can get a one-dimension "matrix" with four elements. That's the evaluation result of a range vector.)
-
-To adapt this range vector to record batch, it should be represented by a column. This RFC proposes to use `DictionaryArray` from Arrow to represent range vector, or `Matrix`. This is "misusing" `DictionaryArray` to ship some additional information about an array. Because the range vector is sliding over one series, we only need to know the `offset` and `length` of each slides to reconstruct the matrix from an array:
-
-![matrix-from-array](matrix-from-array.png)
-
-The length is not fixed, it depends on the input's timestamp. An PoC implementation of `Matrix` and `increase()` can be found in [this repo](https://github.com/waynexia/corroding-prometheus).
-
-## Example
-
-The logic plan of PromQL query
-```promql
-# start: 2022-12-20T10:00:00
-# end: 2022-12-21T10:00:00
-# interval: 1m
-# lookback: 30s
-sum (rate(request_duration[5m])) by (idc)
-```
-looks like
-
-<!-- title: 'PromAggregator: \naggr = sum, column = idc'
-operator: prom
-inputs:
-- title: 'Matrix Manipulator: \ninterval = 1m, range = 5m, expr = div(increase(value), extrapolate_factor(timestamp))'
-  operator: prom
-  inputs:
-  - title: 'Series Normalize: \noffset = 0'
-    operator: prom
-    inputs:
-    - title: 'Filter: \ntimestamp > 2022-12-20T10:00:00 && timestamp < 2022-12-21T10:00:00'
-      operator: filter
-      inputs:
-      - title: 'Table Scan: \ntable = request_duration, timestamp > 2022-12-20T10:00:00 && timestamp < 2022-12-21T10:00:00'
-        operator: scan -->
-
-![example](example.png)
-
-# Drawbacks
-
-Human-being is always error-prone. It's harder to endeavor to rewrite from the ground and requires more attention to ensure correctness, than translate line-by-line. And, since the evaluator's architecture are different, it might be painful to catch up with PromQL's breaking update (if any) in the future.
-
-Misusing Arrow's DictionaryVector as Matrix is another point. This hack needs some `unsafe` function call to bypass Arrow's check. And though Arrow's API is stable, this is still an undocumented behavior.
-
-# Alternatives
-
-There are a few alternatives we've considered:
-- Wrap the existing PromQL's implementation via FFI, and import it to GreptimeDB.
-- Translate its evaluator engine line-by-line, rather than rewrite one.
-- Integrate the Prometheus server into GreptimeDB via RPC, making it a detached execution engine for PromQL.
-
-The first and second options are making a separate execution engine in GreptimeDB, they may alleviate the pain during rewriting, but will have negative impacts to afterward evolve like resource management. And introduce another deploy component in the last option will bring a complex deploy architecture.
-
-And all of them are more or less redundant in data transportation that affects performance and resources. The proposed built-in executing procedure is also easy to integrate and expose to the existing SQL interface GreptimeDB currently provides. Some concepts in PromQL like sliding windows (range vector in PromQL) are very convenient and ergonomic in analyzing series data. This makes it not only a PromQL evaluator, but also an enhancement to our query system.

docs/rfcs/2023-01-03-procedure-framework.md

@@ -1,151 +0,0 @@
----
-Feature Name: "procedure-framework"
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/286
-Date: 2023-01-03
-Author: "Yingwen <realevenyag@gmail.com>"
----
-
-Procedure Framework
-----------------------
-
-# Summary
-A framework for executing operations in a fault-tolerant manner.
-
-# Motivation
-Some operations in GreptimeDB require multiple steps to implement. For example, creating a table needs:
-1. Check whether the table exists
-2. Create the table in the table engine
-  1. Create a region for the table in the storage engine
-  2. Persist the metadata of the table to the table manifest
-3. Add the table to the catalog manager
-
-If the node dies or restarts in the middle of creating a table, it could leave the system in an inconsistent state. The procedure framework, inspired by [Apache HBase's ProcedureV2 framework](https://github.com/apache/hbase/blob/bfc9fc9605de638785435e404430a9408b99a8d0/src/main/asciidoc/_chapters/pv2.adoc) and [Apache Accumulo’s FATE framework](https://accumulo.apache.org/docs/2.x/administration/fate), aims to provide a unified way to implement multi-step operations that is tolerant to failure.
-
-# Details
-## Overview
-The procedure framework consists of the following primary components:
-- A `Procedure` represents an operation or a set of operations to be performed step-by-step
-- `ProcedureManager`, the runtime to run `Procedures`. It executes the submitted procedures, stores procedures' states to the `ProcedureStore` and restores procedures from `ProcedureStore` while the database restarts.
-- `ProcedureStore` is a storage layer for persisting the procedure state
-
-
-## Procedures
-The `ProcedureManager` keeps calling `Procedure::execute()` until the Procedure is done, so the operation of the Procedure should be [idempotent](https://developer.mozilla.org/en-US/docs/Glossary/Idempotent): it needs to be able to undo or replay a partial execution of itself.
-
-```rust
-trait Procedure {
-    fn execute(&mut self, ctx: &Context) -> Result<Status>;
-
-    fn dump(&self) -> Result<String>;
-
-    fn rollback(&self) -> Result<()>;
-
-    // other methods...
-}
-```
-
-The `Status` is an enum that has the following variants:
-```rust
-enum Status {
-    Executing {
-        persist: bool,
-    },
-    Suspended {
-        subprocedures: Vec<ProcedureWithId>,
-        persist: bool,
-    },
-    Done,
-}
-```
-
-A call to `execute()` can result in the following possibilities:
-- `Ok(Status::Done)`: we are done
-- `Ok(Status::Executing { .. })`: there are remaining steps to do
-- `Ok(Status::Suspend { sub_procedure, .. })`: execution is suspended and can be resumed later after the sub-procedure is done.
-- `Err(e)`: error occurs during execution and the procedure is unable to proceed anymore.
-
-Users need to assign a unique `ProcedureId` to the procedure and the procedure can get this id via the `Context`. The `ProcedureId` is typically a UUID.
-
-```rust
-struct Context {
-    id: ProcedureId,
-    // other fields ...
-}
-```
-
-The `ProcedureManager` calls `Procedure::dump()` to serialize the internal state of the procedure and writes to the `ProcedureStore`. The `Status` has a field `persist` to tell the `ProcedureManager` whether it needs persistence.
-
-## Sub-procedures
-A procedure may need to create some sub-procedures to process its subtasks. For example, creating a distributed table with multiple regions (partitions) needs to set up the regions in each node, thus the parent procedure should instantiate a sub-procedure for each region. The `ProcedureManager` makes sure that the parent procedure does not proceed till all sub-procedures are successfully finished.
-
-The procedure can submit sub-procedures to the `ProcedureManager` by returning `Status::Suspended`. It needs to assign a procedure id to each procedure manually so it can track the status of the sub-procedures.
-```rust
-struct ProcedureWithId {
-    id: ProcedureId,
-    procedure: BoxedProcedure,
-}
-```
-
-## ProcedureStore
-We might need to provide two different ProcedureStore implementations:
-- In standalone mode, it stores data on the local disk.
-- In distributed mode, it stores data on the meta server or the object store service.
-
-These implementations should share the same storage structure. They store each procedure's state in a unique path based on the procedure id:
-
-```
-Sample paths:
-
-/procedures/{PROCEDURE_ID}/000001.step
-/procedures/{PROCEDURE_ID}/000002.step
-/procedures/{PROCEDURE_ID}/000003.commit
-```
-
-`ProcedureStore` behaves like a WAL. Before performing each step, the `ProcedureManager` can write the procedure's current state to the ProcedureStore, which stores the state in the `.step` file. The `000001` in the path is a monotonic increasing sequence of the step. After the procedure is done, the `ProcedureManager` puts a `.commit` file to indicate the procedure is finished (committed).
-
-The `ProcedureManager` can remove the procedure's files once the procedure is done, but it needs to leave the `.commit` as the last file to remove in case of failure during removal.
-
-## ProcedureManager
-`ProcedureManager` executes procedures submitted to it.
-
-```rust
-trait ProcedureManager {
-    fn register_loader(&self, name: &str, loader: BoxedProcedureLoader) -> Result<()>;
-
-    async fn submit(&self, procedure: ProcedureWithId) -> Result<()>;
-}
-```
-
-It supports the following operations:
-- Register a `ProcedureLoader` by the type name of the `Procedure`.
-- Submit a `Procedure` to the manager and execute it.
-
-When `ProcedureManager` starts, it loads procedures from the `ProcedureStore` and restores the procedures by the `ProcedureLoader`. The manager stores the type name from `Procedure::type_name()` with the data from `Procedure::dump()` in the `.step` file and uses the type name to find a `ProcedureLoader` to recover the procedure from its data.
-
-```rust
-type BoxedProcedureLoader = Box<dyn Fn(&str) -> Result<BoxedProcedure> + Send>;
-```
-
-## Rollback
-The rollback step is supposed to clean up the resources created during the execute() step. When a procedure has failed, the `ProcedureManager` puts a `rollback` file and calls the `Procedure::rollback()` method.
-
-
-```text
-/procedures/{PROCEDURE_ID}/000001.step
-/procedures/{PROCEDURE_ID}/000002.rollback
-```
-
-Rollback is complicated to implement so some procedures might not support rollback or only provide a best-efforts approach.
-
-## Locking
-The `ProcedureManager` can provide a locking mechanism that gives a procedure read/write access to a database object such as a table so other procedures are unable to modify the same table while the current one is executing.
-
-# Drawbacks
-The `Procedure` framework introduces additional complexity and overhead to our database.
-- To execute a `Procedure`, we need to write to the `ProcedureStore` multiple times, which may slow down the server
-- We need to rewrite the logic of creating/dropping/altering a table using the procedure framework
-
-# Alternatives
-Another approach is to tolerate failure during execution and allow users to retry the operation until it succeeds. But we still need to:
-- Make each step idempotent
-- Record the status in some place to check whether we are done

docs/rfcs/2023-02-01-table-compaction.md

@@ -1,92 +0,0 @@
----
-Feature Name: "table-compaction"
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/930
-Date: 2023-02-01
-Author: "Lei, HUANG <mrsatangel@gmail.com>"
----
-
-# Table Compaction
-
---- 
-
-## Background
-
-GreptimeDB uses an LSM-tree based storage engine that flushes memtables to SSTs for persistence. 
-But currently it only supports level 0. SST files in level 0 does not guarantee to contain only rows with disjoint time ranges. 
-That is to say, different SST files in level 0 may contain overlapped timestamps. 
-The consequence is, in order to retrieve rows in some time range, all files need to be scanned, which brings a lot of IO overhead.
-
-Also, just like other LSMT engines, delete/update to existing primary keys are converted to new rows with delete/update mark and appended to SSTs on flushing. 
-We need to merge the operations to same primary keys so that we don't have to go through all SST files to find the final state of these primary keys.  
-
-## Goal
-
-Implement a compaction framework to: 
-- maintain SSTs in timestamp order to accelerate queries with timestamp condition;
-- merge rows with same primary key;
-- purge expired SSTs;
-- accommodate other tasks like data rollup/indexing.
-
-
-## Overview
-
-Table compaction involves following components:
-- Compaction scheduler: run compaction tasks, limit the consumed resources;
-- Compaction strategy: find the SSTs to compact and determine the output files of compaction.
-- Compaction task: read the rows from input SSTs and write to the output files.
-
-## Implementation
-
-### Compaction scheduler
-
-`CompactionScheduler` is an executor that continuously polls and executes compaction request from a task queue. 
-
-```rust
-#[async_trait]
-pub trait CompactionScheduler {
-    /// Schedules a compaction task.
-    async fn schedule(&self, task: CompactionRequest) -> Result<()>;
-
-    /// Stops compaction scheduler.
-    async fn stop(&self) -> Result<()>;
-}
-```
-
-
-
-### Compaction triggering
-
-Currently, we can check whether to compact tables when memtable is flushed to SST.
-
-https://github.com/GreptimeTeam/greptimedb/blob/4015dd80752e1e6aaa3d7cacc3203cb67ed9be6d/src/storage/src/flush.rs#L245
-
-
-### Compaction strategy
-
-`CompactionStrategy` defines how to pick SSTs in all levels for compaction.   
-
-```rust
-pub trait CompactionStrategy {
-    fn pick(
-        &self,
-        ctx: CompactionContext,
-        levels: &LevelMetas,
-    ) -> Result<CompactionTask>;
-}
-```
-
-The most suitable compaction strategy for time-series scenario would be 
-a hybrid strategy that combines time window compaction with size-tired compaction, just like [Cassandra](https://cassandra.apache.org/doc/latest/cassandra/operating/compaction/twcs.html) and [ScyllaDB](https://docs.scylladb.com/stable/architecture/compaction/compaction-strategies.html#time-window-compaction-strategy-twcs) does.
-
-We can first group SSTs in level n into buckets according to some predefined time window. Within that window, 
-SSTs are compacted in a size-tired manner (find SSTs with similar size and compact them to level n+1). 
-SSTs from different time windows are neven compacted together.
-That strategy guarantees SSTs in each level are mainly sorted in timestamp order which boosts queries with 
-explicit timestamp condition, while size-tired compaction minimizes the impact to foreground writes. 
-
-### Alternatives
-
-Currently, GreptimeDB's storage engine [only support two levels](https://github.com/GreptimeTeam/greptimedb/blob/43aefc5d74dfa73b7819cae77b7eb546d8534a41/src/storage/src/sst.rs#L32).
-For level 0, we can start with a simple time-window based leveled compaction, which reads from all SSTs in level 0, 
-align them to time windows with a fixed duration, merge them with SSTs in level 1 within the same time window 
-to ensure there is only one sorted run in level 1.

docs/rfcs/2023-03-08-region-fault-tolerance.md

@@ -1,196 +0,0 @@
----
-Feature Name: "Fault Tolerance for Region"
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/1126
-Date: 2023-03-08
-Author: "Luo Fucong <luofucong@greptime.com>"
----
-
-Fault Tolerance for Region
-----------------------
-
-# Summary
-
-This RFC proposes a method to achieve fault tolerance for regions in GreptimeDB's distributed mode. Or, put it in another way, achieving region high availability("HA") for GreptimeDB cluster. 
-
-In this RFC, we mainly describe two aspects of region HA: how region availability is detected, and what recovery process is need to be taken. We also discuss some alternatives and future work.
-
-When this feature is done, our users could expect a GreptimeDB cluster that can always handle their requests to regions, despite some requests may failed during the region failover. The optimization to reduce the MTTR(Mean Time To Recovery) is not a concern of this RPC, and is left for future work.
-
-# Motivation
-
-Fault tolerance for regions is a critical feature for our clients to use the GreptimeDB cluster confidently. High availability for users to interact with their stored data is a "must have" for any TSDB products, that include our GreptimeDB cluster.
-
-# Details
-
-## Background
-
-Some backgrounds about region in distributed mode:
-
-- A table is logically split into multiple regions. Each region stores a part of non-overlapping table data.
-- Regions are distributed in Datanodes, the mappings are not static, are assigned and governed by Metasrv.
-- In distributed mode, client requests are scoped in regions. To be more specific, when a request that needs to scan multiple regions arrived in Frontend, Frontend splits the request into multiple sub-requests, each of which scans one region only, and submits them to Datanodes that hold corresponding regions. 
-
-In conclusion, as long as regions remain available, and regions could regain availability when failures do occur, the overall region HA could be achieved. With this in mind, let's see how region failures are detected first. 
-
-## Failure Detection
-
-We detect region failures in Metasrv, and do it both passively and actively. Passively means that Metasrv do not fire some "are you healthy" requests to regions. Instead, we carry region healthy information in the heartbeat requests that are submit to Metasrv by Datanodes. 
-
-Datanode already carries its regions stats in the heartbeat request (the non-relevant fields are omitted):
-
-```protobuf
-message HeartbeatRequest {
-  ...
-  // Region stats on this node
-  repeated RegionStat region_stats = 6;
-  ...
-}
-
-message RegionStat {
-  uint64 region_id = 1;
-  TableName table_name = 2;
-  ...
-}
-```
-
-For the sake of simplicity, we don't add another field `bool available = 3` to the `RegionStat` message; instead, if the region were unavailable in the view of the Datanode that contains it, the Datanode just not includes the `RegionStat` of it in the heartbeat request. Or, if the Datanode itself is not unavailable, the heartbeat request is not submitted, effectively the same with not carrying the `RegionStat`.
-
-> The heartbeat interval is now hardcoded to five seconds.
-
-Metasrv gathers the heartbeat requests, extracts the `RegionStat`s, and treat them as region heartbeat. In this way, Metasrv maintains all regions healthy information. If some region's heartbeats were not received in a period of time, Metasrv speculates the region might be unavailable. To make the decision whether a region is failed or not, Metasrv uses a failure detection algorithm called the "[Phi φ Accrual Failure Detection](https://medium.com/@arpitbhayani/phi-%CF%86-accrual-failure-detection-79c21ce53a7a)". Basically, the algorithm calculates a value called "phi" to represent the possibility of a region's unavailability, based on the historical heartbeats' arrived rate. Once the "phi" is above some pre-defined threshold, Metasrv knows the region is failed.
-
-> This algorithm has been widely adopted in some well known products, like Akka and Cassandra.
-
-When Metasrv decides some region is failed from heartbeats, it's not the final decision. Here comes the "actively" detection. Before Metasrv decides to do region failover, it actively invokes the healthy check interface of the Datanode that the failure region resides. Only this healthy check is failed does Metasrv actually start doing failover upon the region.
-
-To conclude, the failure detection pseudo-codes are like this:
-
-```rust
-// in Metasrv:
-fn failure_detection() {
-    loop {
-        // passive detection
-        let failed_regions = all_regions.iter().filter(|r| r.estimated_failure_possibility() > config.phi).collect();
-
-        // find the datanodes that contains the failed regions
-        let datanodes_and_regions = find_region_resides_datanodes(failed_regions);
-
-        // active detection  
-        for (datanode, regions) in datanodes_and_regions {
-            if !datanode.is_healthy(regions) {
-                do_failover(datanode, regions);
-            }
-        }
-
-        sleep(config.detect_interval);
-    }
-}
-```
-
-Some design considerations:
-
-- Why active detecting while we have passively detection? Because it could be happened that the network is singly connectable sometimes (especially in the complex Cloud environment), then the Datanode's heartbeats cannot reach Metasrv, while Metasrv could request Datanode. Active detecting avoid this false positive situation.
-- Why the detection works on region instead of Datanode? Because we might face the possibility that only part of the regions in the Datanode are not available, not ALL regions. Especially the situation that Datanodes are used by multiple tenants. If this is the case, it's better to do failover upon the designated regions instead of the whole regions that reside on the Datanode. All in all, we want a more subtle control over region failover. 
-
-So we detect some regions are not available. How to regain the availability back?
-
-## Region Failover
-
-Region Failover largely relies on remote WAL, aka "[Bunshin](https://github.com/GreptimeTeam/bunshin)". I'm not including any of the details of it in this RFC, let's just assume we already have it.
-
-In general, region failover is fairly simple. Once Metasrv decides to do failover upon some regions, it first chooses one or more Datanodes to hold the failed region. This can be done easily, as the Metasrv already has the whole picture of Datanodes: it knows which Datanode has the minimum regions, what Datanode historically had the lowest CPU usage and IO rate, and how the Datanodes are assigned to tenants, among other information that can all help the Metasrv choose the most suitable Datanodes. Let's call these chosen Datanodes as "candidates".
-
-> The strategy to choose the most suitable candidates required careful design, but it's another RFC.
-
-Then, Metasrv sets the states of these failed regions as "passive". We should add a field to `Region`:
-
-```protobuf
-message Region {
-  uint64 id = 1;
-  string name = 2;
-  Partition partition = 3;
-  
-  message State {
-    Active,
-    Passive,
-  }
-  State state = 4;
-  
-  map<string, string> attrs = 100;
-}
-```
-
-Here `Region` is used in message `RegionRoute`, which indicates how the write request is split among regions. When a region is set as "passive", Frontend knows the write to it should be rejected at the moment (the region read is not blocked, however).
-
-> Making a region "passive" here is effectively blocking the write to it. It's ok in the failover situation, the region is failed anyway. However, when dealing with active maintenance operations, region state requires more refined design. But that's another story. 
-
-Third, Metasrv fires the "close region" requests to the failed Datanodes, and fires the "open region" requests to those candidates. "Close region" requests might be failed due to the unavailability of Datanodes, but that's fine, it's just a best-effort attempt to reduce the chance of any in-flight writes got handled unintentionally after the region is set as "passive". The "open region" requests must have succeeded though. Datanodes open regions from remote WAL.
-
-> Currently the "close region" is undefined in Datanode. It could be a local cache clean up of region data or other resources tidy up.
-
-Finally, when a candidate successfully opens its region, it calls back to Metasrv, indicating it is ready to handle region. "call back" here is backed by its heartbeat to Metasrv. Metasrv updates the region's state to "active", so as to let Frontend lifts the restrictions of region writes (again, the read part of region is untouched).
-
-All the above steps should be managed by remote procedure framework. It's another implementation challenge in the region failover feature. (One is the remote WAL of course.)
-
-A picture is worth a 1000 words:
-
-```text
-                                    +-------------------------+                                        
-                                    | Metasrv detects region  |                                        
-                                    | failure                 |                                        
-                                    +-------------------------+                                        
-                                                 |                                                     
-                                                 v                                                     
-                                    +----------------------------+                                        
-                                    | Metasrv chooses candidates |                                        
-                                    | to hold failed regions     |                                        
-                                    +----------------------------+                                        
-                                                 |                                                     
-                                                 v                                                     
-                                    +-------------------------+       +-------------------------+      
-                                    | Metasrv "passive" the   |------>| Frontend rejects writes |      
-                                    | failed regions          |       | to "passive" regions    |      
-                                    +-------------------------+       +-------------------------+      
-                                                 |                                                     
-                                                 v                                                     
-+--------------------------+        +---------------------------+                                        
-| Candidate Datanodes open |<-------| Metasrv fires "close" and |                                        
-| regions from remote WAL  |        | "open" region requests    |                                        
-+--------------------------+        +---------------------------+                                        
-             |                                                                                         
-             |                                                                                         
-             |                      +-------------------------+       +-------------------------+      
-             +--------------------->| Metasrv "active" the    |------>| Frontend lifts write    |      
-                                    | failed regions          |       | restriction to regions  |      
-                                    +-------------------------+       +-------------------------+      
-                                                 |                                                     
-                                                 v                                                     
-                                    +-------------------------+                                        
-                                    | Region failover done,   |                                        
-                                    | HA regain               |                                        
-                                    +-------------------------+                                        
-```
-
-# Alternatives
-
-## The "Neon" Way
-
-Remote WAL raises a problem that could harm the write throughput of GreptimeDB cluster: each write request has to do at least two remote call, one is from Frontend to Datanode, and one is from Datanode to remote WAL. What if we do it the "[Neon](https://github.com/neondatabase/neon)" way, making remote WAL sits in between the Frontend and Datanode, couldn't that improve our write throughput? It could, though there're some consistency issues like "read-your-writes" to solve.
-
-However, the main concerns we don't adopt this method are two-fold:
-
-1. Remote WAL is planned to be quorum based, it can be efficiently written;
-2. More importantly, we are planning to make the remote WAL an option that users could choose not to enable it (at the cost of some reliability reduction).
-
-## No WAL, Replication instead
-
-This method replicates region across Datanodes directly, like the common way in shared-nothing database. Were the main region failed, a standby region in the replicate group is elected as new "main" and take the read/write requests. The main concern to this method is the incompatibility to our current architecture and code structure. It requires a major redesign, but gains no significant advantage over the remote WAL method. 
-
-However, the replication does have its own advantage that we can learn from to optimize this failover procedure.
-
-# Future Work
-
-Some optimizations we could take:
-
-- To reduce the MTTR, we could make Metasrv chooses the candidate to each region at normal time. The candidate does some preparation works to reduce the open region time, effectively accelerate the failover procedure.
-- We can adopt the replication method, to the degree that region replicas are used as the fast catch-up candidates. The data difference among replicas is minor, region failover does not need to load or exchange too much data, greatly reduced the region failover time.

docs/rfcs/2023-03-29-file-external-table/rfc.md

@@ -1,174 +0,0 @@
----
-Feature Name: "File external table"
-Tracking Issue: https://github.com/GreptimeTeam/greptimedb/issues/1041
-Date: 2023-03-08
-Author: "Xu Wenkang <wenymedia@gmail.com>"
----
-
-File external table
-
----
-
-# Summary
-
-Allows users to perform SQL queries on files
-
-# Motivation
-
-User data may already exist in other storages, i.g., file systems/s3, etc. in CSV, parquet, JSON format, etc. We can provide users the ability to perform SQL queries on these files.
-
-
-# Details
-
-## Overview
-
-The file external table providers users ability to perform SQL queries on these files.
-
-For example, a user has a CSV file on the local file system `/var/data/city.csv`:
-
-```
-Rank , Name , State , 2023 Population , 2020 Census , Annual Change , Density (mi²)
-1 , New York City , New York , 8,992,908 , 8,804,190 , 0.7% , 29,938
-2 , Los Angeles , California , 3,930,586 , 3,898,747 , 0.27% , 8,382
-3 , Chicago , Illinois , 2,761,625 , 2,746,388 , 0.18% , 12,146
-.....
-```
-
-Then user can create a file external table with:
-
-```sql
-CREATE EXTERNAL TABLE city with(location='/var/data/city.csv', format="CSV", field_delimiter = ',', record_delimiter = '\n', skip_header = 1);
-```
-
-Then query the external table with:
-
-```bash
-MySQL> select * from city;
-```
-
-| Rank | Name          | State      | 2023 Population | 2020 Census | Annual Change | Density (mi²) |
-| :--- | :------------ | :--------- | :-------------- | :---------- | :------------ | :------------ |
-| 1    | New York City | New York   | 8,992,908       | 8,804,190   | 0.7%          | 29,938        |
-| 2    | Los Angeles   | California | 3,930,586       | 3,898,747   | 0.27%         | 8,382         |
-| 3    | Chicago       | Illinois   | 2,761,625       | 2,746,388   | 0.18%         | 12,146        |
-
-Drop the external table, if needs with:
-
-```sql
-DROP EXTERNAL TABLE city
-```
-
-
-### Syntax
-
-```
-CREATE EXTERNAL [<database>.]<table_name>
-[
- (
-    <col_name> <col_type> [NULL | NOT NULL] [COMMENT "<comment>"]
- )
-]
-[ WITH
- (
-     LOCATION = 'url'
-   [,FIELD_DELIMITER =  'delimiter' ]
-   [,RECORD_DELIMITER =  'delimiter' ]
-   [,SKIP_HEADER =  '<number>' ]
-   [,FORMAT =  { csv | json | parquet } ]
-   [,PATTERN = '<regex_pattern>' ]
-   [,ENDPOINT = '<uri>' ]
-   [,ACCESS_KEY_ID = '<key_id>' ]
-   [,SECRET_ACCESS_KEY = '<access_key>' ]
-   [,SESSION_TOKEN = '<token>' ]
-   [,REGION = '<region>' ]
-   [,ENABLE_VIRTUAL_HOST_STYLE = '<boolean>']
-   ..
- )
-]
-```
-
-### Supported File Format
-
-The external file table supports multiple formats; We divide formats into row format and columnar format.
-
-Row formats:
-
-- CSV, JSON
-
-Columnar formats:
-
-- Parquet
-
-Some of these formats support filter pushdown, and others don't. If users use very large files, that format doesn't support pushdown, which might consume a lot of IO for scanning full files and cause a long running query.
-
-### File Table Engine
-
-![overview](external-table-engine-overview.png)
-
-We implement a file table engine that creates an external table by accepting user-specified file paths and treating all records as immutable.
-
-1. File Format Decoder: decode files to the `RecordBatch` stream.
-2. File Table Engine: implement the `TableProvider` trait, store necessary metadata in memory, and provide scan ability.
-
-Our implementation is better for small files. For large files(i.g., a GB-level CSV file), suggests our users import data to the database.
-
-## Drawbacks
-
-- Some formats don't support filter pushdown
-- Hard to support indexing
-
-## Life cycle
-
-### Register a table
-
-1. Write metadata to manifest.
-2. Create the table via file table engine.
-3. Register table to `CatalogProvider` and register table to `SystemCatalog`(persist tables to disk).
-
-### Deregister a table (Drop a table)
-
-1. Fetch the target table info (figure out table engine type).
-2. Deregister the target table in `CatalogProvider` and `SystemCatalog`.
-3. Find the target table engine.
-4. Drop the target table.
-
-### Recover a table when restarting
-
-1. Collect tables name and engine type info.
-2. Find the target tables in different engines.
-3. Open and register tables.
-
-# Alternatives
-
-## Using DataFusion API
-
-We can use datafusion API to register a file table:
-
-```rust
-let ctx = SessionContext::new();
-
-ctx.register_csv("example", "tests/data/example.csv", CsvReadOptions::new()).await?;
-
-// create a plan
-let df = ctx.sql("SELECT a, MIN(b) FROM example WHERE a <= b GROUP BY a LIMIT 100").await?;
-```
-
-### Drawbacks
-
-The DataFusion implements its own `Object Store` abstraction and supports parsing the partitioned directories, which can push down the filter and skips some directories. However, this makes it impossible to use our's `LruCacheLayer`(The parsing of the partitioned directories required paths as input). If we want to manage memory entirely, we should implement our own `TableProvider` or `Table`.
-
-- Impossible to use `CacheLayer`
-
-## Introduce an intermediate representation layer
-
-![overview](external-table-engine-way-2.png)
-
-We convert all files into `parquet` as an intermediate representation. Then we only need to implement a `parquet` file table engine, and we already have a similar one. Also, it supports limited filter pushdown via the `parquet` row group stats.
-
-### Drawbacks
-
-- Computing overhead
-- Storage overhead
-
-
-

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 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.