feat: flownode use Inserter to write to database (#4323)

* feat: use `Inserter` as Frontend

* fix: enable procedure in flownode

* docs: remove `frontend_addr` opts

* chore: rm fe addr in test runner

* refactor: int test also use inserter invoker

* feat: flow shutdown&refactor: remove `Frontendinvoker`

* refactor: rename `RemoteFrontendInvoker` to `FrontendInvoker`

* refactor: per review

* refactor: remove a layer of  box

* fix: standalone use `node_manager`

* fix: remove a `Arc` cycle

.env.example

@@ -28,3 +28,8 @@ GT_MYSQL_ADDR = localhost:4002
 # Setting for unstable fuzz tests
 GT_FUZZ_BINARY_PATH=/path/to/
 GT_FUZZ_INSTANCE_ROOT_DIR=/tmp/unstable_greptime
+GT_FUZZ_INPUT_MAX_ROWS=2048
+GT_FUZZ_INPUT_MAX_TABLES=32
+GT_FUZZ_INPUT_MAX_COLUMNS=32
+GT_FUZZ_INPUT_MAX_ALTER_ACTIONS=256
+GT_FUZZ_INPUT_MAX_INSERT_ACTIONS=8

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

@@ -24,6 +24,14 @@ inputs:
     description: Build android artifacts
     required: false
     default: 'false'
+  image-namespace:
+    description: Image Namespace
+    required: false
+    default: 'greptime'
+  image-registry:
+    description: Image Registry
+    required: false
+    default: 'docker.io'
 runs:
   using: composite
   steps:
@@ -35,7 +43,9 @@ runs:
         make build-by-dev-builder \
           CARGO_PROFILE=${{ inputs.cargo-profile }} \
           FEATURES=${{ inputs.features }} \
-          BASE_IMAGE=${{ inputs.base-image }}
+          BASE_IMAGE=${{ inputs.base-image }} \
+          IMAGE_NAMESPACE=${{ inputs.image-namespace }} \
+          IMAGE_REGISTRY=${{ inputs.image-registry }}
 
     - name: Upload artifacts
       uses: ./.github/actions/upload-artifacts
@@ -53,7 +63,9 @@ runs:
       shell: bash
       if: ${{ inputs.build-android-artifacts == 'true' }}
       run: |
-        cd ${{ inputs.working-dir }} && make strip-android-bin
+        cd ${{ inputs.working-dir }} && make strip-android-bin \
+          IMAGE_NAMESPACE=${{ inputs.image-namespace }} \
+          IMAGE_REGISTRY=${{ inputs.image-registry }}
 
     - name: Upload android artifacts
       uses: ./.github/actions/upload-artifacts

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

@@ -30,7 +30,9 @@ runs:
       # 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
+        make run-it-in-container BUILD_JOBS=4 \
+        IMAGE_NAMESPACE=i8k6a5e1/greptime \
+        IMAGE_REGISTRY=public.ecr.aws
 
     - name: Upload sqlness logs
       if: ${{ failure() && inputs.disable-run-tests == 'false' }} # Only upload logs when the integration tests failed.
@@ -49,6 +51,8 @@ runs:
         artifacts-dir: greptime-linux-${{ inputs.arch }}-pyo3-${{ inputs.version }}
         version: ${{ inputs.version }}
         working-dir: ${{ inputs.working-dir }}
+        image-registry: public.ecr.aws
+        image-namespace: i8k6a5e1/greptime        
 
     - name: Build greptime without pyo3
       if: ${{ inputs.dev-mode == 'false' }}
@@ -60,6 +64,8 @@ runs:
         artifacts-dir: greptime-linux-${{ inputs.arch }}-${{ inputs.version }}
         version: ${{ inputs.version }}
         working-dir: ${{ inputs.working-dir }}
+        image-registry: public.ecr.aws
+        image-namespace: i8k6a5e1/greptime
 
     - 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
@@ -76,6 +82,8 @@ runs:
         artifacts-dir: greptime-linux-${{ inputs.arch }}-centos-${{ inputs.version }}
         version: ${{ inputs.version }}
         working-dir: ${{ inputs.working-dir }}
+        image-registry: public.ecr.aws
+        image-namespace: i8k6a5e1/greptime
 
     - name: Build greptime on android base image
       uses: ./.github/actions/build-greptime-binary
@@ -86,3 +94,5 @@ runs:
         version: ${{ inputs.version }}
         working-dir: ${{ inputs.working-dir }}
         build-android-artifacts: true
+        image-registry: public.ecr.aws
+        image-namespace: i8k6a5e1/greptime

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

@@ -59,9 +59,15 @@ runs:
       if: ${{ inputs.disable-run-tests == 'false' }}
       uses: taiki-e/install-action@nextest
 
+    # Get proper backtraces in mac Sonoma. Currently there's an issue with the new
+    # linker that prevents backtraces from getting printed correctly.
+    #
+    # <https://github.com/rust-lang/rust/issues/113783> 
     - name: Run integration tests
       if: ${{ inputs.disable-run-tests == 'false' }}
       shell: bash
+      env: 
+        CARGO_BUILD_RUSTFLAGS: "-Clink-arg=-Wl,-ld_classic"
       run: |
         make test sqlness-test
 
@@ -75,6 +81,8 @@ runs:
 
     - name: Build greptime binary
       shell: bash
+      env: 
+        CARGO_BUILD_RUSTFLAGS: "-Clink-arg=-Wl,-ld_classic"
       run: |
         make build \
         CARGO_PROFILE=${{ inputs.cargo-profile }} \

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

@@ -123,10 +123,10 @@ runs:
         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.src-image-registry }}/${{ inputs.src-image-namespace }}/${{ inputs.src-image-name }}-centos:${{ inputs.version }} \
          ${{ inputs.dst-image-registry }}/${{ inputs.dst-image-namespace }}
 
-    - name: Push greptimedb-centos image from DockerHub to ACR
+    - name: Push latest greptimedb-centos image from DockerHub to ACR
       shell: bash
       if: ${{ inputs.dev-mode == 'false' && inputs.push-latest-tag == 'true' }}
       env:

.github/actions/setup-chaos/action.yml

@@ -0,0 +1,17 @@
+name: Setup Kind
+description: Deploy Kind
+runs:
+  using: composite
+  steps:
+  - uses: actions/checkout@v4
+  - name: Create kind cluster
+    shell: bash
+    run: |
+      helm repo add chaos-mesh https://charts.chaos-mesh.org
+      kubectl create ns chaos-mesh
+      helm install chaos-mesh chaos-mesh/chaos-mesh -n=chaos-mesh --version 2.6.3
+  - name: Print Chaos-mesh
+    if: always()
+    shell: bash
+    run: | 
+      kubectl get po -n chaos-mesh

.github/actions/setup-greptimedb-cluster/action.yml

@@ -22,28 +22,37 @@ inputs:
   etcd-endpoints:
     default: "etcd.etcd-cluster.svc.cluster.local:2379"
     description: "Etcd endpoints"
+  values-filename:
+    default: "with-minio.yaml"
+  enable-region-failover:
+    default: false
 
 runs:
   using: composite
   steps:
   - name: Install GreptimeDB operator
-    shell: bash
-    run: |
-      helm repo add greptime https://greptimeteam.github.io/helm-charts/ 
-      helm repo update
-      helm upgrade \
-        --install \
-        --create-namespace \
-        greptimedb-operator greptime/greptimedb-operator \
-        -n greptimedb-admin \
-        --wait \
-        --wait-for-jobs
+    uses: nick-fields/retry@v3
+    with: 
+      timeout_minutes: 3
+      max_attempts: 3
+      shell: bash
+      command: |
+        helm repo add greptime https://greptimeteam.github.io/helm-charts/ 
+        helm repo update
+        helm upgrade \
+          --install \
+          --create-namespace \
+          greptimedb-operator greptime/greptimedb-operator \
+          -n greptimedb-admin \
+          --wait \
+          --wait-for-jobs
   - name: Install GreptimeDB cluster
     shell: bash
     run: | 
       helm upgrade \
         --install my-greptimedb \
         --set meta.etcdEndpoints=${{ inputs.etcd-endpoints }} \
+        --set meta.enableRegionFailover=${{ inputs.enable-region-failover }} \
         --set image.registry=${{ inputs.image-registry }} \
         --set image.repository=${{ inputs.image-repository }}  \
         --set image.tag=${{ inputs.image-tag }} \
@@ -57,6 +66,7 @@ runs:
         greptime/greptimedb-cluster \
         --create-namespace \
         -n my-greptimedb \
+        --values ./.github/actions/setup-greptimedb-cluster/${{ inputs.values-filename }} \
         --wait \
         --wait-for-jobs
   - name: Wait for GreptimeDB

.github/actions/setup-greptimedb-cluster/with-disk.yaml

@@ -0,0 +1,18 @@
+meta:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+datanode:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+frontend:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8

.github/actions/setup-greptimedb-cluster/with-minio-and-cache.yaml

@@ -0,0 +1,38 @@
+meta:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+    
+    [datanode]
+    [datanode.client]
+    timeout = "60s"
+datanode:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+    
+    [storage]
+    cache_path = "/data/greptimedb/s3cache"
+    cache_capacity = "256MB"
+frontend:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+
+    [meta_client]
+    ddl_timeout = "60s"
+objectStorage:
+  s3:
+    bucket: default
+    region: us-west-2
+    root: test-root
+    endpoint: http://minio.minio.svc.cluster.local 
+  credentials:
+    accessKeyId: rootuser
+    secretAccessKey: rootpass123

.github/actions/setup-greptimedb-cluster/with-minio.yaml

@@ -0,0 +1,34 @@
+meta:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+    
+    [datanode]
+    [datanode.client]
+    timeout = "60s"
+datanode:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+frontend:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+
+    [meta_client]
+    ddl_timeout = "60s"
+objectStorage:
+  s3:
+    bucket: default
+    region: us-west-2
+    root: test-root
+    endpoint: http://minio.minio.svc.cluster.local 
+  credentials:
+    accessKeyId: rootuser
+    secretAccessKey: rootpass123

.github/actions/setup-greptimedb-cluster/with-remote-wal.yaml

@@ -0,0 +1,45 @@
+meta:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+    
+    [wal]
+    provider = "kafka"
+    broker_endpoints = ["kafka.kafka-cluster.svc.cluster.local:9092"]
+    num_topics = 3
+
+        
+    [datanode]
+    [datanode.client]
+    timeout = "60s"
+datanode:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+
+    [wal]
+    provider = "kafka"
+    broker_endpoints = ["kafka.kafka-cluster.svc.cluster.local:9092"]
+    linger = "2ms"
+frontend:
+  config: |-
+    [runtime]
+    read_rt_size = 8
+    write_rt_size = 8
+    bg_rt_size = 8
+
+    [meta_client]
+    ddl_timeout = "60s"
+objectStorage:
+  s3:
+    bucket: default
+    region: us-west-2
+    root: test-root
+    endpoint: http://minio.minio.svc.cluster.local 
+  credentials:
+    accessKeyId: rootuser
+    secretAccessKey: rootpass123

.github/actions/setup-kafka-cluster/action.yml

@@ -0,0 +1,24 @@
+name: Setup Kafka cluster
+description: Deploy Kafka cluster on Kubernetes
+inputs:
+  controller-replicas:
+    default: 3
+    description: "Kafka controller replicas"
+  namespace:
+    default: "kafka-cluster"
+
+runs:
+  using: composite
+  steps:
+  - name: Install Kafka cluster
+    shell: bash
+    run: | 
+      helm upgrade \
+        --install kafka oci://registry-1.docker.io/bitnamicharts/kafka \
+        --set controller.replicaCount=${{ inputs.controller-replicas }} \
+        --set controller.resources.requests.cpu=50m \
+        --set controller.resources.requests.memory=128Mi \
+        --set listeners.controller.protocol=PLAINTEXT \
+        --set listeners.client.protocol=PLAINTEXT \
+        --create-namespace \
+        -n ${{ inputs.namespace }}

.github/actions/setup-minio/action.yml

@@ -0,0 +1,24 @@
+name: Setup Minio cluster
+description: Deploy Minio cluster on Kubernetes
+inputs:
+  replicas:
+    default: 1
+    description: "replicas"
+
+runs:
+  using: composite
+  steps:
+  - name: Install Etcd cluster
+    shell: bash
+    run: | 
+      helm repo add minio https://charts.min.io/
+      helm upgrade --install minio \
+      --set resources.requests.memory=128Mi \
+      --set replicas=${{ inputs.replicas }} \
+      --set mode=standalone \
+      --set rootUser=rootuser,rootPassword=rootpass123 \
+      --set buckets[0].name=default \
+      --set service.port=80,service.targetPort=9000 \
+      minio/minio \
+      --create-namespace \
+      -n minio

.github/workflows/develop.yml

@@ -139,6 +139,7 @@ jobs:
     name: Fuzz Test
     needs: build
     runs-on: ubuntu-latest
+    timeout-minutes: 60
     strategy:
       matrix:
         target: [ "fuzz_create_table", "fuzz_alter_table", "fuzz_create_database", "fuzz_create_logical_table", "fuzz_alter_logical_table", "fuzz_insert", "fuzz_insert_logical_table" ]
@@ -160,14 +161,16 @@ jobs:
         run: |
           sudo apt-get install -y libfuzzer-14-dev
           rustup install nightly
-          cargo +nightly install cargo-fuzz
+          cargo +nightly install cargo-fuzz cargo-gc-bin
       - name: Download pre-built binaries
         uses: actions/download-artifact@v4
         with:
           name: bins
           path: .
       - name: Unzip binaries
-        run: tar -xvf ./bins.tar.gz
+        run: | 
+          tar -xvf ./bins.tar.gz
+          rm ./bins.tar.gz
       - name: Run GreptimeDB
         run: |
           ./bins/greptime standalone start&
@@ -182,8 +185,9 @@ jobs:
 
   unstable-fuzztest:
     name: Unstable Fuzz Test
-    needs: build
+    needs: build-greptime-ci
     runs-on: ubuntu-latest
+    timeout-minutes: 60
     strategy:
       matrix:
         target: [ "unstable_fuzz_create_table_standalone" ]
@@ -204,20 +208,22 @@ jobs:
         shell: bash
         run: |
           sudo apt update && sudo apt install -y libfuzzer-14-dev
-          cargo install cargo-fuzz
-      - name: Download pre-built binaries
+          cargo install cargo-fuzz cargo-gc-bin
+      - name: Download pre-built binariy
         uses: actions/download-artifact@v4
         with:
-          name: bins
+          name: bin
           path: .
-      - name: Unzip binaries
-        run: tar -xvf ./bins.tar.gz
-      - name: Fuzz Test
+      - name: Unzip bianry
+        run: |
+          tar -xvf ./bin.tar.gz
+          rm ./bin.tar.gz
+      - name: Run Fuzz Test
         uses: ./.github/actions/fuzz-test
         env:
           CUSTOM_LIBFUZZER_PATH: /usr/lib/llvm-14/lib/libFuzzer.a
           GT_MYSQL_ADDR: 127.0.0.1:4002
-          GT_FUZZ_BINARY_PATH: ./bins/greptime
+          GT_FUZZ_BINARY_PATH: ./bin/greptime
           GT_FUZZ_INSTANCE_ROOT_DIR: /tmp/unstable-greptime/
         with:
           target: ${{ matrix.target }}
@@ -256,7 +262,7 @@ jobs:
       - name: Build greptime bianry
         shell: bash
         # `cargo gc` will invoke `cargo build` with specified args
-        run: cargo build --bin greptime --profile ci
+        run: cargo gc --profile ci -- --bin greptime 
       - name: Pack greptime binary
         shell: bash
         run: |
@@ -271,16 +277,40 @@ jobs:
           version: current
 
   distributed-fuzztest: 
-    name: Fuzz Test (Distributed, Disk)
+    name: Fuzz Test (Distributed, ${{ matrix.mode.name }}, ${{ matrix.target }})
     runs-on: ubuntu-latest
     needs:  build-greptime-ci
+    timeout-minutes: 60
     strategy:
       matrix:
         target: [ "fuzz_create_table", "fuzz_alter_table", "fuzz_create_database", "fuzz_create_logical_table", "fuzz_alter_logical_table", "fuzz_insert", "fuzz_insert_logical_table" ]
+        mode: 
+          - name: "Disk"
+            minio: false
+            kafka: false
+            values: "with-disk.yaml"
+          - name: "Minio"
+            minio: true
+            kafka: false
+            values: "with-minio.yaml"
+          - name: "Minio with Cache"
+            minio: true
+            kafka: false
+            values: "with-minio-and-cache.yaml"
+          - name: "Remote WAL"
+            minio: true
+            kafka: true
+            values: "with-remote-wal.yaml"
     steps:
       - uses: actions/checkout@v4
       - name: Setup Kind
         uses: ./.github/actions/setup-kind
+      - if: matrix.mode.minio
+        name: Setup Minio
+        uses: ./.github/actions/setup-minio
+      - if: matrix.mode.kafka
+        name: Setup Kafka cluser
+        uses: ./.github/actions/setup-kafka-cluster
       - name: Setup Etcd cluser
         uses: ./.github/actions/setup-etcd-cluster
       # Prepares for fuzz tests
@@ -300,7 +330,7 @@ jobs:
         run: |
           sudo apt-get install -y libfuzzer-14-dev
           rustup install nightly
-          cargo +nightly install cargo-fuzz
+          cargo +nightly install cargo-fuzz cargo-gc-bin
       # Downloads ci image
       - name: Download pre-built binariy
         uses: actions/download-artifact@v4
@@ -308,7 +338,9 @@ jobs:
           name: bin
           path: .
       - name: Unzip binary
-        run: tar -xvf ./bin.tar.gz
+        run: |
+          tar -xvf ./bin.tar.gz
+          rm ./bin.tar.gz
       - name: Build and push GreptimeDB image
         uses: ./.github/actions/build-and-push-ci-image
       - name: Wait for etcd
@@ -318,6 +350,22 @@ jobs:
             pod -l app.kubernetes.io/instance=etcd \
             --timeout=120s \
             -n etcd-cluster
+      - if: matrix.mode.minio
+        name: Wait for minio
+        run: |
+          kubectl wait \
+            --for=condition=Ready \
+            pod -l app=minio \
+            --timeout=120s \
+            -n minio
+      - if: matrix.mode.kafka
+        name: Wait for kafka
+        run: |
+          kubectl wait \
+            --for=condition=Ready \
+            pod -l app.kubernetes.io/instance=kafka \
+            --timeout=120s \
+            -n kafka-cluster
       - name: Print etcd info
         shell: bash
         run: kubectl get all --show-labels -n etcd-cluster
@@ -326,6 +374,7 @@ jobs:
         uses: ./.github/actions/setup-greptimedb-cluster
         with:
           image-registry: localhost:5001
+          values-filename: ${{ matrix.mode.values }}
       - name: Port forward (mysql)
         run: |
           kubectl port-forward service/my-greptimedb-frontend 4002:4002 -n my-greptimedb&
@@ -351,45 +400,159 @@ jobs:
         if: failure()
         uses: actions/upload-artifact@v4
         with:
-          name: fuzz-tests-kind-logs-${{ matrix.target }}
+          name: fuzz-tests-kind-logs-${{ matrix.mode.name }}-${{ matrix.target }}
           path: /tmp/kind
           retention-days: 3
-        
+      - name: Delete cluster
+        if: success()
+        shell: bash
+        run: | 
+          kind delete cluster
+          docker stop $(docker ps -a -q)
+          docker rm $(docker ps -a -q)
+          docker system prune -f
 
-  sqlness:
-    name: Sqlness Test
-    needs: build
-    runs-on: ${{ matrix.os }}
+  distributed-fuzztest-with-chaos: 
+    name: Fuzz Test with Chaos (Distributed, ${{ matrix.mode.name }}, ${{ matrix.target }})
+    runs-on: ubuntu-latest
+    needs:  build-greptime-ci
+    timeout-minutes: 60
     strategy:
       matrix:
-        os: [ ubuntu-20.04 ]
-    timeout-minutes: 60
+        target: ["fuzz_migrate_mito_regions", "fuzz_failover_mito_regions", "fuzz_failover_metric_regions"]
+        mode: 
+          - name: "Remote WAL"
+            minio: true
+            kafka: true
+            values: "with-remote-wal.yaml"
     steps:
       - uses: actions/checkout@v4
-      - name: Download pre-built binaries
+      - name: Setup Kind
+        uses: ./.github/actions/setup-kind
+      - name: Setup Chaos Mesh
+        uses: ./.github/actions/setup-chaos
+      - if: matrix.mode.minio
+        name: Setup Minio
+        uses: ./.github/actions/setup-minio
+      - if: matrix.mode.kafka
+        name: Setup Kafka cluser
+        uses: ./.github/actions/setup-kafka-cluster
+      - name: Setup Etcd cluser
+        uses: ./.github/actions/setup-etcd-cluster
+      # Prepares for fuzz tests
+      - 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
+        with:
+          # Shares across multiple jobs
+          shared-key: "fuzz-test-targets"
+      - name: Set Rust Fuzz
+        shell: bash
+        run: |
+          sudo apt-get install -y libfuzzer-14-dev
+          rustup install nightly
+          cargo +nightly install cargo-fuzz cargo-gc-bin
+      # Downloads ci image
+      - name: Download pre-built binariy
         uses: actions/download-artifact@v4
         with:
-          name: bins
+          name: bin
           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 --preserve-state
-      - name: Upload sqlness logs
-        if: always()
+      - name: Unzip binary
+        run: |
+          tar -xvf ./bin.tar.gz
+          rm ./bin.tar.gz
+      - name: Build and push GreptimeDB image
+        uses: ./.github/actions/build-and-push-ci-image
+      - name: Wait for etcd
+        run: |
+          kubectl wait \
+            --for=condition=Ready \
+            pod -l app.kubernetes.io/instance=etcd \
+            --timeout=120s \
+            -n etcd-cluster
+      - if: matrix.mode.minio
+        name: Wait for minio
+        run: |
+          kubectl wait \
+            --for=condition=Ready \
+            pod -l app=minio \
+            --timeout=120s \
+            -n minio
+      - if: matrix.mode.kafka
+        name: Wait for kafka
+        run: |
+          kubectl wait \
+            --for=condition=Ready \
+            pod -l app.kubernetes.io/instance=kafka \
+            --timeout=120s \
+            -n kafka-cluster
+      - name: Print etcd info
+        shell: bash
+        run: kubectl get all --show-labels -n etcd-cluster
+      # Setup cluster for test
+      - name: Setup GreptimeDB cluster
+        uses: ./.github/actions/setup-greptimedb-cluster
+        with:
+          image-registry: localhost:5001
+          values-filename: ${{ matrix.mode.values }}
+          enable-region-failover: true
+      - name: Port forward (mysql)
+        run: |
+          kubectl port-forward service/my-greptimedb-frontend 4002:4002 -n my-greptimedb&
+      - name: Fuzz Test
+        uses: ./.github/actions/fuzz-test
+        env:
+          CUSTOM_LIBFUZZER_PATH: /usr/lib/llvm-14/lib/libFuzzer.a
+          GT_MYSQL_ADDR: 127.0.0.1:4002
+        with:
+          target: ${{ matrix.target }}
+          max-total-time: 120
+      - name: Describe Nodes
+        if: failure()
+        shell: bash
+        run: | 
+          kubectl describe nodes      
+      - name: Export kind logs
+        if: failure()
+        shell: bash
+        run: | 
+          kind export logs /tmp/kind
+      - name: Upload logs
+        if: failure()
         uses: actions/upload-artifact@v4
         with:
-          name: sqlness-logs
-          path: /tmp/sqlness*
+          name: fuzz-tests-kind-logs-${{ matrix.mode.name }}-${{ matrix.target }}
+          path: /tmp/kind
           retention-days: 3
+      - name: Delete cluster
+        if: success()
+        shell: bash
+        run: | 
+          kind delete cluster
+          docker stop $(docker ps -a -q)
+          docker rm $(docker ps -a -q)
+          docker system prune -f
 
-  sqlness-kafka-wal:
-    name: Sqlness Test with Kafka Wal
+  sqlness:
+    name: Sqlness Test (${{ matrix.mode.name }})
     needs: build
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ ubuntu-20.04 ]
+        mode:
+          - name: "Basic"
+            opts: ""
+            kafka: false
+          - name: "Remote WAL"
+            opts: "-w kafka -k 127.0.0.1:9092"
+            kafka: true
     timeout-minutes: 60
     steps:
       - uses: actions/checkout@v4
@@ -400,16 +563,17 @@ jobs:
           path: .
       - name: Unzip binaries
         run: tar -xvf ./bins.tar.gz
-      - name: Setup kafka server
+      - if: matrix.mode.kafka
+        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 --preserve-state
+        run: RUST_BACKTRACE=1 ./bins/sqlness-runner ${{ matrix.mode.opts }} -c ./tests/cases --bins-dir ./bins --preserve-state
       - name: Upload sqlness logs
-        if: always()
+        if: failure()
         uses: actions/upload-artifact@v4
         with:
-          name: sqlness-logs-with-kafka-wal
+          name: sqlness-logs-${{ matrix.mode.name }}
           path: /tmp/sqlness*
           retention-days: 3
 
@@ -498,6 +662,9 @@ jobs:
       - name: Setup kafka server
         working-directory: tests-integration/fixtures/kafka
         run: docker compose -f docker-compose-standalone.yml up -d --wait
+      - name: Setup minio
+        working-directory: tests-integration/fixtures/minio
+        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:
@@ -508,6 +675,11 @@ jobs:
           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_MINIO_BUCKET: greptime
+          GT_MINIO_ACCESS_KEY_ID: superpower_ci_user
+          GT_MINIO_ACCESS_KEY: superpower_password
+          GT_MINIO_REGION: us-west-2
+          GT_MINIO_ENDPOINT_URL: http://127.0.0.1:9000
           GT_ETCD_ENDPOINTS: http://127.0.0.1:2379
           GT_KAFKA_ENDPOINTS: 127.0.0.1:9092
           UNITTEST_LOG_DIR: "__unittest_logs"

.github/workflows/docs.yml

@@ -67,19 +67,13 @@ jobs:
       - 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
+    name: Sqlness Test (${{ matrix.mode.name }})
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ ubuntu-20.04 ]
+        mode:
+          - name: "Basic"
+          - name: "Remote WAL"
     steps:
       - run: 'echo "No action required"'

.github/workflows/nightly-build.yml

@@ -199,7 +199,7 @@ jobs:
           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.
+          push-latest-tag: true
 
       - name: Set nightly build result
         id: set-nightly-build-result
@@ -240,7 +240,7 @@ jobs:
           aws-cn-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
           dev-mode: false
           update-version-info: false  # Don't update version info in S3.
-          push-latest-tag: false      # Don't push the latest tag to registry.
+          push-latest-tag: true
 
   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

.pre-commit-config.yaml

@@ -16,6 +16,7 @@ repos:
     hooks:
     -    id: fmt
     -    id: clippy
-         args: ["--workspace", "--all-targets", "--", "-D", "warnings", "-D", "clippy::print_stdout", "-D", "clippy::print_stderr"]
+         args: ["--workspace", "--all-targets", "--all-features", "--", "-D", "warnings"]
          stages: [push]
     -    id: cargo-check
+         args: ["--workspace", "--all-targets", "--all-features"]

AUTHOR.md

