fix: static assets path prefix

.cargo/config.toml

@@ -12,5 +12,4 @@ rustflags = [
     "-Wclippy::print_stdout",
     "-Wclippy::print_stderr",
     "-Wclippy::implicit_clone",
-    "-Aclippy::items_after_test_module",
 ]

.env.example

@@ -3,15 +3,8 @@ GT_S3_BUCKET=S3 bucket
 GT_S3_ACCESS_KEY_ID=S3 access key id
 GT_S3_ACCESS_KEY=S3 secret access key
 GT_S3_ENDPOINT_URL=S3 endpoint url
-GT_S3_REGION=S3 region
 # Settings for oss test
 GT_OSS_BUCKET=OSS bucket
 GT_OSS_ACCESS_KEY_ID=OSS access key id
 GT_OSS_ACCESS_KEY=OSS access key
 GT_OSS_ENDPOINT=OSS endpoint
-# Settings for azblob test
-GT_AZBLOB_CONTAINER=AZBLOB container
-GT_AZBLOB_ACCOUNT_NAME=AZBLOB account name
-GT_AZBLOB_ACCOUNT_KEY=AZBLOB account key
-GT_AZBLOB_ENDPOINT=AZBLOB endpoint
-

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -81,5 +81,6 @@ body:
         Please walk us through and provide steps and details on how
         to reproduce the issue. If possible, provide scripts that we
         can run to trigger the bug.
+      render: bash
     validations:
       required: true

.github/workflows/apidoc.yml

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

.github/workflows/develop.yml

@@ -24,7 +24,7 @@ on:
 name: CI
 
 env:
-  RUST_TOOLCHAIN: nightly-2023-05-03
+  RUST_TOOLCHAIN: nightly-2023-02-26
 
 jobs:
   typos:
@@ -141,7 +141,6 @@ jobs:
       - name: Run sqlness
         run: cargo sqlness && ls /tmp
       - name: Upload sqlness logs
-        if: always()
         uses: actions/upload-artifact@v3
         with:
           name: sqlness-logs
@@ -217,7 +216,7 @@ jobs:
       - name: Install cargo-llvm-cov
         uses: taiki-e/install-action@cargo-llvm-cov
       - name: Collect coverage data
-        run: cargo llvm-cov nextest --workspace --lcov --output-path lcov.info -F pyo3_backend -F dashboard
+        run: cargo llvm-cov nextest --workspace --lcov --output-path lcov.info -F pyo3_backend
         env:
           CARGO_BUILD_RUSTFLAGS: "-C link-arg=-fuse-ld=lld"
           RUST_BACKTRACE: 1
@@ -225,7 +224,6 @@ jobs:
           GT_S3_BUCKET: ${{ secrets.S3_BUCKET }}
           GT_S3_ACCESS_KEY_ID: ${{ secrets.S3_ACCESS_KEY_ID }}
           GT_S3_ACCESS_KEY: ${{ secrets.S3_ACCESS_KEY }}
-          GT_S3_REGION: ${{ secrets.S3_REGION }}
           UNITTEST_LOG_DIR: "__unittest_logs"
       - name: Codecov upload
         uses: codecov/codecov-action@v2

.github/workflows/release.yml

@@ -7,127 +7,24 @@ on:
     - cron: '0 0 * * 1'
   # Mannually trigger only builds binaries.
   workflow_dispatch:
-    inputs:
-      dry_run:
-        description: 'Skip docker push and release steps'
-        type: boolean
-        default: true
-      skip_test:
-        description: 'Do not run tests during build'
-        type: boolean
-        default: false
 
 name: Release
 
 env:
-  RUST_TOOLCHAIN: nightly-2023-05-03
+  RUST_TOOLCHAIN: nightly-2023-02-26
 
-  SCHEDULED_BUILD_VERSION_PREFIX: v0.4.0
+  SCHEDULED_BUILD_VERSION_PREFIX: v0.2.0
 
   SCHEDULED_PERIOD: nightly
 
   CARGO_PROFILE: nightly
 
-  # Controls whether to run tests, include unit-test, integration-test and sqlness.
-  DISABLE_RUN_TESTS: ${{ inputs.skip_test || false }}
+  ## FIXME(zyy17): Enable it after the tests are stabled.
+  DISABLE_RUN_TESTS: true
 
 jobs:
-  build-macos:
-    name: Build macOS binary
-    strategy:
-      matrix:
-        # The file format is greptime-<os>-<arch>
-        include:
-          - arch: aarch64-apple-darwin
-            os: self-hosted
-            file: greptime-darwin-arm64
-            continue-on-error: false
-            opts: "-F servers/dashboard"
-          - arch: x86_64-apple-darwin
-            os: self-hosted
-            file: greptime-darwin-amd64
-            continue-on-error: false
-            opts: "-F servers/dashboard"
-          - arch: aarch64-apple-darwin
-            os: self-hosted
-            file: greptime-darwin-arm64-pyo3
-            continue-on-error: false
-            opts: "-F pyo3_backend,servers/dashboard"
-          - arch: x86_64-apple-darwin
-            os: self-hosted
-            file: greptime-darwin-amd64-pyo3
-            continue-on-error: false
-            opts: "-F pyo3_backend,servers/dashboard"
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.continue-on-error }}
-    if: github.repository == 'GreptimeTeam/greptimedb'
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v3
-
-      - name: Cache cargo assets
-        id: cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-          key: ${{ matrix.arch }}-build-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-      - name: Install Protoc for macos
-        if: contains(matrix.arch, 'darwin')
-        run: |
-          brew install protobuf
-
-      - name: Install etcd for macos
-        if: contains(matrix.arch, 'darwin')
-        run: |
-          brew install etcd
-          brew services start etcd
-
-      - name: Install rust toolchain
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ env.RUST_TOOLCHAIN }}
-          targets: ${{ matrix.arch }}
-      - name: Install latest nextest release
-        uses: taiki-e/install-action@nextest
-      - name: Output package versions
-        run: protoc --version ; cargo version ; rustc --version ; gcc --version ; g++ --version
-
-      - name: Run tests
-        if: env.DISABLE_RUN_TESTS == 'false'
-        run: make test sqlness-test
-
-      - name: Run cargo build
-        if: contains(matrix.arch, 'darwin') || contains(matrix.opts, 'pyo3_backend') == false
-        run: cargo build --profile ${{ env.CARGO_PROFILE }} --locked --target ${{ matrix.arch }} ${{ matrix.opts }}
-
-      - name: Calculate checksum and rename binary
-        shell: bash
-        run: |
-          cd target/${{ matrix.arch }}/${{ env.CARGO_PROFILE }}
-          chmod +x greptime
-          tar -zcvf ${{ matrix.file }}.tgz greptime
-          echo $(shasum -a 256 ${{ matrix.file }}.tgz | cut -f1 -d' ') > ${{ matrix.file }}.sha256sum
-
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: ${{ matrix.file }}
-          path: target/${{ matrix.arch }}/${{ env.CARGO_PROFILE }}/${{ matrix.file }}.tgz
-
-      - name: Upload checksum of artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: ${{ matrix.file }}.sha256sum
-          path: target/${{ matrix.arch }}/${{ env.CARGO_PROFILE }}/${{ matrix.file }}.sha256sum
-
-  build-linux:
-    name: Build linux binary
+  build:
+    name: Build binary
     strategy:
       matrix:
         # The file format is greptime-<os>-<arch>
@@ -142,6 +39,16 @@ jobs:
             file: greptime-linux-arm64
             continue-on-error: false
             opts: "-F servers/dashboard"
+          - arch: aarch64-apple-darwin
+            os: macos-latest
+            file: greptime-darwin-arm64
+            continue-on-error: false
+            opts: "-F servers/dashboard"
+          - arch: x86_64-apple-darwin
+            os: macos-latest
+            file: greptime-darwin-amd64
+            continue-on-error: false
+            opts: "-F servers/dashboard"
           - arch: x86_64-unknown-linux-gnu
             os: ubuntu-2004-16-cores
             file: greptime-linux-amd64-pyo3
@@ -152,6 +59,16 @@ jobs:
             file: greptime-linux-arm64-pyo3
             continue-on-error: false
             opts: "-F pyo3_backend,servers/dashboard"
+          - arch: aarch64-apple-darwin
+            os: macos-latest
+            file: greptime-darwin-arm64-pyo3
+            continue-on-error: false
+            opts: "-F pyo3_backend,servers/dashboard"
+          - arch: x86_64-apple-darwin
+            os: macos-latest
+            file: greptime-darwin-amd64-pyo3
+            continue-on-error: false
+            opts: "-F pyo3_backend,servers/dashboard"
     runs-on: ${{ matrix.os }}
     continue-on-error: ${{ matrix.continue-on-error }}
     if: github.repository == 'GreptimeTeam/greptimedb'
@@ -179,6 +96,11 @@ jobs:
           sudo cp protoc/bin/protoc /usr/local/bin/
           sudo cp -r protoc/include/google /usr/local/include/
 
+      - name: Install Protoc for macos
+        if: contains(matrix.arch, 'darwin')
+        run: |
+          brew install protobuf
+
       - name: Install etcd for linux
         if: contains(matrix.arch, 'linux') && endsWith(matrix.arch, '-gnu')
         run: |
@@ -192,6 +114,12 @@ jobs:
           sudo cp -a /tmp/etcd-download/etcd* /usr/local/bin/
           nohup etcd >/tmp/etcd.log 2>&1 &
 
+      - name: Install etcd for macos
+        if: contains(matrix.arch, 'darwin')
+        run: |
+          brew install etcd
+          brew services start etcd
+
       - name: Install dependencies for linux
         if: contains(matrix.arch, 'linux') && endsWith(matrix.arch, '-gnu')
         run: |
@@ -210,18 +138,13 @@ jobs:
         with:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
           targets: ${{ matrix.arch }}
-      - name: Install latest nextest release
-        uses: taiki-e/install-action@nextest
+
       - name: Output package versions
         run: protoc --version ; cargo version ; rustc --version ; gcc --version ; g++ --version
 
       - name: Run tests
         if: env.DISABLE_RUN_TESTS == 'false'
-        run: make test sqlness-test
-
-      - name: Run cargo build
-        if: contains(matrix.arch, 'darwin') || contains(matrix.opts, 'pyo3_backend') == false
-        run: cargo build --profile ${{ env.CARGO_PROFILE }} --locked --target ${{ matrix.arch }} ${{ matrix.opts }}
+        run: make unit-test integration-test sqlness-test
 
       - name: Run cargo build with pyo3 for aarch64-linux
         if: contains(matrix.arch, 'aarch64-unknown-linux-gnu') && contains(matrix.opts, 'pyo3_backend')
@@ -266,6 +189,10 @@ jobs:
 
           cargo build --profile ${{ env.CARGO_PROFILE }} --locked --target ${{ matrix.arch }} ${{ matrix.opts }}
 
+      - name: Run cargo build
+        if: contains(matrix.arch, 'darwin') || contains(matrix.opts, 'pyo3_backend') == false
+        run: cargo build --profile ${{ env.CARGO_PROFILE }} --locked --target ${{ matrix.arch }} ${{ matrix.opts }}
+
       - name: Calculate checksum and rename binary
         shell: bash
         run: |
@@ -288,9 +215,9 @@ jobs:
 
   docker:
     name: Build docker image
-    needs: [build-linux, build-macos]
+    needs: [build]
     runs-on: ubuntu-latest
-    if: github.repository == 'GreptimeTeam/greptimedb' && !(inputs.dry_run || false)
+    if: github.repository == 'GreptimeTeam/greptimedb' && github.event_name != 'workflow_dispatch'
     steps:
       - name: Checkout sources
         uses: actions/checkout@v3
@@ -303,7 +230,7 @@ jobs:
 
       - name: Configure scheduled build image tag # the tag would be ${SCHEDULED_BUILD_VERSION_PREFIX}-YYYYMMDD-${SCHEDULED_PERIOD}
         shell: bash
-        if: github.event_name != 'push'
+        if: github.event_name == 'schedule'
         run: |
           buildTime=`date "+%Y%m%d"`
           SCHEDULED_BUILD_VERSION=${{ env.SCHEDULED_BUILD_VERSION_PREFIX }}-$buildTime-${{ env.SCHEDULED_PERIOD }}
@@ -311,7 +238,7 @@ jobs:
 
       - name: Configure tag # If the release tag is v0.1.0, then the image version tag will be 0.1.0.
         shell: bash
-        if: github.event_name == 'push'
+        if: github.event_name != 'schedule'
         run: |
           VERSION=${{ github.ref_name }}
           echo "IMAGE_TAG=${VERSION:1}" >> $GITHUB_ENV
@@ -374,9 +301,9 @@ jobs:
   release:
     name: Release artifacts
     # Release artifacts only when all the artifacts are built successfully.
-    needs: [build-linux, build-macos, docker]
+    needs: [build,docker]
     runs-on: ubuntu-latest
-    if: github.repository == 'GreptimeTeam/greptimedb' && !(inputs.dry_run || false)
+    if: github.repository == 'GreptimeTeam/greptimedb' && github.event_name != 'workflow_dispatch'
     steps:
       - name: Checkout sources
         uses: actions/checkout@v3
@@ -386,92 +313,31 @@ jobs:
 
       - name: Configure scheduled build version # the version would be ${SCHEDULED_BUILD_VERSION_PREFIX}-${SCHEDULED_PERIOD}-YYYYMMDD, like v0.2.0-nigthly-20230313.
         shell: bash
-        if: github.event_name != 'push'
+        if: github.event_name == 'schedule'
         run: |
           buildTime=`date "+%Y%m%d"`
           SCHEDULED_BUILD_VERSION=${{ env.SCHEDULED_BUILD_VERSION_PREFIX }}-${{ env.SCHEDULED_PERIOD }}-$buildTime
           echo "SCHEDULED_BUILD_VERSION=${SCHEDULED_BUILD_VERSION}" >> $GITHUB_ENV
 
-      # Only publish release when the release tag is like v1.0.0, v1.0.1, v1.0.2, etc.
-      - name: Set whether it is the latest release
-        run: |
-          if [[ "${{ github.ref_name }}" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-            echo "prerelease=false" >> $GITHUB_ENV
-            echo "makeLatest=true" >> $GITHUB_ENV
-          else
-            echo "prerelease=true" >> $GITHUB_ENV
-            echo "makeLatest=false" >> $GITHUB_ENV
-          fi
-
       - name: Create scheduled build git tag
-        if: github.event_name != 'push'
+        if: github.event_name == 'schedule'
         run: |
           git tag ${{ env.SCHEDULED_BUILD_VERSION }}
 
       - name: Publish scheduled release # configure the different release title and tags.
-        uses: ncipollo/release-action@v1
-        if: github.event_name != 'push'
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'schedule'
         with:
           name: "Release ${{ env.SCHEDULED_BUILD_VERSION }}"
-          prerelease: ${{ env.prerelease }}
-          makeLatest: ${{ env.makeLatest }}
-          tag: ${{ env.SCHEDULED_BUILD_VERSION }}
-          generateReleaseNotes: true
-          artifacts: |
+          tag_name: ${{ env.SCHEDULED_BUILD_VERSION }}
+          generate_release_notes: true
+          files: |
             **/greptime-*
 
       - name: Publish release
-        uses: ncipollo/release-action@v1
-        if: github.event_name == 'push'
+        uses: softprops/action-gh-release@v1
+        if: github.event_name != 'schedule'
         with:
-          name: "${{ github.ref_name }}"
-          prerelease: ${{ env.prerelease }}
-          makeLatest: ${{ env.makeLatest }}
-          generateReleaseNotes: true
-          artifacts: |
+          name: "Release ${{ github.ref_name }}"
+          files: |
             **/greptime-*
-
-  docker-push-acr:
-    name: Push docker image to alibaba cloud container registry
-    needs: [docker]
-    runs-on: ubuntu-latest
-    if: github.repository == 'GreptimeTeam/greptimedb' && !(inputs.dry_run || false)
-    continue-on-error: true
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v3
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      - name: Login to alibaba cloud container registry
-        uses: docker/login-action@v2
-        with:
-          registry: registry.cn-hangzhou.aliyuncs.com
-          username: ${{ secrets.ALICLOUD_USERNAME }}
-          password: ${{ secrets.ALICLOUD_PASSWORD }}
-
-      - name: Configure scheduled build image tag # the tag would be ${SCHEDULED_BUILD_VERSION_PREFIX}-YYYYMMDD-${SCHEDULED_PERIOD}
-        shell: bash
-        if: github.event_name != 'push'
-        run: |
-          buildTime=`date "+%Y%m%d"`
-          SCHEDULED_BUILD_VERSION=${{ env.SCHEDULED_BUILD_VERSION_PREFIX }}-$buildTime-${{ env.SCHEDULED_PERIOD }}
-          echo "IMAGE_TAG=${SCHEDULED_BUILD_VERSION:1}" >> $GITHUB_ENV
-
-      - name: Configure tag # If the release tag is v0.1.0, then the image version tag will be 0.1.0.
-        shell: bash
-        if: github.event_name == 'push'
-        run: |
-          VERSION=${{ github.ref_name }}
-          echo "IMAGE_TAG=${VERSION:1}" >> $GITHUB_ENV
-
-      - name: Push image to alibaba cloud container registry # Use 'docker buildx imagetools create' to create a new image base on source image.
-        run: |
-          docker buildx imagetools create \
-            --tag registry.cn-hangzhou.aliyuncs.com/greptime/greptimedb:latest \
-            --tag registry.cn-hangzhou.aliyuncs.com/greptime/greptimedb:${{ env.IMAGE_TAG }} \
-            greptime/greptimedb:${{ env.IMAGE_TAG }}

.gitignore

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

CONTRIBUTING.md

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

Cargo.toml

@@ -14,10 +14,7 @@ members = [
     "src/common/grpc",
     "src/common/grpc-expr",
     "src/common/mem-prof",
-    "src/common/meta",
     "src/common/procedure",
-    "src/common/procedure-test",
-    "src/common/pprof",
     "src/common/query",
     "src/common/recordbatch",
     "src/common/runtime",
@@ -50,49 +47,39 @@ members = [
 ]
 
 [workspace.package]
-version = "0.4.0"
+version = "0.2.0"
 edition = "2021"
 license = "Apache-2.0"
 
 [workspace.dependencies]
-arrow = { version = "40.0" }
-arrow-array = "40.0"
-arrow-flight = "40.0"
-arrow-schema = { version = "40.0", features = ["serde"] }
+arrow = { version = "37.0" }
+arrow-array = "37.0"
+arrow-flight = "37.0"
+arrow-schema = { version = "37.0", features = ["serde"] }
 async-stream = "0.3"
 async-trait = "0.1"
 chrono = { version = "0.4", features = ["serde"] }
-# TODO(ruihang): use arrow-datafusion when it contains https://github.com/apache/arrow-datafusion/pull/6032
-datafusion = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "63e52dde9e44cac4b1f6c6e6b6bf6368ba3bd323" }
-datafusion-common = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "63e52dde9e44cac4b1f6c6e6b6bf6368ba3bd323" }
-datafusion-expr = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "63e52dde9e44cac4b1f6c6e6b6bf6368ba3bd323" }
-datafusion-optimizer = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "63e52dde9e44cac4b1f6c6e6b6bf6368ba3bd323" }
-datafusion-physical-expr = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "63e52dde9e44cac4b1f6c6e6b6bf6368ba3bd323" }
-datafusion-sql = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "63e52dde9e44cac4b1f6c6e6b6bf6368ba3bd323" }
-datafusion-substrait = { git = "https://github.com/waynexia/arrow-datafusion.git", rev = "63e52dde9e44cac4b1f6c6e6b6bf6368ba3bd323" }
+datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
+datafusion-common = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
+datafusion-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
+datafusion-optimizer = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
+datafusion-physical-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
+datafusion-sql = { git = "https://github.com/apache/arrow-datafusion.git", rev = "74a778ca6016a853a3c3add3fa8c6f12f4fe4561" }
 futures = "0.3"
 futures-util = "0.3"
-greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "4398d20c56d5f7939cc2960789cb1fa7dd18e6fe" }
-itertools = "0.10"
-parquet = "40.0"
+parquet = "37.0"
 paste = "1.0"
 prost = "0.11"
 rand = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 snafu = { version = "0.7", features = ["backtraces"] }
-sqlparser = "0.34"
+sqlparser = "0.33"
 tempfile = "3"
-tokio = { version = "1.28", features = ["full"] }
-tokio-util = { version = "0.7", features = ["io-util", "compat"] }
+tokio = { version = "1.24.2", features = ["full"] }
+tokio-util = { version = "0.7", features = ["io-util"] }
 tonic = { version = "0.9", features = ["tls"] }
 uuid = { version = "1", features = ["serde", "v4", "fast-rng"] }
-metrics = "0.20"
-meter-core = { git = "https://github.com/GreptimeTeam/greptime-meter.git", rev = "f0798c4c648d89f51abe63e870919c75dd463199" }
-
-[workspace.dependencies.meter-macros]
-git = "https://github.com/GreptimeTeam/greptime-meter.git"
-rev = "f0798c4c648d89f51abe63e870919c75dd463199"
 
 [profile.release]
 debug = true

Makefile

@@ -33,12 +33,13 @@ docker-image: ## Build docker image.
 
 ##@ Test
 
-test: nextest ## Run unit and integration tests.
-	cargo nextest run
+.PHONY: unit-test
+unit-test: ## Run unit test.
+	cargo test --workspace
 
-.PHONY: nextest ## Install nextest tools.
-nextest:
-	cargo --list | grep nextest || cargo install cargo-nextest --locked
+.PHONY: integration-test
+integration-test: ## Run integation test.
+	cargo test integration
 
 .PHONY: sqlness-test
 sqlness-test: ## Run sqlness test.

README.md

@@ -47,14 +47,6 @@ for years. Based on their best-practices, GreptimeDB is born to give you:
 
 ## Quick Start
 
-### GreptimePlay
-
-Try out the features of GreptimeDB right from your browser.
-
-<a href="https://greptime.com/playground" target="_blank"><img
-src="https://www.greptime.com/assets/greptime_play_button_colorful.1bbe2746.png"
-alt="GreptimePlay" width="200px" /></a>
-
 ### Build
 
 #### Build from Source
@@ -100,22 +92,64 @@ Or if you built from docker:
 docker run -p 4002:4002 -v "$(pwd):/tmp/greptimedb" greptime/greptimedb standalone start
 ```
 
-Please see [the online document site](https://docs.greptime.com/getting-started/overview#install-greptimedb) for more installation options and [operations info](https://docs.greptime.com/user-guide/operations/overview).
+For more startup options, greptimedb's **distributed mode** and information
+about Kubernetes deployment, check our [docs](https://docs.greptime.com/).
 
-### Get started
+### Connect
 
-Read the [complete getting started guide](https://docs.greptime.com/getting-started/overview#connect) on our [official document site](https://docs.greptime.com/).
+1. Connect to GreptimeDB via standard [MySQL
+   client](https://dev.mysql.com/downloads/mysql/):
 
-To write and query data, GreptimeDB is compatible with multiple [protocols and clients](https://docs.greptime.com/user-guide/client/overview).
+   ```
+   # The standalone instance listen on port 4002 by default.
+   mysql -h 127.0.0.1 -P 4002
+   ```
+
+2. Create table:
+
+   ```SQL
+   CREATE TABLE monitor (
+     host STRING,
+     ts TIMESTAMP,
+     cpu DOUBLE DEFAULT 0,
+     memory DOUBLE,
+     TIME INDEX (ts),
+     PRIMARY KEY(host)) ENGINE=mito WITH(regions=1);
+   ```
+
+3. Insert some data:
+
+   ```SQL
+   INSERT INTO monitor(host, cpu, memory, ts) VALUES ('host1', 66.6, 1024, 1660897955000);
+   INSERT INTO monitor(host, cpu, memory, ts) VALUES ('host2', 77.7, 2048, 1660897956000);
+   INSERT INTO monitor(host, cpu, memory, ts) VALUES ('host3', 88.8, 4096, 1660897957000);
+   ```
+
+4. Query the data:
+
+   ```SQL
+   SELECT * FROM monitor;
+   ```
+
+   ```TEXT
+   +-------+---------------------+------+--------+
+   | host  | ts                  | cpu  | memory |
+   +-------+---------------------+------+--------+
+   | host1 | 2022-08-19 08:32:35 | 66.6 |   1024 |
+   | host2 | 2022-08-19 08:32:36 | 77.7 |   2048 |
+   | host3 | 2022-08-19 08:32:37 | 88.8 |   4096 |
+   +-------+---------------------+------+--------+
+   3 rows in set (0.01 sec)
+   ```
+
+You can always cleanup test database by removing `/tmp/greptimedb`.
 
 ## Resources
 
 ### Installation
 
-- [Pre-built Binaries](https://greptime.com/download):
-  For Linux and macOS, you can easily download pre-built binaries including official releases and nightly builds that are ready to use. 
-  In most cases, downloading the version without PyO3 is sufficient. However, if you plan to run scripts in CPython (and use Python packages like NumPy and Pandas), you will need to download the version with PyO3 and install a Python with the same version as the Python in the PyO3 version.
-  We recommend using virtualenv for the installation process to manage multiple Python versions.
+- [Pre-built Binaries](https://github.com/GreptimeTeam/greptimedb/releases):
+  For Linux and macOS, you can easily download pre-built binaries that are ready to use. In most cases, downloading the version without PyO3 is sufficient. However, if you plan to run scripts in CPython (and use Python packages like NumPy and Pandas), you will need to download the version with PyO3 and install a Python with the same version as the Python in the PyO3 version. We recommend using virtualenv for the installation process to manage multiple Python versions.
 - [Docker Images](https://hub.docker.com/r/greptime/greptimedb)(**recommended**): pre-built
   Docker images, this is the easiest way to try GreptimeDB. By default it runs CPython script with `pyo3_backend` enabled.
 - [`gtctl`](https://github.com/GreptimeTeam/gtctl): the command-line tool for
@@ -123,7 +157,7 @@ To write and query data, GreptimeDB is compatible with multiple [protocols and c
 
 ### Documentation
 
-- GreptimeDB [User Guide](https://docs.greptime.com/user-guide/concepts/overview)
+- GreptimeDB [User Guide](https://docs.greptime.com/user-guide/concepts.html)
 - GreptimeDB [Developer
   Guide](https://docs.greptime.com/developer-guide/overview.html)
 - GreptimeDB [internal code document](https://greptimedb.rs)

benchmarks/Cargo.toml

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

benchmarks/src/bin/nyc-taxi.rs

@@ -26,9 +26,7 @@ use arrow::datatypes::{DataType, Float64Type, Int64Type};
 use arrow::record_batch::RecordBatch;
 use clap::Parser;
 use client::api::v1::column::Values;
-use client::api::v1::{
-    Column, ColumnDataType, ColumnDef, CreateTableExpr, InsertRequest, InsertRequests,
-};
+use client::api::v1::{Column, ColumnDataType, ColumnDef, CreateTableExpr, InsertRequest};
 use client::{Client, Database, DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
@@ -109,12 +107,8 @@ async fn write_data(
             columns,
             row_count,
         };
-        let requests = InsertRequests {
-            inserts: vec![request],
-        };
-
         let now = Instant::now();
-        db.insert(requests).await.unwrap();
+        db.insert(request).await.unwrap();
         let elapsed = now.elapsed();
         total_rpc_elapsed_ms += elapsed.as_millis();
         progress_bar.inc(row_count as _);
@@ -370,7 +364,7 @@ fn create_table_expr() -> CreateTableExpr {
         primary_keys: vec!["VendorID".to_string()],
         create_if_not_exists: false,
         table_options: Default::default(),
-        region_numbers: vec![0],
+        region_ids: vec![0],
         table_id: None,
         engine: "mito".to_string(),
     }

config/datanode.example.toml

@@ -24,8 +24,7 @@ tcp_nodelay = true
 
 # WAL options, see `standalone.example.toml`.
 [wal]
-# WAL data directory
-# dir = "/tmp/greptimedb/wal"
+dir = "/tmp/greptimedb/wal"
 file_size = "1GB"
 purge_threshold = "50GB"
 purge_interval = "10m"
@@ -35,9 +34,7 @@ sync_write = false
 # Storage options, see `standalone.example.toml`.
 [storage]
 type = "File"
-data_home = "/tmp/greptimedb/"
-# TTL for all tables. Disabled by default.
-# global_ttl = "7d"
+data_dir = "/tmp/greptimedb/data/"
 
 # Compaction options, see `standalone.example.toml`.
 [storage.compaction]
@@ -51,31 +48,13 @@ max_purge_tasks = 32
 # Create a checkpoint every <checkpoint_margin> actions.
 checkpoint_margin = 10
 # Region manifest logs and checkpoints gc execution duration
-gc_duration = '10m'
+gc_duration = '30s'
 # Whether to try creating a manifest checkpoint on region opening
 checkpoint_on_startup = false
 
-# Storage flush options
-[storage.flush]
-# Max inflight flush tasks.
-max_flush_tasks = 8
-# Default write buffer size for a region.
-region_write_buffer_size = "32MB"
-# Interval to check whether a region needs flush.
-picker_schedule_interval = "5m"
-# Interval to auto flush a region if it has not flushed yet.
-auto_flush_interval = "1h"
-# Global write buffer size for all regions.
-global_write_buffer_size = "1GB"
-
 # Procedure storage options, see `standalone.example.toml`.
-[procedure]
-max_retry_times = 3
-retry_delay = "500ms"
-
-# Log options
-# [logging]
-# Specify logs directory.
-# dir = "/tmp/greptimedb/logs"
-# Specify the log level [info | debug | error | warn]
-# level = "info"
+# [procedure.store]
+# type = "File"
+# data_dir = "/tmp/greptimedb/procedure/"
+# max_retry_times = 3
+# retry_delay = "500ms"

config/frontend.example.toml

@@ -56,8 +56,3 @@ metasrv_addrs = ["127.0.0.1:3002"]
 timeout_millis = 3000
 connect_timeout_millis = 5000
 tcp_nodelay = true
-
-# Log options, see `standalone.example.toml`
-# [logging]
-# dir = "/tmp/greptimedb/logs"
-# level = "info"

config/metasrv.example.toml

@@ -13,8 +13,3 @@ datanode_lease_secs = 15
 selector = "LeaseBased"
 # Store data in memory, false by default.
 use_memory_store = false
-
-# Log options, see `standalone.example.toml`
-# [logging]
-# dir = "/tmp/greptimedb/logs"
-# level = "info"

config/standalone.example.toml

@@ -78,8 +78,8 @@ addr = "127.0.0.1:4004"
 
 # WAL options.
 [wal]
-# WAL data directory
-# dir = "/tmp/greptimedb/wal"
+# WAL data directory.
+dir = "/tmp/greptimedb/wal"
 # WAL file size in bytes.
 file_size = "1GB"
 # WAL purge threshold in bytes.
@@ -96,9 +96,7 @@ sync_write = false
 # Storage type.
 type = "File"
 # Data directory, "/tmp/greptimedb/data" by default.
-data_home = "/tmp/greptimedb/"
-# TTL for all tables. Disabled by default.
-# global_ttl = "7d"
+data_dir = "/tmp/greptimedb/data/"
 
 # Compaction options.
 [storage.compaction]
@@ -115,33 +113,18 @@ max_purge_tasks = 32
 # Create a checkpoint every <checkpoint_margin> actions.
 checkpoint_margin = 10
 # Region manifest logs and checkpoints gc execution duration
-gc_duration = '10m'
+gc_duration = '30s'
 # Whether to try creating a manifest checkpoint on region opening
 checkpoint_on_startup = false
 
-# Storage flush options
-[storage.flush]
-# Max inflight flush tasks.
-max_flush_tasks = 8
-# Default write buffer size for a region.
-region_write_buffer_size = "32MB"
-# Interval to check whether a region needs flush.
-picker_schedule_interval = "5m"
-# Interval to auto flush a region if it has not flushed yet.
-auto_flush_interval = "1h"
-# Global write buffer size for all regions.
-global_write_buffer_size = "1GB"
-
 # Procedure storage options.
-[procedure]
-# Procedure max retry time.
-max_retry_times = 3
-# Initial retry delay of procedures, increases exponentially
-retry_delay = "500ms"
-
-# Log options
-# [logging]
-# Specify logs directory.
-# dir = "/tmp/greptimedb/logs"
-# Specify the log level [info | debug | error | warn]
-# level = "info"
+# Uncomment to enable.
+# [procedure.store]
+# # Storage type.
+# type = "File"
+# # Procedure data path.
+# data_dir = "/tmp/greptimedb/procedure/"
+# # Procedure max retry time.
+# max_retry_times = 3
+# # Initial retry delay of procedures, increases exponentially
+# retry_delay = "500ms"

docker/Dockerfile

@@ -12,9 +12,7 @@ RUN apt-get update && apt-get install -y \
     pkg-config \
     python3 \
     python3-dev \
-    python3-pip \
-    && pip3 install --upgrade pip \
-    && pip3 install pyarrow
+    && pip install pyarrow
 
 # Install Rust.
 SHELL ["/bin/bash", "-c"]

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

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

docs/schema-structs.md

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

rust-toolchain.toml

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

scripts/fetch-dashboard-assets.sh

@@ -7,12 +7,9 @@ set -e
 declare -r SCRIPT_DIR=$(cd $(dirname ${0}) >/dev/null 2>&1 && pwd)
 declare -r ROOT_DIR=$(dirname ${SCRIPT_DIR})
 declare -r STATIC_DIR="$ROOT_DIR/src/servers/dashboard"
-OUT_DIR="${1:-$SCRIPT_DIR}"
 
 RELEASE_VERSION="$(cat $STATIC_DIR/VERSION)"
 
-echo "Downloading assets to dir: $OUT_DIR"
-cd $OUT_DIR
 # Download the SHA256 checksum attached to the release. To verify the integrity
 # of the download, this checksum will be used to check the download tar file
 # containing the built dashboard assets.

scripts/install.sh

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

src/api/Cargo.toml

@@ -10,7 +10,7 @@ common-base = { path = "../common/base" }
 common-error = { path = "../common/error" }
 common-time = { path = "../common/time" }
 datatypes = { path = "../datatypes" }
-greptime-proto.workspace = true
+greptime-proto = { git = "https://github.com/GreptimeTeam/greptime-proto.git", rev = "0bebe5f69c91cdfbce85cb8f45f9fcd28185261c" }
 prost.workspace = true
 snafu = { version = "0.7", features = ["backtraces"] }
 tonic.workspace = true

src/api/src/error.rs

@@ -41,7 +41,7 @@ pub enum Error {
     ))]
     ConvertColumnDefaultConstraint {
         column: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: datatypes::error::Error,
     },
 
@@ -52,7 +52,7 @@ pub enum Error {
     ))]
     InvalidColumnDefaultConstraint {
         column: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: datatypes::error::Error,
     },
 }

src/api/src/helper.rs

@@ -18,10 +18,6 @@ use datatypes::prelude::ConcreteDataType;
 use datatypes::types::TimestampType;
 use datatypes::value::Value;
 use datatypes::vectors::VectorRef;
-use greptime_proto::v1::ddl_request::Expr;
-use greptime_proto::v1::greptime_request::Request;
-use greptime_proto::v1::query_request::Query;
-use greptime_proto::v1::{DdlRequest, QueryRequest};
 use snafu::prelude::*;
 
 use crate::error::{self, Result};
@@ -228,38 +224,6 @@ pub fn push_vals(column: &mut Column, origin_count: usize, vector: VectorRef) {
     column.null_mask = null_mask.into_vec();
 }
 
-/// Returns the type name of the [Request].
-pub fn request_type(request: &Request) -> &'static str {
-    match request {
-        Request::Inserts(_) => "inserts",
-        Request::Query(query_req) => query_request_type(query_req),
-        Request::Ddl(ddl_req) => ddl_request_type(ddl_req),
-        Request::Delete(_) => "delete",
-    }
-}
-
-/// Returns the type name of the [QueryRequest].
-fn query_request_type(request: &QueryRequest) -> &'static str {
-    match request.query {
-        Some(Query::Sql(_)) => "query.sql",
-        Some(Query::LogicalPlan(_)) => "query.logical_plan",
-        Some(Query::PromRangeQuery(_)) => "query.prom_range",
-        None => "query.empty",
-    }
-}
-
-/// Returns the type name of the [DdlRequest].
-fn ddl_request_type(request: &DdlRequest) -> &'static str {
-    match request.expr {
-        Some(Expr::CreateDatabase(_)) => "ddl.create_database",
-        Some(Expr::CreateTable(_)) => "ddl.create_table",
-        Some(Expr::Alter(_)) => "ddl.alter",
-        Some(Expr::DropTable(_)) => "ddl.drop_table",
-        Some(Expr::FlushTable(_)) => "ddl.flush_table",
-        None => "ddl.empty",
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;

src/api/src/lib.rs

@@ -23,5 +23,4 @@ pub mod prometheus {
 
 pub mod v1;
 
-pub use greptime_proto;
 pub use prost::DecodeError;

src/catalog/Cargo.toml

@@ -4,9 +4,6 @@ version.workspace = true
 edition.workspace = true
 license.workspace = true
 
-[features]
-testing = []
-
 [dependencies]
 api = { path = "../api" }
 arc-swap = "1.0"
@@ -17,7 +14,6 @@ backoff = { version = "0.4", features = ["tokio"] }
 common-catalog = { path = "../common/catalog" }
 common-error = { path = "../common/error" }
 common-grpc = { path = "../common/grpc" }
-common-meta = { path = "../common/meta" }
 common-query = { path = "../common/query" }
 common-recordbatch = { path = "../common/recordbatch" }
 common-runtime = { path = "../common/runtime" }
@@ -28,11 +24,8 @@ datafusion.workspace = true
 datatypes = { path = "../datatypes" }
 futures = "0.3"
 futures-util.workspace = true
-key-lock = "0.1"
 lazy_static = "1.4"
 meta-client = { path = "../meta-client" }
-metrics.workspace = true
-moka = { version = "0.11", features = ["future"] }
 parking_lot = "0.12"
 regex = "1.6"
 serde = "1.0"
@@ -40,12 +33,10 @@ serde_json = "1.0"
 session = { path = "../session" }
 snafu = { version = "0.7", features = ["backtraces"] }
 storage = { path = "../storage" }
-store-api = { path = "../store-api" }
 table = { path = "../table" }
 tokio.workspace = true
 
 [dev-dependencies]
-catalog = { path = ".", features = ["testing"] }
 common-test-util = { path = "../common/test-util" }
 chrono.workspace = true
 log-store = { path = "../log-store" }

src/catalog/src/datafusion.rs

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

src/catalog/src/datafusion/catalog_adapter.rs

@@ -0,0 +1,318 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Catalog adapter between datafusion and greptime query engine.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use common_error::prelude::BoxedError;
+use datafusion::catalog::catalog::{
+    CatalogList as DfCatalogList, CatalogProvider as DfCatalogProvider,
+};
+use datafusion::catalog::schema::SchemaProvider as DfSchemaProvider;
+use datafusion::datasource::TableProvider as DfTableProvider;
+use datafusion::error::Result as DataFusionResult;
+use snafu::ResultExt;
+use table::table::adapter::{DfTableProviderAdapter, TableAdapter};
+use table::TableRef;
+
+use crate::error::{self, Result, SchemaProviderOperationSnafu};
+use crate::{
+    CatalogListRef, CatalogProvider, CatalogProviderRef, SchemaProvider, SchemaProviderRef,
+};
+
+pub struct DfCatalogListAdapter {
+    catalog_list: CatalogListRef,
+}
+
+impl DfCatalogListAdapter {
+    pub fn new(catalog_list: CatalogListRef) -> DfCatalogListAdapter {
+        DfCatalogListAdapter { catalog_list }
+    }
+}
+
+impl DfCatalogList for DfCatalogListAdapter {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn register_catalog(
+        &self,
+        name: String,
+        catalog: Arc<dyn DfCatalogProvider>,
+    ) -> Option<Arc<dyn DfCatalogProvider>> {
+        let catalog_adapter = Arc::new(CatalogProviderAdapter {
+            df_catalog_provider: catalog,
+        });
+        self.catalog_list
+            .register_catalog(name, catalog_adapter)
+            .expect("datafusion does not accept fallible catalog access") // TODO(hl): datafusion register catalog does not handles errors
+            .map(|catalog_provider| Arc::new(DfCatalogProviderAdapter { catalog_provider }) as _)
+    }
+
+    fn catalog_names(&self) -> Vec<String> {
+        // TODO(hl): datafusion register catalog does not handles errors
+        self.catalog_list
+            .catalog_names()
+            .expect("datafusion does not accept fallible catalog access")
+    }
+
+    fn catalog(&self, name: &str) -> Option<Arc<dyn DfCatalogProvider>> {
+        self.catalog_list
+            .catalog(name)
+            .expect("datafusion does not accept fallible catalog access") // TODO(hl): datafusion register catalog does not handles errors
+            .map(|catalog_provider| Arc::new(DfCatalogProviderAdapter { catalog_provider }) as _)
+    }
+}
+
+/// Datafusion's CatalogProvider ->  greptime CatalogProvider
+struct CatalogProviderAdapter {
+    df_catalog_provider: Arc<dyn DfCatalogProvider>,
+}
+
+impl CatalogProvider for CatalogProviderAdapter {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema_names(&self) -> Result<Vec<String>> {
+        Ok(self.df_catalog_provider.schema_names())
+    }
+
+    fn register_schema(
+        &self,
+        _name: String,
+        _schema: SchemaProviderRef,
+    ) -> Result<Option<SchemaProviderRef>> {
+        todo!("register_schema is not supported in Datafusion catalog provider")
+    }
+
+    fn schema(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>> {
+        Ok(self
+            .df_catalog_provider
+            .schema(name)
+            .map(|df_schema_provider| Arc::new(SchemaProviderAdapter { df_schema_provider }) as _))
+    }
+}
+
+///Greptime CatalogProvider -> datafusion's CatalogProvider
+struct DfCatalogProviderAdapter {
+    catalog_provider: CatalogProviderRef,
+}
+
+impl DfCatalogProvider for DfCatalogProviderAdapter {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema_names(&self) -> Vec<String> {
+        self.catalog_provider
+            .schema_names()
+            .expect("datafusion does not accept fallible catalog access")
+    }
+
+    fn schema(&self, name: &str) -> Option<Arc<dyn DfSchemaProvider>> {
+        self.catalog_provider
+            .schema(name)
+            .expect("datafusion does not accept fallible catalog access")
+            .map(|schema_provider| Arc::new(DfSchemaProviderAdapter { schema_provider }) as _)
+    }
+}
+
+/// Greptime SchemaProvider -> datafusion SchemaProvider
+struct DfSchemaProviderAdapter {
+    schema_provider: Arc<dyn SchemaProvider>,
+}
+
+#[async_trait]
+impl DfSchemaProvider for DfSchemaProviderAdapter {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn table_names(&self) -> Vec<String> {
+        self.schema_provider
+            .table_names()
+            .expect("datafusion does not accept fallible catalog access")
+    }
+
+    async fn table(&self, name: &str) -> Option<Arc<dyn DfTableProvider>> {
+        self.schema_provider
+            .table(name)
+            .await
+            .expect("datafusion does not accept fallible catalog access")
+            .map(|table| Arc::new(DfTableProviderAdapter::new(table)) as _)
+    }
+
+    fn register_table(
+        &self,
+        name: String,
+        table: Arc<dyn DfTableProvider>,
+    ) -> DataFusionResult<Option<Arc<dyn DfTableProvider>>> {
+        let table = Arc::new(TableAdapter::new(table)?);
+        match self.schema_provider.register_table(name, table)? {
+            Some(p) => Ok(Some(Arc::new(DfTableProviderAdapter::new(p)))),
+            None => Ok(None),
+        }
+    }
+
+    fn deregister_table(&self, name: &str) -> DataFusionResult<Option<Arc<dyn DfTableProvider>>> {
+        match self.schema_provider.deregister_table(name)? {
+            Some(p) => Ok(Some(Arc::new(DfTableProviderAdapter::new(p)))),
+            None => Ok(None),
+        }
+    }
+
+    fn table_exist(&self, name: &str) -> bool {
+        self.schema_provider
+            .table_exist(name)
+            .expect("datafusion does not accept fallible catalog access")
+    }
+}
+
+/// Datafusion SchemaProviderAdapter -> greptime SchemaProviderAdapter
+struct SchemaProviderAdapter {
+    df_schema_provider: Arc<dyn DfSchemaProvider>,
+}
+
+#[async_trait]
+impl SchemaProvider for SchemaProviderAdapter {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// Retrieves the list of available table names in this schema.
+    fn table_names(&self) -> Result<Vec<String>> {
+        Ok(self.df_schema_provider.table_names())
+    }
+
+    async fn table(&self, name: &str) -> Result<Option<TableRef>> {
+        let table = self.df_schema_provider.table(name).await;
+        let table = table.map(|table_provider| {
+            match table_provider
+                .as_any()
+                .downcast_ref::<DfTableProviderAdapter>()
+            {
+                Some(adapter) => adapter.table(),
+                None => {
+                    // TODO(yingwen): Avoid panic here.
+                    let adapter =
+                        TableAdapter::new(table_provider).expect("convert datafusion table");
+                    Arc::new(adapter) as _
+                }
+            }
+        });
+        Ok(table)
+    }
+
+    fn register_table(&self, name: String, table: TableRef) -> Result<Option<TableRef>> {
+        let table_provider = Arc::new(DfTableProviderAdapter::new(table.clone()));
+        Ok(self
+            .df_schema_provider
+            .register_table(name, table_provider)
+            .context(error::DatafusionSnafu {
+                msg: "Fail to register table to datafusion",
+            })
+            .map_err(BoxedError::new)
+            .context(SchemaProviderOperationSnafu)?
+            .map(|_| table))
+    }
+
+    fn rename_table(&self, _name: &str, _new_name: String) -> Result<TableRef> {
+        todo!()
+    }
+
+    fn deregister_table(&self, name: &str) -> Result<Option<TableRef>> {
+        self.df_schema_provider
+            .deregister_table(name)
+            .context(error::DatafusionSnafu {
+                msg: "Fail to deregister table from datafusion",
+            })
+            .map_err(BoxedError::new)
+            .context(SchemaProviderOperationSnafu)?
+            .map(|table| {
+                let adapter = TableAdapter::new(table)
+                    .context(error::TableSchemaMismatchSnafu)
+                    .map_err(BoxedError::new)
+                    .context(SchemaProviderOperationSnafu)?;
+                Ok(Arc::new(adapter) as _)
+            })
+            .transpose()
+    }
+
+    fn table_exist(&self, name: &str) -> Result<bool> {
+        Ok(self.df_schema_provider.table_exist(name))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use table::table::numbers::NumbersTable;
+
+    use super::*;
+    use crate::local::{new_memory_catalog_list, MemoryCatalogProvider, MemorySchemaProvider};
+
+    #[test]
+    #[should_panic]
+    pub fn test_register_schema() {
+        let adapter = CatalogProviderAdapter {
+            df_catalog_provider: Arc::new(
+                datafusion::catalog::catalog::MemoryCatalogProvider::new(),
+            ),
+        };
+
+        adapter
+            .register_schema(
+                "whatever".to_string(),
+                Arc::new(MemorySchemaProvider::new()),
+            )
+            .unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_register_table() {
+        let adapter = DfSchemaProviderAdapter {
+            schema_provider: Arc::new(MemorySchemaProvider::new()),
+        };
+
+        adapter
+            .register_table(
+                "test_table".to_string(),
+                Arc::new(DfTableProviderAdapter::new(Arc::new(
+                    NumbersTable::default(),
+                ))),
+            )
+            .unwrap();
+        adapter.table("test_table").await.unwrap();
+    }
+
+    #[test]
+    pub fn test_register_catalog() {
+        let catalog_list = DfCatalogListAdapter {
+            catalog_list: new_memory_catalog_list().unwrap(),
+        };
+        assert!(catalog_list
+            .register_catalog(
+                "test_catalog".to_string(),
+                Arc::new(DfCatalogProviderAdapter {
+                    catalog_provider: Arc::new(MemoryCatalogProvider::new()),
+                }),
+            )
+            .is_none());
+
+        catalog_list.catalog("test_catalog").unwrap();
+    }
+}

src/catalog/src/error.rs

@@ -20,30 +20,21 @@ use common_error::prelude::{Snafu, StatusCode};
 use datafusion::error::DataFusionError;
 use datatypes::prelude::ConcreteDataType;
 use snafu::Location;
-use tokio::task::JoinError;
 
 use crate::DeregisterTableRequest;
 
 #[derive(Debug, Snafu)]
 #[snafu(visibility(pub))]
 pub enum Error {
-    #[snafu(display(
-        "Failed to re-compile script due to internal error, source: {}",
-        source
-    ))]
-    CompileScriptInternal {
-        location: Location,
-        source: BoxedError,
-    },
     #[snafu(display("Failed to open system catalog table, source: {}", source))]
     OpenSystemCatalog {
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
     #[snafu(display("Failed to create system catalog table, source: {}", source))]
     CreateSystemCatalog {
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
@@ -54,7 +45,7 @@ pub enum Error {
     ))]
     CreateTable {
         table_info: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
@@ -94,7 +85,7 @@ pub enum Error {
     #[snafu(display("Table engine not found: {}, source: {}", engine_name, source))]
     TableEngineNotFound {
         engine_name: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
@@ -114,7 +105,7 @@ pub enum Error {
     #[snafu(display("Table `{}` already exists", table))]
     TableExists { table: String, location: Location },
 
-    #[snafu(display("Table not found: {}", table))]
+    #[snafu(display("Table `{}` not exist", table))]
     TableNotExist { table: String, location: Location },
 
     #[snafu(display("Schema {} already exists", schema))]
@@ -132,13 +123,10 @@ pub enum Error {
     #[snafu(display("Failed to open table, table info: {}, source: {}", table_info, source))]
     OpenTable {
         table_info: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
-    #[snafu(display("Failed to open table in parallel, source: {}", source))]
-    ParallelOpenTable { source: JoinError },
-
     #[snafu(display("Table not found while opening table, table info: {}", table_info))]
     TableNotFound {
         table_info: String,
@@ -147,13 +135,13 @@ pub enum Error {
 
     #[snafu(display("Failed to read system catalog table records"))]
     ReadSystemCatalog {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_recordbatch::error::Error,
     },
 
     #[snafu(display("Failed to create recordbatch, source: {}", source))]
     CreateRecordBatch {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_recordbatch::error::Error,
     },
 
@@ -162,7 +150,7 @@ pub enum Error {
         source
     ))]
     InsertCatalogRecord {
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
@@ -173,7 +161,7 @@ pub enum Error {
     ))]
     DeregisterTable {
         request: DeregisterTableRequest,
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
@@ -182,42 +170,69 @@ pub enum Error {
 
     #[snafu(display("Failed to scan system catalog table, source: {}", source))]
     SystemCatalogTableScan {
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
 
+    #[snafu(display("Failure during SchemaProvider operation, source: {}", source))]
+    SchemaProviderOperation {
+        #[snafu(backtrace)]
+        source: BoxedError,
+    },
+
     #[snafu(display("{source}"))]
     Internal {
-        location: Location,
+        #[snafu(backtrace)]
         source: BoxedError,
     },
 
     #[snafu(display("Failed to execute system catalog table scan, source: {}", source))]
     SystemCatalogTableScanExec {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_query::error::Error,
     },
     #[snafu(display("Cannot parse catalog value, source: {}", source))]
     InvalidCatalogValue {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_catalog::error::Error,
     },
 
     #[snafu(display("Failed to perform metasrv operation, source: {}", source))]
     MetaSrv {
-        location: Location,
+        #[snafu(backtrace)]
         source: meta_client::error::Error,
     },
 
     #[snafu(display("Invalid table info in catalog, source: {}", source))]
     InvalidTableInfoInCatalog {
-        location: Location,
+        #[snafu(backtrace)]
         source: datatypes::error::Error,
     },
 
+    #[snafu(display("Failed to serialize or deserialize catalog entry: {}", source))]
+    CatalogEntrySerde {
+        #[snafu(backtrace)]
+        source: common_catalog::error::Error,
+    },
+
     #[snafu(display("Illegal access to catalog: {} and schema: {}", catalog, schema))]
     QueryAccessDenied { catalog: String, schema: String },
 
+    #[snafu(display(
+        "Failed to get region stats, catalog: {}, schema: {}, table: {}, source: {}",
+        catalog,
+        schema,
+        table,
+        source
+    ))]
+    RegionStats {
+        catalog: String,
+        schema: String,
+        table: String,
+        #[snafu(backtrace)]
+        source: table::error::Error,
+    },
+
     #[snafu(display("Invalid system table definition: {err_msg}"))]
     InvalidSystemTableDef { err_msg: String, location: Location },
 
@@ -230,12 +245,9 @@ pub enum Error {
 
     #[snafu(display("Table schema mismatch, source: {}", source))]
     TableSchemaMismatch {
-        location: Location,
+        #[snafu(backtrace)]
         source: table::error::Error,
     },
-
-    #[snafu(display("A generic error has occurred, msg: {}", msg))]
-    Generic { msg: String, location: Location },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -249,19 +261,20 @@ impl ErrorExt for Error {
             | Error::IllegalManagerState { .. }
             | Error::CatalogNotFound { .. }
             | Error::InvalidEntryType { .. }
-            | Error::InvalidSystemTableDef { .. }
-            | Error::ParallelOpenTable { .. } => StatusCode::Unexpected,
+            | Error::InvalidSystemTableDef { .. } => StatusCode::Unexpected,
 
             Error::SystemCatalog { .. }
             | Error::EmptyValue { .. }
             | Error::ValueDeserialize { .. } => StatusCode::StorageUnavailable,
 
-            Error::Generic { .. } | Error::SystemCatalogTypeMismatch { .. } => StatusCode::Internal,
+            Error::SystemCatalogTypeMismatch { .. } => StatusCode::Internal,
 
-            Error::ReadSystemCatalog { source, .. } | Error::CreateRecordBatch { source, .. } => {
+            Error::ReadSystemCatalog { source, .. } | Error::CreateRecordBatch { source } => {
+                source.status_code()
+            }
+            Error::InvalidCatalogValue { source, .. } | Error::CatalogEntrySerde { source } => {
                 source.status_code()
             }
-            Error::InvalidCatalogValue { source, .. } => source.status_code(),
 
             Error::TableExists { .. } => StatusCode::TableAlreadyExists,
             Error::TableNotExist { .. } => StatusCode::TableNotFound,
@@ -275,14 +288,14 @@ impl ErrorExt for Error {
             | Error::OpenTable { source, .. }
             | Error::CreateTable { source, .. }
             | Error::DeregisterTable { source, .. }
-            | Error::TableSchemaMismatch { source, .. } => source.status_code(),
+            | Error::RegionStats { source, .. }
+            | Error::TableSchemaMismatch { source } => source.status_code(),
 
             Error::MetaSrv { source, .. } => source.status_code(),
-            Error::SystemCatalogTableScan { source, .. } => source.status_code(),
-            Error::SystemCatalogTableScanExec { source, .. } => source.status_code(),
-            Error::InvalidTableInfoInCatalog { source, .. } => source.status_code(),
-
-            Error::CompileScriptInternal { source, .. } | Error::Internal { source, .. } => {
+            Error::SystemCatalogTableScan { source } => source.status_code(),
+            Error::SystemCatalogTableScanExec { source } => source.status_code(),
+            Error::InvalidTableInfoInCatalog { source } => source.status_code(),
+            Error::SchemaProviderOperation { source } | Error::Internal { source } => {
                 source.status_code()
             }
 

src/catalog/src/helper.rs

@@ -191,7 +191,6 @@ impl TableRegionalKey {
 pub struct TableRegionalValue {
     pub version: TableVersion,
     pub regions_ids: Vec<u32>,
-    pub engine_name: Option<String>,
 }
 
 pub struct CatalogKey {

src/catalog/src/information_schema.rs

@@ -12,36 +12,26 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-mod columns;
 mod tables;
 
 use std::any::Any;
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use common_error::prelude::BoxedError;
-use common_query::physical_plan::PhysicalPlanRef;
-use common_query::prelude::Expr;
-use common_recordbatch::{RecordBatchStreamAdaptor, SendableRecordBatchStream};
-use datatypes::schema::SchemaRef;
-use futures_util::StreamExt;
+use datafusion::datasource::streaming::{PartitionStream, StreamingTable};
 use snafu::ResultExt;
-use store_api::storage::ScanRequest;
-use table::error::{SchemaConversionSnafu, TablesRecordBatchSnafu};
-use table::{Result as TableResult, Table, TableRef};
+use table::table::adapter::TableAdapter;
+use table::TableRef;
 
-use self::columns::InformationSchemaColumns;
-use crate::error::Result;
+use crate::error::{DatafusionSnafu, Result, TableSchemaMismatchSnafu};
 use crate::information_schema::tables::InformationSchemaTables;
 use crate::{CatalogProviderRef, SchemaProvider};
 
 const TABLES: &str = "tables";
-const COLUMNS: &str = "columns";
 
 pub(crate) struct InformationSchemaProvider {
     catalog_name: String,
     catalog_provider: CatalogProviderRef,
-    tables: Vec<String>,
 }
 
 impl InformationSchemaProvider {
@@ -49,7 +39,6 @@ impl InformationSchemaProvider {
         Self {
             catalog_name,
             catalog_provider,
-            tables: vec![TABLES.to_string(), COLUMNS.to_string()],
         }
     }
 }
@@ -60,110 +49,32 @@ impl SchemaProvider for InformationSchemaProvider {
         self
     }
 
-    async fn table_names(&self) -> Result<Vec<String>> {
-        Ok(self.tables.clone())
+    fn table_names(&self) -> Result<Vec<String>> {
+        Ok(vec![TABLES.to_string()])
     }
 
     async fn table(&self, name: &str) -> Result<Option<TableRef>> {
-        let stream_builder = match name.to_ascii_lowercase().as_ref() {
-            TABLES => Arc::new(InformationSchemaTables::new(
+        let table = if name.eq_ignore_ascii_case(TABLES) {
+            Arc::new(InformationSchemaTables::new(
                 self.catalog_name.clone(),
                 self.catalog_provider.clone(),
-            )) as _,
-            COLUMNS => Arc::new(InformationSchemaColumns::new(
-                self.catalog_name.clone(),
-                self.catalog_provider.clone(),
-            )) as _,
-            _ => {
-                return Ok(None);
-            }
-        };
-
-        Ok(Some(Arc::new(InformationTable::new(stream_builder))))
-    }
-
-    async fn table_exist(&self, name: &str) -> Result<bool> {
-        let normalized_name = name.to_ascii_lowercase();
-        Ok(self.tables.contains(&normalized_name))
-    }
-}
-
-// TODO(ruihang): make it a more generic trait:
-// https://github.com/GreptimeTeam/greptimedb/pull/1639#discussion_r1205001903
-pub trait InformationStreamBuilder: Send + Sync {
-    fn to_stream(&self) -> Result<SendableRecordBatchStream>;
-
-    fn schema(&self) -> SchemaRef;
-}
-
-pub struct InformationTable {
-    stream_builder: Arc<dyn InformationStreamBuilder>,
-}
-
-impl InformationTable {
-    pub fn new(stream_builder: Arc<dyn InformationStreamBuilder>) -> Self {
-        Self { stream_builder }
-    }
-}
-
-#[async_trait]
-impl Table for InformationTable {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn schema(&self) -> SchemaRef {
-        self.stream_builder.schema()
-    }
-
-    fn table_info(&self) -> table::metadata::TableInfoRef {
-        unreachable!("Should not call table_info() of InformationTable directly")
-    }
-
-    /// Scan the table and returns a SendableRecordBatchStream.
-    async fn scan(
-        &self,
-        _projection: Option<&Vec<usize>>,
-        _filters: &[Expr],
-        // limit can be used to reduce the amount scanned
-        // from the datasource as a performance optimization.
-        // If set, it contains the amount of rows needed by the `LogicalPlan`,
-        // The datasource should return *at least* this number of rows if available.
-        _limit: Option<usize>,
-    ) -> TableResult<PhysicalPlanRef> {
-        unimplemented!()
-    }
-
-    async fn scan_to_stream(&self, request: ScanRequest) -> TableResult<SendableRecordBatchStream> {
-        let projection = request.projection;
-        let projected_schema = if let Some(projection) = &projection {
-            Arc::new(
-                self.schema()
-                    .try_project(projection)
-                    .context(SchemaConversionSnafu)?,
-            )
+            ))
         } else {
-            self.schema()
+            return Ok(None);
         };
-        let stream = self
-            .stream_builder
-            .to_stream()
-            .map_err(BoxedError::new)
-            .context(TablesRecordBatchSnafu)?
-            .map(move |batch| {
-                batch.and_then(|batch| {
-                    if let Some(projection) = &projection {
-                        batch.try_project(projection)
-                    } else {
-                        Ok(batch)
-                    }
-                })
-            });
-        let stream = RecordBatchStreamAdaptor {
-            schema: projected_schema,
-            stream: Box::pin(stream),
-            output_ordering: None,
-        };
-        Ok(Box::pin(stream))
+
+        let table = Arc::new(
+            StreamingTable::try_new(table.schema().clone(), vec![table]).with_context(|_| {
+                DatafusionSnafu {
+                    msg: format!("Failed to get InformationSchema table '{name}'"),
+                }
+            })?,
+        );
+        let table = TableAdapter::new(table).context(TableSchemaMismatchSnafu)?;
+        Ok(Some(Arc::new(table)))
+    }
+
+    fn table_exist(&self, name: &str) -> Result<bool> {
+        Ok(matches!(name.to_ascii_lowercase().as_str(), TABLES))
     }
 }

src/catalog/src/information_schema/columns.rs

@@ -1,213 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::sync::Arc;
-
-use arrow_schema::SchemaRef as ArrowSchemaRef;
-use common_catalog::consts::{
-    SEMANTIC_TYPE_FIELD, SEMANTIC_TYPE_PRIMARY_KEY, SEMANTIC_TYPE_TIME_INDEX,
-};
-use common_error::prelude::BoxedError;
-use common_query::physical_plan::TaskContext;
-use common_recordbatch::adapter::RecordBatchStreamAdapter;
-use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
-use datafusion::datasource::streaming::PartitionStream as DfPartitionStream;
-use datafusion::physical_plan::stream::RecordBatchStreamAdapter as DfRecordBatchStreamAdapter;
-use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatchStream;
-use datatypes::prelude::{ConcreteDataType, DataType};
-use datatypes::scalars::ScalarVectorBuilder;
-use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::vectors::{StringVectorBuilder, VectorRef};
-use snafu::ResultExt;
-
-use super::InformationStreamBuilder;
-use crate::error::{CreateRecordBatchSnafu, InternalSnafu, Result};
-use crate::CatalogProviderRef;
-
-pub(super) struct InformationSchemaColumns {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_provider: CatalogProviderRef,
-}
-
-const TABLE_CATALOG: &str = "table_catalog";
-const TABLE_SCHEMA: &str = "table_schema";
-const TABLE_NAME: &str = "table_name";
-const COLUMN_NAME: &str = "column_name";
-const DATA_TYPE: &str = "data_type";
-const SEMANTIC_TYPE: &str = "semantic_type";
-
-impl InformationSchemaColumns {
-    pub(super) fn new(catalog_name: String, catalog_provider: CatalogProviderRef) -> Self {
-        let schema = Arc::new(Schema::new(vec![
-            ColumnSchema::new(TABLE_CATALOG, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_SCHEMA, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(TABLE_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(COLUMN_NAME, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(DATA_TYPE, ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new(SEMANTIC_TYPE, ConcreteDataType::string_datatype(), false),
-        ]));
-        Self {
-            schema,
-            catalog_name,
-            catalog_provider,
-        }
-    }
-
-    fn builder(&self) -> InformationSchemaColumnsBuilder {
-        InformationSchemaColumnsBuilder::new(
-            self.schema.clone(),
-            self.catalog_name.clone(),
-            self.catalog_provider.clone(),
-        )
-    }
-}
-
-impl InformationStreamBuilder for InformationSchemaColumns {
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    fn to_stream(&self) -> Result<SendableRecordBatchStream> {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        let stream = Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_tables()
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ));
-        Ok(Box::pin(
-            RecordBatchStreamAdapter::try_new(stream)
-                .map_err(BoxedError::new)
-                .context(InternalSnafu)?,
-        ))
-    }
-}
-
-struct InformationSchemaColumnsBuilder {
-    schema: SchemaRef,
-    catalog_name: String,
-    catalog_provider: CatalogProviderRef,
-
-    catalog_names: StringVectorBuilder,
-    schema_names: StringVectorBuilder,
-    table_names: StringVectorBuilder,
-    column_names: StringVectorBuilder,
-    data_types: StringVectorBuilder,
-    semantic_types: StringVectorBuilder,
-}
-
-impl InformationSchemaColumnsBuilder {
-    fn new(schema: SchemaRef, catalog_name: String, catalog_provider: CatalogProviderRef) -> Self {
-        Self {
-            schema,
-            catalog_name,
-            catalog_provider,
-            catalog_names: StringVectorBuilder::with_capacity(42),
-            schema_names: StringVectorBuilder::with_capacity(42),
-            table_names: StringVectorBuilder::with_capacity(42),
-            column_names: StringVectorBuilder::with_capacity(42),
-            data_types: StringVectorBuilder::with_capacity(42),
-            semantic_types: StringVectorBuilder::with_capacity(42),
-        }
-    }
-
-    /// Construct the `information_schema.tables` virtual table
-    async fn make_tables(&mut self) -> Result<RecordBatch> {
-        let catalog_name = self.catalog_name.clone();
-
-        for schema_name in self.catalog_provider.schema_names().await? {
-            let Some(schema) = self.catalog_provider.schema(&schema_name).await? else { continue };
-            for table_name in schema.table_names().await? {
-                let Some(table) = schema.table(&table_name).await? else { continue };
-                let keys = &table.table_info().meta.primary_key_indices;
-                let schema = table.schema();
-                for (idx, column) in schema.column_schemas().iter().enumerate() {
-                    let semantic_type = if column.is_time_index() {
-                        SEMANTIC_TYPE_TIME_INDEX
-                    } else if keys.contains(&idx) {
-                        SEMANTIC_TYPE_PRIMARY_KEY
-                    } else {
-                        SEMANTIC_TYPE_FIELD
-                    };
-                    self.add_column(
-                        &catalog_name,
-                        &schema_name,
-                        &table_name,
-                        &column.name,
-                        column.data_type.name(),
-                        semantic_type,
-                    );
-                }
-            }
-        }
-
-        self.finish()
-    }
-
-    fn add_column(
-        &mut self,
-        catalog_name: &str,
-        schema_name: &str,
-        table_name: &str,
-        column_name: &str,
-        data_type: &str,
-        semantic_type: &str,
-    ) {
-        self.catalog_names.push(Some(catalog_name));
-        self.schema_names.push(Some(schema_name));
-        self.table_names.push(Some(table_name));
-        self.column_names.push(Some(column_name));
-        self.data_types.push(Some(data_type));
-        self.semantic_types.push(Some(semantic_type));
-    }
-
-    fn finish(&mut self) -> Result<RecordBatch> {
-        let columns: Vec<VectorRef> = vec![
-            Arc::new(self.catalog_names.finish()),
-            Arc::new(self.schema_names.finish()),
-            Arc::new(self.table_names.finish()),
-            Arc::new(self.column_names.finish()),
-            Arc::new(self.data_types.finish()),
-            Arc::new(self.semantic_types.finish()),
-        ];
-        RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
-    }
-}
-
-impl DfPartitionStream for InformationSchemaColumns {
-    fn schema(&self) -> &ArrowSchemaRef {
-        self.schema.arrow_schema()
-    }
-
-    fn execute(&self, _: Arc<TaskContext>) -> DfSendableRecordBatchStream {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_tables()
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ))
-    }
-}

src/catalog/src/information_schema/tables.rs

@@ -16,21 +16,19 @@ use std::sync::Arc;
 
 use arrow_schema::SchemaRef as ArrowSchemaRef;
 use common_catalog::consts::INFORMATION_SCHEMA_NAME;
-use common_error::prelude::BoxedError;
 use common_query::physical_plan::TaskContext;
-use common_recordbatch::adapter::RecordBatchStreamAdapter;
-use common_recordbatch::{RecordBatch, SendableRecordBatchStream};
+use common_recordbatch::RecordBatch;
 use datafusion::datasource::streaming::PartitionStream as DfPartitionStream;
 use datafusion::physical_plan::stream::RecordBatchStreamAdapter as DfRecordBatchStreamAdapter;
 use datafusion::physical_plan::SendableRecordBatchStream as DfSendableRecordBatchStream;
 use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder, VectorRef};
 use datatypes::schema::{ColumnSchema, Schema, SchemaRef};
-use datatypes::vectors::{StringVectorBuilder, UInt32VectorBuilder};
+use datatypes::vectors::StringVectorBuilder;
 use snafu::ResultExt;
 use table::metadata::TableType;
 
-use crate::error::{CreateRecordBatchSnafu, InternalSnafu, Result};
-use crate::information_schema::InformationStreamBuilder;
+use crate::error::{CreateRecordBatchSnafu, Result};
+use crate::information_schema::TABLES;
 use crate::CatalogProviderRef;
 
 pub(super) struct InformationSchemaTables {
@@ -46,8 +44,6 @@ impl InformationSchemaTables {
             ColumnSchema::new("table_schema", ConcreteDataType::string_datatype(), false),
             ColumnSchema::new("table_name", ConcreteDataType::string_datatype(), false),
             ColumnSchema::new("table_type", ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new("table_id", ConcreteDataType::uint32_datatype(), true),
-            ColumnSchema::new("engine", ConcreteDataType::string_datatype(), true),
         ]));
         Self {
             schema,
@@ -65,32 +61,6 @@ impl InformationSchemaTables {
     }
 }
 
-impl InformationStreamBuilder for InformationSchemaTables {
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    fn to_stream(&self) -> Result<SendableRecordBatchStream> {
-        let schema = self.schema.arrow_schema().clone();
-        let mut builder = self.builder();
-        let stream = Box::pin(DfRecordBatchStreamAdapter::new(
-            schema,
-            futures::stream::once(async move {
-                builder
-                    .make_tables()
-                    .await
-                    .map(|x| x.into_df_record_batch())
-                    .map_err(Into::into)
-            }),
-        ));
-        Ok(Box::pin(
-            RecordBatchStreamAdapter::try_new(stream)
-                .map_err(BoxedError::new)
-                .context(InternalSnafu)?,
-        ))
-    }
-}
-
 /// Builds the `information_schema.TABLE` table row by row
 ///
 /// Columns are based on <https://www.postgresql.org/docs/current/infoschema-columns.html>
@@ -103,8 +73,6 @@ struct InformationSchemaTablesBuilder {
     schema_names: StringVectorBuilder,
     table_names: StringVectorBuilder,
     table_types: StringVectorBuilder,
-    table_ids: UInt32VectorBuilder,
-    engines: StringVectorBuilder,
 }
 
 impl InformationSchemaTablesBuilder {
@@ -117,8 +85,6 @@ impl InformationSchemaTablesBuilder {
             schema_names: StringVectorBuilder::with_capacity(42),
             table_names: StringVectorBuilder::with_capacity(42),
             table_types: StringVectorBuilder::with_capacity(42),
-            table_ids: UInt32VectorBuilder::with_capacity(42),
-            engines: StringVectorBuilder::with_capacity(42),
         }
     }
 
@@ -126,26 +92,26 @@ impl InformationSchemaTablesBuilder {
     async fn make_tables(&mut self) -> Result<RecordBatch> {
         let catalog_name = self.catalog_name.clone();
 
-        for schema_name in self.catalog_provider.schema_names().await? {
+        for schema_name in self.catalog_provider.schema_names()? {
             if schema_name == INFORMATION_SCHEMA_NAME {
                 continue;
             }
 
-            let Some(schema) = self.catalog_provider.schema(&schema_name).await? else { continue };
-            for table_name in schema.table_names().await? {
+            let Some(schema) = self.catalog_provider.schema(&schema_name)? else { continue };
+            for table_name in schema.table_names()? {
                 let Some(table) = schema.table(&table_name).await? else { continue };
-                let table_info = table.table_info();
-                self.add_table(
-                    &catalog_name,
-                    &schema_name,
-                    &table_name,
-                    table.table_type(),
-                    Some(table_info.ident.table_id),
-                    Some(&table_info.meta.engine),
-                );
+                self.add_table(&catalog_name, &schema_name, &table_name, table.table_type());
             }
         }
 
+        // Add a final list for the information schema tables themselves
+        self.add_table(
+            &catalog_name,
+            INFORMATION_SCHEMA_NAME,
+            TABLES,
+            TableType::View,
+        );
+
         self.finish()
     }
 
@@ -155,8 +121,6 @@ impl InformationSchemaTablesBuilder {
         schema_name: &str,
         table_name: &str,
         table_type: TableType,
-        table_id: Option<u32>,
-        engine: Option<&str>,
     ) {
         self.catalog_names.push(Some(catalog_name));
         self.schema_names.push(Some(schema_name));
@@ -166,8 +130,6 @@ impl InformationSchemaTablesBuilder {
             TableType::View => "VIEW",
             TableType::Temporary => "LOCAL TEMPORARY",
         }));
-        self.table_ids.push(table_id);
-        self.engines.push(engine);
     }
 
     fn finish(&mut self) -> Result<RecordBatch> {
@@ -176,8 +138,6 @@ impl InformationSchemaTablesBuilder {
             Arc::new(self.schema_names.finish()),
             Arc::new(self.table_names.finish()),
             Arc::new(self.table_types.finish()),
-            Arc::new(self.table_ids.finish()),
-            Arc::new(self.engines.finish()),
         ];
         RecordBatch::new(self.schema.clone(), columns).context(CreateRecordBatchSnafu)
     }
@@ -189,7 +149,7 @@ impl DfPartitionStream for InformationSchemaTables {
     }
 
     fn execute(&self, _: Arc<TaskContext>) -> DfSendableRecordBatchStream {
-        let schema = self.schema.arrow_schema().clone();
+        let schema = self.schema().clone();
         let mut builder = self.builder();
         Box::pin(DfRecordBatchStreamAdapter::new(
             schema,

src/catalog/src/lib.rs

@@ -12,11 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(trait_upcasting)]
 #![feature(assert_matches)]
 
 use std::any::Any;
-use std::collections::HashMap;
 use std::fmt::{Debug, Formatter};
 use std::sync::Arc;
 
@@ -31,51 +29,66 @@ use table::TableRef;
 use crate::error::{CreateTableSnafu, Result};
 pub use crate::schema::{SchemaProvider, SchemaProviderRef};
 
+pub mod datafusion;
 pub mod error;
 pub mod helper;
 pub(crate) mod information_schema;
 pub mod local;
-mod metrics;
 pub mod remote;
 pub mod schema;
 pub mod system;
 pub mod table_source;
 pub mod tables;
 
+/// Represent a list of named catalogs
+pub trait CatalogList: Sync + Send {
+    /// Returns the catalog list as [`Any`](std::any::Any)
+    /// so that it can be downcast to a specific implementation.
+    fn as_any(&self) -> &dyn Any;
+
+    /// Adds a new catalog to this catalog list
+    /// If a catalog of the same name existed before, it is replaced in the list and returned.
+    fn register_catalog(
+        &self,
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Result<Option<CatalogProviderRef>>;
+
+    /// Retrieves the list of available catalog names
+    fn catalog_names(&self) -> Result<Vec<String>>;
+
+    /// Retrieves a specific catalog by name, provided it exists.
+    fn catalog(&self, name: &str) -> Result<Option<CatalogProviderRef>>;
+}
+
 /// Represents a catalog, comprising a number of named schemas.
-#[async_trait::async_trait]
 pub trait CatalogProvider: Sync + Send {
     /// Returns the catalog provider as [`Any`](std::any::Any)
     /// so that it can be downcast to a specific implementation.
     fn as_any(&self) -> &dyn Any;
 
     /// Retrieves the list of available schema names in this catalog.
-    async fn schema_names(&self) -> Result<Vec<String>>;
+    fn schema_names(&self) -> Result<Vec<String>>;
 
     /// Registers schema to this catalog.
-    async fn register_schema(
+    fn register_schema(
         &self,
         name: String,
         schema: SchemaProviderRef,
     ) -> Result<Option<SchemaProviderRef>>;
 
     /// Retrieves a specific schema from the catalog by name, provided it exists.
-    async fn schema(&self, name: &str) -> Result<Option<SchemaProviderRef>>;
+    fn schema(&self, name: &str) -> Result<Option<SchemaProviderRef>>;
 }
 
+pub type CatalogListRef = Arc<dyn CatalogList>;
 pub type CatalogProviderRef = Arc<dyn CatalogProvider>;
 
 #[async_trait::async_trait]
-pub trait CatalogManager: Send + Sync {
+pub trait CatalogManager: CatalogList {
     /// Starts a catalog manager.
     async fn start(&self) -> Result<()>;
 
-    async fn register_catalog(
-        &self,
-        name: String,
-        catalog: CatalogProviderRef,
-    ) -> Result<Option<CatalogProviderRef>>;
-
     /// Registers a table within given catalog/schema to catalog manager,
     /// returns whether the table registered.
     async fn register_table(&self, request: RegisterTableRequest) -> Result<bool>;
@@ -95,11 +108,7 @@ pub trait CatalogManager: Send + Sync {
     async fn register_system_table(&self, request: RegisterSystemTableRequest)
         -> error::Result<()>;
 
-    async fn catalog_names(&self) -> Result<Vec<String>>;
-
-    async fn catalog(&self, catalog: &str) -> Result<Option<CatalogProviderRef>>;
-
-    async fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>>;
+    fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>>;
 
     /// Returns the table by catalog, schema and table name.
     async fn table(
@@ -108,8 +117,6 @@ pub trait CatalogManager: Send + Sync {
         schema: &str,
         table_name: &str,
     ) -> Result<Option<TableRef>>;
-
-    fn as_any(&self) -> &dyn Any;
 }
 
 pub type CatalogManagerRef = Arc<dyn CatalogManager>;
@@ -231,23 +238,21 @@ pub async fn datanode_stat(catalog_manager: &CatalogManagerRef) -> (u64, Vec<Reg
     let mut region_number: u64 = 0;
     let mut region_stats = Vec::new();
 
-    let Ok(catalog_names) = catalog_manager.catalog_names().await else { return (region_number, region_stats) };
+    let Ok(catalog_names) = catalog_manager.catalog_names() else { return (region_number, region_stats) };
     for catalog_name in catalog_names {
-        let Ok(Some(catalog)) = catalog_manager.catalog(&catalog_name).await else { continue };
+        let Ok(Some(catalog)) = catalog_manager.catalog(&catalog_name) else { continue };
 
-        let Ok(schema_names) = catalog.schema_names().await else { continue };
+        let Ok(schema_names) = catalog.schema_names() else { continue };
         for schema_name in schema_names {
-            let Ok(Some(schema)) = catalog.schema(&schema_name).await else { continue };
+            let Ok(Some(schema)) = catalog.schema(&schema_name) else { continue };
 
-            let Ok(table_names) = schema.table_names().await else { continue };
+            let Ok(table_names) = schema.table_names() else { continue };
             for table_name in table_names {
                 let Ok(Some(table)) = schema.table(&table_name).await else { continue };
 
                 let region_numbers = &table.table_info().meta.region_numbers;
                 region_number += region_numbers.len() as u64;
 
-                let engine = &table.table_info().meta.engine;
-
                 match table.region_stats() {
                     Ok(stats) => {
                         let stats = stats.into_iter().map(|stat| RegionStat {
@@ -258,7 +263,6 @@ pub async fn datanode_stat(catalog_manager: &CatalogManagerRef) -> (u64, Vec<Reg
                                 table_name: table_name.clone(),
                             }),
                             approximate_bytes: stat.disk_usage_bytes as i64,
-                            attrs: HashMap::from([("engine_name".to_owned(), engine.clone())]),
                             ..Default::default()
                         });
 

src/catalog/src/local/manager.rs

@@ -26,7 +26,6 @@ use common_telemetry::{error, info};
 use datatypes::prelude::ScalarVector;
 use datatypes::vectors::{BinaryVector, UInt8Vector};
 use futures_util::lock::Mutex;
-use metrics::increment_gauge;
 use snafu::{ensure, OptionExt, ResultExt};
 use table::engine::manager::TableEngineManagerRef;
 use table::engine::EngineContext;
@@ -49,9 +48,9 @@ use crate::system::{
 };
 use crate::tables::SystemCatalog;
 use crate::{
-    handle_system_table_request, CatalogManager, CatalogProviderRef, DeregisterTableRequest,
-    RegisterSchemaRequest, RegisterSystemTableRequest, RegisterTableRequest, RenameTableRequest,
-    SchemaProviderRef,
+    handle_system_table_request, CatalogList, CatalogManager, CatalogProvider, CatalogProviderRef,
+    DeregisterTableRequest, RegisterSchemaRequest, RegisterSystemTableRequest,
+    RegisterTableRequest, RenameTableRequest, SchemaProvider, SchemaProviderRef,
 };
 
 /// A `CatalogManager` consists of a system catalog and a bunch of user catalogs.
@@ -89,7 +88,7 @@ impl LocalCatalogManager {
 
     /// Scan all entries from system catalog table
     pub async fn init(&self) -> Result<()> {
-        self.init_system_catalog().await?;
+        self.init_system_catalog()?;
         let system_records = self.system.information_schema.system.records().await?;
         let entries = self.collect_system_catalog_entries(system_records).await?;
         let max_table_id = self.handle_system_catalog_entries(entries).await?;
@@ -115,27 +114,27 @@ impl LocalCatalogManager {
         Ok(())
     }
 
-    async fn init_system_catalog(&self) -> Result<()> {
+    fn init_system_catalog(&self) -> Result<()> {
         let system_schema = Arc::new(MemorySchemaProvider::new());
-        system_schema.register_table_sync(
+        system_schema.register_table(
             SYSTEM_CATALOG_TABLE_NAME.to_string(),
             self.system.information_schema.system.clone(),
         )?;
         let system_catalog = Arc::new(MemoryCatalogProvider::new());
-        system_catalog.register_schema_sync(INFORMATION_SCHEMA_NAME.to_string(), system_schema)?;
+        system_catalog.register_schema(INFORMATION_SCHEMA_NAME.to_string(), system_schema)?;
         self.catalogs
-            .register_catalog_sync(SYSTEM_CATALOG_NAME.to_string(), system_catalog)?;
+            .register_catalog(SYSTEM_CATALOG_NAME.to_string(), system_catalog)?;
 
         let default_catalog = Arc::new(MemoryCatalogProvider::new());
         let default_schema = Arc::new(MemorySchemaProvider::new());
 
         // Add numbers table for test
         let table = Arc::new(NumbersTable::default());
-        default_schema.register_table_sync("numbers".to_string(), table)?;
+        default_schema.register_table("numbers".to_string(), table)?;
 
-        default_catalog.register_schema_sync(DEFAULT_SCHEMA_NAME.to_string(), default_schema)?;
+        default_catalog.register_schema(DEFAULT_SCHEMA_NAME.to_string(), default_schema)?;
         self.catalogs
-            .register_catalog_sync(DEFAULT_CATALOG_NAME.to_string(), default_catalog)?;
+            .register_catalog(DEFAULT_CATALOG_NAME.to_string(), default_catalog)?;
         Ok(())
     }
 
@@ -214,17 +213,16 @@ impl LocalCatalogManager {
                     info!("Register catalog: {}", c.catalog_name);
                 }
                 Entry::Schema(s) => {
-                    self.catalogs
-                        .catalog(&s.catalog_name)
-                        .await?
-                        .context(CatalogNotFoundSnafu {
-                            catalog_name: &s.catalog_name,
-                        })?
-                        .register_schema(
-                            s.schema_name.clone(),
-                            Arc::new(MemorySchemaProvider::new()),
-                        )
-                        .await?;
+                    let catalog =
+                        self.catalogs
+                            .catalog(&s.catalog_name)?
+                            .context(CatalogNotFoundSnafu {
+                                catalog_name: &s.catalog_name,
+                            })?;
+                    catalog.register_schema(
+                        s.schema_name.clone(),
+                        Arc::new(MemorySchemaProvider::new()),
+                    )?;
                     info!("Registered schema: {:?}", s);
                 }
                 Entry::Table(t) => {
@@ -245,16 +243,14 @@ impl LocalCatalogManager {
     }
 
     async fn open_and_register_table(&self, t: &TableEntry) -> Result<()> {
-        let catalog =
-            self.catalogs
-                .catalog(&t.catalog_name)
-                .await?
-                .context(CatalogNotFoundSnafu {
-                    catalog_name: &t.catalog_name,
-                })?;
+        let catalog = self
+            .catalogs
+            .catalog(&t.catalog_name)?
+            .context(CatalogNotFoundSnafu {
+                catalog_name: &t.catalog_name,
+            })?;
         let schema = catalog
-            .schema(&t.schema_name)
-            .await?
+            .schema(&t.schema_name)?
             .context(SchemaNotFoundSnafu {
                 catalog: &t.catalog_name,
                 schema: &t.schema_name,
@@ -266,7 +262,6 @@ impl LocalCatalogManager {
             schema_name: t.schema_name.clone(),
             table_name: t.table_name.clone(),
             table_id: t.table_id,
-            region_numbers: vec![0],
         };
         let engine = self
             .engine_manager
@@ -291,11 +286,37 @@ impl LocalCatalogManager {
                 ),
             })?;
 
-        schema.register_table(t.table_name.clone(), option).await?;
+        schema.register_table(t.table_name.clone(), option)?;
         Ok(())
     }
 }
 
+impl CatalogList for LocalCatalogManager {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn register_catalog(
+        &self,
+        name: String,
+        catalog: CatalogProviderRef,
+    ) -> Result<Option<CatalogProviderRef>> {
+        self.catalogs.register_catalog(name, catalog)
+    }
+
+    fn catalog_names(&self) -> Result<Vec<String>> {
+        self.catalogs.catalog_names()
+    }
+
+    fn catalog(&self, name: &str) -> Result<Option<CatalogProviderRef>> {
+        if name.eq_ignore_ascii_case(SYSTEM_CATALOG_NAME) {
+            Ok(Some(self.system.clone()))
+        } else {
+            self.catalogs.catalog(name)
+        }
+    }
+}
+
 #[async_trait::async_trait]
 impl TableIdProvider for LocalCatalogManager {
     async fn next_table_id(&self) -> table::Result<TableId> {
@@ -326,12 +347,10 @@ impl CatalogManager for LocalCatalogManager {
 
         let catalog = self
             .catalogs
-            .catalog(catalog_name)
-            .await?
+            .catalog(catalog_name)?
             .context(CatalogNotFoundSnafu { catalog_name })?;
         let schema = catalog
-            .schema(schema_name)
-            .await?
+            .schema(schema_name)?
             .with_context(|| SchemaNotFoundSnafu {
                 catalog: catalog_name,
                 schema: schema_name,
@@ -369,14 +388,7 @@ impl CatalogManager for LocalCatalogManager {
                         engine,
                     )
                     .await?;
-                schema
-                    .register_table(request.table_name, request.table)
-                    .await?;
-                increment_gauge!(
-                    crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-                    1.0,
-                    &[crate::metrics::db_label(catalog_name, schema_name)],
-                );
+                schema.register_table(request.table_name, request.table)?;
                 Ok(true)
             }
         }
@@ -397,13 +409,11 @@ impl CatalogManager for LocalCatalogManager {
 
         let catalog = self
             .catalogs
-            .catalog(catalog_name)
-            .await?
+            .catalog(catalog_name)?
             .context(CatalogNotFoundSnafu { catalog_name })?;
 
         let schema = catalog
-            .schema(schema_name)
-            .await?
+            .schema(schema_name)?
             .with_context(|| SchemaNotFoundSnafu {
                 catalog: catalog_name,
                 schema: schema_name,
@@ -411,7 +421,7 @@ impl CatalogManager for LocalCatalogManager {
 
         let _lock = self.register_lock.lock().await;
         ensure!(
-            !schema.table_exist(&request.new_table_name).await?,
+            !schema.table_exist(&request.new_table_name)?,
             TableExistsSnafu {
                 table: &request.new_table_name
             }
@@ -437,7 +447,6 @@ impl CatalogManager for LocalCatalogManager {
 
         let renamed = schema
             .rename_table(&request.table_name, request.new_table_name.clone())
-            .await
             .is_ok();
         Ok(renamed)
     }
@@ -488,14 +497,13 @@ impl CatalogManager for LocalCatalogManager {
 
         let catalog = self
             .catalogs
-            .catalog(catalog_name)
-            .await?
+            .catalog(catalog_name)?
             .context(CatalogNotFoundSnafu { catalog_name })?;
 
         {
             let _lock = self.register_lock.lock().await;
             ensure!(
-                catalog.schema(schema_name).await?.is_none(),
+                catalog.schema(schema_name)?.is_none(),
                 SchemaExistsSnafu {
                     schema: schema_name,
                 }
@@ -503,18 +511,12 @@ impl CatalogManager for LocalCatalogManager {
             self.system
                 .register_schema(request.catalog, schema_name.clone())
                 .await?;
-            catalog
-                .register_schema(request.schema, Arc::new(MemorySchemaProvider::new()))
-                .await?;
-
+            catalog.register_schema(request.schema, Arc::new(MemorySchemaProvider::new()))?;
             Ok(true)
         }
     }
 
     async fn register_system_table(&self, request: RegisterSystemTableRequest) -> Result<()> {
-        let catalog_name = request.create_table_request.catalog_name.clone();
-        let schema_name = request.create_table_request.schema_name.clone();
-
         ensure!(
             !*self.init_lock.lock().await,
             IllegalManagerStateSnafu {
@@ -524,23 +526,17 @@ impl CatalogManager for LocalCatalogManager {
 
         let mut sys_table_requests = self.system_table_requests.lock().await;
         sys_table_requests.push(request);
-        increment_gauge!(
-            crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-            1.0,
-            &[crate::metrics::db_label(&catalog_name, &schema_name)],
-        );
+
         Ok(())
     }
 
-    async fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>> {
+    fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>> {
         self.catalogs
-            .catalog(catalog)
-            .await?
+            .catalog(catalog)?
             .context(CatalogNotFoundSnafu {
                 catalog_name: catalog,
             })?
             .schema(schema)
-            .await
     }
 
     async fn table(
@@ -551,42 +547,16 @@ impl CatalogManager for LocalCatalogManager {
     ) -> Result<Option<TableRef>> {
         let catalog = self
             .catalogs
-            .catalog(catalog_name)
-            .await?
+            .catalog(catalog_name)?
             .context(CatalogNotFoundSnafu { catalog_name })?;
         let schema = catalog
-            .schema(schema_name)
-            .await?
+            .schema(schema_name)?
             .with_context(|| SchemaNotFoundSnafu {
                 catalog: catalog_name,
                 schema: schema_name,
             })?;
         schema.table(table_name).await
     }
-
-    async fn catalog(&self, catalog: &str) -> Result<Option<CatalogProviderRef>> {
-        if catalog.eq_ignore_ascii_case(SYSTEM_CATALOG_NAME) {
-            Ok(Some(self.system.clone()))
-        } else {
-            self.catalogs.catalog(catalog).await
-        }
-    }
-
-    async fn catalog_names(&self) -> Result<Vec<String>> {
-        self.catalogs.catalog_names().await
-    }
-
-    async fn register_catalog(
-        &self,
-        name: String,
-        catalog: CatalogProviderRef,
-    ) -> Result<Option<CatalogProviderRef>> {
-        self.catalogs.register_catalog(name, catalog).await
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
 }
 
 #[cfg(test)]

src/catalog/src/local/memory.rs

@@ -21,7 +21,6 @@ use std::sync::{Arc, RwLock};
 use async_trait::async_trait;
 use common_catalog::consts::MIN_USER_TABLE_ID;
 use common_telemetry::error;
-use metrics::{decrement_gauge, increment_gauge};
 use snafu::{ensure, OptionExt};
 use table::metadata::TableId;
 use table::table::TableIdProvider;
@@ -32,7 +31,7 @@ use crate::error::{
 };
 use crate::schema::SchemaProvider;
 use crate::{
-    CatalogManager, CatalogProvider, CatalogProviderRef, DeregisterTableRequest,
+    CatalogList, CatalogManager, CatalogProvider, CatalogProviderRef, DeregisterTableRequest,
     RegisterSchemaRequest, RegisterSystemTableRequest, RegisterTableRequest, RenameTableRequest,
     SchemaProviderRef,
 };
@@ -52,10 +51,10 @@ impl Default for MemoryCatalogManager {
         };
         let default_catalog = Arc::new(MemoryCatalogProvider::new());
         manager
-            .register_catalog_sync("greptime".to_string(), default_catalog.clone())
+            .register_catalog("greptime".to_string(), default_catalog.clone())
             .unwrap();
         default_catalog
-            .register_schema_sync("public".to_string(), Arc::new(MemorySchemaProvider::new()))
+            .register_schema("public".to_string(), Arc::new(MemorySchemaProvider::new()))
             .unwrap();
         manager
     }
@@ -76,81 +75,70 @@ impl CatalogManager for MemoryCatalogManager {
     }
 
     async fn register_table(&self, request: RegisterTableRequest) -> Result<bool> {
-        let schema = self
-            .catalog(&request.catalog)
+        let catalogs = self.catalogs.write().unwrap();
+        let catalog = catalogs
+            .get(&request.catalog)
             .context(CatalogNotFoundSnafu {
                 catalog_name: &request.catalog,
             })?
-            .schema(&request.schema)
-            .await?
-            .context(SchemaNotFoundSnafu {
-                catalog: &request.catalog,
-                schema: &request.schema,
-            })?;
-        increment_gauge!(
-            crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-            1.0,
-            &[crate::metrics::db_label(&request.catalog, &request.schema)],
-        );
-        schema
-            .register_table(request.table_name, request.table)
-            .await
-            .map(|v| v.is_none())
-    }
-
-    async fn rename_table(&self, request: RenameTableRequest) -> Result<bool> {
-        let catalog = self
-            .catalog(&request.catalog)
-            .context(CatalogNotFoundSnafu {
-                catalog_name: &request.catalog,
-            })?;
-        let schema =
-            catalog
-                .schema(&request.schema)
-                .await?
-                .with_context(|| SchemaNotFoundSnafu {
-                    catalog: &request.catalog,
-                    schema: &request.schema,
-                })?;
-        Ok(schema
-            .rename_table(&request.table_name, request.new_table_name)
-            .await
-            .is_ok())
-    }
-
-    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<bool> {
-        let schema = self
-            .catalog(&request.catalog)
-            .context(CatalogNotFoundSnafu {
-                catalog_name: &request.catalog,
-            })?
-            .schema(&request.schema)
-            .await?
+            .clone();
+        let schema = catalog
+            .schema(&request.schema)?
+            .with_context(|| SchemaNotFoundSnafu {
+                catalog: &request.catalog,
+                schema: &request.schema,
+            })?;
+        schema
+            .register_table(request.table_name, request.table)
+            .map(|v| v.is_none())
+    }
+
+    async fn rename_table(&self, request: RenameTableRequest) -> Result<bool> {
+        let catalogs = self.catalogs.write().unwrap();
+        let catalog = catalogs
+            .get(&request.catalog)
+            .context(CatalogNotFoundSnafu {
+                catalog_name: &request.catalog,
+            })?
+            .clone();
+        let schema = catalog
+            .schema(&request.schema)?
+            .with_context(|| SchemaNotFoundSnafu {
+                catalog: &request.catalog,
+                schema: &request.schema,
+            })?;
+        Ok(schema
+            .rename_table(&request.table_name, request.new_table_name)
+            .is_ok())
+    }
+
+    async fn deregister_table(&self, request: DeregisterTableRequest) -> Result<bool> {
+        let catalogs = self.catalogs.write().unwrap();
+        let catalog = catalogs
+            .get(&request.catalog)
+            .context(CatalogNotFoundSnafu {
+                catalog_name: &request.catalog,
+            })?
+            .clone();
+        let schema = catalog
+            .schema(&request.schema)?
             .with_context(|| SchemaNotFoundSnafu {
                 catalog: &request.catalog,
                 schema: &request.schema,
             })?;
-        decrement_gauge!(
-            crate::metrics::METRIC_CATALOG_MANAGER_TABLE_COUNT,
-            1.0,
-            &[crate::metrics::db_label(&request.catalog, &request.schema)],
-        );
         schema
             .deregister_table(&request.table_name)
-            .await
             .map(|v| v.is_some())
     }
 
     async fn register_schema(&self, request: RegisterSchemaRequest) -> Result<bool> {
-        let catalog = self
-            .catalog(&request.catalog)
+        let catalogs = self.catalogs.write().unwrap();
+        let catalog = catalogs
+            .get(&request.catalog)
             .context(CatalogNotFoundSnafu {
                 catalog_name: &request.catalog,
             })?;
-        catalog
-            .register_schema(request.schema, Arc::new(MemorySchemaProvider::new()))
-            .await?;
-        increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_SCHEMA_COUNT, 1.0);
+        catalog.register_schema(request.schema, Arc::new(MemorySchemaProvider::new()))?;
         Ok(true)
     }
 
@@ -159,9 +147,10 @@ impl CatalogManager for MemoryCatalogManager {
         Ok(())
     }
 
-    async fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>> {
-        if let Some(c) = self.catalog(catalog) {
-            c.schema(schema).await
+    fn schema(&self, catalog: &str, schema: &str) -> Result<Option<SchemaProviderRef>> {
+        let catalogs = self.catalogs.read().unwrap();
+        if let Some(c) = catalogs.get(catalog) {
+            c.schema(schema)
         } else {
             Ok(None)
         }
@@ -173,31 +162,15 @@ impl CatalogManager for MemoryCatalogManager {
         schema: &str,
         table_name: &str,
     ) -> Result<Option<TableRef>> {
-        let Some(catalog) = self
-            .catalog(catalog) else { return Ok(None)};
-        let Some(s) = catalog.schema(schema).await? else { return Ok(None) };
-        s.table(table_name).await
-    }
-
-    async fn catalog(&self, catalog: &str) -> Result<Option<CatalogProviderRef>> {
-        Ok(self.catalogs.read().unwrap().get(catalog).cloned())
-    }
-
-    async fn catalog_names(&self) -> Result<Vec<String>> {
-        Ok(self.catalogs.read().unwrap().keys().cloned().collect())
-    }
-
-    async fn register_catalog(
-        &self,
-        name: String,
-        catalog: CatalogProviderRef,
-    ) -> Result<Option<CatalogProviderRef>> {
-        increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_CATALOG_COUNT, 1.0);
-        self.register_catalog_sync(name, catalog)
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
+        let catalog = {
+            let c = self.catalogs.read().unwrap();
+            let Some(c) = c.get(catalog) else { return Ok(None) };
+            c.clone()
+        };
+        match catalog.schema(schema)? {
+            None => Ok(None),
+            Some(s) => s.table(table_name).await,
+        }
     }
 }
 
@@ -219,8 +192,14 @@ impl MemoryCatalogManager {
             }
         }
     }
+}
 
-    pub fn register_catalog_sync(
+impl CatalogList for MemoryCatalogManager {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn register_catalog(
         &self,
         name: String,
         catalog: CatalogProviderRef,
@@ -229,8 +208,14 @@ impl MemoryCatalogManager {
         Ok(catalogs.insert(name, catalog))
     }
 
-    fn catalog(&self, catalog_name: &str) -> Option<CatalogProviderRef> {
-        self.catalogs.read().unwrap().get(catalog_name).cloned()
+    fn catalog_names(&self) -> Result<Vec<String>> {
+        let catalogs = self.catalogs.read().unwrap();
+        Ok(catalogs.keys().map(|s| s.to_string()).collect())
+    }
+
+    fn catalog(&self, name: &str) -> Result<Option<CatalogProviderRef>> {
+        let catalogs = self.catalogs.read().unwrap();
+        Ok(catalogs.get(name).cloned())
     }
 }
 
@@ -252,13 +237,19 @@ impl MemoryCatalogProvider {
             schemas: RwLock::new(HashMap::new()),
         }
     }
+}
 
-    pub fn schema_names_sync(&self) -> Result<Vec<String>> {
+impl CatalogProvider for MemoryCatalogProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema_names(&self) -> Result<Vec<String>> {
         let schemas = self.schemas.read().unwrap();
         Ok(schemas.keys().cloned().collect())
     }
 
-    pub fn register_schema_sync(
+    fn register_schema(
         &self,
         name: String,
         schema: SchemaProviderRef,
@@ -268,39 +259,15 @@ impl MemoryCatalogProvider {
             !schemas.contains_key(&name),
             error::SchemaExistsSnafu { schema: &name }
         );
-        increment_gauge!(crate::metrics::METRIC_CATALOG_MANAGER_SCHEMA_COUNT, 1.0);
         Ok(schemas.insert(name, schema))
     }
 
-    pub fn schema_sync(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>> {
+    fn schema(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>> {
         let schemas = self.schemas.read().unwrap();
         Ok(schemas.get(name).cloned())
     }
 }
 
-#[async_trait::async_trait]
-impl CatalogProvider for MemoryCatalogProvider {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    async fn schema_names(&self) -> Result<Vec<String>> {
-        self.schema_names_sync()
-    }
-
-    async fn register_schema(
-        &self,
-        name: String,
-        schema: SchemaProviderRef,
-    ) -> Result<Option<SchemaProviderRef>> {
-        self.register_schema_sync(name, schema)
-    }
-
-    async fn schema(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>> {
-        self.schema_sync(name)
-    }
-}
-
 /// Simple in-memory implementation of a schema.
 pub struct MemorySchemaProvider {
     tables: RwLock<HashMap<String, TableRef>>,
@@ -313,8 +280,31 @@ impl MemorySchemaProvider {
             tables: RwLock::new(HashMap::new()),
         }
     }
+}
 
-    pub fn register_table_sync(&self, name: String, table: TableRef) -> Result<Option<TableRef>> {
+impl Default for MemorySchemaProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait]
+impl SchemaProvider for MemorySchemaProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn table_names(&self) -> Result<Vec<String>> {
+        let tables = self.tables.read().unwrap();
+        Ok(tables.keys().cloned().collect())
+    }
+
+    async fn table(&self, name: &str) -> Result<Option<TableRef>> {
+        let tables = self.tables.read().unwrap();
+        Ok(tables.get(name).cloned())
+    }
+
+    fn register_table(&self, name: String, table: TableRef) -> Result<Option<TableRef>> {
         let mut tables = self.tables.write().unwrap();
         if let Some(existing) = tables.get(name.as_str()) {
             // if table with the same name but different table id exists, then it's a fatal bug
@@ -332,7 +322,7 @@ impl MemorySchemaProvider {
         }
     }
 
-    pub fn rename_table_sync(&self, name: &str, new_name: String) -> Result<TableRef> {
+    fn rename_table(&self, name: &str, new_name: String) -> Result<TableRef> {
         let mut tables = self.tables.write().unwrap();
         let Some(table) = tables.remove(name) else {
             return TableNotFoundSnafu {
@@ -350,53 +340,14 @@ impl MemorySchemaProvider {
         Ok(table)
     }
 
-    pub fn table_exist_sync(&self, name: &str) -> Result<bool> {
-        let tables = self.tables.read().unwrap();
-        Ok(tables.contains_key(name))
-    }
-
-    pub fn deregister_table_sync(&self, name: &str) -> Result<Option<TableRef>> {
+    fn deregister_table(&self, name: &str) -> Result<Option<TableRef>> {
         let mut tables = self.tables.write().unwrap();
         Ok(tables.remove(name))
     }
-}
 
-impl Default for MemorySchemaProvider {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[async_trait]
-impl SchemaProvider for MemorySchemaProvider {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    async fn table_names(&self) -> Result<Vec<String>> {
+    fn table_exist(&self, name: &str) -> Result<bool> {
         let tables = self.tables.read().unwrap();
-        Ok(tables.keys().cloned().collect())
-    }
-
-    async fn table(&self, name: &str) -> Result<Option<TableRef>> {
-        let tables = self.tables.read().unwrap();
-        Ok(tables.get(name).cloned())
-    }
-
-    async fn register_table(&self, name: String, table: TableRef) -> Result<Option<TableRef>> {
-        self.register_table_sync(name, table)
-    }
-
-    async fn rename_table(&self, name: &str, new_name: String) -> Result<TableRef> {
-        self.rename_table_sync(name, new_name)
-    }
-
-    async fn deregister_table(&self, name: &str) -> Result<Option<TableRef>> {
-        self.deregister_table_sync(name)
-    }
-
-    async fn table_exist(&self, name: &str) -> Result<bool> {
-        self.table_exist_sync(name)
+        Ok(tables.contains_key(name))
     }
 }
 
@@ -417,20 +368,15 @@ mod tests {
     #[tokio::test]
     async fn test_new_memory_catalog_list() {
         let catalog_list = new_memory_catalog_list().unwrap();
-        let default_catalog = CatalogManager::catalog(&*catalog_list, DEFAULT_CATALOG_NAME)
-            .await
-            .unwrap()
-            .unwrap();
+        let default_catalog = catalog_list.catalog(DEFAULT_CATALOG_NAME).unwrap().unwrap();
 
         let default_schema = default_catalog
             .schema(DEFAULT_SCHEMA_NAME)
-            .await
             .unwrap()
             .unwrap();
 
         default_schema
             .register_table("numbers".to_string(), Arc::new(NumbersTable::default()))
-            .await
             .unwrap();
 
         let table = default_schema.table("numbers").await.unwrap();
@@ -442,17 +388,17 @@ mod tests {
     async fn test_mem_provider() {
         let provider = MemorySchemaProvider::new();
         let table_name = "numbers";
-        assert!(!provider.table_exist_sync(table_name).unwrap());
-        provider.deregister_table_sync(table_name).unwrap();
+        assert!(!provider.table_exist(table_name).unwrap());
+        assert!(provider.deregister_table(table_name).unwrap().is_none());
         let test_table = NumbersTable::default();
         // register table successfully
         assert!(provider
-            .register_table_sync(table_name.to_string(), Arc::new(test_table))
+            .register_table(table_name.to_string(), Arc::new(test_table))
             .unwrap()
             .is_none());
-        assert!(provider.table_exist_sync(table_name).unwrap());
+        assert!(provider.table_exist(table_name).unwrap());
         let other_table = NumbersTable::new(12);
-        let result = provider.register_table_sync(table_name.to_string(), Arc::new(other_table));
+        let result = provider.register_table(table_name.to_string(), Arc::new(other_table));
         let err = result.err().unwrap();
         assert_eq!(StatusCode::TableAlreadyExists, err.status_code());
     }
@@ -461,27 +407,27 @@ mod tests {
     async fn test_mem_provider_rename_table() {
         let provider = MemorySchemaProvider::new();
         let table_name = "num";
-        assert!(!provider.table_exist_sync(table_name).unwrap());
+        assert!(!provider.table_exist(table_name).unwrap());
         let test_table: TableRef = Arc::new(NumbersTable::default());
         // register test table
         assert!(provider
-            .register_table_sync(table_name.to_string(), test_table.clone())
+            .register_table(table_name.to_string(), test_table.clone())
             .unwrap()
             .is_none());
-        assert!(provider.table_exist_sync(table_name).unwrap());
+        assert!(provider.table_exist(table_name).unwrap());
 
         // rename test table
         let new_table_name = "numbers";
         provider
-            .rename_table_sync(table_name, new_table_name.to_string())
+            .rename_table(table_name, new_table_name.to_string())
             .unwrap();
 
         // test old table name not exist
-        assert!(!provider.table_exist_sync(table_name).unwrap());
-        provider.deregister_table_sync(table_name).unwrap();
+        assert!(!provider.table_exist(table_name).unwrap());
+        assert!(provider.deregister_table(table_name).unwrap().is_none());
 
         // test new table name exists
-        assert!(provider.table_exist_sync(new_table_name).unwrap());
+        assert!(provider.table_exist(new_table_name).unwrap());
         let registered_table = provider.table(new_table_name).await.unwrap().unwrap();
         assert_eq!(
             registered_table.table_info().ident.table_id,
@@ -489,9 +435,7 @@ mod tests {
         );
 
         let other_table = Arc::new(NumbersTable::new(2));
-        let result = provider
-            .register_table(new_table_name.to_string(), other_table)
-            .await;
+        let result = provider.register_table(new_table_name.to_string(), other_table);
         let err = result.err().unwrap();
         assert_eq!(StatusCode::TableAlreadyExists, err.status_code());
     }
@@ -501,7 +445,6 @@ mod tests {
         let catalog = MemoryCatalogManager::default();
         let schema = catalog
             .schema(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME)
-            .await
             .unwrap()
             .unwrap();
 
@@ -517,7 +460,7 @@ mod tests {
             table,
         };
         assert!(catalog.register_table(register_table_req).await.unwrap());
-        assert!(schema.table_exist(table_name).await.unwrap());
+        assert!(schema.table_exist(table_name).unwrap());
 
         // rename table
         let new_table_name = "numbers_new";
@@ -529,8 +472,8 @@ mod tests {
             table_id,
         };
         assert!(catalog.rename_table(rename_table_req).await.unwrap());
-        assert!(!schema.table_exist(table_name).await.unwrap());
-        assert!(schema.table_exist(new_table_name).await.unwrap());
+        assert!(!schema.table_exist(table_name).unwrap());
+        assert!(schema.table_exist(new_table_name).unwrap());
 
         let registered_table = catalog
             .table(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, new_table_name)
@@ -564,7 +507,6 @@ mod tests {
         let catalog = MemoryCatalogManager::default();
         let schema = catalog
             .schema(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME)
-            .await
             .unwrap()
             .unwrap();
 
@@ -576,7 +518,7 @@ mod tests {
             table: Arc::new(NumbersTable::default()),
         };
         catalog.register_table(register_table_req).await.unwrap();
-        assert!(schema.table_exist("numbers").await.unwrap());
+        assert!(schema.table_exist("numbers").unwrap());
 
         let deregister_table_req = DeregisterTableRequest {
             catalog: DEFAULT_CATALOG_NAME.to_string(),
@@ -587,6 +529,6 @@ mod tests {
             .deregister_table(deregister_table_req)
             .await
             .unwrap();
-        assert!(!schema.table_exist("numbers").await.unwrap());
+        assert!(!schema.table_exist("numbers").unwrap());
     }
 }

src/catalog/src/metrics.rs

@@ -1,29 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use common_catalog::build_db_string;
-
-pub(crate) const METRIC_DB_LABEL: &str = "db";
-
-pub(crate) const METRIC_CATALOG_MANAGER_CATALOG_COUNT: &str = "catalog.catalog_count";
-pub(crate) const METRIC_CATALOG_MANAGER_SCHEMA_COUNT: &str = "catalog.schema_count";
-pub(crate) const METRIC_CATALOG_MANAGER_TABLE_COUNT: &str = "catalog.table_count";
-
-pub(crate) const METRIC_CATALOG_KV_REMOTE_GET: &str = "catalog.kv.get.remote";
-pub(crate) const METRIC_CATALOG_KV_GET: &str = "catalog.kv.get";
-
-#[inline]
-pub(crate) fn db_label(catalog: &str, schema: &str) -> (&'static str, String) {
-    (METRIC_DB_LABEL, build_db_string(catalog, schema))
-}

src/catalog/src/remote.rs

@@ -12,12 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::any::Any;
 use std::fmt::Debug;
 use std::pin::Pin;
 use std::sync::Arc;
 
-pub use client::{CachedMetaKvBackend, MetaKvBackend};
+pub use client::MetaKvBackend;
 use futures::Stream;
 use futures_util::StreamExt;
 pub use manager::{RemoteCatalogManager, RemoteCatalogProvider, RemoteSchemaProvider};
@@ -27,9 +26,6 @@ use crate::error::Error;
 mod client;
 mod manager;
 
-#[cfg(feature = "testing")]
-pub mod mock;
-
 #[derive(Debug, Clone)]
 pub struct Kv(pub Vec<u8>, pub Vec<u8>);
 
@@ -74,22 +70,10 @@ pub trait KvBackend: Send + Sync {
         }
         return Ok(None);
     }
-
-    /// MoveValue atomically renames the key to the given updated key.
-    async fn move_value(&self, from_key: &[u8], to_key: &[u8]) -> Result<(), Error>;
-
-    fn as_any(&self) -> &dyn Any;
 }
 
 pub type KvBackendRef = Arc<dyn KvBackend>;
 
-#[async_trait::async_trait]
-pub trait KvCacheInvalidator: Send + Sync {
-    async fn invalidate_key(&self, key: &[u8]);
-}
-
-pub type KvCacheInvalidatorRef = Arc<dyn KvCacheInvalidator>;
-
 #[cfg(test)]
 mod tests {
     use async_stream::stream;
@@ -130,29 +114,17 @@ mod tests {
         async fn delete_range(&self, _key: &[u8], _end: &[u8]) -> Result<(), Error> {
             unimplemented!()
         }
-
-        async fn move_value(&self, _from_key: &[u8], _to_key: &[u8]) -> Result<(), Error> {
-            unimplemented!()
-        }
-
-        fn as_any(&self) -> &dyn Any {
-            self
-        }
     }
 
     #[tokio::test]
     async fn test_get() {
         let backend = MockKvBackend {};
-
         let result = backend.get(0.to_string().as_bytes()).await;
         assert_eq!(0.to_string().as_bytes(), result.unwrap().unwrap().0);
-
         let result = backend.get(1.to_string().as_bytes()).await;
         assert_eq!(1.to_string().as_bytes(), result.unwrap().unwrap().0);
-
         let result = backend.get(2.to_string().as_bytes()).await;
         assert_eq!(2.to_string().as_bytes(), result.unwrap().unwrap().0);
-
         let result = backend.get(3.to_string().as_bytes()).await;
         assert!(result.unwrap().is_none());
     }

src/catalog/src/remote/client.rs

@@ -12,149 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::any::Any;
 use std::fmt::Debug;
 use std::sync::Arc;
-use std::time::Duration;
 
 use async_stream::stream;
-use common_meta::rpc::store::{
-    CompareAndPutRequest, DeleteRangeRequest, MoveValueRequest, PutRequest, RangeRequest,
-};
-use common_telemetry::{info, timer};
+use common_telemetry::info;
 use meta_client::client::MetaClient;
-use moka::future::{Cache, CacheBuilder};
+use meta_client::rpc::{CompareAndPutRequest, DeleteRangeRequest, PutRequest, RangeRequest};
 use snafu::ResultExt;
 
-use super::KvCacheInvalidator;
-use crate::error::{Error, GenericSnafu, MetaSrvSnafu, Result};
-use crate::metrics::{METRIC_CATALOG_KV_GET, METRIC_CATALOG_KV_REMOTE_GET};
-use crate::remote::{Kv, KvBackend, KvBackendRef, ValueIter};
-
-const CACHE_MAX_CAPACITY: u64 = 10000;
-const CACHE_TTL_SECOND: u64 = 10 * 60;
-const CACHE_TTI_SECOND: u64 = 5 * 60;
-
-pub type CacheBackendRef = Arc<Cache<Vec<u8>, Option<Kv>>>;
-pub struct CachedMetaKvBackend {
-    kv_backend: KvBackendRef,
-    cache: CacheBackendRef,
-}
-
-#[async_trait::async_trait]
-impl KvBackend for CachedMetaKvBackend {
-    fn range<'a, 'b>(&'a self, key: &[u8]) -> ValueIter<'b, Error>
-    where
-        'a: 'b,
-    {
-        self.kv_backend.range(key)
-    }
-
-    async fn get(&self, key: &[u8]) -> Result<Option<Kv>> {
-        let _timer = timer!(METRIC_CATALOG_KV_GET);
-
-        let init = async {
-            let _timer = timer!(METRIC_CATALOG_KV_REMOTE_GET);
-
-            self.kv_backend.get(key).await
-        };
-
-        let schema_provider = self.cache.try_get_with_by_ref(key, init).await;
-        schema_provider.map_err(|e| GenericSnafu { msg: e.to_string() }.build())
-    }
-
-    async fn set(&self, key: &[u8], val: &[u8]) -> Result<()> {
-        let ret = self.kv_backend.set(key, val).await;
-
-        if ret.is_ok() {
-            self.invalidate_key(key).await;
-        }
-
-        ret
-    }
-
-    async fn delete(&self, key: &[u8]) -> Result<()> {
-        let ret = self.kv_backend.delete_range(key, &[]).await;
-
-        if ret.is_ok() {
-            self.invalidate_key(key).await;
-        }
-
-        ret
-    }
-
-    async fn delete_range(&self, _key: &[u8], _end: &[u8]) -> Result<()> {
-        // TODO(fys): implement it
-        unimplemented!()
-    }
-
-    async fn compare_and_set(
-        &self,
-        key: &[u8],
-        expect: &[u8],
-        val: &[u8],
-    ) -> Result<std::result::Result<(), Option<Vec<u8>>>> {
-        let ret = self.kv_backend.compare_and_set(key, expect, val).await;
-
-        if ret.is_ok() {
-            self.invalidate_key(key).await;
-        }
-
-        ret
-    }
-
-    async fn move_value(&self, from_key: &[u8], to_key: &[u8]) -> Result<()> {
-        let ret = self.kv_backend.move_value(from_key, to_key).await;
-
-        if ret.is_ok() {
-            self.invalidate_key(from_key).await;
-            self.invalidate_key(to_key).await;
-        }
-
-        ret
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-#[async_trait::async_trait]
-impl KvCacheInvalidator for CachedMetaKvBackend {
-    async fn invalidate_key(&self, key: &[u8]) {
-        self.cache.invalidate(key).await
-    }
-}
-
-impl CachedMetaKvBackend {
-    pub fn new(client: Arc<MetaClient>) -> Self {
-        let cache = Arc::new(
-            CacheBuilder::new(CACHE_MAX_CAPACITY)
-                .time_to_live(Duration::from_secs(CACHE_TTL_SECOND))
-                .time_to_idle(Duration::from_secs(CACHE_TTI_SECOND))
-                .build(),
-        );
-        let kv_backend = Arc::new(MetaKvBackend { client });
-
-        Self { kv_backend, cache }
-    }
-
-    pub fn wrap(kv_backend: KvBackendRef) -> Self {
-        let cache = Arc::new(
-            CacheBuilder::new(CACHE_MAX_CAPACITY)
-                .time_to_live(Duration::from_secs(CACHE_TTL_SECOND))
-                .time_to_idle(Duration::from_secs(CACHE_TTI_SECOND))
-                .build(),
-        );
-
-        Self { kv_backend, cache }
-    }
-
-    pub fn cache(&self) -> &CacheBackendRef {
-        &self.cache
-    }
-}
-
+use crate::error::{Error, MetaSrvSnafu};
+use crate::remote::{Kv, KvBackend, ValueIter};
 #[derive(Debug)]
 pub struct MetaKvBackend {
     pub client: Arc<MetaClient>,
@@ -183,7 +51,7 @@ impl KvBackend for MetaKvBackend {
         }))
     }
 
-    async fn get(&self, key: &[u8]) -> Result<Option<Kv>> {
+    async fn get(&self, key: &[u8]) -> Result<Option<Kv>, Error> {
         let mut response = self
             .client
             .range(RangeRequest::new().with_key(key))
@@ -195,7 +63,7 @@ impl KvBackend for MetaKvBackend {
             .map(|kv| Kv(kv.take_key(), kv.take_value())))
     }
 
-    async fn set(&self, key: &[u8], val: &[u8]) -> Result<()> {
+    async fn set(&self, key: &[u8], val: &[u8]) -> Result<(), Error> {
         let req = PutRequest::new()
             .with_key(key.to_vec())
             .with_value(val.to_vec());
@@ -203,7 +71,7 @@ impl KvBackend for MetaKvBackend {
         Ok(())
     }
 
-    async fn delete_range(&self, key: &[u8], end: &[u8]) -> Result<()> {
+    async fn delete_range(&self, key: &[u8], end: &[u8]) -> Result<(), Error> {
         let req = DeleteRangeRequest::new().with_range(key.to_vec(), end.to_vec());
         let resp = self.client.delete_range(req).await.context(MetaSrvSnafu)?;
         info!(
@@ -221,7 +89,7 @@ impl KvBackend for MetaKvBackend {
         key: &[u8],
         expect: &[u8],
         val: &[u8],
-    ) -> Result<std::result::Result<(), Option<Vec<u8>>>> {
+    ) -> Result<Result<(), Option<Vec<u8>>>, Error> {
         let request = CompareAndPutRequest::new()
             .with_key(key.to_vec())
             .with_expect(expect.to_vec())
@@ -237,14 +105,4 @@ impl KvBackend for MetaKvBackend {
             Ok(Err(response.take_prev_kv().map(|v| v.value().to_vec())))
         }
     }
-
-    async fn move_value(&self, from_key: &[u8], to_key: &[u8]) -> Result<()> {
-        let req = MoveValueRequest::new(from_key, to_key);
-        self.client.move_value(req).await.context(MetaSrvSnafu)?;
-        Ok(())
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
 }

src/catalog/src/schema.rs

@@ -28,14 +28,14 @@ pub trait SchemaProvider: Sync + Send {
     fn as_any(&self) -> &dyn Any;
 
     /// Retrieves the list of available table names in this schema.
-    async fn table_names(&self) -> Result<Vec<String>>;
+    fn table_names(&self) -> Result<Vec<String>>;
 
     /// Retrieves a specific table from the schema by name, provided it exists.
     async fn table(&self, name: &str) -> Result<Option<TableRef>>;
 
     /// If supported by the implementation, adds a new table to this schema.
     /// If a table of the same name existed before, it returns "Table already exists" error.
-    async fn register_table(&self, name: String, _table: TableRef) -> Result<Option<TableRef>> {
+    fn register_table(&self, name: String, _table: TableRef) -> Result<Option<TableRef>> {
         NotSupportedSnafu {
             op: format!("register_table({name}, <table>)"),
         }
@@ -44,7 +44,7 @@ pub trait SchemaProvider: Sync + Send {
 
     /// If supported by the implementation, renames an existing table from this schema and returns it.
     /// If no table of that name exists, returns "Table not found" error.
-    async fn rename_table(&self, name: &str, new_name: String) -> Result<TableRef> {
+    fn rename_table(&self, name: &str, new_name: String) -> Result<TableRef> {
         NotSupportedSnafu {
             op: format!("rename_table({name}, {new_name})"),
         }
@@ -53,7 +53,7 @@ pub trait SchemaProvider: Sync + Send {
 
     /// If supported by the implementation, removes an existing table from this schema and returns it.
     /// If no table of that name exists, returns Ok(None).
-    async fn deregister_table(&self, name: &str) -> Result<Option<TableRef>> {
+    fn deregister_table(&self, name: &str) -> Result<Option<TableRef>> {
         NotSupportedSnafu {
             op: format!("deregister_table({name})"),
         }
@@ -63,7 +63,7 @@ pub trait SchemaProvider: Sync + Send {
     /// If supported by the implementation, checks the table exist in the schema provider or not.
     /// If no matched table in the schema provider, return false.
     /// Otherwise, return true.
-    async fn table_exist(&self, name: &str) -> Result<bool>;
+    fn table_exist(&self, name: &str) -> Result<bool>;
 }
 
 pub type SchemaProviderRef = Arc<dyn SchemaProvider>;

src/catalog/src/system.rs

@@ -30,13 +30,12 @@ use datatypes::schema::{ColumnSchema, RawSchema, SchemaRef};
 use datatypes::vectors::{BinaryVector, TimestampMillisecondVector, UInt8Vector};
 use serde::{Deserialize, Serialize};
 use snafu::{ensure, OptionExt, ResultExt};
-use store_api::storage::ScanRequest;
 use table::engine::{EngineContext, TableEngineRef};
 use table::metadata::{TableId, TableInfoRef};
 use table::requests::{
     CreateTableRequest, DeleteRequest, InsertRequest, OpenTableRequest, TableOptions,
 };
-use table::{Result as TableResult, Table, TableRef};
+use table::{Table, TableRef};
 
 use crate::error::{
     self, CreateSystemCatalogSnafu, EmptyValueSnafu, Error, InvalidEntryTypeSnafu, InvalidKeySnafu,
@@ -69,12 +68,8 @@ impl Table for SystemCatalogTable {
         self.0.scan(projection, filters, limit).await
     }
 
-    async fn scan_to_stream(&self, request: ScanRequest) -> TableResult<SendableRecordBatchStream> {
-        self.0.scan_to_stream(request).await
-    }
-
     /// Insert values into table.
-    async fn insert(&self, request: InsertRequest) -> TableResult<usize> {
+    async fn insert(&self, request: InsertRequest) -> table::error::Result<usize> {
         self.0.insert(request).await
     }
 
@@ -82,13 +77,9 @@ impl Table for SystemCatalogTable {
         self.0.table_info()
     }
 
-    async fn delete(&self, request: DeleteRequest) -> TableResult<usize> {
+    async fn delete(&self, request: DeleteRequest) -> table::Result<usize> {
         self.0.delete(request).await
     }
-
-    fn statistics(&self) -> Option<table::stats::TableStatistics> {
-        self.0.statistics()
-    }
 }
 
 impl SystemCatalogTable {
@@ -98,7 +89,6 @@ impl SystemCatalogTable {
             schema_name: INFORMATION_SCHEMA_NAME.to_string(),
             table_name: SYSTEM_CATALOG_TABLE_NAME.to_string(),
             table_id: SYSTEM_CATALOG_TABLE_ID,
-            region_numbers: vec![0],
         };
         let schema = build_system_catalog_schema();
         let ctx = EngineContext::default();
@@ -514,8 +504,7 @@ mod tests {
                 Arc::new(NoopLogStore::default()),
                 object_store.clone(),
                 noop_compaction_scheduler,
-            )
-            .unwrap(),
+            ),
             object_store,
         ));
         (dir, table_engine)

src/catalog/src/table_source.rs

@@ -28,10 +28,10 @@ use crate::error::{
     CatalogNotFoundSnafu, QueryAccessDeniedSnafu, Result, SchemaNotFoundSnafu, TableNotExistSnafu,
 };
 use crate::information_schema::InformationSchemaProvider;
-use crate::CatalogManagerRef;
+use crate::CatalogListRef;
 
 pub struct DfTableSourceProvider {
-    catalog_manager: CatalogManagerRef,
+    catalog_list: CatalogListRef,
     resolved_tables: HashMap<String, Arc<dyn TableSource>>,
     disallow_cross_schema_query: bool,
     default_catalog: String,
@@ -40,12 +40,12 @@ pub struct DfTableSourceProvider {
 
 impl DfTableSourceProvider {
     pub fn new(
-        catalog_manager: CatalogManagerRef,
+        catalog_list: CatalogListRef,
         disallow_cross_schema_query: bool,
         query_ctx: &QueryContext,
     ) -> Self {
         Self {
-            catalog_manager,
+            catalog_list,
             disallow_cross_schema_query,
             resolved_tables: HashMap::new(),
             default_catalog: query_ctx.current_catalog(),
@@ -62,8 +62,7 @@ impl DfTableSourceProvider {
                 TableReference::Bare { .. } => (),
                 TableReference::Partial { schema, .. } => {
                     ensure!(
-                        schema.as_ref() == self.default_schema
-                            || schema.as_ref() == INFORMATION_SCHEMA_NAME,
+                        schema.as_ref() == self.default_schema,
                         QueryAccessDeniedSnafu {
                             catalog: &self.default_catalog,
                             schema: schema.as_ref(),
@@ -75,8 +74,7 @@ impl DfTableSourceProvider {
                 } => {
                     ensure!(
                         catalog.as_ref() == self.default_catalog
-                            && (schema.as_ref() == self.default_schema
-                                || schema.as_ref() == INFORMATION_SCHEMA_NAME),
+                            && schema.as_ref() == self.default_schema,
                         QueryAccessDeniedSnafu {
                             catalog: catalog.as_ref(),
                             schema: schema.as_ref()
@@ -106,22 +104,17 @@ impl DfTableSourceProvider {
 
         let schema = if schema_name != INFORMATION_SCHEMA_NAME {
             let catalog = self
-                .catalog_manager
-                .catalog(catalog_name)
-                .await?
+                .catalog_list
+                .catalog(catalog_name)?
                 .context(CatalogNotFoundSnafu { catalog_name })?;
-            catalog
-                .schema(schema_name)
-                .await?
-                .context(SchemaNotFoundSnafu {
-                    catalog: catalog_name,
-                    schema: schema_name,
-                })?
+            catalog.schema(schema_name)?.context(SchemaNotFoundSnafu {
+                catalog: catalog_name,
+                schema: schema_name,
+            })?
         } else {
             let catalog_provider = self
-                .catalog_manager
-                .catalog(catalog_name)
-                .await?
+                .catalog_list
+                .catalog(catalog_name)?
                 .context(CatalogNotFoundSnafu { catalog_name })?;
             Arc::new(InformationSchemaProvider::new(
                 catalog_name.to_string(),
@@ -193,25 +186,5 @@ mod tests {
         };
         let result = table_provider.resolve_table_ref(table_ref);
         assert!(result.is_err());
-
-        let table_ref = TableReference::Partial {
-            schema: Cow::Borrowed("information_schema"),
-            table: Cow::Borrowed("columns"),
-        };
-        assert!(table_provider.resolve_table_ref(table_ref).is_ok());
-
-        let table_ref = TableReference::Full {
-            catalog: Cow::Borrowed("greptime"),
-            schema: Cow::Borrowed("information_schema"),
-            table: Cow::Borrowed("columns"),
-        };
-        assert!(table_provider.resolve_table_ref(table_ref).is_ok());
-
-        let table_ref = TableReference::Full {
-            catalog: Cow::Borrowed("dummy"),
-            schema: Cow::Borrowed("information_schema"),
-            table: Cow::Borrowed("columns"),
-        };
-        assert!(table_provider.resolve_table_ref(table_ref).is_err());
     }
 }

src/catalog/src/tables.rs

@@ -40,7 +40,7 @@ impl SchemaProvider for InformationSchema {
         self
     }
 
-    async fn table_names(&self) -> Result<Vec<String>, Error> {
+    fn table_names(&self) -> Result<Vec<String>, Error> {
         Ok(vec![SYSTEM_CATALOG_TABLE_NAME.to_string()])
     }
 
@@ -52,7 +52,7 @@ impl SchemaProvider for InformationSchema {
         }
     }
 
-    async fn table_exist(&self, name: &str) -> Result<bool, Error> {
+    fn table_exist(&self, name: &str) -> Result<bool, Error> {
         Ok(name.eq_ignore_ascii_case(SYSTEM_CATALOG_TABLE_NAME))
     }
 }
@@ -116,17 +116,16 @@ impl SystemCatalog {
     }
 }
 
-#[async_trait::async_trait]
 impl CatalogProvider for SystemCatalog {
     fn as_any(&self) -> &dyn Any {
         self
     }
 
-    async fn schema_names(&self) -> Result<Vec<String>, Error> {
+    fn schema_names(&self) -> Result<Vec<String>, Error> {
         Ok(vec![INFORMATION_SCHEMA_NAME.to_string()])
     }
 
-    async fn register_schema(
+    fn register_schema(
         &self,
         _name: String,
         _schema: SchemaProviderRef,
@@ -134,7 +133,7 @@ impl CatalogProvider for SystemCatalog {
         panic!("System catalog does not support registering schema!")
     }
 
-    async fn schema(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>, Error> {
+    fn schema(&self, name: &str) -> Result<Option<Arc<dyn SchemaProvider>>, Error> {
         if name.eq_ignore_ascii_case(INFORMATION_SCHEMA_NAME) {
             Ok(Some(self.information_schema.clone()))
         } else {

src/catalog/tests/local_catalog_tests.rs

@@ -20,16 +20,14 @@ mod tests {
     use catalog::{CatalogManager, RegisterTableRequest, RenameTableRequest};
     use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
     use common_telemetry::{error, info};
-    use common_test_util::temp_dir::TempDir;
     use mito::config::EngineConfig;
     use table::engine::manager::MemoryTableEngineManager;
     use table::table::numbers::NumbersTable;
     use table::TableRef;
     use tokio::sync::Mutex;
 
-    async fn create_local_catalog_manager(
-    ) -> Result<(TempDir, LocalCatalogManager), catalog::error::Error> {
-        let (dir, object_store) =
+    async fn create_local_catalog_manager() -> Result<LocalCatalogManager, catalog::error::Error> {
+        let (_dir, object_store) =
             mito::table::test_util::new_test_object_store("setup_mock_engine_and_table").await;
         let mock_engine = Arc::new(mito::table::test_util::MockMitoEngine::new(
             EngineConfig::default(),
@@ -39,13 +37,13 @@ mod tests {
         let engine_manager = Arc::new(MemoryTableEngineManager::new(mock_engine.clone()));
         let catalog_manager = LocalCatalogManager::try_new(engine_manager).await.unwrap();
         catalog_manager.start().await?;
-        Ok((dir, catalog_manager))
+        Ok(catalog_manager)
     }
 
     #[tokio::test]
     async fn test_rename_table() {
         common_telemetry::init_default_ut_logging();
-        let (_dir, catalog_manager) = create_local_catalog_manager().await.unwrap();
+        let catalog_manager = create_local_catalog_manager().await.unwrap();
         // register table
         let table_name = "test_table";
         let table_id = 42;
@@ -83,7 +81,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_duplicate_register() {
-        let (_dir, catalog_manager) = create_local_catalog_manager().await.unwrap();
+        let catalog_manager = create_local_catalog_manager().await.unwrap();
         let request = RegisterTableRequest {
             catalog: DEFAULT_CATALOG_NAME.to_string(),
             schema: DEFAULT_SCHEMA_NAME.to_string(),
@@ -120,9 +118,8 @@ mod tests {
     fn test_concurrent_register() {
         common_telemetry::init_default_ut_logging();
         let rt = Arc::new(tokio::runtime::Builder::new_multi_thread().build().unwrap());
-        let (_dir, catalog_manager) =
-            rt.block_on(async { create_local_catalog_manager().await.unwrap() });
-        let catalog_manager = Arc::new(catalog_manager);
+        let catalog_manager =
+            Arc::new(rt.block_on(async { create_local_catalog_manager().await.unwrap() }));
 
         let succeed: Arc<Mutex<Option<TableRef>>> = Arc::new(Mutex::new(None));
 

src/catalog/tests/mock.rs

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::any::Any;
 use std::collections::btree_map::Entry;
 use std::collections::{BTreeMap, HashMap};
 use std::fmt::{Display, Formatter};
@@ -20,7 +19,8 @@ use std::str::FromStr;
 use std::sync::Arc;
 
 use async_stream::stream;
-use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
+use catalog::error::Error;
+use catalog::remote::{Kv, KvBackend, ValueIter};
 use common_recordbatch::RecordBatch;
 use common_telemetry::logging::info;
 use datatypes::data_type::ConcreteDataType;
@@ -34,40 +34,11 @@ use table::test_util::MemTable;
 use table::TableRef;
 use tokio::sync::RwLock;
 
-use crate::error::Error;
-use crate::helper::{CatalogKey, CatalogValue, SchemaKey, SchemaValue};
-use crate::remote::{Kv, KvBackend, ValueIter};
-
+#[derive(Default)]
 pub struct MockKvBackend {
     map: RwLock<BTreeMap<Vec<u8>, Vec<u8>>>,
 }
 
-impl Default for MockKvBackend {
-    fn default() -> Self {
-        let mut map = BTreeMap::default();
-        let catalog_value = CatalogValue {}.as_bytes().unwrap();
-        let schema_value = SchemaValue {}.as_bytes().unwrap();
-
-        let default_catalog_key = CatalogKey {
-            catalog_name: DEFAULT_CATALOG_NAME.to_string(),
-        }
-        .to_string();
-
-        let default_schema_key = SchemaKey {
-            catalog_name: DEFAULT_CATALOG_NAME.to_string(),
-            schema_name: DEFAULT_SCHEMA_NAME.to_string(),
-        }
-        .to_string();
-
-        // create default catalog and schema
-        map.insert(default_catalog_key.into(), catalog_value);
-        map.insert(default_schema_key.into(), schema_value);
-
-        let map = RwLock::new(map);
-        Self { map }
-    }
-}
-
 impl Display for MockKvBackend {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         futures::executor::block_on(async {
@@ -141,26 +112,14 @@ impl KvBackend for MockKvBackend {
     }
 
     async fn delete_range(&self, key: &[u8], end: &[u8]) -> Result<(), Error> {
+        let start = key.to_vec();
+        let end = end.to_vec();
+        let range = start..end;
+
         let mut map = self.map.write().await;
-        if end.is_empty() {
-            let _ = map.remove(key);
-        } else {
-            let start = key.to_vec();
-            let end = end.to_vec();
-            let range = start..end;
-
-            map.retain(|k, _| !range.contains(k));
-        }
+        map.retain(|k, _| !range.contains(k));
         Ok(())
     }
-
-    async fn move_value(&self, _from_key: &[u8], _to_key: &[u8]) -> Result<(), Error> {
-        unimplemented!()
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
 }
 
 #[derive(Default)]

src/catalog/tests/remote_catalog_tests.rs

@@ -14,6 +14,8 @@
 
 #![feature(assert_matches)]
 
+mod mock;
+
 #[cfg(test)]
 mod tests {
     use std::assert_matches::assert_matches;
@@ -21,19 +23,19 @@ mod tests {
     use std::sync::Arc;
 
     use catalog::helper::{CatalogKey, CatalogValue, SchemaKey, SchemaValue};
-    use catalog::remote::mock::{MockKvBackend, MockTableEngine};
     use catalog::remote::{
-        CachedMetaKvBackend, KvBackend, KvBackendRef, RemoteCatalogManager, RemoteCatalogProvider,
-        RemoteSchemaProvider,
+        KvBackend, KvBackendRef, RemoteCatalogManager, RemoteCatalogProvider, RemoteSchemaProvider,
     };
-    use catalog::{CatalogManager, RegisterTableRequest};
+    use catalog::{CatalogList, CatalogManager, RegisterTableRequest};
     use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, MITO_ENGINE};
     use datatypes::schema::RawSchema;
     use futures_util::StreamExt;
-    use table::engine::manager::{MemoryTableEngineManager, TableEngineManagerRef};
+    use table::engine::manager::MemoryTableEngineManager;
     use table::engine::{EngineContext, TableEngineRef};
     use table::requests::CreateTableRequest;
 
+    use crate::mock::{MockKvBackend, MockTableEngine};
+
     #[tokio::test]
     async fn test_backend() {
         common_telemetry::init_default_ut_logging();
@@ -74,100 +76,37 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn test_cached_backend() {
-        common_telemetry::init_default_ut_logging();
-        let backend = CachedMetaKvBackend::wrap(Arc::new(MockKvBackend::default()));
-
-        let default_catalog_key = CatalogKey {
-            catalog_name: DEFAULT_CATALOG_NAME.to_string(),
-        }
-        .to_string();
-
-        backend
-            .set(
-                default_catalog_key.as_bytes(),
-                &CatalogValue {}.as_bytes().unwrap(),
-            )
-            .await
-            .unwrap();
-
-        let ret = backend.get(b"__c-greptime").await.unwrap();
-        assert!(ret.is_some());
-
-        let _ = backend
-            .compare_and_set(
-                b"__c-greptime",
-                &CatalogValue {}.as_bytes().unwrap(),
-                b"123",
-            )
-            .await
-            .unwrap();
-
-        let ret = backend.get(b"__c-greptime").await.unwrap();
-        assert!(ret.is_some());
-        assert_eq!(&b"123"[..], &(ret.as_ref().unwrap().1));
-
-        let _ = backend.set(b"__c-greptime", b"1234").await;
-
-        let ret = backend.get(b"__c-greptime").await.unwrap();
-        assert!(ret.is_some());
-        assert_eq!(&b"1234"[..], &(ret.as_ref().unwrap().1));
-
-        backend.delete(b"__c-greptime").await.unwrap();
-
-        let ret = backend.get(b"__c-greptime").await.unwrap();
-        assert!(ret.is_none());
-    }
-
     async fn prepare_components(
         node_id: u64,
-    ) -> (
-        KvBackendRef,
-        TableEngineRef,
-        Arc<RemoteCatalogManager>,
-        TableEngineManagerRef,
-    ) {
-        let cached_backend = Arc::new(CachedMetaKvBackend::wrap(
-            Arc::new(MockKvBackend::default()),
-        ));
-
+    ) -> (KvBackendRef, TableEngineRef, Arc<RemoteCatalogManager>) {
+        let backend = Arc::new(MockKvBackend::default()) as KvBackendRef;
         let table_engine = Arc::new(MockTableEngine::default());
         let engine_manager = Arc::new(MemoryTableEngineManager::alias(
             MITO_ENGINE.to_string(),
             table_engine.clone(),
         ));
-
-        let catalog_manager =
-            RemoteCatalogManager::new(engine_manager.clone(), node_id, cached_backend.clone());
+        let catalog_manager = RemoteCatalogManager::new(engine_manager, node_id, backend.clone());
         catalog_manager.start().await.unwrap();
-
-        (
-            cached_backend,
-            table_engine,
-            Arc::new(catalog_manager),
-            engine_manager as Arc<_>,
-        )
+        (backend, table_engine, Arc::new(catalog_manager))
     }
 
     #[tokio::test]
     async fn test_remote_catalog_default() {
         common_telemetry::init_default_ut_logging();
         let node_id = 42;
-        let (_, _, catalog_manager, _) = prepare_components(node_id).await;
+        let (_, _, catalog_manager) = prepare_components(node_id).await;
         assert_eq!(
             vec![DEFAULT_CATALOG_NAME.to_string()],
-            catalog_manager.catalog_names().await.unwrap()
+            catalog_manager.catalog_names().unwrap()
         );
 
         let default_catalog = catalog_manager
             .catalog(DEFAULT_CATALOG_NAME)
-            .await
             .unwrap()
             .unwrap();
         assert_eq!(
             vec![DEFAULT_SCHEMA_NAME.to_string()],
-            default_catalog.schema_names().await.unwrap()
+            default_catalog.schema_names().unwrap()
         );
     }
 
@@ -175,7 +114,7 @@ mod tests {
     async fn test_remote_catalog_register_nonexistent() {
         common_telemetry::init_default_ut_logging();
         let node_id = 42;
-        let (_, table_engine, catalog_manager, _) = prepare_components(node_id).await;
+        let (_, table_engine, catalog_manager) = prepare_components(node_id).await;
         // register a new table with an nonexistent catalog
         let catalog_name = "nonexistent_catalog".to_string();
         let schema_name = "nonexistent_schema".to_string();
@@ -220,20 +159,18 @@ mod tests {
     #[tokio::test]
     async fn test_register_table() {
         let node_id = 42;
-        let (_, table_engine, catalog_manager, _) = prepare_components(node_id).await;
+        let (_, table_engine, catalog_manager) = prepare_components(node_id).await;
         let default_catalog = catalog_manager
             .catalog(DEFAULT_CATALOG_NAME)
-            .await
             .unwrap()
             .unwrap();
         assert_eq!(
             vec![DEFAULT_SCHEMA_NAME.to_string()],
-            default_catalog.schema_names().await.unwrap()
+            default_catalog.schema_names().unwrap()
         );
 
         let default_schema = default_catalog
             .schema(DEFAULT_SCHEMA_NAME)
-            .await
             .unwrap()
             .unwrap();
 
@@ -271,36 +208,31 @@ mod tests {
             table,
         };
         assert!(catalog_manager.register_table(reg_req).await.unwrap());
-        assert_eq!(
-            vec![table_name],
-            default_schema.table_names().await.unwrap()
-        );
+        assert_eq!(vec![table_name], default_schema.table_names().unwrap());
     }
 
     #[tokio::test]
     async fn test_register_catalog_schema_table() {
         let node_id = 42;
-        let (backend, table_engine, catalog_manager, engine_manager) =
-            prepare_components(node_id).await;
+        let (backend, table_engine, catalog_manager) = prepare_components(node_id).await;
 
         let catalog_name = "test_catalog".to_string();
         let schema_name = "nonexistent_schema".to_string();
         let catalog = Arc::new(RemoteCatalogProvider::new(
             catalog_name.clone(),
             backend.clone(),
-            engine_manager.clone(),
             node_id,
         ));
 
         // register catalog to catalog manager
-        CatalogManager::register_catalog(&*catalog_manager, catalog_name.clone(), catalog)
-            .await
+        catalog_manager
+            .register_catalog(catalog_name.clone(), catalog)
             .unwrap();
         assert_eq!(
             HashSet::<String>::from_iter(
                 vec![DEFAULT_CATALOG_NAME.to_string(), catalog_name.clone()].into_iter()
             ),
-            HashSet::from_iter(catalog_manager.catalog_names().await.unwrap().into_iter())
+            HashSet::from_iter(catalog_manager.catalog_names().unwrap().into_iter())
         );
 
         let table_to_register = table_engine
@@ -341,32 +273,24 @@ mod tests {
 
         let new_catalog = catalog_manager
             .catalog(&catalog_name)
-            .await
             .unwrap()
             .expect("catalog should exist since it's already registered");
         let schema = Arc::new(RemoteSchemaProvider::new(
             catalog_name.clone(),
             schema_name.clone(),
             node_id,
-            engine_manager,
             backend.clone(),
         ));
 
         let prev = new_catalog
             .register_schema(schema_name.clone(), schema.clone())
-            .await
             .expect("Register schema should not fail");
         assert!(prev.is_none());
         assert!(catalog_manager.register_table(reg_req).await.unwrap());
 
         assert_eq!(
             HashSet::from([schema_name.clone()]),
-            new_catalog
-                .schema_names()
-                .await
-                .unwrap()
-                .into_iter()
-                .collect()
+            new_catalog.schema_names().unwrap().into_iter().collect()
         )
     }
 }

src/client/Cargo.toml

@@ -4,9 +4,6 @@ version.workspace = true
 edition.workspace = true
 license.workspace = true
 
-[features]
-testing = []
-
 [dependencies]
 api = { path = "../api" }
 arrow-flight.workspace = true
@@ -19,28 +16,25 @@ common-grpc-expr = { path = "../common/grpc-expr" }
 common-query = { path = "../common/query" }
 common-recordbatch = { path = "../common/recordbatch" }
 common-time = { path = "../common/time" }
-common-meta = { path = "../common/meta" }
 common-telemetry = { path = "../common/telemetry" }
 datafusion.workspace = true
 datatypes = { path = "../datatypes" }
 enum_dispatch = "0.3"
 futures-util.workspace = true
-moka = { version = "0.9", features = ["future"] }
 parking_lot = "0.12"
 prost.workspace = true
 rand.workspace = true
 snafu.workspace = true
-tokio-stream = { version = "0.1", features = ["net"] }
-tokio.workspace = true
 tonic.workspace = true
 
 [dev-dependencies]
 datanode = { path = "../datanode" }
 substrait = { path = "../common/substrait" }
+tokio.workspace = true
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 prost.workspace = true
 
 [dev-dependencies.substrait_proto]
 package = "substrait"
-version = "0.7"
+version = "0.4"

src/client/examples/logical.rs

@@ -63,7 +63,7 @@ async fn run() {
         create_if_not_exists: false,
         table_options: Default::default(),
         table_id: Some(TableId { id: 1024 }),
-        region_numbers: vec![0],
+        region_ids: vec![0],
         engine: MITO_ENGINE.to_string(),
     };
 

src/client/src/client.rs

@@ -16,7 +16,6 @@ use std::sync::Arc;
 
 use api::v1::greptime_database_client::GreptimeDatabaseClient;
 use api::v1::health_check_client::HealthCheckClient;
-use api::v1::prometheus_gateway_client::PrometheusGatewayClient;
 use api::v1::HealthCheckRequest;
 use arrow_flight::flight_service_client::FlightServiceClient;
 use common_grpc::channel_manager::ChannelManager;
@@ -157,11 +156,6 @@ impl Client {
         })
     }
 
-    pub fn make_prometheus_gateway_client(&self) -> Result<PrometheusGatewayClient<Channel>> {
-        let (_, channel) = self.find_channel()?;
-        Ok(PrometheusGatewayClient::new(channel))
-    }
-
     pub async fn health_check(&self) -> Result<()> {
         let (_, channel) = self.find_channel()?;
         let mut client = HealthCheckClient::new(channel);

src/client/src/database.rs

@@ -18,25 +18,22 @@ use api::v1::greptime_request::Request;
 use api::v1::query_request::Query;
 use api::v1::{
     greptime_response, AffectedRows, AlterExpr, AuthHeader, CreateTableExpr, DdlRequest,
-    DeleteRequest, DropTableExpr, FlushTableExpr, GreptimeRequest, InsertRequests, PromRangeQuery,
-    QueryRequest, RequestHeader,
+    DropTableExpr, FlushTableExpr, GreptimeRequest, InsertRequest, PromRangeQuery, QueryRequest,
+    RequestHeader,
 };
 use arrow_flight::{FlightData, Ticket};
 use common_error::prelude::*;
 use common_grpc::flight::{flight_messages_to_recordbatches, FlightDecoder, FlightMessage};
 use common_query::Output;
-use common_telemetry::{logging, timer};
+use common_telemetry::logging;
 use futures_util::{TryFutureExt, TryStreamExt};
 use prost::Message;
 use snafu::{ensure, ResultExt};
-use tokio::sync::mpsc::Sender;
-use tokio::sync::{mpsc, OnceCell};
-use tokio_stream::wrappers::ReceiverStream;
 
 use crate::error::{
     ConvertFlightDataSnafu, IllegalDatabaseResponseSnafu, IllegalFlightMessagesSnafu,
 };
-use crate::{error, metrics, Client, Result};
+use crate::{error, Client, Result};
 
 #[derive(Clone, Debug, Default)]
 pub struct Database {
@@ -50,7 +47,6 @@ pub struct Database {
     dbname: String,
 
     client: Client,
-    streaming_client: OnceCell<Sender<GreptimeRequest>>,
     ctx: FlightContext,
 }
 
@@ -60,10 +56,8 @@ impl Database {
         Self {
             catalog: catalog.into(),
             schema: schema.into(),
-            dbname: "".to_string(),
             client,
-            streaming_client: OnceCell::new(),
-            ctx: FlightContext::default(),
+            ..Default::default()
         }
     }
 
@@ -76,12 +70,9 @@ impl Database {
     /// environment
     pub fn new_with_dbname(dbname: impl Into<String>, client: Client) -> Self {
         Self {
-            catalog: "".to_string(),
-            schema: "".to_string(),
             dbname: dbname.into(),
             client,
-            streaming_client: OnceCell::new(),
-            ctx: FlightContext::default(),
+            ..Default::default()
         }
     }
 
@@ -115,35 +106,17 @@ impl Database {
         });
     }
 
-    pub async fn insert(&self, requests: InsertRequests) -> Result<u32> {
-        let _timer = timer!(metrics::METRIC_GRPC_INSERT);
-        self.handle(Request::Inserts(requests)).await
-    }
-
-    pub async fn insert_to_stream(&self, requests: InsertRequests) -> Result<()> {
-        let streaming_client = self
-            .streaming_client
-            .get_or_try_init(|| self.client_stream())
-            .await?;
-
-        let request = self.to_rpc_request(Request::Inserts(requests));
-
-        streaming_client.send(request).await.map_err(|e| {
-            error::ClientStreamingSnafu {
-                err_msg: e.to_string(),
-            }
-            .build()
-        })
-    }
-
-    pub async fn delete(&self, request: DeleteRequest) -> Result<u32> {
-        let _timer = timer!(metrics::METRIC_GRPC_DELETE);
-        self.handle(Request::Delete(request)).await
-    }
-
-    async fn handle(&self, request: Request) -> Result<u32> {
+    pub async fn insert(&self, request: InsertRequest) -> Result<u32> {
         let mut client = self.client.make_database_client()?.inner;
-        let request = self.to_rpc_request(request);
+        let request = GreptimeRequest {
+            header: Some(RequestHeader {
+                catalog: self.catalog.clone(),
+                schema: self.schema.clone(),
+                authorization: self.ctx.auth_header.clone(),
+                dbname: self.dbname.clone(),
+            }),
+            request: Some(Request::Insert(request)),
+        };
         let response = client
             .handle(request)
             .await?
@@ -156,29 +129,7 @@ impl Database {
         Ok(value)
     }
 
-    #[inline]
-    fn to_rpc_request(&self, request: Request) -> GreptimeRequest {
-        GreptimeRequest {
-            header: Some(RequestHeader {
-                catalog: self.catalog.clone(),
-                schema: self.schema.clone(),
-                authorization: self.ctx.auth_header.clone(),
-                dbname: self.dbname.clone(),
-            }),
-            request: Some(request),
-        }
-    }
-
-    async fn client_stream(&self) -> Result<Sender<GreptimeRequest>> {
-        let mut client = self.client.make_database_client()?.inner;
-        let (sender, receiver) = mpsc::channel::<GreptimeRequest>(65536);
-        let receiver = ReceiverStream::new(receiver);
-        client.handle_requests(receiver).await?;
-        Ok(sender)
-    }
-
     pub async fn sql(&self, sql: &str) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_SQL);
         self.do_get(Request::Query(QueryRequest {
             query: Some(Query::Sql(sql.to_string())),
         }))
@@ -186,7 +137,6 @@ impl Database {
     }
 
     pub async fn logical_plan(&self, logical_plan: Vec<u8>) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_LOGICAL_PLAN);
         self.do_get(Request::Query(QueryRequest {
             query: Some(Query::LogicalPlan(logical_plan)),
         }))
@@ -200,7 +150,6 @@ impl Database {
         end: &str,
         step: &str,
     ) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_PROMQL_RANGE_QUERY);
         self.do_get(Request::Query(QueryRequest {
             query: Some(Query::PromRangeQuery(PromRangeQuery {
                 query: promql.to_string(),
@@ -213,7 +162,6 @@ impl Database {
     }
 
     pub async fn create(&self, expr: CreateTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_CREATE_TABLE);
         self.do_get(Request::Ddl(DdlRequest {
             expr: Some(DdlExpr::CreateTable(expr)),
         }))
@@ -221,7 +169,6 @@ impl Database {
     }
 
     pub async fn alter(&self, expr: AlterExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_ALTER);
         self.do_get(Request::Ddl(DdlRequest {
             expr: Some(DdlExpr::Alter(expr)),
         }))
@@ -229,7 +176,6 @@ impl Database {
     }
 
     pub async fn drop_table(&self, expr: DropTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_DROP_TABLE);
         self.do_get(Request::Ddl(DdlRequest {
             expr: Some(DdlExpr::DropTable(expr)),
         }))
@@ -237,7 +183,6 @@ impl Database {
     }
 
     pub async fn flush_table(&self, expr: FlushTableExpr) -> Result<Output> {
-        let _timer = timer!(metrics::METRIC_GRPC_FLUSH_TABLE);
         self.do_get(Request::Ddl(DdlRequest {
             expr: Some(DdlExpr::FlushTable(expr)),
         }))
@@ -245,15 +190,22 @@ impl Database {
     }
 
     async fn do_get(&self, request: Request) -> Result<Output> {
-        // FIXME(paomian): should be added some labels for metrics
-        let _timer = timer!(metrics::METRIC_GRPC_DO_GET);
-        let request = self.to_rpc_request(request);
+        let request = GreptimeRequest {
+            header: Some(RequestHeader {
+                catalog: self.catalog.clone(),
+                schema: self.schema.clone(),
+                authorization: self.ctx.auth_header.clone(),
+                dbname: self.dbname.clone(),
+            }),
+            request: Some(request),
+        };
         let request = Ticket {
             ticket: request.encode_to_vec().into(),
         };
 
         let mut client = self.client.make_flight_client()?;
 
+        // TODO(LFC): Streaming get flight data.
         let flight_data: Vec<FlightData> = client
             .mut_inner()
             .do_get(request)

src/client/src/error.rs

@@ -34,13 +34,13 @@ pub enum Error {
 
     #[snafu(display("Failed to convert FlightData, source: {}", source))]
     ConvertFlightData {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_grpc::Error,
     },
 
     #[snafu(display("Column datatype error, source: {}", source))]
     ColumnDataType {
-        location: Location,
+        #[snafu(backtrace)]
         source: api::error::Error,
     },
 
@@ -57,7 +57,7 @@ pub enum Error {
     ))]
     CreateChannel {
         addr: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: common_grpc::error::Error,
     },
 
@@ -67,9 +67,6 @@ pub enum Error {
 
     #[snafu(display("Illegal Database response: {err_msg}"))]
     IllegalDatabaseResponse { err_msg: String },
-
-    #[snafu(display("Failed to send request with streaming: {}", err_msg))]
-    ClientStreaming { err_msg: String, location: Location },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -80,12 +77,11 @@ impl ErrorExt for Error {
             Error::IllegalFlightMessages { .. }
             | Error::ColumnDataType { .. }
             | Error::MissingField { .. }
-            | Error::IllegalDatabaseResponse { .. }
-            | Error::ClientStreaming { .. } => StatusCode::Internal,
+            | Error::IllegalDatabaseResponse { .. } => StatusCode::Internal,
 
             Error::Server { code, .. } => *code,
             Error::FlightGet { source, .. } => source.status_code(),
-            Error::CreateChannel { source, .. } | Error::ConvertFlightData { source, .. } => {
+            Error::CreateChannel { source, .. } | Error::ConvertFlightData { source } => {
                 source.status_code()
             }
             Error::IllegalGrpcClientState { .. } => StatusCode::Unexpected,

src/client/src/lib.rs

@@ -13,11 +13,9 @@
 // limitations under the License.
 
 mod client;
-pub mod client_manager;
 mod database;
 mod error;
 pub mod load_balance;
-mod metrics;
 
 pub use api;
 pub use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};

src/client/src/metrics.rs

@@ -1,25 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! client metrics
-pub const METRIC_GRPC_CREATE_TABLE: &str = "grpc.create_table";
-pub const METRIC_GRPC_PROMQL_RANGE_QUERY: &str = "grpc.promql.range_query";
-pub const METRIC_GRPC_INSERT: &str = "grpc.insert";
-pub const METRIC_GRPC_DELETE: &str = "grpc.delete";
-pub const METRIC_GRPC_SQL: &str = "grpc.sql";
-pub const METRIC_GRPC_LOGICAL_PLAN: &str = "grpc.logical_plan";
-pub const METRIC_GRPC_ALTER: &str = "grpc.alter";
-pub const METRIC_GRPC_DROP_TABLE: &str = "grpc.drop_table";
-pub const METRIC_GRPC_FLUSH_TABLE: &str = "grpc.flush_table";
-pub const METRIC_GRPC_DO_GET: &str = "grpc.do_get";

src/cmd/Cargo.toml

@@ -10,7 +10,7 @@ name = "greptime"
 path = "src/bin/greptime.rs"
 
 [features]
-tokio-console = ["common-telemetry/tokio-console"]
+mem-prof = ["tikv-jemallocator", "tikv-jemalloc-ctl"]
 
 [dependencies]
 anymap = "1.0.0-beta.2"
@@ -24,14 +24,12 @@ common-recordbatch = { path = "../common/recordbatch" }
 common-telemetry = { path = "../common/telemetry", features = [
     "deadlock_detection",
 ] }
-config = "0.13"
 datanode = { path = "../datanode" }
 either = "1.8"
 frontend = { path = "../frontend" }
 futures.workspace = true
 meta-client = { path = "../meta-client" }
 meta-srv = { path = "../meta-srv" }
-metrics.workspace = true
 nu-ansi-term = "0.46"
 partition = { path = "../partition" }
 query = { path = "../query" }
@@ -41,15 +39,16 @@ servers = { path = "../servers" }
 session = { path = "../session" }
 snafu.workspace = true
 substrait = { path = "../common/substrait" }
-tikv-jemallocator = "0.5"
+tikv-jemalloc-ctl = { version = "0.5", optional = true }
+tikv-jemallocator = { version = "0.5", optional = true }
 tokio.workspace = true
+toml = "0.5"
+
 
 [dev-dependencies]
 common-test-util = { path = "../common/test-util" }
 rexpect = "0.5"
-temp-env = "0.3"
 serde.workspace = true
-toml = "0.5"
 
 [build-dependencies]
 build-data = "0.1.3"

src/cmd/build.rs

@@ -18,10 +18,6 @@ fn main() {
         "cargo:rustc-env=GIT_COMMIT={}",
         build_data::get_git_commit().unwrap_or_else(|_| DEFAULT_VALUE.to_string())
     );
-    println!(
-        "cargo:rustc-env=GIT_COMMIT_SHORT={}",
-        build_data::get_git_commit_short().unwrap_or_else(|_| DEFAULT_VALUE.to_string())
-    );
     println!(
         "cargo:rustc-env=GIT_BRANCH={}",
         build_data::get_git_branch().unwrap_or_else(|_| DEFAULT_VALUE.to_string())

src/cmd/src/bin/greptime.rs

@@ -18,24 +18,18 @@ use std::fmt;
 
 use clap::Parser;
 use cmd::error::Result;
-use cmd::options::{Options, TopLevelOptions};
 use cmd::{cli, datanode, frontend, metasrv, standalone};
-use common_telemetry::logging::{error, info, TracingOptions};
-use metrics::gauge;
+use common_telemetry::logging::{error, info};
 
 #[derive(Parser)]
 #[clap(name = "greptimedb", version = print_version())]
 struct Command {
-    #[clap(long)]
-    log_dir: Option<String>,
-    #[clap(long)]
-    log_level: Option<String>,
+    #[clap(long, default_value = "/tmp/greptimedb/logs")]
+    log_dir: String,
+    #[clap(long, default_value = "info")]
+    log_level: String,
     #[clap(subcommand)]
     subcmd: SubCommand,
-
-    #[cfg(feature = "tokio-console")]
-    #[clap(long)]
-    tokio_console_addr: Option<String>,
 }
 
 pub enum Application {
@@ -47,13 +41,13 @@ pub enum Application {
 }
 
 impl Application {
-    async fn start(&mut self) -> Result<()> {
+    async fn run(&mut self) -> Result<()> {
         match self {
-            Application::Datanode(instance) => instance.start().await,
-            Application::Frontend(instance) => instance.start().await,
-            Application::Metasrv(instance) => instance.start().await,
-            Application::Standalone(instance) => instance.start().await,
-            Application::Cli(instance) => instance.start().await,
+            Application::Datanode(instance) => instance.run().await,
+            Application::Frontend(instance) => instance.run().await,
+            Application::Metasrv(instance) => instance.run().await,
+            Application::Standalone(instance) => instance.run().await,
+            Application::Cli(instance) => instance.run().await,
         }
     }
 
@@ -69,20 +63,8 @@ impl Application {
 }
 
 impl Command {
-    async fn build(self, opts: Options) -> Result<Application> {
-        self.subcmd.build(opts).await
-    }
-
-    fn load_options(&self) -> Result<Options> {
-        let top_level_opts = self.top_level_options();
-        self.subcmd.load_options(top_level_opts)
-    }
-
-    fn top_level_options(&self) -> TopLevelOptions {
-        TopLevelOptions {
-            log_dir: self.log_dir.clone(),
-            log_level: self.log_level.clone(),
-        }
+    async fn build(self) -> Result<Application> {
+        self.subcmd.build().await
     }
 }
 
@@ -101,40 +83,28 @@ enum SubCommand {
 }
 
 impl SubCommand {
-    async fn build(self, opts: Options) -> Result<Application> {
-        match (self, opts) {
-            (SubCommand::Datanode(cmd), Options::Datanode(dn_opts)) => {
-                let app = cmd.build(*dn_opts).await?;
+    async fn build(self) -> Result<Application> {
+        match self {
+            SubCommand::Datanode(cmd) => {
+                let app = cmd.build().await?;
                 Ok(Application::Datanode(app))
             }
-            (SubCommand::Frontend(cmd), Options::Frontend(fe_opts)) => {
-                let app = cmd.build(*fe_opts).await?;
+            SubCommand::Frontend(cmd) => {
+                let app = cmd.build().await?;
                 Ok(Application::Frontend(app))
             }
-            (SubCommand::Metasrv(cmd), Options::Metasrv(meta_opts)) => {
-                let app = cmd.build(*meta_opts).await?;
+            SubCommand::Metasrv(cmd) => {
+                let app = cmd.build().await?;
                 Ok(Application::Metasrv(app))
             }
-            (SubCommand::Standalone(cmd), Options::Standalone(opts)) => {
-                let app = cmd.build(opts.fe_opts, opts.dn_opts).await?;
+            SubCommand::Standalone(cmd) => {
+                let app = cmd.build().await?;
                 Ok(Application::Standalone(app))
             }
-            (SubCommand::Cli(cmd), Options::Cli(_)) => {
+            SubCommand::Cli(cmd) => {
                 let app = cmd.build().await?;
                 Ok(Application::Cli(app))
             }
-
-            _ => unreachable!(),
-        }
-    }
-
-    fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        match self {
-            SubCommand::Datanode(cmd) => cmd.load_options(top_level_opts),
-            SubCommand::Frontend(cmd) => cmd.load_options(top_level_opts),
-            SubCommand::Metasrv(cmd) => cmd.load_options(top_level_opts),
-            SubCommand::Standalone(cmd) => cmd.load_options(top_level_opts),
-            SubCommand::Cli(cmd) => cmd.load_options(top_level_opts),
         }
     }
 }
@@ -164,63 +134,27 @@ fn print_version() -> &'static str {
     )
 }
 
-fn short_version() -> &'static str {
-    env!("CARGO_PKG_VERSION")
-}
-
-// {app_name}-{branch_name}-{commit_short}
-// The branch name (tag) of a release build should already contain the short
-// version so the full version doesn't concat the short version explicitly.
-fn full_version() -> &'static str {
-    concat!(
-        "greptimedb-",
-        env!("GIT_BRANCH"),
-        "-",
-        env!("GIT_COMMIT_SHORT")
-    )
-}
-
-fn log_env_flags() {
-    info!("command line arguments");
-    for argument in std::env::args() {
-        info!("argument: {}", argument);
-    }
-}
-
+#[cfg(feature = "mem-prof")]
 #[global_allocator]
 static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
 #[tokio::main]
 async fn main() -> Result<()> {
     let cmd = Command::parse();
+    // TODO(dennis):
+    // 1. adds ip/port to app
     let app_name = &cmd.subcmd.to_string();
-
-    let opts = cmd.load_options()?;
-    let logging_opts = opts.logging_options();
-    let tracing_opts = TracingOptions {
-        #[cfg(feature = "tokio-console")]
-        tokio_console_addr: cmd.tokio_console_addr.clone(),
-    };
+    let log_dir = &cmd.log_dir;
+    let log_level = &cmd.log_level;
 
     common_telemetry::set_panic_hook();
     common_telemetry::init_default_metrics_recorder();
-    let _guard = common_telemetry::init_global_logging(app_name, logging_opts, tracing_opts);
+    let _guard = common_telemetry::init_global_logging(app_name, log_dir, log_level, false);
 
-    // Report app version as gauge.
-    gauge!("app_version", 1.0, "short_version" => short_version(), "version" => full_version());
-
-    // Log version and argument flags.
-    info!(
-        "short_version: {}, full_version: {}",
-        short_version(),
-        full_version()
-    );
-    log_env_flags();
-
-    let mut app = cmd.build(opts).await?;
+    let mut app = cmd.build().await?;
 
     tokio::select! {
-        result = app.start() => {
+        result = app.run() => {
             if let Err(err) = result {
                 error!(err; "Fatal error occurs!");
             }

src/cmd/src/cli.rs

@@ -17,18 +17,16 @@ mod helper;
 mod repl;
 
 use clap::Parser;
-use common_telemetry::logging::LoggingOptions;
 pub use repl::Repl;
 
 use crate::error::Result;
-use crate::options::{Options, TopLevelOptions};
 
 pub struct Instance {
     repl: Repl,
 }
 
 impl Instance {
-    pub async fn start(&mut self) -> Result<()> {
+    pub async fn run(&mut self) -> Result<()> {
         self.repl.run().await
     }
 
@@ -47,17 +45,6 @@ impl Command {
     pub async fn build(self) -> Result<Instance> {
         self.cmd.build().await
     }
-
-    pub fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        let mut logging_opts = LoggingOptions::default();
-        if let Some(dir) = top_level_opts.log_dir {
-            logging_opts.dir = dir;
-        }
-        if top_level_opts.log_level.is_some() {
-            logging_opts.level = top_level_opts.log_level;
-        }
-        Ok(Options::Cli(Box::new(logging_opts)))
-    }
 }
 
 #[derive(Parser)]
@@ -89,46 +76,3 @@ impl AttachCommand {
         Ok(Instance { repl })
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_load_options() {
-        let cmd = Command {
-            cmd: SubCommand::Attach(AttachCommand {
-                grpc_addr: String::from(""),
-                meta_addr: None,
-                disable_helper: false,
-            }),
-        };
-
-        let opts = cmd.load_options(TopLevelOptions::default()).unwrap();
-        let logging_opts = opts.logging_options();
-        assert_eq!("/tmp/greptimedb/logs", logging_opts.dir);
-        assert!(logging_opts.level.is_none());
-        assert!(!logging_opts.enable_jaeger_tracing);
-    }
-
-    #[test]
-    fn test_top_level_options() {
-        let cmd = Command {
-            cmd: SubCommand::Attach(AttachCommand {
-                grpc_addr: String::from(""),
-                meta_addr: None,
-                disable_helper: false,
-            }),
-        };
-
-        let opts = cmd
-            .load_options(TopLevelOptions {
-                log_dir: Some("/tmp/greptimedb/test/logs".to_string()),
-                log_level: Some("debug".to_string()),
-            })
-            .unwrap();
-        let logging_opts = opts.logging_options();
-        assert_eq!("/tmp/greptimedb/test/logs", logging_opts.dir);
-        assert_eq!("debug", logging_opts.level.as_ref().unwrap());
-    }
-}

src/cmd/src/cli/repl.rs

@@ -16,8 +16,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Instant;
 
-use catalog::remote::CachedMetaKvBackend;
-use client::client_manager::DatanodeClients;
+use catalog::remote::MetaKvBackend;
 use client::{Client, Database, DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
 use common_error::prelude::ErrorExt;
 use common_query::Output;
@@ -25,6 +24,7 @@ use common_recordbatch::RecordBatches;
 use common_telemetry::logging;
 use either::Either;
 use frontend::catalog::FrontendCatalogManager;
+use frontend::datanode::DatanodeClients;
 use meta_client::client::MetaClientBuilder;
 use partition::manager::PartitionRuleManager;
 use partition::route::TableRoutes;
@@ -253,7 +253,9 @@ async fn create_query_engine(meta_addr: &str) -> Result<DatafusionQueryEngine> {
         .context(StartMetaClientSnafu)?;
     let meta_client = Arc::new(meta_client);
 
-    let cached_meta_backend = Arc::new(CachedMetaKvBackend::new(meta_client.clone()));
+    let backend = Arc::new(MetaKvBackend {
+        client: meta_client.clone(),
+    });
 
     let table_routes = Arc::new(TableRoutes::new(meta_client));
     let partition_manager = Arc::new(PartitionRuleManager::new(table_routes));
@@ -261,18 +263,11 @@ async fn create_query_engine(meta_addr: &str) -> Result<DatafusionQueryEngine> {
     let datanode_clients = Arc::new(DatanodeClients::default());
 
     let catalog_list = Arc::new(FrontendCatalogManager::new(
-        cached_meta_backend.clone(),
-        cached_meta_backend,
+        backend,
         partition_manager,
         datanode_clients,
     ));
-    let state = Arc::new(QueryEngineState::new(
-        catalog_list,
-        false,
-        None,
-        None,
-        Default::default(),
-    ));
+    let state = Arc::new(QueryEngineState::new(catalog_list, Default::default()));
 
     Ok(DatafusionQueryEngine::new(state))
 }

src/cmd/src/datanode.rs

@@ -16,20 +16,22 @@ use std::time::Duration;
 
 use clap::Parser;
 use common_telemetry::logging;
-use datanode::datanode::{Datanode, DatanodeOptions, FileConfig, ObjectStoreConfig};
+use datanode::datanode::{
+    Datanode, DatanodeOptions, FileConfig, ObjectStoreConfig, ProcedureConfig,
+};
 use meta_client::MetaClientOptions;
 use servers::Mode;
 use snafu::ResultExt;
 
-use crate::error::{MissingConfigSnafu, Result, ShutdownDatanodeSnafu, StartDatanodeSnafu};
-use crate::options::{Options, TopLevelOptions};
+use crate::error::{Error, MissingConfigSnafu, Result, ShutdownDatanodeSnafu, StartDatanodeSnafu};
+use crate::toml_loader;
 
 pub struct Instance {
     datanode: Datanode,
 }
 
 impl Instance {
-    pub async fn start(&mut self) -> Result<()> {
+    pub async fn run(&mut self) -> Result<()> {
         self.datanode.start().await.context(StartDatanodeSnafu)
     }
 
@@ -48,12 +50,8 @@ pub struct Command {
 }
 
 impl Command {
-    pub async fn build(self, opts: DatanodeOptions) -> Result<Instance> {
-        self.subcmd.build(opts).await
-    }
-
-    pub fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        self.subcmd.load_options(top_level_opts)
+    pub async fn build(self) -> Result<Instance> {
+        self.subcmd.build().await
     }
 }
 
@@ -63,15 +61,9 @@ enum SubCommand {
 }
 
 impl SubCommand {
-    async fn build(self, opts: DatanodeOptions) -> Result<Instance> {
+    async fn build(self) -> Result<Instance> {
         match self {
-            SubCommand::Start(cmd) => cmd.build(opts).await,
-        }
-    }
-
-    fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        match self {
-            SubCommand::Start(cmd) => cmd.load_options(top_level_opts),
+            SubCommand::Start(cmd) => cmd.build().await,
         }
     }
 }
@@ -84,54 +76,71 @@ struct StartCommand {
     rpc_addr: Option<String>,
     #[clap(long)]
     rpc_hostname: Option<String>,
-    #[clap(long, multiple = true, value_delimiter = ',')]
-    metasrv_addr: Option<Vec<String>>,
+    #[clap(long)]
+    mysql_addr: Option<String>,
+    #[clap(long)]
+    metasrv_addr: Option<String>,
     #[clap(short, long)]
     config_file: Option<String>,
     #[clap(long)]
-    data_home: Option<String>,
+    data_dir: Option<String>,
     #[clap(long)]
     wal_dir: Option<String>,
     #[clap(long)]
+    procedure_dir: Option<String>,
+    #[clap(long)]
     http_addr: Option<String>,
     #[clap(long)]
     http_timeout: Option<u64>,
-    #[clap(long, default_value = "GREPTIMEDB_DATANODE")]
-    env_prefix: String,
 }
 
 impl StartCommand {
-    fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        let mut opts: DatanodeOptions = Options::load_layered_options(
-            self.config_file.as_deref(),
-            self.env_prefix.as_ref(),
-            DatanodeOptions::env_list_keys(),
-        )?;
+    async fn build(self) -> Result<Instance> {
+        logging::info!("Datanode start command: {:#?}", self);
 
-        if let Some(dir) = top_level_opts.log_dir {
-            opts.logging.dir = dir;
+        let opts: DatanodeOptions = self.try_into()?;
+
+        logging::info!("Datanode options: {:#?}", opts);
+
+        let datanode = Datanode::new(opts).await.context(StartDatanodeSnafu)?;
+
+        Ok(Instance { datanode })
+    }
+}
+
+impl TryFrom<StartCommand> for DatanodeOptions {
+    type Error = Error;
+    fn try_from(cmd: StartCommand) -> Result<Self> {
+        let mut opts: DatanodeOptions = if let Some(path) = cmd.config_file {
+            toml_loader::from_file!(&path)?
+        } else {
+            DatanodeOptions::default()
+        };
+
+        if let Some(addr) = cmd.rpc_addr {
+            opts.rpc_addr = addr;
         }
 
-        if top_level_opts.log_level.is_some() {
-            opts.logging.level = top_level_opts.log_level;
+        if cmd.rpc_hostname.is_some() {
+            opts.rpc_hostname = cmd.rpc_hostname;
         }
 
-        if let Some(addr) = &self.rpc_addr {
-            opts.rpc_addr = addr.clone();
+        if let Some(addr) = cmd.mysql_addr {
+            opts.mysql_addr = addr;
         }
 
-        if self.rpc_hostname.is_some() {
-            opts.rpc_hostname = self.rpc_hostname.clone();
-        }
-
-        if let Some(node_id) = self.node_id {
+        if let Some(node_id) = cmd.node_id {
             opts.node_id = Some(node_id);
         }
 
-        if let Some(metasrv_addrs) = &self.metasrv_addr {
+        if let Some(meta_addr) = cmd.metasrv_addr {
             opts.meta_client_options
                 .get_or_insert_with(MetaClientOptions::default)
-                .metasrv_addrs = metasrv_addrs.clone();
+                .metasrv_addrs = meta_addr
+                .split(',')
+                .map(&str::trim)
+                .map(&str::to_string)
+                .collect::<_>();
             opts.mode = Mode::Distributed;
         }
 
@@ -142,42 +151,33 @@ impl StartCommand {
             .fail();
         }
 
-        if let Some(data_home) = &self.data_home {
-            opts.storage.store = ObjectStoreConfig::File(FileConfig {
-                data_home: data_home.clone(),
-            });
+        if let Some(data_dir) = cmd.data_dir {
+            opts.storage.store = ObjectStoreConfig::File(FileConfig { data_dir });
         }
 
-        if let Some(wal_dir) = &self.wal_dir {
-            opts.wal.dir = Some(wal_dir.clone());
+        if let Some(wal_dir) = cmd.wal_dir {
+            opts.wal.dir = wal_dir;
         }
-
-        if let Some(http_addr) = &self.http_addr {
-            opts.http_opts.addr = http_addr.clone();
+        if let Some(procedure_dir) = cmd.procedure_dir {
+            opts.procedure = Some(ProcedureConfig::from_file_path(procedure_dir));
         }
-
-        if let Some(http_timeout) = self.http_timeout {
+        if let Some(http_addr) = cmd.http_addr {
+            opts.http_opts.addr = http_addr
+        }
+        if let Some(http_timeout) = cmd.http_timeout {
             opts.http_opts.timeout = Duration::from_secs(http_timeout)
         }
 
         // Disable dashboard in datanode.
         opts.http_opts.disable_dashboard = true;
 
-        Ok(Options::Datanode(Box::new(opts)))
-    }
-
-    async fn build(self, opts: DatanodeOptions) -> Result<Instance> {
-        logging::info!("Datanode start command: {:#?}", self);
-        logging::info!("Datanode options: {:#?}", opts);
-
-        let datanode = Datanode::new(opts).await.context(StartDatanodeSnafu)?;
-
-        Ok(Instance { datanode })
+        Ok(opts)
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::assert_matches::assert_matches;
     use std::io::Write;
     use std::time::Duration;
 
@@ -187,7 +187,6 @@ mod tests {
     use servers::Mode;
 
     use super::*;
-    use crate::options::ENV_VAR_SEP;
 
     #[test]
     fn test_read_from_config_file() {
@@ -199,6 +198,8 @@ mod tests {
             rpc_addr = "127.0.0.1:3001"
             rpc_hostname = "127.0.0.1"
             rpc_runtime_size = 8
+            mysql_addr = "127.0.0.1:4406"
+            mysql_runtime_size = 2
 
             [meta_client_options]
             metasrv_addrs = ["127.0.0.1:3002"]
@@ -207,7 +208,7 @@ mod tests {
             tcp_nodelay = true
 
             [wal]
-            dir = "/other/wal"
+            dir = "/tmp/greptimedb/wal"
             file_size = "1GB"
             purge_threshold = "50GB"
             purge_interval = "10m"
@@ -216,7 +217,7 @@ mod tests {
 
             [storage]
             type = "File"
-            data_home = "/tmp/greptimedb/"
+            data_dir = "/tmp/greptimedb/data/"
 
             [storage.compaction]
             max_inflight_tasks = 3
@@ -227,11 +228,6 @@ mod tests {
             checkpoint_margin = 9
             gc_duration = '7s'
             checkpoint_on_startup = true
-            compress = true
-
-            [logging]
-            level = "debug"
-            dir = "/tmp/greptimedb/test/logs"
         "#;
         write!(file, "{}", toml_str).unwrap();
 
@@ -239,14 +235,12 @@ mod tests {
             config_file: Some(file.path().to_str().unwrap().to_string()),
             ..Default::default()
         };
-
-        let Options::Datanode(options) =
-            cmd.load_options(TopLevelOptions::default()).unwrap() else { unreachable!() };
-
+        let options: DatanodeOptions = cmd.try_into().unwrap();
         assert_eq!("127.0.0.1:3001".to_string(), options.rpc_addr);
+        assert_eq!("127.0.0.1:4406".to_string(), options.mysql_addr);
+        assert_eq!(2, options.mysql_runtime_size);
         assert_eq!(Some(42), options.node_id);
 
-        assert_eq!("/other/wal", options.wal.dir.unwrap());
         assert_eq!(Duration::from_secs(600), options.wal.purge_interval);
         assert_eq!(1024 * 1024 * 1024, options.wal.file_size.0);
         assert_eq!(1024 * 1024 * 1024 * 50, options.wal.purge_threshold.0);
@@ -265,12 +259,11 @@ mod tests {
         assert!(tcp_nodelay);
 
         match &options.storage.store {
-            ObjectStoreConfig::File(FileConfig { data_home, .. }) => {
-                assert_eq!("/tmp/greptimedb/", data_home)
+            ObjectStoreConfig::File(FileConfig { data_dir, .. }) => {
+                assert_eq!("/tmp/greptimedb/data/", data_dir)
             }
             ObjectStoreConfig::S3 { .. } => unreachable!(),
             ObjectStoreConfig::Oss { .. } => unreachable!(),
-            ObjectStoreConfig::Azblob { .. } => unreachable!(),
         };
 
         assert_eq!(
@@ -287,184 +280,40 @@ mod tests {
                 checkpoint_margin: Some(9),
                 gc_duration: Some(Duration::from_secs(7)),
                 checkpoint_on_startup: true,
-                compress: true
             },
             options.storage.manifest,
         );
-
-        assert_eq!("debug", options.logging.level.unwrap());
-        assert_eq!("/tmp/greptimedb/test/logs".to_string(), options.logging.dir);
     }
 
     #[test]
     fn test_try_from_cmd() {
-        if let Options::Datanode(opt) = StartCommand::default()
-            .load_options(TopLevelOptions::default())
-            .unwrap()
-        {
-            assert_eq!(Mode::Standalone, opt.mode)
-        }
+        assert_eq!(
+            Mode::Standalone,
+            DatanodeOptions::try_from(StartCommand::default())
+                .unwrap()
+                .mode
+        );
 
-        if let Options::Datanode(opt) = (StartCommand {
+        let mode = DatanodeOptions::try_from(StartCommand {
             node_id: Some(42),
-            metasrv_addr: Some(vec!["127.0.0.1:3002".to_string()]),
+            metasrv_addr: Some("127.0.0.1:3002".to_string()),
             ..Default::default()
         })
-        .load_options(TopLevelOptions::default())
         .unwrap()
-        {
-            assert_eq!(Mode::Distributed, opt.mode)
-        }
+        .mode;
+        assert_matches!(mode, Mode::Distributed);
 
-        assert!((StartCommand {
-            metasrv_addr: Some(vec!["127.0.0.1:3002".to_string()]),
+        assert!(DatanodeOptions::try_from(StartCommand {
+            metasrv_addr: Some("127.0.0.1:3002".to_string()),
             ..Default::default()
         })
-        .load_options(TopLevelOptions::default())
         .is_err());
 
         // Providing node_id but leave metasrv_addr absent is ok since metasrv_addr has default value
-        (StartCommand {
+        DatanodeOptions::try_from(StartCommand {
             node_id: Some(42),
             ..Default::default()
         })
-        .load_options(TopLevelOptions::default())
         .unwrap();
     }
-
-    #[test]
-    fn test_top_level_options() {
-        let cmd = StartCommand::default();
-
-        let options = cmd
-            .load_options(TopLevelOptions {
-                log_dir: Some("/tmp/greptimedb/test/logs".to_string()),
-                log_level: Some("debug".to_string()),
-            })
-            .unwrap();
-
-        let logging_opt = options.logging_options();
-        assert_eq!("/tmp/greptimedb/test/logs", logging_opt.dir);
-        assert_eq!("debug", logging_opt.level.as_ref().unwrap());
-    }
-
-    #[test]
-    fn test_config_precedence_order() {
-        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:3001"
-            rpc_hostname = "127.0.0.1"
-            rpc_runtime_size = 8
-
-            [meta_client_options]
-            timeout_millis = 3000
-            connect_timeout_millis = 5000
-            tcp_nodelay = true
-
-            [wal]
-            file_size = "1GB"
-            purge_threshold = "50GB"
-            purge_interval = "10m"
-            read_batch_size = 128
-            sync_write = false
-
-            [storage]
-            type = "File"
-            data_home = "/tmp/greptimedb/"
-
-            [storage.compaction]
-            max_inflight_tasks = 3
-            max_files_in_level0 = 7
-            max_purge_tasks = 32
-
-            [storage.manifest]
-            checkpoint_on_startup = true
-
-            [logging]
-            level = "debug"
-            dir = "/tmp/greptimedb/test/logs"
-        "#;
-        write!(file, "{}", toml_str).unwrap();
-
-        let env_prefix = "DATANODE_UT";
-        temp_env::with_vars(
-            vec![
-                (
-                    // storage.manifest.gc_duration = 9s
-                    vec![
-                        env_prefix.to_string(),
-                        "storage".to_uppercase(),
-                        "manifest".to_uppercase(),
-                        "gc_duration".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("9s"),
-                ),
-                (
-                    // storage.compaction.max_purge_tasks = 99
-                    vec![
-                        env_prefix.to_string(),
-                        "storage".to_uppercase(),
-                        "compaction".to_uppercase(),
-                        "max_purge_tasks".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("99"),
-                ),
-                (
-                    // meta_client_options.metasrv_addrs = 127.0.0.1:3001,127.0.0.1:3002,127.0.0.1:3003
-                    vec![
-                        env_prefix.to_string(),
-                        "meta_client_options".to_uppercase(),
-                        "metasrv_addrs".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("127.0.0.1:3001,127.0.0.1:3002,127.0.0.1:3003"),
-                ),
-            ],
-            || {
-                let command = StartCommand {
-                    config_file: Some(file.path().to_str().unwrap().to_string()),
-                    wal_dir: Some("/other/wal/dir".to_string()),
-                    env_prefix: env_prefix.to_string(),
-                    ..Default::default()
-                };
-
-                let Options::Datanode(opts) =
-                    command.load_options(TopLevelOptions::default()).unwrap() else {unreachable!()};
-
-                // Should be read from env, env > default values.
-                assert_eq!(
-                    opts.storage.manifest.gc_duration,
-                    Some(Duration::from_secs(9))
-                );
-                assert_eq!(
-                    opts.meta_client_options.unwrap().metasrv_addrs,
-                    vec![
-                        "127.0.0.1:3001".to_string(),
-                        "127.0.0.1:3002".to_string(),
-                        "127.0.0.1:3003".to_string()
-                    ]
-                );
-
-                // Should be read from config file, config file > env > default values.
-                assert_eq!(opts.storage.compaction.max_purge_tasks, 32);
-
-                // Should be read from cli, cli > config file > env > default values.
-                assert_eq!(opts.wal.dir.unwrap(), "/other/wal/dir");
-
-                // Should be default value.
-                assert_eq!(
-                    opts.storage.manifest.checkpoint_margin,
-                    DatanodeOptions::default()
-                        .storage
-                        .manifest
-                        .checkpoint_margin
-                );
-            },
-        );
-    }
 }

src/cmd/src/error.rs

@@ -15,7 +15,6 @@
 use std::any::Any;
 
 use common_error::prelude::*;
-use config::ConfigError;
 use rustyline::error::ReadlineError;
 use snafu::Location;
 
@@ -24,46 +23,59 @@ use snafu::Location;
 pub enum Error {
     #[snafu(display("Failed to start datanode, source: {}", source))]
     StartDatanode {
-        location: Location,
+        #[snafu(backtrace)]
         source: datanode::error::Error,
     },
 
     #[snafu(display("Failed to shutdown datanode, source: {}", source))]
     ShutdownDatanode {
-        location: Location,
+        #[snafu(backtrace)]
         source: datanode::error::Error,
     },
 
     #[snafu(display("Failed to start frontend, source: {}", source))]
     StartFrontend {
-        location: Location,
+        #[snafu(backtrace)]
         source: frontend::error::Error,
     },
 
     #[snafu(display("Failed to shutdown frontend, source: {}", source))]
     ShutdownFrontend {
-        location: Location,
+        #[snafu(backtrace)]
         source: frontend::error::Error,
     },
 
     #[snafu(display("Failed to build meta server, source: {}", source))]
     BuildMetaServer {
-        location: Location,
+        #[snafu(backtrace)]
         source: meta_srv::error::Error,
     },
 
     #[snafu(display("Failed to start meta server, source: {}", source))]
     StartMetaServer {
-        location: Location,
+        #[snafu(backtrace)]
         source: meta_srv::error::Error,
     },
 
     #[snafu(display("Failed to shutdown meta server, source: {}", source))]
     ShutdownMetaServer {
-        location: Location,
+        #[snafu(backtrace)]
         source: meta_srv::error::Error,
     },
 
+    #[snafu(display("Failed to read config file: {}, source: {}", path, source))]
+    ReadConfig {
+        path: String,
+        source: std::io::Error,
+        location: Location,
+    },
+
+    #[snafu(display("Failed to parse config, source: {}", source))]
+    ParseConfig {
+        source: toml::de::Error,
+        location: Location,
+    },
+
     #[snafu(display("Missing config, msg: {}", msg))]
     MissingConfig { msg: String, location: Location },
 
@@ -72,14 +84,14 @@ pub enum Error {
 
     #[snafu(display("Illegal auth config: {}", source))]
     IllegalAuthConfig {
-        location: Location,
+        #[snafu(backtrace)]
         source: servers::auth::Error,
     },
 
     #[snafu(display("Unsupported selector type, {} source: {}", selector_type, source))]
     UnsupportedSelectorType {
         selector_type: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: meta_srv::error::Error,
     },
 
@@ -101,58 +113,46 @@ pub enum Error {
     #[snafu(display("Failed to request database, sql: {sql}, source: {source}"))]
     RequestDatabase {
         sql: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: client::Error,
     },
 
     #[snafu(display("Failed to collect RecordBatches, source: {source}"))]
     CollectRecordBatches {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_recordbatch::error::Error,
     },
 
     #[snafu(display("Failed to pretty print Recordbatches, source: {source}"))]
     PrettyPrintRecordBatches {
-        location: Location,
+        #[snafu(backtrace)]
         source: common_recordbatch::error::Error,
     },
 
     #[snafu(display("Failed to start Meta client, source: {}", source))]
     StartMetaClient {
-        location: Location,
+        #[snafu(backtrace)]
         source: meta_client::error::Error,
     },
 
     #[snafu(display("Failed to parse SQL: {}, source: {}", sql, source))]
     ParseSql {
         sql: String,
-        location: Location,
+        #[snafu(backtrace)]
         source: query::error::Error,
     },
 
     #[snafu(display("Failed to plan statement, source: {}", source))]
     PlanStatement {
-        location: Location,
+        #[snafu(backtrace)]
         source: query::error::Error,
     },
 
     #[snafu(display("Failed to encode logical plan in substrait, source: {}", source))]
     SubstraitEncodeLogicalPlan {
-        location: Location,
+        #[snafu(backtrace)]
         source: substrait::error::Error,
     },
-
-    #[snafu(display("Failed to load layered config, source: {}", source))]
-    LoadLayeredConfig {
-        source: ConfigError,
-        location: Location,
-    },
-
-    #[snafu(display("Failed to start catalog manager, source: {}", source))]
-    StartCatalogManager {
-        location: Location,
-        source: catalog::error::Error,
-    },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -160,29 +160,31 @@ pub type Result<T> = std::result::Result<T, Error>;
 impl ErrorExt for Error {
     fn status_code(&self) -> StatusCode {
         match self {
-            Error::StartDatanode { source, .. } => source.status_code(),
-            Error::StartFrontend { source, .. } => source.status_code(),
-            Error::ShutdownDatanode { source, .. } => source.status_code(),
-            Error::ShutdownFrontend { source, .. } => source.status_code(),
-            Error::StartMetaServer { source, .. } => source.status_code(),
-            Error::ShutdownMetaServer { source, .. } => source.status_code(),
-            Error::BuildMetaServer { source, .. } => source.status_code(),
+            Error::StartDatanode { source } => source.status_code(),
+            Error::StartFrontend { source } => source.status_code(),
+            Error::ShutdownDatanode { source } => source.status_code(),
+            Error::ShutdownFrontend { source } => source.status_code(),
+            Error::StartMetaServer { source } => source.status_code(),
+            Error::ShutdownMetaServer { source } => source.status_code(),
+            Error::BuildMetaServer { source } => source.status_code(),
             Error::UnsupportedSelectorType { source, .. } => source.status_code(),
-            Error::MissingConfig { .. }
-            | Error::LoadLayeredConfig { .. }
-            | Error::IllegalConfig { .. }
-            | Error::InvalidReplCommand { .. }
-            | Error::IllegalAuthConfig { .. } => StatusCode::InvalidArguments,
+            Error::ReadConfig { .. } | Error::ParseConfig { .. } | Error::MissingConfig { .. } => {
+                StatusCode::InvalidArguments
+            }
+            Error::IllegalConfig { .. } | Error::InvalidReplCommand { .. } => {
+                StatusCode::InvalidArguments
+            }
+            Error::IllegalAuthConfig { .. } => StatusCode::InvalidArguments,
             Error::ReplCreation { .. } | Error::Readline { .. } => StatusCode::Internal,
             Error::RequestDatabase { source, .. } => source.status_code(),
-            Error::CollectRecordBatches { source, .. }
-            | Error::PrettyPrintRecordBatches { source, .. } => source.status_code(),
-            Error::StartMetaClient { source, .. } => source.status_code(),
-            Error::ParseSql { source, .. } | Error::PlanStatement { source, .. } => {
+            Error::CollectRecordBatches { source } | Error::PrettyPrintRecordBatches { source } => {
                 source.status_code()
             }
-            Error::SubstraitEncodeLogicalPlan { source, .. } => source.status_code(),
-            Error::StartCatalogManager { source, .. } => source.status_code(),
+            Error::StartMetaClient { source } => source.status_code(),
+            Error::ParseSql { source, .. } | Error::PlanStatement { source } => {
+                source.status_code()
+            }
+            Error::SubstraitEncodeLogicalPlan { source } => source.status_code(),
         }
     }
 

src/cmd/src/frontend.rs

@@ -16,31 +16,30 @@ use std::sync::Arc;
 
 use clap::Parser;
 use common_base::Plugins;
-use common_telemetry::logging;
 use frontend::frontend::FrontendOptions;
+use frontend::grpc::GrpcOptions;
+use frontend::influxdb::InfluxdbOptions;
 use frontend::instance::{FrontendInstance, Instance as FeInstance};
-use frontend::service_config::{InfluxdbOptions, PromOptions};
+use frontend::mysql::MysqlOptions;
+use frontend::opentsdb::OpentsdbOptions;
+use frontend::postgres::PostgresOptions;
+use frontend::prom::PromOptions;
 use meta_client::MetaClientOptions;
 use servers::auth::UserProviderRef;
+use servers::http::HttpOptions;
 use servers::tls::{TlsMode, TlsOption};
 use servers::{auth, Mode};
 use snafu::ResultExt;
 
-use crate::error::{self, IllegalAuthConfigSnafu, Result, StartCatalogManagerSnafu};
-use crate::options::{Options, TopLevelOptions};
+use crate::error::{self, IllegalAuthConfigSnafu, Result};
+use crate::toml_loader;
 
 pub struct Instance {
     frontend: FeInstance,
 }
 
 impl Instance {
-    pub async fn start(&mut self) -> Result<()> {
-        self.frontend
-            .catalog_manager()
-            .start()
-            .await
-            .context(StartCatalogManagerSnafu)?;
-
+    pub async fn run(&mut self) -> Result<()> {
         self.frontend
             .start()
             .await
@@ -62,12 +61,8 @@ pub struct Command {
 }
 
 impl Command {
-    pub async fn build(self, opts: FrontendOptions) -> Result<Instance> {
-        self.subcmd.build(opts).await
-    }
-
-    pub fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        self.subcmd.load_options(top_level_opts)
+    pub async fn build(self) -> Result<Instance> {
+        self.subcmd.build().await
     }
 }
 
@@ -77,20 +72,14 @@ enum SubCommand {
 }
 
 impl SubCommand {
-    async fn build(self, opts: FrontendOptions) -> Result<Instance> {
+    async fn build(self) -> Result<Instance> {
         match self {
-            SubCommand::Start(cmd) => cmd.build(opts).await,
-        }
-    }
-
-    fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        match self {
-            SubCommand::Start(cmd) => cmd.load_options(top_level_opts),
+            SubCommand::Start(cmd) => cmd.build().await,
         }
     }
 }
 
-#[derive(Debug, Default, Parser)]
+#[derive(Debug, Parser)]
 pub struct StartCommand {
     #[clap(long)]
     http_addr: Option<String>,
@@ -108,8 +97,8 @@ pub struct StartCommand {
     config_file: Option<String>,
     #[clap(short, long)]
     influxdb_enable: Option<bool>,
-    #[clap(long, multiple = true, value_delimiter = ',')]
-    metasrv_addr: Option<Vec<String>>,
+    #[clap(long)]
+    metasrv_addr: Option<String>,
     #[clap(long)]
     tls_mode: Option<TlsMode>,
     #[clap(long)]
@@ -119,101 +108,20 @@ pub struct StartCommand {
     #[clap(long)]
     user_provider: Option<String>,
     #[clap(long)]
-    disable_dashboard: Option<bool>,
-    #[clap(long, default_value = "GREPTIMEDB_FRONTEND")]
-    env_prefix: String,
+    disable_dashboard: bool,
 }
 
 impl StartCommand {
-    fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        let mut opts: FrontendOptions = Options::load_layered_options(
-            self.config_file.as_deref(),
-            self.env_prefix.as_ref(),
-            FrontendOptions::env_list_keys(),
-        )?;
-
-        if let Some(dir) = top_level_opts.log_dir {
-            opts.logging.dir = dir;
-        }
-
-        if top_level_opts.log_level.is_some() {
-            opts.logging.level = top_level_opts.log_level;
-        }
-
-        let tls_opts = TlsOption::new(
-            self.tls_mode.clone(),
-            self.tls_cert_path.clone(),
-            self.tls_key_path.clone(),
-        );
-
-        if let Some(addr) = &self.http_addr {
-            if let Some(http_opts) = &mut opts.http_options {
-                http_opts.addr = addr.clone()
-            }
-        }
-
-        if let Some(disable_dashboard) = self.disable_dashboard {
-            opts.http_options
-                .get_or_insert_with(Default::default)
-                .disable_dashboard = disable_dashboard;
-        }
-
-        if let Some(addr) = &self.grpc_addr {
-            if let Some(grpc_opts) = &mut opts.grpc_options {
-                grpc_opts.addr = addr.clone()
-            }
-        }
-
-        if let Some(addr) = &self.mysql_addr {
-            if let Some(mysql_opts) = &mut opts.mysql_options {
-                mysql_opts.addr = addr.clone();
-                mysql_opts.tls = tls_opts.clone();
-            }
-        }
-
-        if let Some(addr) = &self.prom_addr {
-            opts.prom_options = Some(PromOptions { addr: addr.clone() });
-        }
-
-        if let Some(addr) = &self.postgres_addr {
-            if let Some(postgres_opts) = &mut opts.postgres_options {
-                postgres_opts.addr = addr.clone();
-                postgres_opts.tls = tls_opts;
-            }
-        }
-
-        if let Some(addr) = &self.opentsdb_addr {
-            if let Some(opentsdb_addr) = &mut opts.opentsdb_options {
-                opentsdb_addr.addr = addr.clone();
-            }
-        }
-
-        if let Some(enable) = self.influxdb_enable {
-            opts.influxdb_options = Some(InfluxdbOptions { enable });
-        }
-
-        if let Some(metasrv_addrs) = &self.metasrv_addr {
-            opts.meta_client_options
-                .get_or_insert_with(MetaClientOptions::default)
-                .metasrv_addrs = metasrv_addrs.clone();
-            opts.mode = Mode::Distributed;
-        }
-
-        Ok(Options::Frontend(Box::new(opts)))
-    }
-
-    async fn build(self, opts: FrontendOptions) -> Result<Instance> {
-        logging::info!("Frontend start command: {:#?}", self);
-        logging::info!("Frontend options: {:#?}", opts);
-
+    async fn build(self) -> Result<Instance> {
         let plugins = Arc::new(load_frontend_plugins(&self.user_provider)?);
+        let opts: FrontendOptions = self.try_into()?;
 
         let mut instance = FeInstance::try_new_distributed(&opts, plugins.clone())
             .await
             .context(error::StartFrontendSnafu)?;
 
         instance
-            .build_servers(&opts)
+            .build_servers(&opts, plugins)
             .await
             .context(error::StartFrontendSnafu)?;
 
@@ -222,7 +130,7 @@ impl StartCommand {
 }
 
 pub fn load_frontend_plugins(user_provider: &Option<String>) -> Result<Plugins> {
-    let plugins = Plugins::new();
+    let mut plugins = Plugins::new();
 
     if let Some(provider) = user_provider {
         let provider = auth::user_provider_from_option(provider).context(IllegalAuthConfigSnafu)?;
@@ -231,34 +139,106 @@ pub fn load_frontend_plugins(user_provider: &Option<String>) -> Result<Plugins>
     Ok(plugins)
 }
 
+impl TryFrom<StartCommand> for FrontendOptions {
+    type Error = error::Error;
+
+    fn try_from(cmd: StartCommand) -> Result<Self> {
+        let mut opts: FrontendOptions = if let Some(path) = cmd.config_file {
+            toml_loader::from_file!(&path)?
+        } else {
+            FrontendOptions::default()
+        };
+
+        let tls_option = TlsOption::new(cmd.tls_mode, cmd.tls_cert_path, cmd.tls_key_path);
+
+        let mut http_options = HttpOptions {
+            disable_dashboard: cmd.disable_dashboard,
+            ..Default::default()
+        };
+
+        if let Some(addr) = cmd.http_addr {
+            http_options.addr = addr;
+        }
+
+        opts.http_options = Some(http_options);
+
+        if let Some(addr) = cmd.grpc_addr {
+            opts.grpc_options = Some(GrpcOptions {
+                addr,
+                ..Default::default()
+            });
+        }
+
+        if let Some(addr) = cmd.mysql_addr {
+            opts.mysql_options = Some(MysqlOptions {
+                addr,
+                tls: tls_option.clone(),
+                ..Default::default()
+            });
+        }
+        if let Some(addr) = cmd.prom_addr {
+            opts.prom_options = Some(PromOptions { addr });
+        }
+        if let Some(addr) = cmd.postgres_addr {
+            opts.postgres_options = Some(PostgresOptions {
+                addr,
+                tls: tls_option,
+                ..Default::default()
+            });
+        }
+        if let Some(addr) = cmd.opentsdb_addr {
+            opts.opentsdb_options = Some(OpentsdbOptions {
+                addr,
+                ..Default::default()
+            });
+        }
+        if let Some(enable) = cmd.influxdb_enable {
+            opts.influxdb_options = Some(InfluxdbOptions { enable });
+        }
+        if let Some(metasrv_addr) = cmd.metasrv_addr {
+            opts.meta_client_options
+                .get_or_insert_with(MetaClientOptions::default)
+                .metasrv_addrs = metasrv_addr
+                .split(',')
+                .map(&str::trim)
+                .map(&str::to_string)
+                .collect::<Vec<_>>();
+            opts.mode = Mode::Distributed;
+        }
+        Ok(opts)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::io::Write;
     use std::time::Duration;
 
     use common_test_util::temp_dir::create_named_temp_file;
-    use frontend::service_config::GrpcOptions;
     use servers::auth::{Identity, Password, UserProviderRef};
 
     use super::*;
-    use crate::options::ENV_VAR_SEP;
 
     #[test]
     fn test_try_from_start_command() {
         let command = StartCommand {
             http_addr: Some("127.0.0.1:1234".to_string()),
+            grpc_addr: None,
             prom_addr: Some("127.0.0.1:4444".to_string()),
             mysql_addr: Some("127.0.0.1:5678".to_string()),
             postgres_addr: Some("127.0.0.1:5432".to_string()),
             opentsdb_addr: Some("127.0.0.1:4321".to_string()),
             influxdb_enable: Some(false),
-            disable_dashboard: Some(false),
-            ..Default::default()
+            config_file: None,
+            metasrv_addr: None,
+            tls_mode: None,
+            tls_cert_path: None,
+            tls_key_path: None,
+            user_provider: None,
+            disable_dashboard: false,
         };
 
-        let Options::Frontend(opts) =
-            command.load_options(TopLevelOptions::default()).unwrap() else { unreachable!() };
-
+        let opts: FrontendOptions = command.try_into().unwrap();
         assert_eq!(opts.http_options.as_ref().unwrap().addr, "127.0.0.1:1234");
         assert_eq!(opts.mysql_options.as_ref().unwrap().addr, "127.0.0.1:5678");
         assert_eq!(
@@ -301,21 +281,27 @@ mod tests {
             [http_options]
             addr = "127.0.0.1:4000"
             timeout = "30s"
-
-            [logging]
-            level = "debug"
-            dir = "/tmp/greptimedb/test/logs"
         "#;
         write!(file, "{}", toml_str).unwrap();
 
         let command = StartCommand {
+            http_addr: None,
+            grpc_addr: None,
+            mysql_addr: None,
+            prom_addr: None,
+            postgres_addr: None,
+            opentsdb_addr: None,
+            influxdb_enable: None,
             config_file: Some(file.path().to_str().unwrap().to_string()),
-            disable_dashboard: Some(false),
-            ..Default::default()
+            metasrv_addr: None,
+            tls_mode: None,
+            tls_cert_path: None,
+            tls_key_path: None,
+            user_provider: None,
+            disable_dashboard: false,
         };
 
-        let Options::Frontend(fe_opts) =
-            command.load_options(TopLevelOptions::default()).unwrap() else {unreachable!()};
+        let fe_opts = FrontendOptions::try_from(command).unwrap();
         assert_eq!(Mode::Distributed, fe_opts.mode);
         assert_eq!(
             "127.0.0.1:4000".to_string(),
@@ -325,17 +311,25 @@ mod tests {
             Duration::from_secs(30),
             fe_opts.http_options.as_ref().unwrap().timeout
         );
-
-        assert_eq!("debug", fe_opts.logging.level.as_ref().unwrap());
-        assert_eq!("/tmp/greptimedb/test/logs".to_string(), fe_opts.logging.dir);
     }
 
     #[tokio::test]
     async fn test_try_from_start_command_to_anymap() {
         let command = StartCommand {
+            http_addr: None,
+            grpc_addr: None,
+            mysql_addr: None,
+            prom_addr: None,
+            postgres_addr: None,
+            opentsdb_addr: None,
+            influxdb_enable: None,
+            config_file: None,
+            metasrv_addr: None,
+            tls_mode: None,
+            tls_cert_path: None,
+            tls_key_path: None,
             user_provider: Some("static_user_provider:cmd:test=test".to_string()),
-            disable_dashboard: Some(false),
-            ..Default::default()
+            disable_dashboard: false,
         };
 
         let plugins = load_frontend_plugins(&command.user_provider);
@@ -346,140 +340,8 @@ mod tests {
 
         let provider = provider.unwrap();
         let result = provider
-            .authenticate(
-                Identity::UserId("test", None),
-                Password::PlainText("test".to_string().into()),
-            )
+            .authenticate(Identity::UserId("test", None), Password::PlainText("test"))
             .await;
         assert!(result.is_ok());
     }
-
-    #[test]
-    fn test_top_level_options() {
-        let cmd = StartCommand {
-            disable_dashboard: Some(false),
-            ..Default::default()
-        };
-
-        let options = cmd
-            .load_options(TopLevelOptions {
-                log_dir: Some("/tmp/greptimedb/test/logs".to_string()),
-                log_level: Some("debug".to_string()),
-            })
-            .unwrap();
-
-        let logging_opt = options.logging_options();
-        assert_eq!("/tmp/greptimedb/test/logs", logging_opt.dir);
-        assert_eq!("debug", logging_opt.level.as_ref().unwrap());
-    }
-
-    #[test]
-    fn test_config_precedence_order() {
-        let mut file = create_named_temp_file();
-        let toml_str = r#"
-            mode = "distributed"
-
-            [http_options]
-            addr = "127.0.0.1:4000"
-
-            [meta_client_options]
-            timeout_millis = 3000
-            connect_timeout_millis = 5000
-            tcp_nodelay = true
-
-            [mysql_options]
-            addr = "127.0.0.1:4002"
-        "#;
-        write!(file, "{}", toml_str).unwrap();
-
-        let env_prefix = "FRONTEND_UT";
-        temp_env::with_vars(
-            vec![
-                (
-                    // mysql_options.addr = 127.0.0.1:14002
-                    vec![
-                        env_prefix.to_string(),
-                        "mysql_options".to_uppercase(),
-                        "addr".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("127.0.0.1:14002"),
-                ),
-                (
-                    // mysql_options.runtime_size = 11
-                    vec![
-                        env_prefix.to_string(),
-                        "mysql_options".to_uppercase(),
-                        "runtime_size".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("11"),
-                ),
-                (
-                    // http_options.addr = 127.0.0.1:24000
-                    vec![
-                        env_prefix.to_string(),
-                        "http_options".to_uppercase(),
-                        "addr".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("127.0.0.1:24000"),
-                ),
-                (
-                    // meta_client_options.metasrv_addrs = 127.0.0.1:3001,127.0.0.1:3002,127.0.0.1:3003
-                    vec![
-                        env_prefix.to_string(),
-                        "meta_client_options".to_uppercase(),
-                        "metasrv_addrs".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("127.0.0.1:3001,127.0.0.1:3002,127.0.0.1:3003"),
-                ),
-            ],
-            || {
-                let command = StartCommand {
-                    config_file: Some(file.path().to_str().unwrap().to_string()),
-                    http_addr: Some("127.0.0.1:14000".to_string()),
-                    env_prefix: env_prefix.to_string(),
-                    ..Default::default()
-                };
-
-                let top_level_opts = TopLevelOptions {
-                    log_dir: None,
-                    log_level: Some("error".to_string()),
-                };
-                let Options::Frontend(fe_opts) =
-                    command.load_options(top_level_opts).unwrap() else {unreachable!()};
-
-                // Should be read from env, env > default values.
-                assert_eq!(fe_opts.mysql_options.as_ref().unwrap().runtime_size, 11);
-                assert_eq!(
-                    fe_opts.meta_client_options.unwrap().metasrv_addrs,
-                    vec![
-                        "127.0.0.1:3001".to_string(),
-                        "127.0.0.1:3002".to_string(),
-                        "127.0.0.1:3003".to_string()
-                    ]
-                );
-
-                // Should be read from config file, config file > env > default values.
-                assert_eq!(
-                    fe_opts.mysql_options.as_ref().unwrap().addr,
-                    "127.0.0.1:4002"
-                );
-
-                // Should be read from cli, cli > config file > env > default values.
-                assert_eq!(
-                    fe_opts.http_options.as_ref().unwrap().addr,
-                    "127.0.0.1:14000"
-                );
-
-                // Should be default value.
-                assert_eq!(
-                    fe_opts.grpc_options.as_ref().unwrap().addr,
-                    GrpcOptions::default().addr
-                );
-            },
-        );
-    }
 }

src/cmd/src/lib.rs

@@ -19,5 +19,5 @@ pub mod datanode;
 pub mod error;
 pub mod frontend;
 pub mod metasrv;
-pub mod options;
 pub mod standalone;
+mod toml_loader;

src/cmd/src/metasrv.rs

@@ -15,20 +15,20 @@
 use std::time::Duration;
 
 use clap::Parser;
-use common_telemetry::logging;
+use common_telemetry::{info, logging, warn};
 use meta_srv::bootstrap::MetaSrvInstance;
 use meta_srv::metasrv::MetaSrvOptions;
 use snafu::ResultExt;
 
-use crate::error::{self, Result};
-use crate::options::{Options, TopLevelOptions};
+use crate::error::{Error, Result};
+use crate::{error, toml_loader};
 
 pub struct Instance {
     instance: MetaSrvInstance,
 }
 
 impl Instance {
-    pub async fn start(&mut self) -> Result<()> {
+    pub async fn run(&mut self) -> Result<()> {
         self.instance
             .start()
             .await
@@ -50,12 +50,8 @@ pub struct Command {
 }
 
 impl Command {
-    pub async fn build(self, opts: MetaSrvOptions) -> Result<Instance> {
-        self.subcmd.build(opts).await
-    }
-
-    pub fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        self.subcmd.load_options(top_level_opts)
+    pub async fn build(self) -> Result<Instance> {
+        self.subcmd.build().await
     }
 }
 
@@ -65,20 +61,14 @@ enum SubCommand {
 }
 
 impl SubCommand {
-    async fn build(self, opts: MetaSrvOptions) -> Result<Instance> {
+    async fn build(self) -> Result<Instance> {
         match self {
-            SubCommand::Start(cmd) => cmd.build(opts).await,
-        }
-    }
-
-    fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        match self {
-            SubCommand::Start(cmd) => cmd.load_options(top_level_opts),
+            SubCommand::Start(cmd) => cmd.build().await,
         }
     }
 }
 
-#[derive(Debug, Default, Parser)]
+#[derive(Debug, Parser)]
 struct StartCommand {
     #[clap(long)]
     bind_addr: Option<String>,
@@ -96,72 +86,65 @@ struct StartCommand {
     http_addr: Option<String>,
     #[clap(long)]
     http_timeout: Option<u64>,
-    #[clap(long, default_value = "GREPTIMEDB_METASRV")]
-    env_prefix: String,
 }
 
 impl StartCommand {
-    fn load_options(&self, top_level_opts: TopLevelOptions) -> Result<Options> {
-        let mut opts: MetaSrvOptions = Options::load_layered_options(
-            self.config_file.as_deref(),
-            self.env_prefix.as_ref(),
-            None,
-        )?;
+    async fn build(self) -> Result<Instance> {
+        logging::info!("MetaSrv start command: {:#?}", self);
 
-        if let Some(dir) = top_level_opts.log_dir {
-            opts.logging.dir = dir;
+        let opts: MetaSrvOptions = self.try_into()?;
+
+        logging::info!("MetaSrv options: {:#?}", opts);
+        let instance = MetaSrvInstance::new(opts)
+            .await
+            .context(error::BuildMetaServerSnafu)?;
+
+        Ok(Instance { instance })
+    }
+}
+
+impl TryFrom<StartCommand> for MetaSrvOptions {
+    type Error = Error;
+
+    fn try_from(cmd: StartCommand) -> Result<Self> {
+        let mut opts: MetaSrvOptions = if let Some(path) = cmd.config_file {
+            toml_loader::from_file!(&path)?
+        } else {
+            MetaSrvOptions::default()
+        };
+
+        if let Some(addr) = cmd.bind_addr {
+            opts.bind_addr = addr;
         }
-
-        if top_level_opts.log_level.is_some() {
-            opts.logging.level = top_level_opts.log_level;
+        if let Some(addr) = cmd.server_addr {
+            opts.server_addr = addr;
         }
-
-        if let Some(addr) = &self.bind_addr {
-            opts.bind_addr = addr.clone();
+        if let Some(addr) = cmd.store_addr {
+            opts.store_addr = addr;
         }
-
-        if let Some(addr) = &self.server_addr {
-            opts.server_addr = addr.clone();
-        }
-
-        if let Some(addr) = &self.store_addr {
-            opts.store_addr = addr.clone();
-        }
-
-        if let Some(selector_type) = &self.selector {
+        if let Some(selector_type) = &cmd.selector {
             opts.selector = selector_type[..]
                 .try_into()
                 .context(error::UnsupportedSelectorTypeSnafu { selector_type })?;
+            info!("Using {} selector", selector_type);
         }
 
-        if self.use_memory_store {
+        if cmd.use_memory_store {
+            warn!("Using memory store for Meta. Make sure you are in running tests.");
             opts.use_memory_store = true;
         }
 
-        if let Some(http_addr) = &self.http_addr {
-            opts.http_opts.addr = http_addr.clone();
+        if let Some(http_addr) = cmd.http_addr {
+            opts.http_opts.addr = http_addr;
         }
-
-        if let Some(http_timeout) = self.http_timeout {
+        if let Some(http_timeout) = cmd.http_timeout {
             opts.http_opts.timeout = Duration::from_secs(http_timeout);
         }
 
         // Disable dashboard in metasrv.
         opts.http_opts.disable_dashboard = true;
 
-        Ok(Options::Metasrv(Box::new(opts)))
-    }
-
-    async fn build(self, opts: MetaSrvOptions) -> Result<Instance> {
-        logging::info!("MetaSrv start command: {:#?}", self);
-
-        logging::info!("MetaSrv options: {:#?}", opts);
-
-        let instance = MetaSrvInstance::new(opts)
-            .await
-            .context(error::BuildMetaServerSnafu)?;
-
-        Ok(Instance { instance })
+        Ok(opts)
     }
 }
 
@@ -173,7 +156,6 @@ mod tests {
     use meta_srv::selector::SelectorType;
 
     use super::*;
-    use crate::options::ENV_VAR_SEP;
 
     #[test]
     fn test_read_from_cmd() {
@@ -181,13 +163,15 @@ mod tests {
             bind_addr: Some("127.0.0.1:3002".to_string()),
             server_addr: Some("127.0.0.1:3002".to_string()),
             store_addr: Some("127.0.0.1:2380".to_string()),
+            config_file: None,
             selector: Some("LoadBased".to_string()),
-            ..Default::default()
+            use_memory_store: false,
+            http_addr: None,
+            http_timeout: None,
         };
-
-        let Options::Metasrv(options) =
-        cmd.load_options(TopLevelOptions::default()).unwrap() else { unreachable!() };
+        let options: MetaSrvOptions = cmd.try_into().unwrap();
         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!("127.0.0.1:2380".to_string(), options.store_addr);
         assert_eq!(SelectorType::LoadBased, options.selector);
     }
@@ -202,116 +186,24 @@ mod tests {
             datanode_lease_secs = 15
             selector = "LeaseBased"
             use_memory_store = false
-
-            [logging]
-            level = "debug"
-            dir = "/tmp/greptimedb/test/logs"
         "#;
         write!(file, "{}", toml_str).unwrap();
 
         let cmd = StartCommand {
+            bind_addr: None,
+            server_addr: None,
+            store_addr: None,
+            selector: None,
             config_file: Some(file.path().to_str().unwrap().to_string()),
-            ..Default::default()
+            use_memory_store: false,
+            http_addr: None,
+            http_timeout: None,
         };
-
-        let Options::Metasrv(options) =
-            cmd.load_options(TopLevelOptions::default()).unwrap() else { unreachable!() };
+        let options: MetaSrvOptions = cmd.try_into().unwrap();
         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!("127.0.0.1:2379".to_string(), options.store_addr);
         assert_eq!(15, options.datanode_lease_secs);
         assert_eq!(SelectorType::LeaseBased, options.selector);
-        assert_eq!("debug", options.logging.level.as_ref().unwrap());
-        assert_eq!("/tmp/greptimedb/test/logs".to_string(), options.logging.dir);
-    }
-
-    #[test]
-    fn test_top_level_options() {
-        let cmd = StartCommand {
-            bind_addr: Some("127.0.0.1:3002".to_string()),
-            server_addr: Some("127.0.0.1:3002".to_string()),
-            store_addr: Some("127.0.0.1:2380".to_string()),
-            selector: Some("LoadBased".to_string()),
-            ..Default::default()
-        };
-
-        let options = cmd
-            .load_options(TopLevelOptions {
-                log_dir: Some("/tmp/greptimedb/test/logs".to_string()),
-                log_level: Some("debug".to_string()),
-            })
-            .unwrap();
-
-        let logging_opt = options.logging_options();
-        assert_eq!("/tmp/greptimedb/test/logs", logging_opt.dir);
-        assert_eq!("debug", logging_opt.level.as_ref().unwrap());
-    }
-
-    #[test]
-    fn test_config_precedence_order() {
-        let mut file = create_named_temp_file();
-        let toml_str = r#"
-            server_addr = "127.0.0.1:3002"
-            datanode_lease_secs = 15
-            selector = "LeaseBased"
-            use_memory_store = false
-
-            [http_options]
-            addr = "127.0.0.1:4000"
-
-            [logging]
-            level = "debug"
-            dir = "/tmp/greptimedb/test/logs"
-        "#;
-        write!(file, "{}", toml_str).unwrap();
-
-        let env_prefix = "METASRV_UT";
-        temp_env::with_vars(
-            vec![
-                (
-                    // bind_addr = 127.0.0.1:14002
-                    vec![env_prefix.to_string(), "bind_addr".to_uppercase()].join(ENV_VAR_SEP),
-                    Some("127.0.0.1:14002"),
-                ),
-                (
-                    // server_addr = 127.0.0.1:13002
-                    vec![env_prefix.to_string(), "server_addr".to_uppercase()].join(ENV_VAR_SEP),
-                    Some("127.0.0.1:13002"),
-                ),
-                (
-                    // http_options.addr = 127.0.0.1:24000
-                    vec![
-                        env_prefix.to_string(),
-                        "http_options".to_uppercase(),
-                        "addr".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("127.0.0.1:24000"),
-                ),
-            ],
-            || {
-                let command = StartCommand {
-                    http_addr: Some("127.0.0.1:14000".to_string()),
-                    config_file: Some(file.path().to_str().unwrap().to_string()),
-                    env_prefix: env_prefix.to_string(),
-                    ..Default::default()
-                };
-
-                let Options::Metasrv(opts) =
-                    command.load_options(TopLevelOptions::default()).unwrap() else {unreachable!()};
-
-                // Should be read from env, env > default values.
-                assert_eq!(opts.bind_addr, "127.0.0.1:14002");
-
-                // Should be read from config file, config file > env > default values.
-                assert_eq!(opts.server_addr, "127.0.0.1:3002");
-
-                // Should be read from cli, cli > config file > env > default values.
-                assert_eq!(opts.http_opts.addr, "127.0.0.1:14000");
-
-                // Should be default value.
-                assert_eq!(opts.store_addr, "127.0.0.1:2379");
-            },
-        );
     }
 }

src/cmd/src/options.rs

@@ -1,274 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use common_telemetry::logging::LoggingOptions;
-use config::{Config, Environment, File, FileFormat};
-use datanode::datanode::DatanodeOptions;
-use frontend::frontend::FrontendOptions;
-use meta_srv::metasrv::MetaSrvOptions;
-use serde::{Deserialize, Serialize};
-use snafu::ResultExt;
-
-use crate::error::{LoadLayeredConfigSnafu, Result};
-
-pub const ENV_VAR_SEP: &str = "__";
-pub const ENV_LIST_SEP: &str = ",";
-
-pub struct MixOptions {
-    pub fe_opts: FrontendOptions,
-    pub dn_opts: DatanodeOptions,
-    pub logging: LoggingOptions,
-}
-
-pub enum Options {
-    Datanode(Box<DatanodeOptions>),
-    Frontend(Box<FrontendOptions>),
-    Metasrv(Box<MetaSrvOptions>),
-    Standalone(Box<MixOptions>),
-    Cli(Box<LoggingOptions>),
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct TopLevelOptions {
-    pub log_dir: Option<String>,
-    pub log_level: Option<String>,
-}
-
-impl Options {
-    pub fn logging_options(&self) -> &LoggingOptions {
-        match self {
-            Options::Datanode(opts) => &opts.logging,
-            Options::Frontend(opts) => &opts.logging,
-            Options::Metasrv(opts) => &opts.logging,
-            Options::Standalone(opts) => &opts.logging,
-            Options::Cli(opts) => opts,
-        }
-    }
-
-    /// 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".
-    /// The function will use dunder(double underscore) `__` as the separator for environment variables, for example:
-    /// `DATANODE__STORAGE__MANIFEST__CHECKPOINT_MARGIN` will be mapped to `DatanodeOptions.storage.manifest.checkpoint_margin` field in the configuration.
-    /// `list_keys` is the list of keys that should be parsed as a list, for example, you can pass `Some(&["meta_client_options.metasrv_addrs"]` to parse `GREPTIMEDB_METASRV__META_CLIENT_OPTIONS__METASRV_ADDRS` as a list.
-    /// The function will use comma `,` as the separator for list values, for example: `127.0.0.1:3001,127.0.0.1:3002,127.0.0.1:3003`.
-    pub fn load_layered_options<'de, T: Serialize + Deserialize<'de> + Default>(
-        config_file: Option<&str>,
-        env_prefix: &str,
-        list_keys: Option<&[&str]>,
-    ) -> Result<T> {
-        let default_opts = T::default();
-
-        let env_source = {
-            let mut env = Environment::default();
-
-            if !env_prefix.is_empty() {
-                env = env.prefix(env_prefix);
-            }
-
-            if let Some(list_keys) = list_keys {
-                env = env.list_separator(ENV_LIST_SEP);
-                for key in list_keys {
-                    env = env.with_list_parse_key(key);
-                }
-            }
-
-            env.try_parsing(true)
-                .separator(ENV_VAR_SEP)
-                .ignore_empty(true)
-        };
-
-        // Add default values and environment variables as the sources of the configuration.
-        let mut layered_config = Config::builder()
-            .add_source(Config::try_from(&default_opts).context(LoadLayeredConfigSnafu)?)
-            .add_source(env_source);
-
-        // Add config file as the source of the configuration if it is specified.
-        if let Some(config_file) = config_file {
-            layered_config = layered_config.add_source(File::new(config_file, FileFormat::Toml));
-        }
-
-        let opts = layered_config
-            .build()
-            .context(LoadLayeredConfigSnafu)?
-            .try_deserialize()
-            .context(LoadLayeredConfigSnafu)?;
-
-        Ok(opts)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::io::Write;
-    use std::time::Duration;
-
-    use common_test_util::temp_dir::create_named_temp_file;
-    use datanode::datanode::{DatanodeOptions, ObjectStoreConfig};
-
-    use super::*;
-
-    #[test]
-    fn test_load_layered_options() {
-        let mut file = create_named_temp_file();
-        let toml_str = r#"
-            mode = "distributed"
-            enable_memory_catalog = false
-            rpc_addr = "127.0.0.1:3001"
-            rpc_hostname = "127.0.0.1"
-            rpc_runtime_size = 8
-            mysql_addr = "127.0.0.1:4406"
-            mysql_runtime_size = 2
-
-            [meta_client_options]
-            timeout_millis = 3000
-            connect_timeout_millis = 5000
-            tcp_nodelay = true
-
-            [wal]
-            dir = "/tmp/greptimedb/wal"
-            file_size = "1GB"
-            purge_threshold = "50GB"
-            purge_interval = "10m"
-            read_batch_size = 128
-            sync_write = false
-
-            [storage.compaction]
-            max_inflight_tasks = 3
-            max_files_in_level0 = 7
-            max_purge_tasks = 32
-
-            [logging]
-            level = "debug"
-            dir = "/tmp/greptimedb/test/logs"
-        "#;
-        write!(file, "{}", toml_str).unwrap();
-
-        let env_prefix = "DATANODE_UT";
-        temp_env::with_vars(
-            // The following environment variables will be used to override the values in the config file.
-            vec![
-                (
-                    // storage.manifest.checkpoint_margin = 99
-                    vec![
-                        env_prefix.to_string(),
-                        "storage".to_uppercase(),
-                        "manifest".to_uppercase(),
-                        "checkpoint_margin".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("99"),
-                ),
-                (
-                    // storage.type = S3
-                    vec![
-                        env_prefix.to_string(),
-                        "storage".to_uppercase(),
-                        "type".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("S3"),
-                ),
-                (
-                    // storage.bucket = mybucket
-                    vec![
-                        env_prefix.to_string(),
-                        "storage".to_uppercase(),
-                        "bucket".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("mybucket"),
-                ),
-                (
-                    // storage.manifest.gc_duration = 42s
-                    vec![
-                        env_prefix.to_string(),
-                        "storage".to_uppercase(),
-                        "manifest".to_uppercase(),
-                        "gc_duration".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("42s"),
-                ),
-                (
-                    // storage.manifest.checkpoint_on_startup = true
-                    vec![
-                        env_prefix.to_string(),
-                        "storage".to_uppercase(),
-                        "manifest".to_uppercase(),
-                        "checkpoint_on_startup".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("true"),
-                ),
-                (
-                    // wal.dir = /other/wal/dir
-                    vec![
-                        env_prefix.to_string(),
-                        "wal".to_uppercase(),
-                        "dir".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("/other/wal/dir"),
-                ),
-                (
-                    // meta_client_options.metasrv_addrs = 127.0.0.1:3001,127.0.0.1:3002,127.0.0.1:3003
-                    vec![
-                        env_prefix.to_string(),
-                        "meta_client_options".to_uppercase(),
-                        "metasrv_addrs".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("127.0.0.1:3001,127.0.0.1:3002,127.0.0.1:3003"),
-                ),
-            ],
-            || {
-                let opts: DatanodeOptions = Options::load_layered_options(
-                    Some(file.path().to_str().unwrap()),
-                    env_prefix,
-                    DatanodeOptions::env_list_keys(),
-                )
-                .unwrap();
-
-                // Check the configs from environment variables.
-                assert_eq!(opts.storage.manifest.checkpoint_margin, Some(99));
-                match opts.storage.store {
-                    ObjectStoreConfig::S3(s3_config) => {
-                        assert_eq!(s3_config.bucket, "mybucket".to_string());
-                    }
-                    _ => panic!("unexpected store type"),
-                }
-                assert_eq!(
-                    opts.storage.manifest.gc_duration,
-                    Some(Duration::from_secs(42))
-                );
-                assert!(opts.storage.manifest.checkpoint_on_startup);
-                assert_eq!(
-                    opts.meta_client_options.unwrap().metasrv_addrs,
-                    vec![
-                        "127.0.0.1:3001".to_string(),
-                        "127.0.0.1:3002".to_string(),
-                        "127.0.0.1:3003".to_string()
-                    ]
-                );
-
-                // Should be the values from config file, not environment variables.
-                assert_eq!(opts.wal.dir.unwrap(), "/tmp/greptimedb/wal");
-
-                // Should be default values.
-                assert_eq!(opts.node_id, None);
-            },
-        );
-    }
-}

src/cmd/src/standalone.rs

@@ -17,15 +17,17 @@ use std::sync::Arc;
 use clap::Parser;
 use common_base::Plugins;
 use common_telemetry::info;
-use common_telemetry::logging::LoggingOptions;
 use datanode::datanode::{Datanode, DatanodeOptions, ProcedureConfig, StorageConfig, WalConfig};
 use datanode::instance::InstanceRef;
 use frontend::frontend::FrontendOptions;
+use frontend::grpc::GrpcOptions;
+use frontend::influxdb::InfluxdbOptions;
 use frontend::instance::{FrontendInstance, Instance as FeInstance};
-use frontend::service_config::{
-    GrpcOptions, InfluxdbOptions, MysqlOptions, OpentsdbOptions, PostgresOptions, PromOptions,
-    PrometheusOptions,
-};
+use frontend::mysql::MysqlOptions;
+use frontend::opentsdb::OpentsdbOptions;
+use frontend::postgres::PostgresOptions;
+use frontend::prom::PromOptions;
+use frontend::prometheus::PrometheusOptions;
 use serde::{Deserialize, Serialize};
 use servers::http::HttpOptions;
 use servers::tls::{TlsMode, TlsOption};
@@ -33,11 +35,11 @@ use servers::Mode;
 use snafu::ResultExt;
 
 use crate::error::{
-    IllegalConfigSnafu, Result, ShutdownDatanodeSnafu, ShutdownFrontendSnafu, StartDatanodeSnafu,
-    StartFrontendSnafu,
+    Error, IllegalConfigSnafu, Result, ShutdownDatanodeSnafu, ShutdownFrontendSnafu,
+    StartDatanodeSnafu, StartFrontendSnafu,
 };
 use crate::frontend::load_frontend_plugins;
-use crate::options::{MixOptions, Options, TopLevelOptions};
+use crate::toml_loader;
 
 #[derive(Parser)]
 pub struct Command {
@@ -46,16 +48,8 @@ pub struct Command {
 }
 
 impl Command {
-    pub async fn build(
-        self,
-        fe_opts: FrontendOptions,
-        dn_opts: DatanodeOptions,
-    ) -> Result<Instance> {
-        self.subcmd.build(fe_opts, dn_opts).await
-    }
-
-    pub fn load_options(&self, top_level_options: TopLevelOptions) -> Result<Options> {
-        self.subcmd.load_options(top_level_options)
+    pub async fn build(self) -> Result<Instance> {
+        self.subcmd.build().await
     }
 }
 
@@ -65,15 +59,9 @@ enum SubCommand {
 }
 
 impl SubCommand {
-    async fn build(self, fe_opts: FrontendOptions, dn_opts: DatanodeOptions) -> Result<Instance> {
+    async fn build(self) -> Result<Instance> {
         match self {
-            SubCommand::Start(cmd) => cmd.build(fe_opts, dn_opts).await,
-        }
-    }
-
-    fn load_options(&self, top_level_options: TopLevelOptions) -> Result<Options> {
-        match self {
-            SubCommand::Start(cmd) => cmd.load_options(top_level_options),
+            SubCommand::Start(cmd) => cmd.build().await,
         }
     }
 }
@@ -93,8 +81,7 @@ pub struct StandaloneOptions {
     pub prom_options: Option<PromOptions>,
     pub wal: WalConfig,
     pub storage: StorageConfig,
-    pub procedure: ProcedureConfig,
-    pub logging: LoggingOptions,
+    pub procedure: Option<ProcedureConfig>,
 }
 
 impl Default for StandaloneOptions {
@@ -112,8 +99,7 @@ impl Default for StandaloneOptions {
             prom_options: Some(PromOptions::default()),
             wal: WalConfig::default(),
             storage: StorageConfig::default(),
-            procedure: ProcedureConfig::default(),
-            logging: LoggingOptions::default(),
+            procedure: None,
         }
     }
 }
@@ -131,7 +117,6 @@ impl StandaloneOptions {
             prometheus_options: self.prometheus_options,
             prom_options: self.prom_options,
             meta_client_options: None,
-            logging: self.logging,
         }
     }
 
@@ -152,7 +137,7 @@ pub struct Instance {
 }
 
 impl Instance {
-    pub async fn start(&mut self) -> Result<()> {
+    pub async fn run(&mut self) -> Result<()> {
         // Start datanode instance before starting services, to avoid requests come in before internal components are started.
         self.datanode
             .start_instance()
@@ -180,7 +165,7 @@ impl Instance {
     }
 }
 
-#[derive(Debug, Default, Parser)]
+#[derive(Debug, Parser)]
 struct StartCommand {
     #[clap(long)]
     http_addr: Option<String>,
@@ -208,101 +193,24 @@ struct StartCommand {
     tls_key_path: Option<String>,
     #[clap(long)]
     user_provider: Option<String>,
-    #[clap(long, default_value = "GREPTIMEDB_STANDALONE")]
-    env_prefix: String,
 }
 
 impl StartCommand {
-    fn load_options(&self, top_level_options: TopLevelOptions) -> Result<Options> {
-        let mut opts: StandaloneOptions = Options::load_layered_options(
-            self.config_file.as_deref(),
-            self.env_prefix.as_ref(),
-            None,
-        )?;
-
-        opts.enable_memory_catalog = self.enable_memory_catalog;
-
-        opts.mode = Mode::Standalone;
-
-        if let Some(dir) = top_level_options.log_dir {
-            opts.logging.dir = dir;
-        }
-
-        if top_level_options.log_level.is_some() {
-            opts.logging.level = top_level_options.log_level;
-        }
-
-        let tls_opts = TlsOption::new(
-            self.tls_mode.clone(),
-            self.tls_cert_path.clone(),
-            self.tls_key_path.clone(),
-        );
-
-        if let Some(addr) = &self.http_addr {
-            if let Some(http_opts) = &mut opts.http_options {
-                http_opts.addr = addr.clone()
-            }
-        }
-
-        if let Some(addr) = &self.rpc_addr {
-            // frontend grpc addr conflict with datanode default grpc addr
-            let datanode_grpc_addr = DatanodeOptions::default().rpc_addr;
-            if addr.eq(&datanode_grpc_addr) {
-                return IllegalConfigSnafu {
-                    msg: format!(
-                        "gRPC listen address conflicts with datanode reserved gRPC addr: {datanode_grpc_addr}",
-                    ),
-                }
-                .fail();
-            }
-            if let Some(grpc_opts) = &mut opts.grpc_options {
-                grpc_opts.addr = addr.clone()
-            }
-        }
-
-        if let Some(addr) = &self.mysql_addr {
-            if let Some(mysql_opts) = &mut opts.mysql_options {
-                mysql_opts.addr = addr.clone();
-                mysql_opts.tls = tls_opts.clone();
-            }
-        }
-
-        if let Some(addr) = &self.prom_addr {
-            opts.prom_options = Some(PromOptions { addr: addr.clone() })
-        }
-
-        if let Some(addr) = &self.postgres_addr {
-            if let Some(postgres_opts) = &mut opts.postgres_options {
-                postgres_opts.addr = addr.clone();
-                postgres_opts.tls = tls_opts;
-            }
-        }
-
-        if let Some(addr) = &self.opentsdb_addr {
-            if let Some(opentsdb_addr) = &mut opts.opentsdb_options {
-                opentsdb_addr.addr = addr.clone();
-            }
-        }
-
-        if self.influxdb_enable {
-            opts.influxdb_options = Some(InfluxdbOptions { enable: true });
-        }
-
-        let fe_opts = opts.clone().frontend_options();
-        let logging = opts.logging.clone();
-        let dn_opts = opts.datanode_options();
-
-        Ok(Options::Standalone(Box::new(MixOptions {
-            fe_opts,
-            dn_opts,
-            logging,
-        })))
-    }
-
-    async fn build(self, fe_opts: FrontendOptions, dn_opts: DatanodeOptions) -> Result<Instance> {
+    async fn build(self) -> Result<Instance> {
+        let enable_memory_catalog = self.enable_memory_catalog;
+        let config_file = self.config_file.clone();
         let plugins = Arc::new(load_frontend_plugins(&self.user_provider)?);
+        let fe_opts = FrontendOptions::try_from(self)?;
+        let dn_opts: DatanodeOptions = {
+            let mut opts: StandaloneOptions = if let Some(path) = config_file {
+                toml_loader::from_file!(&path)?
+            } else {
+                StandaloneOptions::default()
+            };
+            opts.enable_memory_catalog = enable_memory_catalog;
+            opts.datanode_options()
+        };
 
-        info!("Standalone start command: {:#?}", self);
         info!(
             "Standalone frontend options: {:#?}, datanode options: {:#?}",
             fe_opts, dn_opts
@@ -315,7 +223,7 @@ impl StartCommand {
         let mut frontend = build_frontend(plugins.clone(), datanode.get_instance()).await?;
 
         frontend
-            .build_servers(&fe_opts)
+            .build_servers(&fe_opts, plugins)
             .await
             .context(StartFrontendSnafu)?;
 
@@ -335,98 +243,118 @@ async fn build_frontend(
     Ok(frontend_instance)
 }
 
+impl TryFrom<StartCommand> for FrontendOptions {
+    type Error = Error;
+
+    fn try_from(cmd: StartCommand) -> std::result::Result<Self, Self::Error> {
+        let opts: StandaloneOptions = if let Some(path) = cmd.config_file {
+            toml_loader::from_file!(&path)?
+        } else {
+            StandaloneOptions::default()
+        };
+
+        let mut opts = opts.frontend_options();
+
+        opts.mode = Mode::Standalone;
+
+        if let Some(addr) = cmd.http_addr {
+            opts.http_options = Some(HttpOptions {
+                addr,
+                ..Default::default()
+            });
+        }
+        if let Some(addr) = cmd.rpc_addr {
+            // frontend grpc addr conflict with datanode default grpc addr
+            let datanode_grpc_addr = DatanodeOptions::default().rpc_addr;
+            if addr == datanode_grpc_addr {
+                return IllegalConfigSnafu {
+                    msg: format!(
+                        "gRPC listen address conflicts with datanode reserved gRPC addr: {datanode_grpc_addr}",
+                    ),
+                }
+                .fail();
+            }
+            opts.grpc_options = Some(GrpcOptions {
+                addr,
+                ..Default::default()
+            });
+        }
+
+        if let Some(addr) = cmd.mysql_addr {
+            opts.mysql_options = Some(MysqlOptions {
+                addr,
+                ..Default::default()
+            })
+        }
+
+        if let Some(addr) = cmd.prom_addr {
+            opts.prom_options = Some(PromOptions { addr })
+        }
+
+        if let Some(addr) = cmd.postgres_addr {
+            opts.postgres_options = Some(PostgresOptions {
+                addr,
+                ..Default::default()
+            })
+        }
+
+        if let Some(addr) = cmd.opentsdb_addr {
+            opts.opentsdb_options = Some(OpentsdbOptions {
+                addr,
+                ..Default::default()
+            });
+        }
+
+        if cmd.influxdb_enable {
+            opts.influxdb_options = Some(InfluxdbOptions { enable: true });
+        }
+
+        let tls_option = TlsOption::new(cmd.tls_mode, cmd.tls_cert_path, cmd.tls_key_path);
+
+        if let Some(mut mysql_options) = opts.mysql_options {
+            mysql_options.tls = tls_option.clone();
+            opts.mysql_options = Some(mysql_options);
+        }
+
+        if let Some(mut postgres_options) = opts.postgres_options {
+            postgres_options.tls = tls_option;
+            opts.postgres_options = Some(postgres_options);
+        }
+
+        Ok(opts)
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use std::default::Default;
-    use std::io::Write;
     use std::time::Duration;
 
-    use common_test_util::temp_dir::create_named_temp_file;
     use servers::auth::{Identity, Password, UserProviderRef};
-    use servers::Mode;
 
     use super::*;
-    use crate::options::ENV_VAR_SEP;
-
-    #[tokio::test]
-    async fn test_try_from_start_command_to_anymap() {
-        let command = StartCommand {
-            user_provider: Some("static_user_provider:cmd:test=test".to_string()),
-            ..Default::default()
-        };
-
-        let plugins = load_frontend_plugins(&command.user_provider);
-        assert!(plugins.is_ok());
-        let plugins = plugins.unwrap();
-        let provider = plugins.get::<UserProviderRef>();
-        assert!(provider.is_some());
-        let provider = provider.unwrap();
-        let result = provider
-            .authenticate(
-                Identity::UserId("test", None),
-                Password::PlainText("test".to_string().into()),
-            )
-            .await;
-        assert!(result.is_ok());
-    }
 
     #[test]
-    fn test_toml() {
-        let opts = StandaloneOptions::default();
-        let toml_string = toml::to_string(&opts).unwrap();
-        let _parsed: StandaloneOptions = toml::from_str(&toml_string).unwrap();
-    }
-
-    #[test]
-    fn test_read_from_config_file() {
-        let mut file = create_named_temp_file();
-        let toml_str = r#"
-            mode = "distributed"
-
-            enable_memory_catalog = true
-
-            [wal]
-            dir = "/tmp/greptimedb/test/wal"
-            file_size = "1GB"
-            purge_threshold = "50GB"
-            purge_interval = "10m"
-            read_batch_size = 128
-            sync_write = false
-
-            [storage]
-            type = "S3"
-            access_key_id = "access_key_id"
-            secret_access_key = "secret_access_key"
-
-            [storage.compaction]
-            max_inflight_tasks = 3
-            max_files_in_level0 = 7
-            max_purge_tasks = 32
-
-            [storage.manifest]
-            checkpoint_margin = 9
-            gc_duration = '7s'
-            checkpoint_on_startup = true
-
-            [http_options]
-            addr = "127.0.0.1:4000"
-            timeout = "30s"
-
-            [logging]
-            level = "debug"
-            dir = "/tmp/greptimedb/test/logs"
-        "#;
-        write!(file, "{}", toml_str).unwrap();
+    fn test_read_config_file() {
         let cmd = StartCommand {
-            config_file: Some(file.path().to_str().unwrap().to_string()),
-            user_provider: Some("static_user_provider:cmd:test=test".to_string()),
-            ..Default::default()
+            http_addr: None,
+            rpc_addr: None,
+            mysql_addr: None,
+            prom_addr: None,
+            postgres_addr: None,
+            opentsdb_addr: None,
+            config_file: Some(format!(
+                "{}/../../config/standalone.example.toml",
+                std::env::current_dir().unwrap().as_path().to_str().unwrap()
+            )),
+            influxdb_enable: false,
+            enable_memory_catalog: false,
+            tls_mode: None,
+            tls_cert_path: None,
+            tls_key_path: None,
+            user_provider: None,
         };
 
-        let Options::Standalone(options) = cmd.load_options(TopLevelOptions::default()).unwrap() else {unreachable!()};
-        let fe_opts = options.fe_opts;
-        let dn_opts = options.dn_opts;
-        let logging_opts = options.logging;
+        let fe_opts = FrontendOptions::try_from(cmd).unwrap();
         assert_eq!(Mode::Standalone, fe_opts.mode);
         assert_eq!(
             "127.0.0.1:4000".to_string(),
@@ -450,125 +378,42 @@ mod tests {
             fe_opts.mysql_options.as_ref().unwrap().reject_no_database
         );
         assert!(fe_opts.influxdb_options.as_ref().unwrap().enable);
-
-        assert_eq!("/tmp/greptimedb/test/wal", dn_opts.wal.dir.unwrap());
-        match &dn_opts.storage.store {
-            datanode::datanode::ObjectStoreConfig::S3(s3_config) => {
-                assert_eq!(
-                    "Secret([REDACTED alloc::string::String])".to_string(),
-                    format!("{:?}", s3_config.access_key_id)
-                );
-            }
-            _ => {
-                unreachable!()
-            }
-        }
-
-        assert_eq!("debug", logging_opts.level.as_ref().unwrap());
-        assert_eq!("/tmp/greptimedb/test/logs".to_string(), logging_opts.dir);
     }
 
-    #[test]
-    fn test_top_level_options() {
-        let cmd = StartCommand {
+    #[tokio::test]
+    async fn test_try_from_start_command_to_anymap() {
+        let command = StartCommand {
+            http_addr: None,
+            rpc_addr: None,
+            prom_addr: None,
+            mysql_addr: None,
+            postgres_addr: None,
+            opentsdb_addr: None,
+            config_file: None,
+            influxdb_enable: false,
+            enable_memory_catalog: false,
+            tls_mode: None,
+            tls_cert_path: None,
+            tls_key_path: None,
             user_provider: Some("static_user_provider:cmd:test=test".to_string()),
-            ..Default::default()
         };
 
-        let Options::Standalone(opts) = cmd
-            .load_options(TopLevelOptions {
-                log_dir: Some("/tmp/greptimedb/test/logs".to_string()),
-                log_level: Some("debug".to_string()),
-            })
-            .unwrap() else {
-            unreachable!()
-        };
-
-        assert_eq!("/tmp/greptimedb/test/logs", opts.logging.dir);
-        assert_eq!("debug", opts.logging.level.unwrap());
+        let plugins = load_frontend_plugins(&command.user_provider);
+        assert!(plugins.is_ok());
+        let plugins = plugins.unwrap();
+        let provider = plugins.get::<UserProviderRef>();
+        assert!(provider.is_some());
+        let provider = provider.unwrap();
+        let result = provider
+            .authenticate(Identity::UserId("test", None), Password::PlainText("test"))
+            .await;
+        assert!(result.is_ok());
     }
 
     #[test]
-    fn test_config_precedence_order() {
-        let mut file = create_named_temp_file();
-        let toml_str = r#"
-            mode = "standalone"
-
-            [http_options]
-            addr = "127.0.0.1:4000"
-
-            [logging]
-            level = "debug"
-        "#;
-        write!(file, "{}", toml_str).unwrap();
-
-        let env_prefix = "STANDALONE_UT";
-        temp_env::with_vars(
-            vec![
-                (
-                    // logging.dir = /other/log/dir
-                    vec![
-                        env_prefix.to_string(),
-                        "logging".to_uppercase(),
-                        "dir".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("/other/log/dir"),
-                ),
-                (
-                    // logging.level = info
-                    vec![
-                        env_prefix.to_string(),
-                        "logging".to_uppercase(),
-                        "level".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("info"),
-                ),
-                (
-                    // http_options.addr = 127.0.0.1:24000
-                    vec![
-                        env_prefix.to_string(),
-                        "http_options".to_uppercase(),
-                        "addr".to_uppercase(),
-                    ]
-                    .join(ENV_VAR_SEP),
-                    Some("127.0.0.1:24000"),
-                ),
-            ],
-            || {
-                let command = StartCommand {
-                    config_file: Some(file.path().to_str().unwrap().to_string()),
-                    http_addr: Some("127.0.0.1:14000".to_string()),
-                    env_prefix: env_prefix.to_string(),
-                    ..Default::default()
-                };
-
-                let top_level_opts = TopLevelOptions {
-                    log_dir: None,
-                    log_level: None,
-                };
-                let Options::Standalone(opts) =
-                    command.load_options(top_level_opts).unwrap() else {unreachable!()};
-
-                // Should be read from env, env > default values.
-                assert_eq!(opts.logging.dir, "/other/log/dir");
-
-                // Should be read from config file, config file > env > default values.
-                assert_eq!(opts.logging.level.as_ref().unwrap(), "debug");
-
-                // Should be read from cli, cli > config file > env > default values.
-                assert_eq!(
-                    opts.fe_opts.http_options.as_ref().unwrap().addr,
-                    "127.0.0.1:14000"
-                );
-
-                // Should be default value.
-                assert_eq!(
-                    opts.fe_opts.grpc_options.unwrap().addr,
-                    GrpcOptions::default().addr
-                );
-            },
-        );
+    fn test_toml() {
+        let opts = StandaloneOptions::default();
+        let toml_string = toml::to_string(&opts).unwrap();
+        let _parsed: StandaloneOptions = toml::from_str(&toml_string).unwrap();
     }
 }

src/cmd/src/toml_loader.rs

@@ -0,0 +1,94 @@
+// 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.
+
+macro_rules! from_file {
+    ($path: expr) => {
+        toml::from_str(
+            &std::fs::read_to_string($path)
+                .context(crate::error::ReadConfigSnafu { path: $path })?,
+        )
+        .context(crate::error::ParseConfigSnafu)
+    };
+}
+
+pub(crate) use from_file;
+
+#[cfg(test)]
+mod tests {
+    use std::fs::File;
+    use std::io::Write;
+
+    use common_test_util::temp_dir::create_temp_dir;
+    use serde::{Deserialize, Serialize};
+    use snafu::ResultExt;
+
+    use super::*;
+    use crate::error::Result;
+
+    #[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
+    #[serde(default)]
+    struct MockConfig {
+        path: String,
+        port: u32,
+        host: String,
+    }
+
+    impl Default for MockConfig {
+        fn default() -> Self {
+            Self {
+                path: "test".to_string(),
+                port: 0,
+                host: "localhost".to_string(),
+            }
+        }
+    }
+
+    #[test]
+    fn test_from_file() -> Result<()> {
+        let config = MockConfig {
+            path: "/tmp".to_string(),
+            port: 999,
+            host: "greptime.test".to_string(),
+        };
+
+        let dir = create_temp_dir("test_from_file");
+        let test_file = format!("{}/test.toml", dir.path().to_str().unwrap());
+
+        let s = toml::to_string(&config).unwrap();
+        assert!(s.contains("host") && s.contains("path") && s.contains("port"));
+
+        let mut file = File::create(&test_file).unwrap();
+        file.write_all(s.as_bytes()).unwrap();
+
+        let loaded_config: MockConfig = from_file!(&test_file)?;
+        assert_eq!(loaded_config, config);
+
+        // Only host in file
+        let mut file = File::create(&test_file).unwrap();
+        file.write_all("host='greptime.test'\n".as_bytes()).unwrap();
+
+        let loaded_config: MockConfig = from_file!(&test_file)?;
+        assert_eq!(loaded_config.host, "greptime.test");
+        assert_eq!(loaded_config.port, 0);
+        assert_eq!(loaded_config.path, "test");
+
+        // Truncate the file.
+        let file = File::create(&test_file).unwrap();
+        file.set_len(0).unwrap();
+        let loaded_config: MockConfig = from_file!(&test_file)?;
+        assert_eq!(loaded_config, MockConfig::default());
+
+        Ok(())
+    }
+}

src/cmd/tests/cli.rs

@@ -51,7 +51,7 @@ mod tests {
     #[ignore]
     #[test]
     fn test_repl() {
-        let data_home = create_temp_dir("data");
+        let data_dir = create_temp_dir("data");
         let wal_dir = create_temp_dir("wal");
 
         let mut bin_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
@@ -65,7 +65,7 @@ mod tests {
                 "start",
                 "--rpc-addr=0.0.0.0:4321",
                 "--node-id=1",
-                &format!("--data-home={}", data_home.path().display()),
+                &format!("--data-dir={}", data_dir.path().display()),
                 &format!("--wal-dir={}", wal_dir.path().display()),
             ])
             .stdout(Stdio::null())

src/common/base/src/bytes.rs

@@ -92,14 +92,6 @@ impl StringBytes {
     pub fn as_utf8(&self) -> &str {
         unsafe { std::str::from_utf8_unchecked(&self.0) }
     }
-
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
 }
 
 impl From<String> for StringBytes {
@@ -186,17 +178,6 @@ mod tests {
         assert_eq!(world, &bytes);
     }
 
-    #[test]
-    fn test_bytes_len() {
-        let hello = b"hello".to_vec();
-        let bytes = Bytes::from(hello.clone());
-        assert_eq!(bytes.len(), hello.len());
-
-        let zero = b"".to_vec();
-        let bytes = Bytes::from(zero);
-        assert!(bytes.is_empty());
-    }
-
     #[test]
     fn test_string_bytes_from() {
         let hello = "hello".to_string();
@@ -210,17 +191,6 @@ mod tests {
         assert_eq!(&bytes, world);
     }
 
-    #[test]
-    fn test_string_bytes_len() {
-        let hello = "hello".to_string();
-        let bytes = StringBytes::from(hello.clone());
-        assert_eq!(bytes.len(), hello.len());
-
-        let zero = "".to_string();
-        let bytes = StringBytes::from(zero);
-        assert!(bytes.is_empty());
-    }
-
     fn check_str(expect: &str, given: &str) {
         assert_eq!(expect, given);
     }

src/common/base/src/lib.rs

@@ -15,64 +15,9 @@
 pub mod bit_vec;
 pub mod buffer;
 pub mod bytes;
-pub mod paths;
 #[allow(clippy::all)]
 pub mod readable_size;
 
-use core::any::Any;
-use std::sync::{Arc, Mutex, MutexGuard};
-
 pub use bit_vec::BitVec;
 
-#[derive(Default, Clone)]
-pub struct Plugins {
-    inner: Arc<Mutex<anymap::Map<dyn Any + Send + Sync>>>,
-}
-
-impl Plugins {
-    pub fn new() -> Self {
-        Self {
-            inner: Arc::new(Mutex::new(anymap::Map::new())),
-        }
-    }
-
-    fn lock(&self) -> MutexGuard<anymap::Map<dyn Any + Send + Sync>> {
-        self.inner.lock().unwrap()
-    }
-
-    pub fn insert<T: 'static + Send + Sync>(&self, value: T) {
-        self.lock().insert(value);
-    }
-
-    pub fn get<T: 'static + Send + Sync + Clone>(&self) -> Option<T> {
-        let binding = self.lock();
-        binding.get::<T>().cloned()
-    }
-
-    pub fn map_mut<T: 'static + Send + Sync, F, R>(&self, mapper: F) -> R
-    where
-        F: FnOnce(Option<&mut T>) -> R,
-    {
-        let mut binding = self.lock();
-        let opt = binding.get_mut::<T>();
-        mapper(opt)
-    }
-
-    pub fn map<T: 'static + Send + Sync, F, R>(&self, mapper: F) -> Option<R>
-    where
-        F: FnOnce(&T) -> R,
-    {
-        let binding = self.lock();
-        binding.get::<T>().map(mapper)
-    }
-
-    pub fn len(&self) -> usize {
-        let binding = self.lock();
-        binding.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        let binding = self.lock();
-        binding.is_empty()
-    }
-}
+pub type Plugins = anymap::Map<dyn core::any::Any + Send + Sync>;

src/common/base/src/paths.rs

@@ -1,25 +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.
-
-//! Path constants for table engines, cluster states and WAL
-/// All paths relative to data_home(file storage) or root path(S3, OSS etc).
-
-/// WAL dir for local file storage
-pub const WAL_DIR: &str = "wal/";
-
-/// Data dir for table engines
-pub const DATA_DIR: &str = "data/";
-
-/// Cluster state dir
-pub const CLUSTER_DIR: &str = "cluster/";

src/common/catalog/src/consts.rs

@@ -21,8 +21,6 @@ pub const DEFAULT_SCHEMA_NAME: &str = "public";
 /// Reserves [0,MIN_USER_TABLE_ID) for internal usage.
 /// User defined table id starts from this value.
 pub const MIN_USER_TABLE_ID: u32 = 1024;
-/// the max system table id
-pub const MAX_SYS_TABLE_ID: u32 = MIN_USER_TABLE_ID - 1;
 /// system_catalog table id
 pub const SYSTEM_CATALOG_TABLE_ID: u32 = 0;
 /// scripts table id
@@ -30,7 +28,3 @@ pub const SCRIPTS_TABLE_ID: u32 = 1;
 
 pub const MITO_ENGINE: &str = "mito";
 pub const IMMUTABLE_FILE_ENGINE: &str = "file";
-
-pub const SEMANTIC_TYPE_PRIMARY_KEY: &str = "PRIMARY KEY";
-pub const SEMANTIC_TYPE_FIELD: &str = "FIELD";
-pub const SEMANTIC_TYPE_TIME_INDEX: &str = "TIME INDEX";

src/common/catalog/src/error.rs

@@ -36,6 +36,9 @@ pub enum Error {
         location: Location,
         source: serde_json::error::Error,
     },
+
+    #[snafu(display("Failed to parse node id: {}", key))]
+    ParseNodeId { key: String, location: Location },
 }
 
 impl ErrorExt for Error {
@@ -44,6 +47,7 @@ impl ErrorExt for Error {
             Error::InvalidCatalog { .. }
             | Error::DeserializeCatalogEntryValue { .. }
             | Error::SerializeCatalogEntryValue { .. } => StatusCode::Unexpected,
+            Error::ParseNodeId { .. } => StatusCode::InvalidArguments,
         }
     }
 

src/common/catalog/src/lib.rs

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use consts::DEFAULT_CATALOG_NAME;
-
 pub mod consts;
 pub mod error;
 
@@ -22,23 +20,3 @@ pub mod error;
 pub fn format_full_table_name(catalog: &str, schema: &str, table: &str) -> String {
     format!("{catalog}.{schema}.{table}")
 }
-
-/// Build db name from catalog and schema string
-pub fn build_db_string(catalog: &str, schema: &str) -> String {
-    if catalog == DEFAULT_CATALOG_NAME {
-        schema.to_string()
-    } else {
-        format!("{catalog}-{schema}")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_db_string() {
-        assert_eq!("test", build_db_string(DEFAULT_CATALOG_NAME, "test"));
-        assert_eq!("a0b1c2d3-test", build_db_string("a0b1c2d3", "test"));
-    }
-}

src/common/datasource/Cargo.toml

@@ -16,12 +16,9 @@ async-compression = { version = "0.3", features = [
     "tokio",
 ] }
 async-trait.workspace = true
-bytes = "1.1"
-common-base = { path = "../base" }
 common-error = { path = "../error" }
 common-runtime = { path = "../runtime" }
 datafusion.workspace = true
-derive_builder = "0.12"
 futures.workspace = true
 object-store = { path = "../../object-store" }
 regex = "1.7"
@@ -29,7 +26,3 @@ snafu.workspace = true
 tokio.workspace = true
 tokio-util.workspace = true
 url = "2.3"
-paste = "1.0"
-
-[dev-dependencies]
-common-test-util = { path = "../test-util" }

src/common/datasource/src/buffered_writer.rs

@@ -1,138 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use arrow::record_batch::RecordBatch;
-use async_trait::async_trait;
-use datafusion::parquet::format::FileMetaData;
-use object_store::Writer;
-use snafu::{OptionExt, ResultExt};
-use tokio::io::{AsyncWrite, AsyncWriteExt};
-use tokio_util::compat::Compat;
-
-use crate::error::{self, Result};
-use crate::share_buffer::SharedBuffer;
-
-pub struct BufferedWriter<T, U> {
-    writer: T,
-    /// None stands for [`BufferedWriter`] closed.
-    encoder: Option<U>,
-    buffer: SharedBuffer,
-    bytes_written: u64,
-    flushed: bool,
-    threshold: usize,
-}
-
-pub trait DfRecordBatchEncoder {
-    fn write(&mut self, batch: &RecordBatch) -> Result<()>;
-}
-
-#[async_trait]
-pub trait ArrowWriterCloser {
-    async fn close(mut self) -> Result<FileMetaData>;
-}
-
-pub type DefaultBufferedWriter<E> = BufferedWriter<Compat<Writer>, E>;
-
-impl<T: AsyncWrite + Send + Unpin, U: DfRecordBatchEncoder + ArrowWriterCloser>
-    BufferedWriter<T, U>
-{
-    pub async fn close_with_arrow_writer(mut self) -> Result<(FileMetaData, u64)> {
-        let encoder = self
-            .encoder
-            .take()
-            .context(error::BufferedWriterClosedSnafu)?;
-        let metadata = encoder.close().await?;
-        let written = self.try_flush(true).await?;
-        // It's important to shut down! flushes all pending writes
-        self.close().await?;
-        Ok((metadata, written))
-    }
-}
-
-impl<T: AsyncWrite + Send + Unpin, U: DfRecordBatchEncoder> BufferedWriter<T, U> {
-    pub async fn close(&mut self) -> Result<()> {
-        self.writer.shutdown().await.context(error::AsyncWriteSnafu)
-    }
-
-    pub fn new(threshold: usize, buffer: SharedBuffer, encoder: U, writer: T) -> Self {
-        Self {
-            threshold,
-            writer,
-            encoder: Some(encoder),
-            buffer,
-            bytes_written: 0,
-            flushed: false,
-        }
-    }
-
-    pub fn bytes_written(&self) -> u64 {
-        self.bytes_written
-    }
-
-    pub async fn write(&mut self, batch: &RecordBatch) -> Result<()> {
-        let encoder = self
-            .encoder
-            .as_mut()
-            .context(error::BufferedWriterClosedSnafu)?;
-        encoder.write(batch)?;
-        self.try_flush(false).await?;
-        Ok(())
-    }
-
-    pub fn flushed(&self) -> bool {
-        self.flushed
-    }
-
-    pub async fn try_flush(&mut self, all: bool) -> Result<u64> {
-        let mut bytes_written: u64 = 0;
-
-        // Once buffered data size reaches threshold, split the data in chunks (typically 4MB)
-        // and write to underlying storage.
-        while self.buffer.buffer.lock().unwrap().len() >= self.threshold {
-            let chunk = {
-                let mut buffer = self.buffer.buffer.lock().unwrap();
-                buffer.split_to(self.threshold)
-            };
-            let size = chunk.len();
-
-            self.writer
-                .write_all(&chunk)
-                .await
-                .context(error::AsyncWriteSnafu)?;
-
-            bytes_written += size as u64;
-        }
-
-        if all {
-            bytes_written += self.try_flush_all().await?;
-        }
-
-        self.flushed = bytes_written > 0;
-        self.bytes_written += bytes_written;
-
-        Ok(bytes_written)
-    }
-
-    async fn try_flush_all(&mut self) -> Result<u64> {
-        let remain = self.buffer.buffer.lock().unwrap().split();
-        let size = remain.len();
-
-        self.writer
-            .write_all(&remain)
-            .await
-            .context(error::AsyncWriteSnafu)?;
-
-        Ok(size as u64)
-    }
-}

src/common/datasource/src/compression.rs

@@ -13,29 +13,24 @@
 // limitations under the License.
 
 use std::fmt::Display;
-use std::io;
 use std::str::FromStr;
 
 use async_compression::tokio::bufread::{BzDecoder, GzipDecoder, XzDecoder, ZstdDecoder};
-use async_compression::tokio::write;
-use bytes::Bytes;
-use futures::Stream;
-use tokio::io::{AsyncRead, AsyncWriteExt, BufReader};
-use tokio_util::io::{ReaderStream, StreamReader};
+use tokio::io::{AsyncRead, BufReader};
 
 use crate::error::{self, Error, Result};
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum CompressionType {
     /// Gzip-ed file
-    Gzip,
+    GZIP,
     /// Bzip2-ed file
-    Bzip2,
+    BZIP2,
     /// Xz-ed file (liblzma)
-    Xz,
+    XZ,
     /// Zstd-ed file,
-    Zstd,
+    ZSTD,
     /// Uncompressed file
-    Uncompressed,
+    UNCOMPRESSED,
 }
 
 impl FromStr for CompressionType {
@@ -44,11 +39,11 @@ impl FromStr for CompressionType {
     fn from_str(s: &str) -> Result<Self> {
         let s = s.to_uppercase();
         match s.as_str() {
-            "GZIP" | "GZ" => Ok(Self::Gzip),
-            "BZIP2" | "BZ2" => Ok(Self::Bzip2),
-            "XZ" => Ok(Self::Xz),
-            "ZST" | "ZSTD" => Ok(Self::Zstd),
-            "" => Ok(Self::Uncompressed),
+            "GZIP" | "GZ" => Ok(Self::GZIP),
+            "BZIP2" | "BZ2" => Ok(Self::BZIP2),
+            "XZ" => Ok(Self::XZ),
+            "ZST" | "ZSTD" => Ok(Self::ZSTD),
+            "" => Ok(Self::UNCOMPRESSED),
             _ => error::UnsupportedCompressionTypeSnafu {
                 compression_type: s,
             }
@@ -60,121 +55,30 @@ impl FromStr for CompressionType {
 impl Display for CompressionType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(match self {
-            Self::Gzip => "GZIP",
-            Self::Bzip2 => "BZIP2",
-            Self::Xz => "XZ",
-            Self::Zstd => "ZSTD",
-            Self::Uncompressed => "",
+            Self::GZIP => "GZIP",
+            Self::BZIP2 => "BZIP2",
+            Self::XZ => "XZ",
+            Self::ZSTD => "ZSTD",
+            Self::UNCOMPRESSED => "",
         })
     }
 }
 
 impl CompressionType {
     pub const fn is_compressed(&self) -> bool {
-        !matches!(self, &Self::Uncompressed)
+        !matches!(self, &Self::UNCOMPRESSED)
     }
 
-    pub const fn file_extension(&self) -> &'static str {
+    pub fn convert_async_read<T: AsyncRead + Unpin + Send + 'static>(
+        &self,
+        s: T,
+    ) -> Box<dyn AsyncRead + Unpin + Send> {
         match self {
-            Self::Gzip => "gz",
-            Self::Bzip2 => "bz2",
-            Self::Xz => "xz",
-            Self::Zstd => "zst",
-            Self::Uncompressed => "",
+            CompressionType::GZIP => Box::new(GzipDecoder::new(BufReader::new(s))),
+            CompressionType::BZIP2 => Box::new(BzDecoder::new(BufReader::new(s))),
+            CompressionType::XZ => Box::new(XzDecoder::new(BufReader::new(s))),
+            CompressionType::ZSTD => Box::new(ZstdDecoder::new(BufReader::new(s))),
+            CompressionType::UNCOMPRESSED => Box::new(s),
         }
     }
 }
-
-macro_rules! impl_compression_type {
-    ($(($enum_item:ident, $prefix:ident)),*) => {
-        paste::item! {
-            impl CompressionType {
-                pub async fn encode(&self, content: impl AsRef<[u8]>) -> io::Result<Vec<u8>> {
-                    match self {
-                        $(
-                            CompressionType::$enum_item => {
-                                let mut buffer = Vec::with_capacity(content.as_ref().len());
-                                let mut encoder = write::[<$prefix Encoder>]::new(&mut buffer);
-                                encoder.write_all(content.as_ref()).await?;
-                                encoder.shutdown().await?;
-                                Ok(buffer)
-                            }
-                        )*
-                        CompressionType::Uncompressed => Ok(content.as_ref().to_vec()),
-                    }
-                }
-
-                pub async fn decode(&self, content: impl AsRef<[u8]>) -> io::Result<Vec<u8>> {
-                    match self {
-                        $(
-                            CompressionType::$enum_item => {
-                                let mut buffer = Vec::with_capacity(content.as_ref().len() * 2);
-                                let mut encoder = write::[<$prefix Decoder>]::new(&mut buffer);
-                                encoder.write_all(content.as_ref()).await?;
-                                encoder.shutdown().await?;
-                                Ok(buffer)
-                            }
-                        )*
-                        CompressionType::Uncompressed => Ok(content.as_ref().to_vec()),
-                    }
-                }
-
-                pub fn convert_async_read<T: AsyncRead + Unpin + Send + 'static>(
-                    &self,
-                    s: T,
-                ) -> Box<dyn AsyncRead + Unpin + Send> {
-                    match self {
-                        $(CompressionType::$enum_item => Box::new([<$prefix Decoder>]::new(BufReader::new(s))),)*
-                        CompressionType::Uncompressed => Box::new(s),
-                    }
-                }
-
-                pub fn convert_stream<T: Stream<Item = io::Result<Bytes>> + Unpin + Send + 'static>(
-                    &self,
-                    s: T,
-                ) -> Box<dyn Stream<Item = io::Result<Bytes>> + Send + Unpin> {
-                    match self {
-                        $(CompressionType::$enum_item => Box::new(ReaderStream::new([<$prefix Decoder>]::new(StreamReader::new(s)))),)*
-                        CompressionType::Uncompressed => Box::new(s),
-                    }
-                }
-            }
-
-            #[cfg(test)]
-            mod tests {
-                use super::CompressionType;
-
-                $(
-                #[tokio::test]
-                async fn [<test_ $enum_item:lower _compression>]() {
-                    let string = "foo_bar".as_bytes().to_vec();
-                    let compress = CompressionType::$enum_item
-                        .encode(&string)
-                        .await
-                        .unwrap();
-                    let decompress = CompressionType::$enum_item
-                        .decode(&compress)
-                        .await
-                        .unwrap();
-                    assert_eq!(decompress, string);
-                })*
-
-                #[tokio::test]
-                async fn test_uncompression() {
-                    let string = "foo_bar".as_bytes().to_vec();
-                    let compress = CompressionType::Uncompressed
-                        .encode(&string)
-                        .await
-                        .unwrap();
-                    let decompress = CompressionType::Uncompressed
-                        .decode(&compress)
-                        .await
-                        .unwrap();
-                    assert_eq!(decompress, string);
-                }
-            }
-        }
-    };
-}
-
-impl_compression_type!((Gzip, Gzip), (Bzip2, Bz), (Xz, Xz), (Zstd, Zstd));

src/common/datasource/src/error.rs

@@ -14,9 +14,7 @@
 
 use std::any::Any;
 
-use arrow_schema::ArrowError;
 use common_error::prelude::*;
-use datafusion::parquet::errors::ParquetError;
 use snafu::Location;
 use url::ParseError;
 
@@ -24,27 +22,23 @@ use url::ParseError;
 #[snafu(visibility(pub))]
 pub enum Error {
     #[snafu(display("Unsupported compression type: {}", compression_type))]
-    UnsupportedCompressionType {
-        compression_type: String,
-        location: Location,
-    },
+    UnsupportedCompressionType { compression_type: String },
 
     #[snafu(display("Unsupported backend protocol: {}", protocol))]
-    UnsupportedBackendProtocol {
-        protocol: String,
-        location: Location,
-    },
-
-    #[snafu(display("Unsupported format protocol: {}", format))]
-    UnsupportedFormat { format: String, location: Location },
+    UnsupportedBackendProtocol { protocol: String },
 
     #[snafu(display("empty host: {}", url))]
-    EmptyHostPath { url: String, location: Location },
+    EmptyHostPath { url: String },
+
+    #[snafu(display("Invalid path: {}", path))]
+    InvalidPath { path: String },
 
     #[snafu(display("Invalid url: {}, error :{}", url, source))]
-    InvalidUrl {
-        url: String,
-        source: ParseError,
+    InvalidUrl { url: String, source: ParseError },
+
+    #[snafu(display("Failed to decompression, source: {}", source))]
+    Decompression {
+        source: object_store::Error,
         location: Location,
     },
 
@@ -61,37 +55,6 @@ pub enum Error {
         source: object_store::Error,
     },
 
-    #[snafu(display("Failed to write object to path: {}, source: {}", path, source))]
-    WriteObject {
-        path: String,
-        location: Location,
-        source: object_store::Error,
-    },
-
-    #[snafu(display("Failed to write: {}", source))]
-    AsyncWrite {
-        source: std::io::Error,
-        location: Location,
-    },
-
-    #[snafu(display("Failed to write record batch: {}", source))]
-    WriteRecordBatch {
-        location: Location,
-        source: ArrowError,
-    },
-
-    #[snafu(display("Failed to encode record batch: {}", source))]
-    EncodeRecordBatch {
-        location: Location,
-        source: ParquetError,
-    },
-
-    #[snafu(display("Failed to read record batch: {}", source))]
-    ReadRecordBatch {
-        location: Location,
-        source: datafusion::error::DataFusionError,
-    },
-
     #[snafu(display("Failed to read parquet source: {}", source))]
     ReadParquetSnafu {
         location: Location,
@@ -104,8 +67,9 @@ pub enum Error {
         source: datafusion::parquet::errors::ParquetError,
     },
 
-    #[snafu(display("Failed to infer schema from file, source: {}", source))]
+    #[snafu(display("Failed to infer schema from file: {}, source: {}", path, source))]
     InferSchema {
+        path: String,
         location: Location,
         source: arrow_schema::ArrowError,
     },
@@ -118,29 +82,13 @@ pub enum Error {
     },
 
     #[snafu(display("Invalid connection: {}", msg))]
-    InvalidConnection { msg: String, location: Location },
+    InvalidConnection { msg: String },
 
     #[snafu(display("Failed to join handle: {}", source))]
     JoinHandle {
         location: Location,
         source: tokio::task::JoinError,
     },
-
-    #[snafu(display("Failed to parse format {} with value: {}", key, value))]
-    ParseFormat {
-        key: &'static str,
-        value: String,
-        location: Location,
-    },
-
-    #[snafu(display("Failed to merge schema: {}", source))]
-    MergeSchema {
-        source: arrow_schema::ArrowError,
-        location: Location,
-    },
-
-    #[snafu(display("Buffered writer closed"))]
-    BufferedWriterClosed { location: Location },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -149,29 +97,21 @@ impl ErrorExt for Error {
     fn status_code(&self) -> StatusCode {
         use Error::*;
         match self {
-            BuildBackend { .. }
-            | ListObjects { .. }
-            | ReadObject { .. }
-            | WriteObject { .. }
-            | AsyncWrite { .. } => StatusCode::StorageUnavailable,
+            BuildBackend { .. } | ListObjects { .. } | ReadObject { .. } => {
+                StatusCode::StorageUnavailable
+            }
 
             UnsupportedBackendProtocol { .. }
             | UnsupportedCompressionType { .. }
-            | UnsupportedFormat { .. }
             | InvalidConnection { .. }
             | InvalidUrl { .. }
             | EmptyHostPath { .. }
+            | InvalidPath { .. }
             | InferSchema { .. }
             | ReadParquetSnafu { .. }
-            | ParquetToSchema { .. }
-            | ParseFormat { .. }
-            | MergeSchema { .. } => StatusCode::InvalidArguments,
+            | ParquetToSchema { .. } => StatusCode::InvalidArguments,
 
-            JoinHandle { .. }
-            | ReadRecordBatch { .. }
-            | WriteRecordBatch { .. }
-            | EncodeRecordBatch { .. }
-            | BufferedWriterClosed { .. } => StatusCode::Unexpected,
+            Decompression { .. } | JoinHandle { .. } => StatusCode::Unexpected,
         }
     }
 
@@ -188,22 +128,15 @@ impl ErrorExt for Error {
             InferSchema { location, .. } => Some(*location),
             ReadParquetSnafu { location, .. } => Some(*location),
             ParquetToSchema { location, .. } => Some(*location),
+            Decompression { location, .. } => Some(*location),
             JoinHandle { location, .. } => Some(*location),
-            ParseFormat { location, .. } => Some(*location),
-            MergeSchema { location, .. } => Some(*location),
-            WriteObject { location, .. } => Some(*location),
-            ReadRecordBatch { location, .. } => Some(*location),
-            WriteRecordBatch { location, .. } => Some(*location),
-            AsyncWrite { location, .. } => Some(*location),
-            EncodeRecordBatch { location, .. } => Some(*location),
-            BufferedWriterClosed { location, .. } => Some(*location),
 
-            UnsupportedBackendProtocol { location, .. } => Some(*location),
-            EmptyHostPath { location, .. } => Some(*location),
-            InvalidUrl { location, .. } => Some(*location),
-            InvalidConnection { location, .. } => Some(*location),
-            UnsupportedCompressionType { location, .. } => Some(*location),
-            UnsupportedFormat { location, .. } => Some(*location),
+            UnsupportedBackendProtocol { .. }
+            | EmptyHostPath { .. }
+            | InvalidPath { .. }
+            | InvalidUrl { .. }
+            | InvalidConnection { .. }
+            | UnsupportedCompressionType { .. } => None,
         }
     }
 }

src/common/datasource/src/file_format.rs

@@ -15,194 +15,16 @@
 pub mod csv;
 pub mod json;
 pub mod parquet;
-#[cfg(test)]
-pub mod tests;
 
 pub const DEFAULT_SCHEMA_INFER_MAX_RECORD: usize = 1000;
 
-use std::collections::HashMap;
-use std::result;
-use std::sync::Arc;
-use std::task::Poll;
-
-use arrow::record_batch::RecordBatch;
-use arrow_schema::{ArrowError, Schema as ArrowSchema};
+use arrow::datatypes::SchemaRef;
 use async_trait::async_trait;
-use bytes::{Buf, Bytes};
-use datafusion::error::{DataFusionError, Result as DataFusionResult};
-use datafusion::physical_plan::file_format::FileOpenFuture;
-use datafusion::physical_plan::SendableRecordBatchStream;
-use futures::StreamExt;
 use object_store::ObjectStore;
-use snafu::ResultExt;
-use tokio_util::compat::FuturesAsyncWriteCompatExt;
 
-use self::csv::CsvFormat;
-use self::json::JsonFormat;
-use self::parquet::ParquetFormat;
-use crate::buffered_writer::{BufferedWriter, DfRecordBatchEncoder};
-use crate::compression::CompressionType;
-use crate::error::{self, Result};
-use crate::share_buffer::SharedBuffer;
-
-pub const FORMAT_COMPRESSION_TYPE: &str = "compression_type";
-pub const FORMAT_DELIMITER: &str = "delimiter";
-pub const FORMAT_SCHEMA_INFER_MAX_RECORD: &str = "schema_infer_max_record";
-pub const FORMAT_HAS_HEADER: &str = "has_header";
-pub const FORMAT_TYPE: &str = "format";
-pub const FILE_PATTERN: &str = "pattern";
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Format {
-    Csv(CsvFormat),
-    Json(JsonFormat),
-    Parquet(ParquetFormat),
-}
-
-impl TryFrom<&HashMap<String, String>> for Format {
-    type Error = error::Error;
-
-    fn try_from(options: &HashMap<String, String>) -> Result<Self> {
-        let format = options
-            .get(FORMAT_TYPE)
-            .map(|format| format.to_ascii_uppercase())
-            .unwrap_or_else(|| "PARQUET".to_string());
-
-        match format.as_str() {
-            "CSV" => Ok(Self::Csv(CsvFormat::try_from(options)?)),
-            "JSON" => Ok(Self::Json(JsonFormat::try_from(options)?)),
-            "PARQUET" => Ok(Self::Parquet(ParquetFormat::default())),
-            _ => error::UnsupportedFormatSnafu { format: &format }.fail(),
-        }
-    }
-}
+use crate::error::Result;
 
 #[async_trait]
 pub trait FileFormat: Send + Sync + std::fmt::Debug {
-    async fn infer_schema(&self, store: &ObjectStore, path: &str) -> Result<ArrowSchema>;
-}
-
-pub trait ArrowDecoder: Send + 'static {
-    /// Decode records from `buf` returning the number of bytes read.
-    ///
-    /// This method returns `Ok(0)` once `batch_size` objects have been parsed since the
-    /// last call to [`Self::flush`], or `buf` is exhausted.
-    ///
-    /// Any remaining bytes should be included in the next call to [`Self::decode`].
-    fn decode(&mut self, buf: &[u8]) -> result::Result<usize, ArrowError>;
-
-    /// Flushes the currently buffered data to a [`RecordBatch`].
-    ///
-    /// This should only be called after [`Self::decode`] has returned `Ok(0)`,
-    /// otherwise may return an error if part way through decoding a record
-    ///
-    /// Returns `Ok(None)` if no buffered data.
-    fn flush(&mut self) -> result::Result<Option<RecordBatch>, ArrowError>;
-}
-
-impl ArrowDecoder for arrow::csv::reader::Decoder {
-    fn decode(&mut self, buf: &[u8]) -> result::Result<usize, ArrowError> {
-        self.decode(buf)
-    }
-
-    fn flush(&mut self) -> result::Result<Option<RecordBatch>, ArrowError> {
-        self.flush()
-    }
-}
-
-#[allow(deprecated)]
-impl ArrowDecoder for arrow::json::RawDecoder {
-    fn decode(&mut self, buf: &[u8]) -> result::Result<usize, ArrowError> {
-        self.decode(buf)
-    }
-
-    fn flush(&mut self) -> result::Result<Option<RecordBatch>, ArrowError> {
-        self.flush()
-    }
-}
-
-pub fn open_with_decoder<T: ArrowDecoder, F: Fn() -> DataFusionResult<T>>(
-    object_store: Arc<ObjectStore>,
-    path: String,
-    compression_type: CompressionType,
-    decoder_factory: F,
-) -> DataFusionResult<FileOpenFuture> {
-    let mut decoder = decoder_factory()?;
-    Ok(Box::pin(async move {
-        let reader = object_store
-            .reader(&path)
-            .await
-            .map_err(|e| DataFusionError::External(Box::new(e)))?;
-
-        let mut upstream = compression_type.convert_stream(reader).fuse();
-
-        let mut buffered = Bytes::new();
-
-        let stream = futures::stream::poll_fn(move |cx| {
-            loop {
-                if buffered.is_empty() {
-                    if let Some(result) = futures::ready!(upstream.poll_next_unpin(cx)) {
-                        buffered = result?;
-                    };
-                }
-
-                let decoded = decoder.decode(buffered.as_ref())?;
-
-                if decoded == 0 {
-                    break;
-                } else {
-                    buffered.advance(decoded);
-                }
-            }
-
-            Poll::Ready(decoder.flush().transpose())
-        });
-
-        Ok(stream.boxed())
-    }))
-}
-
-pub async fn infer_schemas(
-    store: &ObjectStore,
-    files: &[String],
-    file_format: &dyn FileFormat,
-) -> Result<ArrowSchema> {
-    let mut schemas = Vec::with_capacity(files.len());
-    for file in files {
-        schemas.push(file_format.infer_schema(store, file).await?)
-    }
-    ArrowSchema::try_merge(schemas).context(error::MergeSchemaSnafu)
-}
-
-pub async fn stream_to_file<T: DfRecordBatchEncoder, U: Fn(SharedBuffer) -> T>(
-    mut stream: SendableRecordBatchStream,
-    store: ObjectStore,
-    path: &str,
-    threshold: usize,
-    encoder_factory: U,
-) -> Result<usize> {
-    let writer = store
-        .writer(path)
-        .await
-        .context(error::WriteObjectSnafu { path })?
-        .compat_write();
-
-    let buffer = SharedBuffer::with_capacity(threshold);
-    let encoder = encoder_factory(buffer.clone());
-    let mut writer = BufferedWriter::new(threshold, buffer, encoder, writer);
-
-    let mut rows = 0;
-
-    while let Some(batch) = stream.next().await {
-        let batch = batch.context(error::ReadRecordBatchSnafu)?;
-        writer.write(&batch).await?;
-        rows += batch.num_rows();
-    }
-
-    // Flushes all pending writes
-    writer.try_flush(true).await?;
-
-    writer.close().await?;
-
-    Ok(rows)
+    async fn infer_schema(&self, store: &ObjectStore, path: String) -> Result<SchemaRef>;
 }

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

@@ -12,33 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
-use std::str::FromStr;
 use std::sync::Arc;
 
-use arrow::csv;
-#[allow(deprecated)]
 use arrow::csv::reader::infer_reader_schema as infer_csv_schema;
-use arrow::record_batch::RecordBatch;
-use arrow_schema::{Schema, SchemaRef};
+use arrow_schema::SchemaRef;
 use async_trait::async_trait;
 use common_runtime;
-use datafusion::error::Result as DataFusionResult;
-use datafusion::physical_plan::file_format::{FileMeta, FileOpenFuture, FileOpener};
-use datafusion::physical_plan::SendableRecordBatchStream;
-use derive_builder::Builder;
 use object_store::ObjectStore;
 use snafu::ResultExt;
 use tokio_util::io::SyncIoBridge;
 
-use super::stream_to_file;
-use crate::buffered_writer::DfRecordBatchEncoder;
 use crate::compression::CompressionType;
 use crate::error::{self, Result};
-use crate::file_format::{self, open_with_decoder, FileFormat};
-use crate::share_buffer::SharedBuffer;
+use crate::file_format::{self, FileFormat};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct CsvFormat {
     pub has_header: bool,
     pub delimiter: u8,
@@ -46,128 +34,24 @@ pub struct CsvFormat {
     pub compression_type: CompressionType,
 }
 
-impl TryFrom<&HashMap<String, String>> for CsvFormat {
-    type Error = error::Error;
-
-    fn try_from(value: &HashMap<String, String>) -> Result<Self> {
-        let mut format = CsvFormat::default();
-        if let Some(delimiter) = value.get(file_format::FORMAT_DELIMITER) {
-            // TODO(weny): considers to support parse like "\t" (not only b'\t')
-            format.delimiter = u8::from_str(delimiter).map_err(|_| {
-                error::ParseFormatSnafu {
-                    key: file_format::FORMAT_DELIMITER,
-                    value: delimiter,
-                }
-                .build()
-            })?;
-        };
-        if let Some(compression_type) = value.get(file_format::FORMAT_COMPRESSION_TYPE) {
-            format.compression_type = CompressionType::from_str(compression_type)?;
-        };
-        if let Some(schema_infer_max_record) =
-            value.get(file_format::FORMAT_SCHEMA_INFER_MAX_RECORD)
-        {
-            format.schema_infer_max_record =
-                Some(schema_infer_max_record.parse::<usize>().map_err(|_| {
-                    error::ParseFormatSnafu {
-                        key: file_format::FORMAT_SCHEMA_INFER_MAX_RECORD,
-                        value: schema_infer_max_record,
-                    }
-                    .build()
-                })?);
-        };
-        if let Some(has_header) = value.get(file_format::FORMAT_HAS_HEADER) {
-            format.has_header = has_header.parse().map_err(|_| {
-                error::ParseFormatSnafu {
-                    key: file_format::FORMAT_HAS_HEADER,
-                    value: has_header,
-                }
-                .build()
-            })?;
-        }
-        Ok(format)
-    }
-}
-
 impl Default for CsvFormat {
     fn default() -> Self {
         Self {
             has_header: true,
             delimiter: b',',
             schema_infer_max_record: Some(file_format::DEFAULT_SCHEMA_INFER_MAX_RECORD),
-            compression_type: CompressionType::Uncompressed,
+            compression_type: CompressionType::UNCOMPRESSED,
         }
     }
 }
 
-#[derive(Debug, Clone, Builder)]
-pub struct CsvConfig {
-    batch_size: usize,
-    file_schema: SchemaRef,
-    #[builder(default = "None")]
-    file_projection: Option<Vec<usize>>,
-    #[builder(default = "true")]
-    has_header: bool,
-    #[builder(default = "b','")]
-    delimiter: u8,
-}
-
-impl CsvConfig {
-    fn builder(&self) -> csv::ReaderBuilder {
-        let mut builder = csv::ReaderBuilder::new(self.file_schema.clone())
-            .with_delimiter(self.delimiter)
-            .with_batch_size(self.batch_size)
-            .has_header(self.has_header);
-
-        if let Some(proj) = &self.file_projection {
-            builder = builder.with_projection(proj.clone());
-        }
-
-        builder
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct CsvOpener {
-    config: Arc<CsvConfig>,
-    object_store: Arc<ObjectStore>,
-    compression_type: CompressionType,
-}
-
-impl CsvOpener {
-    /// Return a new [`CsvOpener`]. The caller must ensure [`CsvConfig`].file_schema must correspond to the opening file.
-    pub fn new(
-        config: CsvConfig,
-        object_store: ObjectStore,
-        compression_type: CompressionType,
-    ) -> Self {
-        CsvOpener {
-            config: Arc::new(config),
-            object_store: Arc::new(object_store),
-            compression_type,
-        }
-    }
-}
-
-impl FileOpener for CsvOpener {
-    fn open(&self, meta: FileMeta) -> DataFusionResult<FileOpenFuture> {
-        open_with_decoder(
-            self.object_store.clone(),
-            meta.location().to_string(),
-            self.compression_type,
-            || Ok(self.config.builder().build_decoder()),
-        )
-    }
-}
-
-#[allow(deprecated)]
 #[async_trait]
 impl FileFormat for CsvFormat {
-    async fn infer_schema(&self, store: &ObjectStore, path: &str) -> Result<Schema> {
+    async fn infer_schema(&self, store: &ObjectStore, path: String) -> Result<SchemaRef> {
         let reader = store
-            .reader(path)
+            .reader(&path)
             .await
-            .context(error::ReadObjectSnafu { path })?;
+            .context(error::ReadObjectSnafu { path: &path })?;
 
         let decoded = self.compression_type.convert_async_read(reader);
 
@@ -180,40 +64,20 @@ impl FileFormat for CsvFormat {
 
             let (schema, _records_read) =
                 infer_csv_schema(reader, delimiter, schema_infer_max_record, has_header)
-                    .context(error::InferSchemaSnafu)?;
-            Ok(schema)
+                    .context(error::InferSchemaSnafu { path: &path })?;
+
+            Ok(Arc::new(schema))
         })
         .await
         .context(error::JoinHandleSnafu)?
     }
 }
 
-pub async fn stream_to_csv(
-    stream: SendableRecordBatchStream,
-    store: ObjectStore,
-    path: &str,
-    threshold: usize,
-) -> Result<usize> {
-    stream_to_file(stream, store, path, threshold, |buffer| {
-        csv::Writer::new(buffer)
-    })
-    .await
-}
-
-impl DfRecordBatchEncoder for csv::Writer<SharedBuffer> {
-    fn write(&mut self, batch: &RecordBatch) -> Result<()> {
-        self.write(batch).context(error::WriteRecordBatchSnafu)
-    }
-}
-
 #[cfg(test)]
 mod tests {
 
     use super::*;
-    use crate::file_format::{
-        FileFormat, FORMAT_COMPRESSION_TYPE, FORMAT_DELIMITER, FORMAT_HAS_HEADER,
-        FORMAT_SCHEMA_INFER_MAX_RECORD,
-    };
+    use crate::file_format::FileFormat;
     use crate::test_util::{self, format_schema, test_store};
 
     fn test_data_root() -> String {
@@ -224,7 +88,10 @@ mod tests {
     async fn infer_schema_basic() {
         let csv = CsvFormat::default();
         let store = test_store(&test_data_root());
-        let schema = csv.infer_schema(&store, "simple.csv").await.unwrap();
+        let schema = csv
+            .infer_schema(&store, "simple.csv".to_string())
+            .await
+            .unwrap();
         let formatted: Vec<_> = format_schema(schema);
 
         assert_eq!(
@@ -255,7 +122,7 @@ mod tests {
         };
         let store = test_store(&test_data_root());
         let schema = json
-            .infer_schema(&store, "schema_infer_limit.csv")
+            .infer_schema(&store, "schema_infer_limit.csv".to_string())
             .await
             .unwrap();
         let formatted: Vec<_> = format_schema(schema);
@@ -273,7 +140,7 @@ mod tests {
         let json = CsvFormat::default();
         let store = test_store(&test_data_root());
         let schema = json
-            .infer_schema(&store, "schema_infer_limit.csv")
+            .infer_schema(&store, "schema_infer_limit.csv".to_string())
             .await
             .unwrap();
         let formatted: Vec<_> = format_schema(schema);
@@ -288,33 +155,4 @@ mod tests {
             formatted
         );
     }
-
-    #[test]
-    fn test_try_from() {
-        let mut map = HashMap::new();
-        let format: CsvFormat = CsvFormat::try_from(&map).unwrap();
-
-        assert_eq!(format, CsvFormat::default());
-
-        map.insert(
-            FORMAT_SCHEMA_INFER_MAX_RECORD.to_string(),
-            "2000".to_string(),
-        );
-
-        map.insert(FORMAT_COMPRESSION_TYPE.to_string(), "zstd".to_string());
-        map.insert(FORMAT_DELIMITER.to_string(), b'\t'.to_string());
-        map.insert(FORMAT_HAS_HEADER.to_string(), "false".to_string());
-
-        let format = CsvFormat::try_from(&map).unwrap();
-
-        assert_eq!(
-            format,
-            CsvFormat {
-                compression_type: CompressionType::Zstd,
-                schema_infer_max_record: Some(2000),
-                delimiter: b'\t',
-                has_header: false,
-            }
-        );
-    }
 }

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

@@ -12,80 +12,43 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
 use std::io::BufReader;
-use std::str::FromStr;
 use std::sync::Arc;
 
 use arrow::datatypes::SchemaRef;
 use arrow::json::reader::{infer_json_schema_from_iterator, ValueIter};
-use arrow::json::writer::LineDelimited;
-#[allow(deprecated)]
-use arrow::json::{self, RawReaderBuilder};
-use arrow::record_batch::RecordBatch;
-use arrow_schema::Schema;
 use async_trait::async_trait;
 use common_runtime;
-use datafusion::error::{DataFusionError, Result as DataFusionResult};
-use datafusion::physical_plan::file_format::{FileMeta, FileOpenFuture, FileOpener};
-use datafusion::physical_plan::SendableRecordBatchStream;
 use object_store::ObjectStore;
 use snafu::ResultExt;
 use tokio_util::io::SyncIoBridge;
 
-use super::stream_to_file;
-use crate::buffered_writer::DfRecordBatchEncoder;
 use crate::compression::CompressionType;
 use crate::error::{self, Result};
-use crate::file_format::{self, open_with_decoder, FileFormat};
-use crate::share_buffer::SharedBuffer;
+use crate::file_format::{self, FileFormat};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct JsonFormat {
     pub schema_infer_max_record: Option<usize>,
     pub compression_type: CompressionType,
 }
 
-impl TryFrom<&HashMap<String, String>> for JsonFormat {
-    type Error = error::Error;
-
-    fn try_from(value: &HashMap<String, String>) -> Result<Self> {
-        let mut format = JsonFormat::default();
-        if let Some(compression_type) = value.get(file_format::FORMAT_COMPRESSION_TYPE) {
-            format.compression_type = CompressionType::from_str(compression_type)?
-        };
-        if let Some(schema_infer_max_record) =
-            value.get(file_format::FORMAT_SCHEMA_INFER_MAX_RECORD)
-        {
-            format.schema_infer_max_record =
-                Some(schema_infer_max_record.parse::<usize>().map_err(|_| {
-                    error::ParseFormatSnafu {
-                        key: file_format::FORMAT_SCHEMA_INFER_MAX_RECORD,
-                        value: schema_infer_max_record,
-                    }
-                    .build()
-                })?);
-        };
-        Ok(format)
-    }
-}
-
 impl Default for JsonFormat {
     fn default() -> Self {
         Self {
             schema_infer_max_record: Some(file_format::DEFAULT_SCHEMA_INFER_MAX_RECORD),
-            compression_type: CompressionType::Uncompressed,
+            compression_type: CompressionType::UNCOMPRESSED,
         }
     }
 }
 
 #[async_trait]
 impl FileFormat for JsonFormat {
-    async fn infer_schema(&self, store: &ObjectStore, path: &str) -> Result<Schema> {
+    async fn infer_schema(&self, store: &ObjectStore, path: String) -> Result<SchemaRef> {
         let reader = store
-            .reader(path)
+            .reader(&path)
             .await
-            .context(error::ReadObjectSnafu { path })?;
+            .context(error::ReadObjectSnafu { path: &path })?;
 
         let decoded = self.compression_type.convert_async_read(reader);
 
@@ -96,79 +59,20 @@ impl FileFormat for JsonFormat {
 
             let iter = ValueIter::new(&mut reader, schema_infer_max_record);
 
-            let schema = infer_json_schema_from_iterator(iter).context(error::InferSchemaSnafu)?;
+            let schema = infer_json_schema_from_iterator(iter)
+                .context(error::InferSchemaSnafu { path: &path })?;
 
-            Ok(schema)
+            Ok(Arc::new(schema))
         })
         .await
         .context(error::JoinHandleSnafu)?
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct JsonOpener {
-    batch_size: usize,
-    projected_schema: SchemaRef,
-    object_store: Arc<ObjectStore>,
-    compression_type: CompressionType,
-}
-
-impl JsonOpener {
-    /// Return a new [`JsonOpener`]. Any fields not present in `projected_schema` will be ignored.
-    pub fn new(
-        batch_size: usize,
-        projected_schema: SchemaRef,
-        object_store: ObjectStore,
-        compression_type: CompressionType,
-    ) -> Self {
-        Self {
-            batch_size,
-            projected_schema,
-            object_store: Arc::new(object_store),
-            compression_type,
-        }
-    }
-}
-
-#[allow(deprecated)]
-impl FileOpener for JsonOpener {
-    fn open(&self, meta: FileMeta) -> DataFusionResult<FileOpenFuture> {
-        open_with_decoder(
-            self.object_store.clone(),
-            meta.location().to_string(),
-            self.compression_type,
-            || {
-                RawReaderBuilder::new(self.projected_schema.clone())
-                    .with_batch_size(self.batch_size)
-                    .build_decoder()
-                    .map_err(DataFusionError::from)
-            },
-        )
-    }
-}
-
-pub async fn stream_to_json(
-    stream: SendableRecordBatchStream,
-    store: ObjectStore,
-    path: &str,
-    threshold: usize,
-) -> Result<usize> {
-    stream_to_file(stream, store, path, threshold, |buffer| {
-        json::LineDelimitedWriter::new(buffer)
-    })
-    .await
-}
-
-impl DfRecordBatchEncoder for json::Writer<SharedBuffer, LineDelimited> {
-    fn write(&mut self, batch: &RecordBatch) -> Result<()> {
-        self.write(batch).context(error::WriteRecordBatchSnafu)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::file_format::{FileFormat, FORMAT_COMPRESSION_TYPE, FORMAT_SCHEMA_INFER_MAX_RECORD};
+    use crate::file_format::FileFormat;
     use crate::test_util::{self, format_schema, test_store};
 
     fn test_data_root() -> String {
@@ -179,7 +83,10 @@ mod tests {
     async fn infer_schema_basic() {
         let json = JsonFormat::default();
         let store = test_store(&test_data_root());
-        let schema = json.infer_schema(&store, "simple.json").await.unwrap();
+        let schema = json
+            .infer_schema(&store, "simple.json".to_string())
+            .await
+            .unwrap();
         let formatted: Vec<_> = format_schema(schema);
 
         assert_eq!(
@@ -201,7 +108,7 @@ mod tests {
         };
         let store = test_store(&test_data_root());
         let schema = json
-            .infer_schema(&store, "schema_infer_limit.json")
+            .infer_schema(&store, "schema_infer_limit.json".to_string())
             .await
             .unwrap();
         let formatted: Vec<_> = format_schema(schema);
@@ -211,29 +118,4 @@ mod tests {
             formatted
         );
     }
-
-    #[test]
-    fn test_try_from() {
-        let mut map = HashMap::new();
-        let format = JsonFormat::try_from(&map).unwrap();
-
-        assert_eq!(format, JsonFormat::default());
-
-        map.insert(
-            FORMAT_SCHEMA_INFER_MAX_RECORD.to_string(),
-            "2000".to_string(),
-        );
-
-        map.insert(FORMAT_COMPRESSION_TYPE.to_string(), "zstd".to_string());
-
-        let format = JsonFormat::try_from(&map).unwrap();
-
-        assert_eq!(
-            format,
-            JsonFormat {
-                compression_type: CompressionType::Zstd,
-                schema_infer_max_record: Some(2000),
-            }
-        );
-    }
 }

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

@@ -12,39 +12,28 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::result;
 use std::sync::Arc;
 
-use arrow::record_batch::RecordBatch;
-use arrow_schema::Schema;
+use arrow_schema::SchemaRef;
 use async_trait::async_trait;
-use datafusion::error::Result as DatafusionResult;
 use datafusion::parquet::arrow::async_reader::AsyncFileReader;
-use datafusion::parquet::arrow::{parquet_to_arrow_schema, ArrowWriter};
-use datafusion::parquet::errors::{ParquetError, Result as ParquetResult};
-use datafusion::parquet::file::metadata::ParquetMetaData;
-use datafusion::parquet::format::FileMetaData;
-use datafusion::physical_plan::file_format::{FileMeta, ParquetFileReaderFactory};
-use datafusion::physical_plan::metrics::ExecutionPlanMetricsSet;
-use futures::future::BoxFuture;
-use object_store::{ObjectStore, Reader};
+use datafusion::parquet::arrow::parquet_to_arrow_schema;
+use object_store::ObjectStore;
 use snafu::ResultExt;
 
-use crate::buffered_writer::{ArrowWriterCloser, DfRecordBatchEncoder};
 use crate::error::{self, Result};
 use crate::file_format::FileFormat;
-use crate::share_buffer::SharedBuffer;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[derive(Debug, Default)]
 pub struct ParquetFormat {}
 
 #[async_trait]
 impl FileFormat for ParquetFormat {
-    async fn infer_schema(&self, store: &ObjectStore, path: &str) -> Result<Schema> {
+    async fn infer_schema(&self, store: &ObjectStore, path: String) -> Result<SchemaRef> {
         let mut reader = store
-            .reader(path)
+            .reader(&path)
             .await
-            .context(error::ReadObjectSnafu { path })?;
+            .context(error::ReadObjectSnafu { path: &path })?;
 
         let metadata = reader
             .get_metadata()
@@ -58,107 +47,14 @@ impl FileFormat for ParquetFormat {
         )
         .context(error::ParquetToSchemaSnafu)?;
 
-        Ok(schema)
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct DefaultParquetFileReaderFactory {
-    object_store: ObjectStore,
-}
-
-/// Returns a AsyncFileReader factory
-impl DefaultParquetFileReaderFactory {
-    pub fn new(object_store: ObjectStore) -> Self {
-        Self { object_store }
-    }
-}
-
-impl ParquetFileReaderFactory for DefaultParquetFileReaderFactory {
-    // TODO(weny): Supports [`metadata_size_hint`].
-    // The upstream has a implementation supports [`metadata_size_hint`],
-    // however it coupled with Box<dyn ObjectStore>.
-    fn create_reader(
-        &self,
-        _partition_index: usize,
-        file_meta: FileMeta,
-        _metadata_size_hint: Option<usize>,
-        _metrics: &ExecutionPlanMetricsSet,
-    ) -> DatafusionResult<Box<dyn AsyncFileReader + Send>> {
-        let path = file_meta.location().to_string();
-        let object_store = self.object_store.clone();
-
-        Ok(Box::new(LazyParquetFileReader::new(object_store, path)))
-    }
-}
-
-pub struct LazyParquetFileReader {
-    object_store: ObjectStore,
-    reader: Option<Reader>,
-    path: String,
-}
-
-impl LazyParquetFileReader {
-    pub fn new(object_store: ObjectStore, path: String) -> Self {
-        LazyParquetFileReader {
-            object_store,
-            path,
-            reader: None,
-        }
-    }
-
-    /// Must initialize the reader, or throw an error from the future.
-    async fn maybe_initialize(&mut self) -> result::Result<(), object_store::Error> {
-        if self.reader.is_none() {
-            let reader = self.object_store.reader(&self.path).await?;
-            self.reader = Some(reader);
-        }
-
-        Ok(())
-    }
-}
-
-impl AsyncFileReader for LazyParquetFileReader {
-    fn get_bytes(
-        &mut self,
-        range: std::ops::Range<usize>,
-    ) -> BoxFuture<'_, ParquetResult<bytes::Bytes>> {
-        Box::pin(async move {
-            self.maybe_initialize()
-                .await
-                .map_err(|e| ParquetError::External(Box::new(e)))?;
-            // Safety: Must initialized
-            self.reader.as_mut().unwrap().get_bytes(range).await
-        })
-    }
-
-    fn get_metadata(&mut self) -> BoxFuture<'_, ParquetResult<Arc<ParquetMetaData>>> {
-        Box::pin(async move {
-            self.maybe_initialize()
-                .await
-                .map_err(|e| ParquetError::External(Box::new(e)))?;
-            // Safety: Must initialized
-            self.reader.as_mut().unwrap().get_metadata().await
-        })
-    }
-}
-
-impl DfRecordBatchEncoder for ArrowWriter<SharedBuffer> {
-    fn write(&mut self, batch: &RecordBatch) -> Result<()> {
-        self.write(batch).context(error::EncodeRecordBatchSnafu)
-    }
-}
-
-#[async_trait]
-impl ArrowWriterCloser for ArrowWriter<SharedBuffer> {
-    async fn close(self) -> Result<FileMetaData> {
-        self.close().context(error::EncodeRecordBatchSnafu)
+        Ok(Arc::new(schema))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::file_format::FileFormat;
     use crate::test_util::{self, format_schema, test_store};
 
     fn test_data_root() -> String {
@@ -171,7 +67,10 @@ mod tests {
     async fn infer_schema_basic() {
         let json = ParquetFormat::default();
         let store = test_store(&test_data_root());
-        let schema = json.infer_schema(&store, "basic.parquet").await.unwrap();
+        let schema = json
+            .infer_schema(&store, "basic.parquet".to_string())
+            .await
+            .unwrap();
         let formatted: Vec<_> = format_schema(schema);
 
         assert_eq!(vec!["num: Int64: NULL", "str: Utf8: NULL"], formatted);

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

@@ -1,228 +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::assert_matches::assert_matches;
-use std::collections::HashMap;
-use std::sync::Arc;
-use std::vec;
-
-use datafusion::assert_batches_eq;
-use datafusion::execution::context::TaskContext;
-use datafusion::physical_plan::file_format::{FileOpener, FileScanConfig, FileStream, ParquetExec};
-use datafusion::physical_plan::metrics::ExecutionPlanMetricsSet;
-use datafusion::physical_plan::ExecutionPlan;
-use datafusion::prelude::SessionContext;
-use futures::StreamExt;
-
-use super::FORMAT_TYPE;
-use crate::compression::CompressionType;
-use crate::error;
-use crate::file_format::csv::{CsvConfigBuilder, CsvOpener};
-use crate::file_format::json::JsonOpener;
-use crate::file_format::parquet::DefaultParquetFileReaderFactory;
-use crate::file_format::Format;
-use crate::test_util::{self, scan_config, test_basic_schema, test_store};
-
-struct Test<'a, T: FileOpener> {
-    config: FileScanConfig,
-    opener: T,
-    expected: Vec<&'a str>,
-}
-
-impl<'a, T: FileOpener> Test<'a, T> {
-    pub async fn run(self) {
-        let result = FileStream::new(
-            &self.config,
-            0,
-            self.opener,
-            &ExecutionPlanMetricsSet::new(),
-        )
-        .unwrap()
-        .map(|b| b.unwrap())
-        .collect::<Vec<_>>()
-        .await;
-
-        assert_batches_eq!(self.expected, &result);
-    }
-}
-
-#[tokio::test]
-async fn test_json_opener() {
-    let store = test_store("/");
-
-    let schema = test_basic_schema();
-
-    let json_opener = JsonOpener::new(
-        100,
-        schema.clone(),
-        store.clone(),
-        CompressionType::Uncompressed,
-    );
-
-    let path = &test_util::get_data_dir("tests/json/basic.json")
-        .display()
-        .to_string();
-    let tests = [
-        Test {
-            config: scan_config(schema.clone(), None, path),
-            opener: json_opener.clone(),
-            expected: vec![
-                "+-----+-------+",
-                "| num | str   |",
-                "+-----+-------+",
-                "| 5   | test  |",
-                "| 2   | hello |",
-                "| 4   | foo   |",
-                "+-----+-------+",
-            ],
-        },
-        Test {
-            config: scan_config(schema.clone(), Some(1), path),
-            opener: json_opener.clone(),
-            expected: vec![
-                "+-----+------+",
-                "| num | str  |",
-                "+-----+------+",
-                "| 5   | test |",
-                "+-----+------+",
-            ],
-        },
-    ];
-
-    for test in tests {
-        test.run().await;
-    }
-}
-
-#[tokio::test]
-async fn test_csv_opener() {
-    let store = test_store("/");
-
-    let schema = test_basic_schema();
-    let path = &test_util::get_data_dir("tests/csv/basic.csv")
-        .display()
-        .to_string();
-    let csv_conf = CsvConfigBuilder::default()
-        .batch_size(test_util::TEST_BATCH_SIZE)
-        .file_schema(schema.clone())
-        .build()
-        .unwrap();
-
-    let csv_opener = CsvOpener::new(csv_conf, store, CompressionType::Uncompressed);
-
-    let tests = [
-        Test {
-            config: scan_config(schema.clone(), None, path),
-            opener: csv_opener.clone(),
-            expected: vec![
-                "+-----+-------+",
-                "| num | str   |",
-                "+-----+-------+",
-                "| 5   | test  |",
-                "| 2   | hello |",
-                "| 4   | foo   |",
-                "+-----+-------+",
-            ],
-        },
-        Test {
-            config: scan_config(schema.clone(), Some(1), path),
-            opener: csv_opener.clone(),
-            expected: vec![
-                "+-----+------+",
-                "| num | str  |",
-                "+-----+------+",
-                "| 5   | test |",
-                "+-----+------+",
-            ],
-        },
-    ];
-
-    for test in tests {
-        test.run().await;
-    }
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn test_parquet_exec() {
-    let store = test_store("/");
-
-    let schema = test_basic_schema();
-
-    let path = &test_util::get_data_dir("tests/parquet/basic.parquet")
-        .display()
-        .to_string();
-    let base_config = scan_config(schema.clone(), None, path);
-
-    let exec = ParquetExec::new(base_config, None, None)
-        .with_parquet_file_reader_factory(Arc::new(DefaultParquetFileReaderFactory::new(store)));
-
-    let ctx = SessionContext::new();
-
-    let context = Arc::new(TaskContext::from(&ctx));
-
-    // The stream batch size can be set by ctx.session_config.batch_size
-    let result = exec
-        .execute(0, context)
-        .unwrap()
-        .map(|b| b.unwrap())
-        .collect::<Vec<_>>()
-        .await;
-
-    assert_batches_eq!(
-        vec![
-            "+-----+-------+",
-            "| num | str   |",
-            "+-----+-------+",
-            "| 5   | test  |",
-            "| 2   | hello |",
-            "| 4   | foo   |",
-            "+-----+-------+",
-        ],
-        &result
-    );
-}
-
-#[test]
-fn test_format() {
-    let value = [(FORMAT_TYPE.to_string(), "csv".to_string())]
-        .into_iter()
-        .collect::<HashMap<_, _>>();
-
-    assert_matches!(Format::try_from(&value).unwrap(), Format::Csv(_));
-
-    let value = [(FORMAT_TYPE.to_string(), "Parquet".to_string())]
-        .into_iter()
-        .collect::<HashMap<_, _>>();
-
-    assert_matches!(Format::try_from(&value).unwrap(), Format::Parquet(_));
-
-    let value = [(FORMAT_TYPE.to_string(), "JSON".to_string())]
-        .into_iter()
-        .collect::<HashMap<_, _>>();
-
-    assert_matches!(Format::try_from(&value).unwrap(), Format::Json(_));
-
-    let value = [(FORMAT_TYPE.to_string(), "Foobar".to_string())]
-        .into_iter()
-        .collect::<HashMap<_, _>>();
-
-    assert_matches!(
-        Format::try_from(&value).unwrap_err(),
-        error::Error::UnsupportedFormat { .. }
-    );
-
-    let value = HashMap::new();
-
-    assert_matches!(Format::try_from(&value).unwrap(), Format::Parquet(_));
-}

src/common/datasource/src/lib.rs

@@ -12,17 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![feature(assert_matches)]
-
-pub mod buffered_writer;
 pub mod compression;
 pub mod error;
 pub mod file_format;
 pub mod lister;
 pub mod object_store;
-pub mod share_buffer;
-#[cfg(test)]
 pub mod test_util;
-#[cfg(test)]
-pub mod tests;
 pub mod util;

src/common/datasource/src/object_store.rs

@@ -27,7 +27,7 @@ use crate::error::{self, Result};
 pub const FS_SCHEMA: &str = "FS";
 pub const S3_SCHEMA: &str = "S3";
 
-/// Returns (schema, Option<host>, path)
+/// parse url returns (schema,Option<host>,path)
 pub fn parse_url(url: &str) -> Result<(String, Option<String>, String)> {
     let parsed_url = Url::parse(url);
     match parsed_url {
@@ -43,7 +43,7 @@ pub fn parse_url(url: &str) -> Result<(String, Option<String>, String)> {
     }
 }
 
-pub fn build_backend(url: &str, connection: &HashMap<String, String>) -> Result<ObjectStore> {
+pub fn build_backend(url: &str, connection: HashMap<String, String>) -> Result<ObjectStore> {
     let (schema, host, _path) = parse_url(url)?;
 
     match schema.to_uppercase().as_str() {

src/common/datasource/src/object_store/s3.rs

@@ -20,17 +20,17 @@ use snafu::ResultExt;
 
 use crate::error::{self, Result};
 
-const ENDPOINT_URL: &str = "endpoint_url";
-const ACCESS_KEY_ID: &str = "access_key_id";
-const SECRET_ACCESS_KEY: &str = "secret_access_key";
-const SESSION_TOKEN: &str = "session_token";
-const REGION: &str = "region";
-const ENABLE_VIRTUAL_HOST_STYLE: &str = "enable_virtual_host_style";
+const ENDPOINT_URL: &str = "ENDPOINT_URL";
+const ACCESS_KEY_ID: &str = "ACCESS_KEY_ID";
+const SECRET_ACCESS_KEY: &str = "SECRET_ACCESS_KEY";
+const SESSION_TOKEN: &str = "SESSION_TOKEN";
+const REGION: &str = "REGION";
+const ENABLE_VIRTUAL_HOST_STYLE: &str = "ENABLE_VIRTUAL_HOST_STYLE";
 
 pub fn build_s3_backend(
     host: &str,
     path: &str,
-    connection: &HashMap<String, String>,
+    connection: HashMap<String, String>,
 ) -> Result<ObjectStore> {
     let mut builder = S3::default();
 

src/common/datasource/src/share_buffer.rs

@@ -1,46 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::io::Write;
-use std::sync::{Arc, Mutex};
-
-use bytes::{BufMut, BytesMut};
-
-#[derive(Clone, Default)]
-pub struct SharedBuffer {
-    pub buffer: Arc<Mutex<BytesMut>>,
-}
-
-impl SharedBuffer {
-    pub fn with_capacity(size: usize) -> Self {
-        Self {
-            buffer: Arc::new(Mutex::new(BytesMut::with_capacity(size))),
-        }
-    }
-}
-
-impl Write for SharedBuffer {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        let len = buf.len();
-        let mut buffer = self.buffer.lock().unwrap();
-        buffer.put_slice(buf);
-        Ok(len)
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        // This flush implementation is intentionally left to blank.
-        // The actual flush is in `BufferedWriter::try_flush`
-        Ok(())
-    }
-}

src/common/datasource/src/test_util.rs

@@ -13,24 +13,11 @@
 // limitations under the License.
 
 use std::path::PathBuf;
-use std::sync::Arc;
 
-use arrow_schema::{DataType, Field, Schema, SchemaRef};
-use common_test_util::temp_dir::{create_temp_dir, TempDir};
-use datafusion::datasource::listing::PartitionedFile;
-use datafusion::datasource::object_store::ObjectStoreUrl;
-use datafusion::physical_plan::file_format::{FileScanConfig, FileStream};
-use datafusion::physical_plan::metrics::ExecutionPlanMetricsSet;
+use arrow_schema::SchemaRef;
 use object_store::services::Fs;
 use object_store::ObjectStore;
 
-use crate::compression::CompressionType;
-use crate::file_format::csv::{stream_to_csv, CsvConfigBuilder, CsvOpener};
-use crate::file_format::json::{stream_to_json, JsonOpener};
-use crate::test_util;
-
-pub const TEST_BATCH_SIZE: usize = 100;
-
 pub fn get_data_dir(path: &str) -> PathBuf {
     // https://doc.rust-lang.org/cargo/reference/environment-variables.html
     let dir = env!("CARGO_MANIFEST_DIR");
@@ -38,7 +25,7 @@ pub fn get_data_dir(path: &str) -> PathBuf {
     PathBuf::from(dir).join(path)
 }
 
-pub fn format_schema(schema: Schema) -> Vec<String> {
+pub fn format_schema(schema: SchemaRef) -> Vec<String> {
     schema
         .fields()
         .iter()
@@ -59,117 +46,3 @@ pub fn test_store(root: &str) -> ObjectStore {
 
     ObjectStore::new(builder).unwrap().finish()
 }
-
-pub fn test_tmp_store(root: &str) -> (ObjectStore, TempDir) {
-    let dir = create_temp_dir(root);
-
-    let mut builder = Fs::default();
-    builder.root("/");
-
-    (ObjectStore::new(builder).unwrap().finish(), dir)
-}
-
-pub fn test_basic_schema() -> SchemaRef {
-    let schema = Schema::new(vec![
-        Field::new("num", DataType::Int64, false),
-        Field::new("str", DataType::Utf8, false),
-    ]);
-    Arc::new(schema)
-}
-
-pub fn scan_config(file_schema: SchemaRef, limit: Option<usize>, filename: &str) -> FileScanConfig {
-    FileScanConfig {
-        object_store_url: ObjectStoreUrl::parse("empty://").unwrap(), // won't be used
-        file_schema,
-        file_groups: vec![vec![PartitionedFile::new(filename.to_string(), 10)]],
-        statistics: Default::default(),
-        projection: None,
-        limit,
-        table_partition_cols: vec![],
-        output_ordering: None,
-        infinite_source: false,
-    }
-}
-
-pub async fn setup_stream_to_json_test(origin_path: &str, threshold: impl Fn(usize) -> usize) {
-    let store = test_store("/");
-
-    let schema = test_basic_schema();
-
-    let json_opener = JsonOpener::new(
-        test_util::TEST_BATCH_SIZE,
-        schema.clone(),
-        store.clone(),
-        CompressionType::Uncompressed,
-    );
-
-    let size = store.read(origin_path).await.unwrap().len();
-
-    let config = scan_config(schema.clone(), None, origin_path);
-
-    let stream = FileStream::new(&config, 0, json_opener, &ExecutionPlanMetricsSet::new()).unwrap();
-
-    let (tmp_store, dir) = test_tmp_store("test_stream_to_json");
-
-    let output_path = format!("{}/{}", dir.path().display(), "output");
-
-    stream_to_json(
-        Box::pin(stream),
-        tmp_store.clone(),
-        &output_path,
-        threshold(size),
-    )
-    .await
-    .unwrap();
-
-    let written = tmp_store.read(&output_path).await.unwrap();
-    let origin = store.read(origin_path).await.unwrap();
-
-    // ignores `\n`
-    assert_eq!(
-        String::from_utf8_lossy(&written).trim_end_matches('\n'),
-        String::from_utf8_lossy(&origin).trim_end_matches('\n'),
-    )
-}
-
-pub async fn setup_stream_to_csv_test(origin_path: &str, threshold: impl Fn(usize) -> usize) {
-    let store = test_store("/");
-
-    let schema = test_basic_schema();
-
-    let csv_conf = CsvConfigBuilder::default()
-        .batch_size(test_util::TEST_BATCH_SIZE)
-        .file_schema(schema.clone())
-        .build()
-        .unwrap();
-
-    let csv_opener = CsvOpener::new(csv_conf, store.clone(), CompressionType::Uncompressed);
-
-    let size = store.read(origin_path).await.unwrap().len();
-
-    let config = scan_config(schema.clone(), None, origin_path);
-
-    let stream = FileStream::new(&config, 0, csv_opener, &ExecutionPlanMetricsSet::new()).unwrap();
-
-    let (tmp_store, dir) = test_tmp_store("test_stream_to_csv");
-
-    let output_path = format!("{}/{}", dir.path().display(), "output");
-
-    stream_to_csv(
-        Box::pin(stream),
-        tmp_store.clone(),
-        &output_path,
-        threshold(size),
-    )
-    .await
-    .unwrap();
-
-    let written = tmp_store.read(&output_path).await.unwrap();
-    let origin = store.read(origin_path).await.unwrap();
-
-    // ignores `\n`
-    assert_eq!(
-        String::from_utf8_lossy(&written).trim_end_matches('\n'),
-        String::from_utf8_lossy(&origin).trim_end_matches('\n'),
-    )
-}

src/common/datasource/src/tests.rs

@@ -1,61 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use crate::test_util;
-
-#[tokio::test]
-async fn test_stream_to_json() {
-    // A small threshold
-    // Triggers the flush each writes
-    test_util::setup_stream_to_json_test(
-        &test_util::get_data_dir("tests/json/basic.json")
-            .display()
-            .to_string(),
-        |size| size / 2,
-    )
-    .await;
-
-    // A large threshold
-    // Only triggers the flush at last
-    test_util::setup_stream_to_json_test(
-        &test_util::get_data_dir("tests/json/basic.json")
-            .display()
-            .to_string(),
-        |size| size * 2,
-    )
-    .await;
-}
-
-#[tokio::test]
-async fn test_stream_to_csv() {
-    // A small threshold
-    // Triggers the flush each writes
-    test_util::setup_stream_to_csv_test(
-        &test_util::get_data_dir("tests/csv/basic.csv")
-            .display()
-            .to_string(),
-        |size| size / 2,
-    )
-    .await;
-
-    // A large threshold
-    // Only triggers the flush at last
-    test_util::setup_stream_to_csv_test(
-        &test_util::get_data_dir("tests/csv/basic.csv")
-            .display()
-            .to_string(),
-        |size| size * 2,
-    )
-    .await;
-}

src/common/datasource/tests/csv/type_cast.csv

@@ -1,6 +0,0 @@
-hostname,environment,usage_user,usage_system,usage_idle,usage_nice,usage_iowait,usage_irq,usage_softirq,usage_steal,usage_guest,usage_guest_nice,ts
-host_0,test,32,58,36,72,61,21,53,12,59,72,2023-04-01T00:00:00+00:00
-host_1,staging,12,32,50,84,19,73,38,37,72,2,2023-04-01T00:00:00+00:00
-host_2,test,98,5,40,95,64,39,21,63,53,94,2023-04-01T00:00:00+00:00
-host_3,test,98,95,7,48,99,67,14,86,36,23,2023-04-01T00:00:00+00:00
-host_4,test,32,44,11,53,64,9,17,39,20,7,2023-04-01T00:00:00+00:00

src/common/datasource/tests/json/basic.json

@@ -1,3 +0,0 @@
-{"num":5,"str":"test"}
-{"num":2,"str":"hello"}
-{"num":4,"str":"foo"}

src/common/error/src/status_code.rs

@@ -33,8 +33,6 @@ pub enum StatusCode {
     Internal = 1003,
     /// Invalid arguments.
     InvalidArguments = 1004,
-    /// The task is cancelled.
-    Cancelled = 1005,
     // ====== End of common status code ================
 
     // ====== Begin of SQL related status code =========
@@ -85,12 +83,10 @@ pub enum StatusCode {
 }
 
 impl StatusCode {
-    /// Returns `true` if `code` is success.
     pub fn is_success(code: u32) -> bool {
         Self::Success as u32 == code
     }
 
-    /// Returns `true` if the error with this code is retryable.
     pub fn is_retryable(&self) -> bool {
         match self {
             StatusCode::StorageUnavailable
@@ -102,7 +98,6 @@ impl StatusCode {
             | StatusCode::Unsupported
             | StatusCode::Unexpected
             | StatusCode::InvalidArguments
-            | StatusCode::Cancelled
             | StatusCode::InvalidSyntax
             | StatusCode::PlanQuery
             | StatusCode::EngineExecuteQuery
@@ -119,36 +114,6 @@ impl StatusCode {
             | StatusCode::AccessDenied => false,
         }
     }
-
-    /// Returns `true` if we should print an error log for an error with
-    /// this status code.
-    pub fn should_log_error(&self) -> bool {
-        match self {
-            StatusCode::Unknown
-            | StatusCode::Unsupported
-            | StatusCode::Unexpected
-            | StatusCode::Internal
-            | StatusCode::Cancelled
-            | StatusCode::PlanQuery
-            | StatusCode::EngineExecuteQuery
-            | StatusCode::StorageUnavailable
-            | StatusCode::RuntimeResourcesExhausted => true,
-            StatusCode::Success
-            | StatusCode::InvalidArguments
-            | StatusCode::InvalidSyntax
-            | StatusCode::TableAlreadyExists
-            | StatusCode::TableNotFound
-            | StatusCode::TableColumnNotFound
-            | StatusCode::TableColumnExists
-            | StatusCode::DatabaseNotFound
-            | StatusCode::UserNotFound
-            | StatusCode::UnsupportedPasswordType
-            | StatusCode::UserPasswordMismatch
-            | StatusCode::AuthHeaderNotFound
-            | StatusCode::InvalidAuthHeader
-            | StatusCode::AccessDenied => false,
-        }
-    }
 }
 
 impl fmt::Display for StatusCode {

src/common/function-macro/Cargo.toml

@@ -8,8 +8,6 @@ license.workspace = true
 proc-macro = true
 
 [dependencies]
-common-telemetry = { path = "../telemetry" }
-backtrace = "0.3"
 quote = "1.0"
 syn = "1.0"
 proc-macro2 = "1.0"

src/common/function-macro/src/lib.rs

@@ -15,13 +15,11 @@
 mod range_fn;
 
 use proc_macro::TokenStream;
-use quote::{quote, quote_spanned, ToTokens};
+use quote::{quote, quote_spanned};
 use range_fn::process_range_fn;
 use syn::parse::Parser;
 use syn::spanned::Spanned;
-use syn::{
-    parse_macro_input, AttributeArgs, DeriveInput, ItemFn, ItemStruct, Lit, Meta, NestedMeta,
-};
+use syn::{parse_macro_input, DeriveInput, ItemStruct};
 
 /// Make struct implemented trait [AggrFuncTypeStore], which is necessary when writing UDAF.
 /// This derive macro is expect to be used along with attribute macro [as_aggr_func_creator].
@@ -116,109 +114,3 @@ pub fn as_aggr_func_creator(_args: TokenStream, input: TokenStream) -> TokenStre
 pub fn range_fn(args: TokenStream, input: TokenStream) -> TokenStream {
     process_range_fn(args, input)
 }
-
-/// Attribute macro to print the caller to the annotated function.
-/// The caller is printed as its filename and the call site line number.
-///
-/// This macro works like this: inject the tracking codes as the first statement to the annotated
-/// function body. The tracking codes use [backtrace-rs](https://crates.io/crates/backtrace) to get
-/// the callers. So you must dependent on the `backtrace-rs` crate.
-///
-/// # Arguments
-/// - `depth`: The max depth of call stack to print. Optional, defaults to 1.
-///
-/// # Example
-/// ```rust, ignore
-///
-/// #[print_caller(depth = 3)]
-/// fn foo() {}
-/// ```
-#[proc_macro_attribute]
-pub fn print_caller(args: TokenStream, input: TokenStream) -> TokenStream {
-    let mut depth = 1;
-
-    let args = parse_macro_input!(args as AttributeArgs);
-    for meta in args.iter() {
-        if let NestedMeta::Meta(Meta::NameValue(name_value)) = meta {
-            let ident = name_value
-                .path
-                .get_ident()
-                .expect("Expected an ident!")
-                .to_string();
-            if ident == "depth" {
-                let Lit::Int(i) = &name_value.lit else { panic!("Expected 'depth' to be a valid int!") };
-                depth = i.base10_parse::<usize>().expect("Invalid 'depth' value");
-                break;
-            }
-        }
-    }
-
-    let tokens: TokenStream = quote! {
-        {
-            let curr_file = file!();
-
-            let bt = backtrace::Backtrace::new();
-            let call_stack = bt
-                .frames()
-                .iter()
-                .skip_while(|f| {
-                    !f.symbols().iter().any(|s| {
-                        s.filename()
-                            .map(|p| p.ends_with(curr_file))
-                            .unwrap_or(false)
-                    })
-                })
-                .skip(1)
-                .take(#depth);
-
-            let call_stack = call_stack
-                .map(|f| {
-                    f.symbols()
-                        .iter()
-                        .map(|s| {
-                            let filename = s
-                                .filename()
-                                .map(|p| format!("{:?}", p))
-                                .unwrap_or_else(|| "unknown".to_string());
-
-                            let lineno = s
-                                .lineno()
-                                .map(|l| format!("{}", l))
-                                .unwrap_or_else(|| "unknown".to_string());
-
-                            format!("filename: {}, lineno: {}", filename, lineno)
-                        })
-                        .collect::<Vec<String>>()
-                        .join(", ")
-                })
-                .collect::<Vec<_>>();
-
-            match call_stack.len() {
-                0 => common_telemetry::info!("unable to find call stack"),
-                1 => common_telemetry::info!("caller: {}", call_stack[0]),
-                _ => {
-                    let mut s = String::new();
-                    s.push_str("[\n");
-                    for e in call_stack {
-                        s.push_str("\t");
-                        s.push_str(&e);
-                        s.push_str("\n");
-                    }
-                    s.push_str("]");
-                    common_telemetry::info!("call stack: {}", s)
-                }
-            }
-        }
-    }
-    .into();
-
-    let stmt = match syn::parse(tokens) {
-        Ok(stmt) => stmt,
-        Err(e) => return e.into_compile_error().into(),
-    };
-
-    let mut item = parse_macro_input!(input as ItemFn);
-    item.block.stmts.insert(0, stmt);
-
-    item.into_token_stream().into()
-}

src/common/function/src/scalars/timestamp/to_unixtime.rs

@@ -16,16 +16,13 @@ use std::fmt;
 use std::str::FromStr;
 use std::sync::Arc;
 
-use common_query::error::{InvalidFuncArgsSnafu, Result, UnsupportedInputDataTypeSnafu};
+use common_query::error::{self, Result, UnsupportedInputDataTypeSnafu};
 use common_query::prelude::{Signature, Volatility};
 use common_time::timestamp::TimeUnit;
 use common_time::Timestamp;
 use datatypes::prelude::ConcreteDataType;
-use datatypes::types::TimestampType;
-use datatypes::vectors::{
-    Int64Vector, StringVector, TimestampMicrosecondVector, TimestampMillisecondVector,
-    TimestampNanosecondVector, TimestampSecondVector, Vector, VectorRef,
-};
+use datatypes::types::StringType;
+use datatypes::vectors::{Int64Vector, StringVector, Vector, VectorRef};
 use snafu::ensure;
 
 use crate::scalars::function::{Function, FunctionContext};
@@ -45,33 +42,18 @@ fn convert_to_seconds(arg: &str) -> Option<i64> {
     }
 }
 
-fn process_vector(vector: &dyn Vector) -> Vec<Option<i64>> {
-    (0..vector.len())
-        .map(|i| paste::expr!((vector.get(i)).as_timestamp().map(|ts| ts.value())))
-        .collect::<Vec<Option<i64>>>()
-}
-
 impl Function for ToUnixtimeFunction {
     fn name(&self) -> &str {
         NAME
     }
 
     fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
-        Ok(ConcreteDataType::int64_datatype())
+        Ok(ConcreteDataType::timestamp_second_datatype())
     }
 
     fn signature(&self) -> Signature {
-        Signature::uniform(
-            1,
-            vec![
-                ConcreteDataType::string_datatype(),
-                ConcreteDataType::int32_datatype(),
-                ConcreteDataType::int64_datatype(),
-                ConcreteDataType::timestamp_second_datatype(),
-                ConcreteDataType::timestamp_millisecond_datatype(),
-                ConcreteDataType::timestamp_microsecond_datatype(),
-                ConcreteDataType::timestamp_nanosecond_datatype(),
-            ],
+        Signature::exact(
+            vec![ConcreteDataType::String(StringType)],
             Volatility::Immutable,
         )
     }
@@ -79,7 +61,7 @@ impl Function for ToUnixtimeFunction {
     fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 1,
-            InvalidFuncArgsSnafu {
+            error::InvalidFuncArgsSnafu {
                 err_msg: format!(
                     "The length of the args is not correct, expect exactly one, have: {}",
                     columns.len()
@@ -97,42 +79,6 @@ impl Function for ToUnixtimeFunction {
                         .collect::<Vec<_>>(),
                 )))
             }
-            ConcreteDataType::Int64(_) | ConcreteDataType::Int32(_) => {
-                let array = columns[0].to_arrow_array();
-                Ok(Arc::new(Int64Vector::try_from_arrow_array(&array).unwrap()))
-            }
-            ConcreteDataType::Timestamp(ts) => {
-                let array = columns[0].to_arrow_array();
-                let value = match ts {
-                    TimestampType::Second(_) => {
-                        let vector = paste::expr!(TimestampSecondVector::try_from_arrow_array(
-                            array
-                        )
-                        .unwrap());
-                        process_vector(&vector)
-                    }
-                    TimestampType::Millisecond(_) => {
-                        let vector = paste::expr!(
-                            TimestampMillisecondVector::try_from_arrow_array(array).unwrap()
-                        );
-                        process_vector(&vector)
-                    }
-                    TimestampType::Microsecond(_) => {
-                        let vector = paste::expr!(
-                            TimestampMicrosecondVector::try_from_arrow_array(array).unwrap()
-                        );
-                        process_vector(&vector)
-                    }
-                    TimestampType::Nanosecond(_) => {
-                        let vector = paste::expr!(TimestampNanosecondVector::try_from_arrow_array(
-                            array
-                        )
-                        .unwrap());
-                        process_vector(&vector)
-                    }
-                };
-                Ok(Arc::new(Int64Vector::from(value)))
-            }
             _ => UnsupportedInputDataTypeSnafu {
                 function: NAME,
                 datatypes: columns.iter().map(|c| c.data_type()).collect::<Vec<_>>(),
@@ -151,37 +97,28 @@ impl fmt::Display for ToUnixtimeFunction {
 #[cfg(test)]
 mod tests {
     use common_query::prelude::TypeSignature;
-    use datatypes::prelude::{ConcreteDataType, ScalarVectorBuilder};
-    use datatypes::scalars::ScalarVector;
-    use datatypes::timestamp::TimestampSecond;
+    use datatypes::prelude::ConcreteDataType;
+    use datatypes::types::StringType;
     use datatypes::value::Value;
-    use datatypes::vectors::{StringVector, TimestampSecondVector};
+    use datatypes::vectors::StringVector;
 
     use super::{ToUnixtimeFunction, *};
     use crate::scalars::Function;
 
     #[test]
-    fn test_string_to_unixtime() {
+    fn test_to_unixtime() {
         let f = ToUnixtimeFunction::default();
         assert_eq!("to_unixtime", f.name());
         assert_eq!(
-            ConcreteDataType::int64_datatype(),
+            ConcreteDataType::timestamp_second_datatype(),
             f.return_type(&[]).unwrap()
         );
 
         assert!(matches!(f.signature(),
-        Signature {
-                type_signature: TypeSignature::Uniform(1, valid_types),
-                volatility: Volatility::Immutable
-            } if  valid_types == vec![
-                ConcreteDataType::string_datatype(),
-                ConcreteDataType::int32_datatype(),
-                ConcreteDataType::int64_datatype(),
-                ConcreteDataType::timestamp_second_datatype(),
-                ConcreteDataType::timestamp_millisecond_datatype(),
-                ConcreteDataType::timestamp_microsecond_datatype(),
-                ConcreteDataType::timestamp_nanosecond_datatype(),
-            ]
+                         Signature {
+                            type_signature: TypeSignature::Exact(valid_types),
+                            volatility: Volatility::Immutable
+                         } if  valid_types == vec![ConcreteDataType::String(StringType)]
         ));
 
         let times = vec![
@@ -208,106 +145,4 @@ mod tests {
             }
         }
     }
-
-    #[test]
-    fn test_int_to_unixtime() {
-        let f = ToUnixtimeFunction::default();
-        assert_eq!("to_unixtime", f.name());
-        assert_eq!(
-            ConcreteDataType::int64_datatype(),
-            f.return_type(&[]).unwrap()
-        );
-
-        assert!(matches!(f.signature(),
-        Signature {
-                type_signature: TypeSignature::Uniform(1, valid_types),
-                volatility: Volatility::Immutable
-            } if  valid_types == vec![
-                ConcreteDataType::string_datatype(),
-                ConcreteDataType::int32_datatype(),
-                ConcreteDataType::int64_datatype(),
-                ConcreteDataType::timestamp_second_datatype(),
-                ConcreteDataType::timestamp_millisecond_datatype(),
-                ConcreteDataType::timestamp_microsecond_datatype(),
-                ConcreteDataType::timestamp_nanosecond_datatype(),
-            ]
-        ));
-
-        let times = vec![Some(3_i64), None, Some(5_i64), None];
-        let results = vec![Some(3), None, Some(5), None];
-        let args: Vec<VectorRef> = vec![Arc::new(Int64Vector::from(times.clone()))];
-        let vector = f.eval(FunctionContext::default(), &args).unwrap();
-        assert_eq!(4, vector.len());
-        for (i, _t) in times.iter().enumerate() {
-            let v = vector.get(i);
-            if i == 1 || i == 3 {
-                assert_eq!(Value::Null, v);
-                continue;
-            }
-            match v {
-                Value::Int64(ts) => {
-                    assert_eq!(ts, (*results.get(i).unwrap()).unwrap());
-                }
-                _ => unreachable!(),
-            }
-        }
-    }
-
-    #[test]
-    fn test_timestamp_to_unixtime() {
-        let f = ToUnixtimeFunction::default();
-        assert_eq!("to_unixtime", f.name());
-        assert_eq!(
-            ConcreteDataType::int64_datatype(),
-            f.return_type(&[]).unwrap()
-        );
-
-        assert!(matches!(f.signature(),
-        Signature {
-                type_signature: TypeSignature::Uniform(1, valid_types),
-                volatility: Volatility::Immutable
-            } if  valid_types == vec![
-                ConcreteDataType::string_datatype(),
-                ConcreteDataType::int32_datatype(),
-                ConcreteDataType::int64_datatype(),
-                ConcreteDataType::timestamp_second_datatype(),
-                ConcreteDataType::timestamp_millisecond_datatype(),
-                ConcreteDataType::timestamp_microsecond_datatype(),
-                ConcreteDataType::timestamp_nanosecond_datatype(),
-            ]
-        ));
-
-        let times: Vec<Option<TimestampSecond>> = vec![
-            Some(TimestampSecond::new(123)),
-            None,
-            Some(TimestampSecond::new(42)),
-            None,
-        ];
-        let results = vec![Some(123), None, Some(42), None];
-        let ts_vector: TimestampSecondVector = build_vector_from_slice(&times);
-        let args: Vec<VectorRef> = vec![Arc::new(ts_vector)];
-        let vector = f.eval(FunctionContext::default(), &args).unwrap();
-        assert_eq!(4, vector.len());
-        for (i, _t) in times.iter().enumerate() {
-            let v = vector.get(i);
-            if i == 1 || i == 3 {
-                assert_eq!(Value::Null, v);
-                continue;
-            }
-            match v {
-                Value::Int64(ts) => {
-                    assert_eq!(ts, (*results.get(i).unwrap()).unwrap());
-                }
-                _ => unreachable!(),
-            }
-        }
-    }
-
-    fn build_vector_from_slice<T: ScalarVector>(items: &[Option<T::RefItem<'_>>]) -> T {
-        let mut builder = T::Builder::with_capacity(items.len());
-        for item in items {
-            builder.push(*item);
-        }
-        builder.finish()
-    }
 }

src/common/grpc-expr/Cargo.toml

@@ -17,6 +17,3 @@ common-time = { path = "../time" }
 datatypes = { path = "../../datatypes" }
 snafu = { version = "0.7", features = ["backtraces"] }
 table = { path = "../../table" }
-
-[dev-dependencies]
-paste = "1.0"

src/common/grpc-expr/src/alter.rs

@@ -12,12 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use api::v1::add_column::location::LocationType;
-use api::v1::add_column::Location;
 use api::v1::alter_expr::Kind;
 use api::v1::{column_def, AlterExpr, CreateTableExpr, DropColumns, RenameTable};
 use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
-use common_query::AddColumnLocation;
 use datatypes::schema::{ColumnSchema, RawSchema};
 use snafu::{ensure, OptionExt, ResultExt};
 use table::metadata::TableId;
@@ -27,12 +24,9 @@ use table::requests::{
 
 use crate::error::{
     ColumnNotFoundSnafu, InvalidColumnDefSnafu, MissingFieldSnafu, MissingTimestampColumnSnafu,
-    Result, UnknownLocationTypeSnafu, UnrecognizedTableOptionSnafu,
+    Result, UnrecognizedTableOptionSnafu,
 };
 
-const LOCATION_TYPE_FIRST: i32 = LocationType::First as i32;
-const LOCATION_TYPE_AFTER: i32 = LocationType::After as i32;
-
 /// Convert an [`AlterExpr`] to an [`AlterTableRequest`]
 pub fn alter_expr_to_request(expr: AlterExpr) -> Result<AlterTableRequest> {
     let catalog_name = expr.catalog_name;
@@ -56,7 +50,6 @@ pub fn alter_expr_to_request(expr: AlterExpr) -> Result<AlterTableRequest> {
                     Ok(AddColumnRequest {
                         column_schema: schema,
                         is_key: ac.is_key,
-                        location: parse_location(ac.location)?,
                     })
                 })
                 .collect::<Result<Vec<_>>>()?;
@@ -99,7 +92,7 @@ pub fn alter_expr_to_request(expr: AlterExpr) -> Result<AlterTableRequest> {
     }
 }
 
-pub fn create_table_schema(expr: &CreateTableExpr, require_time_index: bool) -> Result<RawSchema> {
+pub fn create_table_schema(expr: &CreateTableExpr) -> Result<RawSchema> {
     let column_schemas = expr
         .column_defs
         .iter()
@@ -108,17 +101,14 @@ pub fn create_table_schema(expr: &CreateTableExpr, require_time_index: bool) ->
         })
         .collect::<Result<Vec<ColumnSchema>>>()?;
 
-    // allow external table schema without the time index
-    if require_time_index {
-        ensure!(
-            column_schemas
-                .iter()
-                .any(|column| column.name == expr.time_index),
-            MissingTimestampColumnSnafu {
-                msg: format!("CreateExpr: {expr:?}")
-            }
-        );
-    }
+    ensure!(
+        column_schemas
+            .iter()
+            .any(|column| column.name == expr.time_index),
+        MissingTimestampColumnSnafu {
+            msg: format!("CreateExpr: {expr:?}")
+        }
+    );
 
     let column_schemas = column_schemas
         .into_iter()
@@ -137,9 +127,8 @@ pub fn create_table_schema(expr: &CreateTableExpr, require_time_index: bool) ->
 pub fn create_expr_to_request(
     table_id: TableId,
     expr: CreateTableExpr,
-    require_time_index: bool,
 ) -> Result<CreateTableRequest> {
-    let schema = create_table_schema(&expr, require_time_index)?;
+    let schema = create_table_schema(&expr)?;
     let primary_key_indices = expr
         .primary_keys
         .iter()
@@ -170,10 +159,10 @@ pub fn create_expr_to_request(
         Some(expr.desc)
     };
 
-    let region_numbers = if expr.region_numbers.is_empty() {
+    let region_ids = if expr.region_ids.is_empty() {
         vec![0]
     } else {
-        expr.region_numbers
+        expr.region_ids
     };
 
     let table_options =
@@ -185,7 +174,7 @@ pub fn create_expr_to_request(
         table_name: expr.table_name,
         desc,
         schema,
-        region_numbers,
+        region_numbers: region_ids,
         primary_key_indices,
         create_if_not_exists: expr.create_if_not_exists,
         table_options,
@@ -193,26 +182,8 @@ pub fn create_expr_to_request(
     })
 }
 
-fn parse_location(location: Option<Location>) -> Result<Option<AddColumnLocation>> {
-    match location {
-        Some(Location {
-            location_type: LOCATION_TYPE_FIRST,
-            ..
-        }) => Ok(Some(AddColumnLocation::First)),
-        Some(Location {
-            location_type: LOCATION_TYPE_AFTER,
-            after_cloumn_name,
-        }) => Ok(Some(AddColumnLocation::After {
-            column_name: after_cloumn_name,
-        })),
-        Some(Location { location_type, .. }) => UnknownLocationTypeSnafu { location_type }.fail(),
-        None => Ok(None),
-    }
-}
-
 #[cfg(test)]
 mod tests {
-    use api::v1::add_column::location::LocationType;
     use api::v1::{AddColumn, AddColumns, ColumnDataType, ColumnDef, DropColumn};
     use datatypes::prelude::ConcreteDataType;
 
@@ -234,7 +205,6 @@ mod tests {
                         default_constraint: vec![],
                     }),
                     is_key: false,
-                    location: None,
                 }],
             })),
         };
@@ -254,80 +224,6 @@ mod tests {
             ConcreteDataType::float64_datatype(),
             add_column.column_schema.data_type
         );
-        assert_eq!(None, add_column.location);
-    }
-
-    #[test]
-    fn test_alter_expr_with_location_to_request() {
-        let expr = AlterExpr {
-            catalog_name: "".to_string(),
-            schema_name: "".to_string(),
-            table_name: "monitor".to_string(),
-
-            kind: Some(Kind::AddColumns(AddColumns {
-                add_columns: vec![
-                    AddColumn {
-                        column_def: Some(ColumnDef {
-                            name: "mem_usage".to_string(),
-                            datatype: ColumnDataType::Float64 as i32,
-                            is_nullable: false,
-                            default_constraint: vec![],
-                        }),
-                        is_key: false,
-                        location: Some(Location {
-                            location_type: LocationType::First.into(),
-                            after_cloumn_name: "".to_string(),
-                        }),
-                    },
-                    AddColumn {
-                        column_def: Some(ColumnDef {
-                            name: "cpu_usage".to_string(),
-                            datatype: ColumnDataType::Float64 as i32,
-                            is_nullable: false,
-                            default_constraint: vec![],
-                        }),
-                        is_key: false,
-                        location: Some(Location {
-                            location_type: LocationType::After.into(),
-                            after_cloumn_name: "ts".to_string(),
-                        }),
-                    },
-                ],
-            })),
-        };
-
-        let alter_request = alter_expr_to_request(expr).unwrap();
-        assert_eq!(alter_request.catalog_name, "");
-        assert_eq!(alter_request.schema_name, "");
-        assert_eq!("monitor".to_string(), alter_request.table_name);
-
-        let mut add_columns = match alter_request.alter_kind {
-            AlterKind::AddColumns { columns } => columns,
-            _ => unreachable!(),
-        };
-
-        let add_column = add_columns.pop().unwrap();
-        assert!(!add_column.is_key);
-        assert_eq!("cpu_usage", add_column.column_schema.name);
-        assert_eq!(
-            ConcreteDataType::float64_datatype(),
-            add_column.column_schema.data_type
-        );
-        assert_eq!(
-            Some(AddColumnLocation::After {
-                column_name: "ts".to_string()
-            }),
-            add_column.location
-        );
-
-        let add_column = add_columns.pop().unwrap();
-        assert!(!add_column.is_key);
-        assert_eq!("mem_usage", add_column.column_schema.name);
-        assert_eq!(
-            ConcreteDataType::float64_datatype(),
-            add_column.column_schema.data_type
-        );
-        assert_eq!(Some(AddColumnLocation::First), add_column.location);
     }
 
     #[test]