@@ -0,0 +1,43 @@
+# GreptimeDB Authors
+
+## Individual Committers (in alphabetical order)
+
+* [CookiePieWw](https://github.com/CookiePieWw)
+* [KKould](https://github.com/KKould)
+* [NiwakaDev](https://github.com/NiwakaDev)
+* [etolbakov](https://github.com/etolbakov)
+* [irenjj](https://github.com/irenjj)
+
+## Team Members (in alphabetical order)
+
+* [Breeze-P](https://github.com/Breeze-P)
+* [GrepTime](https://github.com/GrepTime)
+* [MichaelScofield](https://github.com/MichaelScofield)
+* [Wenjie0329](https://github.com/Wenjie0329)
+* [WenyXu](https://github.com/WenyXu)
+* [ZonaHex](https://github.com/ZonaHex)
+* [apdong2022](https://github.com/apdong2022)
+* [beryl678](https://github.com/beryl678)
+* [daviderli614](https://github.com/daviderli614)
+* [discord9](https://github.com/discord9)
+* [evenyag](https://github.com/evenyag)
+* [fengjiachun](https://github.com/fengjiachun)
+* [fengys1996](https://github.com/fengys1996)
+* [holalengyu](https://github.com/holalengyu)
+* [killme2008](https://github.com/killme2008)
+* [nicecui](https://github.com/nicecui)
+* [paomian](https://github.com/paomian)
+* [shuiyisong](https://github.com/shuiyisong)
+* [sunchanglong](https://github.com/sunchanglong)
+* [sunng87](https://github.com/sunng87)
+* [tisonkun](https://github.com/tisonkun)
+* [v0y4g3r](https://github.com/v0y4g3r)
+* [waynexia](https://github.com/waynexia)
+* [xtang](https://github.com/xtang)
+* [zhaoyingnan01](https://github.com/zhaoyingnan01)
+* [zhongzc](https://github.com/zhongzc)
+* [zyy17](https://github.com/zyy17)
+
+## All Contributors
+
+[![All Contributors](https://contrib.rocks/image?repo=GreptimeTeam/greptimedb)](https://github.com/GreptimeTeam/greptimedb/graphs/contributors)

CONTRIBUTING.md

@@ -2,7 +2,11 @@
 
 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.
+You can find our contributors at https://github.com/GreptimeTeam/greptimedb/graphs/contributors. When you dedicate to GreptimeDB for a few months and keep bringing high-quality contributions (code, docs, advocate, etc.), you will be a candidate of a committer.
+
+A committer will be granted both read & write access to GreptimeDB repos. Check the [AUTHOR.md](AUTHOR.md) file for all current individual committers.
+
+Please read the guidelines, and they can help you get started. Communicate respectfully with the 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).
 

Cargo.toml

@@ -1,6 +1,5 @@
 [workspace]
 members = [
-    "benchmarks",
     "src/api",
     "src/auth",
     "src/catalog",
@@ -46,6 +45,7 @@ members = [
     "src/object-store",
     "src/operator",
     "src/partition",
+    "src/pipeline",
     "src/plugins",
     "src/promql",
     "src/puffin",
@@ -64,7 +64,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.8.1"
+version = "0.8.2"
 edition = "2021"
 license = "Apache-2.0"
 
@@ -104,23 +104,22 @@ clap = { version = "4.4", features = ["derive"] }
 config = "0.13.0"
 crossbeam-utils = "0.8"
 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-physical-plan = { 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" }
+datafusion = { git = "https://github.com/apache/datafusion.git", rev = "729b356ef543ffcda6813c7b5373507a04ae0109" }
+datafusion-common = { git = "https://github.com/apache/datafusion.git", rev = "729b356ef543ffcda6813c7b5373507a04ae0109" }
+datafusion-expr = { git = "https://github.com/apache/datafusion.git", rev = "729b356ef543ffcda6813c7b5373507a04ae0109" }
+datafusion-functions = { git = "https://github.com/apache/datafusion.git", rev = "729b356ef543ffcda6813c7b5373507a04ae0109" }
+datafusion-optimizer = { git = "https://github.com/apache/datafusion.git", rev = "729b356ef543ffcda6813c7b5373507a04ae0109" }
+datafusion-physical-expr = { git = "https://github.com/apache/datafusion.git", rev = "729b356ef543ffcda6813c7b5373507a04ae0109" }
+datafusion-physical-plan = { git = "https://github.com/apache/datafusion.git", rev = "729b356ef543ffcda6813c7b5373507a04ae0109" }
+datafusion-sql = { git = "https://github.com/apache/datafusion.git", rev = "729b356ef543ffcda6813c7b5373507a04ae0109" }
+datafusion-substrait = { git = "https://github.com/apache/datafusion.git", rev = "729b356ef543ffcda6813c7b5373507a04ae0109" }
 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" }
+etcd-client = { version = "0.13" }
 fst = "0.4.7"
 futures = "0.3"
 futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "902f75fdd170c572e90b1f640161d90995f20218" }
+greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "b83f00958fe4cbc77b85b7407bca206e98bdc845" }
 humantime = "2.1"
 humantime-serde = "1.1"
 itertools = "0.10"
@@ -153,6 +152,8 @@ reqwest = { version = "0.12", default-features = false, features = [
     "multipart",
 ] }
 rskafka = "0.5"
+rstest = "0.21"
+rstest_reuse = "0.7"
 rust_decimal = "1.33"
 schemars = "0.8"
 serde = { version = "1.0", features = ["derive"] }
@@ -162,7 +163,7 @@ smallvec = { version = "1", features = ["serde"] }
 snafu = "0.8"
 sysinfo = "0.30"
 # on branch v0.44.x
-sqlparser = { git = "https://github.com/GreptimeTeam/sqlparser-rs.git", rev = "e4e496b8d62416ad50ce70a1b460c7313610cf5d", features = [
+sqlparser = { git = "https://github.com/GreptimeTeam/sqlparser-rs.git", rev = "54a267ac89c09b11c0c88934690530807185d3e7", features = [
     "visitor",
 ] }
 strum = { version = "0.25", features = ["derive"] }
@@ -222,6 +223,7 @@ mito2 = { path = "src/mito2" }
 object-store = { path = "src/object-store" }
 operator = { path = "src/operator" }
 partition = { path = "src/partition" }
+pipeline = { path = "src/pipeline" }
 plugins = { path = "src/plugins" }
 promql = { path = "src/promql" }
 puffin = { path = "src/puffin" }
@@ -250,9 +252,12 @@ incremental = false
 
 [profile.ci]
 inherits = "dev"
-debug = false
 strip = true
 
 [profile.dev.package.sqlness-runner]
 debug = false
 strip = true
+
+[profile.dev.package.tests-fuzz]
+debug = false
+strip = true

Makefile

@@ -163,6 +163,17 @@ nextest: ## Install nextest tools.
 sqlness-test: ## Run sqlness test.
 	cargo sqlness
 
+# Run fuzz test ${FUZZ_TARGET}.
+RUNS ?= 1
+FUZZ_TARGET ?= fuzz_alter_table
+.PHONY: fuzz
+fuzz:
+	cargo fuzz run ${FUZZ_TARGET} --fuzz-dir tests-fuzz -D -s none -- -runs=${RUNS}
+
+.PHONY: fuzz-ls
+fuzz-ls:
+	cargo fuzz list --fuzz-dir tests-fuzz 
+
 .PHONY: check
 check: ## Cargo check all the targets.
 	cargo check --workspace --all-targets --all-features
@@ -194,6 +205,10 @@ run-it-in-container: start-etcd ## Run integration tests in dev-builder.
 	-w /greptimedb ${IMAGE_REGISTRY}/${IMAGE_NAMESPACE}/dev-builder-${BASE_IMAGE}:latest \
 	make test sqlness-test BUILD_JOBS=${BUILD_JOBS}
 
+.PHONY: run-cluster-with-etcd
+run-cluster-with-etcd: ## Run greptime cluster with etcd in docker-compose.
+	 docker compose -f ./docker/docker-compose/cluster-with-etcd.yaml up
+
 ##@ Docs
 config-docs: ## Generate configuration documentation from toml files.
 	docker run --rm \

README.md

@@ -183,6 +183,8 @@ Please refer to [contribution guidelines](CONTRIBUTING.md) and [internal concept
 
 ## Acknowledgement
 
+Special thanks to all the contributors who have propelled GreptimeDB forward. For a complete list of contributors, please refer to [AUTHOR.md](AUTHOR.md).
+
 - 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.

benchmarks/Cargo.toml

@@ -1,38 +0,0 @@
-[package]
-name = "benchmarks"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-
-[lints]
-workspace = true
-
-[dependencies]
-api.workspace = true
-arrow.workspace = true
-chrono.workspace = true
-clap.workspace = true
-client = { workspace = true, features = ["testing"] }
-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
-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

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/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,366 +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::provider::Provider;
-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>,
-    provider: Provider,
-    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 {
-        let provider = match wal_options {
-            WalOptions::RaftEngine => Provider::raft_engine_provider(id.as_u64()),
-            WalOptions::Kafka(opts) => Provider::kafka_provider(opts.topic),
-        };
-        Self {
-            id,
-            schema,
-            provider,
-            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.provider,
-            )
-            .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.provider).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!(),
-        }
-    }
-}

config/config-docs-template.md

@@ -1,10 +1,12 @@
 # Configurations
 
-- [Standalone Mode](#standalone-mode)
-- [Distributed Mode](#distributed-mode)
+- [Configurations](#configurations)
+  - [Standalone Mode](#standalone-mode)
+  - [Distributed Mode](#distributed-mode)
     - [Frontend](#frontend)
     - [Metasrv](#metasrv)
     - [Datanode](#datanode)
+    - [Flownode](#flownode)
 
 ## Standalone Mode
 
@@ -23,3 +25,7 @@
 ### Datanode
 
 {{ toml2docs "./datanode.example.toml" }}
+
+### Flownode
+
+{{ toml2docs "./flownode.example.toml"}}

config/config.md

@@ -1,10 +1,12 @@
 # Configurations
 
-- [Standalone Mode](#standalone-mode)
-- [Distributed Mode](#distributed-mode)
+- [Configurations](#configurations)
+  - [Standalone Mode](#standalone-mode)
+  - [Distributed Mode](#distributed-mode)
     - [Frontend](#frontend)
     - [Metasrv](#metasrv)
     - [Datanode](#datanode)
+    - [Flownode](#flownode)
 
 ## Standalone Mode
 
@@ -13,10 +15,14 @@
 | `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. |
+| `runtime` | -- | -- | The runtime options. |
+| `runtime.read_rt_size` | Integer | `8` | The number of threads to execute the runtime for global read operations. |
+| `runtime.write_rt_size` | Integer | `8` | The number of threads to execute the runtime for global write operations. |
+| `runtime.bg_rt_size` | Integer | `4` | The number of threads to execute the runtime for global background operations. |
 | `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`. |
+| `http.timeout` | String | `30s` | HTTP request timeout. Set to 0 to disable timeout. |
+| `http.body_limit` | String | `64MB` | HTTP request body limit.<br/>The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.<br/>Set to 0 to disable limit. |
 | `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. |
@@ -62,8 +68,7 @@
 | `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.max_batch_bytes` | 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.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`**. |
@@ -115,12 +120,20 @@
 | `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.index` | -- | -- | The options for index in Mito engine. |
+| `region_engine.mito.index.aux_path` | String | `""` | Auxiliary directory path for the index in filesystem, used to store intermediate files for<br/>creating the index and staging files for searching the index, defaults to `{data_home}/index_intermediate`.<br/>The default name for this directory is `index_intermediate` for backward compatibility.<br/><br/>This path contains two subdirectories:<br/>- `__intm`: for storing intermediate files used during creating index.<br/>- `staging`: for storing staging files used during searching index. |
+| `region_engine.mito.index.staging_size` | String | `2GB` | The max capacity of the staging directory. |
 | `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.inverted_index.create_on_flush` | String | `auto` | Whether to create the index on flush.<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.inverted_index.create_on_compaction` | String | `auto` | Whether to create the index on compaction.<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.inverted_index.apply_on_query` | String | `auto` | Whether to apply the index on query<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.inverted_index.mem_threshold_on_create` | String | `auto` | Memory threshold for performing an external sort during index creation.<br/>- `auto`: automatically determine the threshold based on the system memory size (default)<br/>- `unlimited`: no memory limit<br/>- `[size]` e.g. `64MB`: fixed memory threshold |
+| `region_engine.mito.inverted_index.intermediate_path` | String | `""` | Deprecated, use `region_engine.mito.index.aux_path` instead. |
+| `region_engine.mito.fulltext_index` | -- | -- | The options for full-text index in Mito engine. |
+| `region_engine.mito.fulltext_index.create_on_flush` | String | `auto` | Whether to create the index on flush.<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.fulltext_index.create_on_compaction` | String | `auto` | Whether to create the index on compaction.<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.fulltext_index.apply_on_query` | String | `auto` | Whether to apply the index on query<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.fulltext_index.mem_threshold_on_create` | String | `auto` | Memory threshold for index creation.<br/>- `auto`: automatically determine the threshold based on the system memory size (default)<br/>- `unlimited`: no memory limit<br/>- `[size]` e.g. `64MB`: fixed memory threshold |
 | `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. |
@@ -154,15 +167,20 @@
 | --- | -----| ------- | ----------- |
 | `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. |
+| `runtime` | -- | -- | The runtime options. |
+| `runtime.read_rt_size` | Integer | `8` | The number of threads to execute the runtime for global read operations. |
+| `runtime.write_rt_size` | Integer | `8` | The number of threads to execute the runtime for global write operations. |
+| `runtime.bg_rt_size` | Integer | `4` | The number of threads to execute the runtime for global background operations. |
 | `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`. |
+| `http.timeout` | String | `30s` | HTTP request timeout. Set to 0 to disable timeout. |
+| `http.body_limit` | String | `64MB` | HTTP request body limit.<br/>The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.<br/>Set to 0 to disable limit. |
 | `grpc` | -- | -- | The gRPC server options. |
 | `grpc.addr` | String | `127.0.0.1:4001` | The address to bind the gRPC server. |
+| `grpc.hostname` | String | `127.0.0.1` | The hostname advertised to the metasrv,<br/>and used for connections from outside the host |
 | `grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
 | `grpc.tls` | -- | -- | gRPC server TLS options, see `mysql.tls` section. |
 | `grpc.tls.mode` | String | `disable` | TLS mode. |
@@ -240,6 +258,10 @@
 | `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. |
+| `runtime` | -- | -- | The runtime options. |
+| `runtime.read_rt_size` | Integer | `8` | The number of threads to execute the runtime for global read operations. |
+| `runtime.write_rt_size` | Integer | `8` | The number of threads to execute the runtime for global write operations. |
+| `runtime.bg_rt_size` | Integer | `4` | The number of threads to execute the runtime for global background operations. |
 | `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 |
@@ -247,7 +269,7 @@
 | `failure_detector` | -- | -- | -- |
 | `failure_detector.threshold` | Float | `8.0` | -- |
 | `failure_detector.min_std_deviation` | String | `100ms` | -- |
-| `failure_detector.acceptable_heartbeat_pause` | String | `3000ms` | -- |
+| `failure_detector.acceptable_heartbeat_pause` | String | `10000ms` | -- |
 | `failure_detector.first_heartbeat_estimate` | String | `1000ms` | -- |
 | `datanode` | -- | -- | Datanode options. |
 | `datanode.client` | -- | -- | Datanode client options. |
@@ -294,12 +316,28 @@
 | `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. |
+| `init_regions_parallelism` | Integer | `16` | Parallelism of initializing regions. |
+| `rpc_addr` | String | `None` | Deprecated, use `grpc.addr` instead. |
+| `rpc_hostname` | String | `None` | Deprecated, use `grpc.hostname` instead. |
+| `rpc_runtime_size` | Integer | `None` | Deprecated, use `grpc.runtime_size` instead. |
+| `rpc_max_recv_message_size` | String | `None` | Deprecated, use `grpc.rpc_max_recv_message_size` instead. |
+| `rpc_max_send_message_size` | String | `None` | Deprecated, use `grpc.rpc_max_send_message_size` instead. |
+| `grpc` | -- | -- | The gRPC server options. |
+| `grpc.addr` | String | `127.0.0.1:3001` | The address to bind the gRPC server. |
+| `grpc.hostname` | String | `127.0.0.1` | The hostname advertised to the metasrv,<br/>and used for connections from outside the host |
+| `grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
+| `grpc.max_recv_message_size` | String | `512MB` | The maximum receive message size for gRPC server. |
+| `grpc.max_send_message_size` | String | `512MB` | The maximum send message size for gRPC server. |
+| `grpc.tls` | -- | -- | gRPC server TLS options, see `mysql.tls` section. |
+| `grpc.tls.mode` | String | `disable` | TLS mode. |
+| `grpc.tls.cert_path` | String | `None` | Certificate file path. |
+| `grpc.tls.key_path` | String | `None` | Private key file path. |
+| `grpc.tls.watch` | Bool | `false` | Watch for Certificate and key file change and auto reload.<br/>For now, gRPC tls config does not support auto reload. |
+| `runtime` | -- | -- | The runtime options. |
+| `runtime.read_rt_size` | Integer | `8` | The number of threads to execute the runtime for global read operations. |
+| `runtime.write_rt_size` | Integer | `8` | The number of threads to execute the runtime for global write operations. |
+| `runtime.bg_rt_size` | Integer | `4` | The number of threads to execute the runtime for global background operations. |
 | `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. |
@@ -325,8 +363,7 @@
 | `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.max_batch_bytes` | 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.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`**. |
@@ -372,12 +409,20 @@
 | `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.index` | -- | -- | The options for index in Mito engine. |
+| `region_engine.mito.index.aux_path` | String | `""` | Auxiliary directory path for the index in filesystem, used to store intermediate files for<br/>creating the index and staging files for searching the index, defaults to `{data_home}/index_intermediate`.<br/>The default name for this directory is `index_intermediate` for backward compatibility.<br/><br/>This path contains two subdirectories:<br/>- `__intm`: for storing intermediate files used during creating index.<br/>- `staging`: for storing staging files used during searching index. |
+| `region_engine.mito.index.staging_size` | String | `2GB` | The max capacity of the staging directory. |
 | `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.inverted_index.create_on_flush` | String | `auto` | Whether to create the index on flush.<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.inverted_index.create_on_compaction` | String | `auto` | Whether to create the index on compaction.<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.inverted_index.apply_on_query` | String | `auto` | Whether to apply the index on query<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.inverted_index.mem_threshold_on_create` | String | `auto` | Memory threshold for performing an external sort during index creation.<br/>- `auto`: automatically determine the threshold based on the system memory size (default)<br/>- `unlimited`: no memory limit<br/>- `[size]` e.g. `64MB`: fixed memory threshold |
+| `region_engine.mito.inverted_index.intermediate_path` | String | `""` | Deprecated, use `region_engine.mito.index.aux_path` instead. |
+| `region_engine.mito.fulltext_index` | -- | -- | The options for full-text index in Mito engine. |
+| `region_engine.mito.fulltext_index.create_on_flush` | String | `auto` | Whether to create the index on flush.<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.fulltext_index.create_on_compaction` | String | `auto` | Whether to create the index on compaction.<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.fulltext_index.apply_on_query` | String | `auto` | Whether to apply the index on query<br/>- `auto`: automatically (default)<br/>- `disable`: never |
+| `region_engine.mito.fulltext_index.mem_threshold_on_create` | String | `auto` | Memory threshold for index creation.<br/>- `auto`: automatically determine the threshold based on the system memory size (default)<br/>- `unlimited`: no memory limit<br/>- `[size]` e.g. `64MB`: fixed memory threshold |
 | `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. |
@@ -401,3 +446,40 @@
 | `export_metrics.remote_write.headers` | InlineTable | -- | HTTP headers of Prometheus remote-write carry. |
 | `tracing` | -- | -- | The tracing options. Only effect when compiled with `tokio-console` feature. |
 | `tracing.tokio_console_addr` | String | `None` | The tokio console address. |
+
+
+### Flownode
+
+| Key | Type | Default | Descriptions |
+| --- | -----| ------- | ----------- |
+| `mode` | String | `distributed` | The running mode of the flownode. It can be `standalone` or `distributed`. |
+| `node_id` | Integer | `None` | The flownode identifier and should be unique in the cluster. |
+| `grpc` | -- | -- | The gRPC server options. |
+| `grpc.addr` | String | `127.0.0.1:6800` | The address to bind the gRPC server. |
+| `grpc.hostname` | String | `127.0.0.1` | The hostname advertised to the metasrv,<br/>and used for connections from outside the host |
+| `grpc.runtime_size` | Integer | `2` | The number of server worker threads. |
+| `grpc.max_recv_message_size` | String | `512MB` | The maximum receive message size for gRPC server. |
+| `grpc.max_send_message_size` | String | `512MB` | The maximum send message size for gRPC server. |
+| `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` | -- |
+| `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. |
+| `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` | -- |
+| `tracing` | -- | -- | The tracing options. Only effect when compiled with `tokio-console` feature. |
+| `tracing.tokio_console_addr` | String | `None` | The tokio console address. |

config/datanode.example.toml

@@ -13,24 +13,71 @@ require_lease_before_startup = false
 ## By default, it provides services after all regions have been initialized.
 init_regions_in_background = false
 
-## The gRPC address of the datanode.
+## Enable telemetry to collect anonymous usage data.
+enable_telemetry = true
+
+## Parallelism of initializing regions.
+init_regions_parallelism = 16
+
+## Deprecated, use `grpc.addr` instead.
+## +toml2docs:none-default
 rpc_addr = "127.0.0.1:3001"
 
-## The hostname of the datanode.
+## Deprecated, use `grpc.hostname` instead.
 ## +toml2docs:none-default
 rpc_hostname = "127.0.0.1"
 
-## The number of gRPC server worker threads.
+## Deprecated, use `grpc.runtime_size` instead.
+## +toml2docs:none-default
 rpc_runtime_size = 8
 
-## The maximum receive message size for gRPC server.
+## Deprecated, use `grpc.rpc_max_recv_message_size` instead.
+## +toml2docs:none-default
 rpc_max_recv_message_size = "512MB"
 
-## The maximum send message size for gRPC server.
+## Deprecated, use `grpc.rpc_max_send_message_size` instead.
+## +toml2docs:none-default
 rpc_max_send_message_size = "512MB"
 
-## Enable telemetry to collect anonymous usage data.
-enable_telemetry = true
+## The gRPC server options.
+[grpc]
+## The address to bind the gRPC server.
+addr = "127.0.0.1:3001"
+## The hostname advertised to the metasrv,
+## and used for connections from outside the host
+hostname = "127.0.0.1"
+## The number of server worker threads.
+runtime_size = 8
+## The maximum receive message size for gRPC server.
+max_recv_message_size = "512MB"
+## The maximum send message size for gRPC server.
+max_send_message_size = "512MB"
+
+## gRPC server TLS options, see `mysql.tls` section.
+[grpc.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.
+## For now, gRPC tls config does not support auto reload.
+watch = false
+
+## The runtime options.
+[runtime]
+## The number of threads to execute the runtime for global read operations.
+read_rt_size = 8
+## The number of threads to execute the runtime for global write operations.
+write_rt_size = 8
+## The number of threads to execute the runtime for global background operations.
+bg_rt_size = 4
 
 ## The heartbeat options.
 [heartbeat]
@@ -120,11 +167,7 @@ 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"
+max_batch_bytes = "1MB"
 
 ## The consumer wait timeout.
 ## **It's only used when the provider is `kafka`**.
@@ -351,31 +394,72 @@ parallel_scan_channel_size = 32
 ## Whether to allow stale WAL entries read during replay.
 allow_stale_entries = false
 
+## The options for index in Mito engine.
+[region_engine.mito.index]
+
+## Auxiliary directory path for the index in filesystem, used to store intermediate files for
+## creating the index and staging files for searching the index, defaults to `{data_home}/index_intermediate`.
+## The default name for this directory is `index_intermediate` for backward compatibility.
+##
+## This path contains two subdirectories:
+## - `__intm`: for storing intermediate files used during creating index.
+## - `staging`: for storing staging files used during searching index.
+aux_path = ""
+
+## The max capacity of the staging directory.
+staging_size = "2GB"
+
 ## The options for inverted index in Mito engine.
 [region_engine.mito.inverted_index]
 
 ## Whether to create the index on flush.
-## - `auto`: automatically
+## - `auto`: automatically (default)
 ## - `disable`: never
 create_on_flush = "auto"
 
 ## Whether to create the index on compaction.
-## - `auto`: automatically
+## - `auto`: automatically (default)
 ## - `disable`: never
 create_on_compaction = "auto"
 
 ## Whether to apply the index on query
-## - `auto`: automatically
+## - `auto`: automatically (default)
 ## - `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"
+## - `auto`: automatically determine the threshold based on the system memory size (default)
+## - `unlimited`: no memory limit
+## - `[size]` e.g. `64MB`: fixed memory threshold
+mem_threshold_on_create = "auto"
 
-## File system path to store intermediate files for external sorting (default `{data_home}/index_intermediate`).
+## Deprecated, use `region_engine.mito.index.aux_path` instead.
 intermediate_path = ""
 
+## The options for full-text index in Mito engine.
+[region_engine.mito.fulltext_index]
+
+## Whether to create the index on flush.
+## - `auto`: automatically (default)
+## - `disable`: never
+create_on_flush = "auto"
+
+## Whether to create the index on compaction.
+## - `auto`: automatically (default)
+## - `disable`: never
+create_on_compaction = "auto"
+
+## Whether to apply the index on query
+## - `auto`: automatically (default)
+## - `disable`: never
+apply_on_query = "auto"
+
+## Memory threshold for index creation.
+## - `auto`: automatically determine the threshold based on the system memory size (default)
+## - `unlimited`: no memory limit
+## - `[size]` e.g. `64MB`: fixed memory threshold
+mem_threshold_on_create = "auto"
+
 [region_engine.mito.memtable]
 ## Memtable type.
 ## - `time_series`: time-series memtable

config/flownode.example.toml

@@ -0,0 +1,90 @@
+## The running mode of the flownode. It can be `standalone` or `distributed`.
+mode = "distributed"
+
+## The flownode identifier and should be unique in the cluster.
+## +toml2docs:none-default
+node_id = 14
+
+## The gRPC server options.
+[grpc]
+## The address to bind the gRPC server.
+addr = "127.0.0.1:6800"
+## The hostname advertised to the metasrv,
+## and used for connections from outside the host
+hostname = "127.0.0.1"
+## The number of server worker threads.
+runtime_size = 2
+## The maximum receive message size for gRPC server.
+max_recv_message_size = "512MB"
+## The maximum send message size for gRPC server.
+max_send_message_size = "512MB"
+
+
+## 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 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 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 tracing options. Only effect when compiled with `tokio-console` feature.
+[tracing]
+## The tokio console address.
+## +toml2docs:none-default
+tokio_console_addr = "127.0.0.1"
+

config/frontend.example.toml

@@ -5,6 +5,15 @@ mode = "standalone"
 ## +toml2docs:none-default
 default_timezone = "UTC"
 
+## The runtime options.
+[runtime]
+## The number of threads to execute the runtime for global read operations.
+read_rt_size = 8
+## The number of threads to execute the runtime for global write operations.
+write_rt_size = 8
+## The number of threads to execute the runtime for global background operations.
+bg_rt_size = 4
+
 ## The heartbeat options.
 [heartbeat]
 ## Interval for sending heartbeat messages to the metasrv.
@@ -17,16 +26,20 @@ retry_interval = "3s"
 [http]
 ## The address to bind the HTTP server.
 addr = "127.0.0.1:4000"
-## HTTP request timeout.
+## HTTP request timeout. Set to 0 to disable timeout.
 timeout = "30s"
 ## HTTP request body limit.
-## Support the following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.
+## The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.
+## Set to 0 to disable limit.
 body_limit = "64MB"
 
 ## The gRPC server options.
 [grpc]
 ## The address to bind the gRPC server.
 addr = "127.0.0.1:4001"
+## The hostname advertised to the metasrv,
+## and used for connections from outside the host
+hostname = "127.0.0.1"
 ## The number of server worker threads.
 runtime_size = 8
 

config/metasrv.example.toml

@@ -25,6 +25,15 @@ enable_telemetry = true
 ## If it's not empty, the metasrv will store all data with this key prefix.
 store_key_prefix = ""
 
+## The runtime options.
+[runtime]
+## The number of threads to execute the runtime for global read operations.
+read_rt_size = 8
+## The number of threads to execute the runtime for global write operations.
+write_rt_size = 8
+## The number of threads to execute the runtime for global background operations.
+bg_rt_size = 4
+
 ## Procedure storage options.
 [procedure]
 
@@ -45,7 +54,7 @@ max_metadata_value_size = "1500KiB"
 [failure_detector]
 threshold = 8.0
 min_std_deviation = "100ms"
-acceptable_heartbeat_pause = "3000ms"
+acceptable_heartbeat_pause = "10000ms"
 first_heartbeat_estimate = "1000ms"
 
 ## Datanode options.

config/standalone.example.toml

@@ -8,14 +8,24 @@ enable_telemetry = true
 ## +toml2docs:none-default
 default_timezone = "UTC"
 
+## The runtime options.
+[runtime]
+## The number of threads to execute the runtime for global read operations.
+read_rt_size = 8
+## The number of threads to execute the runtime for global write operations.
+write_rt_size = 8
+## The number of threads to execute the runtime for global background operations.
+bg_rt_size = 4
+
 ## The HTTP server options.
 [http]
 ## The address to bind the HTTP server.
 addr = "127.0.0.1:4000"
-## HTTP request timeout.
+## HTTP request timeout. Set to 0 to disable timeout.
 timeout = "30s"
 ## HTTP request body limit.
-## Support the following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.
+## The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.
+## Set to 0 to disable limit.
 body_limit = "64MB"
 
 ## The gRPC server options.
@@ -166,11 +176,7 @@ 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"
+max_batch_bytes = "1MB"
 
 ## The consumer wait timeout.
 ## **It's only used when the provider is `kafka`**.
@@ -411,31 +417,72 @@ parallel_scan_channel_size = 32
 ## Whether to allow stale WAL entries read during replay.
 allow_stale_entries = false
 
+## The options for index in Mito engine.
+[region_engine.mito.index]
+
+## Auxiliary directory path for the index in filesystem, used to store intermediate files for
+## creating the index and staging files for searching the index, defaults to `{data_home}/index_intermediate`.
+## The default name for this directory is `index_intermediate` for backward compatibility.
+##
+## This path contains two subdirectories:
+## - `__intm`: for storing intermediate files used during creating index.
+## - `staging`: for storing staging files used during searching index.
+aux_path = ""
+
+## The max capacity of the staging directory.
+staging_size = "2GB"
+
 ## The options for inverted index in Mito engine.
 [region_engine.mito.inverted_index]
 
 ## Whether to create the index on flush.
-## - `auto`: automatically
+## - `auto`: automatically (default)
 ## - `disable`: never
 create_on_flush = "auto"
 
 ## Whether to create the index on compaction.
-## - `auto`: automatically
+## - `auto`: automatically (default)
 ## - `disable`: never
 create_on_compaction = "auto"
 
 ## Whether to apply the index on query
-## - `auto`: automatically
+## - `auto`: automatically (default)
 ## - `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"
+## - `auto`: automatically determine the threshold based on the system memory size (default)
+## - `unlimited`: no memory limit
+## - `[size]` e.g. `64MB`: fixed memory threshold
+mem_threshold_on_create = "auto"
 
-## File system path to store intermediate files for external sorting (default `{data_home}/index_intermediate`).
+## Deprecated, use `region_engine.mito.index.aux_path` instead.
 intermediate_path = ""
 
+## The options for full-text index in Mito engine.
+[region_engine.mito.fulltext_index]
+
+## Whether to create the index on flush.
+## - `auto`: automatically (default)
+## - `disable`: never
+create_on_flush = "auto"
+
+## Whether to create the index on compaction.
+## - `auto`: automatically (default)
+## - `disable`: never
+create_on_compaction = "auto"
+
+## Whether to apply the index on query
+## - `auto`: automatically (default)
+## - `disable`: never
+apply_on_query = "auto"
+
+## Memory threshold for index creation.
+## - `auto`: automatically determine the threshold based on the system memory size (default)
+## - `unlimited`: no memory limit
+## - `[size]` e.g. `64MB`: fixed memory threshold
+mem_threshold_on_create = "auto"
+
 [region_engine.mito.memtable]
 ## Memtable type.
 ## - `time_series`: time-series memtable

docker/ci/centos/Dockerfile

@@ -1,5 +1,9 @@
 FROM centos:7
 
+# Note: CentOS 7 has reached EOL since 2024-07-01 thus `mirror.centos.org` is no longer available and we need to use `vault.centos.org` instead.
+RUN sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/*.repo
+RUN sed -i s/^#.*baseurl=http/baseurl=http/g /etc/yum.repos.d/*.repo
+
 RUN yum install -y epel-release \
     openssl \
     openssl-devel  \

docker/dev-builder/centos/Dockerfile

@@ -2,6 +2,10 @@ FROM centos:7 as builder
 
 ENV LANG en_US.utf8
 
+# Note: CentOS 7 has reached EOL since 2024-07-01 thus `mirror.centos.org` is no longer available and we need to use `vault.centos.org` instead.
+RUN sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/*.repo
+RUN sed -i s/^#.*baseurl=http/baseurl=http/g /etc/yum.repos.d/*.repo
+
 # Install dependencies
 RUN ulimit -n 1024000 && yum groupinstall -y 'Development Tools'
 RUN yum install -y epel-release  \
@@ -25,6 +29,10 @@ ENV PATH /opt/rh/rh-python38/root/usr/bin:/usr/local/bin:/root/.cargo/bin/:$PATH
 ARG RUST_TOOLCHAIN
 RUN rustup toolchain install ${RUST_TOOLCHAIN}
 
+
+# Install cargo-binstall with a specific version to adapt the current rust toolchain.
+# Note: if we use the latest version, we may encounter the following `use of unstable library feature 'io_error_downcast'` error.
+RUN cargo install cargo-binstall --version 1.6.6 --locked
+
 # Install nextest.
-RUN cargo install cargo-binstall --locked
 RUN cargo binstall cargo-nextest --no-confirm

docker/dev-builder/ubuntu/Dockerfile

@@ -55,6 +55,9 @@ ENV PATH /root/.cargo/bin/:$PATH
 ARG RUST_TOOLCHAIN
 RUN rustup toolchain install ${RUST_TOOLCHAIN}
 
+# Install cargo-binstall with a specific version to adapt the current rust toolchain.
+# Note: if we use the latest version, we may encounter the following `use of unstable library feature 'io_error_downcast'` error.
+RUN cargo install cargo-binstall --version 1.6.6 --locked
+
 # Install nextest.
-RUN cargo install cargo-binstall --locked
 RUN cargo binstall cargo-nextest --no-confirm

docker/dev-builder/ubuntu/Dockerfile-18.10

@@ -43,6 +43,9 @@ ENV PATH /root/.cargo/bin/:$PATH
 ARG RUST_TOOLCHAIN
 RUN rustup toolchain install ${RUST_TOOLCHAIN}
 
+# Install cargo-binstall with a specific version to adapt the current rust toolchain.
+# Note: if we use the latest version, we may encounter the following `use of unstable library feature 'io_error_downcast'` error.
+RUN cargo install cargo-binstall --version 1.6.6 --locked
+
 # Install nextest.
-RUN cargo install cargo-binstall --locked
 RUN cargo binstall cargo-nextest --no-confirm

docker/docker-compose/cluster-with-etcd.yaml

@@ -0,0 +1,102 @@
+x-custom:
+  initial_cluster_token: &initial_cluster_token "--initial-cluster-token=etcd-cluster"
+  common_settings: &common_settings
+    image: quay.io/coreos/etcd:v3.5.10
+    entrypoint: /usr/local/bin/etcd
+
+services:
+  etcd0:
+    <<: *common_settings
+    container_name: etcd0
+    ports:
+      - 2379:2379
+      - 2380:2380
+    command:
+      - --name=etcd0
+      - --data-dir=/var/lib/etcd
+      - --initial-advertise-peer-urls=http://etcd0:2380
+      - --listen-peer-urls=http://0.0.0.0:2380
+      - --listen-client-urls=http://0.0.0.0:2379
+      - --advertise-client-urls=http://etcd0:2379
+      - --heartbeat-interval=250
+      - --election-timeout=1250
+      - --initial-cluster=etcd0=http://etcd0:2380
+      - --initial-cluster-state=new
+      - *initial_cluster_token
+    volumes:
+      - /tmp/greptimedb-cluster-docker-compose/etcd0:/var/lib/etcd
+    healthcheck:
+      test: [ "CMD", "etcdctl", "--endpoints=http://etcd0:2379", "endpoint", "health" ]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+    networks:
+      - greptimedb
+
+  metasrv:
+    image: docker.io/greptime/greptimedb:latest
+    container_name: metasrv
+    ports:
+      - 3002:3002
+    command:
+      - metasrv
+      - start
+      - --bind-addr=0.0.0.0:3002
+      - --server-addr=metasrv:3002
+      - --store-addrs=etcd0:2379
+    healthcheck:
+      test: [ "CMD", "curl", "-f", "http://metasrv:3002/health" ]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+    depends_on:
+      etcd0:
+        condition: service_healthy
+    networks:
+      - greptimedb
+
+  datanode0:
+    image: docker.io/greptime/greptimedb:latest
+    container_name: datanode0
+    ports:
+      - 3001:3001
+    command:
+      - datanode
+      - start
+      - --node-id=0
+      - --rpc-addr=0.0.0.0:3001
+      - --rpc-hostname=datanode0:3001
+      - --metasrv-addrs=metasrv:3002
+    volumes:
+      - /tmp/greptimedb-cluster-docker-compose/datanode0:/tmp/greptimedb
+    depends_on:
+      metasrv:
+        condition: service_healthy
+    networks:
+      - greptimedb
+
+  frontend0:
+    image: docker.io/greptime/greptimedb:latest
+    container_name: frontend0
+    ports:
+      - 4000:4000
+      - 4001:4001
+      - 4002:4002
+      - 4003:4003
+    command:
+      - frontend
+      - start
+      - --metasrv-addrs=metasrv:3002
+      - --http-addr=0.0.0.0:4000
+      - --rpc-addr=0.0.0.0:4001
+      - --mysql-addr=0.0.0.0:4002
+      - --postgres-addr=0.0.0.0:4003
+    depends_on:
+      metasrv:
+        condition: service_healthy
+    networks:
+      - greptimedb
+
+networks:
+  greptimedb:
+    name: greptimedb

docs/benchmarks/tsbs/README.md

@@ -0,0 +1,253 @@
+# How to run TSBS Benchmark
+
+This document contains the steps to run TSBS Benchmark. Our results are listed in other files in the same directory.
+
+## Prerequires
+
+You need the following tools to run TSBS Benchmark:
+- Go
+- git
+- make
+- rust (optional, if you want to build the DB from source)
+
+## Build TSBS suite
+
+Clone our fork of TSBS:
+
+```shell
+git clone https://github.com/GreptimeTeam/tsbs.git
+```
+
+Then build it:
+
+```shell
+cd tsbs
+make
+```
+
+You can check the `bin/` directory for compiled binaries. We will only use some of them.
+
+```shell
+ls ./bin/
+```
+
+Binaries we will use later:
+- `tsbs_generate_data`
+- `tsbs_generate_queries`
+- `tsbs_load_greptime`
+- `tsbs_run_queries_influx`
+
+## Generate test data and queries
+
+The data is generated by `tsbs_generate_data`
+
+```shell
+mkdir bench-data
+./bin/tsbs_generate_data --use-case="cpu-only" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:00Z" \
+    --log-interval="10s" --format="influx" \
+    > ./bench-data/influx-data.lp
+```
+
+Here we generates 4000 time-series in 3 days with 10s interval. We'll use influx line protocol to write so the target format is `influx`.
+
+Queries are generated by `tsbs_generate_queries`. You can change the parameters but need to make sure it matches with `tsbs_generate_data`.
+
+```shell
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=100 \
+    --query-type cpu-max-all-1 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-cpu-max-all-1.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=100 \
+    --query-type cpu-max-all-8 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-cpu-max-all-8.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=50 \
+    --query-type double-groupby-1 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-double-groupby-1.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=50 \
+    --query-type double-groupby-5 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-double-groupby-5.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=50 \
+    --query-type double-groupby-all \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-double-groupby-all.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=50 \
+    --query-type groupby-orderby-limit \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-groupby-orderby-limit.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=100 \
+    --query-type high-cpu-1 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-high-cpu-1.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=50 \
+    --query-type high-cpu-all \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-high-cpu-all.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=10 \
+    --query-type lastpoint \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-lastpoint.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=100 \
+    --query-type single-groupby-1-1-1 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-single-groupby-1-1-1.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=100 \
+    --query-type single-groupby-1-1-12 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-single-groupby-1-1-12.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=100 \
+    --query-type single-groupby-1-8-1 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-single-groupby-1-8-1.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=100 \
+    --query-type single-groupby-5-1-1 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-single-groupby-5-1-1.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=100 \
+    --query-type single-groupby-5-1-12 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-single-groupby-5-1-12.dat
+./bin/tsbs_generate_queries \
+    --use-case="devops" --seed=123 --scale=4000 \
+    --timestamp-start="2023-06-11T00:00:00Z" \
+    --timestamp-end="2023-06-14T00:00:01Z" \
+    --queries=100 \
+    --query-type single-groupby-5-8-1 \
+    --format="greptime" \
+    > ./bench-data/greptime-queries-single-groupby-5-8-1.dat
+```
+
+## Start GreptimeDB
+
+Reference to our [document](https://docs.greptime.com/getting-started/installation/overview) for how to install and start a GreptimeDB. Or you can also check this [document](https://docs.greptime.com/contributor-guide/getting-started#compile-and-run) for how to build a GreptimeDB from source.
+
+## Write Data
+
+After the DB is started, we can use `tsbs_load_greptime` to test the write performance.
+
+```shell
+./bin/tsbs_load_greptime \
+    --urls=http://localhost:4000 \
+    --file=./bench-data/influx-data.lp \
+    --batch-size=3000 \
+    --gzip=false \
+    --workers=6
+```
+
+Parameters here are only provided as an example. You can choose whatever you like or adjust them to match your target scenario.
+
+Notice that if you want to rerun `tsbs_load_greptime`, please destroy and restart the DB and clear its previous data first. Existing duplicated data will impact the write and query performance.
+
+## Query Data
+
+After the data is imported, you can then run queries. The following script runs all queries. You can also choose a subset of queries to run.
+
+```shell
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-cpu-max-all-1.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-cpu-max-all-8.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-double-groupby-1.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-double-groupby-5.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-double-groupby-all.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-groupby-orderby-limit.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-high-cpu-1.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-high-cpu-all.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-lastpoint.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-single-groupby-1-1-1.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-single-groupby-1-1-12.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-single-groupby-1-8-1.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-single-groupby-5-1-1.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-single-groupby-5-1-12.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+./bin/tsbs_run_queries_influx --file=./bench-data/greptime-queries-single-groupby-5-8-1.dat \
+    --db-name=benchmark \
+    --urls="http://localhost:4000"
+```
+
+Rerun queries need not to re-import data. Just execute the corresponding command again is fine.

docs/schema-structs.md

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

src/api/Cargo.toml

@@ -17,10 +17,11 @@ datatypes.workspace = true
 greptime-proto.workspace = true
 paste = "1.0"
 prost.workspace = true
+serde_json.workspace = true
 snafu.workspace = true
 
 [build-dependencies]
-tonic-build = "0.9"
+tonic-build = "0.11"
 
 [dev-dependencies]
 paste = "1.0"

src/api/src/error.rs

@@ -58,13 +58,23 @@ pub enum Error {
         location: Location,
         source: datatypes::error::Error,
     },
+
+    #[snafu(display("Failed to serialize JSON"))]
+    SerializeJson {
+        #[snafu(source)]
+        error: serde_json::Error,
+        #[snafu(implicit)]
+        location: Location,
+    },
 }
 
 impl ErrorExt for Error {
     fn status_code(&self) -> StatusCode {
         match self {
             Error::UnknownColumnDataType { .. } => StatusCode::InvalidArguments,
-            Error::IntoColumnDataType { .. } => StatusCode::Unexpected,
+            Error::IntoColumnDataType { .. } | Error::SerializeJson { .. } => {
+                StatusCode::Unexpected
+            }
             Error::ConvertColumnDefaultConstraint { source, .. }
             | Error::InvalidColumnDefaultConstraint { source, .. } => source.status_code(),
         }

src/api/src/helper.rs

@@ -1843,6 +1843,7 @@ mod tests {
             null_mask: vec![2],
             datatype: ColumnDataType::Boolean as i32,
             datatype_extension: None,
+            options: None,
         };
         assert!(is_column_type_value_eq(
             column1.datatype,

src/api/src/lib.rs

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#![feature(let_chains)]
+
 pub mod error;
 pub mod helper;
 

src/api/src/v1/column_def.rs

@@ -14,13 +14,19 @@
 
 use std::collections::HashMap;
 
-use datatypes::schema::{ColumnDefaultConstraint, ColumnSchema, COMMENT_KEY};
+use datatypes::schema::{
+    ColumnDefaultConstraint, ColumnSchema, FulltextOptions, COMMENT_KEY, FULLTEXT_KEY,
+};
 use snafu::ResultExt;
 
 use crate::error::{self, Result};
 use crate::helper::ColumnDataTypeWrapper;
-use crate::v1::ColumnDef;
+use crate::v1::{ColumnDef, ColumnOptions, SemanticType};
 
+/// Key used to store fulltext options in gRPC column options.
+const FULLTEXT_GRPC_KEY: &str = "fulltext";
+
+/// Tries to construct a `ColumnSchema` from the given  `ColumnDef`.
 pub fn try_as_column_schema(column_def: &ColumnDef) -> Result<ColumnSchema> {
     let data_type = ColumnDataTypeWrapper::try_new(
         column_def.data_type,
@@ -43,13 +49,147 @@ pub fn try_as_column_schema(column_def: &ColumnDef) -> Result<ColumnSchema> {
     if !column_def.comment.is_empty() {
         metadata.insert(COMMENT_KEY.to_string(), column_def.comment.clone());
     }
+    if let Some(options) = column_def.options.as_ref()
+        && let Some(fulltext) = options.options.get(FULLTEXT_GRPC_KEY)
+    {
+        metadata.insert(FULLTEXT_KEY.to_string(), fulltext.to_string());
+    }
 
-    Ok(
-        ColumnSchema::new(&column_def.name, data_type.into(), column_def.is_nullable)
-            .with_default_constraint(constraint)
-            .context(error::InvalidColumnDefaultConstraintSnafu {
-                column: &column_def.name,
-            })?
-            .with_metadata(metadata),
-    )
+    ColumnSchema::new(&column_def.name, data_type.into(), column_def.is_nullable)
+        .with_metadata(metadata)
+        .with_time_index(column_def.semantic_type() == SemanticType::Timestamp)
+        .with_default_constraint(constraint)
+        .context(error::InvalidColumnDefaultConstraintSnafu {
+            column: &column_def.name,
+        })
+}
+
+/// Constructs a `ColumnOptions` from the given `ColumnSchema`.
+pub fn options_from_column_schema(column_schema: &ColumnSchema) -> Option<ColumnOptions> {
+    let mut options = ColumnOptions::default();
+    if let Some(fulltext) = column_schema.metadata().get(FULLTEXT_KEY) {
+        options
+            .options
+            .insert(FULLTEXT_GRPC_KEY.to_string(), fulltext.to_string());
+    }
+
+    (!options.options.is_empty()).then_some(options)
+}
+
+/// Checks if the `ColumnOptions` contains fulltext options.
+pub fn contains_fulltext(options: &Option<ColumnOptions>) -> bool {
+    options
+        .as_ref()
+        .map_or(false, |o| o.options.contains_key(FULLTEXT_GRPC_KEY))
+}
+
+/// Tries to construct a `ColumnOptions` from the given `FulltextOptions`.
+pub fn options_from_fulltext(fulltext: &FulltextOptions) -> Result<Option<ColumnOptions>> {
+    let mut options = ColumnOptions::default();
+
+    let v = serde_json::to_string(fulltext).context(error::SerializeJsonSnafu)?;
+    options.options.insert(FULLTEXT_GRPC_KEY.to_string(), v);
+
+    Ok((!options.options.is_empty()).then_some(options))
+}
+
+#[cfg(test)]
+mod tests {
+
+    use datatypes::data_type::ConcreteDataType;
+    use datatypes::schema::FulltextAnalyzer;
+
+    use super::*;
+    use crate::v1::ColumnDataType;
+
+    #[test]
+    fn test_try_as_column_schema() {
+        let column_def = ColumnDef {
+            name: "test".to_string(),
+            data_type: ColumnDataType::String as i32,
+            is_nullable: true,
+            default_constraint: ColumnDefaultConstraint::Value("test_default".into())
+                .try_into()
+                .unwrap(),
+            semantic_type: SemanticType::Field as i32,
+            comment: "test_comment".to_string(),
+            datatype_extension: None,
+            options: Some(ColumnOptions {
+                options: HashMap::from([(
+                    FULLTEXT_GRPC_KEY.to_string(),
+                    "{\"enable\":true}".to_string(),
+                )]),
+            }),
+        };
+
+        let schema = try_as_column_schema(&column_def).unwrap();
+        assert_eq!(schema.name, "test");
+        assert_eq!(schema.data_type, ConcreteDataType::string_datatype());
+        assert!(!schema.is_time_index());
+        assert!(schema.is_nullable());
+        assert_eq!(
+            schema.default_constraint().unwrap(),
+            &ColumnDefaultConstraint::Value("test_default".into())
+        );
+        assert_eq!(schema.metadata().get(COMMENT_KEY).unwrap(), "test_comment");
+        assert_eq!(
+            schema.fulltext_options().unwrap().unwrap(),
+            FulltextOptions {
+                enable: true,
+                ..Default::default()
+            }
+        );
+    }
+
+    #[test]
+    fn test_options_from_column_schema() {
+        let schema = ColumnSchema::new("test", ConcreteDataType::string_datatype(), true);
+        let options = options_from_column_schema(&schema);
+        assert!(options.is_none());
+
+        let schema = ColumnSchema::new("test", ConcreteDataType::string_datatype(), true)
+            .with_fulltext_options(FulltextOptions {
+                enable: true,
+                analyzer: FulltextAnalyzer::English,
+                case_sensitive: false,
+            })
+            .unwrap();
+        let options = options_from_column_schema(&schema).unwrap();
+        assert_eq!(
+            options.options.get(FULLTEXT_GRPC_KEY).unwrap(),
+            "{\"enable\":true,\"analyzer\":\"English\",\"case-sensitive\":false}"
+        );
+    }
+
+    #[test]
+    fn test_options_with_fulltext() {
+        let fulltext = FulltextOptions {
+            enable: true,
+            analyzer: FulltextAnalyzer::English,
+            case_sensitive: false,
+        };
+        let options = options_from_fulltext(&fulltext).unwrap().unwrap();
+        assert_eq!(
+            options.options.get(FULLTEXT_GRPC_KEY).unwrap(),
+            "{\"enable\":true,\"analyzer\":\"English\",\"case-sensitive\":false}"
+        );
+    }
+
+    #[test]
+    fn test_contains_fulltext() {
+        let options = ColumnOptions {
+            options: HashMap::from([(
+                FULLTEXT_GRPC_KEY.to_string(),
+                "{\"enable\":true}".to_string(),
+            )]),
+        };
+        assert!(contains_fulltext(&Some(options)));
+
+        let options = ColumnOptions {
+            options: HashMap::new(),
+        };
+        assert!(!contains_fulltext(&Some(options)));
+
+        assert!(!contains_fulltext(&None));
+    }
 }

src/auth/src/permission.rs

@@ -30,6 +30,7 @@ pub enum PermissionReq<'a> {
     PromStoreWrite,
     PromStoreRead,
     Otlp,
+    LogWrite,
 }
 
 #[derive(Debug)]
@@ -41,7 +42,7 @@ pub enum PermissionResp {
 pub trait PermissionChecker: Send + Sync {
     fn check_permission(
         &self,
-        user_info: Option<UserInfoRef>,
+        user_info: UserInfoRef,
         req: PermissionReq,
     ) -> Result<PermissionResp>;
 }
@@ -49,7 +50,7 @@ pub trait PermissionChecker: Send + Sync {
 impl PermissionChecker for Option<&PermissionCheckerRef> {
     fn check_permission(
         &self,
-        user_info: Option<UserInfoRef>,
+        user_info: UserInfoRef,
         req: PermissionReq,
     ) -> Result<PermissionResp> {
         match self {

src/auth/tests/mod.rs

@@ -27,7 +27,7 @@ struct DummyPermissionChecker;
 impl PermissionChecker for DummyPermissionChecker {
     fn check_permission(
         &self,
-        _user_info: Option<UserInfoRef>,
+        _user_info: UserInfoRef,
         req: PermissionReq,
     ) -> auth::error::Result<PermissionResp> {
         match req {
@@ -45,17 +45,21 @@ fn test_permission_checker() {
     let checker: PermissionCheckerRef = Arc::new(DummyPermissionChecker);
 
     let grpc_result = checker.check_permission(
-        None,
+        auth::userinfo_by_name(None),
         PermissionReq::GrpcRequest(&Request::Query(Default::default())),
     );
     assert_matches!(grpc_result, Ok(PermissionResp::Allow));
 
     let sql_result = checker.check_permission(
-        None,
-        PermissionReq::SqlStatement(&Statement::ShowDatabases(ShowDatabases::new(ShowKind::All))),
+        auth::userinfo_by_name(None),
+        PermissionReq::SqlStatement(&Statement::ShowDatabases(ShowDatabases::new(
+            ShowKind::All,
+            false,
+        ))),
     );
     assert_matches!(sql_result, Ok(PermissionResp::Reject));
 
-    let err_result = checker.check_permission(None, PermissionReq::Opentsdb);
+    let err_result =
+        checker.check_permission(auth::userinfo_by_name(None), PermissionReq::Opentsdb);
     assert_matches!(err_result, Err(InternalState { msg }) if msg == "testing");
 }

src/cache/Cargo.toml

@@ -11,3 +11,4 @@ common-macro.workspace = true
 common-meta.workspace = true
 moka.workspace = true
 snafu.workspace = true
+substrait.workspace = true

src/cache/src/lib.rs

@@ -20,7 +20,8 @@ use std::time::Duration;
 use catalog::kvbackend::new_table_cache;
 use common_meta::cache::{
     new_table_flownode_set_cache, new_table_info_cache, new_table_name_cache,
-    new_table_route_cache, CacheRegistry, CacheRegistryBuilder, LayeredCacheRegistryBuilder,
+    new_table_route_cache, new_view_info_cache, CacheRegistry, CacheRegistryBuilder,
+    LayeredCacheRegistryBuilder,
 };
 use common_meta::kv_backend::KvBackendRef;
 use moka::future::CacheBuilder;
@@ -33,6 +34,7 @@ const DEFAULT_CACHE_TTL: Duration = Duration::from_secs(10 * 60);
 const DEFAULT_CACHE_TTI: Duration = Duration::from_secs(5 * 60);
 
 pub const TABLE_INFO_CACHE_NAME: &str = "table_info_cache";
+pub const VIEW_INFO_CACHE_NAME: &str = "view_info_cache";
 pub const TABLE_NAME_CACHE_NAME: &str = "table_name_cache";
 pub const TABLE_CACHE_NAME: &str = "table_cache";
 pub const TABLE_FLOWNODE_SET_CACHE_NAME: &str = "table_flownode_set_cache";
@@ -82,11 +84,22 @@ pub fn build_fundamental_cache_registry(kv_backend: KvBackendRef) -> CacheRegist
         cache,
         kv_backend.clone(),
     ));
+    // Builds the view info cache
+    let cache = CacheBuilder::new(DEFAULT_CACHE_MAX_CAPACITY)
+        .time_to_live(DEFAULT_CACHE_TTL)
+        .time_to_idle(DEFAULT_CACHE_TTI)
+        .build();
+    let view_info_cache = Arc::new(new_view_info_cache(
+        VIEW_INFO_CACHE_NAME.to_string(),
+        cache,
+        kv_backend.clone(),
+    ));
 
     CacheRegistryBuilder::default()
         .add_cache(table_info_cache)
         .add_cache(table_name_cache)
         .add_cache(table_route_cache)
+        .add_cache(view_info_cache)
         .add_cache(table_flownode_set_cache)
         .build()
 }

src/catalog/Cargo.toml

@@ -16,6 +16,7 @@ arrow.workspace = true
 arrow-schema.workspace = true
 async-stream.workspace = true
 async-trait = "0.1"
+bytes.workspace = true
 common-catalog.workspace = true
 common-config.workspace = true
 common-error.workspace = true
@@ -48,8 +49,11 @@ table.workspace = true
 tokio.workspace = true
 
 [dev-dependencies]
+cache.workspace = true
 catalog = { workspace = true, features = ["testing"] }
 chrono.workspace = true
+common-meta = { workspace = true, features = ["testing"] }
+common-query = { workspace = true, features = ["testing"] }
 common-test-util.workspace = true
 log-store.workspace = true
 object-store.workspace = true

src/catalog/src/error.rs

@@ -19,10 +19,7 @@ use common_error::ext::{BoxedError, ErrorExt};
 use common_error::status_code::StatusCode;
 use common_macro::stack_trace_debug;
 use datafusion::error::DataFusionError;
-use datatypes::prelude::ConcreteDataType;
 use snafu::{Location, Snafu};
-use table::metadata::TableId;
-use tokio::task::JoinError;
 
 #[derive(Snafu)]
 #[snafu(visibility(pub))]
@@ -65,19 +62,6 @@ pub enum Error {
         location: Location,
         source: BoxedError,
     },
-    #[snafu(display("Failed to open system catalog table"))]
-    OpenSystemCatalog {
-        #[snafu(implicit)]
-        location: Location,
-        source: table::error::Error,
-    },
-
-    #[snafu(display("Failed to create system catalog table"))]
-    CreateSystemCatalog {
-        #[snafu(implicit)]
-        location: Location,
-        source: table::error::Error,
-    },
 
     #[snafu(display("Failed to create table, table info: {}", table_info))]
     CreateTable {
@@ -94,52 +78,6 @@ pub enum Error {
         location: Location,
     },
 
-    #[snafu(display(
-        "System catalog table type mismatch, expected: binary, found: {:?}",
-        data_type,
-    ))]
-    SystemCatalogTypeMismatch {
-        data_type: ConcreteDataType,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
-    #[snafu(display("Invalid system catalog entry type: {:?}", entry_type))]
-    InvalidEntryType {
-        entry_type: Option<u8>,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
-    #[snafu(display("Invalid system catalog key: {:?}", key))]
-    InvalidKey {
-        key: Option<String>,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
-    #[snafu(display("Catalog value is not present"))]
-    EmptyValue {
-        #[snafu(implicit)]
-        location: Location,
-    },
-
-    #[snafu(display("Failed to deserialize value"))]
-    ValueDeserialize {
-        #[snafu(source)]
-        error: serde_json::error::Error,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
-    #[snafu(display("Table engine not found: {}", engine_name))]
-    TableEngineNotFound {
-        engine_name: String,
-        #[snafu(implicit)]
-        location: Location,
-        source: table::error::Error,
-    },
-
     #[snafu(display("Cannot find catalog by name: {}", catalog_name))]
     CatalogNotFound {
         catalog_name: String,
@@ -169,44 +107,9 @@ pub enum Error {
         location: Location,
     },
 
-    #[snafu(display("Schema {} already exists", schema))]
-    SchemaExists {
-        schema: String,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
-    #[snafu(display("Operation {} not implemented yet", operation))]
-    Unimplemented {
-        operation: String,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
-    #[snafu(display("Operation {} not supported", op))]
-    NotSupported {
-        op: String,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
-    #[snafu(display("Failed to open table {table_id}"))]
-    OpenTable {
-        table_id: TableId,
-        #[snafu(implicit)]
-        location: Location,
-        source: table::error::Error,
-    },
-
-    #[snafu(display("Failed to open table in parallel"))]
-    ParallelOpenTable {
-        #[snafu(source)]
-        error: JoinError,
-    },
-
-    #[snafu(display("Table not found while opening table, table info: {}", table_info))]
-    TableNotFound {
-        table_info: String,
+    #[snafu(display("View info not found: {}", name))]
+    ViewInfoNotFound {
+        name: String,
         #[snafu(implicit)]
         location: Location,
     },
@@ -217,13 +120,6 @@ pub enum Error {
     #[snafu(display("Failed to find region routes"))]
     FindRegionRoutes { source: partition::error::Error },
 
-    #[snafu(display("Failed to read system catalog table records"))]
-    ReadSystemCatalog {
-        #[snafu(implicit)]
-        location: Location,
-        source: common_recordbatch::error::Error,
-    },
-
     #[snafu(display("Failed to create recordbatch"))]
     CreateRecordBatch {
         #[snafu(implicit)]
@@ -231,20 +127,6 @@ pub enum Error {
         source: common_recordbatch::error::Error,
     },
 
-    #[snafu(display("Failed to insert table creation record to system catalog"))]
-    InsertCatalogRecord {
-        #[snafu(implicit)]
-        location: Location,
-        source: table::error::Error,
-    },
-
-    #[snafu(display("Failed to scan system catalog table"))]
-    SystemCatalogTableScan {
-        #[snafu(implicit)]
-        location: Location,
-        source: table::error::Error,
-    },
-
     #[snafu(display("Internal error"))]
     Internal {
         #[snafu(implicit)]
@@ -258,20 +140,14 @@ pub enum Error {
         location: Location,
     },
 
-    #[snafu(display("Failed to execute system catalog table scan"))]
-    SystemCatalogTableScanExec {
+    #[snafu(display("Failed to decode logical plan for view: {}", name))]
+    DecodePlan {
+        name: String,
         #[snafu(implicit)]
         location: Location,
         source: common_query::error::Error,
     },
 
-    #[snafu(display("Cannot parse catalog value"))]
-    InvalidCatalogValue {
-        #[snafu(implicit)]
-        location: Location,
-        source: common_catalog::error::Error,
-    },
-
     #[snafu(display("Failed to perform metasrv operation"))]
     Metasrv {
         #[snafu(implicit)]
@@ -297,20 +173,6 @@ pub enum Error {
         location: Location,
     },
 
-    #[snafu(display("Table schema mismatch"))]
-    TableSchemaMismatch {
-        #[snafu(implicit)]
-        location: Location,
-        source: table::error::Error,
-    },
-
-    #[snafu(display("A generic error has occurred, msg: {}", msg))]
-    Generic {
-        msg: String,
-        #[snafu(implicit)]
-        location: Location,
-    },
-
     #[snafu(display("Table metadata manager error"))]
     TableMetadataManager {
         source: common_meta::error::Error,
@@ -324,6 +186,26 @@ pub enum Error {
         #[snafu(implicit)]
         location: Location,
     },
+
+    #[snafu(display("Failed to get view info from cache"))]
+    GetViewCache {
+        source: common_meta::error::Error,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("Cache not found: {name}"))]
+    CacheNotFound {
+        name: String,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("Failed to cast the catalog manager"))]
+    CastManager {
+        #[snafu(implicit)]
+        location: Location,
+    },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -331,61 +213,43 @@ pub type Result<T> = std::result::Result<T, Error>;
 impl ErrorExt for Error {
     fn status_code(&self) -> StatusCode {
         match self {
-            Error::InvalidKey { .. }
-            | Error::SchemaNotFound { .. }
+            Error::SchemaNotFound { .. }
             | Error::CatalogNotFound { .. }
             | Error::FindPartitions { .. }
             | Error::FindRegionRoutes { .. }
-            | Error::InvalidEntryType { .. }
-            | Error::ParallelOpenTable { .. } => StatusCode::Unexpected,
+            | Error::CacheNotFound { .. }
+            | Error::CastManager { .. } => StatusCode::Unexpected,
 
-            Error::TableNotFound { .. } => StatusCode::TableNotFound,
+            Error::ViewInfoNotFound { .. } => StatusCode::TableNotFound,
 
-            Error::SystemCatalog { .. }
-            | Error::EmptyValue { .. }
-            | Error::ValueDeserialize { .. } => StatusCode::StorageUnavailable,
+            Error::SystemCatalog { .. } => StatusCode::StorageUnavailable,
 
-            Error::Generic { .. }
-            | Error::SystemCatalogTypeMismatch { .. }
-            | Error::UpgradeWeakCatalogManagerRef { .. } => StatusCode::Internal,
-
-            Error::ReadSystemCatalog { source, .. } | Error::CreateRecordBatch { source, .. } => {
-                source.status_code()
-            }
-            Error::InvalidCatalogValue { source, .. } => source.status_code(),
+            Error::UpgradeWeakCatalogManagerRef { .. } => StatusCode::Internal,
 
+            Error::CreateRecordBatch { source, .. } => source.status_code(),
             Error::TableExists { .. } => StatusCode::TableAlreadyExists,
             Error::TableNotExist { .. } => StatusCode::TableNotFound,
-            Error::SchemaExists { .. } | Error::TableEngineNotFound { .. } => {
-                StatusCode::InvalidArguments
-            }
-
             Error::ListCatalogs { source, .. }
             | Error::ListNodes { source, .. }
             | Error::ListSchemas { source, .. }
             | Error::ListTables { source, .. } => source.status_code(),
 
-            Error::OpenSystemCatalog { source, .. }
-            | Error::CreateSystemCatalog { source, .. }
-            | Error::InsertCatalogRecord { source, .. }
-            | Error::OpenTable { source, .. }
-            | Error::CreateTable { source, .. }
-            | Error::TableSchemaMismatch { source, .. } => source.status_code(),
+            Error::CreateTable { source, .. } => source.status_code(),
 
             Error::Metasrv { source, .. } => source.status_code(),
-            Error::SystemCatalogTableScan { source, .. } => source.status_code(),
-            Error::SystemCatalogTableScanExec { source, .. } => source.status_code(),
+            Error::DecodePlan { source, .. } => source.status_code(),
             Error::InvalidTableInfoInCatalog { source, .. } => source.status_code(),
 
             Error::CompileScriptInternal { source, .. } | Error::Internal { source, .. } => {
                 source.status_code()
             }
 
-            Error::Unimplemented { .. } | Error::NotSupported { .. } => StatusCode::Unsupported,
             Error::QueryAccessDenied { .. } => StatusCode::AccessDenied,
             Error::Datafusion { .. } => StatusCode::EngineExecuteQuery,
             Error::TableMetadataManager { source, .. } => source.status_code(),
-            Error::GetTableCache { .. } => StatusCode::Internal,
+            Error::GetViewCache { source, .. } | Error::GetTableCache { source, .. } => {
+                source.status_code()
+            }
         }
     }
 
@@ -417,11 +281,6 @@ mod tests {
             .status_code()
         );
 
-        assert_eq!(
-            StatusCode::Unexpected,
-            InvalidKeySnafu { key: None }.build().status_code()
-        );
-
         assert_eq!(
             StatusCode::StorageUnavailable,
             Error::SystemCatalog {
@@ -430,19 +289,6 @@ mod tests {
             }
             .status_code()
         );
-
-        assert_eq!(
-            StatusCode::Internal,
-            Error::SystemCatalogTypeMismatch {
-                data_type: ConcreteDataType::binary_datatype(),
-                location: Location::generate(),
-            }
-            .status_code()
-        );
-        assert_eq!(
-            StatusCode::StorageUnavailable,
-            EmptyValueSnafu {}.build().status_code()
-        );
     }
 
     #[test]

src/catalog/src/information_schema/key_column_usage.rs

@@ -27,6 +27,7 @@ use datatypes::prelude::{ConcreteDataType, MutableVector, ScalarVectorBuilder, V
 use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
 use datatypes::value::Value;
 use datatypes::vectors::{ConstantVector, StringVector, StringVectorBuilder, UInt32VectorBuilder};
+use futures_util::TryStreamExt;
 use snafu::{OptionExt, ResultExt};
 use store_api::storage::{ScanRequest, TableId};
 
@@ -211,71 +212,58 @@ impl InformationSchemaKeyColumnUsageBuilder {
             .context(UpgradeWeakCatalogManagerRefSnafu)?;
         let predicates = Predicates::from_scan_request(&request);
 
-        let mut primary_constraints = vec![];
-
         for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            if !catalog_manager
-                .schema_exists(&catalog_name, &schema_name)
-                .await?
-            {
-                continue;
-            }
+            let mut stream = catalog_manager.tables(&catalog_name, &schema_name);
 
-            for table_name in catalog_manager
-                .table_names(&catalog_name, &schema_name)
-                .await?
-            {
-                if let Some(table) = catalog_manager
-                    .table(&catalog_name, &schema_name, &table_name)
-                    .await?
-                {
-                    let keys = &table.table_info().meta.primary_key_indices;
-                    let schema = table.schema();
+            while let Some(table) = stream.try_next().await? {
+                let mut primary_constraints = vec![];
 
-                    for (idx, column) in schema.column_schemas().iter().enumerate() {
-                        if column.is_time_index() {
-                            self.add_key_column_usage(
-                                &predicates,
-                                &schema_name,
-                                TIME_INDEX_CONSTRAINT_NAME,
-                                &catalog_name,
-                                &schema_name,
-                                &table_name,
-                                &column.name,
-                                1, //always 1 for time index
-                            );
-                        }
-                        if keys.contains(&idx) {
-                            primary_constraints.push((
-                                catalog_name.clone(),
-                                schema_name.clone(),
-                                table_name.clone(),
-                                column.name.clone(),
-                            ));
-                        }
-                        // TODO(dimbtp): foreign key constraint not supported yet
+                let table_info = table.table_info();
+                let table_name = &table_info.name;
+                let keys = &table_info.meta.primary_key_indices;
+                let schema = table.schema();
+
+                for (idx, column) in schema.column_schemas().iter().enumerate() {
+                    if column.is_time_index() {
+                        self.add_key_column_usage(
+                            &predicates,
+                            &schema_name,
+                            TIME_INDEX_CONSTRAINT_NAME,
+                            &catalog_name,
+                            &schema_name,
+                            table_name,
+                            &column.name,
+                            1, //always 1 for time index
+                        );
                     }
-                } else {
-                    unreachable!();
+                    if keys.contains(&idx) {
+                        primary_constraints.push((
+                            catalog_name.clone(),
+                            schema_name.clone(),
+                            table_name.to_string(),
+                            column.name.clone(),
+                        ));
+                    }
+                    // TODO(dimbtp): foreign key constraint not supported yet
+                }
+
+                for (i, (catalog_name, schema_name, table_name, column_name)) in
+                    primary_constraints.into_iter().enumerate()
+                {
+                    self.add_key_column_usage(
+                        &predicates,
+                        &schema_name,
+                        PRI_CONSTRAINT_NAME,
+                        &catalog_name,
+                        &schema_name,
+                        &table_name,
+                        &column_name,
+                        i as u32 + 1,
+                    );
                 }
             }
         }
 
-        for (i, (catalog_name, schema_name, table_name, column_name)) in
-            primary_constraints.into_iter().enumerate()
-        {
-            self.add_key_column_usage(
-                &predicates,
-                &schema_name,
-                PRI_CONSTRAINT_NAME,
-                &catalog_name,
-                &schema_name,
-                &table_name,
-                &column_name,
-                i as u32 + 1,
-            );
-        }
-
         self.finish()
     }
 

src/catalog/src/information_schema/region_peers.rs

@@ -31,7 +31,7 @@ use datatypes::value::Value;
 use datatypes::vectors::{Int64VectorBuilder, StringVectorBuilder, UInt64VectorBuilder};
 use futures::{StreamExt, TryStreamExt};
 use snafu::{OptionExt, ResultExt};
-use store_api::storage::{ScanRequest, TableId};
+use store_api::storage::{RegionId, ScanRequest, TableId};
 use table::metadata::TableType;
 
 use super::REGION_PEERS;
@@ -205,8 +205,8 @@ impl InformationSchemaRegionPeersBuilder {
                     table_ids.into_iter().map(|id| (id, vec![])).collect()
                 };
 
-                for routes in table_routes.values() {
-                    self.add_region_peers(&predicates, routes);
+                for (table_id, routes) in table_routes {
+                    self.add_region_peers(&predicates, table_id, &routes);
                 }
             }
         }
@@ -214,9 +214,14 @@ impl InformationSchemaRegionPeersBuilder {
         self.finish()
     }
 
-    fn add_region_peers(&mut self, predicates: &Predicates, routes: &[RegionRoute]) {
+    fn add_region_peers(
+        &mut self,
+        predicates: &Predicates,
+        table_id: TableId,
+        routes: &[RegionRoute],
+    ) {
         for route in routes {
-            let region_id = route.region.id.as_u64();
+            let region_id = RegionId::new(table_id, route.region.id.region_number()).as_u64();
             let peer_id = route.leader_peer.clone().map(|p| p.id);
             let peer_addr = route.leader_peer.clone().map(|p| p.addr);
             let status = if let Some(status) = route.leader_status {

src/catalog/src/information_schema/schemata.rs

@@ -17,6 +17,7 @@ use std::sync::{Arc, Weak};
 use arrow_schema::SchemaRef as ArrowSchemaRef;
 use common_catalog::consts::INFORMATION_SCHEMA_SCHEMATA_TABLE_ID;
 use common_error::ext::BoxedError;
+use common_meta::key::schema_name::SchemaNameKey;
 use common_recordbatch::adapter::RecordBatchStreamAdapter;
 use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
 use datafusion::execution::TaskContext;
@@ -32,15 +33,18 @@ use store_api::storage::{ScanRequest, TableId};
 
 use super::SCHEMATA;
 use crate::error::{
-    CreateRecordBatchSnafu, InternalSnafu, Result, UpgradeWeakCatalogManagerRefSnafu,
+    CreateRecordBatchSnafu, InternalSnafu, Result, TableMetadataManagerSnafu,
+    UpgradeWeakCatalogManagerRefSnafu,
 };
-use crate::information_schema::{InformationTable, Predicates};
+use crate::information_schema::{utils, InformationTable, Predicates};
 use crate::CatalogManager;
 
 pub const CATALOG_NAME: &str = "catalog_name";
 pub const SCHEMA_NAME: &str = "schema_name";
 const DEFAULT_CHARACTER_SET_NAME: &str = "default_character_set_name";
 const DEFAULT_COLLATION_NAME: &str = "default_collation_name";
+/// The database options
+pub const SCHEMA_OPTS: &str = "options";
 const INIT_CAPACITY: usize = 42;
 
 /// The `information_schema.schemata` table implementation.
@@ -74,6 +78,7 @@ impl InformationSchemaSchemata {
                 false,
             ),
             ColumnSchema::new("sql_path", ConcreteDataType::string_datatype(), true),
+            ColumnSchema::new(SCHEMA_OPTS, ConcreteDataType::string_datatype(), true),
         ]))
     }
 
@@ -133,6 +138,7 @@ struct InformationSchemaSchemataBuilder {
     charset_names: StringVectorBuilder,
     collation_names: StringVectorBuilder,
     sql_paths: StringVectorBuilder,
+    schema_options: StringVectorBuilder,
 }
 
 impl InformationSchemaSchemataBuilder {
@@ -150,6 +156,7 @@ impl InformationSchemaSchemataBuilder {
             charset_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
             collation_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
             sql_paths: StringVectorBuilder::with_capacity(INIT_CAPACITY),
+            schema_options: StringVectorBuilder::with_capacity(INIT_CAPACITY),
         }
     }
 
@@ -160,21 +167,47 @@ impl InformationSchemaSchemataBuilder {
             .catalog_manager
             .upgrade()
             .context(UpgradeWeakCatalogManagerRefSnafu)?;
+        let table_metadata_manager = utils::table_meta_manager(&self.catalog_manager)?;
         let predicates = Predicates::from_scan_request(&request);
 
         for schema_name in catalog_manager.schema_names(&catalog_name).await? {
-            self.add_schema(&predicates, &catalog_name, &schema_name);
+            let opts = if let Some(table_metadata_manager) = &table_metadata_manager {
+                table_metadata_manager
+                    .schema_manager()
+                    .get(SchemaNameKey::new(&catalog_name, &schema_name))
+                    .await
+                    .context(TableMetadataManagerSnafu)?
+                    // information_schema is not available from this
+                    // table_metadata_manager and we return None
+                    .map(|schema_opts| format!("{schema_opts}"))
+            } else {
+                None
+            };
+
+            self.add_schema(
+                &predicates,
+                &catalog_name,
+                &schema_name,
+                opts.as_deref().unwrap_or(""),
+            );
         }
 
         self.finish()
     }
 
-    fn add_schema(&mut self, predicates: &Predicates, catalog_name: &str, schema_name: &str) {
+    fn add_schema(
+        &mut self,
+        predicates: &Predicates,
+        catalog_name: &str,
+        schema_name: &str,
+        schema_options: &str,
+    ) {
         let row = [
             (CATALOG_NAME, &Value::from(catalog_name)),
             (SCHEMA_NAME, &Value::from(schema_name)),
             (DEFAULT_CHARACTER_SET_NAME, &Value::from("utf8")),
             (DEFAULT_COLLATION_NAME, &Value::from("utf8_bin")),
+            (SCHEMA_OPTS, &Value::from(schema_options)),
         ];
 
         if !predicates.eval(&row) {
@@ -186,6 +219,7 @@ impl InformationSchemaSchemataBuilder {
         self.charset_names.push(Some("utf8"));
         self.collation_names.push(Some("utf8_bin"));
         self.sql_paths.push(None);
+        self.schema_options.push(Some(schema_options));
     }
 
     fn finish(&mut self) -> Result<RecordBatch> {
@@ -195,6 +229,7 @@ impl InformationSchemaSchemataBuilder {
             Arc::new(self.charset_names.finish()),
             Arc::new(self.collation_names.finish()),
             Arc::new(self.sql_paths.finish()),
+            Arc::new(self.schema_options.finish()),
         ];
         RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
     }

src/catalog/src/information_schema/tables.rs

@@ -26,11 +26,13 @@ use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatc
 use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder, VectorRef};
 use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
 use datatypes::value::Value;
-use datatypes::vectors::{StringVectorBuilder, UInt32VectorBuilder};
+use datatypes::vectors::{
+    DateTimeVectorBuilder, StringVectorBuilder, UInt32VectorBuilder, UInt64VectorBuilder,
+};
 use futures::TryStreamExt;
 use snafu::{OptionExt, ResultExt};
 use store_api::storage::{ScanRequest, TableId};
-use table::metadata::TableType;
+use table::metadata::{TableInfo, TableType};
 
 use super::TABLES;
 use crate::error::{
@@ -43,8 +45,26 @@ pub const TABLE_CATALOG: &str = "table_catalog";
 pub const TABLE_SCHEMA: &str = "table_schema";
 pub const TABLE_NAME: &str = "table_name";
 pub const TABLE_TYPE: &str = "table_type";
+pub const VERSION: &str = "version";
+pub const ROW_FORMAT: &str = "row_format";
+pub const TABLE_ROWS: &str = "table_rows";
+pub const DATA_LENGTH: &str = "data_length";
+pub const INDEX_LENGTH: &str = "index_length";
+pub const MAX_DATA_LENGTH: &str = "max_data_length";
+pub const AVG_ROW_LENGTH: &str = "avg_row_length";
+pub const DATA_FREE: &str = "data_free";
+pub const AUTO_INCREMENT: &str = "auto_increment";
+pub const CREATE_TIME: &str = "create_time";
+pub const UPDATE_TIME: &str = "update_time";
+pub const CHECK_TIME: &str = "check_time";
+pub const TABLE_COLLATION: &str = "table_collation";
+pub const CHECKSUM: &str = "checksum";
+pub const CREATE_OPTIONS: &str = "create_options";
+pub const TABLE_COMMENT: &str = "table_comment";
+pub const MAX_INDEX_LENGTH: &str = "max_index_length";
+pub const TEMPORARY: &str = "temporary";
 const TABLE_ID: &str = "table_id";
-const ENGINE: &str = "engine";
+pub const ENGINE: &str = "engine";
 const INIT_CAPACITY: usize = 42;
 
 pub(super) struct InformationSchemaTables {
@@ -69,7 +89,25 @@ impl InformationSchemaTables {
             ColumnSchema::new(TABLE_NAME, ConcreteDataType::string_datatype(), false),
             ColumnSchema::new(TABLE_TYPE, ConcreteDataType::string_datatype(), false),
             ColumnSchema::new(TABLE_ID, ConcreteDataType::uint32_datatype(), true),
+            ColumnSchema::new(DATA_LENGTH, ConcreteDataType::uint64_datatype(), true),
+            ColumnSchema::new(MAX_DATA_LENGTH, ConcreteDataType::uint64_datatype(), true),
+            ColumnSchema::new(INDEX_LENGTH, ConcreteDataType::uint64_datatype(), true),
+            ColumnSchema::new(MAX_INDEX_LENGTH, ConcreteDataType::uint64_datatype(), true),
+            ColumnSchema::new(AVG_ROW_LENGTH, ConcreteDataType::uint64_datatype(), true),
             ColumnSchema::new(ENGINE, ConcreteDataType::string_datatype(), true),
+            ColumnSchema::new(VERSION, ConcreteDataType::uint64_datatype(), true),
+            ColumnSchema::new(ROW_FORMAT, ConcreteDataType::string_datatype(), true),
+            ColumnSchema::new(TABLE_ROWS, ConcreteDataType::uint64_datatype(), true),
+            ColumnSchema::new(DATA_FREE, ConcreteDataType::uint64_datatype(), true),
+            ColumnSchema::new(AUTO_INCREMENT, ConcreteDataType::uint64_datatype(), true),
+            ColumnSchema::new(CREATE_TIME, ConcreteDataType::datetime_datatype(), true),
+            ColumnSchema::new(UPDATE_TIME, ConcreteDataType::datetime_datatype(), true),
+            ColumnSchema::new(CHECK_TIME, ConcreteDataType::datetime_datatype(), true),
+            ColumnSchema::new(TABLE_COLLATION, ConcreteDataType::string_datatype(), true),
+            ColumnSchema::new(CHECKSUM, ConcreteDataType::uint64_datatype(), true),
+            ColumnSchema::new(CREATE_OPTIONS, ConcreteDataType::string_datatype(), true),
+            ColumnSchema::new(TABLE_COMMENT, ConcreteDataType::string_datatype(), true),
+            ColumnSchema::new(TEMPORARY, ConcreteDataType::string_datatype(), true),
         ]))
     }
 
@@ -105,7 +143,9 @@ impl InformationTable for InformationSchemaTables {
                     .make_tables(Some(request))
                     .await
                     .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
+                    .map_err(|err| {
+                        datafusion::error::DataFusionError::External(format!("{err:?}").into())
+                    })
             }),
         ));
         Ok(Box::pin(
@@ -129,7 +169,25 @@ struct InformationSchemaTablesBuilder {
     table_names: StringVectorBuilder,
     table_types: StringVectorBuilder,
     table_ids: UInt32VectorBuilder,
+    version: UInt64VectorBuilder,
+    row_format: StringVectorBuilder,
+    table_rows: UInt64VectorBuilder,
+    data_length: UInt64VectorBuilder,
+    max_data_length: UInt64VectorBuilder,
+    index_length: UInt64VectorBuilder,
+    avg_row_length: UInt64VectorBuilder,
+    max_index_length: UInt64VectorBuilder,
+    data_free: UInt64VectorBuilder,
+    auto_increment: UInt64VectorBuilder,
+    create_time: DateTimeVectorBuilder,
+    update_time: DateTimeVectorBuilder,
+    check_time: DateTimeVectorBuilder,
+    table_collation: StringVectorBuilder,
+    checksum: UInt64VectorBuilder,
+    create_options: StringVectorBuilder,
+    table_comment: StringVectorBuilder,
     engines: StringVectorBuilder,
+    temporary: StringVectorBuilder,
 }
 
 impl InformationSchemaTablesBuilder {
@@ -147,7 +205,25 @@ impl InformationSchemaTablesBuilder {
             table_names: StringVectorBuilder::with_capacity(INIT_CAPACITY),
             table_types: StringVectorBuilder::with_capacity(INIT_CAPACITY),
             table_ids: UInt32VectorBuilder::with_capacity(INIT_CAPACITY),
+            data_length: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
+            max_data_length: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
+            index_length: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
+            avg_row_length: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
             engines: StringVectorBuilder::with_capacity(INIT_CAPACITY),
+            version: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
+            row_format: StringVectorBuilder::with_capacity(INIT_CAPACITY),
+            table_rows: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
+            max_index_length: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
+            data_free: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
+            auto_increment: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
+            create_time: DateTimeVectorBuilder::with_capacity(INIT_CAPACITY),
+            update_time: DateTimeVectorBuilder::with_capacity(INIT_CAPACITY),
+            check_time: DateTimeVectorBuilder::with_capacity(INIT_CAPACITY),
+            table_collation: StringVectorBuilder::with_capacity(INIT_CAPACITY),
+            checksum: UInt64VectorBuilder::with_capacity(INIT_CAPACITY),
+            create_options: StringVectorBuilder::with_capacity(INIT_CAPACITY),
+            table_comment: StringVectorBuilder::with_capacity(INIT_CAPACITY),
+            temporary: StringVectorBuilder::with_capacity(INIT_CAPACITY),
         }
     }
 
@@ -169,10 +245,8 @@ impl InformationSchemaTablesBuilder {
                     &predicates,
                     &catalog_name,
                     &schema_name,
-                    &table_info.name,
+                    table_info,
                     table.table_type(),
-                    Some(table_info.ident.table_id),
-                    Some(&table_info.meta.engine),
                 );
             }
         }
@@ -186,12 +260,14 @@ impl InformationSchemaTablesBuilder {
         predicates: &Predicates,
         catalog_name: &str,
         schema_name: &str,
-        table_name: &str,
+        table_info: Arc<TableInfo>,
         table_type: TableType,
-        table_id: Option<u32>,
-        engine: Option<&str>,
     ) {
-        let table_type = match table_type {
+        let table_name = table_info.name.as_ref();
+        let table_id = table_info.table_id();
+        let engine = table_info.meta.engine.as_ref();
+
+        let table_type_text = match table_type {
             TableType::Base => "BASE TABLE",
             TableType::View => "VIEW",
             TableType::Temporary => "LOCAL TEMPORARY",
@@ -201,7 +277,7 @@ impl InformationSchemaTablesBuilder {
             (TABLE_CATALOG, &Value::from(catalog_name)),
             (TABLE_SCHEMA, &Value::from(schema_name)),
             (TABLE_NAME, &Value::from(table_name)),
-            (TABLE_TYPE, &Value::from(table_type)),
+            (TABLE_TYPE, &Value::from(table_type_text)),
         ];
 
         if !predicates.eval(&row) {
@@ -211,9 +287,38 @@ impl InformationSchemaTablesBuilder {
         self.catalog_names.push(Some(catalog_name));
         self.schema_names.push(Some(schema_name));
         self.table_names.push(Some(table_name));
-        self.table_types.push(Some(table_type));
-        self.table_ids.push(table_id);
-        self.engines.push(engine);
+        self.table_types.push(Some(table_type_text));
+        self.table_ids.push(Some(table_id));
+        // TODO(sunng87): use real data for these fields
+        self.data_length.push(Some(0));
+        self.max_data_length.push(Some(0));
+        self.index_length.push(Some(0));
+        self.avg_row_length.push(Some(0));
+        self.max_index_length.push(Some(0));
+        self.checksum.push(Some(0));
+        self.table_rows.push(Some(0));
+        self.data_free.push(Some(0));
+        self.auto_increment.push(Some(0));
+        self.row_format.push(Some("Fixed"));
+        self.table_collation.push(None);
+        self.update_time.push(None);
+        self.check_time.push(None);
+
+        // use mariadb default table version number here
+        self.version.push(Some(11));
+        self.table_comment.push(table_info.desc.as_deref());
+        self.create_options
+            .push(Some(table_info.meta.options.to_string().as_ref()));
+        self.create_time
+            .push(Some(table_info.meta.created_on.timestamp_millis().into()));
+
+        self.temporary
+            .push(if matches!(table_type, TableType::Temporary) {
+                Some("Y")
+            } else {
+                Some("N")
+            });
+        self.engines.push(Some(engine));
     }
 
     fn finish(&mut self) -> Result<RecordBatch> {
@@ -223,7 +328,25 @@ impl InformationSchemaTablesBuilder {
             Arc::new(self.table_names.finish()),
             Arc::new(self.table_types.finish()),
             Arc::new(self.table_ids.finish()),
+            Arc::new(self.data_length.finish()),
+            Arc::new(self.max_data_length.finish()),
+            Arc::new(self.index_length.finish()),
+            Arc::new(self.max_index_length.finish()),
+            Arc::new(self.avg_row_length.finish()),
             Arc::new(self.engines.finish()),
+            Arc::new(self.version.finish()),
+            Arc::new(self.row_format.finish()),
+            Arc::new(self.table_rows.finish()),
+            Arc::new(self.data_free.finish()),
+            Arc::new(self.auto_increment.finish()),
+            Arc::new(self.create_time.finish()),
+            Arc::new(self.update_time.finish()),
+            Arc::new(self.check_time.finish()),
+            Arc::new(self.table_collation.finish()),
+            Arc::new(self.checksum.finish()),
+            Arc::new(self.create_options.finish()),
+            Arc::new(self.table_comment.finish()),
+            Arc::new(self.temporary.finish()),
         ];
         RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
     }

src/catalog/src/information_schema/utils.rs

@@ -15,6 +15,7 @@
 use std::sync::{Arc, Weak};
 
 use common_config::Mode;
+use common_meta::key::TableMetadataManagerRef;
 use meta_client::client::MetaClient;
 use snafu::OptionExt;
 
@@ -51,3 +52,17 @@ pub fn meta_client(catalog_manager: &Weak<dyn CatalogManager>) -> Result<Option<
 
     Ok(meta_client)
 }
+
+/// Try to get the `[TableMetadataManagerRef]` from `[CatalogManager]` weak reference.
+pub fn table_meta_manager(
+    catalog_manager: &Weak<dyn CatalogManager>,
+) -> Result<Option<TableMetadataManagerRef>> {
+    let catalog_manager = catalog_manager
+        .upgrade()
+        .context(UpgradeWeakCatalogManagerRefSnafu)?;
+
+    Ok(catalog_manager
+        .as_any()
+        .downcast_ref::<KvBackendCatalogManager>()
+        .map(|manager| manager.table_metadata_manager_ref().clone()))
+}

src/catalog/src/kvbackend/manager.rs

@@ -22,14 +22,13 @@ use common_catalog::consts::{
 };
 use common_config::Mode;
 use common_error::ext::BoxedError;
-use common_meta::cache::TableRouteCacheRef;
+use common_meta::cache::{LayeredCacheRegistryRef, ViewInfoCacheRef};
 use common_meta::key::catalog_name::CatalogNameKey;
 use common_meta::key::schema_name::SchemaNameKey;
 use common_meta::key::table_info::TableInfoValue;
 use common_meta::key::table_name::TableNameKey;
 use common_meta::key::{TableMetadataManager, TableMetadataManagerRef};
 use common_meta::kv_backend::KvBackendRef;
-use common_meta::table_name::TableName;
 use futures_util::stream::BoxStream;
 use futures_util::{StreamExt, TryStreamExt};
 use meta_client::client::MetaClient;
@@ -38,11 +37,12 @@ use partition::manager::{PartitionRuleManager, PartitionRuleManagerRef};
 use snafu::prelude::*;
 use table::dist_table::DistTable;
 use table::table::numbers::{NumbersTable, NUMBERS_TABLE_NAME};
+use table::table_name::TableName;
 use table::TableRef;
 
 use crate::error::{
-    GetTableCacheSnafu, InvalidTableInfoInCatalogSnafu, ListCatalogsSnafu, ListSchemasSnafu,
-    ListTablesSnafu, Result, TableMetadataManagerSnafu,
+    CacheNotFoundSnafu, GetTableCacheSnafu, InvalidTableInfoInCatalogSnafu, ListCatalogsSnafu,
+    ListSchemasSnafu, ListTablesSnafu, Result, TableMetadataManagerSnafu,
 };
 use crate::information_schema::InformationSchemaProvider;
 use crate::kvbackend::TableCacheRef;
@@ -61,25 +61,26 @@ pub struct KvBackendCatalogManager {
     table_metadata_manager: TableMetadataManagerRef,
     /// A sub-CatalogManager that handles system tables
     system_catalog: SystemCatalog,
-    table_cache: TableCacheRef,
+    cache_registry: LayeredCacheRegistryRef,
 }
 
 const CATALOG_CACHE_MAX_CAPACITY: u64 = 128;
 
 impl KvBackendCatalogManager {
-    pub async fn new(
+    pub fn new(
         mode: Mode,
         meta_client: Option<Arc<MetaClient>>,
         backend: KvBackendRef,
-        table_cache: TableCacheRef,
-        table_route_cache: TableRouteCacheRef,
+        cache_registry: LayeredCacheRegistryRef,
     ) -> Arc<Self> {
         Arc::new_cyclic(|me| Self {
             mode,
             meta_client,
             partition_manager: Arc::new(PartitionRuleManager::new(
                 backend.clone(),
-                table_route_cache,
+                cache_registry
+                    .get()
+                    .expect("Failed to get table_route_cache"),
             )),
             table_metadata_manager: Arc::new(TableMetadataManager::new(backend)),
             system_catalog: SystemCatalog {
@@ -90,7 +91,7 @@ impl KvBackendCatalogManager {
                     me.clone(),
                 )),
             },
-            table_cache,
+            cache_registry,
         })
     }
 
@@ -99,6 +100,12 @@ impl KvBackendCatalogManager {
         &self.mode
     }
 
+    pub fn view_info_cache(&self) -> Result<ViewInfoCacheRef> {
+        self.cache_registry.get().context(CacheNotFoundSnafu {
+            name: "view_info_cache",
+        })
+    }
+
     /// Returns the `[MetaClient]`.
     pub fn meta_client(&self) -> Option<Arc<MetaClient>> {
         self.meta_client.clone()
@@ -215,7 +222,11 @@ impl CatalogManager for KvBackendCatalogManager {
             return Ok(Some(table));
         }
 
-        self.table_cache
+        let table_cache: TableCacheRef = self.cache_registry.get().context(CacheNotFoundSnafu {
+            name: "table_cache",
+        })?;
+
+        table_cache
             .get_by_ref(&TableName {
                 catalog_name: catalog_name.to_string(),
                 schema_name: schema_name.to_string(),

src/catalog/src/kvbackend/table_cache.rs

@@ -17,11 +17,11 @@ use std::sync::Arc;
 use common_meta::cache::{CacheContainer, Initializer, TableInfoCacheRef, TableNameCacheRef};
 use common_meta::error::{Result as MetaResult, ValueNotExistSnafu};
 use common_meta::instruction::CacheIdent;
-use common_meta::table_name::TableName;
 use futures::future::BoxFuture;
 use moka::future::Cache;
 use snafu::OptionExt;
 use table::dist_table::DistTable;
+use table::table_name::TableName;
 use table::TableRef;
 
 pub type TableCacheRef = Arc<TableCache>;

src/catalog/src/table_source.rs

@@ -15,15 +15,25 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use bytes::Bytes;
 use common_catalog::format_full_table_name;
+use common_query::logical_plan::SubstraitPlanDecoderRef;
 use datafusion::common::{ResolvedTableReference, TableReference};
-use datafusion::datasource::provider_as_source;
+use datafusion::datasource::view::ViewTable;
+use datafusion::datasource::{provider_as_source, TableProvider};
 use datafusion::logical_expr::TableSource;
 use session::context::QueryContext;
-use snafu::{ensure, OptionExt};
+use snafu::{ensure, OptionExt, ResultExt};
+use table::metadata::TableType;
 use table::table::adapter::DfTableProviderAdapter;
+mod dummy_catalog;
+use dummy_catalog::DummyCatalogList;
 
-use crate::error::{QueryAccessDeniedSnafu, Result, TableNotExistSnafu};
+use crate::error::{
+    CastManagerSnafu, DatafusionSnafu, DecodePlanSnafu, GetViewCacheSnafu, QueryAccessDeniedSnafu,
+    Result, TableNotExistSnafu, ViewInfoNotFoundSnafu,
+};
+use crate::kvbackend::KvBackendCatalogManager;
 use crate::CatalogManagerRef;
 
 pub struct DfTableSourceProvider {
@@ -32,6 +42,7 @@ pub struct DfTableSourceProvider {
     disallow_cross_catalog_query: bool,
     default_catalog: String,
     default_schema: String,
+    plan_decoder: SubstraitPlanDecoderRef,
 }
 
 impl DfTableSourceProvider {
@@ -39,13 +50,15 @@ impl DfTableSourceProvider {
         catalog_manager: CatalogManagerRef,
         disallow_cross_catalog_query: bool,
         query_ctx: &QueryContext,
+        plan_decoder: SubstraitPlanDecoderRef,
     ) -> Self {
         Self {
             catalog_manager,
             disallow_cross_catalog_query,
             resolved_tables: HashMap::new(),
             default_catalog: query_ctx.current_catalog().to_owned(),
-            default_schema: query_ctx.current_schema().to_owned(),
+            default_schema: query_ctx.current_schema(),
+            plan_decoder,
         }
     }
 
@@ -94,8 +107,39 @@ impl DfTableSourceProvider {
                 table: format_full_table_name(catalog_name, schema_name, table_name),
             })?;
 
-        let provider = DfTableProviderAdapter::new(table);
-        let source = provider_as_source(Arc::new(provider));
+        let provider: Arc<dyn TableProvider> = if table.table_info().table_type == TableType::View {
+            let catalog_manager = self
+                .catalog_manager
+                .as_any()
+                .downcast_ref::<KvBackendCatalogManager>()
+                .context(CastManagerSnafu)?;
+
+            let view_info = catalog_manager
+                .view_info_cache()?
+                .get(table.table_info().ident.table_id)
+                .await
+                .context(GetViewCacheSnafu)?
+                .context(ViewInfoNotFoundSnafu {
+                    name: &table.table_info().name,
+                })?;
+
+            // Build the catalog list provider for deserialization.
+            let catalog_list = Arc::new(DummyCatalogList::new(self.catalog_manager.clone()));
+            let logical_plan = self
+                .plan_decoder
+                .decode(Bytes::from(view_info.view_info.clone()), catalog_list, true)
+                .await
+                .context(DecodePlanSnafu {
+                    name: &table.table_info().name,
+                })?;
+
+            Arc::new(ViewTable::try_new(logical_plan, None).context(DatafusionSnafu)?)
+        } else {
+            Arc::new(DfTableProviderAdapter::new(table))
+        };
+
+        let source = provider_as_source(provider);
+
         let _ = self.resolved_tables.insert(resolved_name, source.clone());
         Ok(source)
     }
@@ -103,6 +147,7 @@ impl DfTableSourceProvider {
 
 #[cfg(test)]
 mod tests {
+    use common_query::test_util::DummyDecoder;
     use session::context::QueryContext;
 
     use super::*;
@@ -112,8 +157,12 @@ mod tests {
     fn test_validate_table_ref() {
         let query_ctx = &QueryContext::with("greptime", "public");
 
-        let table_provider =
-            DfTableSourceProvider::new(MemoryCatalogManager::with_default_setup(), true, query_ctx);
+        let table_provider = DfTableSourceProvider::new(
+            MemoryCatalogManager::with_default_setup(),
+            true,
+            query_ctx,
+            DummyDecoder::arc(),
+        );
 
         let table_ref = TableReference::bare("table_name");
         let result = table_provider.resolve_table_ref(table_ref);
@@ -148,4 +197,99 @@ mod tests {
         let table_ref = TableReference::full("greptime", "greptime_private", "columns");
         assert!(table_provider.resolve_table_ref(table_ref).is_ok());
     }
+
+    use std::collections::HashSet;
+
+    use arrow::datatypes::{DataType, Field, Schema, SchemaRef};
+    use cache::{build_fundamental_cache_registry, with_default_composite_cache_registry};
+    use common_config::Mode;
+    use common_meta::cache::{CacheRegistryBuilder, LayeredCacheRegistryBuilder};
+    use common_meta::key::TableMetadataManager;
+    use common_meta::kv_backend::memory::MemoryKvBackend;
+    use common_query::error::Result as QueryResult;
+    use common_query::logical_plan::SubstraitPlanDecoder;
+    use datafusion::catalog::CatalogProviderList;
+    use datafusion::logical_expr::builder::LogicalTableSource;
+    use datafusion::logical_expr::{col, lit, LogicalPlan, LogicalPlanBuilder};
+
+    struct MockDecoder;
+    impl MockDecoder {
+        pub fn arc() -> Arc<Self> {
+            Arc::new(MockDecoder)
+        }
+    }
+
+    #[async_trait::async_trait]
+    impl SubstraitPlanDecoder for MockDecoder {
+        async fn decode(
+            &self,
+            _message: bytes::Bytes,
+            _catalog_list: Arc<dyn CatalogProviderList>,
+            _optimize: bool,
+        ) -> QueryResult<LogicalPlan> {
+            Ok(mock_plan())
+        }
+    }
+
+    fn mock_plan() -> LogicalPlan {
+        let schema = Schema::new(vec![
+            Field::new("id", DataType::Int32, true),
+            Field::new("name", DataType::Utf8, true),
+        ]);
+        let table_source = LogicalTableSource::new(SchemaRef::new(schema));
+
+        let projection = None;
+
+        let builder =
+            LogicalPlanBuilder::scan("person", Arc::new(table_source), projection).unwrap();
+
+        builder
+            .filter(col("id").gt(lit(500)))
+            .unwrap()
+            .build()
+            .unwrap()
+    }
+
+    #[tokio::test]
+    async fn test_resolve_view() {
+        let query_ctx = &QueryContext::with("greptime", "public");
+        let backend = Arc::new(MemoryKvBackend::default());
+        let layered_cache_builder = LayeredCacheRegistryBuilder::default()
+            .add_cache_registry(CacheRegistryBuilder::default().build());
+        let fundamental_cache_registry = build_fundamental_cache_registry(backend.clone());
+        let layered_cache_registry = Arc::new(
+            with_default_composite_cache_registry(
+                layered_cache_builder.add_cache_registry(fundamental_cache_registry),
+            )
+            .unwrap()
+            .build(),
+        );
+
+        let catalog_manager = KvBackendCatalogManager::new(
+            Mode::Standalone,
+            None,
+            backend.clone(),
+            layered_cache_registry,
+        );
+        let table_metadata_manager = TableMetadataManager::new(backend);
+        let mut view_info = common_meta::key::test_utils::new_test_table_info(1024, vec![]);
+        view_info.table_type = TableType::View;
+        let logical_plan = vec![1, 2, 3];
+        // Create view metadata
+        table_metadata_manager
+            .create_view_metadata(view_info.clone().into(), logical_plan, HashSet::new())
+            .await
+            .unwrap();
+
+        let mut table_provider =
+            DfTableSourceProvider::new(catalog_manager, true, query_ctx, MockDecoder::arc());
+
+        // View not found
+        let table_ref = TableReference::bare("not_exists_view");
+        assert!(table_provider.resolve_table(table_ref).await.is_err());
+
+        let table_ref = TableReference::bare(view_info.name);
+        let source = table_provider.resolve_table(table_ref).await.unwrap();
+        assert_eq!(*source.get_logical_plan().unwrap(), mock_plan());
+    }
 }

src/catalog/src/table_source/dummy_catalog.rs

@@ -0,0 +1,129 @@
+// 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.
+
+//! Dummy catalog for region server.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use common_catalog::format_full_table_name;
+use datafusion::catalog::schema::SchemaProvider;
+use datafusion::catalog::{CatalogProvider, CatalogProviderList};
+use datafusion::datasource::TableProvider;
+use snafu::OptionExt;
+use table::table::adapter::DfTableProviderAdapter;
+
+use crate::error::TableNotExistSnafu;
+use crate::CatalogManagerRef;
+
+/// Delegate the resolving requests to the `[CatalogManager]` unconditionally.
+#[derive(Clone)]
+pub struct DummyCatalogList {
+    catalog_manager: CatalogManagerRef,
+}
+
+impl DummyCatalogList {
+    /// Creates a new catalog list with the given catalog manager.
+    pub fn new(catalog_manager: CatalogManagerRef) -> Self {
+        Self { catalog_manager }
+    }
+}
+
+impl CatalogProviderList for DummyCatalogList {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn register_catalog(
+        &self,
+        _name: String,
+        _catalog: Arc<dyn CatalogProvider>,
+    ) -> Option<Arc<dyn CatalogProvider>> {
+        None
+    }
+
+    fn catalog_names(&self) -> Vec<String> {
+        vec![]
+    }
+
+    fn catalog(&self, catalog_name: &str) -> Option<Arc<dyn CatalogProvider>> {
+        Some(Arc::new(DummyCatalogProvider {
+            catalog_name: catalog_name.to_string(),
+            catalog_manager: self.catalog_manager.clone(),
+        }))
+    }
+}
+
+/// A dummy catalog provider for [DummyCatalogList].
+#[derive(Clone)]
+struct DummyCatalogProvider {
+    catalog_name: String,
+    catalog_manager: CatalogManagerRef,
+}
+
+impl CatalogProvider for DummyCatalogProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema_names(&self) -> Vec<String> {
+        vec![]
+    }
+
+    fn schema(&self, schema_name: &str) -> Option<Arc<dyn SchemaProvider>> {
+        Some(Arc::new(DummySchemaProvider {
+            catalog_name: self.catalog_name.clone(),
+            schema_name: schema_name.to_string(),
+            catalog_manager: self.catalog_manager.clone(),
+        }))
+    }
+}
+
+/// A dummy schema provider for [DummyCatalogList].
+#[derive(Clone)]
+struct DummySchemaProvider {
+    catalog_name: String,
+    schema_name: String,
+    catalog_manager: CatalogManagerRef,
+}
+
+#[async_trait]
+impl SchemaProvider for DummySchemaProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn table_names(&self) -> Vec<String> {
+        vec![]
+    }
+
+    async fn table(&self, name: &str) -> datafusion::error::Result<Option<Arc<dyn TableProvider>>> {
+        let table = self
+            .catalog_manager
+            .table(&self.catalog_name, &self.schema_name, name)
+            .await?
+            .with_context(|| TableNotExistSnafu {
+                table: format_full_table_name(&self.catalog_name, &self.schema_name, name),
+            })?;
+
+        let table_provider: Arc<dyn TableProvider> = Arc::new(DfTableProviderAdapter::new(table));
+
+        Ok(Some(table_provider))
+    }
+
+    fn table_exist(&self, _name: &str) -> bool {
+        true
+    }
+}

src/client/Cargo.toml

@@ -31,9 +31,11 @@ moka = { workspace = true, features = ["future"] }
 parking_lot = "0.12"
 prometheus.workspace = true
 prost.workspace = true
+query.workspace = true
 rand.workspace = true
 serde_json.workspace = true
 snafu.workspace = true
+substrait.workspace = true
 tokio.workspace = true
 tokio-stream = { workspace = true, features = ["net"] }
 tonic.workspace = true
@@ -42,7 +44,6 @@ tonic.workspace = true
 common-grpc-expr.workspace = true
 datanode.workspace = true
 derive-new = "0.5"
-substrait.workspace = true
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 

src/client/src/client.rs

@@ -14,6 +14,7 @@
 
 use std::sync::Arc;
 
+use api::v1::flow::flow_client::FlowClient as PbFlowClient;
 use api::v1::health_check_client::HealthCheckClient;
 use api::v1::prometheus_gateway_client::PrometheusGatewayClient;
 use api::v1::region::region_client::RegionClient as PbRegionClient;
@@ -173,14 +174,24 @@ impl Client {
         Ok(FlightClient { addr, client })
     }
 
-    pub(crate) fn raw_region_client(&self) -> Result<PbRegionClient<Channel>> {
-        let (_, channel) = self.find_channel()?;
+    pub(crate) fn raw_region_client(&self) -> Result<(String, PbRegionClient<Channel>)> {
+        let (addr, channel) = self.find_channel()?;
         let client = PbRegionClient::new(channel)
             .max_decoding_message_size(self.max_grpc_recv_message_size())
             .max_encoding_message_size(self.max_grpc_send_message_size())
             .accept_compressed(CompressionEncoding::Zstd)
             .send_compressed(CompressionEncoding::Zstd);
-        Ok(client)
+        Ok((addr, client))
+    }
+
+    pub(crate) fn raw_flow_client(&self) -> Result<(String, PbFlowClient<Channel>)> {
+        let (addr, channel) = self.find_channel()?;
+        let client = PbFlowClient::new(channel)
+            .max_decoding_message_size(self.max_grpc_recv_message_size())
+            .max_encoding_message_size(self.max_grpc_send_message_size())
+            .accept_compressed(CompressionEncoding::Zstd)
+            .send_compressed(CompressionEncoding::Zstd);
+        Ok((addr, client))
     }
 
     pub fn make_prometheus_gateway_client(&self) -> Result<PrometheusGatewayClient<Channel>> {

src/client/src/client_manager.rs

@@ -21,43 +21,45 @@ use common_meta::node_manager::{DatanodeRef, FlownodeRef, NodeManager};
 use common_meta::peer::Peer;
 use moka::future::{Cache, CacheBuilder};
 
+use crate::flow::FlowRequester;
 use crate::region::RegionRequester;
 use crate::Client;
 
-pub struct DatanodeClients {
+pub struct NodeClients {
     channel_manager: ChannelManager,
     clients: Cache<Peer, Client>,
 }
 
-impl Default for DatanodeClients {
+impl Default for NodeClients {
     fn default() -> Self {
         Self::new(ChannelConfig::new())
     }
 }
 
-impl Debug for DatanodeClients {
+impl Debug for NodeClients {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("DatanodeClients")
+        f.debug_struct("NodeClients")
             .field("channel_manager", &self.channel_manager)
             .finish()
     }
 }
 
 #[async_trait::async_trait]
-impl NodeManager for DatanodeClients {
+impl NodeManager for NodeClients {
     async fn datanode(&self, datanode: &Peer) -> DatanodeRef {
         let client = self.get_client(datanode).await;
 
         Arc::new(RegionRequester::new(client))
     }
 
-    async fn flownode(&self, _node: &Peer) -> FlownodeRef {
-        // TODO(weny): Support it.
-        unimplemented!()
+    async fn flownode(&self, flownode: &Peer) -> FlownodeRef {
+        let client = self.get_client(flownode).await;
+
+        Arc::new(FlowRequester::new(client))
     }
 }
 
-impl DatanodeClients {
+impl NodeClients {
     pub fn new(config: ChannelConfig) -> Self {
         Self {
             channel_manager: ChannelManager::with_config(config),

src/client/src/error.rs

@@ -89,8 +89,18 @@ pub enum Error {
         source: common_grpc::error::Error,
     },
 
-    #[snafu(display("Failed to request RegionServer, code: {}", code))]
+    #[snafu(display("Failed to request RegionServer {}, code: {}", addr, code))]
     RegionServer {
+        addr: String,
+        code: Code,
+        source: BoxedError,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display("Failed to request FlowServer {}, code: {}", addr, code))]
+    FlowServer {
+        addr: String,
         code: Code,
         source: BoxedError,
         #[snafu(implicit)]
@@ -135,7 +145,8 @@ impl ErrorExt for Error {
             Error::Server { code, .. } => *code,
             Error::FlightGet { source, .. }
             | Error::HandleRequest { source, .. }
-            | Error::RegionServer { source, .. } => source.status_code(),
+            | Error::RegionServer { source, .. }
+            | Error::FlowServer { source, .. } => source.status_code(),
             Error::CreateChannel { source, .. }
             | Error::ConvertFlightData { source, .. }
             | Error::CreateTlsChannel { source, .. } => source.status_code(),
@@ -191,6 +202,9 @@ impl Error {
             } | Self::RegionServer {
                 code: Code::Unavailable,
                 ..
+            } | Self::RegionServer {
+                code: Code::Unknown,
+                ..
             }
         )
     }

src/client/src/flow.rs

@@ -0,0 +1,104 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use api::v1::flow::{FlowRequest, FlowResponse};
+use api::v1::region::InsertRequests;
+use common_error::ext::BoxedError;
+use common_meta::node_manager::Flownode;
+use snafu::{location, Location, ResultExt};
+
+use crate::error::Result;
+use crate::Client;
+
+#[derive(Debug)]
+pub struct FlowRequester {
+    client: Client,
+}
+
+#[async_trait::async_trait]
+impl Flownode for FlowRequester {
+    async fn handle(&self, request: FlowRequest) -> common_meta::error::Result<FlowResponse> {
+        self.handle_inner(request)
+            .await
+            .map_err(BoxedError::new)
+            .context(common_meta::error::ExternalSnafu)
+    }
+
+    async fn handle_inserts(
+        &self,
+        request: InsertRequests,
+    ) -> common_meta::error::Result<FlowResponse> {
+        self.handle_inserts_inner(request)
+            .await
+            .map_err(BoxedError::new)
+            .context(common_meta::error::ExternalSnafu)
+    }
+}
+
+impl FlowRequester {
+    pub fn new(client: Client) -> Self {
+        Self { client }
+    }
+
+    async fn handle_inner(&self, request: FlowRequest) -> Result<FlowResponse> {
+        let (addr, mut client) = self.client.raw_flow_client()?;
+
+        let response = client
+            .handle_create_remove(request)
+            .await
+            .map_err(|e| {
+                let code = e.code();
+                let err: crate::error::Error = e.into();
+                crate::error::Error::FlowServer {
+                    addr,
+                    code,
+                    source: BoxedError::new(err),
+                    location: location!(),
+                }
+            })?
+            .into_inner();
+        Ok(response)
+    }
+
+    async fn handle_inserts_inner(&self, request: InsertRequests) -> Result<FlowResponse> {
+        let (addr, mut client) = self.client.raw_flow_client()?;
+
+        let requests = api::v1::flow::InsertRequests {
+            requests: request
+                .requests
+                .into_iter()
+                .map(|insert| api::v1::flow::InsertRequest {
+                    region_id: insert.region_id,
+                    rows: insert.rows,
+                })
+                .collect(),
+        };
+
+        let response = client
+            .handle_mirror_request(requests)
+            .await
+            .map_err(|e| {
+                let code = e.code();
+                let err: crate::error::Error = e.into();
+                crate::error::Error::FlowServer {
+                    addr,
+                    code,
+                    source: BoxedError::new(err),
+                    location: location!(),
+                }
+            })?
+            .into_inner();
+        Ok(response)
+    }
+}

src/client/src/lib.rs

@@ -19,6 +19,7 @@ pub mod client_manager;
 #[cfg(feature = "testing")]
 mod database;
 pub mod error;
+pub mod flow;
 pub mod load_balance;
 mod metrics;
 pub mod region;

src/client/src/region.rs

@@ -15,7 +15,7 @@
 use std::sync::Arc;
 
 use api::region::RegionResponse;
-use api::v1::region::{QueryRequest, RegionRequest};
+use api::v1::region::RegionRequest;
 use api::v1::ResponseHeader;
 use arc_swap::ArcSwapOption;
 use arrow_flight::Ticket;
@@ -26,12 +26,15 @@ use common_error::status_code::StatusCode;
 use common_grpc::flight::{FlightDecoder, FlightMessage};
 use common_meta::error::{self as meta_error, Result as MetaResult};
 use common_meta::node_manager::Datanode;
+use common_query::request::QueryRequest;
 use common_recordbatch::error::ExternalSnafu;
 use common_recordbatch::{RecordBatchStreamWrapper, SendableRecordBatchStream};
 use common_telemetry::error;
 use common_telemetry::tracing_context::TracingContext;
 use prost::Message;
+use query::query_engine::DefaultSerializer;
 use snafu::{location, Location, OptionExt, ResultExt};
+use substrait::{DFLogicalSubstraitConvertor, SubstraitPlan};
 use tokio_stream::StreamExt;
 
 use crate::error::{
@@ -63,6 +66,17 @@ impl Datanode for RegionRequester {
     }
 
     async fn handle_query(&self, request: QueryRequest) -> MetaResult<SendableRecordBatchStream> {
+        let plan = DFLogicalSubstraitConvertor
+            .encode(&request.plan, DefaultSerializer)
+            .map_err(BoxedError::new)
+            .context(meta_error::ExternalSnafu)?
+            .to_vec();
+        let request = api::v1::region::QueryRequest {
+            header: request.header,
+            region_id: request.region_id.as_u64(),
+            plan,
+        };
+
         let ticket = Ticket {
             ticket: request.encode_to_vec().into(),
         };
@@ -177,7 +191,7 @@ impl RegionRequester {
             .with_label_values(&[request_type.as_str()])
             .start_timer();
 
-        let mut client = self.client.raw_region_client()?;
+        let (addr, mut client) = self.client.raw_region_client()?;
 
         let response = client
             .handle(request)
@@ -187,6 +201,7 @@ impl RegionRequester {
                 let err: error::Error = e.into();
                 // Uses `Error::RegionServer` instead of `Error::Server`
                 error::Error::RegionServer {
+                    addr,
                     code,
                     source: BoxedError::new(err),
                     location: location!(),

src/cmd/Cargo.toml

@@ -74,6 +74,7 @@ substrait.workspace = true
 table.workspace = true
 tokio.workspace = true
 toml.workspace = true
+tonic.workspace = true
 tracing-appender = "0.2"
 
 [target.'cfg(not(windows))'.dependencies]

src/cmd/src/bin/greptime.rs

@@ -17,7 +17,7 @@
 use clap::{Parser, Subcommand};
 use cmd::error::Result;
 use cmd::options::GlobalOptions;
-use cmd::{cli, datanode, frontend, metasrv, standalone, App};
+use cmd::{cli, datanode, flownode, frontend, metasrv, standalone, App};
 use common_version::version;
 
 #[derive(Parser)]
@@ -37,6 +37,10 @@ enum SubCommand {
     #[clap(name = "datanode")]
     Datanode(datanode::Command),
 
+    /// Start flownode service.
+    #[clap(name = "flownode")]
+    Flownode(flownode::Command),
+
     /// Start frontend service.
     #[clap(name = "frontend")]
     Frontend(frontend::Command),
@@ -72,6 +76,12 @@ async fn start(cli: Command) -> Result<()> {
                 .run()
                 .await
         }
+        SubCommand::Flownode(cmd) => {
+            cmd.build(cmd.load_options(&cli.global_options)?)
+                .await?
+                .run()
+                .await
+        }
         SubCommand::Frontend(cmd) => {
             cmd.build(cmd.load_options(&cli.global_options)?)
                 .await?

src/cmd/src/cli.rs

@@ -23,9 +23,6 @@ mod helper;
 // Wait for https://github.com/GreptimeTeam/greptimedb/issues/2373
 #[allow(unused)]
 mod repl;
-// TODO(tisonkun): migrate deprecated methods
-#[allow(deprecated)]
-mod upgrade;
 
 use async_trait::async_trait;
 use bench::BenchTableMetadataCommand;
@@ -33,7 +30,6 @@ use clap::Parser;
 use common_telemetry::logging::{LoggingOptions, TracingOptions};
 pub use repl::Repl;
 use tracing_appender::non_blocking::WorkerGuard;
-use upgrade::UpgradeCommand;
 
 use self::export::ExportCommand;
 use crate::error::Result;
@@ -116,7 +112,6 @@ impl Command {
 #[derive(Parser)]
 enum SubCommand {
     // Attach(AttachCommand),
-    Upgrade(UpgradeCommand),
     Bench(BenchTableMetadataCommand),
     Export(ExportCommand),
 }
@@ -125,7 +120,6 @@ impl SubCommand {
     async fn build(&self, guard: Vec<WorkerGuard>) -> Result<Instance> {
         match self {
             // SubCommand::Attach(cmd) => cmd.build().await,
-            SubCommand::Upgrade(cmd) => cmd.build(guard).await,
             SubCommand::Bench(cmd) => cmd.build(guard).await,
             SubCommand::Export(cmd) => cmd.build(guard).await,
         }

src/cmd/src/cli/bench.rs

@@ -23,13 +23,13 @@ use common_meta::key::{TableMetadataManager, TableMetadataManagerRef};
 use common_meta::kv_backend::etcd::EtcdStore;
 use common_meta::peer::Peer;
 use common_meta::rpc::router::{Region, RegionRoute};
-use common_meta::table_name::TableName;
 use common_telemetry::info;
 use datatypes::data_type::ConcreteDataType;
 use datatypes::schema::{ColumnSchema, RawSchema};
 use rand::Rng;
 use store_api::storage::RegionNumber;
 use table::metadata::{RawTableInfo, RawTableMeta, TableId, TableIdent, TableType};
+use table::table_name::TableName;
 use tracing_appender::non_blocking::WorkerGuard;
 
 use self::metadata::TableMetadataBencher;

src/cmd/src/cli/bench/metadata.rs

@@ -16,7 +16,7 @@ use std::time::Instant;
 
 use common_meta::key::table_route::TableRouteValue;
 use common_meta::key::TableMetadataManagerRef;
-use common_meta::table_name::TableName;
+use table::table_name::TableName;
 
 use crate::cli::bench::{
     bench_self_recorded, create_region_routes, create_region_wal_options, create_table_info,

src/cmd/src/cli/repl.rs

@@ -37,7 +37,7 @@ use query::datafusion::DatafusionQueryEngine;
 use query::logical_optimizer::LogicalOptimizer;
 use query::parser::QueryLanguageParser;
 use query::plan::LogicalPlan;
-use query::query_engine::QueryEngineState;
+use query::query_engine::{DefaultSerializer, QueryEngineState};
 use query::QueryEngine;
 use rustyline::error::ReadlineError;
 use rustyline::Editor;
@@ -185,7 +185,7 @@ impl Repl {
                 .context(PlanStatementSnafu)?;
 
             let plan = DFLogicalSubstraitConvertor {}
-                .encode(&plan)
+                .encode(&plan, DefaultSerializer)
                 .context(SubstraitEncodeLogicalPlanSnafu)?;
 
             self.database.logical_plan(plan.to_vec()).await
@@ -277,24 +277,12 @@ async fn create_query_engine(meta_addr: &str) -> Result<DatafusionQueryEngine> {
         .build(),
     );
 
-    let table_cache = layered_cache_registry
-        .get()
-        .context(error::CacheRequiredSnafu {
-            name: TABLE_CACHE_NAME,
-        })?;
-    let table_route_cache = layered_cache_registry
-        .get()
-        .context(error::CacheRequiredSnafu {
-            name: TABLE_ROUTE_CACHE_NAME,
-        })?;
     let catalog_manager = KvBackendCatalogManager::new(
         Mode::Distributed,
         Some(meta_client.clone()),
         cached_meta_backend.clone(),
-        table_cache,
-        table_route_cache,
-    )
-    .await;
+        layered_cache_registry,
+    );
     let plugins: Plugins = Default::default();
     let state = Arc::new(QueryEngineState::new(
         catalog_manager,

src/cmd/src/cli/upgrade.rs

@@ -1,584 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use clap::Parser;
-use client::api::v1::meta::TableRouteValue;
-use common_meta::ddl::utils::region_storage_path;
-use common_meta::error as MetaError;
-use common_meta::key::catalog_name::{CatalogNameKey, CatalogNameValue};
-use common_meta::key::datanode_table::{DatanodeTableKey, DatanodeTableValue, RegionInfo};
-use common_meta::key::schema_name::{SchemaNameKey, SchemaNameValue};
-use common_meta::key::table_info::{TableInfoKey, TableInfoValue};
-use common_meta::key::table_name::{TableNameKey, TableNameValue};
-use common_meta::key::table_region::{TableRegionKey, TableRegionValue};
-use common_meta::key::table_route::{TableRouteKey, TableRouteValue as NextTableRouteValue};
-use common_meta::key::{MetaKey, RegionDistribution, TableMetaValue};
-use common_meta::kv_backend::etcd::EtcdStore;
-use common_meta::kv_backend::KvBackendRef;
-use common_meta::range_stream::PaginationStream;
-use common_meta::rpc::router::TableRoute;
-use common_meta::rpc::store::{BatchDeleteRequest, BatchPutRequest, PutRequest, RangeRequest};
-use common_meta::rpc::KeyValue;
-use common_meta::util::get_prefix_end_key;
-use common_telemetry::info;
-use etcd_client::Client;
-use futures::TryStreamExt;
-use prost::Message;
-use snafu::ResultExt;
-use tracing_appender::non_blocking::WorkerGuard;
-use v1_helper::{CatalogKey as v1CatalogKey, SchemaKey as v1SchemaKey, TableGlobalValue};
-
-use crate::cli::{Instance, Tool};
-use crate::error::{self, ConnectEtcdSnafu, Result};
-
-#[derive(Debug, Default, Parser)]
-pub struct UpgradeCommand {
-    #[clap(long)]
-    etcd_addr: String,
-    #[clap(long)]
-    dryrun: bool,
-
-    #[clap(long)]
-    skip_table_global_keys: bool,
-    #[clap(long)]
-    skip_catalog_keys: bool,
-    #[clap(long)]
-    skip_schema_keys: bool,
-    #[clap(long)]
-    skip_table_route_keys: bool,
-}
-
-impl UpgradeCommand {
-    pub async fn build(&self, guard: Vec<WorkerGuard>) -> Result<Instance> {
-        let client = Client::connect([&self.etcd_addr], None)
-            .await
-            .context(ConnectEtcdSnafu {
-                etcd_addr: &self.etcd_addr,
-            })?;
-        let tool = MigrateTableMetadata {
-            etcd_store: EtcdStore::with_etcd_client(client, 128),
-            dryrun: self.dryrun,
-            skip_catalog_keys: self.skip_catalog_keys,
-            skip_table_global_keys: self.skip_table_global_keys,
-            skip_schema_keys: self.skip_schema_keys,
-            skip_table_route_keys: self.skip_table_route_keys,
-        };
-        Ok(Instance::new(Box::new(tool), guard))
-    }
-}
-
-struct MigrateTableMetadata {
-    etcd_store: KvBackendRef,
-    dryrun: bool,
-
-    skip_table_global_keys: bool,
-
-    skip_catalog_keys: bool,
-
-    skip_schema_keys: bool,
-
-    skip_table_route_keys: bool,
-}
-
-#[async_trait]
-impl Tool for MigrateTableMetadata {
-    // migrates database's metadata from 0.3 to 0.4.
-    async fn do_work(&self) -> Result<()> {
-        if !self.skip_table_global_keys {
-            self.migrate_table_global_values().await?;
-        }
-        if !self.skip_catalog_keys {
-            self.migrate_catalog_keys().await?;
-        }
-        if !self.skip_schema_keys {
-            self.migrate_schema_keys().await?;
-        }
-        if !self.skip_table_route_keys {
-            self.migrate_table_route_keys().await?;
-        }
-        Ok(())
-    }
-}
-
-const PAGE_SIZE: usize = 1000;
-
-impl MigrateTableMetadata {
-    async fn migrate_table_route_keys(&self) -> Result<()> {
-        let key = b"__meta_table_route".to_vec();
-        let range_end = get_prefix_end_key(&key);
-        let mut keys = Vec::new();
-        info!("Start scanning key from: {}", String::from_utf8_lossy(&key));
-
-        let mut stream = PaginationStream::new(
-            self.etcd_store.clone(),
-            RangeRequest::new().with_range(key, range_end),
-            PAGE_SIZE,
-            Arc::new(|kv: KeyValue| {
-                let value =
-                    TableRouteValue::decode(&kv.value[..]).context(MetaError::DecodeProtoSnafu)?;
-                Ok((kv.key, value))
-            }),
-        );
-
-        while let Some((key, value)) = stream.try_next().await.context(error::IterStreamSnafu)? {
-            let table_id = self.migrate_table_route_key(value).await?;
-            keys.push(key);
-            keys.push(TableRegionKey::new(table_id).to_bytes())
-        }
-
-        info!("Total migrated TableRouteKeys: {}", keys.len() / 2);
-        self.delete_migrated_keys(keys).await;
-
-        Ok(())
-    }
-
-    async fn migrate_table_route_key(&self, value: TableRouteValue) -> Result<u32> {
-        let table_route = TableRoute::try_from_raw(
-            &value.peers,
-            value.table_route.expect("expected table_route"),
-        )
-        .unwrap();
-
-        let new_table_value = NextTableRouteValue::physical(table_route.region_routes);
-
-        let table_id = table_route.table.id as u32;
-        let new_key = TableRouteKey::new(table_id);
-        info!("Creating '{new_key}'");
-
-        if self.dryrun {
-            info!("Dryrun: do nothing");
-        } else {
-            self.etcd_store
-                .put(
-                    PutRequest::new()
-                        .with_key(new_key.to_bytes())
-                        .with_value(new_table_value.try_as_raw_value().unwrap()),
-                )
-                .await
-                .unwrap();
-        }
-
-        Ok(table_id)
-    }
-
-    async fn migrate_schema_keys(&self) -> Result<()> {
-        // The schema key prefix.
-        let key = b"__s".to_vec();
-        let range_end = get_prefix_end_key(&key);
-
-        let mut keys = Vec::new();
-        info!("Start scanning key from: {}", String::from_utf8_lossy(&key));
-        let mut stream = PaginationStream::new(
-            self.etcd_store.clone(),
-            RangeRequest::new().with_range(key, range_end),
-            PAGE_SIZE,
-            Arc::new(|kv: KeyValue| {
-                let key_str =
-                    std::str::from_utf8(&kv.key).context(MetaError::ConvertRawKeySnafu)?;
-                let key = v1SchemaKey::parse(key_str)
-                    .unwrap_or_else(|e| panic!("schema key is corrupted: {e}, key: {key_str}"));
-
-                Ok(key)
-            }),
-        );
-        while let Some(key) = stream.try_next().await.context(error::IterStreamSnafu)? {
-            let _ = self.migrate_schema_key(&key).await;
-            keys.push(key.to_string().as_bytes().to_vec());
-        }
-        info!("Total migrated SchemaKeys: {}", keys.len());
-        self.delete_migrated_keys(keys).await;
-
-        Ok(())
-    }
-
-    async fn migrate_schema_key(&self, key: &v1SchemaKey) -> Result<()> {
-        let new_key = SchemaNameKey::new(&key.catalog_name, &key.schema_name);
-        let schema_name_value = SchemaNameValue::default();
-
-        info!("Creating '{new_key}'");
-
-        if self.dryrun {
-            info!("Dryrun: do nothing");
-        } else {
-            self.etcd_store
-                .put(
-                    PutRequest::new()
-                        .with_key(new_key.to_bytes())
-                        .with_value(schema_name_value.try_as_raw_value().unwrap()),
-                )
-                .await
-                .unwrap();
-        }
-
-        Ok(())
-    }
-
-    async fn migrate_catalog_keys(&self) -> Result<()> {
-        // The catalog key prefix.
-        let key = b"__c".to_vec();
-        let range_end = get_prefix_end_key(&key);
-
-        let mut keys = Vec::new();
-        info!("Start scanning key from: {}", String::from_utf8_lossy(&key));
-        let mut stream = PaginationStream::new(
-            self.etcd_store.clone(),
-            RangeRequest::new().with_range(key, range_end),
-            PAGE_SIZE,
-            Arc::new(|kv: KeyValue| {
-                let key_str =
-                    std::str::from_utf8(&kv.key).context(MetaError::ConvertRawKeySnafu)?;
-                let key = v1CatalogKey::parse(key_str)
-                    .unwrap_or_else(|e| panic!("catalog key is corrupted: {e}, key: {key_str}"));
-
-                Ok(key)
-            }),
-        );
-        while let Some(key) = stream.try_next().await.context(error::IterStreamSnafu)? {
-            let _ = self.migrate_catalog_key(&key).await;
-            keys.push(key.to_string().as_bytes().to_vec());
-        }
-        info!("Total migrated CatalogKeys: {}", keys.len());
-        self.delete_migrated_keys(keys).await;
-
-        Ok(())
-    }
-
-    async fn migrate_catalog_key(&self, key: &v1CatalogKey) {
-        let new_key = CatalogNameKey::new(&key.catalog_name);
-        let catalog_name_value = CatalogNameValue;
-
-        info!("Creating '{new_key}'");
-
-        if self.dryrun {
-            info!("Dryrun: do nothing");
-        } else {
-            self.etcd_store
-                .put(
-                    PutRequest::new()
-                        .with_key(new_key.to_bytes())
-                        .with_value(catalog_name_value.try_as_raw_value().unwrap()),
-                )
-                .await
-                .unwrap();
-        }
-    }
-
-    async fn migrate_table_global_values(&self) -> Result<()> {
-        let key = b"__tg".to_vec();
-        let range_end = get_prefix_end_key(&key);
-
-        let mut keys = Vec::new();
-
-        info!("Start scanning key from: {}", String::from_utf8_lossy(&key));
-        let mut stream = PaginationStream::new(
-            self.etcd_store.clone(),
-            RangeRequest::new().with_range(key, range_end.clone()),
-            PAGE_SIZE,
-            Arc::new(|kv: KeyValue| {
-                let key = String::from_utf8_lossy(kv.key()).to_string();
-                let value = TableGlobalValue::from_bytes(kv.value())
-                    .unwrap_or_else(|e| panic!("table global value is corrupted: {e}, key: {key}"));
-
-                Ok((key, value))
-            }),
-        );
-        while let Some((key, value)) = stream.try_next().await.context(error::IterStreamSnafu)? {
-            self.create_table_name_key(&value).await;
-
-            self.create_datanode_table_keys(&value).await;
-
-            self.split_table_global_value(&key, value).await;
-
-            keys.push(key.as_bytes().to_vec());
-        }
-
-        info!("Total migrated TableGlobalKeys: {}", keys.len());
-        self.delete_migrated_keys(keys).await;
-
-        Ok(())
-    }
-
-    async fn delete_migrated_keys(&self, keys: Vec<Vec<u8>>) {
-        for keys in keys.chunks(PAGE_SIZE) {
-            info!("Deleting {} keys", keys.len());
-            let req = BatchDeleteRequest {
-                keys: keys.to_vec(),
-                prev_kv: false,
-            };
-            if self.dryrun {
-                info!("Dryrun: do nothing");
-            } else {
-                self.etcd_store.batch_delete(req).await.unwrap();
-            }
-        }
-    }
-
-    async fn split_table_global_value(&self, key: &str, value: TableGlobalValue) {
-        let table_id = value.table_id();
-        let region_distribution: RegionDistribution = value.regions_id_map.into_iter().collect();
-
-        let table_info_key = TableInfoKey::new(table_id);
-        let table_info_value = TableInfoValue::new(value.table_info);
-
-        let table_region_key = TableRegionKey::new(table_id);
-        let table_region_value = TableRegionValue::new(region_distribution);
-
-        info!("Splitting TableGlobalKey '{key}' into '{table_info_key}' and '{table_region_key}'");
-
-        if self.dryrun {
-            info!("Dryrun: do nothing");
-        } else {
-            self.etcd_store
-                .batch_put(
-                    BatchPutRequest::new()
-                        .add_kv(
-                            table_info_key.to_bytes(),
-                            table_info_value.try_as_raw_value().unwrap(),
-                        )
-                        .add_kv(
-                            table_region_key.to_bytes(),
-                            table_region_value.try_as_raw_value().unwrap(),
-                        ),
-                )
-                .await
-                .unwrap();
-        }
-    }
-
-    async fn create_table_name_key(&self, value: &TableGlobalValue) {
-        let table_info = &value.table_info;
-        let table_id = value.table_id();
-
-        let table_name_key = TableNameKey::new(
-            &table_info.catalog_name,
-            &table_info.schema_name,
-            &table_info.name,
-        );
-        let table_name_value = TableNameValue::new(table_id);
-
-        info!("Creating '{table_name_key}' => {table_id}");
-
-        if self.dryrun {
-            info!("Dryrun: do nothing");
-        } else {
-            self.etcd_store
-                .put(
-                    PutRequest::new()
-                        .with_key(table_name_key.to_bytes())
-                        .with_value(table_name_value.try_as_raw_value().unwrap()),
-                )
-                .await
-                .unwrap();
-        }
-    }
-
-    async fn create_datanode_table_keys(&self, value: &TableGlobalValue) {
-        let table_id = value.table_id();
-        let engine = value.table_info.meta.engine.as_str();
-        let region_storage_path = region_storage_path(
-            &value.table_info.catalog_name,
-            &value.table_info.schema_name,
-        );
-        let region_distribution: RegionDistribution =
-            value.regions_id_map.clone().into_iter().collect();
-
-        // TODO(niebayes): properly fetch or construct wal options.
-        let region_wal_options = HashMap::default();
-
-        let datanode_table_kvs = region_distribution
-            .into_iter()
-            .map(|(datanode_id, regions)| {
-                let k = DatanodeTableKey::new(datanode_id, table_id);
-                info!("Creating DatanodeTableKey '{k}' => {regions:?}");
-                (
-                    k,
-                    DatanodeTableValue::new(
-                        table_id,
-                        regions,
-                        RegionInfo {
-                            engine: engine.to_string(),
-                            region_storage_path: region_storage_path.clone(),
-                            region_options: (&value.table_info.meta.options).into(),
-                            region_wal_options: region_wal_options.clone(),
-                        },
-                    ),
-                )
-            })
-            .collect::<Vec<_>>();
-
-        if self.dryrun {
-            info!("Dryrun: do nothing");
-        } else {
-            let mut req = BatchPutRequest::new();
-            for (key, value) in datanode_table_kvs {
-                req = req.add_kv(key.to_bytes(), value.try_as_raw_value().unwrap());
-            }
-            self.etcd_store.batch_put(req).await.unwrap();
-        }
-    }
-}
-
-#[deprecated(since = "0.4.0", note = "Used for migrate old version(v0.3) metadata")]
-mod v1_helper {
-    use std::collections::HashMap;
-    use std::fmt::{Display, Formatter};
-
-    use err::{DeserializeCatalogEntryValueSnafu, Error, InvalidCatalogSnafu};
-    use lazy_static::lazy_static;
-    use regex::Regex;
-    use serde::{Deserialize, Serialize};
-    use snafu::{ensure, OptionExt, ResultExt};
-    use table::metadata::{RawTableInfo, TableId};
-
-    pub const CATALOG_KEY_PREFIX: &str = "__c";
-    pub const SCHEMA_KEY_PREFIX: &str = "__s";
-
-    /// The pattern of a valid catalog, schema or table name.
-    const NAME_PATTERN: &str = "[a-zA-Z_:][a-zA-Z0-9_:]*";
-
-    lazy_static! {
-        static ref CATALOG_KEY_PATTERN: Regex =
-            Regex::new(&format!("^{CATALOG_KEY_PREFIX}-({NAME_PATTERN})$")).unwrap();
-    }
-
-    lazy_static! {
-        static ref SCHEMA_KEY_PATTERN: Regex = Regex::new(&format!(
-            "^{SCHEMA_KEY_PREFIX}-({NAME_PATTERN})-({NAME_PATTERN})$"
-        ))
-        .unwrap();
-    }
-
-    /// Table global info contains necessary info for a datanode to create table regions, including
-    /// table id, table meta(schema...), region id allocation across datanodes.
-    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-    pub struct TableGlobalValue {
-        /// Id of datanode that created the global table info kv. only for debugging.
-        pub node_id: u64,
-        /// Allocation of region ids across all datanodes.
-        pub regions_id_map: HashMap<u64, Vec<u32>>,
-        pub table_info: RawTableInfo,
-    }
-
-    impl TableGlobalValue {
-        pub fn table_id(&self) -> TableId {
-            self.table_info.ident.table_id
-        }
-    }
-
-    pub struct CatalogKey {
-        pub catalog_name: String,
-    }
-
-    impl Display for CatalogKey {
-        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-            f.write_str(CATALOG_KEY_PREFIX)?;
-            f.write_str("-")?;
-            f.write_str(&self.catalog_name)
-        }
-    }
-
-    impl CatalogKey {
-        pub fn parse(s: impl AsRef<str>) -> Result<Self, Error> {
-            let key = s.as_ref();
-            let captures = CATALOG_KEY_PATTERN
-                .captures(key)
-                .context(InvalidCatalogSnafu { key })?;
-            ensure!(captures.len() == 2, InvalidCatalogSnafu { key });
-            Ok(Self {
-                catalog_name: captures[1].to_string(),
-            })
-        }
-    }
-
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct CatalogValue;
-
-    pub struct SchemaKey {
-        pub catalog_name: String,
-        pub schema_name: String,
-    }
-
-    impl Display for SchemaKey {
-        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-            f.write_str(SCHEMA_KEY_PREFIX)?;
-            f.write_str("-")?;
-            f.write_str(&self.catalog_name)?;
-            f.write_str("-")?;
-            f.write_str(&self.schema_name)
-        }
-    }
-
-    impl SchemaKey {
-        pub fn parse(s: impl AsRef<str>) -> Result<Self, Error> {
-            let key = s.as_ref();
-            let captures = SCHEMA_KEY_PATTERN
-                .captures(key)
-                .context(InvalidCatalogSnafu { key })?;
-            ensure!(captures.len() == 3, InvalidCatalogSnafu { key });
-            Ok(Self {
-                catalog_name: captures[1].to_string(),
-                schema_name: captures[2].to_string(),
-            })
-        }
-    }
-
-    #[derive(Debug, Serialize, Deserialize)]
-    pub struct SchemaValue;
-
-    macro_rules! define_catalog_value {
-    ( $($val_ty: ty), *) => {
-            $(
-                impl $val_ty {
-                    pub fn parse(s: impl AsRef<str>) -> Result<Self, Error> {
-                        serde_json::from_str(s.as_ref())
-                            .context(DeserializeCatalogEntryValueSnafu { raw: s.as_ref() })
-                    }
-
-                    pub fn from_bytes(bytes: impl AsRef<[u8]>) -> Result<Self, Error> {
-                         Self::parse(&String::from_utf8_lossy(bytes.as_ref()))
-                    }
-                }
-            )*
-        }
-    }
-
-    define_catalog_value!(TableGlobalValue);
-
-    mod err {
-        use snafu::{Location, Snafu};
-
-        #[derive(Debug, Snafu)]
-        #[snafu(visibility(pub))]
-        pub enum Error {
-            #[snafu(display("Invalid catalog info: {}", key))]
-            InvalidCatalog {
-                key: String,
-                #[snafu(implicit)]
-                location: Location,
-            },
-
-            #[snafu(display("Failed to deserialize catalog entry value: {}", raw))]
-            DeserializeCatalogEntryValue {
-                raw: String,
-                #[snafu(implicit)]
-                location: Location,
-                source: serde_json::error::Error,
-            },
-        }
-    }
-}

src/cmd/src/datanode.rs

@@ -19,26 +19,28 @@ use async_trait::async_trait;
 use catalog::kvbackend::MetaKvBackend;
 use clap::Parser;
 use common_config::Configurable;
-use common_telemetry::info;
 use common_telemetry::logging::TracingOptions;
+use common_telemetry::{info, warn};
 use common_version::{short_version, version};
 use common_wal::config::DatanodeWalConfig;
-use datanode::config::DatanodeOptions;
 use datanode::datanode::{Datanode, DatanodeBuilder};
 use datanode::service::DatanodeServiceBuilder;
-use meta_client::MetaClientOptions;
+use meta_client::{MetaClientOptions, MetaClientType};
 use servers::Mode;
 use snafu::{OptionExt, ResultExt};
 use tracing_appender::non_blocking::WorkerGuard;
 
 use crate::error::{
-    LoadLayeredConfigSnafu, MissingConfigSnafu, Result, ShutdownDatanodeSnafu, StartDatanodeSnafu,
+    LoadLayeredConfigSnafu, MetaClientInitSnafu, MissingConfigSnafu, Result, ShutdownDatanodeSnafu,
+    StartDatanodeSnafu,
 };
-use crate::options::GlobalOptions;
+use crate::options::{GlobalOptions, GreptimeOptions};
 use crate::{log_versions, App};
 
 pub const APP_NAME: &str = "greptime-datanode";
 
+type DatanodeOptions = GreptimeOptions<datanode::config::DatanodeOptions>;
+
 pub struct Instance {
     datanode: Datanode,
 
@@ -97,7 +99,9 @@ impl Command {
     }
 
     pub fn load_options(&self, global_options: &GlobalOptions) -> Result<DatanodeOptions> {
-        self.subcmd.load_options(global_options)
+        match &self.subcmd {
+            SubCommand::Start(cmd) => cmd.load_options(global_options),
+        }
     }
 }
 
@@ -112,12 +116,6 @@ impl SubCommand {
             SubCommand::Start(cmd) => cmd.build(opts).await,
         }
     }
-
-    fn load_options(&self, global_options: &GlobalOptions) -> Result<DatanodeOptions> {
-        match self {
-            SubCommand::Start(cmd) => cmd.load_options(global_options),
-        }
-    }
 }
 
 #[derive(Debug, Parser, Default)]
@@ -128,7 +126,7 @@ struct StartCommand {
     rpc_addr: Option<String>,
     #[clap(long)]
     rpc_hostname: Option<String>,
-    #[clap(long, aliases = ["metasrv-addr"], value_delimiter = ',', num_args = 1..)]
+    #[clap(long, value_delimiter = ',', num_args = 1..)]
     metasrv_addrs: Option<Vec<String>>,
     #[clap(short, long)]
     config_file: Option<String>,
@@ -146,22 +144,26 @@ struct StartCommand {
 
 impl StartCommand {
     fn load_options(&self, global_options: &GlobalOptions) -> Result<DatanodeOptions> {
-        self.merge_with_cli_options(
-            global_options,
-            DatanodeOptions::load_layered_options(
-                self.config_file.as_deref(),
-                self.env_prefix.as_ref(),
-            )
-            .context(LoadLayeredConfigSnafu)?,
+        let mut opts = DatanodeOptions::load_layered_options(
+            self.config_file.as_deref(),
+            self.env_prefix.as_ref(),
         )
+        .context(LoadLayeredConfigSnafu)?;
+
+        self.merge_with_cli_options(global_options, &mut opts)?;
+
+        Ok(opts)
     }
 
     // The precedence order is: cli > config file > environment variables > default values.
+    #[allow(deprecated)]
     fn merge_with_cli_options(
         &self,
         global_options: &GlobalOptions,
-        mut opts: DatanodeOptions,
-    ) -> Result<DatanodeOptions> {
+        opts: &mut DatanodeOptions,
+    ) -> Result<()> {
+        let opts = &mut opts.component;
+
         if let Some(dir) = &global_options.log_dir {
             opts.logging.dir.clone_from(dir);
         }
@@ -176,11 +178,32 @@ impl StartCommand {
         };
 
         if let Some(addr) = &self.rpc_addr {
-            opts.rpc_addr.clone_from(addr);
+            opts.grpc.addr.clone_from(addr);
+        } else if let Some(addr) = &opts.rpc_addr {
+            warn!("Use the deprecated attribute `DatanodeOptions.rpc_addr`, please use `grpc.addr` instead.");
+            opts.grpc.addr.clone_from(addr);
         }
 
-        if self.rpc_hostname.is_some() {
-            opts.rpc_hostname.clone_from(&self.rpc_hostname);
+        if let Some(hostname) = &self.rpc_hostname {
+            opts.grpc.hostname.clone_from(hostname);
+        } else if let Some(hostname) = &opts.rpc_hostname {
+            warn!("Use the deprecated attribute `DatanodeOptions.rpc_hostname`, please use `grpc.hostname` instead.");
+            opts.grpc.hostname.clone_from(hostname);
+        }
+
+        if let Some(runtime_size) = opts.rpc_runtime_size {
+            warn!("Use the deprecated attribute `DatanodeOptions.rpc_runtime_size`, please use `grpc.runtime_size` instead.");
+            opts.grpc.runtime_size = runtime_size;
+        }
+
+        if let Some(max_recv_message_size) = opts.rpc_max_recv_message_size {
+            warn!("Use the deprecated attribute `DatanodeOptions.rpc_max_recv_message_size`, please use `grpc.max_recv_message_size` instead.");
+            opts.grpc.max_recv_message_size = max_recv_message_size;
+        }
+
+        if let Some(max_send_message_size) = opts.rpc_max_send_message_size {
+            warn!("Use the deprecated attribute `DatanodeOptions.rpc_max_send_message_size`, please use `grpc.max_send_message_size` instead.");
+            opts.grpc.max_send_message_size = max_send_message_size;
         }
 
         if let Some(node_id) = self.node_id {
@@ -231,26 +254,30 @@ impl StartCommand {
         // Disable dashboard in datanode.
         opts.http.disable_dashboard = true;
 
-        Ok(opts)
+        Ok(())
     }
 
-    async fn build(&self, mut opts: DatanodeOptions) -> Result<Instance> {
+    async fn build(&self, opts: DatanodeOptions) -> Result<Instance> {
+        common_runtime::init_global_runtimes(&opts.runtime);
+
         let guard = common_telemetry::init_global_logging(
             APP_NAME,
-            &opts.logging,
-            &opts.tracing,
-            opts.node_id.map(|x| x.to_string()),
+            &opts.component.logging,
+            &opts.component.tracing,
+            opts.component.node_id.map(|x| x.to_string()),
         );
         log_versions(version!(), short_version!());
 
-        let plugins = plugins::setup_datanode_plugins(&mut opts)
-            .await
-            .context(StartDatanodeSnafu)?;
-
         info!("Datanode start command: {:#?}", self);
         info!("Datanode options: {:#?}", opts);
 
-        let node_id = opts
+        let mut opts = opts.component;
+        let plugins = plugins::setup_datanode_plugins(&mut opts)
+            .await
+            .context(StartDatanodeSnafu)?;
+
+        let cluster_id = 0; // TODO(hl): read from config
+        let member_id = opts
             .node_id
             .context(MissingConfigSnafu { msg: "'node_id'" })?;
 
@@ -258,12 +285,16 @@ impl StartCommand {
             msg: "'meta_client_options'",
         })?;
 
-        let meta_client = datanode::heartbeat::new_metasrv_client(node_id, meta_config)
-            .await
-            .context(StartDatanodeSnafu)?;
+        let meta_client = meta_client::create_meta_client(
+            cluster_id,
+            MetaClientType::Datanode { member_id },
+            meta_config,
+        )
+        .await
+        .context(MetaClientInitSnafu)?;
 
         let meta_backend = Arc::new(MetaKvBackend {
-            client: Arc::new(meta_client.clone()),
+            client: meta_client.clone(),
         });
 
         let mut datanode = DatanodeBuilder::new(opts.clone(), plugins)
@@ -299,6 +330,34 @@ mod tests {
     use super::*;
     use crate::options::GlobalOptions;
 
+    #[test]
+    fn test_deprecated_cli_options() {
+        common_telemetry::init_default_ut_logging();
+        let mut file = create_named_temp_file();
+        let toml_str = r#"
+            mode = "distributed"
+            enable_memory_catalog = false
+            node_id = 42
+            
+            rpc_addr = "127.0.0.1:4001"
+            rpc_hostname = "192.168.0.1"
+            [grpc]
+            addr = "127.0.0.1:3001"
+            hostname = "127.0.0.1"
+            runtime_size = 8
+        "#;
+        write!(file, "{}", toml_str).unwrap();
+
+        let cmd = StartCommand {
+            config_file: Some(file.path().to_str().unwrap().to_string()),
+            ..Default::default()
+        };
+
+        let options = cmd.load_options(&Default::default()).unwrap().component;
+        assert_eq!("127.0.0.1:4001".to_string(), options.grpc.addr);
+        assert_eq!("192.168.0.1".to_string(), options.grpc.hostname);
+    }
+
     #[test]
     fn test_read_from_config_file() {
         let mut file = create_named_temp_file();
@@ -306,9 +365,11 @@ mod tests {
             mode = "distributed"
             enable_memory_catalog = false
             node_id = 42
-            rpc_addr = "127.0.0.1:3001"
-            rpc_hostname = "127.0.0.1"
-            rpc_runtime_size = 8
+            
+            [grpc]
+            addr = "127.0.0.1:3001"
+            hostname = "127.0.0.1"
+            runtime_size = 8
 
             [heartbeat]
             interval = "300ms"
@@ -353,9 +414,9 @@ mod tests {
             ..Default::default()
         };
 
-        let options = cmd.load_options(&GlobalOptions::default()).unwrap();
+        let options = cmd.load_options(&Default::default()).unwrap().component;
 
-        assert_eq!("127.0.0.1:3001".to_string(), options.rpc_addr);
+        assert_eq!("127.0.0.1:3001".to_string(), options.grpc.addr);
         assert_eq!(Some(42), options.node_id);
 
         let DatanodeWalConfig::RaftEngine(raft_engine_config) = options.wal else {
@@ -414,7 +475,8 @@ mod tests {
     fn test_try_from_cmd() {
         let opt = StartCommand::default()
             .load_options(&GlobalOptions::default())
-            .unwrap();
+            .unwrap()
+            .component;
         assert_eq!(Mode::Standalone, opt.mode);
 
         let opt = (StartCommand {
@@ -423,7 +485,8 @@ mod tests {
             ..Default::default()
         })
         .load_options(&GlobalOptions::default())
-        .unwrap();
+        .unwrap()
+        .component;
         assert_eq!(Mode::Distributed, opt.mode);
 
         assert!((StartCommand {
@@ -454,7 +517,8 @@ mod tests {
                 #[cfg(feature = "tokio-console")]
                 tokio_console_addr: None,
             })
-            .unwrap();
+            .unwrap()
+            .component;
 
         let logging_opt = options.logging;
         assert_eq!("/tmp/greptimedb/test/logs", logging_opt.dir);
@@ -469,8 +533,8 @@ mod tests {
             enable_memory_catalog = false
             node_id = 42
             rpc_addr = "127.0.0.1:3001"
-            rpc_hostname = "127.0.0.1"
             rpc_runtime_size = 8
+            rpc_hostname = "10.103.174.219"
 
             [meta_client]
             timeout = "3s"
@@ -536,7 +600,7 @@ mod tests {
                     ..Default::default()
                 };
 
-                let opts = command.load_options(&GlobalOptions::default()).unwrap();
+                let opts = command.load_options(&Default::default()).unwrap().component;
 
                 // Should be read from env, env > default values.
                 let DatanodeWalConfig::RaftEngine(raft_engine_config) = opts.wal else {
@@ -562,7 +626,11 @@ mod tests {
                 assert_eq!(raft_engine_config.dir.unwrap(), "/other/wal/dir");
 
                 // Should be default value.
-                assert_eq!(opts.http.addr, DatanodeOptions::default().http.addr);
+                assert_eq!(
+                    opts.http.addr,
+                    DatanodeOptions::default().component.http.addr
+                );
+                assert_eq!(opts.grpc.hostname, "10.103.174.219");
             },
         );
     }

src/cmd/src/error.rs

@@ -87,6 +87,20 @@ pub enum Error {
         source: datanode::error::Error,
     },
 
+    #[snafu(display("Failed to start flownode"))]
+    StartFlownode {
+        #[snafu(implicit)]
+        location: Location,
+        source: flow::Error,
+    },
+
+    #[snafu(display("Failed to shutdown flownode"))]
+    ShutdownFlownode {
+        #[snafu(implicit)]
+        location: Location,
+        source: flow::Error,
+    },
+
     #[snafu(display("Failed to start frontend"))]
     StartFrontend {
         #[snafu(implicit)]
@@ -325,6 +339,22 @@ pub enum Error {
         location: Location,
         source: cache::error::Error,
     },
+
+    #[snafu(display("Failed to initialize meta client"))]
+    MetaClientInit {
+        #[snafu(implicit)]
+        location: Location,
+        source: meta_client::error::Error,
+    },
+
+    #[snafu(display("Tonic transport error: {error:?} with msg: {msg:?}"))]
+    TonicTransport {
+        #[snafu(implicit)]
+        location: Location,
+        #[snafu(source)]
+        error: tonic::transport::Error,
+        msg: Option<String>,
+    },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -375,11 +405,16 @@ impl ErrorExt for Error {
 
             Error::SerdeJson { .. } | Error::FileIo { .. } => StatusCode::Unexpected,
 
-            Error::CacheRequired { .. } | Error::BuildCacheRegistry { .. } => StatusCode::Internal,
-
             Error::Other { source, .. } => source.status_code(),
 
             Error::BuildRuntime { source, .. } => source.status_code(),
+
+            Error::CacheRequired { .. } | Error::BuildCacheRegistry { .. } => StatusCode::Internal,
+            Self::StartFlownode { source, .. } | Self::ShutdownFlownode { source, .. } => {
+                source.status_code()
+            }
+            Error::MetaClientInit { source, .. } => source.status_code(),
+            Error::TonicTransport { .. } => StatusCode::Internal,
         }
     }
 

src/cmd/src/flownode.rs

@@ -0,0 +1,334 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::Arc;
+
+use cache::{build_fundamental_cache_registry, with_default_composite_cache_registry};
+use catalog::kvbackend::{CachedMetaKvBackendBuilder, KvBackendCatalogManager, MetaKvBackend};
+use clap::Parser;
+use client::client_manager::NodeClients;
+use common_base::Plugins;
+use common_config::Configurable;
+use common_grpc::channel_manager::ChannelConfig;
+use common_meta::cache::{CacheRegistryBuilder, LayeredCacheRegistryBuilder};
+use common_meta::heartbeat::handler::parse_mailbox_message::ParseMailboxMessageHandler;
+use common_meta::heartbeat::handler::HandlerGroupExecutor;
+use common_meta::key::TableMetadataManager;
+use common_telemetry::info;
+use common_telemetry::logging::TracingOptions;
+use common_version::{short_version, version};
+use flow::{FlownodeBuilder, FlownodeInstance, FrontendInvoker};
+use frontend::heartbeat::handler::invalidate_table_cache::InvalidateTableCacheHandler;
+use meta_client::{MetaClientOptions, MetaClientType};
+use servers::Mode;
+use snafu::{OptionExt, ResultExt};
+use tracing_appender::non_blocking::WorkerGuard;
+
+use crate::error::{
+    BuildCacheRegistrySnafu, InitMetadataSnafu, LoadLayeredConfigSnafu, MetaClientInitSnafu,
+    MissingConfigSnafu, Result, ShutdownFlownodeSnafu, StartFlownodeSnafu,
+};
+use crate::options::{GlobalOptions, GreptimeOptions};
+use crate::{log_versions, App};
+
+pub const APP_NAME: &str = "greptime-flownode";
+
+type FlownodeOptions = GreptimeOptions<flow::FlownodeOptions>;
+
+pub struct Instance {
+    flownode: FlownodeInstance,
+
+    // Keep the logging guard to prevent the worker from being dropped.
+    _guard: Vec<WorkerGuard>,
+}
+
+impl Instance {
+    pub fn new(flownode: FlownodeInstance, guard: Vec<WorkerGuard>) -> Self {
+        Self {
+            flownode,
+            _guard: guard,
+        }
+    }
+
+    pub fn flownode_mut(&mut self) -> &mut FlownodeInstance {
+        &mut self.flownode
+    }
+
+    pub fn flownode(&self) -> &FlownodeInstance {
+        &self.flownode
+    }
+}
+
+#[async_trait::async_trait]
+impl App for Instance {
+    fn name(&self) -> &str {
+        APP_NAME
+    }
+
+    async fn start(&mut self) -> Result<()> {
+        self.flownode.start().await.context(StartFlownodeSnafu)
+    }
+
+    async fn stop(&self) -> Result<()> {
+        self.flownode
+            .shutdown()
+            .await
+            .context(ShutdownFlownodeSnafu)
+    }
+}
+
+#[derive(Parser)]
+pub struct Command {
+    #[clap(subcommand)]
+    subcmd: SubCommand,
+}
+
+impl Command {
+    pub async fn build(&self, opts: FlownodeOptions) -> Result<Instance> {
+        self.subcmd.build(opts).await
+    }
+
+    pub fn load_options(&self, global_options: &GlobalOptions) -> Result<FlownodeOptions> {
+        match &self.subcmd {
+            SubCommand::Start(cmd) => cmd.load_options(global_options),
+        }
+    }
+}
+
+#[derive(Parser)]
+enum SubCommand {
+    Start(StartCommand),
+}
+
+impl SubCommand {
+    async fn build(&self, opts: FlownodeOptions) -> Result<Instance> {
+        match self {
+            SubCommand::Start(cmd) => cmd.build(opts).await,
+        }
+    }
+}
+
+#[derive(Debug, Parser, Default)]
+struct StartCommand {
+    /// Flownode's id
+    #[clap(long)]
+    node_id: Option<u64>,
+    /// Bind address for the gRPC server.
+    #[clap(long)]
+    rpc_addr: Option<String>,
+    /// Hostname for the gRPC server.
+    #[clap(long)]
+    rpc_hostname: Option<String>,
+    /// Metasrv address list;
+    #[clap(long, value_delimiter = ',', num_args = 1..)]
+    metasrv_addrs: Option<Vec<String>>,
+    /// The configuration file for flownode
+    #[clap(short, long)]
+    config_file: Option<String>,
+    /// The prefix of environment variables, default is `GREPTIMEDB_FLOWNODE`;
+    #[clap(long, default_value = "GREPTIMEDB_FLOWNODE")]
+    env_prefix: String,
+}
+
+impl StartCommand {
+    fn load_options(&self, global_options: &GlobalOptions) -> Result<FlownodeOptions> {
+        let mut opts = FlownodeOptions::load_layered_options(
+            self.config_file.as_deref(),
+            self.env_prefix.as_ref(),
+        )
+        .context(LoadLayeredConfigSnafu)?;
+
+        self.merge_with_cli_options(global_options, &mut opts)?;
+
+        Ok(opts)
+    }
+
+    // The precedence order is: cli > config file > environment variables > default values.
+    fn merge_with_cli_options(
+        &self,
+        global_options: &GlobalOptions,
+        opts: &mut FlownodeOptions,
+    ) -> Result<()> {
+        let opts = &mut opts.component;
+
+        if let Some(dir) = &global_options.log_dir {
+            opts.logging.dir.clone_from(dir);
+        }
+
+        if global_options.log_level.is_some() {
+            opts.logging.level.clone_from(&global_options.log_level);
+        }
+
+        opts.tracing = TracingOptions {
+            #[cfg(feature = "tokio-console")]
+            tokio_console_addr: global_options.tokio_console_addr.clone(),
+        };
+
+        if let Some(addr) = &self.rpc_addr {
+            opts.grpc.addr.clone_from(addr);
+        }
+
+        if let Some(hostname) = &self.rpc_hostname {
+            opts.grpc.hostname.clone_from(hostname);
+        }
+
+        if let Some(node_id) = self.node_id {
+            opts.node_id = Some(node_id);
+        }
+
+        if let Some(metasrv_addrs) = &self.metasrv_addrs {
+            opts.meta_client
+                .get_or_insert_with(MetaClientOptions::default)
+                .metasrv_addrs
+                .clone_from(metasrv_addrs);
+            opts.mode = Mode::Distributed;
+        }
+
+        if let (Mode::Distributed, None) = (&opts.mode, &opts.node_id) {
+            return MissingConfigSnafu {
+                msg: "Missing node id option",
+            }
+            .fail();
+        }
+
+        Ok(())
+    }
+
+    async fn build(&self, opts: FlownodeOptions) -> Result<Instance> {
+        common_runtime::init_global_runtimes(&opts.runtime);
+
+        let guard = common_telemetry::init_global_logging(
+            APP_NAME,
+            &opts.component.logging,
+            &opts.component.tracing,
+            opts.component.node_id.map(|x| x.to_string()),
+        );
+        log_versions(version!(), short_version!());
+
+        info!("Flownode start command: {:#?}", self);
+        info!("Flownode options: {:#?}", opts);
+
+        let opts = opts.component;
+
+        // TODO(discord9): make it not optionale after cluster id is required
+        let cluster_id = opts.cluster_id.unwrap_or(0);
+
+        let member_id = opts
+            .node_id
+            .context(MissingConfigSnafu { msg: "'node_id'" })?;
+
+        let meta_config = opts.meta_client.as_ref().context(MissingConfigSnafu {
+            msg: "'meta_client_options'",
+        })?;
+
+        let meta_client = meta_client::create_meta_client(
+            cluster_id,
+            MetaClientType::Flownode { member_id },
+            meta_config,
+        )
+        .await
+        .context(MetaClientInitSnafu)?;
+
+        let cache_max_capacity = meta_config.metadata_cache_max_capacity;
+        let cache_ttl = meta_config.metadata_cache_ttl;
+        let cache_tti = meta_config.metadata_cache_tti;
+
+        // TODO(discord9): add helper function to ease the creation of cache registry&such
+        let cached_meta_backend = CachedMetaKvBackendBuilder::new(meta_client.clone())
+            .cache_max_capacity(cache_max_capacity)
+            .cache_ttl(cache_ttl)
+            .cache_tti(cache_tti)
+            .build();
+        let cached_meta_backend = Arc::new(cached_meta_backend);
+
+        // Builds cache registry
+        let layered_cache_builder = LayeredCacheRegistryBuilder::default().add_cache_registry(
+            CacheRegistryBuilder::default()
+                .add_cache(cached_meta_backend.clone())
+                .build(),
+        );
+        let fundamental_cache_registry =
+            build_fundamental_cache_registry(Arc::new(MetaKvBackend::new(meta_client.clone())));
+        let layered_cache_registry = Arc::new(
+            with_default_composite_cache_registry(
+                layered_cache_builder.add_cache_registry(fundamental_cache_registry),
+            )
+            .context(BuildCacheRegistrySnafu)?
+            .build(),
+        );
+
+        let catalog_manager = KvBackendCatalogManager::new(
+            opts.mode,
+            Some(meta_client.clone()),
+            cached_meta_backend.clone(),
+            layered_cache_registry.clone(),
+        );
+
+        let table_metadata_manager =
+            Arc::new(TableMetadataManager::new(cached_meta_backend.clone()));
+        table_metadata_manager
+            .init()
+            .await
+            .context(InitMetadataSnafu)?;
+
+        let executor = HandlerGroupExecutor::new(vec![
+            Arc::new(ParseMailboxMessageHandler),
+            Arc::new(InvalidateTableCacheHandler::new(
+                layered_cache_registry.clone(),
+            )),
+        ]);
+
+        let heartbeat_task = flow::heartbeat::HeartbeatTask::new(
+            &opts,
+            meta_client.clone(),
+            opts.heartbeat.clone(),
+            Arc::new(executor),
+        );
+
+        let flownode_builder = FlownodeBuilder::new(
+            opts,
+            Plugins::new(),
+            table_metadata_manager,
+            catalog_manager.clone(),
+        )
+        .with_heartbeat_task(heartbeat_task);
+
+        let flownode = flownode_builder.build().await.context(StartFlownodeSnafu)?;
+
+        // flownode's frontend to datanode need not timeout.
+        // Some queries are expected to take long time.
+        let channel_config = ChannelConfig {
+            timeout: None,
+            ..Default::default()
+        };
+        let client = Arc::new(NodeClients::new(channel_config));
+
+        let invoker = FrontendInvoker::build_from(
+            flownode.flow_worker_manager().clone(),
+            catalog_manager.clone(),
+            cached_meta_backend.clone(),
+            layered_cache_registry.clone(),
+            meta_client.clone(),
+            client,
+        )
+        .await
+        .context(StartFlownodeSnafu)?;
+        flownode
+            .flow_worker_manager()
+            .set_frontend_invoker(invoker)
+            .await;
+
+        Ok(Instance::new(flownode, guard))
+    }
+}

src/cmd/src/frontend.rs

@@ -16,13 +16,10 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use async_trait::async_trait;
-use cache::{
-    build_fundamental_cache_registry, with_default_composite_cache_registry, TABLE_CACHE_NAME,
-    TABLE_ROUTE_CACHE_NAME,
-};
+use cache::{build_fundamental_cache_registry, with_default_composite_cache_registry};
 use catalog::kvbackend::{CachedMetaKvBackendBuilder, KvBackendCatalogManager, MetaKvBackend};
 use clap::Parser;
-use client::client_manager::DatanodeClients;
+use client::client_manager::NodeClients;
 use common_config::Configurable;
 use common_grpc::channel_manager::ChannelConfig;
 use common_meta::cache::{CacheRegistryBuilder, LayeredCacheRegistryBuilder};
@@ -32,24 +29,26 @@ use common_telemetry::info;
 use common_telemetry::logging::TracingOptions;
 use common_time::timezone::set_default_timezone;
 use common_version::{short_version, version};
-use frontend::frontend::FrontendOptions;
 use frontend::heartbeat::handler::invalidate_table_cache::InvalidateTableCacheHandler;
 use frontend::heartbeat::HeartbeatTask;
 use frontend::instance::builder::FrontendBuilder;
 use frontend::instance::{FrontendInstance, Instance as FeInstance};
 use frontend::server::Services;
-use meta_client::MetaClientOptions;
+use meta_client::{MetaClientOptions, MetaClientType};
 use servers::tls::{TlsMode, TlsOption};
 use servers::Mode;
 use snafu::{OptionExt, ResultExt};
 use tracing_appender::non_blocking::WorkerGuard;
 
 use crate::error::{
-    self, InitTimezoneSnafu, LoadLayeredConfigSnafu, MissingConfigSnafu, Result, StartFrontendSnafu,
+    self, InitTimezoneSnafu, LoadLayeredConfigSnafu, MetaClientInitSnafu, MissingConfigSnafu,
+    Result, StartFrontendSnafu,
 };
-use crate::options::GlobalOptions;
+use crate::options::{GlobalOptions, GreptimeOptions};
 use crate::{log_versions, App};
 
+type FrontendOptions = GreptimeOptions<frontend::frontend::FrontendOptions>;
+
 pub struct Instance {
     frontend: FeInstance,
 
@@ -149,7 +148,7 @@ pub struct StartCommand {
     config_file: Option<String>,
     #[clap(short, long)]
     influxdb_enable: Option<bool>,
-    #[clap(long, aliases = ["metasrv-addr"], value_delimiter = ',', num_args = 1..)]
+    #[clap(long, value_delimiter = ',', num_args = 1..)]
     metasrv_addrs: Option<Vec<String>>,
     #[clap(long)]
     tls_mode: Option<TlsMode>,
@@ -167,22 +166,25 @@ pub struct StartCommand {
 
 impl StartCommand {
     fn load_options(&self, global_options: &GlobalOptions) -> Result<FrontendOptions> {
-        self.merge_with_cli_options(
-            global_options,
-            FrontendOptions::load_layered_options(
-                self.config_file.as_deref(),
-                self.env_prefix.as_ref(),
-            )
-            .context(LoadLayeredConfigSnafu)?,
+        let mut opts = FrontendOptions::load_layered_options(
+            self.config_file.as_deref(),
+            self.env_prefix.as_ref(),
         )
+        .context(LoadLayeredConfigSnafu)?;
+
+        self.merge_with_cli_options(global_options, &mut opts)?;
+
+        Ok(opts)
     }
 
     // The precedence order is: cli > config file > environment variables > default values.
     fn merge_with_cli_options(
         &self,
         global_options: &GlobalOptions,
-        mut opts: FrontendOptions,
-    ) -> Result<FrontendOptions> {
+        opts: &mut FrontendOptions,
+    ) -> Result<()> {
+        let opts = &mut opts.component;
+
         if let Some(dir) = &global_options.log_dir {
             opts.logging.dir.clone_from(dir);
         }
@@ -245,26 +247,29 @@ impl StartCommand {
 
         opts.user_provider.clone_from(&self.user_provider);
 
-        Ok(opts)
+        Ok(())
     }
 
-    async fn build(&self, mut opts: FrontendOptions) -> Result<Instance> {
+    async fn build(&self, opts: FrontendOptions) -> Result<Instance> {
+        common_runtime::init_global_runtimes(&opts.runtime);
+
         let guard = common_telemetry::init_global_logging(
             APP_NAME,
-            &opts.logging,
-            &opts.tracing,
-            opts.node_id.clone(),
+            &opts.component.logging,
+            &opts.component.tracing,
+            opts.component.node_id.clone(),
         );
         log_versions(version!(), short_version!());
 
+        info!("Frontend start command: {:#?}", self);
+        info!("Frontend options: {:#?}", opts);
+
+        let mut opts = opts.component;
         #[allow(clippy::unnecessary_mut_passed)]
         let plugins = plugins::setup_frontend_plugins(&mut opts)
             .await
             .context(StartFrontendSnafu)?;
 
-        info!("Frontend start command: {:#?}", self);
-        info!("Frontend options: {:#?}", opts);
-
         set_default_timezone(opts.default_timezone.as_deref()).context(InitTimezoneSnafu)?;
 
         let meta_client_options = opts.meta_client.as_ref().context(MissingConfigSnafu {
@@ -275,10 +280,16 @@ impl StartCommand {
         let cache_ttl = meta_client_options.metadata_cache_ttl;
         let cache_tti = meta_client_options.metadata_cache_tti;
 
-        let meta_client = FeInstance::create_meta_client(meta_client_options)
-            .await
-            .context(StartFrontendSnafu)?;
+        let cluster_id = 0; // (TODO: jeremy): It is currently a reserved field and has not been enabled.
+        let meta_client = meta_client::create_meta_client(
+            cluster_id,
+            MetaClientType::Frontend,
+            meta_client_options,
+        )
+        .await
+        .context(MetaClientInitSnafu)?;
 
+        // TODO(discord9): add helper function to ease the creation of cache registry&such
         let cached_meta_backend = CachedMetaKvBackendBuilder::new(meta_client.clone())
             .cache_max_capacity(cache_max_capacity)
             .cache_ttl(cache_ttl)
@@ -302,25 +313,12 @@ impl StartCommand {
             .build(),
         );
 
-        let table_cache = layered_cache_registry
-            .get()
-            .context(error::CacheRequiredSnafu {
-                name: TABLE_CACHE_NAME,
-            })?;
-        let table_route_cache =
-            layered_cache_registry
-                .get()
-                .context(error::CacheRequiredSnafu {
-                    name: TABLE_ROUTE_CACHE_NAME,
-                })?;
         let catalog_manager = KvBackendCatalogManager::new(
             opts.mode,
             Some(meta_client.clone()),
             cached_meta_backend.clone(),
-            table_cache,
-            table_route_cache,
-        )
-        .await;
+            layered_cache_registry.clone(),
+        );
 
         let executor = HandlerGroupExecutor::new(vec![
             Arc::new(ParseMailboxMessageHandler),
@@ -342,9 +340,10 @@ impl StartCommand {
             timeout: None,
             ..Default::default()
         };
-        let client = DatanodeClients::new(channel_config);
+        let client = NodeClients::new(channel_config);
 
         let mut instance = FrontendBuilder::new(
+            opts.clone(),
             cached_meta_backend.clone(),
             layered_cache_registry.clone(),
             catalog_manager,
@@ -358,12 +357,12 @@ impl StartCommand {
         .await
         .context(StartFrontendSnafu)?;
 
-        let servers = Services::new(opts.clone(), Arc::new(instance.clone()), plugins)
+        let servers = Services::new(opts, Arc::new(instance.clone()), plugins)
             .build()
             .await
             .context(StartFrontendSnafu)?;
         instance
-            .build_servers(opts, servers)
+            .build_servers(servers)
             .context(StartFrontendSnafu)?;
 
         Ok(Instance::new(instance, guard))
@@ -379,7 +378,7 @@ mod tests {
     use common_base::readable_size::ReadableSize;
     use common_config::ENV_VAR_SEP;
     use common_test_util::temp_dir::create_named_temp_file;
-    use frontend::service_config::GrpcOptions;
+    use servers::grpc::GrpcOptions;
     use servers::http::HttpOptions;
 
     use super::*;
@@ -396,14 +395,14 @@ mod tests {
             ..Default::default()
         };
 
-        let opts = command.load_options(&GlobalOptions::default()).unwrap();
+        let opts = command.load_options(&Default::default()).unwrap().component;
 
         assert_eq!(opts.http.addr, "127.0.0.1:1234");
         assert_eq!(ReadableSize::mb(64), opts.http.body_limit);
         assert_eq!(opts.mysql.addr, "127.0.0.1:5678");
         assert_eq!(opts.postgres.addr, "127.0.0.1:5432");
 
-        let default_opts = FrontendOptions::default();
+        let default_opts = FrontendOptions::default().component;
 
         assert_eq!(opts.grpc.addr, default_opts.grpc.addr);
         assert!(opts.mysql.enable);
@@ -444,7 +443,8 @@ mod tests {
             ..Default::default()
         };
 
-        let fe_opts = command.load_options(&GlobalOptions::default()).unwrap();
+        let fe_opts = command.load_options(&Default::default()).unwrap().component;
+
         assert_eq!(Mode::Distributed, fe_opts.mode);
         assert_eq!("127.0.0.1:4000".to_string(), fe_opts.http.addr);
         assert_eq!(Duration::from_secs(30), fe_opts.http.timeout);
@@ -458,7 +458,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_try_from_start_command_to_anymap() {
-        let mut fe_opts = FrontendOptions {
+        let mut fe_opts = frontend::frontend::FrontendOptions {
             http: HttpOptions {
                 disable_dashboard: false,
                 ..Default::default()
@@ -495,7 +495,8 @@ mod tests {
                 #[cfg(feature = "tokio-console")]
                 tokio_console_addr: None,
             })
-            .unwrap();
+            .unwrap()
+            .component;
 
         let logging_opt = options.logging;
         assert_eq!("/tmp/greptimedb/test/logs", logging_opt.dir);
@@ -573,7 +574,7 @@ mod tests {
                     ..Default::default()
                 };
 
-                let fe_opts = command.load_options(&GlobalOptions::default()).unwrap();
+                let fe_opts = command.load_options(&Default::default()).unwrap().component;
 
                 // Should be read from env, env > default values.
                 assert_eq!(fe_opts.mysql.runtime_size, 11);

src/cmd/src/lib.rs

@@ -22,6 +22,7 @@ use crate::error::Result;
 pub mod cli;
 pub mod datanode;
 pub mod error;
+pub mod flownode;
 pub mod frontend;
 pub mod metasrv;
 pub mod options;

src/cmd/src/metasrv.rs

@@ -21,14 +21,15 @@ use common_telemetry::info;
 use common_telemetry::logging::TracingOptions;
 use common_version::{short_version, version};
 use meta_srv::bootstrap::MetasrvInstance;
-use meta_srv::metasrv::MetasrvOptions;
 use snafu::ResultExt;
 use tracing_appender::non_blocking::WorkerGuard;
 
 use crate::error::{self, LoadLayeredConfigSnafu, Result, StartMetaServerSnafu};
-use crate::options::GlobalOptions;
+use crate::options::{GlobalOptions, GreptimeOptions};
 use crate::{log_versions, App};
 
+type MetasrvOptions = GreptimeOptions<meta_srv::metasrv::MetasrvOptions>;
+
 pub const APP_NAME: &str = "greptime-metasrv";
 
 pub struct Instance {
@@ -139,22 +140,25 @@ struct StartCommand {
 
 impl StartCommand {
     fn load_options(&self, global_options: &GlobalOptions) -> Result<MetasrvOptions> {
-        self.merge_with_cli_options(
-            global_options,
-            MetasrvOptions::load_layered_options(
-                self.config_file.as_deref(),
-                self.env_prefix.as_ref(),
-            )
-            .context(LoadLayeredConfigSnafu)?,
+        let mut opts = MetasrvOptions::load_layered_options(
+            self.config_file.as_deref(),
+            self.env_prefix.as_ref(),
         )
+        .context(LoadLayeredConfigSnafu)?;
+
+        self.merge_with_cli_options(global_options, &mut opts)?;
+
+        Ok(opts)
     }
 
     // The precedence order is: cli > config file > environment variables > default values.
     fn merge_with_cli_options(
         &self,
         global_options: &GlobalOptions,
-        mut opts: MetasrvOptions,
-    ) -> Result<MetasrvOptions> {
+        opts: &mut MetasrvOptions,
+    ) -> Result<()> {
+        let opts = &mut opts.component;
+
         if let Some(dir) = &global_options.log_dir {
             opts.logging.dir.clone_from(dir);
         }
@@ -217,21 +221,28 @@ impl StartCommand {
         // Disable dashboard in metasrv.
         opts.http.disable_dashboard = true;
 
-        Ok(opts)
+        Ok(())
     }
 
-    async fn build(&self, mut opts: MetasrvOptions) -> Result<Instance> {
-        let guard =
-            common_telemetry::init_global_logging(APP_NAME, &opts.logging, &opts.tracing, None);
-        log_versions(version!(), short_version!());
+    async fn build(&self, opts: MetasrvOptions) -> Result<Instance> {
+        common_runtime::init_global_runtimes(&opts.runtime);
 
-        let plugins = plugins::setup_metasrv_plugins(&mut opts)
-            .await
-            .context(StartMetaServerSnafu)?;
+        let guard = common_telemetry::init_global_logging(
+            APP_NAME,
+            &opts.component.logging,
+            &opts.component.tracing,
+            None,
+        );
+        log_versions(version!(), short_version!());
 
         info!("Metasrv start command: {:#?}", self);
         info!("Metasrv options: {:#?}", opts);
 
+        let mut opts = opts.component;
+        let plugins = plugins::setup_metasrv_plugins(&mut opts)
+            .await
+            .context(StartMetaServerSnafu)?;
+
         let builder = meta_srv::bootstrap::metasrv_builder(&opts, plugins.clone(), None)
             .await
             .context(error::BuildMetaServerSnafu)?;
@@ -266,7 +277,7 @@ mod tests {
             ..Default::default()
         };
 
-        let options = cmd.load_options(&GlobalOptions::default()).unwrap();
+        let options = cmd.load_options(&Default::default()).unwrap().component;
         assert_eq!("127.0.0.1:3002".to_string(), options.bind_addr);
         assert_eq!(vec!["127.0.0.1:2380".to_string()], options.store_addrs);
         assert_eq!(SelectorType::LoadBased, options.selector);
@@ -299,7 +310,7 @@ mod tests {
             ..Default::default()
         };
 
-        let options = cmd.load_options(&GlobalOptions::default()).unwrap();
+        let options = cmd.load_options(&Default::default()).unwrap().component;
         assert_eq!("127.0.0.1:3002".to_string(), options.bind_addr);
         assert_eq!("127.0.0.1:3002".to_string(), options.server_addr);
         assert_eq!(vec!["127.0.0.1:2379".to_string()], options.store_addrs);
@@ -349,7 +360,8 @@ mod tests {
                 #[cfg(feature = "tokio-console")]
                 tokio_console_addr: None,
             })
-            .unwrap();
+            .unwrap()
+            .component;
 
         let logging_opt = options.logging;
         assert_eq!("/tmp/greptimedb/test/logs", logging_opt.dir);
@@ -406,7 +418,7 @@ mod tests {
                     ..Default::default()
                 };
 
-                let opts = command.load_options(&GlobalOptions::default()).unwrap();
+                let opts = command.load_options(&Default::default()).unwrap().component;
 
                 // Should be read from env, env > default values.
                 assert_eq!(opts.bind_addr, "127.0.0.1:14002");

src/cmd/src/options.rs

@@ -13,6 +13,9 @@
 // limitations under the License.
 
 use clap::Parser;
+use common_config::Configurable;
+use common_runtime::global::RuntimeOptions;
+use serde::{Deserialize, Serialize};
 
 #[derive(Parser, Default, Debug, Clone)]
 pub struct GlobalOptions {
@@ -29,3 +32,22 @@ pub struct GlobalOptions {
     #[arg(global = true)]
     pub tokio_console_addr: Option<String>,
 }
+
+// TODO(LFC): Move logging and tracing options into global options, like the runtime options.
+/// All the options of GreptimeDB.
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct GreptimeOptions<T> {
+    /// The runtime options.
+    pub runtime: RuntimeOptions,
+
+    /// The options of each component (like Datanode or Standalone) of GreptimeDB.
+    #[serde(flatten)]
+    pub component: T,
+}
+
+impl<T: Configurable> Configurable for GreptimeOptions<T> {
+    fn env_list_keys() -> Option<&'static [&'static str]> {
+        T::env_list_keys()
+    }
+}

src/cmd/src/standalone.rs

@@ -16,19 +16,17 @@ use std::sync::Arc;
 use std::{fs, path};
 
 use async_trait::async_trait;
-use cache::{
-    build_fundamental_cache_registry, with_default_composite_cache_registry, TABLE_CACHE_NAME,
-    TABLE_ROUTE_CACHE_NAME,
-};
+use cache::{build_fundamental_cache_registry, with_default_composite_cache_registry};
 use catalog::kvbackend::KvBackendCatalogManager;
 use clap::Parser;
 use common_catalog::consts::{MIN_USER_FLOW_ID, MIN_USER_TABLE_ID};
 use common_config::{metadata_store_dir, Configurable, KvBackendConfig};
+use common_error::ext::BoxedError;
 use common_meta::cache::LayeredCacheRegistryBuilder;
 use common_meta::cache_invalidator::CacheInvalidatorRef;
 use common_meta::ddl::flow_meta::{FlowMetadataAllocator, FlowMetadataAllocatorRef};
 use common_meta::ddl::table_meta::{TableMetadataAllocator, TableMetadataAllocatorRef};
-use common_meta::ddl::{DdlContext, ProcedureExecutorRef};
+use common_meta::ddl::{DdlContext, NoopRegionFailureDetectorControl, ProcedureExecutorRef};
 use common_meta::ddl_manager::DdlManager;
 use common_meta::key::flow::{FlowMetadataManager, FlowMetadataManagerRef};
 use common_meta::key::{TableMetadataManager, TableMetadataManagerRef};
@@ -46,31 +44,34 @@ use common_wal::config::StandaloneWalConfig;
 use datanode::config::{DatanodeOptions, ProcedureConfig, RegionEngineConfig, StorageConfig};
 use datanode::datanode::{Datanode, DatanodeBuilder};
 use file_engine::config::EngineConfig as FileEngineConfig;
-use flow::FlownodeBuilder;
+use flow::{FlowWorkerManager, FlownodeBuilder, FrontendInvoker};
 use frontend::frontend::FrontendOptions;
 use frontend::instance::builder::FrontendBuilder;
 use frontend::instance::{FrontendInstance, Instance as FeInstance, StandaloneDatanodeManager};
 use frontend::server::Services;
 use frontend::service_config::{
-    GrpcOptions, InfluxdbOptions, MysqlOptions, OpentsdbOptions, PostgresOptions, PromStoreOptions,
+    InfluxdbOptions, MysqlOptions, OpentsdbOptions, PostgresOptions, PromStoreOptions,
 };
 use meta_srv::metasrv::{FLOW_ID_SEQ, TABLE_ID_SEQ};
 use mito2::config::MitoConfig;
 use serde::{Deserialize, Serialize};
 use servers::export_metrics::ExportMetricsOption;
+use servers::grpc::GrpcOptions;
 use servers::http::HttpOptions;
 use servers::tls::{TlsMode, TlsOption};
 use servers::Mode;
-use snafu::{OptionExt, ResultExt};
+use snafu::ResultExt;
+use tokio::sync::broadcast;
 use tracing_appender::non_blocking::WorkerGuard;
 
 use crate::error::{
-    BuildCacheRegistrySnafu, CacheRequiredSnafu, CreateDirSnafu, IllegalConfigSnafu,
-    InitDdlManagerSnafu, InitMetadataSnafu, InitTimezoneSnafu, LoadLayeredConfigSnafu, Result,
-    ShutdownDatanodeSnafu, ShutdownFrontendSnafu, StartDatanodeSnafu, StartFrontendSnafu,
-    StartProcedureManagerSnafu, StartWalOptionsAllocatorSnafu, StopProcedureManagerSnafu,
+    BuildCacheRegistrySnafu, CreateDirSnafu, IllegalConfigSnafu, InitDdlManagerSnafu,
+    InitMetadataSnafu, InitTimezoneSnafu, LoadLayeredConfigSnafu, OtherSnafu, Result,
+    ShutdownDatanodeSnafu, ShutdownFlownodeSnafu, ShutdownFrontendSnafu, StartDatanodeSnafu,
+    StartFlownodeSnafu, StartFrontendSnafu, StartProcedureManagerSnafu,
+    StartWalOptionsAllocatorSnafu, StopProcedureManagerSnafu,
 };
-use crate::options::GlobalOptions;
+use crate::options::{GlobalOptions, GreptimeOptions};
 use crate::{log_versions, App};
 
 pub const APP_NAME: &str = "greptime-standalone";
@@ -82,11 +83,14 @@ pub struct Command {
 }
 
 impl Command {
-    pub async fn build(&self, opts: StandaloneOptions) -> Result<Instance> {
+    pub async fn build(&self, opts: GreptimeOptions<StandaloneOptions>) -> Result<Instance> {
         self.subcmd.build(opts).await
     }
 
-    pub fn load_options(&self, global_options: &GlobalOptions) -> Result<StandaloneOptions> {
+    pub fn load_options(
+        &self,
+        global_options: &GlobalOptions,
+    ) -> Result<GreptimeOptions<StandaloneOptions>> {
         self.subcmd.load_options(global_options)
     }
 }
@@ -97,20 +101,23 @@ enum SubCommand {
 }
 
 impl SubCommand {
-    async fn build(&self, opts: StandaloneOptions) -> Result<Instance> {
+    async fn build(&self, opts: GreptimeOptions<StandaloneOptions>) -> Result<Instance> {
         match self {
             SubCommand::Start(cmd) => cmd.build(opts).await,
         }
     }
 
-    fn load_options(&self, global_options: &GlobalOptions) -> Result<StandaloneOptions> {
+    fn load_options(
+        &self,
+        global_options: &GlobalOptions,
+    ) -> Result<GreptimeOptions<StandaloneOptions>> {
         match self {
             SubCommand::Start(cmd) => cmd.load_options(global_options),
         }
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(default)]
 pub struct StandaloneOptions {
     pub mode: Mode,
@@ -164,7 +171,7 @@ impl Default for StandaloneOptions {
     }
 }
 
-impl Configurable<'_> for StandaloneOptions {
+impl Configurable for StandaloneOptions {
     fn env_list_keys() -> Option<&'static [&'static str]> {
         Some(&["wal.broker_endpoints"])
     }
@@ -200,7 +207,7 @@ impl StandaloneOptions {
             wal: cloned_opts.wal.into(),
             storage: cloned_opts.storage,
             region_engine: cloned_opts.region_engine,
-            rpc_addr: cloned_opts.grpc.addr,
+            grpc: cloned_opts.grpc,
             ..Default::default()
         }
     }
@@ -209,6 +216,9 @@ impl StandaloneOptions {
 pub struct Instance {
     datanode: Datanode,
     frontend: FeInstance,
+    // TODO(discord9): wrapped it in flownode instance instead
+    flow_worker_manager: Arc<FlowWorkerManager>,
+    flow_shutdown: broadcast::Sender<()>,
     procedure_manager: ProcedureManagerRef,
     wal_options_allocator: WalOptionsAllocatorRef,
 
@@ -240,6 +250,9 @@ impl App for Instance {
             .context(StartFrontendSnafu)?;
 
         self.frontend.start().await.context(StartFrontendSnafu)?;
+        self.flow_worker_manager
+            .clone()
+            .run_background(Some(self.flow_shutdown.subscribe()));
         Ok(())
     }
 
@@ -258,6 +271,15 @@ impl App for Instance {
             .shutdown()
             .await
             .context(ShutdownDatanodeSnafu)?;
+        self.flow_shutdown
+            .send(())
+            .map_err(|_e| {
+                flow::error::InternalSnafu {
+                    reason: "Failed to send shutdown signal to flow worker manager, all receiver end already closed".to_string(),
+                }
+                .build()
+            })
+            .context(ShutdownFlownodeSnafu)?;
         info!("Datanode instance stopped.");
 
         Ok(())
@@ -294,23 +316,27 @@ pub struct StartCommand {
 }
 
 impl StartCommand {
-    fn load_options(&self, global_options: &GlobalOptions) -> Result<StandaloneOptions> {
-        self.merge_with_cli_options(
-            global_options,
-            StandaloneOptions::load_layered_options(
-                self.config_file.as_deref(),
-                self.env_prefix.as_ref(),
-            )
-            .context(LoadLayeredConfigSnafu)?,
+    fn load_options(
+        &self,
+        global_options: &GlobalOptions,
+    ) -> Result<GreptimeOptions<StandaloneOptions>> {
+        let mut opts = GreptimeOptions::<StandaloneOptions>::load_layered_options(
+            self.config_file.as_deref(),
+            self.env_prefix.as_ref(),
         )
+        .context(LoadLayeredConfigSnafu)?;
+
+        self.merge_with_cli_options(global_options, &mut opts.component)?;
+
+        Ok(opts)
     }
 
     // The precedence order is: cli > config file > environment variables > default values.
     pub fn merge_with_cli_options(
         &self,
         global_options: &GlobalOptions,
-        mut opts: StandaloneOptions,
-    ) -> Result<StandaloneOptions> {
+        opts: &mut StandaloneOptions,
+    ) -> Result<()> {
         // Should always be standalone mode.
         opts.mode = Mode::Standalone;
 
@@ -343,7 +369,7 @@ impl StartCommand {
 
         if let Some(addr) = &self.rpc_addr {
             // frontend grpc addr conflict with datanode default grpc addr
-            let datanode_grpc_addr = DatanodeOptions::default().rpc_addr;
+            let datanode_grpc_addr = DatanodeOptions::default().grpc.addr;
             if addr.eq(&datanode_grpc_addr) {
                 return IllegalConfigSnafu {
                     msg: format!(
@@ -372,20 +398,27 @@ impl StartCommand {
 
         opts.user_provider.clone_from(&self.user_provider);
 
-        Ok(opts)
+        Ok(())
     }
 
     #[allow(unreachable_code)]
     #[allow(unused_variables)]
     #[allow(clippy::diverging_sub_expression)]
-    async fn build(&self, opts: StandaloneOptions) -> Result<Instance> {
-        let guard =
-            common_telemetry::init_global_logging(APP_NAME, &opts.logging, &opts.tracing, None);
+    async fn build(&self, opts: GreptimeOptions<StandaloneOptions>) -> Result<Instance> {
+        common_runtime::init_global_runtimes(&opts.runtime);
+
+        let guard = common_telemetry::init_global_logging(
+            APP_NAME,
+            &opts.component.logging,
+            &opts.component.tracing,
+            None,
+        );
         log_versions(version!(), short_version!());
 
         info!("Standalone start command: {:#?}", self);
-        info!("Building standalone instance with {opts:#?}");
+        info!("Standalone options: {opts:#?}");
 
+        let opts = opts.component;
         let mut fe_opts = opts.frontend_options();
         #[allow(clippy::unnecessary_mut_passed)]
         let fe_plugins = plugins::setup_frontend_plugins(&mut fe_opts) // mut ref is MUST, DO NOT change it
@@ -421,40 +454,39 @@ impl StartCommand {
             .build(),
         );
 
-        let table_cache = layered_cache_registry.get().context(CacheRequiredSnafu {
-            name: TABLE_CACHE_NAME,
-        })?;
-        let table_route_cache = layered_cache_registry.get().context(CacheRequiredSnafu {
-            name: TABLE_ROUTE_CACHE_NAME,
-        })?;
         let catalog_manager = KvBackendCatalogManager::new(
             dn_opts.mode,
             None,
             kv_backend.clone(),
-            table_cache,
-            table_route_cache,
-        )
-        .await;
+            layered_cache_registry.clone(),
+        );
 
         let table_metadata_manager =
             Self::create_table_metadata_manager(kv_backend.clone()).await?;
 
+        let datanode = DatanodeBuilder::new(dn_opts, fe_plugins.clone())
+            .with_kv_backend(kv_backend.clone())
+            .build()
+            .await
+            .context(StartDatanodeSnafu)?;
+
         let flow_builder = FlownodeBuilder::new(
-            1,
             Default::default(),
             fe_plugins.clone(),
             table_metadata_manager.clone(),
             catalog_manager.clone(),
         );
-        let flownode = Arc::new(flow_builder.build().await);
-
-        let builder =
-            DatanodeBuilder::new(dn_opts, fe_plugins.clone()).with_kv_backend(kv_backend.clone());
-        let datanode = builder.build().await.context(StartDatanodeSnafu)?;
+        let flownode = Arc::new(
+            flow_builder
+                .build()
+                .await
+                .map_err(BoxedError::new)
+                .context(OtherSnafu)?,
+        );
 
         let node_manager = Arc::new(StandaloneDatanodeManager {
             region_server: datanode.region_server(),
-            flow_server: flownode.clone(),
+            flow_server: flownode.flow_worker_manager(),
         });
 
         let table_id_sequence = Arc::new(
@@ -494,35 +526,47 @@ impl StartCommand {
         .await?;
 
         let mut frontend = FrontendBuilder::new(
-            kv_backend,
-            layered_cache_registry,
-            catalog_manager,
-            node_manager,
-            ddl_task_executor,
+            fe_opts.clone(),
+            kv_backend.clone(),
+            layered_cache_registry.clone(),
+            catalog_manager.clone(),
+            node_manager.clone(),
+            ddl_task_executor.clone(),
         )
         .with_plugin(fe_plugins.clone())
         .try_build()
         .await
         .context(StartFrontendSnafu)?;
 
+        let flow_worker_manager = flownode.flow_worker_manager();
         // flow server need to be able to use frontend to write insert requests back
-        flownode
-            .set_frontend_invoker(Box::new(frontend.clone()))
-            .await;
-        // TODO(discord9): unify with adding `start` and `shutdown` method to flownode too.
-        let _handle = flownode.clone().run_background();
+        let invoker = FrontendInvoker::build_from(
+            flow_worker_manager.clone(),
+            catalog_manager.clone(),
+            kv_backend.clone(),
+            layered_cache_registry.clone(),
+            ddl_task_executor.clone(),
+            node_manager,
+        )
+        .await
+        .context(StartFlownodeSnafu)?;
+        flow_worker_manager.set_frontend_invoker(invoker).await;
 
-        let servers = Services::new(fe_opts.clone(), Arc::new(frontend.clone()), fe_plugins)
+        let (tx, _rx) = broadcast::channel(1);
+
+        let servers = Services::new(fe_opts, Arc::new(frontend.clone()), fe_plugins)
             .build()
             .await
             .context(StartFrontendSnafu)?;
         frontend
-            .build_servers(fe_opts, servers)
+            .build_servers(servers)
             .context(StartFrontendSnafu)?;
 
         Ok(Instance {
             datanode,
             frontend,
+            flow_worker_manager,
+            flow_shutdown: tx,
             procedure_manager,
             wal_options_allocator,
             _guard: guard,
@@ -548,6 +592,7 @@ impl StartCommand {
                     table_metadata_allocator,
                     flow_metadata_manager,
                     flow_metadata_allocator,
+                    region_failure_detector_controller: Arc::new(NoopRegionFailureDetectorControl),
                 },
                 procedure_manager,
                 true,
@@ -675,7 +720,10 @@ mod tests {
             ..Default::default()
         };
 
-        let options = cmd.load_options(&GlobalOptions::default()).unwrap();
+        let options = cmd
+            .load_options(&GlobalOptions::default())
+            .unwrap()
+            .component;
         let fe_opts = options.frontend_options();
         let dn_opts = options.datanode_options();
         let logging_opts = options.logging;
@@ -736,7 +784,8 @@ mod tests {
                 #[cfg(feature = "tokio-console")]
                 tokio_console_addr: None,
             })
-            .unwrap();
+            .unwrap()
+            .component;
 
         assert_eq!("/tmp/greptimedb/test/logs", opts.logging.dir);
         assert_eq!("debug", opts.logging.level.unwrap());
@@ -798,7 +847,7 @@ mod tests {
                     ..Default::default()
                 };
 
-                let opts = command.load_options(&GlobalOptions::default()).unwrap();
+                let opts = command.load_options(&Default::default()).unwrap().component;
 
                 // Should be read from env, env > default values.
                 assert_eq!(opts.logging.dir, "/other/log/dir");

src/cmd/tests/load_config_test.rs

@@ -0,0 +1,241 @@
+// 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::time::Duration;
+
+use cmd::options::GreptimeOptions;
+use cmd::standalone::StandaloneOptions;
+use common_base::readable_size::ReadableSize;
+use common_config::Configurable;
+use common_grpc::channel_manager::{
+    DEFAULT_MAX_GRPC_RECV_MESSAGE_SIZE, DEFAULT_MAX_GRPC_SEND_MESSAGE_SIZE,
+};
+use common_runtime::global::RuntimeOptions;
+use common_telemetry::logging::LoggingOptions;
+use common_wal::config::raft_engine::RaftEngineConfig;
+use common_wal::config::{DatanodeWalConfig, StandaloneWalConfig};
+use datanode::config::{DatanodeOptions, RegionEngineConfig, StorageConfig};
+use frontend::frontend::FrontendOptions;
+use frontend::service_config::datanode::DatanodeClientOptions;
+use meta_client::MetaClientOptions;
+use meta_srv::metasrv::MetasrvOptions;
+use meta_srv::selector::SelectorType;
+use mito2::config::MitoConfig;
+use servers::export_metrics::ExportMetricsOption;
+use servers::grpc::GrpcOptions;
+
+#[allow(deprecated)]
+#[test]
+fn test_load_datanode_example_config() {
+    let example_config = common_test_util::find_workspace_path("config/datanode.example.toml");
+    let options =
+        GreptimeOptions::<DatanodeOptions>::load_layered_options(example_config.to_str(), "")
+            .unwrap();
+
+    let expected = GreptimeOptions::<DatanodeOptions> {
+        runtime: RuntimeOptions {
+            read_rt_size: 8,
+            write_rt_size: 8,
+            bg_rt_size: 4,
+        },
+        component: DatanodeOptions {
+            node_id: Some(42),
+            meta_client: Some(MetaClientOptions {
+                metasrv_addrs: vec!["127.0.0.1:3002".to_string()],
+                timeout: Duration::from_secs(3),
+                heartbeat_timeout: Duration::from_millis(500),
+                ddl_timeout: Duration::from_secs(10),
+                connect_timeout: Duration::from_secs(1),
+                tcp_nodelay: true,
+                metadata_cache_max_capacity: 100000,
+                metadata_cache_ttl: Duration::from_secs(600),
+                metadata_cache_tti: Duration::from_secs(300),
+            }),
+            wal: DatanodeWalConfig::RaftEngine(RaftEngineConfig {
+                dir: Some("/tmp/greptimedb/wal".to_string()),
+                sync_period: Some(Duration::from_secs(10)),
+                ..Default::default()
+            }),
+            storage: StorageConfig {
+                data_home: "/tmp/greptimedb/".to_string(),
+                ..Default::default()
+            },
+            region_engine: vec![RegionEngineConfig::Mito(MitoConfig {
+                num_workers: 8,
+                auto_flush_interval: Duration::from_secs(3600),
+                scan_parallelism: 0,
+                global_write_buffer_size: ReadableSize::gb(1),
+                global_write_buffer_reject_size: ReadableSize::gb(2),
+                sst_meta_cache_size: ReadableSize::mb(128),
+                vector_cache_size: ReadableSize::mb(512),
+                page_cache_size: ReadableSize::mb(512),
+                max_background_jobs: 4,
+                ..Default::default()
+            })],
+            logging: LoggingOptions {
+                level: Some("info".to_string()),
+                otlp_endpoint: Some("".to_string()),
+                tracing_sample_ratio: Some(Default::default()),
+                ..Default::default()
+            },
+            export_metrics: ExportMetricsOption {
+                self_import: Some(Default::default()),
+                remote_write: Some(Default::default()),
+                ..Default::default()
+            },
+            grpc: GrpcOptions::default().with_addr("127.0.0.1:3001"),
+            rpc_addr: Some("127.0.0.1:3001".to_string()),
+            rpc_hostname: Some("127.0.0.1".to_string()),
+            rpc_runtime_size: Some(8),
+            rpc_max_recv_message_size: Some(DEFAULT_MAX_GRPC_RECV_MESSAGE_SIZE),
+            rpc_max_send_message_size: Some(DEFAULT_MAX_GRPC_SEND_MESSAGE_SIZE),
+            ..Default::default()
+        },
+    };
+
+    assert_eq!(options, expected);
+}
+
+#[test]
+fn test_load_frontend_example_config() {
+    let example_config = common_test_util::find_workspace_path("config/frontend.example.toml");
+    let options =
+        GreptimeOptions::<FrontendOptions>::load_layered_options(example_config.to_str(), "")
+            .unwrap();
+    let expected = GreptimeOptions::<FrontendOptions> {
+        runtime: RuntimeOptions {
+            read_rt_size: 8,
+            write_rt_size: 8,
+            bg_rt_size: 4,
+        },
+        component: FrontendOptions {
+            default_timezone: Some("UTC".to_string()),
+            meta_client: Some(MetaClientOptions {
+                metasrv_addrs: vec!["127.0.0.1:3002".to_string()],
+                timeout: Duration::from_secs(3),
+                heartbeat_timeout: Duration::from_millis(500),
+                ddl_timeout: Duration::from_secs(10),
+                connect_timeout: Duration::from_secs(1),
+                tcp_nodelay: true,
+                metadata_cache_max_capacity: 100000,
+                metadata_cache_ttl: Duration::from_secs(600),
+                metadata_cache_tti: Duration::from_secs(300),
+            }),
+            logging: LoggingOptions {
+                level: Some("info".to_string()),
+                otlp_endpoint: Some("".to_string()),
+                tracing_sample_ratio: Some(Default::default()),
+                ..Default::default()
+            },
+            datanode: frontend::service_config::DatanodeOptions {
+                client: DatanodeClientOptions {
+                    connect_timeout: Duration::from_secs(10),
+                    tcp_nodelay: true,
+                },
+            },
+            export_metrics: ExportMetricsOption {
+                self_import: Some(Default::default()),
+                remote_write: Some(Default::default()),
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+    };
+    assert_eq!(options, expected);
+}
+
+#[test]
+fn test_load_metasrv_example_config() {
+    let example_config = common_test_util::find_workspace_path("config/metasrv.example.toml");
+    let options =
+        GreptimeOptions::<MetasrvOptions>::load_layered_options(example_config.to_str(), "")
+            .unwrap();
+    let expected = GreptimeOptions::<MetasrvOptions> {
+        runtime: RuntimeOptions {
+            read_rt_size: 8,
+            write_rt_size: 8,
+            bg_rt_size: 4,
+        },
+        component: MetasrvOptions {
+            selector: SelectorType::LeaseBased,
+            data_home: "/tmp/metasrv/".to_string(),
+            logging: LoggingOptions {
+                dir: "/tmp/greptimedb/logs".to_string(),
+                level: Some("info".to_string()),
+                otlp_endpoint: Some("".to_string()),
+                tracing_sample_ratio: Some(Default::default()),
+                ..Default::default()
+            },
+            export_metrics: ExportMetricsOption {
+                self_import: Some(Default::default()),
+                remote_write: Some(Default::default()),
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+    };
+    assert_eq!(options, expected);
+}
+
+#[test]
+fn test_load_standalone_example_config() {
+    let example_config = common_test_util::find_workspace_path("config/standalone.example.toml");
+    let options =
+        GreptimeOptions::<StandaloneOptions>::load_layered_options(example_config.to_str(), "")
+            .unwrap();
+    let expected = GreptimeOptions::<StandaloneOptions> {
+        runtime: RuntimeOptions {
+            read_rt_size: 8,
+            write_rt_size: 8,
+            bg_rt_size: 4,
+        },
+        component: StandaloneOptions {
+            default_timezone: Some("UTC".to_string()),
+            wal: StandaloneWalConfig::RaftEngine(RaftEngineConfig {
+                dir: Some("/tmp/greptimedb/wal".to_string()),
+                sync_period: Some(Duration::from_secs(10)),
+                ..Default::default()
+            }),
+            region_engine: vec![RegionEngineConfig::Mito(MitoConfig {
+                num_workers: 8,
+                auto_flush_interval: Duration::from_secs(3600),
+                scan_parallelism: 0,
+                global_write_buffer_size: ReadableSize::gb(1),
+                global_write_buffer_reject_size: ReadableSize::gb(2),
+                sst_meta_cache_size: ReadableSize::mb(128),
+                vector_cache_size: ReadableSize::mb(512),
+                page_cache_size: ReadableSize::mb(512),
+                max_background_jobs: 4,
+                ..Default::default()
+            })],
+            storage: StorageConfig {
+                data_home: "/tmp/greptimedb/".to_string(),
+                ..Default::default()
+            },
+            logging: LoggingOptions {
+                level: Some("info".to_string()),
+                otlp_endpoint: Some("".to_string()),
+                tracing_sample_ratio: Some(Default::default()),
+                ..Default::default()
+            },
+            export_metrics: ExportMetricsOption {
+                self_import: Some(Default::default()),
+                remote_write: Some(Default::default()),
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+    };
+    assert_eq!(options, expected);
+}

src/common/base/src/bytes.rs

@@ -81,16 +81,17 @@ impl PartialEq<Bytes> for [u8] {
 /// Now this buffer is restricted to only hold valid UTF-8 string (only allow constructing `StringBytes`
 /// from String or str). We may support other encoding in the future.
 #[derive(Debug, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct StringBytes(bytes::Bytes);
+pub struct StringBytes(String);
 
 impl StringBytes {
     /// View this string as UTF-8 string slice.
-    ///
-    /// # Safety
-    /// We only allow constructing `StringBytes` from String/str, so the inner
-    /// buffer must holds valid UTF-8.
     pub fn as_utf8(&self) -> &str {
-        unsafe { std::str::from_utf8_unchecked(&self.0) }
+        &self.0
+    }
+
+    /// Convert this string into owned UTF-8 string.
+    pub fn into_string(self) -> String {
+        self.0
     }
 
     pub fn len(&self) -> usize {
@@ -104,37 +105,37 @@ impl StringBytes {
 
 impl From<String> for StringBytes {
     fn from(string: String) -> StringBytes {
-        StringBytes(bytes::Bytes::from(string))
+        StringBytes(string)
     }
 }
 
 impl From<&str> for StringBytes {
     fn from(string: &str) -> StringBytes {
-        StringBytes(bytes::Bytes::copy_from_slice(string.as_bytes()))
+        StringBytes(string.to_string())
     }
 }
 
 impl PartialEq<String> for StringBytes {
     fn eq(&self, other: &String) -> bool {
-        self.0 == other.as_bytes()
+        &self.0 == other
     }
 }
 
 impl PartialEq<StringBytes> for String {
     fn eq(&self, other: &StringBytes) -> bool {
-        self.as_bytes() == other.0
+        self == &other.0
     }
 }
 
 impl PartialEq<str> for StringBytes {
     fn eq(&self, other: &str) -> bool {
-        self.0 == other.as_bytes()
+        self.0.as_str() == other
     }
 }
 
 impl PartialEq<StringBytes> for str {
     fn eq(&self, other: &StringBytes) -> bool {
-        self.as_bytes() == other.0
+        self == other.0
     }
 }
 

src/common/catalog/src/consts.rs

@@ -108,3 +108,7 @@ pub const FILE_ENGINE: &str = "file";
 pub const SEMANTIC_TYPE_PRIMARY_KEY: &str = "TAG";
 pub const SEMANTIC_TYPE_FIELD: &str = "FIELD";
 pub const SEMANTIC_TYPE_TIME_INDEX: &str = "TIMESTAMP";
+
+pub fn is_readonly_schema(schema: &str) -> bool {
+    matches!(schema, INFORMATION_SCHEMA_NAME)
+}

src/common/config/src/config.rs

@@ -13,7 +13,8 @@
 // limitations under the License.
 
 use config::{Environment, File, FileFormat};
-use serde::{Deserialize, Serialize};
+use serde::de::DeserializeOwned;
+use serde::Serialize;
 use snafu::ResultExt;
 
 use crate::error::{LoadLayeredConfigSnafu, Result, SerdeJsonSnafu, TomlFormatSnafu};
@@ -25,7 +26,7 @@ pub const ENV_VAR_SEP: &str = "__";
 pub const ENV_LIST_SEP: &str = ",";
 
 /// Configuration trait defines the common interface for configuration that can be loaded from multiple sources and serialized to TOML.
-pub trait Configurable<'de>: Serialize + Deserialize<'de> + Default + Sized {
+pub trait Configurable: Serialize + DeserializeOwned + Default + Sized {
     /// Load the configuration from multiple sources and merge them.
     /// The precedence order is: config file > environment variables > default values.
     /// `env_prefix` is the prefix of environment variables, e.g. "FRONTEND__xxx".
@@ -128,7 +129,7 @@ mod tests {
         }
     }
 
-    impl Configurable<'_> for TestDatanodeConfig {
+    impl Configurable for TestDatanodeConfig {
         fn env_list_keys() -> Option<&'static [&'static str]> {
             Some(&["meta_client.metasrv_addrs"])
         }

src/common/datasource/Cargo.toml

@@ -20,6 +20,7 @@ async-compression = { version = "0.3", features = [
 ] }
 async-trait.workspace = true
 bytes.workspace = true
+common-base.workspace = true
 common-error.workspace = true
 common-macro.workspace = true
 common-recordbatch.workspace = true
@@ -30,9 +31,12 @@ derive_builder.workspace = true
 futures.workspace = true
 lazy_static.workspace = true
 object-store.workspace = true
-orc-rust = { git = "https://github.com/datafusion-contrib/datafusion-orc.git", rev = "502217315726314c4008808fe169764529640599" }
+orc-rust = { git = "https://github.com/datafusion-contrib/datafusion-orc.git", rev = "502217315726314c4008808fe169764529640599", default-features = false, features = [
+    "async",
+] }
 parquet.workspace = true
 paste = "1.0"
+rand.workspace = true
 regex = "1.7"
 serde.workspace = true
 snafu.workspace = true
@@ -42,4 +46,7 @@ tokio-util.workspace = true
 url = "2.3"
 
 [dev-dependencies]
+common-telemetry.workspace = true
 common-test-util.workspace = true
+dotenv.workspace = true
+uuid.workspace = true

src/common/datasource/src/file_format.rs

@@ -46,6 +46,7 @@ use crate::buffered_writer::{DfRecordBatchEncoder, LazyBufferedWriter};
 use crate::compression::CompressionType;
 use crate::error::{self, Result};
 use crate::share_buffer::SharedBuffer;
+use crate::DEFAULT_WRITE_BUFFER_SIZE;
 
 pub const FORMAT_COMPRESSION_TYPE: &str = "compression_type";
 pub const FORMAT_DELIMITER: &str = "delimiter";
@@ -148,7 +149,9 @@ pub fn open_with_decoder<T: ArrowDecoder, F: Fn() -> DataFusionResult<T>>(
             .reader(&path)
             .await
             .map_err(|e| DataFusionError::External(Box::new(e)))?
-            .into_bytes_stream(..);
+            .into_bytes_stream(..)
+            .await
+            .map_err(|e| DataFusionError::External(Box::new(e)))?;
 
         let mut upstream = compression_type.convert_stream(reader).fuse();
 
@@ -204,6 +207,7 @@ pub async fn stream_to_file<T: DfRecordBatchEncoder, U: Fn(SharedBuffer) -> T>(
         store
             .writer_with(&path)
             .concurrent(concurrency)
+            .chunk(DEFAULT_WRITE_BUFFER_SIZE.as_bytes() as usize)
             .await
             .map(|v| v.into_futures_async_write().compat_write())
             .context(error::WriteObjectSnafu { path })

src/common/datasource/src/file_format/csv.rs

@@ -169,11 +169,14 @@ impl FileFormat for CsvFormat {
             .stat(path)
             .await
             .context(error::ReadObjectSnafu { path })?;
+
         let reader = store
             .reader(path)
             .await
             .context(error::ReadObjectSnafu { path })?
             .into_futures_async_read(0..meta.content_length())
+            .await
+            .context(error::ReadObjectSnafu { path })?
             .compat();
 
         let decoded = self.compression_type.convert_async_read(reader);

src/common/datasource/src/file_format/json.rs

@@ -87,11 +87,14 @@ impl FileFormat for JsonFormat {
             .stat(path)
             .await
             .context(error::ReadObjectSnafu { path })?;
+
         let reader = store
             .reader(path)
             .await
             .context(error::ReadObjectSnafu { path })?
             .into_futures_async_read(0..meta.content_length())
+            .await
+            .context(error::ReadObjectSnafu { path })?
             .compat();
 
         let decoded = self.compression_type.convert_async_read(reader);

src/common/datasource/src/file_format/parquet.rs

@@ -16,7 +16,7 @@ use std::result;
 use std::sync::Arc;
 
 use arrow::record_batch::RecordBatch;
-use arrow_schema::{Schema, SchemaRef};
+use arrow_schema::Schema;
 use async_trait::async_trait;
 use datafusion::datasource::physical_plan::{FileMeta, ParquetFileReaderFactory};
 use datafusion::error::Result as DatafusionResult;
@@ -30,15 +30,17 @@ use datafusion::physical_plan::SendableRecordBatchStream;
 use futures::future::BoxFuture;
 use futures::StreamExt;
 use object_store::{FuturesAsyncReader, ObjectStore};
+use parquet::arrow::AsyncArrowWriter;
 use parquet::basic::{Compression, ZstdLevel};
 use parquet::file::properties::WriterProperties;
 use snafu::ResultExt;
 use tokio_util::compat::{Compat, FuturesAsyncReadCompatExt, FuturesAsyncWriteCompatExt};
 
-use crate::buffered_writer::{ArrowWriterCloser, DfRecordBatchEncoder, LazyBufferedWriter};
-use crate::error::{self, Result};
+use crate::buffered_writer::{ArrowWriterCloser, DfRecordBatchEncoder};
+use crate::error::{self, Result, WriteObjectSnafu, WriteParquetSnafu};
 use crate::file_format::FileFormat;
 use crate::share_buffer::SharedBuffer;
+use crate::DEFAULT_WRITE_BUFFER_SIZE;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub struct ParquetFormat {}
@@ -50,11 +52,14 @@ impl FileFormat for ParquetFormat {
             .stat(path)
             .await
             .context(error::ReadObjectSnafu { path })?;
+
         let mut reader = store
             .reader(path)
             .await
             .context(error::ReadObjectSnafu { path })?
             .into_futures_async_read(0..meta.content_length())
+            .await
+            .context(error::ReadObjectSnafu { path })?
             .compat();
 
         let metadata = reader
@@ -127,6 +132,7 @@ impl LazyParquetFileReader {
                 .reader(&self.path)
                 .await?
                 .into_futures_async_read(0..meta.content_length())
+                .await?
                 .compat();
             self.reader = Some(reader);
         }
@@ -173,74 +179,6 @@ impl ArrowWriterCloser for ArrowWriter<SharedBuffer> {
     }
 }
 
-/// Parquet writer that buffers row groups in memory and writes buffered data to an underlying
-/// storage by chunks to reduce memory consumption.
-pub struct BufferedWriter {
-    inner: InnerBufferedWriter,
-}
-
-type InnerBufferedWriter = LazyBufferedWriter<
-    Compat<object_store::FuturesAsyncWriter>,
-    ArrowWriter<SharedBuffer>,
-    impl Fn(String) -> BoxFuture<'static, Result<Compat<object_store::FuturesAsyncWriter>>>,
->;
-
-impl BufferedWriter {
-    fn make_write_factory(
-        store: ObjectStore,
-        concurrency: usize,
-    ) -> impl Fn(String) -> BoxFuture<'static, Result<Compat<object_store::FuturesAsyncWriter>>>
-    {
-        move |path| {
-            let store = store.clone();
-            Box::pin(async move {
-                store
-                    .writer_with(&path)
-                    .concurrent(concurrency)
-                    .await
-                    .map(|v| v.into_futures_async_write().compat_write())
-                    .context(error::WriteObjectSnafu { path })
-            })
-        }
-    }
-
-    pub async fn try_new(
-        path: String,
-        store: ObjectStore,
-        arrow_schema: SchemaRef,
-        props: Option<WriterProperties>,
-        buffer_threshold: usize,
-        concurrency: usize,
-    ) -> error::Result<Self> {
-        let buffer = SharedBuffer::with_capacity(buffer_threshold);
-
-        let arrow_writer = ArrowWriter::try_new(buffer.clone(), arrow_schema.clone(), props)
-            .context(error::WriteParquetSnafu { path: &path })?;
-
-        Ok(Self {
-            inner: LazyBufferedWriter::new(
-                buffer_threshold,
-                buffer,
-                arrow_writer,
-                &path,
-                Self::make_write_factory(store, concurrency),
-            ),
-        })
-    }
-
-    /// Write a record batch to stream writer.
-    pub async fn write(&mut self, arrow_batch: &RecordBatch) -> error::Result<()> {
-        self.inner.write(arrow_batch).await
-    }
-
-    /// Close parquet writer.
-    ///
-    /// Return file metadata and bytes written.
-    pub async fn close(self) -> error::Result<(FileMetaData, u64)> {
-        self.inner.close_with_arrow_writer().await
-    }
-}
-
 /// Output the stream to a parquet file.
 ///
 /// Returns number of rows written.
@@ -248,29 +186,33 @@ pub async fn stream_to_parquet(
     mut stream: SendableRecordBatchStream,
     store: ObjectStore,
     path: &str,
-    threshold: usize,
     concurrency: usize,
 ) -> Result<usize> {
     let write_props = WriterProperties::builder()
         .set_compression(Compression::ZSTD(ZstdLevel::default()))
         .build();
     let schema = stream.schema();
-    let mut buffered_writer = BufferedWriter::try_new(
-        path.to_string(),
-        store,
-        schema,
-        Some(write_props),
-        threshold,
-        concurrency,
-    )
-    .await?;
+    let inner_writer = store
+        .writer_with(path)
+        .concurrent(concurrency)
+        .chunk(DEFAULT_WRITE_BUFFER_SIZE.as_bytes() as usize)
+        .await
+        .map(|w| w.into_futures_async_write().compat_write())
+        .context(WriteObjectSnafu { path })?;
+
+    let mut writer = AsyncArrowWriter::try_new(inner_writer, schema, Some(write_props))
+        .context(WriteParquetSnafu { path })?;
     let mut rows_written = 0;
+
     while let Some(batch) = stream.next().await {
         let batch = batch.context(error::ReadRecordBatchSnafu)?;
-        buffered_writer.write(&batch).await?;
+        writer
+            .write(&batch)
+            .await
+            .context(WriteParquetSnafu { path })?;
         rows_written += batch.num_rows();
     }
-    buffered_writer.close().await?;
+    writer.close().await.context(WriteParquetSnafu { path })?;
     Ok(rows_written)
 }
 

src/common/datasource/src/file_format/tests.rs

@@ -19,7 +19,6 @@ use std::vec;
 
 use common_test_util::find_workspace_path;
 use datafusion::assert_batches_eq;
-use datafusion::config::TableParquetOptions;
 use datafusion::datasource::physical_plan::{FileOpener, FileScanConfig, FileStream, ParquetExec};
 use datafusion::execution::context::TaskContext;
 use datafusion::physical_plan::metrics::ExecutionPlanMetricsSet;
@@ -167,8 +166,9 @@ async fn test_parquet_exec() {
         .to_string();
     let base_config = scan_config(schema.clone(), None, path);
 
-    let exec = ParquetExec::new(base_config, None, None, TableParquetOptions::default())
-        .with_parquet_file_reader_factory(Arc::new(DefaultParquetFileReaderFactory::new(store)));
+    let exec = ParquetExec::builder(base_config)
+        .with_parquet_file_reader_factory(Arc::new(DefaultParquetFileReaderFactory::new(store)))
+        .build();
 
     let ctx = SessionContext::new();
 

src/common/datasource/src/lib.rs

@@ -27,3 +27,8 @@ pub mod test_util;
 #[cfg(test)]
 pub mod tests;
 pub mod util;
+
+use common_base::readable_size::ReadableSize;
+
+/// Default write buffer size, it should be greater than the default minimum upload part of S3 (5mb).
+pub const DEFAULT_WRITE_BUFFER_SIZE: ReadableSize = ReadableSize::mb(8);

src/common/decimal/src/decimal128.rs

@@ -121,6 +121,11 @@ impl Decimal128 {
         let value = (hi | lo) as i128;
         Self::new(value, precision, scale)
     }
+
+    pub fn negative(mut self) -> Self {
+        self.value = -self.value;
+        self
+    }
 }
 
 /// The default value of Decimal128 is 0, and its precision is 1 and scale is 0.

src/common/error/Cargo.toml

@@ -10,3 +10,4 @@ workspace = true
 [dependencies]
 snafu.workspace = true
 strum.workspace = true
+tonic.workspace = true

src/common/error/src/ext.rs

@@ -105,6 +105,10 @@ impl BoxedError {
             inner: Box::new(err),
         }
     }
+
+    pub fn into_inner(self) -> Box<dyn crate::ext::ErrorExt + Send + Sync> {
+        self.inner
+    }
 }
 
 impl std::fmt::Debug for BoxedError {

src/common/error/src/status_code.rs

@@ -15,6 +15,7 @@
 use std::fmt;
 
 use strum::{AsRefStr, EnumIter, EnumString, FromRepr};
+use tonic::Code;
 
 /// Common status code for public API.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, EnumString, AsRefStr, EnumIter, FromRepr)]
@@ -158,7 +159,6 @@ impl StatusCode {
             | StatusCode::Unexpected
             | StatusCode::Internal
             | StatusCode::Cancelled
-            | StatusCode::PlanQuery
             | StatusCode::EngineExecuteQuery
             | StatusCode::StorageUnavailable
             | StatusCode::RuntimeResourcesExhausted => true,
@@ -170,6 +170,7 @@ impl StatusCode {
             | StatusCode::TableNotFound
             | StatusCode::RegionAlreadyExists
             | StatusCode::RegionNotFound
+            | StatusCode::PlanQuery
             | StatusCode::FlowAlreadyExists
             | StatusCode::FlowNotFound
             | StatusCode::RegionNotReady
@@ -202,6 +203,75 @@ impl fmt::Display for StatusCode {
     }
 }
 
+#[macro_export]
+macro_rules! define_into_tonic_status {
+    ($Error: ty) => {
+        impl From<$Error> for tonic::Status {
+            fn from(err: $Error) -> Self {
+                use tonic::codegen::http::{HeaderMap, HeaderValue};
+                use tonic::metadata::MetadataMap;
+                use $crate::GREPTIME_DB_HEADER_ERROR_CODE;
+
+                let mut headers = HeaderMap::<HeaderValue>::with_capacity(2);
+
+                // If either of the status_code or error msg cannot convert to valid HTTP header value
+                // (which is a very rare case), just ignore. Client will use Tonic status code and message.
+                let status_code = err.status_code();
+                headers.insert(
+                    GREPTIME_DB_HEADER_ERROR_CODE,
+                    HeaderValue::from(status_code as u32),
+                );
+                let root_error = err.output_msg();
+
+                let metadata = MetadataMap::from_headers(headers);
+                tonic::Status::with_metadata(
+                    $crate::status_code::status_to_tonic_code(status_code),
+                    root_error,
+                    metadata,
+                )
+            }
+        }
+    };
+}
+
+/// Returns the tonic [Code] of a [StatusCode].
+pub fn status_to_tonic_code(status_code: StatusCode) -> Code {
+    match status_code {
+        StatusCode::Success => Code::Ok,
+        StatusCode::Unknown => Code::Unknown,
+        StatusCode::Unsupported => Code::Unimplemented,
+        StatusCode::Unexpected
+        | StatusCode::Internal
+        | StatusCode::PlanQuery
+        | StatusCode::EngineExecuteQuery => Code::Internal,
+        StatusCode::InvalidArguments | StatusCode::InvalidSyntax | StatusCode::RequestOutdated => {
+            Code::InvalidArgument
+        }
+        StatusCode::Cancelled => Code::Cancelled,
+        StatusCode::TableAlreadyExists
+        | StatusCode::TableColumnExists
+        | StatusCode::RegionAlreadyExists
+        | StatusCode::FlowAlreadyExists => Code::AlreadyExists,
+        StatusCode::TableNotFound
+        | StatusCode::RegionNotFound
+        | StatusCode::TableColumnNotFound
+        | StatusCode::DatabaseNotFound
+        | StatusCode::UserNotFound
+        | StatusCode::FlowNotFound => Code::NotFound,
+        StatusCode::StorageUnavailable | StatusCode::RegionNotReady => Code::Unavailable,
+        StatusCode::RuntimeResourcesExhausted
+        | StatusCode::RateLimited
+        | StatusCode::RegionBusy => Code::ResourceExhausted,
+        StatusCode::UnsupportedPasswordType
+        | StatusCode::UserPasswordMismatch
+        | StatusCode::AuthHeaderNotFound
+        | StatusCode::InvalidAuthHeader => Code::Unauthenticated,
+        StatusCode::AccessDenied | StatusCode::PermissionDenied | StatusCode::RegionReadonly => {
+            Code::PermissionDenied
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use strum::IntoEnumIterator;