feat: opendal metrics

Signed-off-by: evenyag <realevenyag@gmail.com>

.cargo/config.toml

@@ -3,12 +3,3 @@ linker = "aarch64-linux-gnu-gcc"
 
 [alias]
 sqlness = "run --bin sqlness-runner --"
-
-[unstable.git]
-shallow_index = true
-shallow_deps = true
-[unstable.gitoxide]
-fetch = true
-checkout = true
-list_files = true
-internal_use_git2 = false

.github/CODEOWNERS

@@ -4,7 +4,7 @@
 
 * @GreptimeTeam/db-approver
 
-## [Module] Databse Engine
+## [Module] Database Engine
 /src/index @zhongzc
 /src/mito2 @evenyag @v0y4g3r @waynexia
 /src/query @evenyag

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

@@ -41,7 +41,14 @@ runs:
         username: ${{ inputs.dockerhub-image-registry-username }}
         password: ${{ inputs.dockerhub-image-registry-token }}
 
-    - name: Build and push dev-builder-ubuntu image
+    - name: Set up qemu for multi-platform builds
+      uses: docker/setup-qemu-action@v3
+      with:
+        platforms: linux/amd64,linux/arm64
+        # The latest version will lead to segmentation fault.
+        image: tonistiigi/binfmt:qemu-v7.0.0-28
+
+    - name: Build and push dev-builder-ubuntu image # Build image for amd64 and arm64 platform.
       shell: bash
       if: ${{ inputs.build-dev-builder-ubuntu == 'true' }}
       run: |
@@ -52,7 +59,7 @@ runs:
           IMAGE_NAMESPACE=${{ inputs.dockerhub-image-namespace }} \
           DEV_BUILDER_IMAGE_TAG=${{ inputs.version }}
 
-    - name: Build and push dev-builder-centos image
+    - name: Build and push dev-builder-centos image # Only build image for amd64 platform.
       shell: bash
       if: ${{ inputs.build-dev-builder-centos == 'true' }}
       run: |
@@ -69,8 +76,7 @@ runs:
       run: |
         make dev-builder \
           BASE_IMAGE=android \
+          BUILDX_MULTI_PLATFORM_BUILD=amd64 \
           IMAGE_REGISTRY=${{ inputs.dockerhub-image-registry }} \
           IMAGE_NAMESPACE=${{ inputs.dockerhub-image-namespace }} \
-          DEV_BUILDER_IMAGE_TAG=${{ inputs.version }} && \
-
-        docker push ${{ inputs.dockerhub-image-registry }}/${{ inputs.dockerhub-image-namespace }}/dev-builder-android:${{ inputs.version }}
+          DEV_BUILDER_IMAGE_TAG=${{ inputs.version }}

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

@@ -52,7 +52,7 @@ runs:
       uses: ./.github/actions/build-greptime-binary
       with:
         base-image: ubuntu
-        features: servers/dashboard,pg_kvbackend
+        features: servers/dashboard
         cargo-profile: ${{ inputs.cargo-profile }}
         artifacts-dir: greptime-linux-${{ inputs.arch }}-${{ inputs.version }}
         version: ${{ inputs.version }}
@@ -70,7 +70,7 @@ runs:
       if: ${{ inputs.arch == 'amd64' && inputs.dev-mode == 'false' }} # Builds greptime for centos if the host machine is amd64.
       with:
         base-image: centos
-        features: servers/dashboard,pg_kvbackend
+        features: servers/dashboard
         cargo-profile: ${{ inputs.cargo-profile }}
         artifacts-dir: greptime-linux-${{ inputs.arch }}-centos-${{ inputs.version }}
         version: ${{ inputs.version }}

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

@@ -47,7 +47,6 @@ runs:
       shell: pwsh
       run: make test sqlness-test
       env:
-        RUSTUP_WINDOWS_PATH_ADD_BIN: 1 # Workaround for https://github.com/nextest-rs/nextest/issues/1493
         RUST_BACKTRACE: 1
         SQLNESS_OPTS: "--preserve-state"
 

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

@@ -64,11 +64,11 @@ inputs:
   upload-max-retry-times:
     description: Max retry times for uploading artifacts to S3
     required: false
-    default: "20"
+    default: "30"
   upload-retry-timeout:
     description: Timeout for uploading artifacts to S3
     required: false
-    default: "30" # minutes
+    default: "120" # minutes
 runs:
   using: composite
   steps:

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

@@ -8,15 +8,15 @@ inputs:
     default: 2
     description: "Number of Datanode replicas"
   meta-replicas:
-    default: 1
+    default: 2
     description: "Number of Metasrv replicas"
-  image-registry: 
+  image-registry:
     default: "docker.io"
     description: "Image registry"
-  image-repository: 
+  image-repository:
     default: "greptime/greptimedb"
     description: "Image repository"
-  image-tag: 
+  image-tag:
     default: "latest"
     description: 'Image tag'
   etcd-endpoints:
@@ -32,12 +32,12 @@ runs:
   steps:
   - name: Install GreptimeDB operator
     uses: nick-fields/retry@v3
-    with: 
+    with:
       timeout_minutes: 3
       max_attempts: 3
       shell: bash
       command: |
-        helm repo add greptime https://greptimeteam.github.io/helm-charts/ 
+        helm repo add greptime https://greptimeteam.github.io/helm-charts/
         helm repo update
         helm upgrade \
           --install \
@@ -48,10 +48,10 @@ runs:
           --wait-for-jobs
   - name: Install GreptimeDB cluster
     shell: bash
-    run: | 
+    run: |
       helm upgrade \
         --install my-greptimedb \
-        --set meta.etcdEndpoints=${{ inputs.etcd-endpoints }} \
+        --set meta.backendStorage.etcd.endpoints=${{ inputs.etcd-endpoints }} \
         --set meta.enableRegionFailover=${{ inputs.enable-region-failover }} \
         --set image.registry=${{ inputs.image-registry }} \
         --set image.repository=${{ inputs.image-repository }}  \
@@ -59,7 +59,7 @@ runs:
         --set base.podTemplate.main.resources.requests.cpu=50m \
         --set base.podTemplate.main.resources.requests.memory=256Mi \
         --set base.podTemplate.main.resources.limits.cpu=2000m \
-        --set base.podTemplate.main.resources.limits.memory=2Gi \
+        --set base.podTemplate.main.resources.limits.memory=3Gi \
         --set frontend.replicas=${{ inputs.frontend-replicas }} \
         --set datanode.replicas=${{ inputs.datanode-replicas }} \
         --set meta.replicas=${{ inputs.meta-replicas }} \
@@ -72,7 +72,7 @@ runs:
   - name: Wait for GreptimeDB
     shell: bash
     run: |
-      while true; do 
+      while true; do
         PHASE=$(kubectl -n my-greptimedb get gtc my-greptimedb -o jsonpath='{.status.clusterPhase}')
         if [ "$PHASE" == "Running" ]; then
           echo "Cluster is ready"
@@ -86,10 +86,10 @@ runs:
   - name: Print GreptimeDB info
     if: always()
     shell: bash
-    run: | 
+    run: |
       kubectl get all --show-labels -n my-greptimedb
   - name: Describe Nodes
     if: always()
     shell: bash
-    run: | 
+    run: |
       kubectl describe nodes

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

@@ -2,13 +2,14 @@ meta:
   configData: |-
     [runtime]
     global_rt_size = 4
-    
+
     [wal]
     provider = "kafka"
     broker_endpoints = ["kafka.kafka-cluster.svc.cluster.local:9092"]
     num_topics = 3
+    auto_prune_interval = "30s"
+    trigger_flush_threshold = 100
 
-        
     [datanode]
     [datanode.client]
     timeout = "120s"
@@ -21,7 +22,7 @@ datanode:
     [wal]
     provider = "kafka"
     broker_endpoints = ["kafka.kafka-cluster.svc.cluster.local:9092"]
-    linger = "2ms"
+    overwrite_entry_start_id = true
 frontend:
   configData: |-
     [runtime]

.github/labeler.yaml

@@ -0,0 +1,15 @@
+ci:
+  - changed-files:
+      - any-glob-to-any-file: .github/**
+
+docker:
+  - changed-files:
+      - any-glob-to-any-file: docker/**
+
+documentation:
+  - changed-files:
+      - any-glob-to-any-file: docs/**
+
+dashboard:
+  - changed-files:
+      - any-glob-to-any-file: grafana/**

.github/scripts/check-version.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# Get current version
+CURRENT_VERSION=$1
+if [ -z "$CURRENT_VERSION" ]; then
+  echo "Error: Failed to get current version"
+  exit 1
+fi
+
+# Get the latest version from GitHub Releases
+API_RESPONSE=$(curl -s "https://api.github.com/repos/GreptimeTeam/greptimedb/releases/latest")
+
+if [ -z "$API_RESPONSE" ] || [ "$(echo "$API_RESPONSE" | jq -r '.message')" = "Not Found" ]; then
+  echo "Error: Failed to fetch latest version from GitHub"
+  exit 1
+fi
+
+# Get the latest version
+LATEST_VERSION=$(echo "$API_RESPONSE" | jq -r '.tag_name')
+
+if [ -z "$LATEST_VERSION" ] || [ "$LATEST_VERSION" = "null" ]; then
+  echo "Error: No valid version found in GitHub releases"
+  exit 1
+fi
+
+# Cleaned up version number format (removed possible 'v' prefix and -nightly suffix)
+CLEAN_CURRENT=$(echo "$CURRENT_VERSION" | sed 's/^v//' | sed 's/-nightly-.*//')
+CLEAN_LATEST=$(echo "$LATEST_VERSION" | sed 's/^v//' | sed 's/-nightly-.*//')
+
+echo "Current version: $CLEAN_CURRENT"
+echo "Latest release version: $CLEAN_LATEST"
+
+# Use sort -V to compare versions
+HIGHER_VERSION=$(printf "%s\n%s" "$CLEAN_CURRENT" "$CLEAN_LATEST" | sort -V | tail -n1)
+
+if [ "$HIGHER_VERSION" = "$CLEAN_CURRENT" ]; then
+  echo "Current version ($CLEAN_CURRENT) is NEWER than or EQUAL to latest ($CLEAN_LATEST)"
+  echo "should-push-latest-tag=true" >> $GITHUB_OUTPUT
+else
+  echo "Current version ($CLEAN_CURRENT) is OLDER than latest ($CLEAN_LATEST)"
+  echo "should-push-latest-tag=false" >> $GITHUB_OUTPUT
+fi

.github/scripts/create-version.sh

@@ -8,24 +8,25 @@ set -e
 # - If it's a nightly build, the version is 'nightly-YYYYMMDD-$(git rev-parse --short HEAD)', like 'nightly-20230712-e5b243c'.
 # create_version ${GIHUB_EVENT_NAME} ${NEXT_RELEASE_VERSION} ${NIGHTLY_RELEASE_PREFIX}
 function create_version() {
-  # Read from envrionment variables.
+  # Read from environment variables.
   if [ -z "$GITHUB_EVENT_NAME" ]; then
-      echo "GITHUB_EVENT_NAME is empty"
+      echo "GITHUB_EVENT_NAME is empty" >&2
       exit 1
   fi
 
   if [ -z "$NEXT_RELEASE_VERSION" ]; then
-      echo "NEXT_RELEASE_VERSION is empty"
-      exit 1
+      echo "NEXT_RELEASE_VERSION is empty, use version from Cargo.toml" >&2
+      # NOTE: Need a `v` prefix for the version string.
+      export NEXT_RELEASE_VERSION=v$(grep '^version = ' Cargo.toml | cut -d '"' -f 2 | head -n 1)
   fi
 
   if [ -z "$NIGHTLY_RELEASE_PREFIX" ]; then
-      echo "NIGHTLY_RELEASE_PREFIX is empty"
+      echo "NIGHTLY_RELEASE_PREFIX is empty" >&2
       exit 1
   fi
 
   # Reuse $NEXT_RELEASE_VERSION to identify whether it's a nightly build.
-  # It will be like 'nigtly-20230808-7d0d8dc6'.
+  # It will be like 'nightly-20230808-7d0d8dc6'.
   if [ "$NEXT_RELEASE_VERSION" = nightly ]; then
     echo "$NIGHTLY_RELEASE_PREFIX-$(date "+%Y%m%d")-$(git rev-parse --short HEAD)"
     exit 0
@@ -35,7 +36,7 @@ function create_version() {
   # It will be like 'dev-2023080819-f0e7216c'.
   if [ "$NEXT_RELEASE_VERSION" = dev ]; then
     if [ -z "$COMMIT_SHA" ]; then
-      echo "COMMIT_SHA is empty in dev build"
+      echo "COMMIT_SHA is empty in dev build" >&2
       exit 1
     fi
     echo "dev-$(date "+%Y%m%d-%s")-$(echo "$COMMIT_SHA" | cut -c1-8)"
@@ -45,7 +46,7 @@ function create_version() {
   # Note: Only output 'version=xxx' to stdout when everything is ok, so that it can be used in GitHub Actions Outputs.
   if [ "$GITHUB_EVENT_NAME" = push ]; then
     if [ -z "$GITHUB_REF_NAME" ]; then
-      echo "GITHUB_REF_NAME is empty in push event"
+      echo "GITHUB_REF_NAME is empty in push event" >&2
       exit 1
     fi
     echo "$GITHUB_REF_NAME"
@@ -54,15 +55,15 @@ function create_version() {
   elif [ "$GITHUB_EVENT_NAME" = schedule ]; then
     echo "$NEXT_RELEASE_VERSION-$NIGHTLY_RELEASE_PREFIX-$(date "+%Y%m%d")"
   else
-    echo "Unsupported GITHUB_EVENT_NAME: $GITHUB_EVENT_NAME"
+    echo "Unsupported GITHUB_EVENT_NAME: $GITHUB_EVENT_NAME" >&2
     exit 1
   fi
 }
 
 # You can run as following examples:
-#  GITHUB_EVENT_NAME=push NEXT_RELEASE_VERSION=v0.4.0 NIGHTLY_RELEASE_PREFIX=nigtly GITHUB_REF_NAME=v0.3.0 ./create-version.sh
-#  GITHUB_EVENT_NAME=workflow_dispatch NEXT_RELEASE_VERSION=v0.4.0 NIGHTLY_RELEASE_PREFIX=nigtly ./create-version.sh
-#  GITHUB_EVENT_NAME=schedule NEXT_RELEASE_VERSION=v0.4.0 NIGHTLY_RELEASE_PREFIX=nigtly ./create-version.sh
-#  GITHUB_EVENT_NAME=schedule NEXT_RELEASE_VERSION=nightly NIGHTLY_RELEASE_PREFIX=nigtly ./create-version.sh
-#  GITHUB_EVENT_NAME=workflow_dispatch COMMIT_SHA=f0e7216c4bb6acce9b29a21ec2d683be2e3f984a NEXT_RELEASE_VERSION=dev NIGHTLY_RELEASE_PREFIX=nigtly ./create-version.sh
+#  GITHUB_EVENT_NAME=push NEXT_RELEASE_VERSION=v0.4.0 NIGHTLY_RELEASE_PREFIX=nightly GITHUB_REF_NAME=v0.3.0 ./create-version.sh
+#  GITHUB_EVENT_NAME=workflow_dispatch NEXT_RELEASE_VERSION=v0.4.0 NIGHTLY_RELEASE_PREFIX=nightly ./create-version.sh
+#  GITHUB_EVENT_NAME=schedule NEXT_RELEASE_VERSION=v0.4.0 NIGHTLY_RELEASE_PREFIX=nightly ./create-version.sh
+#  GITHUB_EVENT_NAME=schedule NEXT_RELEASE_VERSION=nightly NIGHTLY_RELEASE_PREFIX=nightly ./create-version.sh
+#  GITHUB_EVENT_NAME=workflow_dispatch COMMIT_SHA=f0e7216c4bb6acce9b29a21ec2d683be2e3f984a NEXT_RELEASE_VERSION=dev NIGHTLY_RELEASE_PREFIX=nightly ./create-version.sh
 create_version

.github/scripts/deploy-greptimedb.sh

@@ -10,7 +10,7 @@ GREPTIMEDB_IMAGE_TAG=${GREPTIMEDB_IMAGE_TAG:-latest}
 ETCD_CHART="oci://registry-1.docker.io/bitnamicharts/etcd"
 GREPTIME_CHART="https://greptimeteam.github.io/helm-charts/"
 
-# Ceate a cluster with 1 control-plane node and 5 workers.
+# Create a cluster with 1 control-plane node and 5 workers.
 function create_kind_cluster() {
   cat <<EOF | kind create cluster --name "${CLUSTER}" --image kindest/node:"$KUBERNETES_VERSION" --config=-
 kind: Cluster
@@ -68,7 +68,7 @@ function deploy_greptimedb_cluster() {
 
   helm install "$cluster_name" greptime/greptimedb-cluster \
     --set image.tag="$GREPTIMEDB_IMAGE_TAG" \
-    --set meta.etcdEndpoints="etcd.$install_namespace:2379" \
+    --set meta.backendStorage.etcd.endpoints="etcd.$install_namespace:2379" \
     -n "$install_namespace"
 
   # Wait for greptimedb cluster to be ready.
@@ -103,7 +103,7 @@ function deploy_greptimedb_cluster_with_s3_storage() {
 
   helm install "$cluster_name" greptime/greptimedb-cluster -n "$install_namespace" \
     --set image.tag="$GREPTIMEDB_IMAGE_TAG" \
-    --set meta.etcdEndpoints="etcd.$install_namespace:2379" \
+    --set meta.backendStorage.etcd.endpoints="etcd.$install_namespace:2379" \
     --set storage.s3.bucket="$AWS_CI_TEST_BUCKET" \
     --set storage.s3.region="$AWS_REGION" \
     --set storage.s3.root="$DATA_ROOT" \

.github/scripts/update-dev-builder-version.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+DEV_BUILDER_IMAGE_TAG=$1
+
+update_dev_builder_version() {
+  if [ -z "$DEV_BUILDER_IMAGE_TAG" ]; then
+    echo "Error: Should specify the dev-builder image tag"
+    exit 1
+  fi
+
+  # Configure Git configs.
+  git config --global user.email greptimedb-ci@greptime.com
+  git config --global user.name greptimedb-ci
+
+  # Checkout a new branch.
+  BRANCH_NAME="ci/update-dev-builder-$(date +%Y%m%d%H%M%S)"
+  git checkout -b $BRANCH_NAME
+
+  # Update the dev-builder image tag in the Makefile.
+  sed -i "s/DEV_BUILDER_IMAGE_TAG ?=.*/DEV_BUILDER_IMAGE_TAG ?= ${DEV_BUILDER_IMAGE_TAG}/g" Makefile
+
+  # Commit the changes.
+  git add Makefile
+  git commit -m "ci: update dev-builder image tag"
+  git push origin $BRANCH_NAME
+
+  # Create a Pull Request.
+  gh pr create \
+      --title "ci: update dev-builder image tag" \
+      --body "This PR updates the dev-builder image tag" \
+      --base main \
+      --head $BRANCH_NAME \
+      --reviewer zyy17 \
+      --reviewer daviderli614
+}
+
+update_dev_builder_version

.github/scripts/update-helm-charts-version.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+set -e
+
+VERSION=${VERSION}
+GITHUB_TOKEN=${GITHUB_TOKEN}
+
+update_helm_charts_version() {
+  # Configure Git configs.
+  git config --global user.email update-helm-charts-version@greptime.com
+  git config --global user.name update-helm-charts-version
+
+  # Clone helm-charts repository.
+  git clone "https://x-access-token:${GITHUB_TOKEN}@github.com/GreptimeTeam/helm-charts.git"
+  cd helm-charts
+
+  # Set default remote for gh CLI
+  gh repo set-default GreptimeTeam/helm-charts
+
+  # Checkout a new branch.
+  BRANCH_NAME="chore/greptimedb-${VERSION}"
+  git checkout -b $BRANCH_NAME
+
+  # Update version.
+  make update-version CHART=greptimedb-cluster VERSION=${VERSION}
+  make update-version CHART=greptimedb-standalone VERSION=${VERSION}
+
+  # Update docs.
+  make docs
+
+  # Commit the changes.
+  git add .
+  git commit -s -m "chore: Update GreptimeDB version to ${VERSION}"
+  git push origin $BRANCH_NAME
+
+  # Create a Pull Request.
+  gh pr create \
+    --title "chore: Update GreptimeDB version to ${VERSION}" \
+    --body "This PR updates the GreptimeDB version." \
+    --base main \
+    --head $BRANCH_NAME \
+    --reviewer zyy17 \
+    --reviewer daviderli614
+}
+
+update_helm_charts_version

.github/scripts/update-homebrew-greptme-version.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+set -e
+
+VERSION=${VERSION}
+GITHUB_TOKEN=${GITHUB_TOKEN}
+
+update_homebrew_greptime_version() {
+  # Configure Git configs.
+  git config --global user.email update-greptime-version@greptime.com
+  git config --global user.name update-greptime-version
+
+  # Clone helm-charts repository.
+  git clone "https://x-access-token:${GITHUB_TOKEN}@github.com/GreptimeTeam/homebrew-greptime.git"
+  cd homebrew-greptime
+
+  # Set default remote for gh CLI
+  gh repo set-default GreptimeTeam/homebrew-greptime
+
+  # Checkout a new branch.
+  BRANCH_NAME="chore/greptimedb-${VERSION}"
+  git checkout -b $BRANCH_NAME
+
+  # Update version.
+  make update-greptime-version VERSION=${VERSION}
+
+  # Commit the changes.
+  git add .
+  git commit -s -m "chore: Update GreptimeDB version to ${VERSION}"
+  git push origin $BRANCH_NAME
+
+  # Create a Pull Request.
+  gh pr create \
+    --title "chore: Update GreptimeDB version to ${VERSION}" \
+    --body "This PR updates the GreptimeDB version." \
+    --base main \
+    --head $BRANCH_NAME \
+    --reviewer zyy17 \
+    --reviewer daviderli614
+}
+
+update_homebrew_greptime_version

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

@@ -41,7 +41,7 @@ function upload_artifacts() {
 # Updates the latest version information in AWS S3 if UPDATE_VERSION_INFO is true.
 function update_version_info() {
   if [ "$UPDATE_VERSION_INFO" == "true" ]; then
-    # If it's the officail release(like v1.0.0, v1.0.1, v1.0.2, etc.), update latest-version.txt.
+    # If it's the official release(like v1.0.0, v1.0.1, v1.0.2, etc.), update latest-version.txt.
     if [[ "$VERSION" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
       echo "Updating latest-version.txt"
       echo "$VERSION" > latest-version.txt

.github/workflows/dev-build.yml

@@ -55,6 +55,11 @@ on:
         description: Build and push images to DockerHub and ACR
         required: false
         default: true
+      upload_artifacts_to_s3:
+        type: boolean
+        description: Whether upload artifacts to s3
+        required: false
+        default: false
       cargo_profile:
         type: choice
         description: The cargo profile to use in building GreptimeDB.
@@ -239,6 +244,13 @@ jobs:
           push-latest-tag: false # Don't push the latest tag to registry.
           dev-mode: true # Only build the standard images.
 
+      - name: Echo Docker image tag to step summary
+        run: |
+          echo "## Docker Image Tag" >> $GITHUB_STEP_SUMMARY
+          echo "Image Tag: \`${{ needs.allocate-runners.outputs.version }}\`" >> $GITHUB_STEP_SUMMARY
+          echo "Full Image Name: \`docker.io/${{ vars.IMAGE_NAMESPACE }}/${{ vars.DEV_BUILD_IMAGE_NAME }}:${{ needs.allocate-runners.outputs.version }}\`" >> $GITHUB_STEP_SUMMARY
+          echo "Pull Command: \`docker pull docker.io/${{ vars.IMAGE_NAMESPACE }}/${{ vars.DEV_BUILD_IMAGE_NAME }}:${{ needs.allocate-runners.outputs.version }}\`" >> $GITHUB_STEP_SUMMARY
+
       - name: Set build result
         id: set-build-result
         run: |
@@ -274,7 +286,7 @@ jobs:
           aws-cn-access-key-id: ${{ secrets.AWS_CN_ACCESS_KEY_ID }}
           aws-cn-secret-access-key: ${{ secrets.AWS_CN_SECRET_ACCESS_KEY }}
           aws-cn-region: ${{ vars.AWS_RELEASE_BUCKET_REGION }}
-          upload-to-s3: false
+          upload-to-s3: ${{ inputs.upload_artifacts_to_s3 }}
           dev-mode: true                     # Only build the standard images(exclude centos images).
           push-latest-tag: false             # Don't push the latest tag to registry.
           update-version-info: false         # Don't update the version info in S3.

.github/workflows/develop.yml

@@ -22,6 +22,7 @@ concurrency:
 
 jobs:
   check-typos-and-docs:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Check typos and docs
     runs-on: ubuntu-latest
     steps:
@@ -36,6 +37,7 @@ jobs:
           || (echo "'config/config.md' is not up-to-date, please run 'make config-docs'." && exit 1)
 
   license-header-check:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     runs-on: ubuntu-latest
     name: Check License Header
     steps:
@@ -45,6 +47,7 @@ jobs:
       - uses: korandoru/hawkeye@v5
 
   check:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Check
     runs-on: ${{ matrix.os }}
     strategy:
@@ -71,6 +74,7 @@ jobs:
         run: cargo check --locked --workspace --all-targets
 
   toml:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Toml Check
     runs-on: ubuntu-latest
     timeout-minutes: 60
@@ -85,6 +89,7 @@ jobs:
         run: taplo format --check
 
   build:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Build GreptimeDB binaries
     runs-on: ${{ matrix.os }}
     strategy:
@@ -127,6 +132,7 @@ jobs:
           version: current
 
   fuzztest:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Fuzz Test
     needs: build
     runs-on: ubuntu-latest
@@ -183,11 +189,13 @@ jobs:
           max-total-time: 120
 
   unstable-fuzztest:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Unstable Fuzz Test
     needs: build-greptime-ci
     runs-on: ubuntu-latest
     timeout-minutes: 60
     strategy:
+      fail-fast: false
       matrix:
         target: [ "unstable_fuzz_create_table_standalone" ]
     steps:
@@ -215,12 +223,12 @@ jobs:
         run: |
           sudo apt update && sudo apt install -y libfuzzer-14-dev
           cargo install cargo-fuzz cargo-gc-bin --force
-      - name: Download pre-built binariy
+      - name: Download pre-built binary
         uses: actions/download-artifact@v4
         with:
           name: bin
           path: .
-      - name: Unzip bianry
+      - name: Unzip binary
         run: |
           tar -xvf ./bin.tar.gz
           rm ./bin.tar.gz
@@ -242,8 +250,14 @@ jobs:
           name: unstable-fuzz-logs
           path: /tmp/unstable-greptime/
           retention-days: 3
+      - name: Describe pods
+        if: failure()
+        shell: bash
+        run: |
+          kubectl describe pod -n my-greptimedb
 
   build-greptime-ci:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Build GreptimeDB binary (profile-CI)
     runs-on: ${{ matrix.os }}
     strategy:
@@ -267,7 +281,7 @@ jobs:
       - name: Install cargo-gc-bin
         shell: bash
         run: cargo install cargo-gc-bin --force
-      - name: Build greptime bianry
+      - name: Build greptime binary
         shell: bash
         # `cargo gc` will invoke `cargo build` with specified args
         run: cargo gc --profile ci -- --bin greptime --features pg_kvbackend
@@ -285,11 +299,13 @@ jobs:
           version: current
 
   distributed-fuzztest:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Fuzz Test (Distributed, ${{ matrix.mode.name }}, ${{ matrix.target }})
     runs-on: ubuntu-latest
     needs:  build-greptime-ci
     timeout-minutes: 60
     strategy:
+      fail-fast: false
       matrix:
         target: [ "fuzz_create_table", "fuzz_alter_table", "fuzz_create_database", "fuzz_create_logical_table", "fuzz_alter_logical_table", "fuzz_insert", "fuzz_insert_logical_table" ]
         mode:
@@ -319,9 +335,9 @@ jobs:
         name: Setup Minio
         uses: ./.github/actions/setup-minio
       - if: matrix.mode.kafka
-        name: Setup Kafka cluser
+        name: Setup Kafka cluster
         uses: ./.github/actions/setup-kafka-cluster
-      - name: Setup Etcd cluser
+      - name: Setup Etcd cluster
         uses: ./.github/actions/setup-etcd-cluster
       # Prepares for fuzz tests
       - uses: arduino/setup-protoc@v3
@@ -394,6 +410,11 @@ jobs:
         shell: bash
         run: |
           kubectl describe nodes
+      - name: Describe pod
+        if: failure()
+        shell: bash
+        run: |
+          kubectl describe pod -n my-greptimedb
       - name: Export kind logs
         if: failure()
         shell: bash
@@ -416,11 +437,13 @@ jobs:
           docker system prune -f
 
   distributed-fuzztest-with-chaos:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Fuzz Test with Chaos (Distributed, ${{ matrix.mode.name }}, ${{ matrix.target }})
     runs-on: ubuntu-latest
     needs:  build-greptime-ci
     timeout-minutes: 60
     strategy:
+      fail-fast: false
       matrix:
         target: ["fuzz_migrate_mito_regions", "fuzz_migrate_metric_regions", "fuzz_failover_mito_regions", "fuzz_failover_metric_regions"]
         mode:
@@ -465,9 +488,9 @@ jobs:
         name: Setup Minio
         uses: ./.github/actions/setup-minio
       - if: matrix.mode.kafka
-        name: Setup Kafka cluser
+        name: Setup Kafka cluster
         uses: ./.github/actions/setup-kafka-cluster
-      - name: Setup Etcd cluser
+      - name: Setup Etcd cluster
         uses: ./.github/actions/setup-etcd-cluster
       # Prepares for fuzz tests
       - uses: arduino/setup-protoc@v3
@@ -541,6 +564,11 @@ jobs:
         shell: bash
         run: |
           kubectl describe nodes
+      - name: Describe pods
+        if: failure()
+        shell: bash
+        run: |
+          kubectl describe pod -n my-greptimedb
       - name: Export kind logs
         if: failure()
         shell: bash
@@ -563,10 +591,12 @@ jobs:
           docker system prune -f
 
   sqlness:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Sqlness Test (${{ matrix.mode.name }})
     needs: build
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
         os: [ ubuntu-latest ]
         mode:
@@ -576,7 +606,7 @@ jobs:
           - name: "Remote WAL"
             opts: "-w kafka -k 127.0.0.1:9092"
             kafka: true
-          - name: "Pg Kvbackend"
+          - name: "PostgreSQL KvBackend"
             opts: "--setup-pg"
             kafka: false
     timeout-minutes: 60
@@ -606,6 +636,7 @@ jobs:
           retention-days: 3
 
   fmt:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Rustfmt
     runs-on: ubuntu-latest
     timeout-minutes: 60
@@ -623,6 +654,7 @@ jobs:
         run: make fmt-check
 
   clippy:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Clippy
     runs-on: ubuntu-latest
     timeout-minutes: 60
@@ -648,6 +680,7 @@ jobs:
         run: make clippy
 
   conflict-check:
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
     name: Check for conflict
     runs-on: ubuntu-latest
     steps:
@@ -658,7 +691,7 @@ jobs:
         uses: olivernybroe/action-conflict-finder@v4.0
 
   test:
-    if: github.event_name != 'merge_group'
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' && github.event_name != 'merge_group' }}
     runs-on: ubuntu-22.04-arm
     timeout-minutes: 60
     needs:  [conflict-check, clippy, fmt]
@@ -673,7 +706,7 @@ jobs:
       - name: Install toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-            cache: false
+          cache: false
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
         with:
@@ -704,12 +737,13 @@ jobs:
           GT_MINIO_ENDPOINT_URL: http://127.0.0.1:9000
           GT_ETCD_ENDPOINTS: http://127.0.0.1:2379
           GT_POSTGRES_ENDPOINTS: postgres://greptimedb:admin@127.0.0.1:5432/postgres
+          GT_MYSQL_ENDPOINTS: mysql://greptimedb:admin@127.0.0.1:3306/mysql
           GT_KAFKA_ENDPOINTS: 127.0.0.1:9092
           GT_KAFKA_SASL_ENDPOINTS: 127.0.0.1:9093
           UNITTEST_LOG_DIR: "__unittest_logs"
 
   coverage:
-    if: github.event_name == 'merge_group'
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' && github.event_name == 'merge_group' }}
     runs-on: ubuntu-22.04-8-cores
     timeout-minutes: 60
     steps:
@@ -755,6 +789,7 @@ jobs:
           GT_MINIO_ENDPOINT_URL: http://127.0.0.1:9000
           GT_ETCD_ENDPOINTS: http://127.0.0.1:2379
           GT_POSTGRES_ENDPOINTS: postgres://greptimedb:admin@127.0.0.1:5432/postgres
+          GT_MYSQL_ENDPOINTS: mysql://greptimedb:admin@127.0.0.1:3306/mysql
           GT_KAFKA_ENDPOINTS: 127.0.0.1:9092
           GT_KAFKA_SASL_ENDPOINTS: 127.0.0.1:9093
           UNITTEST_LOG_DIR: "__unittest_logs"
@@ -768,6 +803,7 @@ jobs:
           verbose: true
 
   # compat:
+  #   if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
   #   name: Compatibility Test
   #   needs: build
   #   runs-on: ubuntu-22.04

.github/workflows/nightly-ci.yml

@@ -107,7 +107,6 @@ jobs:
           CARGO_BUILD_RUSTFLAGS: "-C linker=lld-link"
           RUST_BACKTRACE: 1
           CARGO_INCREMENTAL: 0
-          RUSTUP_WINDOWS_PATH_ADD_BIN: 1 # Workaround for https://github.com/nextest-rs/nextest/issues/1493
           GT_S3_BUCKET: ${{ vars.AWS_CI_TEST_BUCKET }}
           GT_S3_ACCESS_KEY_ID: ${{ secrets.AWS_CI_TEST_ACCESS_KEY_ID }}
           GT_S3_ACCESS_KEY: ${{ secrets.AWS_CI_TEST_SECRET_ACCESS_KEY }}
@@ -118,16 +117,16 @@ jobs:
     name: Run clean build on Linux
     runs-on: ubuntu-latest
     if: ${{ github.repository == 'GreptimeTeam/greptimedb' }}
-    timeout-minutes: 60
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
           persist-credentials: false
-      - uses: cachix/install-nix-action@v27
-        with:
-          nix_path: nixpkgs=channel:nixos-24.11
-      - run: nix develop --command cargo build
+      - uses: cachix/install-nix-action@v31
+      - run: nix develop --command cargo check --bin greptime
+        env:
+          CARGO_BUILD_RUSTFLAGS: "-C link-arg=-fuse-ld=mold"
 
   check-status:
     name: Check status

.github/workflows/pr-labeling.yaml

@@ -0,0 +1,42 @@
+name: 'PR Labeling'
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - synchronize
+      - reopened
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  labeler:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - uses: actions/labeler@v5
+        with:
+          configuration-path: ".github/labeler.yaml"
+          repo-token: "${{ secrets.GITHUB_TOKEN }}"
+
+  size-label:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: pascalgn/size-label-action@v0.5.5
+        env:
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+        with:
+          sizes: >
+            {
+              "0": "XS",
+              "100": "S",
+              "300": "M",
+              "1000": "L",
+              "1500": "XL",
+              "2000": "XXL"
+            }

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

@@ -24,11 +24,19 @@ on:
         description: Release dev-builder-android image
         required: false
         default: false
+      update_dev_builder_image_tag:
+        type: boolean
+        description: Update the DEV_BUILDER_IMAGE_TAG in Makefile and create a PR
+        required: false
+        default: false
 
 jobs:
   release-dev-builder-images:
     name: Release dev builder images
-    if: ${{ inputs.release_dev_builder_ubuntu_image || inputs.release_dev_builder_centos_image || inputs.release_dev_builder_android_image }} # Only manually trigger this job.
+    # The jobs are triggered by the following events:
+    # 1. Manually triggered workflow_dispatch event
+    # 2. Push event when the PR that modifies the `rust-toolchain.toml` or `docker/dev-builder/**` is merged to main
+    if: ${{ github.event_name == 'push' || inputs.release_dev_builder_ubuntu_image || inputs.release_dev_builder_centos_image || inputs.release_dev_builder_android_image }}
     runs-on: ubuntu-latest
     outputs:
       version: ${{ steps.set-version.outputs.version }}
@@ -57,9 +65,9 @@ jobs:
           version: ${{ env.VERSION }}
           dockerhub-image-registry-username: ${{ secrets.DOCKERHUB_USERNAME }}
           dockerhub-image-registry-token: ${{ secrets.DOCKERHUB_TOKEN }}
-          build-dev-builder-ubuntu: ${{ inputs.release_dev_builder_ubuntu_image }}
-          build-dev-builder-centos: ${{ inputs.release_dev_builder_centos_image }}
-          build-dev-builder-android: ${{ inputs.release_dev_builder_android_image }}
+          build-dev-builder-ubuntu: ${{ inputs.release_dev_builder_ubuntu_image || github.event_name == 'push' }}
+          build-dev-builder-centos: ${{ inputs.release_dev_builder_centos_image || github.event_name == 'push' }}
+          build-dev-builder-android: ${{ inputs.release_dev_builder_android_image || github.event_name == 'push' }}
 
   release-dev-builder-images-ecr:
     name: Release dev builder images to AWS ECR
@@ -85,7 +93,7 @@ jobs:
 
       - name: Push dev-builder-ubuntu image
         shell: bash
-        if: ${{ inputs.release_dev_builder_ubuntu_image }}
+        if: ${{ inputs.release_dev_builder_ubuntu_image || github.event_name == 'push' }}
         env:
           IMAGE_VERSION: ${{ needs.release-dev-builder-images.outputs.version }}
           IMAGE_NAMESPACE: ${{ vars.IMAGE_NAMESPACE }}
@@ -106,7 +114,7 @@ jobs:
 
       - name: Push dev-builder-centos image
         shell: bash
-        if: ${{ inputs.release_dev_builder_centos_image }}
+        if: ${{ inputs.release_dev_builder_centos_image || github.event_name == 'push' }}
         env:
           IMAGE_VERSION: ${{ needs.release-dev-builder-images.outputs.version }}
           IMAGE_NAMESPACE: ${{ vars.IMAGE_NAMESPACE }}
@@ -127,7 +135,7 @@ jobs:
 
       - name: Push dev-builder-android image
         shell: bash
-        if: ${{ inputs.release_dev_builder_android_image }}
+        if: ${{ inputs.release_dev_builder_android_image || github.event_name == 'push' }}
         env:
           IMAGE_VERSION: ${{ needs.release-dev-builder-images.outputs.version }}
           IMAGE_NAMESPACE: ${{ vars.IMAGE_NAMESPACE }}
@@ -162,7 +170,7 @@ jobs:
 
       - name: Push dev-builder-ubuntu image
         shell: bash
-        if: ${{ inputs.release_dev_builder_ubuntu_image }}
+        if: ${{ inputs.release_dev_builder_ubuntu_image || github.event_name == 'push' }}
         env:
           IMAGE_VERSION: ${{ needs.release-dev-builder-images.outputs.version }}
           IMAGE_NAMESPACE: ${{ vars.IMAGE_NAMESPACE }}
@@ -176,7 +184,7 @@ jobs:
 
       - name: Push dev-builder-centos image
         shell: bash
-        if: ${{ inputs.release_dev_builder_centos_image }}
+        if: ${{ inputs.release_dev_builder_centos_image || github.event_name == 'push' }}
         env:
           IMAGE_VERSION: ${{ needs.release-dev-builder-images.outputs.version }}
           IMAGE_NAMESPACE: ${{ vars.IMAGE_NAMESPACE }}
@@ -190,7 +198,7 @@ jobs:
 
       - name: Push dev-builder-android image
         shell: bash
-        if: ${{ inputs.release_dev_builder_android_image }}
+        if: ${{ inputs.release_dev_builder_android_image || github.event_name == 'push' }}
         env:
           IMAGE_VERSION: ${{ needs.release-dev-builder-images.outputs.version }}
           IMAGE_NAMESPACE: ${{ vars.IMAGE_NAMESPACE }}
@@ -201,3 +209,24 @@ jobs:
             quay.io/skopeo/stable:latest \
             copy -a docker://docker.io/$IMAGE_NAMESPACE/dev-builder-android:$IMAGE_VERSION \
             docker://$ACR_IMAGE_REGISTRY/$IMAGE_NAMESPACE/dev-builder-android:$IMAGE_VERSION
+  
+  update-dev-builder-image-tag:
+    name: Update dev-builder image tag
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    if: ${{ github.event_name == 'push' || inputs.update_dev_builder_image_tag }}
+    needs: [
+      release-dev-builder-images
+    ]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Update dev-builder image tag
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          ./.github/scripts/update-dev-builder-version.sh ${{ needs.release-dev-builder-images.outputs.version }}

.github/workflows/release.yml

@@ -88,10 +88,8 @@ env:
   # Controls whether to run tests, include unit-test, integration-test and sqlness.
   DISABLE_RUN_TESTS: ${{ inputs.skip_test || vars.DEFAULT_SKIP_TEST }}
 
-  # The scheduled version is '${{ env.NEXT_RELEASE_VERSION }}-nightly-YYYYMMDD', like v0.2.0-nigthly-20230313;
+  # The scheduled version is '${{ env.NEXT_RELEASE_VERSION }}-nightly-YYYYMMDD', like v0.2.0-nightly-20230313;
   NIGHTLY_RELEASE_PREFIX: nightly
-  # Note: The NEXT_RELEASE_VERSION should be modified manually by every formal release.
-  NEXT_RELEASE_VERSION: v0.13.0
 
 jobs:
   allocate-runners:
@@ -112,6 +110,8 @@ jobs:
 
       # The 'version' use as the global tag name of the release workflow.
       version: ${{ steps.create-version.outputs.version }}
+
+      should-push-latest-tag: ${{ steps.check-version.outputs.should-push-latest-tag }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -126,7 +126,7 @@ jobs:
 
       # The create-version will create a global variable named 'version' in the global workflows.
       # - If it's a tag push release, the version is the tag name(${{ github.ref_name }});
-      # - If it's a scheduled release, the version is '${{ env.NEXT_RELEASE_VERSION }}-nightly-$buildTime', like v0.2.0-nigthly-20230313;
+      # - If it's a scheduled release, the version is '${{ env.NEXT_RELEASE_VERSION }}-nightly-$buildTime', like v0.2.0-nightly-20230313;
       # - If it's a manual release, the version is '${{ env.NEXT_RELEASE_VERSION }}-<short-git-sha>-YYYYMMDDSS', like v0.2.0-e5b243c-2023071245;
       - name: Create version
         id: create-version
@@ -135,9 +135,13 @@ jobs:
         env:
           GITHUB_EVENT_NAME: ${{ github.event_name }}
           GITHUB_REF_NAME: ${{ github.ref_name }}
-          NEXT_RELEASE_VERSION: ${{ env.NEXT_RELEASE_VERSION }}
           NIGHTLY_RELEASE_PREFIX: ${{ env.NIGHTLY_RELEASE_PREFIX }}
 
+      - name: Check version
+        id: check-version
+        run: |
+          ./.github/scripts/check-version.sh "${{ steps.create-version.outputs.version }}"
+
       - name: Allocate linux-amd64 runner
         if: ${{ inputs.build_linux_amd64_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
         uses: ./.github/actions/start-runner
@@ -317,7 +321,7 @@ jobs:
           image-registry-username: ${{ secrets.DOCKERHUB_USERNAME }}
           image-registry-password: ${{ secrets.DOCKERHUB_TOKEN }}
           version: ${{ needs.allocate-runners.outputs.version }}
-          push-latest-tag: true
+          push-latest-tag: ${{ needs.allocate-runners.outputs.should-push-latest-tag == 'true' && github.ref_type == 'tag' && !contains(github.ref_name, 'nightly') && github.event_name != 'schedule' }}
 
       - name: Set build image result
         id: set-build-image-result
@@ -335,7 +339,7 @@ jobs:
       build-windows-artifacts,
       release-images-to-dockerhub,
     ]
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-latest-16-cores
     # When we push to ACR, it's easy to fail due to some unknown network issues.
     # However, we don't want to fail the whole workflow because of this.
     # The ACR have daily sync with DockerHub, so don't worry about the image not being updated.
@@ -364,7 +368,7 @@ jobs:
           dev-mode: false
           upload-to-s3: true
           update-version-info: true
-          push-latest-tag: true
+          push-latest-tag: ${{ needs.allocate-runners.outputs.should-push-latest-tag == 'true' && github.ref_type == 'tag' && !contains(github.ref_name, 'nightly') && github.event_name != 'schedule' }}
 
   publish-github-release:
     name: Create GitHub release and upload artifacts
@@ -391,7 +395,7 @@ jobs:
 
   ### Stop runners ###
   # It's very necessary to split the job of releasing runners into 'stop-linux-amd64-runner' and 'stop-linux-arm64-runner'.
-  # Because we can terminate the specified EC2 instance immediately after the job is finished without uncessary waiting.
+  # Because we can terminate the specified EC2 instance immediately after the job is finished without unnecessary waiting.
   stop-linux-amd64-runner: # It's always run as the last job in the workflow to make sure that the runner is released.
     name: Stop linux-amd64 runner
     # Only run this job when the runner is allocated.
@@ -444,10 +448,10 @@ jobs:
           aws-region: ${{ vars.EC2_RUNNER_REGION }}
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
 
-  bump-doc-version:
-    name: Bump doc version
+  bump-downstream-repo-versions:
+    name: Bump downstream repo versions
     if: ${{ github.event_name == 'push' || github.event_name == 'schedule' }}
-    needs: [allocate-runners]
+    needs: [allocate-runners, publish-github-release]
     runs-on: ubuntu-latest
     # Permission reference: https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs
     permissions:
@@ -459,13 +463,58 @@ jobs:
           fetch-depth: 0
           persist-credentials: false
       - uses: ./.github/actions/setup-cyborg
-      - name: Bump doc version
+      - name: Bump downstream repo versions
         working-directory: cyborg
-        run: pnpm tsx bin/bump-doc-version.ts
+        run: pnpm tsx bin/bump-versions.ts
         env:
+          TARGET_REPOS: website,docs,demo
           VERSION: ${{ needs.allocate-runners.outputs.version }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          WEBSITE_REPO_TOKEN: ${{ secrets.WEBSITE_REPO_TOKEN }}
           DOCS_REPO_TOKEN: ${{ secrets.DOCS_REPO_TOKEN }}
+          DEMO_REPO_TOKEN: ${{ secrets.DEMO_REPO_TOKEN }}
+
+  bump-helm-charts-version:
+    name: Bump helm charts version
+    if: ${{ github.ref_type == 'tag' && !contains(github.ref_name, 'nightly') && github.event_name != 'schedule' }}
+    needs: [allocate-runners, publish-github-release]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Bump helm charts version
+        env:
+          GITHUB_TOKEN: ${{ secrets.HELM_CHARTS_REPO_TOKEN }}
+          VERSION: ${{ needs.allocate-runners.outputs.version }}
+        run: |
+          ./.github/scripts/update-helm-charts-version.sh
+
+  bump-homebrew-greptime-version:
+    name: Bump homebrew greptime version
+    if: ${{ github.ref_type == 'tag' && !contains(github.ref_name, 'nightly') && github.event_name != 'schedule' }}
+    needs: [allocate-runners, publish-github-release]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Bump homebrew greptime version
+        env:
+          GITHUB_TOKEN: ${{ secrets.HOMEBREW_GREPTIME_REPO_TOKEN }}
+          VERSION: ${{ needs.allocate-runners.outputs.version }}
+        run: |
+          ./.github/scripts/update-homebrew-greptme-version.sh
 
   notification:
     if: ${{ github.repository == 'GreptimeTeam/greptimedb' && (github.event_name == 'push' || github.event_name == 'schedule') && always() }}

.github/workflows/semantic-pull-request.yml

@@ -11,14 +11,17 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 
+permissions:
+  issues: write
+  contents: write
+  pull-requests: write
+
 jobs:
   check:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
       - uses: ./.github/actions/setup-cyborg
       - name: Check Pull Request
         working-directory: cyborg

.gitignore

@@ -54,3 +54,10 @@ tests-fuzz/corpus/
 # Nix
 .direnv
 .envrc
+
+## default data home
+greptimedb_data
+
+# github
+!/.github
+

Cargo.lock

@@ -185,7 +185,7 @@ checksum = "d301b3b94cb4b2f23d7917810addbbaff90738e0ca2be692bd027e70d7e0330c"
 
 [[package]]
 name = "api"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "common-base",
  "common-decimal",
@@ -710,7 +710,7 @@ dependencies = [
 
 [[package]]
 name = "auth"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "async-trait",
@@ -1324,7 +1324,7 @@ dependencies = [
 
 [[package]]
 name = "cache"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "catalog",
  "common-error",
@@ -1348,7 +1348,7 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "catalog"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "arrow",
@@ -1661,7 +1661,7 @@ checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
 [[package]]
 name = "cli"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-trait",
  "auth",
@@ -1703,7 +1703,7 @@ dependencies = [
  "session",
  "snafu 0.8.5",
  "store-api",
- "substrait 0.13.0",
+ "substrait 0.12.2",
  "table",
  "tempfile",
  "tokio",
@@ -1712,7 +1712,7 @@ dependencies = [
 
 [[package]]
 name = "client"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "arc-swap",
@@ -1739,7 +1739,7 @@ dependencies = [
  "rand",
  "serde_json",
  "snafu 0.8.5",
- "substrait 0.13.0",
+ "substrait 0.12.2",
  "substrait 0.37.3",
  "tokio",
  "tokio-stream",
@@ -1780,7 +1780,7 @@ dependencies = [
 
 [[package]]
 name = "cmd"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-trait",
  "auth",
@@ -1791,6 +1791,7 @@ dependencies = [
  "clap 4.5.19",
  "cli",
  "client",
+ "colored",
  "common-base",
  "common-catalog",
  "common-config",
@@ -1825,7 +1826,10 @@ dependencies = [
  "mito2",
  "moka",
  "nu-ansi-term",
+ "object-store",
+ "parquet",
  "plugins",
+ "pprof",
  "prometheus",
  "prost 0.13.3",
  "query",
@@ -1841,7 +1845,7 @@ dependencies = [
  "similar-asserts",
  "snafu 0.8.5",
  "store-api",
- "substrait 0.13.0",
+ "substrait 0.12.2",
  "table",
  "temp-env",
  "tempfile",
@@ -1858,6 +1862,16 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0"
 
+[[package]]
+name = "colored"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
+dependencies = [
+ "lazy_static",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "combine"
 version = "4.6.7"
@@ -1887,7 +1901,7 @@ checksum = "55b672471b4e9f9e95499ea597ff64941a309b2cdbffcc46f2cc5e2d971fd335"
 
 [[package]]
 name = "common-base"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "anymap2",
  "async-trait",
@@ -1909,11 +1923,11 @@ dependencies = [
 
 [[package]]
 name = "common-catalog"
-version = "0.13.0"
+version = "0.12.2"
 
 [[package]]
 name = "common-config"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "common-base",
  "common-error",
@@ -1938,7 +1952,7 @@ dependencies = [
 
 [[package]]
 name = "common-datasource"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "arrow",
  "arrow-schema",
@@ -1974,7 +1988,7 @@ dependencies = [
 
 [[package]]
 name = "common-decimal"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "bigdecimal 0.4.5",
  "common-error",
@@ -1987,7 +2001,7 @@ dependencies = [
 
 [[package]]
 name = "common-error"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "http 1.1.0",
  "snafu 0.8.5",
@@ -1997,7 +2011,7 @@ dependencies = [
 
 [[package]]
 name = "common-frontend"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-trait",
  "common-error",
@@ -2007,7 +2021,7 @@ dependencies = [
 
 [[package]]
 name = "common-function"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "ahash 0.8.11",
  "api",
@@ -2026,8 +2040,6 @@ dependencies = [
  "common-time",
  "common-version",
  "datafusion",
- "datafusion-common",
- "datafusion-expr",
  "datatypes",
  "derive_more",
  "geo",
@@ -2057,7 +2069,7 @@ dependencies = [
 
 [[package]]
 name = "common-greptimedb-telemetry"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-trait",
  "common-runtime",
@@ -2074,7 +2086,7 @@ dependencies = [
 
 [[package]]
 name = "common-grpc"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "arrow-flight",
@@ -2102,7 +2114,7 @@ dependencies = [
 
 [[package]]
 name = "common-grpc-expr"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "common-base",
@@ -2121,7 +2133,7 @@ dependencies = [
 
 [[package]]
 name = "common-macro"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "arc-swap",
  "common-query",
@@ -2135,7 +2147,7 @@ dependencies = [
 
 [[package]]
 name = "common-mem-prof"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "common-error",
  "common-macro",
@@ -2148,7 +2160,7 @@ dependencies = [
 
 [[package]]
 name = "common-meta"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "anymap2",
  "api",
@@ -2208,7 +2220,7 @@ dependencies = [
 
 [[package]]
 name = "common-options"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "common-grpc",
  "humantime-serde",
@@ -2217,11 +2229,11 @@ dependencies = [
 
 [[package]]
 name = "common-plugins"
-version = "0.13.0"
+version = "0.12.2"
 
 [[package]]
 name = "common-pprof"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "common-error",
  "common-macro",
@@ -2233,7 +2245,7 @@ dependencies = [
 
 [[package]]
 name = "common-procedure"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -2260,7 +2272,7 @@ dependencies = [
 
 [[package]]
 name = "common-procedure-test"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-trait",
  "common-procedure",
@@ -2268,7 +2280,7 @@ dependencies = [
 
 [[package]]
 name = "common-query"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "async-trait",
@@ -2294,7 +2306,7 @@ dependencies = [
 
 [[package]]
 name = "common-recordbatch"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "arc-swap",
  "common-error",
@@ -2313,7 +2325,7 @@ dependencies = [
 
 [[package]]
 name = "common-runtime"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-trait",
  "clap 4.5.19",
@@ -2343,7 +2355,7 @@ dependencies = [
 
 [[package]]
 name = "common-telemetry"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "atty",
  "backtrace",
@@ -2371,7 +2383,7 @@ dependencies = [
 
 [[package]]
 name = "common-test-util"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "client",
  "common-query",
@@ -2383,7 +2395,7 @@ dependencies = [
 
 [[package]]
 name = "common-time"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "arrow",
  "chrono",
@@ -2401,7 +2413,7 @@ dependencies = [
 
 [[package]]
 name = "common-version"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "build-data",
  "const_format",
@@ -2411,7 +2423,7 @@ dependencies = [
 
 [[package]]
 name = "common-wal"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "common-base",
  "common-error",
@@ -3342,7 +3354,7 @@ dependencies = [
 
 [[package]]
 name = "datanode"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "arrow-flight",
@@ -3394,7 +3406,7 @@ dependencies = [
  "session",
  "snafu 0.8.5",
  "store-api",
- "substrait 0.13.0",
+ "substrait 0.12.2",
  "table",
  "tokio",
  "toml 0.8.19",
@@ -3403,7 +3415,7 @@ dependencies = [
 
 [[package]]
 name = "datatypes"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "arrow",
  "arrow-array",
@@ -4047,7 +4059,7 @@ dependencies = [
 
 [[package]]
 name = "file-engine"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "async-trait",
@@ -4157,7 +4169,7 @@ checksum = "8bf7cc16383c4b8d58b9905a8509f02926ce3058053c056376248d958c9df1e8"
 
 [[package]]
 name = "flow"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "arrow",
@@ -4167,7 +4179,6 @@ dependencies = [
  "bytes",
  "cache",
  "catalog",
- "chrono",
  "client",
  "common-base",
  "common-catalog",
@@ -4219,7 +4230,7 @@ dependencies = [
  "snafu 0.8.5",
  "store-api",
  "strum 0.25.0",
- "substrait 0.13.0",
+ "substrait 0.12.2",
  "table",
  "tokio",
  "tonic 0.12.3",
@@ -4274,7 +4285,7 @@ checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa"
 
 [[package]]
 name = "frontend"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "arc-swap",
@@ -5542,7 +5553,7 @@ dependencies = [
 
 [[package]]
 name = "index"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-trait",
  "asynchronous-codec",
@@ -6334,7 +6345,7 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "log-query"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "chrono",
  "common-error",
@@ -6346,7 +6357,7 @@ dependencies = [
 
 [[package]]
 name = "log-store"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -6639,7 +6650,7 @@ dependencies = [
 
 [[package]]
 name = "meta-client"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "async-trait",
@@ -6666,7 +6677,7 @@ dependencies = [
 
 [[package]]
 name = "meta-srv"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "async-trait",
@@ -6752,7 +6763,7 @@ dependencies = [
 
 [[package]]
 name = "metric-engine"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "aquamarine",
@@ -6850,7 +6861,7 @@ dependencies = [
 
 [[package]]
 name = "mito2"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "aquamarine",
@@ -7547,7 +7558,7 @@ dependencies = [
 
 [[package]]
 name = "object-store"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "anyhow",
  "bytes",
@@ -7796,7 +7807,7 @@ dependencies = [
 
 [[package]]
 name = "operator"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "ahash 0.8.11",
  "api",
@@ -7844,7 +7855,7 @@ dependencies = [
  "sql",
  "sqlparser 0.52.0 (git+https://github.com/GreptimeTeam/sqlparser-rs.git?rev=71dd86058d2af97b9925093d40c4e03360403170)",
  "store-api",
- "substrait 0.13.0",
+ "substrait 0.12.2",
  "table",
  "tokio",
  "tokio-util",
@@ -8081,7 +8092,7 @@ dependencies = [
 
 [[package]]
 name = "partition"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "async-trait",
@@ -8349,7 +8360,7 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "pipeline"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "ahash 0.8.11",
  "api",
@@ -8489,7 +8500,7 @@ dependencies = [
 
 [[package]]
 name = "plugins"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "auth",
  "clap 4.5.19",
@@ -8751,7 +8762,7 @@ dependencies = [
 
 [[package]]
 name = "promql"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "ahash 0.8.11",
  "async-trait",
@@ -8996,7 +9007,7 @@ dependencies = [
 
 [[package]]
 name = "puffin"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-compression 0.4.13",
  "async-trait",
@@ -9037,7 +9048,7 @@ dependencies = [
 
 [[package]]
 name = "query"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "ahash 0.8.11",
  "api",
@@ -9102,7 +9113,7 @@ dependencies = [
  "sqlparser 0.52.0 (git+https://github.com/GreptimeTeam/sqlparser-rs.git?rev=71dd86058d2af97b9925093d40c4e03360403170)",
  "statrs",
  "store-api",
- "substrait 0.13.0",
+ "substrait 0.12.2",
  "table",
  "tokio",
  "tokio-stream",
@@ -10447,7 +10458,7 @@ dependencies = [
 
 [[package]]
 name = "servers"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "ahash 0.8.11",
  "api",
@@ -10564,7 +10575,7 @@ dependencies = [
 
 [[package]]
 name = "session"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "arc-swap",
@@ -10873,7 +10884,7 @@ dependencies = [
 
 [[package]]
 name = "sql"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "chrono",
@@ -10927,7 +10938,7 @@ dependencies = [
 
 [[package]]
 name = "sqlness-runner"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-trait",
  "clap 4.5.19",
@@ -11244,7 +11255,7 @@ dependencies = [
 
 [[package]]
 name = "store-api"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "aquamarine",
@@ -11374,7 +11385,7 @@ dependencies = [
 
 [[package]]
 name = "substrait"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "async-trait",
  "bytes",
@@ -11555,7 +11566,7 @@ dependencies = [
 
 [[package]]
 name = "table"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "async-trait",
@@ -11806,7 +11817,7 @@ checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
 
 [[package]]
 name = "tests-fuzz"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "arbitrary",
  "async-trait",
@@ -11850,7 +11861,7 @@ dependencies = [
 
 [[package]]
 name = "tests-integration"
-version = "0.13.0"
+version = "0.12.2"
 dependencies = [
  "api",
  "arrow-flight",
@@ -11916,7 +11927,7 @@ dependencies = [
  "sql",
  "sqlx",
  "store-api",
- "substrait 0.13.0",
+ "substrait 0.12.2",
  "table",
  "tempfile",
  "time",

Cargo.toml

@@ -67,7 +67,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.13.0"
+version = "0.12.2"
 edition = "2021"
 license = "Apache-2.0"
 

config/datanode.example.toml

@@ -231,6 +231,7 @@ overwrite_entry_start_id = false
 # secret_access_key = "123456"
 # endpoint = "https://s3.amazonaws.com"
 # region = "us-west-2"
+# enable_virtual_host_style = false
 
 # Example of using Oss as the storage.
 # [storage]

config/standalone.example.toml

@@ -318,6 +318,7 @@ retry_delay = "500ms"
 # secret_access_key = "123456"
 # endpoint = "https://s3.amazonaws.com"
 # region = "us-west-2"
+# enable_virtual_host_style = false
 
 # Example of using Oss as the storage.
 # [storage]

cyborg/bin/bump-versions.ts

@@ -0,0 +1,156 @@
+/*
+ * 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.
+ */
+
+import * as core from "@actions/core";
+import {obtainClient} from "@/common";
+
+interface RepoConfig {
+  tokenEnv: string;
+  repo: string;
+  workflowLogic: (version: string) => [string, string] | null;
+}
+
+const REPO_CONFIGS: Record<string, RepoConfig> = {
+  website: {
+    tokenEnv: "WEBSITE_REPO_TOKEN",
+    repo: "website",
+    workflowLogic: (version: string) => {
+      // Skip nightly versions for website
+      if (version.includes('nightly')) {
+        console.log('Nightly version detected for website, skipping workflow trigger.');
+        return null;
+      }
+      return ['bump-patch-version.yml', version];
+    }
+  },
+  demo: {
+    tokenEnv: "DEMO_REPO_TOKEN",
+    repo: "demo-scene",
+    workflowLogic: (version: string) => {
+      // Skip nightly versions for demo
+      if (version.includes('nightly')) {
+        console.log('Nightly version detected for demo, skipping workflow trigger.');
+        return null;
+      }
+      return ['bump-patch-version.yml', version];
+    }
+  },
+  docs: {
+    tokenEnv: "DOCS_REPO_TOKEN",
+    repo: "docs",
+    workflowLogic: (version: string) => {
+      // Check if it's a nightly version
+      if (version.includes('nightly')) {
+        return ['bump-nightly-version.yml', version];
+      }
+
+      const parts = version.split('.');
+      if (parts.length !== 3) {
+        throw new Error('Invalid version format');
+      }
+
+      // If patch version (last number) is 0, it's a major version
+      // Return only major.minor version
+      if (parts[2] === '0') {
+        return ['bump-version.yml', `${parts[0]}.${parts[1]}`];
+      }
+
+      // Otherwise it's a patch version, use full version
+      return ['bump-patch-version.yml', version];
+    }
+  }
+};
+
+async function triggerWorkflow(repoConfig: RepoConfig, workflowId: string, version: string) {
+  const client = obtainClient(repoConfig.tokenEnv);
+  try {
+    await client.rest.actions.createWorkflowDispatch({
+      owner: "GreptimeTeam",
+      repo: repoConfig.repo,
+      workflow_id: workflowId,
+      ref: "main",
+      inputs: {
+        version,
+      },
+    });
+    console.log(`Successfully triggered ${workflowId} workflow for ${repoConfig.repo} with version ${version}`);
+  } catch (error) {
+    core.setFailed(`Failed to trigger workflow for ${repoConfig.repo}: ${error.message}`);
+    throw error;
+  }
+}
+
+async function processRepo(repoName: string, version: string) {
+  const repoConfig = REPO_CONFIGS[repoName];
+  if (!repoConfig) {
+    throw new Error(`Unknown repository: ${repoName}`);
+  }
+
+  try {
+    const workflowResult = repoConfig.workflowLogic(version);
+    if (workflowResult === null) {
+      // Skip this repo (e.g., nightly version for website)
+      return;
+    }
+
+    const [workflowId, apiVersion] = workflowResult;
+    await triggerWorkflow(repoConfig, workflowId, apiVersion);
+  } catch (error) {
+    core.setFailed(`Error processing ${repoName} with version ${version}: ${error.message}`);
+    throw error;
+  }
+}
+
+async function main() {
+  const version = process.env.VERSION;
+  if (!version) {
+    core.setFailed("VERSION environment variable is required");
+    process.exit(1);
+  }
+
+  // Remove 'v' prefix if exists
+  const cleanVersion = version.startsWith('v') ? version.slice(1) : version;
+
+  // Get target repositories from environment variable
+  // Default to both if not specified
+  const targetRepos = process.env.TARGET_REPOS?.split(',').map(repo => repo.trim()) || ['website', 'docs'];
+
+  console.log(`Processing version ${cleanVersion} for repositories: ${targetRepos.join(', ')}`);
+
+  const errors: string[] = [];
+
+  // Process each repository
+  for (const repo of targetRepos) {
+    try {
+      await processRepo(repo, cleanVersion);
+    } catch (error) {
+      errors.push(`${repo}: ${error.message}`);
+    }
+  }
+
+  if (errors.length > 0) {
+    core.setFailed(`Failed to process some repositories: ${errors.join('; ')}`);
+    process.exit(1);
+  }
+
+  console.log('All repositories processed successfully');
+}
+
+// Execute main function
+main().catch((error) => {
+  core.setFailed(`Unexpected error: ${error.message}`);
+  process.exit(1);
+});

cyborg/bin/follow-up-docs-issue.ts

@@ -55,12 +55,25 @@ async function main() {
         await client.rest.issues.addLabels({
             owner, repo, issue_number: number, labels: [labelDocsRequired],
         })
+
+        // Get available assignees for the docs repo
+        const assigneesResponse = await docsClient.rest.issues.listAssignees({
+            owner: 'GreptimeTeam',
+            repo: 'docs',
+        })
+        const validAssignees = assigneesResponse.data.map(assignee => assignee.login)
+        core.info(`Available assignees: ${validAssignees.join(', ')}`)
+
+        // Check if the actor is a valid assignee, otherwise fallback to fengjiachun
+        const assignee = validAssignees.includes(actor) ? actor : 'fengjiachun'
+        core.info(`Assigning issue to: ${assignee}`)
+
         await docsClient.rest.issues.create({
             owner: 'GreptimeTeam',
             repo: 'docs',
             title: `Update docs for ${title}`,
             body: `A document change request is generated from ${html_url}`,
-            assignee: actor,
+            assignee: assignee,
         }).then((res) => {
             core.info(`Created issue ${res.data}`)
         })

docker/buildx/ubuntu/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:22.04 as builder
+FROM ubuntu:20.04 as builder
 
 ARG CARGO_PROFILE
 ARG FEATURES

docker/ci/ubuntu/Dockerfile.fuzztests

@@ -1,4 +1,4 @@
-FROM ubuntu:latest
+FROM ubuntu:22.04
 
 # The binary name of GreptimeDB executable.
 # Defaults to "greptime", but sometimes in other projects it might be different.

docker/dev-builder/ubuntu/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:22.04
+FROM ubuntu:20.04
 
 # The root path under which contains all the dependencies to build this Dockerfile.
 ARG DOCKER_BUILD_ROOT=.
@@ -41,7 +41,7 @@ RUN mv protoc3/include/* /usr/local/include/
 # and the repositories are pulled from trusted sources (still us, of course). Doing so does not violate the intention
 # of the Git's addition to the "safe.directory" at the first place (see the commit message here:
 # https://github.com/git/git/commit/8959555cee7ec045958f9b6dd62e541affb7e7d9).
-# There's also another solution to this, that we add the desired submodules to the safe directory, instead of using
+# There's also another solution to this, that we add the desired submodules to the safe directory, instead of using 
 # wildcard here. However, that requires the git's config files and the submodules all owned by the very same user.
 # It's troublesome to do this since the dev build runs in Docker, which is under user "root"; while outside the Docker,
 # it can be a different user that have prepared the submodules.

docker/dev-builder/ubuntu/Dockerfile-18.10

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

docker/dev-builder/ubuntu/Dockerfile-20.04

@@ -1,66 +0,0 @@
-FROM ubuntu:20.04
-
-# The root path under which contains all the dependencies to build this Dockerfile.
-ARG DOCKER_BUILD_ROOT=.
-
-ENV LANG en_US.utf8
-WORKDIR /greptimedb
-
-RUN apt-get update && \
-    DEBIAN_FRONTEND=noninteractive apt-get install -y software-properties-common
-# Install dependencies.
-RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
-    libssl-dev \
-    tzdata \
-    curl \
-    unzip \
-    ca-certificates \
-    git \
-    build-essential \
-    pkg-config
-
-ARG TARGETPLATFORM
-RUN echo "target platform: $TARGETPLATFORM"
-
-ARG PROTOBUF_VERSION=29.3
-
-# Install protobuf, because the one in the apt is too old (v3.12).
-RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
-    curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOBUF_VERSION}/protoc-${PROTOBUF_VERSION}-linux-aarch_64.zip && \
-    unzip protoc-${PROTOBUF_VERSION}-linux-aarch_64.zip -d protoc3; \
-elif [ "$TARGETPLATFORM" = "linux/amd64" ]; then \
-    curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOBUF_VERSION}/protoc-${PROTOBUF_VERSION}-linux-x86_64.zip && \
-    unzip protoc-${PROTOBUF_VERSION}-linux-x86_64.zip -d protoc3; \
-fi
-RUN mv protoc3/bin/* /usr/local/bin/
-RUN mv protoc3/include/* /usr/local/include/
-
-# Silence all `safe.directory` warnings, to avoid the "detect dubious repository" error when building with submodules.
-# Disabling the safe directory check here won't pose extra security issues, because in our usage for this dev build
-# image, we use it solely on our own environment (that github action's VM, or ECS created dynamically by ourselves),
-# and the repositories are pulled from trusted sources (still us, of course). Doing so does not violate the intention
-# of the Git's addition to the "safe.directory" at the first place (see the commit message here:
-# https://github.com/git/git/commit/8959555cee7ec045958f9b6dd62e541affb7e7d9).
-# There's also another solution to this, that we add the desired submodules to the safe directory, instead of using 
-# wildcard here. However, that requires the git's config files and the submodules all owned by the very same user.
-# It's troublesome to do this since the dev build runs in Docker, which is under user "root"; while outside the Docker,
-# it can be a different user that have prepared the submodules.
-RUN git config --global --add safe.directory '*'
-
-# Install Rust.
-SHELL ["/bin/bash", "-c"]
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --no-modify-path --default-toolchain none -y
-ENV PATH /root/.cargo/bin/:$PATH
-
-# Install Rust toolchains.
-ARG RUST_TOOLCHAIN
-RUN rustup toolchain install ${RUST_TOOLCHAIN}
-
-# Install cargo-binstall with a specific version to adapt the current rust toolchain.
-# Note: if we use the latest version, we may encounter the following `use of unstable library feature 'io_error_downcast'` error.
-# compile from source take too long, so we use the precompiled binary instead
-COPY $DOCKER_BUILD_ROOT/docker/dev-builder/binstall/pull_binstall.sh /usr/local/bin/pull_binstall.sh
-RUN chmod +x /usr/local/bin/pull_binstall.sh && /usr/local/bin/pull_binstall.sh
-
-# Install nextest.
-RUN cargo binstall cargo-nextest --no-confirm

docs/benchmarks/tsbs/v0.12.0.md

@@ -1,40 +0,0 @@
-# TSBS benchmark - v0.12.0
-
-## Environment
-
-### Amazon EC2
-
-|         |                         |
-|---------|-------------------------|
-| Machine | c5d.2xlarge             |
-| CPU     | 8 core                  |
-| Memory  | 16GB                    |
-| Disk    | 100GB (GP3)             |
-| OS      | Ubuntu Server 24.04 LTS |
-
-## Write performance
-
-| Environment     | Ingest rate (rows/s) |
-|-----------------|----------------------|
-| EC2 c5d.2xlarge | 326839.28            |
-
-## Query performance
-
-| Query type            | EC2 c5d.2xlarge (ms) |
-|-----------------------|----------------------|
-| cpu-max-all-1         | 12.46                |
-| cpu-max-all-8         | 24.20                |
-| double-groupby-1      | 673.08               |
-| double-groupby-5      | 963.99               |
-| double-groupby-all    | 1330.05              |
-| groupby-orderby-limit | 952.46               |
-| high-cpu-1            | 5.08                 |
-| high-cpu-all          | 4638.57              |
-| lastpoint             | 591.02               |
-| single-groupby-1-1-1  | 4.06                 |
-| single-groupby-1-1-12 | 4.73                 |
-| single-groupby-1-8-1  | 8.23                 |
-| single-groupby-5-1-1  | 4.61                 |
-| single-groupby-5-1-12 | 5.61                 |
-| single-groupby-5-8-1  | 9.74                 |
-

scripts/install.sh

@@ -53,6 +53,54 @@ get_arch_type() {
   esac
 }
 
+# Verify SHA256 checksum
+verify_sha256() {
+  file="$1"
+  expected_sha256="$2"
+
+  if command -v sha256sum >/dev/null 2>&1; then
+    actual_sha256=$(sha256sum "$file" | cut -d' ' -f1)
+  elif command -v shasum >/dev/null 2>&1; then
+    actual_sha256=$(shasum -a 256 "$file" | cut -d' ' -f1)
+  else
+    echo "Warning: No SHA256 verification tool found (sha256sum or shasum). Skipping checksum verification."
+    return 0
+  fi
+
+  if [ "$actual_sha256" = "$expected_sha256" ]; then
+    echo "SHA256 checksum verified successfully."
+    return 0
+  else
+    echo "Error: SHA256 checksum verification failed!"
+    echo "Expected: $expected_sha256"
+    echo "Actual: $actual_sha256"
+    return 1
+  fi
+}
+
+# Prompt for user confirmation (compatible with different shells)
+prompt_confirmation() {
+  message="$1"
+  printf "%s (y/N): " "$message"
+
+  # Try to read user input, fallback if read fails
+  answer=""
+  if read answer </dev/tty 2>/dev/null; then
+    case "$answer" in
+      [Yy]|[Yy][Ee][Ss])
+        return 0
+        ;;
+      *)
+        return 1
+        ;;
+    esac
+  else
+    echo ""
+    echo "Cannot read user input. Defaulting to No."
+    return 1
+  fi
+}
+
 download_artifact() {
   if [ -n "${OS_TYPE}" ] && [ -n "${ARCH_TYPE}" ]; then
     # Use the latest stable released version.
@@ -71,17 +119,104 @@ download_artifact() {
     fi
 
     echo "Downloading ${BIN}, OS: ${OS_TYPE}, Arch: ${ARCH_TYPE}, Version: ${VERSION}"
-    PACKAGE_NAME="${BIN}-${OS_TYPE}-${ARCH_TYPE}-${VERSION}.tar.gz"
+    PKG_NAME="${BIN}-${OS_TYPE}-${ARCH_TYPE}-${VERSION}"
+    PACKAGE_NAME="${PKG_NAME}.tar.gz"
+    SHA256_FILE="${PKG_NAME}.sha256sum"
 
     if [ -n "${PACKAGE_NAME}" ]; then
-      wget "https://github.com/${GITHUB_ORG}/${GITHUB_REPO}/releases/download/${VERSION}/${PACKAGE_NAME}"
+      # Check if files already exist and prompt for override
+      if [ -f "${PACKAGE_NAME}" ]; then
+        echo "File ${PACKAGE_NAME} already exists."
+        if prompt_confirmation "Do you want to override it?"; then
+          echo "Overriding existing file..."
+          rm -f "${PACKAGE_NAME}"
+        else
+          echo "Skipping download. Using existing file."
+        fi
+      fi
+
+      if [ -f "${BIN}" ]; then
+        echo "Binary ${BIN} already exists."
+        if prompt_confirmation "Do you want to override it?"; then
+          echo "Will override existing binary..."
+          rm -f "${BIN}"
+        else
+          echo "Installation cancelled."
+          exit 0
+        fi
+      fi
+
+      # Download package if not exists
+      if [ ! -f "${PACKAGE_NAME}" ]; then
+        echo "Downloading ${PACKAGE_NAME}..."
+        # Use curl instead of wget for better compatibility
+        if command -v curl >/dev/null 2>&1; then
+          if ! curl -L -o "${PACKAGE_NAME}" "https://github.com/${GITHUB_ORG}/${GITHUB_REPO}/releases/download/${VERSION}/${PACKAGE_NAME}"; then
+            echo "Error: Failed to download ${PACKAGE_NAME}"
+            exit 1
+          fi
+        elif command -v wget >/dev/null 2>&1; then
+          if ! wget -O "${PACKAGE_NAME}" "https://github.com/${GITHUB_ORG}/${GITHUB_REPO}/releases/download/${VERSION}/${PACKAGE_NAME}"; then
+            echo "Error: Failed to download ${PACKAGE_NAME}"
+            exit 1
+          fi
+        else
+          echo "Error: Neither curl nor wget is available for downloading."
+          exit 1
+        fi
+      fi
+
+      # Download and verify SHA256 checksum
+      echo "Downloading SHA256 checksum..."
+      sha256_download_success=0
+      if command -v curl >/dev/null 2>&1; then
+        if curl -L -s -o "${SHA256_FILE}" "https://github.com/${GITHUB_ORG}/${GITHUB_REPO}/releases/download/${VERSION}/${SHA256_FILE}" 2>/dev/null; then
+          sha256_download_success=1
+        fi
+      elif command -v wget >/dev/null 2>&1; then
+        if wget -q -O "${SHA256_FILE}" "https://github.com/${GITHUB_ORG}/${GITHUB_REPO}/releases/download/${VERSION}/${SHA256_FILE}" 2>/dev/null; then
+          sha256_download_success=1
+        fi
+      fi
+
+      if [ $sha256_download_success -eq 1 ] && [ -f "${SHA256_FILE}" ]; then
+        expected_sha256=$(cat "${SHA256_FILE}" | cut -d' ' -f1)
+        if [ -n "$expected_sha256" ]; then
+          if ! verify_sha256 "${PACKAGE_NAME}" "${expected_sha256}"; then
+            echo "SHA256 verification failed. Removing downloaded file."
+            rm -f "${PACKAGE_NAME}" "${SHA256_FILE}"
+            exit 1
+          fi
+        else
+          echo "Warning: Could not parse SHA256 checksum from file."
+        fi
+        rm -f "${SHA256_FILE}"
+      else
+        echo "Warning: Could not download SHA256 checksum file. Skipping verification."
+      fi
 
       # Extract the binary and clean the rest.
-      tar xvf "${PACKAGE_NAME}" && \
-      mv "${PACKAGE_NAME%.tar.gz}/${BIN}" "${PWD}" && \
-      rm -r "${PACKAGE_NAME}" && \
-      rm -r "${PACKAGE_NAME%.tar.gz}" && \
-      echo "Run './${BIN} --help' to get started"
+      echo "Extracting ${PACKAGE_NAME}..."
+      if ! tar xf "${PACKAGE_NAME}"; then
+        echo "Error: Failed to extract ${PACKAGE_NAME}"
+        exit 1
+      fi
+
+      # Find the binary in the extracted directory
+      extracted_dir="${PACKAGE_NAME%.tar.gz}"
+      if [ -f "${extracted_dir}/${BIN}" ]; then
+        mv "${extracted_dir}/${BIN}" "${PWD}/"
+        rm -f "${PACKAGE_NAME}"
+        rm -rf "${extracted_dir}"
+        chmod +x "${BIN}"
+        echo "Installation completed successfully!"
+        echo "Run './${BIN} --help' to get started"
+      else
+        echo "Error: Binary ${BIN} not found in extracted archive"
+        rm -f "${PACKAGE_NAME}"
+        rm -rf "${extracted_dir}"
+        exit 1
+      fi
     fi
   fi
 }

src/api/src/v1/column_def.rs

@@ -15,8 +15,8 @@
 use std::collections::HashMap;
 
 use datatypes::schema::{
-    ColumnDefaultConstraint, ColumnSchema, FulltextAnalyzer, FulltextOptions, SkippingIndexOptions,
-    SkippingIndexType, COMMENT_KEY, FULLTEXT_KEY, INVERTED_INDEX_KEY, SKIPPING_INDEX_KEY,
+    ColumnDefaultConstraint, ColumnSchema, FulltextAnalyzer, FulltextOptions, SkippingIndexType,
+    COMMENT_KEY, FULLTEXT_KEY, INVERTED_INDEX_KEY, SKIPPING_INDEX_KEY,
 };
 use greptime_proto::v1::{Analyzer, SkippingIndexType as PbSkippingIndexType};
 use snafu::ResultExt;
@@ -103,13 +103,6 @@ pub fn contains_fulltext(options: &Option<ColumnOptions>) -> bool {
         .is_some_and(|o| o.options.contains_key(FULLTEXT_GRPC_KEY))
 }
 
-/// Checks if the `ColumnOptions` contains skipping index options.
-pub fn contains_skipping(options: &Option<ColumnOptions>) -> bool {
-    options
-        .as_ref()
-        .is_some_and(|o| o.options.contains_key(SKIPPING_INDEX_GRPC_KEY))
-}
-
 /// Tries to construct a `ColumnOptions` from the given `FulltextOptions`.
 pub fn options_from_fulltext(fulltext: &FulltextOptions) -> Result<Option<ColumnOptions>> {
     let mut options = ColumnOptions::default();
@@ -120,18 +113,6 @@ pub fn options_from_fulltext(fulltext: &FulltextOptions) -> Result<Option<Column
     Ok((!options.options.is_empty()).then_some(options))
 }
 
-/// Tries to construct a `ColumnOptions` from the given `SkippingIndexOptions`.
-pub fn options_from_skipping(skipping: &SkippingIndexOptions) -> Result<Option<ColumnOptions>> {
-    let mut options = ColumnOptions::default();
-
-    let v = serde_json::to_string(skipping).context(error::SerializeJsonSnafu)?;
-    options
-        .options
-        .insert(SKIPPING_INDEX_GRPC_KEY.to_string(), v);
-
-    Ok((!options.options.is_empty()).then_some(options))
-}
-
 /// Tries to construct a `FulltextAnalyzer` from the given analyzer.
 pub fn as_fulltext_option(analyzer: Analyzer) -> FulltextAnalyzer {
     match analyzer {

src/catalog/src/kvbackend/manager.rs

@@ -38,7 +38,6 @@ use partition::manager::{PartitionRuleManager, PartitionRuleManagerRef};
 use session::context::{Channel, QueryContext};
 use snafu::prelude::*;
 use table::dist_table::DistTable;
-use table::metadata::TableId;
 use table::table::numbers::{NumbersTable, NUMBERS_TABLE_NAME};
 use table::table_name::TableName;
 use table::TableRef;
@@ -287,28 +286,6 @@ impl CatalogManager for KvBackendCatalogManager {
         return Ok(None);
     }
 
-    async fn tables_by_ids(
-        &self,
-        catalog: &str,
-        schema: &str,
-        table_ids: &[TableId],
-    ) -> Result<Vec<TableRef>> {
-        let table_info_values = self
-            .table_metadata_manager
-            .table_info_manager()
-            .batch_get(table_ids)
-            .await
-            .context(TableMetadataManagerSnafu)?;
-
-        let tables = table_info_values
-            .into_values()
-            .filter(|t| t.table_info.catalog_name == catalog && t.table_info.schema_name == schema)
-            .map(build_table)
-            .collect::<Result<Vec<_>>>()?;
-
-        Ok(tables)
-    }
-
     fn tables<'a>(
         &'a self,
         catalog: &'a str,

src/catalog/src/lib.rs

@@ -87,14 +87,6 @@ pub trait CatalogManager: Send + Sync {
         query_ctx: Option<&QueryContext>,
     ) -> Result<Option<TableRef>>;
 
-    /// Returns the tables by table ids.
-    async fn tables_by_ids(
-        &self,
-        catalog: &str,
-        schema: &str,
-        table_ids: &[TableId],
-    ) -> Result<Vec<TableRef>>;
-
     /// Returns all tables with a stream by catalog and schema.
     fn tables<'a>(
         &'a self,

src/catalog/src/memory/manager.rs

@@ -14,7 +14,7 @@
 
 use std::any::Any;
 use std::collections::hash_map::Entry;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::sync::{Arc, RwLock, Weak};
 
 use async_stream::{stream, try_stream};
@@ -28,7 +28,6 @@ use common_meta::kv_backend::memory::MemoryKvBackend;
 use futures_util::stream::BoxStream;
 use session::context::QueryContext;
 use snafu::OptionExt;
-use table::metadata::TableId;
 use table::TableRef;
 
 use crate::error::{CatalogNotFoundSnafu, Result, SchemaNotFoundSnafu, TableExistsSnafu};
@@ -144,33 +143,6 @@ impl CatalogManager for MemoryCatalogManager {
         Ok(result)
     }
 
-    async fn tables_by_ids(
-        &self,
-        catalog: &str,
-        schema: &str,
-        table_ids: &[TableId],
-    ) -> Result<Vec<TableRef>> {
-        let catalogs = self.catalogs.read().unwrap();
-
-        let schemas = catalogs.get(catalog).context(CatalogNotFoundSnafu {
-            catalog_name: catalog,
-        })?;
-
-        let tables = schemas
-            .get(schema)
-            .context(SchemaNotFoundSnafu { catalog, schema })?;
-
-        let filter_ids: HashSet<_> = table_ids.iter().collect();
-        // It is very inefficient, but we do not need to optimize it since it will not be called in `MemoryCatalogManager`.
-        let tables = tables
-            .values()
-            .filter(|t| filter_ids.contains(&t.table_info().table_id()))
-            .cloned()
-            .collect::<Vec<_>>();
-
-        Ok(tables)
-    }
-
     fn tables<'a>(
         &'a self,
         catalog: &'a str,

src/client/src/lib.rs

@@ -16,6 +16,7 @@
 
 mod client;
 pub mod client_manager;
+#[cfg(feature = "testing")]
 mod database;
 pub mod error;
 pub mod flow;
@@ -33,6 +34,7 @@ pub use common_recordbatch::{RecordBatches, SendableRecordBatchStream};
 use snafu::OptionExt;
 
 pub use self::client::Client;
+#[cfg(feature = "testing")]
 pub use self::database::Database;
 pub use self::error::{Error, Result};
 use crate::error::{IllegalDatabaseResponseSnafu, ServerSnafu};

src/cmd/Cargo.toml

@@ -9,6 +9,10 @@ default-run = "greptime"
 name = "greptime"
 path = "src/bin/greptime.rs"
 
+[[bin]]
+name = "objbench"
+path = "src/bin/objbench.rs"
+
 [features]
 default = ["servers/pprof", "servers/mem-prof"]
 tokio-console = ["common-telemetry/tokio-console"]
@@ -20,6 +24,7 @@ workspace = true
 async-trait.workspace = true
 auth.workspace = true
 base64.workspace = true
+colored = "2.0"
 cache.workspace = true
 catalog.workspace = true
 chrono.workspace = true
@@ -55,6 +60,9 @@ futures.workspace = true
 human-panic = "2.0"
 humantime.workspace = true
 lazy_static.workspace = true
+object-store.workspace = true
+parquet = "53"
+pprof = "0.14"
 meta-client.workspace = true
 meta-srv.workspace = true
 metric-engine.workspace = true

src/cmd/src/bin/greptime.rs

@@ -21,6 +21,8 @@ use cmd::{cli, datanode, flownode, frontend, metasrv, standalone, App};
 use common_version::version;
 use servers::install_ring_crypto_provider;
 
+pub mod objbench;
+
 #[derive(Parser)]
 #[command(name = "greptime", author, version, long_version = version(), about)]
 #[command(propagate_version = true)]

src/cmd/src/bin/objbench.rs

@@ -0,0 +1,602 @@
+// Copyright 2025 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::path::{Path, PathBuf};
+use std::time::Instant;
+
+use clap::Parser;
+use cmd::error::{self, Result};
+use colored::Colorize;
+use datanode::config::ObjectStoreConfig;
+use mito2::config::{FulltextIndexConfig, MitoConfig, Mode};
+use mito2::read::Source;
+use mito2::sst::file::{FileHandle, FileId, FileMeta};
+use mito2::sst::file_purger::{FilePurger, FilePurgerRef, PurgeRequest};
+use mito2::sst::parquet::{WriteOptions, PARQUET_METADATA_KEY};
+use mito2::{build_access_layer, Metrics, OperationType, SstWriteRequest};
+use object_store::ObjectStore;
+use serde::{Deserialize, Serialize};
+use store_api::metadata::{RegionMetadata, RegionMetadataRef};
+
+#[tokio::main]
+pub async fn main() {
+    // common_telemetry::init_default_ut_logging();
+    let cmd = Command::parse();
+    if let Err(e) = cmd.run().await {
+        eprintln!("{}: {}", "Error".red().bold(), e);
+        std::process::exit(1);
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(default)]
+pub struct StorageConfigWrapper {
+    storage: StorageConfig,
+}
+
+/// Storage engine config
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(default)]
+pub struct StorageConfig {
+    /// The working directory of database
+    pub data_home: String,
+    #[serde(flatten)]
+    pub store: ObjectStoreConfig,
+}
+
+#[derive(Debug, Parser)]
+pub struct Command {
+    /// Path to the object-store config file (TOML). Must deserialize into datanode::config::ObjectStoreConfig.
+    #[clap(long, value_name = "FILE")]
+    pub config: PathBuf,
+
+    /// Source SST file path in object-store (e.g. "region_dir/<uuid>.parquet").
+    #[clap(long, value_name = "PATH")]
+    pub source: String,
+
+    /// Target SST file path in object-store; its parent directory is used as destination region dir.
+    #[clap(long, value_name = "PATH")]
+    pub target: String,
+
+    /// Verbose output
+    #[clap(short, long, default_value_t = false)]
+    pub verbose: bool,
+
+    /// Output file path for pprof flamegraph (enables profiling)
+    #[clap(long, value_name = "FILE")]
+    pub pprof_file: Option<PathBuf>,
+}
+
+impl Command {
+    pub async fn run(&self) -> Result<()> {
+        if self.verbose {
+            common_telemetry::init_default_ut_logging();
+        }
+
+        println!("{}", "Starting objbench...".cyan().bold());
+
+        // Build object store from config
+        let cfg_str = std::fs::read_to_string(&self.config).map_err(|e| {
+            error::IllegalConfigSnafu {
+                msg: format!("failed to read config {}: {e}", self.config.display()),
+            }
+            .build()
+        })?;
+        let store_cfg: StorageConfigWrapper = toml::from_str(&cfg_str).map_err(|e| {
+            error::IllegalConfigSnafu {
+                msg: format!("failed to parse config {}: {e}", self.config.display()),
+            }
+            .build()
+        })?;
+
+        let object_store = build_object_store(&store_cfg.storage).await?;
+        println!("{} Object store initialized", "✓".green());
+
+        // Prepare source identifiers
+        let (src_region_dir, src_file_id) = split_sst_path(&self.source)?;
+        println!("{} Source path parsed: {}", "✓".green(), self.source);
+
+        // Load parquet metadata to extract RegionMetadata and file stats
+        println!("{}", "Loading parquet metadata...".yellow());
+        let file_size = object_store
+            .stat(&self.source)
+            .await
+            .map_err(|e| {
+                error::IllegalConfigSnafu {
+                    msg: format!("stat failed: {e}"),
+                }
+                .build()
+            })?
+            .content_length();
+        let parquet_meta = load_parquet_metadata(object_store.clone(), &self.source, file_size)
+            .await
+            .map_err(|e| {
+                error::IllegalConfigSnafu {
+                    msg: format!("read parquet metadata failed: {e}"),
+                }
+                .build()
+            })?;
+
+        let region_meta = extract_region_metadata(&self.source, &parquet_meta)?;
+        let num_rows = parquet_meta.file_metadata().num_rows() as u64;
+        let num_row_groups = parquet_meta.num_row_groups() as u64;
+
+        println!(
+            "{} Metadata loaded - rows: {}, size: {} bytes",
+            "✓".green(),
+            num_rows,
+            file_size
+        );
+
+        // Build a FileHandle for the source file
+        let file_meta = FileMeta {
+            region_id: region_meta.region_id,
+            file_id: src_file_id,
+            time_range: Default::default(),
+            level: 0,
+            file_size,
+            available_indexes: Default::default(),
+            index_file_size: 0,
+            num_rows,
+            num_row_groups,
+            sequence: None,
+        };
+        let src_handle = FileHandle::new(file_meta, new_noop_file_purger());
+
+        // Build the reader for a single file via ParquetReaderBuilder
+        println!("{}", "Building reader...".yellow());
+        let (_src_access_layer, _cache_manager) =
+            build_access_layer_simple(src_region_dir.clone(), object_store.clone()).await?;
+        let reader_build_start = Instant::now();
+        let reader = mito2::sst::parquet::reader::ParquetReaderBuilder::new(
+            src_region_dir.clone(),
+            src_handle.clone(),
+            object_store.clone(),
+        )
+        .expected_metadata(Some(region_meta.clone()))
+        .build()
+        .await
+        .map_err(|e| {
+            error::IllegalConfigSnafu {
+                msg: format!("build reader failed: {e}"),
+            }
+            .build()
+        })?;
+
+        let reader_build_elapsed = reader_build_start.elapsed();
+        let total_rows = reader.parquet_metadata().file_metadata().num_rows();
+        println!("{} Reader built in {:?}", "✓".green(), reader_build_elapsed);
+
+        // Prepare target access layer for writing
+        println!("{}", "Preparing target access layer...".yellow());
+        let (tgt_access_layer, tgt_cache_manager) =
+            build_access_layer_simple(self.target.clone(), object_store.clone()).await?;
+
+        // Build write request
+        let fulltext_index_config = FulltextIndexConfig {
+            create_on_compaction: Mode::Disable,
+            ..Default::default()
+        };
+        let write_opts = WriteOptions::default();
+        let write_req = SstWriteRequest {
+            op_type: OperationType::Compact,
+            metadata: region_meta,
+            source: Source::Reader(Box::new(reader)),
+            cache_manager: tgt_cache_manager,
+            storage: None,
+            max_sequence: None,
+            index_options: Default::default(),
+            inverted_index_config: MitoConfig::default().inverted_index,
+            fulltext_index_config,
+            bloom_filter_index_config: MitoConfig::default().bloom_filter_index,
+        };
+
+        // Write SST
+        println!("{}", "Writing SST...".yellow());
+        let mut metrics = Metrics::default();
+
+        // Start profiling if pprof_file is specified
+        #[cfg(unix)]
+        let profiler_guard = if self.pprof_file.is_some() {
+            println!("{} Starting profiling...", "⚡".yellow());
+            Some(
+                pprof::ProfilerGuardBuilder::default()
+                    .frequency(99)
+                    .blocklist(&["libc", "libgcc", "pthread", "vdso"])
+                    .build()
+                    .map_err(|e| {
+                        error::IllegalConfigSnafu {
+                            msg: format!("Failed to start profiler: {e}"),
+                        }
+                        .build()
+                    })?,
+            )
+        } else {
+            None
+        };
+
+        #[cfg(not(unix))]
+        if self.pprof_file.is_some() {
+            eprintln!(
+                "{}: Profiling is not supported on this platform",
+                "Warning".yellow()
+            );
+        }
+
+        let write_start = Instant::now();
+        let infos = tgt_access_layer
+            .write_sst(write_req, &write_opts, &mut metrics)
+            .await
+            .map_err(|e| {
+                error::IllegalConfigSnafu {
+                    msg: format!("write_sst failed: {e}"),
+                }
+                .build()
+            })?;
+
+        let write_elapsed = write_start.elapsed();
+
+        // Stop profiling and generate flamegraph if enabled
+        #[cfg(unix)]
+        if let (Some(guard), Some(pprof_file)) = (profiler_guard, &self.pprof_file) {
+            println!("{} Generating flamegraph...", "🔥".yellow());
+            match guard.report().build() {
+                Ok(report) => {
+                    let mut flamegraph_data = Vec::new();
+                    if let Err(e) = report.flamegraph(&mut flamegraph_data) {
+                        eprintln!(
+                            "{}: Failed to generate flamegraph: {}",
+                            "Warning".yellow(),
+                            e
+                        );
+                    } else if let Err(e) = std::fs::write(pprof_file, flamegraph_data) {
+                        eprintln!(
+                            "{}: Failed to write flamegraph to {}: {}",
+                            "Warning".yellow(),
+                            pprof_file.display(),
+                            e
+                        );
+                    } else {
+                        println!(
+                            "{} Flamegraph saved to {}",
+                            "✓".green(),
+                            pprof_file.display().to_string().cyan()
+                        );
+                    }
+                }
+                Err(e) => {
+                    eprintln!(
+                        "{}: Failed to generate pprof report: {}",
+                        "Warning".yellow(),
+                        e
+                    );
+                }
+            }
+        }
+        assert_eq!(infos.len(), 1);
+        let dst_file_id = infos[0].file_id;
+        let dst_file_path = format!("{}{}", self.target, dst_file_id.as_parquet(),);
+
+        // Report results with ANSI colors
+        println!("\n{} {}", "Write complete!".green().bold(), "✓".green());
+        println!("  {}: {}", "Destination file".bold(), dst_file_path.cyan());
+        println!("  {}: {}", "Rows".bold(), total_rows.to_string().cyan());
+        println!(
+            "  {}: {}",
+            "File size".bold(),
+            format!("{} bytes", file_size).cyan()
+        );
+        println!(
+            "  {}: {:?}",
+            "Reader build time".bold(),
+            reader_build_elapsed
+        );
+        println!("  {}: {:?}", "Total time".bold(), write_elapsed);
+
+        // Print metrics in a formatted way
+        println!(
+            "  {}: {:?}, sum: {:?}",
+            "Metrics".bold(),
+            metrics,
+            metrics.sum()
+        );
+
+        // Print infos
+        println!("  {}: {:?}", "Index".bold(), infos[0].index_metadata);
+
+        // Cleanup
+        println!("\n{}", "Cleaning up...".yellow());
+        object_store.delete(&dst_file_path).await.map_err(|e| {
+            error::IllegalConfigSnafu {
+                msg: format!("Failed to delete dest file {}: {}", dst_file_path, e),
+            }
+            .build()
+        })?;
+        println!("{} Temporary file deleted", "✓".green());
+
+        println!("\n{}", "Benchmark completed successfully!".green().bold());
+        Ok(())
+    }
+}
+
+fn split_sst_path(path: &str) -> Result<(String, FileId)> {
+    let p = Path::new(path);
+    let file_name = p.file_name().and_then(|s| s.to_str()).ok_or_else(|| {
+        error::IllegalConfigSnafu {
+            msg: "invalid source path".to_string(),
+        }
+        .build()
+    })?;
+    let uuid_str = file_name.strip_suffix(".parquet").ok_or_else(|| {
+        error::IllegalConfigSnafu {
+            msg: "expect .parquet file".to_string(),
+        }
+        .build()
+    })?;
+    let file_id = FileId::parse_str(uuid_str).map_err(|e| {
+        error::IllegalConfigSnafu {
+            msg: format!("invalid file id: {e}"),
+        }
+        .build()
+    })?;
+    let parent = p
+        .parent()
+        .and_then(|s| s.to_str())
+        .unwrap_or("")
+        .to_string();
+    Ok((parent, file_id))
+}
+
+fn extract_region_metadata(
+    file_path: &str,
+    meta: &parquet::file::metadata::ParquetMetaData,
+) -> Result<RegionMetadataRef> {
+    use parquet::format::KeyValue;
+    let kvs: Option<&Vec<KeyValue>> = meta.file_metadata().key_value_metadata();
+    let Some(kvs) = kvs else {
+        return Err(error::IllegalConfigSnafu {
+            msg: format!("{file_path}: missing parquet key_value metadata"),
+        }
+        .build());
+    };
+    let json = kvs
+        .iter()
+        .find(|kv| kv.key == PARQUET_METADATA_KEY)
+        .and_then(|kv| kv.value.as_ref())
+        .ok_or_else(|| {
+            error::IllegalConfigSnafu {
+                msg: format!("{file_path}: key {PARQUET_METADATA_KEY} not found or empty"),
+            }
+            .build()
+        })?;
+    let region: RegionMetadata = RegionMetadata::from_json(json).map_err(|e| {
+        error::IllegalConfigSnafu {
+            msg: format!("invalid region metadata json: {e}"),
+        }
+        .build()
+    })?;
+    Ok(std::sync::Arc::new(region))
+}
+
+async fn build_object_store(sc: &StorageConfig) -> Result<ObjectStore> {
+    use datanode::config::ObjectStoreConfig::*;
+    let oss = &sc.store;
+    match oss {
+        File(_) => {
+            use object_store::services::Fs;
+            let builder = Fs::default().root(&sc.data_home);
+            Ok(ObjectStore::new(builder)
+                .map_err(|e| {
+                    error::IllegalConfigSnafu {
+                        msg: format!("init fs backend failed: {e}"),
+                    }
+                    .build()
+                })?
+                .finish())
+        }
+        S3(s3) => {
+            use common_base::secrets::ExposeSecret;
+            use object_store::services::S3;
+            use object_store::util;
+            let root = util::normalize_dir(&s3.root);
+            let mut builder = S3::default()
+                .root(&root)
+                .bucket(&s3.bucket)
+                .access_key_id(s3.access_key_id.expose_secret())
+                .secret_access_key(s3.secret_access_key.expose_secret());
+            if let Some(ep) = &s3.endpoint {
+                builder = builder.endpoint(ep);
+            }
+            if let Some(region) = &s3.region {
+                builder = builder.region(region);
+            }
+            if s3.enable_virtual_host_style {
+                builder = builder.enable_virtual_host_style();
+            }
+            Ok(ObjectStore::new(builder)
+                .map_err(|e| {
+                    error::IllegalConfigSnafu {
+                        msg: format!("init s3 backend failed: {e}"),
+                    }
+                    .build()
+                })?
+                .finish())
+        }
+        Oss(oss) => {
+            use common_base::secrets::ExposeSecret;
+            use object_store::services::Oss;
+            use object_store::util;
+            let root = util::normalize_dir(&oss.root);
+            let builder = Oss::default()
+                .root(&root)
+                .bucket(&oss.bucket)
+                .endpoint(&oss.endpoint)
+                .access_key_id(oss.access_key_id.expose_secret())
+                .access_key_secret(oss.access_key_secret.expose_secret());
+            Ok(ObjectStore::new(builder)
+                .map_err(|e| {
+                    error::IllegalConfigSnafu {
+                        msg: format!("init oss backend failed: {e}"),
+                    }
+                    .build()
+                })?
+                .finish())
+        }
+        Azblob(az) => {
+            use common_base::secrets::ExposeSecret;
+            use object_store::services::Azblob;
+            use object_store::util;
+            let root = util::normalize_dir(&az.root);
+            let mut builder = Azblob::default()
+                .root(&root)
+                .container(&az.container)
+                .endpoint(&az.endpoint)
+                .account_name(az.account_name.expose_secret())
+                .account_key(az.account_key.expose_secret());
+            if let Some(token) = &az.sas_token {
+                builder = builder.sas_token(token);
+            }
+            Ok(ObjectStore::new(builder)
+                .map_err(|e| {
+                    error::IllegalConfigSnafu {
+                        msg: format!("init azblob backend failed: {e}"),
+                    }
+                    .build()
+                })?
+                .finish())
+        }
+        Gcs(gcs) => {
+            use common_base::secrets::ExposeSecret;
+            use object_store::services::Gcs;
+            use object_store::util;
+            let root = util::normalize_dir(&gcs.root);
+            let builder = Gcs::default()
+                .root(&root)
+                .bucket(&gcs.bucket)
+                .scope(&gcs.scope)
+                .credential_path(gcs.credential_path.expose_secret())
+                .credential(gcs.credential.expose_secret())
+                .endpoint(&gcs.endpoint);
+            Ok(ObjectStore::new(builder)
+                .map_err(|e| {
+                    error::IllegalConfigSnafu {
+                        msg: format!("init gcs backend failed: {e}"),
+                    }
+                    .build()
+                })?
+                .finish())
+        }
+    }
+}
+
+async fn build_access_layer_simple(
+    region_dir: String,
+    object_store: ObjectStore,
+) -> Result<(
+    std::sync::Arc<mito2::AccessLayer>,
+    std::sync::Arc<mito2::CacheManager>,
+)> {
+    // Minimal index aux path setup
+    let mut mito_cfg = MitoConfig::default();
+    // Use a temporary directory as aux path
+    let data_home = std::env::temp_dir().join("greptime_objbench");
+    let _ = std::fs::create_dir_all(&data_home);
+    let _ = mito_cfg.index.sanitize(
+        data_home.to_str().unwrap_or("/tmp"),
+        &mito_cfg.inverted_index,
+    );
+    let access_layer = build_access_layer(&region_dir, object_store, &mito_cfg)
+        .await
+        .map_err(|e| {
+            error::IllegalConfigSnafu {
+                msg: format!("build_access_layer failed: {e}"),
+            }
+            .build()
+        })?;
+    Ok((
+        access_layer,
+        std::sync::Arc::new(mito2::CacheManager::default()),
+    ))
+}
+
+fn new_noop_file_purger() -> FilePurgerRef {
+    #[derive(Debug)]
+    struct Noop;
+    impl FilePurger for Noop {
+        fn send_request(&self, _request: PurgeRequest) {}
+    }
+    std::sync::Arc::new(Noop)
+}
+
+async fn load_parquet_metadata(
+    object_store: ObjectStore,
+    path: &str,
+    file_size: u64,
+) -> std::result::Result<
+    parquet::file::metadata::ParquetMetaData,
+    Box<dyn std::error::Error + Send + Sync>,
+> {
+    use parquet::file::metadata::ParquetMetaDataReader;
+    use parquet::file::FOOTER_SIZE;
+    let actual_size = if file_size == 0 {
+        object_store.stat(path).await?.content_length()
+    } else {
+        file_size
+    };
+    if actual_size < FOOTER_SIZE as u64 {
+        return Err("file too small".into());
+    }
+    let prefetch: u64 = 64 * 1024;
+    let start = actual_size.saturating_sub(prefetch);
+    let buffer = object_store
+        .read_with(path)
+        .range(start..actual_size)
+        .await?
+        .to_vec();
+    let buffer_len = buffer.len();
+    let mut footer = [0; 8];
+    footer.copy_from_slice(&buffer[buffer_len - FOOTER_SIZE..]);
+    let metadata_len = ParquetMetaDataReader::decode_footer(&footer)? as u64;
+    if actual_size - (FOOTER_SIZE as u64) < metadata_len {
+        return Err("invalid footer/metadata length".into());
+    }
+    if (metadata_len as usize) <= buffer_len - FOOTER_SIZE {
+        let metadata_start = buffer_len - metadata_len as usize - FOOTER_SIZE;
+        let meta = ParquetMetaDataReader::decode_metadata(
+            &buffer[metadata_start..buffer_len - FOOTER_SIZE],
+        )?;
+        Ok(meta)
+    } else {
+        let metadata_start = actual_size - metadata_len - FOOTER_SIZE as u64;
+        let data = object_store
+            .read_with(path)
+            .range(metadata_start..(actual_size - FOOTER_SIZE as u64))
+            .await?
+            .to_vec();
+        let meta = ParquetMetaDataReader::decode_metadata(&data)?;
+        Ok(meta)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::StorageConfigWrapper;
+
+    #[test]
+    fn test_decode() {
+        let cfg = std::fs::read_to_string("/home/lei/datanode-bulk.toml").unwrap();
+        let storage: StorageConfigWrapper = toml::from_str(&cfg).unwrap();
+        println!("{:?}", storage);
+    }
+}

src/cmd/src/flownode.rs

@@ -32,7 +32,7 @@ use common_meta::key::TableMetadataManager;
 use common_telemetry::info;
 use common_telemetry::logging::TracingOptions;
 use common_version::{short_version, version};
-use flow::{FlownodeBuilder, FlownodeInstance, FrontendClient, FrontendInvoker};
+use flow::{FlownodeBuilder, FlownodeInstance, FrontendInvoker};
 use meta_client::{MetaClientOptions, MetaClientType};
 use servers::Mode;
 use snafu::{OptionExt, ResultExt};
@@ -317,8 +317,6 @@ impl StartCommand {
             Arc::new(executor),
         );
 
-        let frontend_client = FrontendClient::from_meta_client(meta_client.clone());
-
         let flow_metadata_manager = Arc::new(FlowMetadataManager::new(cached_meta_backend.clone()));
         let flownode_builder = FlownodeBuilder::new(
             opts,
@@ -326,7 +324,6 @@ impl StartCommand {
             table_metadata_manager,
             catalog_manager.clone(),
             flow_metadata_manager,
-            Arc::new(frontend_client),
         )
         .with_heartbeat_task(heartbeat_task);
 

src/cmd/src/standalone.rs

@@ -54,10 +54,7 @@ use datanode::config::{DatanodeOptions, ProcedureConfig, RegionEngineConfig, Sto
 use datanode::datanode::{Datanode, DatanodeBuilder};
 use datanode::region_server::RegionServer;
 use file_engine::config::EngineConfig as FileEngineConfig;
-use flow::{
-    FlowConfig, FlowWorkerManager, FlownodeBuilder, FlownodeOptions, FrontendClient,
-    FrontendInvoker,
-};
+use flow::{FlowConfig, FlowWorkerManager, FlownodeBuilder, FlownodeOptions, FrontendInvoker};
 use frontend::frontend::FrontendOptions;
 use frontend::instance::builder::FrontendBuilder;
 use frontend::instance::{FrontendInstance, Instance as FeInstance, StandaloneDatanodeManager};
@@ -536,16 +533,12 @@ impl StartCommand {
             flow: opts.flow.clone(),
             ..Default::default()
         };
-
-        let fe_server_addr = fe_opts.grpc.bind_addr.clone();
-        let frontend_client = FrontendClient::from_static_grpc_addr(fe_server_addr);
         let flow_builder = FlownodeBuilder::new(
             flownode_options,
             plugins.clone(),
             table_metadata_manager.clone(),
             catalog_manager.clone(),
             flow_metadata_manager.clone(),
-            Arc::new(frontend_client),
         );
         let flownode = Arc::new(
             flow_builder

src/common/catalog/src/consts.rs

@@ -130,10 +130,3 @@ pub const SEMANTIC_TYPE_TIME_INDEX: &str = "TIMESTAMP";
 pub fn is_readonly_schema(schema: &str) -> bool {
     matches!(schema, INFORMATION_SCHEMA_NAME)
 }
-
-// ---- special table and fields ----
-pub const TRACE_ID_COLUMN: &str = "trace_id";
-pub const SPAN_ID_COLUMN: &str = "span_id";
-pub const SPAN_NAME_COLUMN: &str = "span_name";
-pub const PARENT_SPAN_ID_COLUMN: &str = "parent_span_id";
-// ---- End of special table and fields ----

src/common/function/Cargo.toml

@@ -28,8 +28,6 @@ common-telemetry.workspace = true
 common-time.workspace = true
 common-version.workspace = true
 datafusion.workspace = true
-datafusion-common.workspace = true
-datafusion-expr.workspace = true
 datatypes.workspace = true
 derive_more = { version = "1", default-features = false, features = ["display"] }
 geo = { version = "0.29", optional = true }

src/common/function/src/aggr.rs

@@ -12,11 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-mod geo_path;
 mod hll;
 mod uddsketch_state;
 
-pub use geo_path::{GeoPathAccumulator, GEO_PATH_NAME};
 pub(crate) use hll::HllStateType;
 pub use hll::{HllState, HLL_MERGE_NAME, HLL_NAME};
 pub use uddsketch_state::{UddSketchState, UDDSKETCH_STATE_NAME};

src/common/function/src/aggr/geo_path.rs

@@ -1,433 +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 datafusion::arrow::array::{Array, ArrayRef};
-use datafusion::common::cast::as_primitive_array;
-use datafusion::error::{DataFusionError, Result as DfResult};
-use datafusion::logical_expr::{Accumulator as DfAccumulator, AggregateUDF, Volatility};
-use datafusion::prelude::create_udaf;
-use datafusion_common::cast::{as_list_array, as_struct_array};
-use datafusion_common::utils::SingleRowListArrayBuilder;
-use datafusion_common::ScalarValue;
-use datatypes::arrow::array::{Float64Array, Int64Array, ListArray, StructArray};
-use datatypes::arrow::datatypes::{
-    DataType, Field, Float64Type, Int64Type, TimeUnit, TimestampNanosecondType,
-};
-use datatypes::compute::{self, sort_to_indices};
-
-pub const GEO_PATH_NAME: &str = "geo_path";
-
-const LATITUDE_FIELD: &str = "lat";
-const LONGITUDE_FIELD: &str = "lng";
-const TIMESTAMP_FIELD: &str = "timestamp";
-const DEFAULT_LIST_FIELD_NAME: &str = "item";
-
-#[derive(Debug, Default)]
-pub struct GeoPathAccumulator {
-    lat: Vec<Option<f64>>,
-    lng: Vec<Option<f64>>,
-    timestamp: Vec<Option<i64>>,
-}
-
-impl GeoPathAccumulator {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn udf_impl() -> AggregateUDF {
-        create_udaf(
-            GEO_PATH_NAME,
-            // Input types: lat, lng, timestamp
-            vec![
-                DataType::Float64,
-                DataType::Float64,
-                DataType::Timestamp(TimeUnit::Nanosecond, None),
-            ],
-            // Output type: list of points {[lat], [lng]}
-            Arc::new(DataType::Struct(
-                vec![
-                    Field::new(
-                        LATITUDE_FIELD,
-                        DataType::List(Arc::new(Field::new(
-                            DEFAULT_LIST_FIELD_NAME,
-                            DataType::Float64,
-                            true,
-                        ))),
-                        false,
-                    ),
-                    Field::new(
-                        LONGITUDE_FIELD,
-                        DataType::List(Arc::new(Field::new(
-                            DEFAULT_LIST_FIELD_NAME,
-                            DataType::Float64,
-                            true,
-                        ))),
-                        false,
-                    ),
-                ]
-                .into(),
-            )),
-            Volatility::Immutable,
-            // Create the accumulator
-            Arc::new(|_| Ok(Box::new(GeoPathAccumulator::new()))),
-            // Intermediate state types
-            Arc::new(vec![DataType::Struct(
-                vec![
-                    Field::new(
-                        LATITUDE_FIELD,
-                        DataType::List(Arc::new(Field::new(
-                            DEFAULT_LIST_FIELD_NAME,
-                            DataType::Float64,
-                            true,
-                        ))),
-                        false,
-                    ),
-                    Field::new(
-                        LONGITUDE_FIELD,
-                        DataType::List(Arc::new(Field::new(
-                            DEFAULT_LIST_FIELD_NAME,
-                            DataType::Float64,
-                            true,
-                        ))),
-                        false,
-                    ),
-                    Field::new(
-                        TIMESTAMP_FIELD,
-                        DataType::List(Arc::new(Field::new(
-                            DEFAULT_LIST_FIELD_NAME,
-                            DataType::Int64,
-                            true,
-                        ))),
-                        false,
-                    ),
-                ]
-                .into(),
-            )]),
-        )
-    }
-}
-
-impl DfAccumulator for GeoPathAccumulator {
-    fn update_batch(&mut self, values: &[ArrayRef]) -> datafusion::error::Result<()> {
-        if values.len() != 3 {
-            return Err(DataFusionError::Internal(format!(
-                "Expected 3 columns for geo_path, got {}",
-                values.len()
-            )));
-        }
-
-        let lat_array = as_primitive_array::<Float64Type>(&values[0])?;
-        let lng_array = as_primitive_array::<Float64Type>(&values[1])?;
-        let ts_array = as_primitive_array::<TimestampNanosecondType>(&values[2])?;
-
-        let size = lat_array.len();
-        self.lat.reserve(size);
-        self.lng.reserve(size);
-
-        for idx in 0..size {
-            self.lat.push(if lat_array.is_null(idx) {
-                None
-            } else {
-                Some(lat_array.value(idx))
-            });
-
-            self.lng.push(if lng_array.is_null(idx) {
-                None
-            } else {
-                Some(lng_array.value(idx))
-            });
-
-            self.timestamp.push(if ts_array.is_null(idx) {
-                None
-            } else {
-                Some(ts_array.value(idx))
-            });
-        }
-
-        Ok(())
-    }
-
-    fn evaluate(&mut self) -> DfResult<ScalarValue> {
-        let unordered_lng_array = Float64Array::from(self.lng.clone());
-        let unordered_lat_array = Float64Array::from(self.lat.clone());
-        let ts_array = Int64Array::from(self.timestamp.clone());
-
-        let ordered_indices = sort_to_indices(&ts_array, None, None)?;
-        let lat_array = compute::take(&unordered_lat_array, &ordered_indices, None)?;
-        let lng_array = compute::take(&unordered_lng_array, &ordered_indices, None)?;
-
-        let lat_list = Arc::new(SingleRowListArrayBuilder::new(lat_array).build_list_array());
-        let lng_list = Arc::new(SingleRowListArrayBuilder::new(lng_array).build_list_array());
-
-        let result = ScalarValue::Struct(Arc::new(StructArray::new(
-            vec![
-                Field::new(
-                    LATITUDE_FIELD,
-                    DataType::List(Arc::new(Field::new("item", DataType::Float64, true))),
-                    false,
-                ),
-                Field::new(
-                    LONGITUDE_FIELD,
-                    DataType::List(Arc::new(Field::new("item", DataType::Float64, true))),
-                    false,
-                ),
-            ]
-            .into(),
-            vec![lat_list, lng_list],
-            None,
-        )));
-
-        Ok(result)
-    }
-
-    fn size(&self) -> usize {
-        // Base size of GeoPathAccumulator struct fields
-        let mut total_size = std::mem::size_of::<Self>();
-
-        // Size of vectors (approximation)
-        total_size += self.lat.capacity() * std::mem::size_of::<Option<f64>>();
-        total_size += self.lng.capacity() * std::mem::size_of::<Option<f64>>();
-        total_size += self.timestamp.capacity() * std::mem::size_of::<Option<i64>>();
-
-        total_size
-    }
-
-    fn state(&mut self) -> datafusion::error::Result<Vec<ScalarValue>> {
-        let lat_array = Arc::new(ListArray::from_iter_primitive::<Float64Type, _, _>(vec![
-            Some(self.lat.clone()),
-        ]));
-        let lng_array = Arc::new(ListArray::from_iter_primitive::<Float64Type, _, _>(vec![
-            Some(self.lng.clone()),
-        ]));
-        let ts_array = Arc::new(ListArray::from_iter_primitive::<Int64Type, _, _>(vec![
-            Some(self.timestamp.clone()),
-        ]));
-
-        let state_struct = StructArray::new(
-            vec![
-                Field::new(
-                    LATITUDE_FIELD,
-                    DataType::List(Arc::new(Field::new("item", DataType::Float64, true))),
-                    false,
-                ),
-                Field::new(
-                    LONGITUDE_FIELD,
-                    DataType::List(Arc::new(Field::new("item", DataType::Float64, true))),
-                    false,
-                ),
-                Field::new(
-                    TIMESTAMP_FIELD,
-                    DataType::List(Arc::new(Field::new("item", DataType::Int64, true))),
-                    false,
-                ),
-            ]
-            .into(),
-            vec![lat_array, lng_array, ts_array],
-            None,
-        );
-
-        Ok(vec![ScalarValue::Struct(Arc::new(state_struct))])
-    }
-
-    fn merge_batch(&mut self, states: &[ArrayRef]) -> datafusion::error::Result<()> {
-        if states.len() != 1 {
-            return Err(DataFusionError::Internal(format!(
-                "Expected 1 states for geo_path, got {}",
-                states.len()
-            )));
-        }
-
-        for state in states {
-            let state = as_struct_array(state)?;
-            let lat_list = as_list_array(state.column(0))?.value(0);
-            let lat_array = as_primitive_array::<Float64Type>(&lat_list)?;
-            let lng_list = as_list_array(state.column(1))?.value(0);
-            let lng_array = as_primitive_array::<Float64Type>(&lng_list)?;
-            let ts_list = as_list_array(state.column(2))?.value(0);
-            let ts_array = as_primitive_array::<Int64Type>(&ts_list)?;
-
-            self.lat.extend(lat_array);
-            self.lng.extend(lng_array);
-            self.timestamp.extend(ts_array);
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use datafusion::arrow::array::{Float64Array, TimestampNanosecondArray};
-    use datafusion::scalar::ScalarValue;
-
-    use super::*;
-
-    #[test]
-    fn test_geo_path_basic() {
-        let mut accumulator = GeoPathAccumulator::new();
-
-        // Create test data
-        let lat_array = Arc::new(Float64Array::from(vec![1.0, 2.0, 3.0]));
-        let lng_array = Arc::new(Float64Array::from(vec![4.0, 5.0, 6.0]));
-        let ts_array = Arc::new(TimestampNanosecondArray::from(vec![100, 200, 300]));
-
-        // Update batch
-        accumulator
-            .update_batch(&[lat_array, lng_array, ts_array])
-            .unwrap();
-
-        // Evaluate
-        let result = accumulator.evaluate().unwrap();
-        if let ScalarValue::Struct(struct_array) = result {
-            // Verify structure
-            let fields = struct_array.fields().clone();
-            assert_eq!(fields.len(), 2);
-            assert_eq!(fields[0].name(), LATITUDE_FIELD);
-            assert_eq!(fields[1].name(), LONGITUDE_FIELD);
-
-            // Verify data
-            let columns = struct_array.columns();
-            assert_eq!(columns.len(), 2);
-
-            // Check latitude values
-            let lat_list = as_list_array(&columns[0]).unwrap().value(0);
-            let lat_array = as_primitive_array::<Float64Type>(&lat_list).unwrap();
-            assert_eq!(lat_array.len(), 3);
-            assert_eq!(lat_array.value(0), 1.0);
-            assert_eq!(lat_array.value(1), 2.0);
-            assert_eq!(lat_array.value(2), 3.0);
-
-            // Check longitude values
-            let lng_list = as_list_array(&columns[1]).unwrap().value(0);
-            let lng_array = as_primitive_array::<Float64Type>(&lng_list).unwrap();
-            assert_eq!(lng_array.len(), 3);
-            assert_eq!(lng_array.value(0), 4.0);
-            assert_eq!(lng_array.value(1), 5.0);
-            assert_eq!(lng_array.value(2), 6.0);
-        } else {
-            panic!("Expected Struct scalar value");
-        }
-    }
-
-    #[test]
-    fn test_geo_path_sort_by_timestamp() {
-        let mut accumulator = GeoPathAccumulator::new();
-
-        // Create test data with unordered timestamps
-        let lat_array = Arc::new(Float64Array::from(vec![1.0, 2.0, 3.0]));
-        let lng_array = Arc::new(Float64Array::from(vec![4.0, 5.0, 6.0]));
-        let ts_array = Arc::new(TimestampNanosecondArray::from(vec![300, 100, 200]));
-
-        // Update batch
-        accumulator
-            .update_batch(&[lat_array, lng_array, ts_array])
-            .unwrap();
-
-        // Evaluate
-        let result = accumulator.evaluate().unwrap();
-        if let ScalarValue::Struct(struct_array) = result {
-            // Extract arrays
-            let columns = struct_array.columns();
-
-            // Check latitude values
-            let lat_list = as_list_array(&columns[0]).unwrap().value(0);
-            let lat_array = as_primitive_array::<Float64Type>(&lat_list).unwrap();
-            assert_eq!(lat_array.len(), 3);
-            assert_eq!(lat_array.value(0), 2.0); // timestamp 100
-            assert_eq!(lat_array.value(1), 3.0); // timestamp 200
-            assert_eq!(lat_array.value(2), 1.0); // timestamp 300
-
-            // Check longitude values (should be sorted by timestamp)
-            let lng_list = as_list_array(&columns[1]).unwrap().value(0);
-            let lng_array = as_primitive_array::<Float64Type>(&lng_list).unwrap();
-            assert_eq!(lng_array.len(), 3);
-            assert_eq!(lng_array.value(0), 5.0); // timestamp 100
-            assert_eq!(lng_array.value(1), 6.0); // timestamp 200
-            assert_eq!(lng_array.value(2), 4.0); // timestamp 300
-        } else {
-            panic!("Expected Struct scalar value");
-        }
-    }
-
-    #[test]
-    fn test_geo_path_merge() {
-        let mut accumulator1 = GeoPathAccumulator::new();
-        let mut accumulator2 = GeoPathAccumulator::new();
-
-        // Create test data for first accumulator
-        let lat_array1 = Arc::new(Float64Array::from(vec![1.0]));
-        let lng_array1 = Arc::new(Float64Array::from(vec![4.0]));
-        let ts_array1 = Arc::new(TimestampNanosecondArray::from(vec![100]));
-
-        // Create test data for second accumulator
-        let lat_array2 = Arc::new(Float64Array::from(vec![2.0]));
-        let lng_array2 = Arc::new(Float64Array::from(vec![5.0]));
-        let ts_array2 = Arc::new(TimestampNanosecondArray::from(vec![200]));
-
-        // Update batches
-        accumulator1
-            .update_batch(&[lat_array1, lng_array1, ts_array1])
-            .unwrap();
-        accumulator2
-            .update_batch(&[lat_array2, lng_array2, ts_array2])
-            .unwrap();
-
-        // Get states
-        let state1 = accumulator1.state().unwrap();
-        let state2 = accumulator2.state().unwrap();
-
-        // Create a merged accumulator
-        let mut merged = GeoPathAccumulator::new();
-
-        // Extract the struct arrays from the states
-        let state_array1 = match &state1[0] {
-            ScalarValue::Struct(array) => array.clone(),
-            _ => panic!("Expected Struct scalar value"),
-        };
-
-        let state_array2 = match &state2[0] {
-            ScalarValue::Struct(array) => array.clone(),
-            _ => panic!("Expected Struct scalar value"),
-        };
-
-        // Merge state arrays
-        merged.merge_batch(&[state_array1]).unwrap();
-        merged.merge_batch(&[state_array2]).unwrap();
-
-        // Evaluate merged result
-        let result = merged.evaluate().unwrap();
-        if let ScalarValue::Struct(struct_array) = result {
-            // Extract arrays
-            let columns = struct_array.columns();
-
-            // Check latitude values
-            let lat_list = as_list_array(&columns[0]).unwrap().value(0);
-            let lat_array = as_primitive_array::<Float64Type>(&lat_list).unwrap();
-            assert_eq!(lat_array.len(), 2);
-            assert_eq!(lat_array.value(0), 1.0); // timestamp 100
-            assert_eq!(lat_array.value(1), 2.0); // timestamp 200
-
-            // Check longitude values (should be sorted by timestamp)
-            let lng_list = as_list_array(&columns[1]).unwrap().value(0);
-            let lng_array = as_primitive_array::<Float64Type>(&lng_list).unwrap();
-            assert_eq!(lng_array.len(), 2);
-            assert_eq!(lng_array.value(0), 4.0); // timestamp 100
-            assert_eq!(lng_array.value(1), 5.0); // timestamp 200
-        } else {
-            panic!("Expected Struct scalar value");
-        }
-    }
-}

src/common/function/src/aggr/hll.rs

@@ -12,16 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! Two UDAFs are implemented for HyperLogLog:
-//!
-//! - `hll`: Accepts a string column and aggregates the values into a
-//!   HyperLogLog state.
-//! - `hll_merge`: Accepts a binary column of states generated by `hll`
-//!   and merges them into a single state.
-//!
-//! The states can be then used to estimate the cardinality of the
-//! values in the column by `hll_count` UDF.
-
 use std::sync::Arc;
 
 use common_query::prelude::*;

src/common/function/src/aggr/uddsketch_state.rs

@@ -12,12 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! Implementation of the `uddsketch_state` UDAF that generate the state of
-//! UDDSketch for a given set of values.
-//!
-//! The generated state can be used to compute approximate quantiles using
-//! `uddsketch_calc` UDF.
-
 use std::sync::Arc;
 
 use common_query::prelude::*;

src/common/function/src/function.rs

@@ -63,7 +63,7 @@ pub trait Function: fmt::Display + Sync + Send {
     fn signature(&self) -> Signature;
 
     /// Evaluate the function, e.g. run/execute the function.
-    fn eval(&self, ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef>;
+    fn eval(&self, _func_ctx: FunctionContext, _columns: &[VectorRef]) -> Result<VectorRef>;
 }
 
 pub type FunctionRef = Arc<dyn Function>;

src/common/function/src/function_registry.rs

@@ -18,13 +18,11 @@ use std::sync::{Arc, RwLock};
 
 use once_cell::sync::Lazy;
 
-use crate::admin::AdminFunction;
 use crate::function::{AsyncFunctionRef, FunctionRef};
 use crate::scalars::aggregate::{AggregateFunctionMetaRef, AggregateFunctions};
 use crate::scalars::date::DateFunction;
 use crate::scalars::expression::ExpressionFunction;
 use crate::scalars::hll_count::HllCalcFunction;
-use crate::scalars::ip::IpFunctions;
 use crate::scalars::json::JsonFunction;
 use crate::scalars::matches::MatchesFunction;
 use crate::scalars::math::MathFunction;
@@ -32,6 +30,7 @@ use crate::scalars::timestamp::TimestampFunction;
 use crate::scalars::uddsketch_calc::UddSketchCalcFunction;
 use crate::scalars::vector::VectorFunction;
 use crate::system::SystemFunction;
+use crate::table::TableFunction;
 
 #[derive(Default)]
 pub struct FunctionRegistry {
@@ -119,7 +118,7 @@ pub static FUNCTION_REGISTRY: Lazy<Arc<FunctionRegistry>> = Lazy::new(|| {
 
     // System and administration functions
     SystemFunction::register(&function_registry);
-    AdminFunction::register(&function_registry);
+    TableFunction::register(&function_registry);
 
     // Json related functions
     JsonFunction::register(&function_registry);
@@ -131,9 +130,6 @@ pub static FUNCTION_REGISTRY: Lazy<Arc<FunctionRegistry>> = Lazy::new(|| {
     #[cfg(feature = "geo")]
     crate::scalars::geo::GeoFunctions::register(&function_registry);
 
-    // Ip functions
-    IpFunctions::register(&function_registry);
-
     Arc::new(function_registry)
 });
 

src/common/function/src/lib.rs

@@ -15,11 +15,11 @@
 #![feature(let_chains)]
 #![feature(try_blocks)]
 
-mod admin;
 mod flush_flow;
 mod macros;
 pub mod scalars;
 mod system;
+mod table;
 
 pub mod aggr;
 pub mod function;

src/common/function/src/scalars.rs

@@ -23,7 +23,6 @@ pub mod math;
 pub mod vector;
 
 pub(crate) mod hll_count;
-pub mod ip;
 #[cfg(test)]
 pub(crate) mod test;
 pub(crate) mod timestamp;

src/common/function/src/scalars/aggregate.rs

@@ -12,16 +12,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! # Deprecate Warning:
-//!
-//! This module is deprecated and will be removed in the future.
-//! All UDAF implementation here are not maintained and should
-//! not be used before they are refactored into the `src/aggr`
-//! version.
+mod argmax;
+mod argmin;
+mod diff;
+mod mean;
+mod polyval;
+mod scipy_stats_norm_cdf;
+mod scipy_stats_norm_pdf;
 
 use std::sync::Arc;
 
+pub use argmax::ArgmaxAccumulatorCreator;
+pub use argmin::ArgminAccumulatorCreator;
 use common_query::logical_plan::AggregateFunctionCreatorRef;
+pub use diff::DiffAccumulatorCreator;
+pub use mean::MeanAccumulatorCreator;
+pub use polyval::PolyvalAccumulatorCreator;
+pub use scipy_stats_norm_cdf::ScipyStatsNormCdfAccumulatorCreator;
+pub use scipy_stats_norm_pdf::ScipyStatsNormPdfAccumulatorCreator;
 
 use crate::function_registry::FunctionRegistry;
 use crate::scalars::vector::product::VectorProductCreator;
@@ -68,22 +76,31 @@ pub(crate) struct AggregateFunctions;
 
 impl AggregateFunctions {
     pub fn register(registry: &FunctionRegistry) {
-        registry.register_aggregate_function(Arc::new(AggregateFunctionMeta::new(
-            "vec_sum",
-            1,
-            Arc::new(|| Arc::new(VectorSumCreator::default())),
-        )));
-        registry.register_aggregate_function(Arc::new(AggregateFunctionMeta::new(
-            "vec_product",
-            1,
-            Arc::new(|| Arc::new(VectorProductCreator::default())),
-        )));
+        macro_rules! register_aggr_func {
+            ($name :expr, $arg_count :expr, $creator :ty) => {
+                registry.register_aggregate_function(Arc::new(AggregateFunctionMeta::new(
+                    $name,
+                    $arg_count,
+                    Arc::new(|| Arc::new(<$creator>::default())),
+                )));
+            };
+        }
+
+        register_aggr_func!("diff", 1, DiffAccumulatorCreator);
+        register_aggr_func!("mean", 1, MeanAccumulatorCreator);
+        register_aggr_func!("polyval", 2, PolyvalAccumulatorCreator);
+        register_aggr_func!("argmax", 1, ArgmaxAccumulatorCreator);
+        register_aggr_func!("argmin", 1, ArgminAccumulatorCreator);
+        register_aggr_func!("scipystatsnormcdf", 2, ScipyStatsNormCdfAccumulatorCreator);
+        register_aggr_func!("scipystatsnormpdf", 2, ScipyStatsNormPdfAccumulatorCreator);
+        register_aggr_func!("vec_sum", 1, VectorSumCreator);
+        register_aggr_func!("vec_product", 1, VectorProductCreator);
 
         #[cfg(feature = "geo")]
-        registry.register_aggregate_function(Arc::new(AggregateFunctionMeta::new(
+        register_aggr_func!(
             "json_encode_path",
             3,
-            Arc::new(|| Arc::new(super::geo::encoding::JsonPathEncodeFunctionCreator::default())),
-        )));
+            super::geo::encoding::JsonPathEncodeFunctionCreator
+        );
     }
 }

src/common/function/src/scalars/aggregate/argmax.rs

@@ -0,0 +1,208 @@
+// 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::cmp::Ordering;
+use std::sync::Arc;
+
+use common_macro::{as_aggr_func_creator, AggrFuncTypeStore};
+use common_query::error::{
+    BadAccumulatorImplSnafu, CreateAccumulatorSnafu, InvalidInputStateSnafu, Result,
+};
+use common_query::logical_plan::accumulator::AggrFuncTypeStore;
+use common_query::logical_plan::{Accumulator, AggregateFunctionCreator};
+use common_query::prelude::*;
+use datatypes::prelude::*;
+use datatypes::types::{LogicalPrimitiveType, WrapperType};
+use datatypes::vectors::{ConstantVector, Helper};
+use datatypes::with_match_primitive_type_id;
+use snafu::ensure;
+
+// https://numpy.org/doc/stable/reference/generated/numpy.argmax.html
+// return the index of the max value
+#[derive(Debug, Default)]
+pub struct Argmax<T> {
+    max: Option<T>,
+    n: u64,
+}
+
+impl<T> Argmax<T>
+where
+    T: PartialOrd + Copy,
+{
+    fn update(&mut self, value: T, index: u64) {
+        if let Some(Ordering::Less) = self.max.partial_cmp(&Some(value)) {
+            self.max = Some(value);
+            self.n = index;
+        }
+    }
+}
+
+impl<T> Accumulator for Argmax<T>
+where
+    T: WrapperType + PartialOrd,
+{
+    fn state(&self) -> Result<Vec<Value>> {
+        match self.max {
+            Some(max) => Ok(vec![max.into(), self.n.into()]),
+            _ => Ok(vec![Value::Null, self.n.into()]),
+        }
+    }
+
+    fn update_batch(&mut self, values: &[VectorRef]) -> Result<()> {
+        if values.is_empty() {
+            return Ok(());
+        }
+
+        let column = &values[0];
+        let column: &<T as Scalar>::VectorType = if column.is_const() {
+            let column: &ConstantVector = unsafe { Helper::static_cast(column) };
+            unsafe { Helper::static_cast(column.inner()) }
+        } else {
+            unsafe { Helper::static_cast(column) }
+        };
+        for (i, v) in column.iter_data().enumerate() {
+            if let Some(value) = v {
+                self.update(value, i as u64);
+            }
+        }
+        Ok(())
+    }
+
+    fn merge_batch(&mut self, states: &[VectorRef]) -> Result<()> {
+        if states.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(
+            states.len() == 2,
+            BadAccumulatorImplSnafu {
+                err_msg: "expect 2 states in `merge_batch`",
+            }
+        );
+
+        let max = &states[0];
+        let index = &states[1];
+        let max: &<T as Scalar>::VectorType = unsafe { Helper::static_cast(max) };
+        let index: &<u64 as Scalar>::VectorType = unsafe { Helper::static_cast(index) };
+        index
+            .iter_data()
+            .flatten()
+            .zip(max.iter_data().flatten())
+            .for_each(|(i, max)| self.update(max, i));
+        Ok(())
+    }
+
+    fn evaluate(&self) -> Result<Value> {
+        match self.max {
+            Some(_) => Ok(self.n.into()),
+            _ => Ok(Value::Null),
+        }
+    }
+}
+
+#[as_aggr_func_creator]
+#[derive(Debug, Default, AggrFuncTypeStore)]
+pub struct ArgmaxAccumulatorCreator {}
+
+impl AggregateFunctionCreator for ArgmaxAccumulatorCreator {
+    fn creator(&self) -> AccumulatorCreatorFunction {
+        let creator: AccumulatorCreatorFunction = Arc::new(move |types: &[ConcreteDataType]| {
+            let input_type = &types[0];
+            with_match_primitive_type_id!(
+                input_type.logical_type_id(),
+                |$S| {
+                    Ok(Box::new(Argmax::<<$S as LogicalPrimitiveType>::Wrapper>::default()))
+                },
+                {
+                    let err_msg = format!(
+                        "\"ARGMAX\" aggregate function not support data type {:?}",
+                        input_type.logical_type_id(),
+                    );
+                    CreateAccumulatorSnafu { err_msg }.fail()?
+                }
+            )
+        });
+        creator
+    }
+
+    fn output_type(&self) -> Result<ConcreteDataType> {
+        Ok(ConcreteDataType::uint64_datatype())
+    }
+
+    fn state_types(&self) -> Result<Vec<ConcreteDataType>> {
+        let input_types = self.input_types()?;
+
+        ensure!(input_types.len() == 1, InvalidInputStateSnafu);
+
+        Ok(vec![
+            input_types.into_iter().next().unwrap(),
+            ConcreteDataType::uint64_datatype(),
+        ])
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use datatypes::vectors::Int32Vector;
+
+    use super::*;
+    #[test]
+    fn test_update_batch() {
+        // test update empty batch, expect not updating anything
+        let mut argmax = Argmax::<i32>::default();
+        argmax.update_batch(&[]).unwrap();
+        assert_eq!(Value::Null, argmax.evaluate().unwrap());
+
+        // test update one not-null value
+        let mut argmax = Argmax::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Some(42)]))];
+        argmax.update_batch(&v).unwrap();
+        assert_eq!(Value::from(0_u64), argmax.evaluate().unwrap());
+
+        // test update one null value
+        let mut argmax = Argmax::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Option::<i32>::None]))];
+        argmax.update_batch(&v).unwrap();
+        assert_eq!(Value::Null, argmax.evaluate().unwrap());
+
+        // test update no null-value batch
+        let mut argmax = Argmax::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![
+            Some(-1i32),
+            Some(1),
+            Some(3),
+        ]))];
+        argmax.update_batch(&v).unwrap();
+        assert_eq!(Value::from(2_u64), argmax.evaluate().unwrap());
+
+        // test update null-value batch
+        let mut argmax = Argmax::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![
+            Some(-2i32),
+            None,
+            Some(4),
+        ]))];
+        argmax.update_batch(&v).unwrap();
+        assert_eq!(Value::from(2_u64), argmax.evaluate().unwrap());
+
+        // test update with constant vector
+        let mut argmax = Argmax::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(ConstantVector::new(
+            Arc::new(Int32Vector::from_vec(vec![4])),
+            10,
+        ))];
+        argmax.update_batch(&v).unwrap();
+        assert_eq!(Value::from(0_u64), argmax.evaluate().unwrap());
+    }
+}

src/common/function/src/scalars/aggregate/argmin.rs

@@ -0,0 +1,216 @@
+// 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::cmp::Ordering;
+use std::sync::Arc;
+
+use common_macro::{as_aggr_func_creator, AggrFuncTypeStore};
+use common_query::error::{
+    BadAccumulatorImplSnafu, CreateAccumulatorSnafu, InvalidInputStateSnafu, Result,
+};
+use common_query::logical_plan::accumulator::AggrFuncTypeStore;
+use common_query::logical_plan::{Accumulator, AggregateFunctionCreator};
+use common_query::prelude::*;
+use datatypes::prelude::*;
+use datatypes::vectors::{ConstantVector, Helper};
+use datatypes::with_match_primitive_type_id;
+use snafu::ensure;
+
+// // https://numpy.org/doc/stable/reference/generated/numpy.argmin.html
+#[derive(Debug, Default)]
+pub struct Argmin<T> {
+    min: Option<T>,
+    n: u32,
+}
+
+impl<T> Argmin<T>
+where
+    T: Copy + PartialOrd,
+{
+    fn update(&mut self, value: T, index: u32) {
+        match self.min {
+            Some(min) => {
+                if let Some(Ordering::Greater) = min.partial_cmp(&value) {
+                    self.min = Some(value);
+                    self.n = index;
+                }
+            }
+            None => {
+                self.min = Some(value);
+                self.n = index;
+            }
+        }
+    }
+}
+
+impl<T> Accumulator for Argmin<T>
+where
+    T: WrapperType + PartialOrd,
+{
+    fn state(&self) -> Result<Vec<Value>> {
+        match self.min {
+            Some(min) => Ok(vec![min.into(), self.n.into()]),
+            _ => Ok(vec![Value::Null, self.n.into()]),
+        }
+    }
+
+    fn update_batch(&mut self, values: &[VectorRef]) -> Result<()> {
+        if values.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(values.len() == 1, InvalidInputStateSnafu);
+
+        let column = &values[0];
+        let column: &<T as Scalar>::VectorType = if column.is_const() {
+            let column: &ConstantVector = unsafe { Helper::static_cast(column) };
+            unsafe { Helper::static_cast(column.inner()) }
+        } else {
+            unsafe { Helper::static_cast(column) }
+        };
+        for (i, v) in column.iter_data().enumerate() {
+            if let Some(value) = v {
+                self.update(value, i as u32);
+            }
+        }
+        Ok(())
+    }
+
+    fn merge_batch(&mut self, states: &[VectorRef]) -> Result<()> {
+        if states.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(
+            states.len() == 2,
+            BadAccumulatorImplSnafu {
+                err_msg: "expect 2 states in `merge_batch`",
+            }
+        );
+
+        let min = &states[0];
+        let index = &states[1];
+        let min: &<T as Scalar>::VectorType = unsafe { Helper::static_cast(min) };
+        let index: &<u32 as Scalar>::VectorType = unsafe { Helper::static_cast(index) };
+        index
+            .iter_data()
+            .flatten()
+            .zip(min.iter_data().flatten())
+            .for_each(|(i, min)| self.update(min, i));
+        Ok(())
+    }
+
+    fn evaluate(&self) -> Result<Value> {
+        match self.min {
+            Some(_) => Ok(self.n.into()),
+            _ => Ok(Value::Null),
+        }
+    }
+}
+
+#[as_aggr_func_creator]
+#[derive(Debug, Default, AggrFuncTypeStore)]
+pub struct ArgminAccumulatorCreator {}
+
+impl AggregateFunctionCreator for ArgminAccumulatorCreator {
+    fn creator(&self) -> AccumulatorCreatorFunction {
+        let creator: AccumulatorCreatorFunction = Arc::new(move |types: &[ConcreteDataType]| {
+            let input_type = &types[0];
+            with_match_primitive_type_id!(
+                input_type.logical_type_id(),
+                |$S| {
+                    Ok(Box::new(Argmin::<<$S as LogicalPrimitiveType>::Wrapper>::default()))
+                },
+                {
+                    let err_msg = format!(
+                        "\"ARGMIN\" aggregate function not support data type {:?}",
+                        input_type.logical_type_id(),
+                    );
+                    CreateAccumulatorSnafu { err_msg }.fail()?
+                }
+            )
+        });
+        creator
+    }
+
+    fn output_type(&self) -> Result<ConcreteDataType> {
+        Ok(ConcreteDataType::uint32_datatype())
+    }
+
+    fn state_types(&self) -> Result<Vec<ConcreteDataType>> {
+        let input_types = self.input_types()?;
+
+        ensure!(input_types.len() == 1, InvalidInputStateSnafu);
+
+        Ok(vec![
+            input_types.into_iter().next().unwrap(),
+            ConcreteDataType::uint32_datatype(),
+        ])
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use datatypes::vectors::Int32Vector;
+
+    use super::*;
+    #[test]
+    fn test_update_batch() {
+        // test update empty batch, expect not updating anything
+        let mut argmin = Argmin::<i32>::default();
+        argmin.update_batch(&[]).unwrap();
+        assert_eq!(Value::Null, argmin.evaluate().unwrap());
+
+        // test update one not-null value
+        let mut argmin = Argmin::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Some(42)]))];
+        argmin.update_batch(&v).unwrap();
+        assert_eq!(Value::from(0_u32), argmin.evaluate().unwrap());
+
+        // test update one null value
+        let mut argmin = Argmin::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Option::<i32>::None]))];
+        argmin.update_batch(&v).unwrap();
+        assert_eq!(Value::Null, argmin.evaluate().unwrap());
+
+        // test update no null-value batch
+        let mut argmin = Argmin::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![
+            Some(-1i32),
+            Some(1),
+            Some(3),
+        ]))];
+        argmin.update_batch(&v).unwrap();
+        assert_eq!(Value::from(0_u32), argmin.evaluate().unwrap());
+
+        // test update null-value batch
+        let mut argmin = Argmin::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![
+            Some(-2i32),
+            None,
+            Some(4),
+        ]))];
+        argmin.update_batch(&v).unwrap();
+        assert_eq!(Value::from(0_u32), argmin.evaluate().unwrap());
+
+        // test update with constant vector
+        let mut argmin = Argmin::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(ConstantVector::new(
+            Arc::new(Int32Vector::from_vec(vec![4])),
+            10,
+        ))];
+        argmin.update_batch(&v).unwrap();
+        assert_eq!(Value::from(0_u32), argmin.evaluate().unwrap());
+    }
+}

src/common/function/src/scalars/aggregate/diff.rs

@@ -0,0 +1,252 @@
+// 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::marker::PhantomData;
+use std::sync::Arc;
+
+use common_macro::{as_aggr_func_creator, AggrFuncTypeStore};
+use common_query::error::{
+    CreateAccumulatorSnafu, DowncastVectorSnafu, FromScalarValueSnafu, InvalidInputStateSnafu,
+    Result,
+};
+use common_query::logical_plan::accumulator::AggrFuncTypeStore;
+use common_query::logical_plan::{Accumulator, AggregateFunctionCreator};
+use common_query::prelude::*;
+use datatypes::prelude::*;
+use datatypes::value::ListValue;
+use datatypes::vectors::{ConstantVector, Helper, ListVector};
+use datatypes::with_match_primitive_type_id;
+use num_traits::AsPrimitive;
+use snafu::{ensure, OptionExt, ResultExt};
+
+// https://numpy.org/doc/stable/reference/generated/numpy.diff.html
+// I is the input type, O is the output type.
+#[derive(Debug, Default)]
+pub struct Diff<I, O> {
+    values: Vec<I>,
+    _phantom: PhantomData<O>,
+}
+
+impl<I, O> Diff<I, O> {
+    fn push(&mut self, value: I) {
+        self.values.push(value);
+    }
+}
+
+impl<I, O> Accumulator for Diff<I, O>
+where
+    I: WrapperType,
+    O: WrapperType,
+    I::Native: AsPrimitive<O::Native>,
+    O::Native: std::ops::Sub<Output = O::Native>,
+{
+    fn state(&self) -> Result<Vec<Value>> {
+        let nums = self
+            .values
+            .iter()
+            .map(|&n| n.into())
+            .collect::<Vec<Value>>();
+        Ok(vec![Value::List(ListValue::new(
+            nums,
+            I::LogicalType::build_data_type(),
+        ))])
+    }
+
+    fn update_batch(&mut self, values: &[VectorRef]) -> Result<()> {
+        if values.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(values.len() == 1, InvalidInputStateSnafu);
+
+        let column = &values[0];
+        let mut len = 1;
+        let column: &<I as Scalar>::VectorType = if column.is_const() {
+            len = column.len();
+            let column: &ConstantVector = unsafe { Helper::static_cast(column) };
+            unsafe { Helper::static_cast(column.inner()) }
+        } else {
+            unsafe { Helper::static_cast(column) }
+        };
+        (0..len).for_each(|_| {
+            for v in column.iter_data().flatten() {
+                self.push(v);
+            }
+        });
+        Ok(())
+    }
+
+    fn merge_batch(&mut self, states: &[VectorRef]) -> Result<()> {
+        if states.is_empty() {
+            return Ok(());
+        }
+
+        let states = &states[0];
+        let states = states
+            .as_any()
+            .downcast_ref::<ListVector>()
+            .with_context(|| DowncastVectorSnafu {
+                err_msg: format!(
+                    "expect ListVector, got vector type {}",
+                    states.vector_type_name()
+                ),
+            })?;
+        for state in states.values_iter() {
+            if let Some(state) = state.context(FromScalarValueSnafu)? {
+                self.update_batch(&[state])?;
+            }
+        }
+        Ok(())
+    }
+
+    fn evaluate(&self) -> Result<Value> {
+        if self.values.is_empty() || self.values.len() == 1 {
+            return Ok(Value::Null);
+        }
+        let diff = self
+            .values
+            .windows(2)
+            .map(|x| {
+                let native = x[1].into_native().as_() - x[0].into_native().as_();
+                O::from_native(native).into()
+            })
+            .collect::<Vec<Value>>();
+        let diff = Value::List(ListValue::new(diff, O::LogicalType::build_data_type()));
+        Ok(diff)
+    }
+}
+
+#[as_aggr_func_creator]
+#[derive(Debug, Default, AggrFuncTypeStore)]
+pub struct DiffAccumulatorCreator {}
+
+impl AggregateFunctionCreator for DiffAccumulatorCreator {
+    fn creator(&self) -> AccumulatorCreatorFunction {
+        let creator: AccumulatorCreatorFunction = Arc::new(move |types: &[ConcreteDataType]| {
+            let input_type = &types[0];
+            with_match_primitive_type_id!(
+                input_type.logical_type_id(),
+                |$S| {
+                    Ok(Box::new(Diff::<<$S as LogicalPrimitiveType>::Wrapper, <<$S as LogicalPrimitiveType>::LargestType as LogicalPrimitiveType>::Wrapper>::default()))
+                },
+                {
+                    let err_msg = format!(
+                        "\"DIFF\" aggregate function not support data type {:?}",
+                        input_type.logical_type_id(),
+                    );
+                    CreateAccumulatorSnafu { err_msg }.fail()?
+                }
+            )
+        });
+        creator
+    }
+
+    fn output_type(&self) -> Result<ConcreteDataType> {
+        let input_types = self.input_types()?;
+        ensure!(input_types.len() == 1, InvalidInputStateSnafu);
+        with_match_primitive_type_id!(
+            input_types[0].logical_type_id(),
+            |$S| {
+                Ok(ConcreteDataType::list_datatype($S::default().into()))
+            },
+            {
+                unreachable!()
+            }
+        )
+    }
+
+    fn state_types(&self) -> Result<Vec<ConcreteDataType>> {
+        let input_types = self.input_types()?;
+        ensure!(input_types.len() == 1, InvalidInputStateSnafu);
+        with_match_primitive_type_id!(
+            input_types[0].logical_type_id(),
+            |$S| {
+                Ok(vec![ConcreteDataType::list_datatype($S::default().into())])
+            },
+            {
+                unreachable!()
+            }
+        )
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use datatypes::vectors::Int32Vector;
+
+    use super::*;
+
+    #[test]
+    fn test_update_batch() {
+        // test update empty batch, expect not updating anything
+        let mut diff = Diff::<i32, i64>::default();
+        diff.update_batch(&[]).unwrap();
+        assert!(diff.values.is_empty());
+        assert_eq!(Value::Null, diff.evaluate().unwrap());
+
+        // test update one not-null value
+        let mut diff = Diff::<i32, i64>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Some(42)]))];
+        diff.update_batch(&v).unwrap();
+        assert_eq!(Value::Null, diff.evaluate().unwrap());
+
+        // test update one null value
+        let mut diff = Diff::<i32, i64>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Option::<i32>::None]))];
+        diff.update_batch(&v).unwrap();
+        assert_eq!(Value::Null, diff.evaluate().unwrap());
+
+        // test update no null-value batch
+        let mut diff = Diff::<i32, i64>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![
+            Some(-1i32),
+            Some(1),
+            Some(2),
+        ]))];
+        let values = vec![Value::from(2_i64), Value::from(1_i64)];
+        diff.update_batch(&v).unwrap();
+        assert_eq!(
+            Value::List(ListValue::new(values, ConcreteDataType::int64_datatype())),
+            diff.evaluate().unwrap()
+        );
+
+        // test update null-value batch
+        let mut diff = Diff::<i32, i64>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![
+            Some(-2i32),
+            None,
+            Some(3),
+            Some(4),
+        ]))];
+        let values = vec![Value::from(5_i64), Value::from(1_i64)];
+        diff.update_batch(&v).unwrap();
+        assert_eq!(
+            Value::List(ListValue::new(values, ConcreteDataType::int64_datatype())),
+            diff.evaluate().unwrap()
+        );
+
+        // test update with constant vector
+        let mut diff = Diff::<i32, i64>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(ConstantVector::new(
+            Arc::new(Int32Vector::from_vec(vec![4])),
+            4,
+        ))];
+        let values = vec![Value::from(0_i64), Value::from(0_i64), Value::from(0_i64)];
+        diff.update_batch(&v).unwrap();
+        assert_eq!(
+            Value::List(ListValue::new(values, ConcreteDataType::int64_datatype())),
+            diff.evaluate().unwrap()
+        );
+    }
+}

src/common/function/src/scalars/aggregate/mean.rs

@@ -0,0 +1,238 @@
+// 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::marker::PhantomData;
+use std::sync::Arc;
+
+use common_macro::{as_aggr_func_creator, AggrFuncTypeStore};
+use common_query::error::{
+    BadAccumulatorImplSnafu, CreateAccumulatorSnafu, DowncastVectorSnafu, InvalidInputStateSnafu,
+    Result,
+};
+use common_query::logical_plan::accumulator::AggrFuncTypeStore;
+use common_query::logical_plan::{Accumulator, AggregateFunctionCreator};
+use common_query::prelude::*;
+use datatypes::prelude::*;
+use datatypes::types::WrapperType;
+use datatypes::vectors::{ConstantVector, Float64Vector, Helper, UInt64Vector};
+use datatypes::with_match_primitive_type_id;
+use num_traits::AsPrimitive;
+use snafu::{ensure, OptionExt};
+
+#[derive(Debug, Default)]
+pub struct Mean<T> {
+    sum: f64,
+    n: u64,
+    _phantom: PhantomData<T>,
+}
+
+impl<T> Mean<T>
+where
+    T: WrapperType,
+    T::Native: AsPrimitive<f64>,
+{
+    #[inline(always)]
+    fn push(&mut self, value: T) {
+        self.sum += value.into_native().as_();
+        self.n += 1;
+    }
+
+    #[inline(always)]
+    fn update(&mut self, sum: f64, n: u64) {
+        self.sum += sum;
+        self.n += n;
+    }
+}
+
+impl<T> Accumulator for Mean<T>
+where
+    T: WrapperType,
+    T::Native: AsPrimitive<f64>,
+{
+    fn state(&self) -> Result<Vec<Value>> {
+        Ok(vec![self.sum.into(), self.n.into()])
+    }
+
+    fn update_batch(&mut self, values: &[VectorRef]) -> Result<()> {
+        if values.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(values.len() == 1, InvalidInputStateSnafu);
+        let column = &values[0];
+        let mut len = 1;
+        let column: &<T as Scalar>::VectorType = if column.is_const() {
+            len = column.len();
+            let column: &ConstantVector = unsafe { Helper::static_cast(column) };
+            unsafe { Helper::static_cast(column.inner()) }
+        } else {
+            unsafe { Helper::static_cast(column) }
+        };
+        (0..len).for_each(|_| {
+            for v in column.iter_data().flatten() {
+                self.push(v);
+            }
+        });
+
+        Ok(())
+    }
+
+    fn merge_batch(&mut self, states: &[VectorRef]) -> Result<()> {
+        if states.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(
+            states.len() == 2,
+            BadAccumulatorImplSnafu {
+                err_msg: "expect 2 states in `merge_batch`",
+            }
+        );
+
+        let sum = &states[0];
+        let n = &states[1];
+
+        let sum = sum
+            .as_any()
+            .downcast_ref::<Float64Vector>()
+            .with_context(|| DowncastVectorSnafu {
+                err_msg: format!(
+                    "expect Float64Vector, got vector type {}",
+                    sum.vector_type_name()
+                ),
+            })?;
+
+        let n = n
+            .as_any()
+            .downcast_ref::<UInt64Vector>()
+            .with_context(|| DowncastVectorSnafu {
+                err_msg: format!(
+                    "expect UInt64Vector, got vector type {}",
+                    sum.vector_type_name()
+                ),
+            })?;
+
+        sum.iter_data().zip(n.iter_data()).for_each(|(sum, n)| {
+            if let (Some(sum), Some(n)) = (sum, n) {
+                self.update(sum, n);
+            }
+        });
+        Ok(())
+    }
+
+    fn evaluate(&self) -> Result<Value> {
+        if self.n == 0 {
+            return Ok(Value::Null);
+        }
+        let values = self.sum / self.n as f64;
+        Ok(values.into())
+    }
+}
+
+#[as_aggr_func_creator]
+#[derive(Debug, Default, AggrFuncTypeStore)]
+pub struct MeanAccumulatorCreator {}
+
+impl AggregateFunctionCreator for MeanAccumulatorCreator {
+    fn creator(&self) -> AccumulatorCreatorFunction {
+        let creator: AccumulatorCreatorFunction = Arc::new(move |types: &[ConcreteDataType]| {
+            let input_type = &types[0];
+            with_match_primitive_type_id!(
+                input_type.logical_type_id(),
+                |$S| {
+                    Ok(Box::new(Mean::<<$S as LogicalPrimitiveType>::Native>::default()))
+                },
+                {
+                    let err_msg = format!(
+                        "\"MEAN\" aggregate function not support data type {:?}",
+                        input_type.logical_type_id(),
+                    );
+                    CreateAccumulatorSnafu { err_msg }.fail()?
+                }
+            )
+        });
+        creator
+    }
+
+    fn output_type(&self) -> Result<ConcreteDataType> {
+        let input_types = self.input_types()?;
+        ensure!(input_types.len() == 1, InvalidInputStateSnafu);
+        Ok(ConcreteDataType::float64_datatype())
+    }
+
+    fn state_types(&self) -> Result<Vec<ConcreteDataType>> {
+        let input_types = self.input_types()?;
+        ensure!(input_types.len() == 1, InvalidInputStateSnafu);
+        Ok(vec![
+            ConcreteDataType::float64_datatype(),
+            ConcreteDataType::uint64_datatype(),
+        ])
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use datatypes::vectors::Int32Vector;
+
+    use super::*;
+    #[test]
+    fn test_update_batch() {
+        // test update empty batch, expect not updating anything
+        let mut mean = Mean::<i32>::default();
+        mean.update_batch(&[]).unwrap();
+        assert_eq!(Value::Null, mean.evaluate().unwrap());
+
+        // test update one not-null value
+        let mut mean = Mean::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Some(42)]))];
+        mean.update_batch(&v).unwrap();
+        assert_eq!(Value::from(42.0_f64), mean.evaluate().unwrap());
+
+        // test update one null value
+        let mut mean = Mean::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![Option::<i32>::None]))];
+        mean.update_batch(&v).unwrap();
+        assert_eq!(Value::Null, mean.evaluate().unwrap());
+
+        // test update no null-value batch
+        let mut mean = Mean::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![
+            Some(-1i32),
+            Some(1),
+            Some(2),
+        ]))];
+        mean.update_batch(&v).unwrap();
+        assert_eq!(Value::from(0.6666666666666666), mean.evaluate().unwrap());
+
+        // test update null-value batch
+        let mut mean = Mean::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(Int32Vector::from(vec![
+            Some(-2i32),
+            None,
+            Some(3),
+            Some(4),
+        ]))];
+        mean.update_batch(&v).unwrap();
+        assert_eq!(Value::from(1.6666666666666667), mean.evaluate().unwrap());
+
+        // test update with constant vector
+        let mut mean = Mean::<i32>::default();
+        let v: Vec<VectorRef> = vec![Arc::new(ConstantVector::new(
+            Arc::new(Int32Vector::from_vec(vec![4])),
+            10,
+        ))];
+        mean.update_batch(&v).unwrap();
+        assert_eq!(Value::from(4.0), mean.evaluate().unwrap());
+    }
+}

src/common/function/src/scalars/aggregate/polyval.rs

@@ -0,0 +1,329 @@
+// 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::marker::PhantomData;
+use std::sync::Arc;
+
+use common_macro::{as_aggr_func_creator, AggrFuncTypeStore};
+use common_query::error::{
+    self, BadAccumulatorImplSnafu, CreateAccumulatorSnafu, DowncastVectorSnafu,
+    FromScalarValueSnafu, InvalidInputColSnafu, InvalidInputStateSnafu, Result,
+};
+use common_query::logical_plan::accumulator::AggrFuncTypeStore;
+use common_query::logical_plan::{Accumulator, AggregateFunctionCreator};
+use common_query::prelude::*;
+use datatypes::prelude::*;
+use datatypes::types::{LogicalPrimitiveType, WrapperType};
+use datatypes::value::ListValue;
+use datatypes::vectors::{ConstantVector, Helper, Int64Vector, ListVector};
+use datatypes::with_match_primitive_type_id;
+use num_traits::AsPrimitive;
+use snafu::{ensure, OptionExt, ResultExt};
+
+// https://numpy.org/doc/stable/reference/generated/numpy.polyval.html
+#[derive(Debug, Default)]
+pub struct Polyval<T, PolyT>
+where
+    T: WrapperType,
+    T::Native: AsPrimitive<PolyT::Native>,
+    PolyT: WrapperType,
+    PolyT::Native: std::ops::Mul<Output = PolyT::Native>,
+{
+    values: Vec<T>,
+    // DataFusion casts constant in into i64 type.
+    x: Option<i64>,
+    _phantom: PhantomData<PolyT>,
+}
+
+impl<T, PolyT> Polyval<T, PolyT>
+where
+    T: WrapperType,
+    T::Native: AsPrimitive<PolyT::Native>,
+    PolyT: WrapperType,
+    PolyT::Native: std::ops::Mul<Output = PolyT::Native>,
+{
+    fn push(&mut self, value: T) {
+        self.values.push(value);
+    }
+}
+
+impl<T, PolyT> Accumulator for Polyval<T, PolyT>
+where
+    T: WrapperType,
+    T::Native: AsPrimitive<PolyT::Native>,
+    PolyT: WrapperType + std::iter::Sum<<PolyT as WrapperType>::Native>,
+    PolyT::Native: std::ops::Mul<Output = PolyT::Native> + std::iter::Sum<PolyT::Native>,
+    i64: AsPrimitive<<PolyT as WrapperType>::Native>,
+{
+    fn state(&self) -> Result<Vec<Value>> {
+        let nums = self
+            .values
+            .iter()
+            .map(|&n| n.into())
+            .collect::<Vec<Value>>();
+        Ok(vec![
+            Value::List(ListValue::new(nums, T::LogicalType::build_data_type())),
+            self.x.into(),
+        ])
+    }
+
+    fn update_batch(&mut self, values: &[VectorRef]) -> Result<()> {
+        if values.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(values.len() == 2, InvalidInputStateSnafu);
+        ensure!(values[0].len() == values[1].len(), InvalidInputStateSnafu);
+        if values[0].len() == 0 {
+            return Ok(());
+        }
+        // This is a unary accumulator, so only one column is provided.
+        let column = &values[0];
+        let mut len = 1;
+        let column: &<T as Scalar>::VectorType = if column.is_const() {
+            len = column.len();
+            let column: &ConstantVector = unsafe { Helper::static_cast(column) };
+            unsafe { Helper::static_cast(column.inner()) }
+        } else {
+            unsafe { Helper::static_cast(column) }
+        };
+        (0..len).for_each(|_| {
+            for v in column.iter_data().flatten() {
+                self.push(v);
+            }
+        });
+
+        let x = &values[1];
+        let x = Helper::check_get_scalar::<i64>(x).context(error::InvalidInputTypeSnafu {
+            err_msg: "expecting \"POLYVAL\" function's second argument to be a positive integer",
+        })?;
+        // `get(0)` is safe because we have checked `values[1].len() == values[0].len() != 0`
+        let first = x.get(0);
+        ensure!(!first.is_null(), InvalidInputColSnafu);
+
+        for i in 1..x.len() {
+            ensure!(first == x.get(i), InvalidInputColSnafu);
+        }
+
+        let first = match first {
+            Value::Int64(v) => v,
+            // unreachable because we have checked `first` is not null and is i64 above
+            _ => unreachable!(),
+        };
+        if let Some(x) = self.x {
+            ensure!(x == first, InvalidInputColSnafu);
+        } else {
+            self.x = Some(first);
+        };
+        Ok(())
+    }
+
+    // DataFusion executes accumulators in partitions. In some execution stage, DataFusion will
+    // merge states from other accumulators (returned by `state()` method).
+    fn merge_batch(&mut self, states: &[VectorRef]) -> Result<()> {
+        if states.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(
+            states.len() == 2,
+            BadAccumulatorImplSnafu {
+                err_msg: "expect 2 states in `merge_batch`",
+            }
+        );
+
+        let x = &states[1];
+        let x = x
+            .as_any()
+            .downcast_ref::<Int64Vector>()
+            .with_context(|| DowncastVectorSnafu {
+                err_msg: format!(
+                    "expect Int64Vector, got vector type {}",
+                    x.vector_type_name()
+                ),
+            })?;
+        let x = x.get(0);
+        if x.is_null() {
+            return Ok(());
+        }
+        let x = match x {
+            Value::Int64(x) => x,
+            _ => unreachable!(),
+        };
+        self.x = Some(x);
+
+        let values = &states[0];
+        let values = values
+            .as_any()
+            .downcast_ref::<ListVector>()
+            .with_context(|| DowncastVectorSnafu {
+                err_msg: format!(
+                    "expect ListVector, got vector type {}",
+                    values.vector_type_name()
+                ),
+            })?;
+        for value in values.values_iter() {
+            if let Some(value) = value.context(FromScalarValueSnafu)? {
+                let column: &<T as Scalar>::VectorType = unsafe { Helper::static_cast(&value) };
+                for v in column.iter_data().flatten() {
+                    self.push(v);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    // DataFusion expects this function to return the final value of this aggregator.
+    fn evaluate(&self) -> Result<Value> {
+        if self.values.is_empty() {
+            return Ok(Value::Null);
+        }
+        let x = if let Some(x) = self.x {
+            x
+        } else {
+            return Ok(Value::Null);
+        };
+        let len = self.values.len();
+        let polyval: PolyT = self
+            .values
+            .iter()
+            .enumerate()
+            .map(|(i, &value)| value.into_native().as_() * x.pow((len - 1 - i) as u32).as_())
+            .sum();
+        Ok(polyval.into())
+    }
+}
+
+#[as_aggr_func_creator]
+#[derive(Debug, Default, AggrFuncTypeStore)]
+pub struct PolyvalAccumulatorCreator {}
+
+impl AggregateFunctionCreator for PolyvalAccumulatorCreator {
+    fn creator(&self) -> AccumulatorCreatorFunction {
+        let creator: AccumulatorCreatorFunction = Arc::new(move |types: &[ConcreteDataType]| {
+            let input_type = &types[0];
+            with_match_primitive_type_id!(
+                input_type.logical_type_id(),
+                |$S| {
+                    Ok(Box::new(Polyval::<<$S as LogicalPrimitiveType>::Wrapper, <<$S as LogicalPrimitiveType>::LargestType as LogicalPrimitiveType>::Wrapper>::default()))
+                },
+                {
+                    let err_msg = format!(
+                        "\"POLYVAL\" aggregate function not support data type {:?}",
+                        input_type.logical_type_id(),
+                    );
+                    CreateAccumulatorSnafu { err_msg }.fail()?
+                }
+            )
+        });
+        creator
+    }
+
+    fn output_type(&self) -> Result<ConcreteDataType> {
+        let input_types = self.input_types()?;
+        ensure!(input_types.len() == 2, InvalidInputStateSnafu);
+        let input_type = self.input_types()?[0].logical_type_id();
+        with_match_primitive_type_id!(
+            input_type,
+            |$S| {
+                Ok(<<$S as LogicalPrimitiveType>::LargestType as LogicalPrimitiveType>::build_data_type())
+            },
+            {
+                unreachable!()
+            }
+        )
+    }
+
+    fn state_types(&self) -> Result<Vec<ConcreteDataType>> {
+        let input_types = self.input_types()?;
+        ensure!(input_types.len() == 2, InvalidInputStateSnafu);
+        Ok(vec![
+            ConcreteDataType::list_datatype(input_types.into_iter().next().unwrap()),
+            ConcreteDataType::int64_datatype(),
+        ])
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use datatypes::vectors::Int32Vector;
+
+    use super::*;
+    #[test]
+    fn test_update_batch() {
+        // test update empty batch, expect not updating anything
+        let mut polyval = Polyval::<i32, i64>::default();
+        polyval.update_batch(&[]).unwrap();
+        assert!(polyval.values.is_empty());
+        assert_eq!(Value::Null, polyval.evaluate().unwrap());
+
+        // test update one not-null value
+        let mut polyval = Polyval::<i32, i64>::default();
+        let v: Vec<VectorRef> = vec![
+            Arc::new(Int32Vector::from(vec![Some(3)])),
+            Arc::new(Int64Vector::from(vec![Some(2_i64)])),
+        ];
+        polyval.update_batch(&v).unwrap();
+        assert_eq!(Value::Int64(3), polyval.evaluate().unwrap());
+
+        // test update one null value
+        let mut polyval = Polyval::<i32, i64>::default();
+        let v: Vec<VectorRef> = vec![
+            Arc::new(Int32Vector::from(vec![Option::<i32>::None])),
+            Arc::new(Int64Vector::from(vec![Some(2_i64)])),
+        ];
+        polyval.update_batch(&v).unwrap();
+        assert_eq!(Value::Null, polyval.evaluate().unwrap());
+
+        // test update no null-value batch
+        let mut polyval = Polyval::<i32, i64>::default();
+        let v: Vec<VectorRef> = vec![
+            Arc::new(Int32Vector::from(vec![Some(3), Some(0), Some(1)])),
+            Arc::new(Int64Vector::from(vec![
+                Some(2_i64),
+                Some(2_i64),
+                Some(2_i64),
+            ])),
+        ];
+        polyval.update_batch(&v).unwrap();
+        assert_eq!(Value::Int64(13), polyval.evaluate().unwrap());
+
+        // test update null-value batch
+        let mut polyval = Polyval::<i32, i64>::default();
+        let v: Vec<VectorRef> = vec![
+            Arc::new(Int32Vector::from(vec![Some(3), Some(0), None, Some(1)])),
+            Arc::new(Int64Vector::from(vec![
+                Some(2_i64),
+                Some(2_i64),
+                Some(2_i64),
+                Some(2_i64),
+            ])),
+        ];
+        polyval.update_batch(&v).unwrap();
+        assert_eq!(Value::Int64(13), polyval.evaluate().unwrap());
+
+        // test update with constant vector
+        let mut polyval = Polyval::<i32, i64>::default();
+        let v: Vec<VectorRef> = vec![
+            Arc::new(ConstantVector::new(
+                Arc::new(Int32Vector::from_vec(vec![4])),
+                2,
+            )),
+            Arc::new(Int64Vector::from(vec![Some(5_i64), Some(5_i64)])),
+        ];
+        polyval.update_batch(&v).unwrap();
+        assert_eq!(Value::Int64(24), polyval.evaluate().unwrap());
+    }
+}

src/common/function/src/scalars/aggregate/scipy_stats_norm_cdf.rs

@@ -0,0 +1,270 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::Arc;
+
+use common_macro::{as_aggr_func_creator, AggrFuncTypeStore};
+use common_query::error::{
+    self, BadAccumulatorImplSnafu, CreateAccumulatorSnafu, DowncastVectorSnafu,
+    FromScalarValueSnafu, GenerateFunctionSnafu, InvalidInputColSnafu, InvalidInputStateSnafu,
+    Result,
+};
+use common_query::logical_plan::accumulator::AggrFuncTypeStore;
+use common_query::logical_plan::{Accumulator, AggregateFunctionCreator};
+use common_query::prelude::*;
+use datatypes::prelude::*;
+use datatypes::value::{ListValue, OrderedFloat};
+use datatypes::vectors::{ConstantVector, Float64Vector, Helper, ListVector};
+use datatypes::with_match_primitive_type_id;
+use num_traits::AsPrimitive;
+use snafu::{ensure, OptionExt, ResultExt};
+use statrs::distribution::{ContinuousCDF, Normal};
+use statrs::statistics::Statistics;
+
+// https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.norm.html
+
+#[derive(Debug, Default)]
+pub struct ScipyStatsNormCdf<T> {
+    values: Vec<T>,
+    x: Option<f64>,
+}
+
+impl<T> ScipyStatsNormCdf<T> {
+    fn push(&mut self, value: T) {
+        self.values.push(value);
+    }
+}
+
+impl<T> Accumulator for ScipyStatsNormCdf<T>
+where
+    T: WrapperType + std::iter::Sum<T>,
+    T::Native: AsPrimitive<f64>,
+{
+    fn state(&self) -> Result<Vec<Value>> {
+        let nums = self
+            .values
+            .iter()
+            .map(|&x| x.into())
+            .collect::<Vec<Value>>();
+        Ok(vec![
+            Value::List(ListValue::new(nums, T::LogicalType::build_data_type())),
+            self.x.into(),
+        ])
+    }
+
+    fn update_batch(&mut self, values: &[VectorRef]) -> Result<()> {
+        if values.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(values.len() == 2, InvalidInputStateSnafu);
+        ensure!(values[1].len() == values[0].len(), InvalidInputStateSnafu);
+
+        if values[0].len() == 0 {
+            return Ok(());
+        }
+
+        let column = &values[0];
+        let mut len = 1;
+        let column: &<T as Scalar>::VectorType = if column.is_const() {
+            len = column.len();
+            let column: &ConstantVector = unsafe { Helper::static_cast(column) };
+            unsafe { Helper::static_cast(column.inner()) }
+        } else {
+            unsafe { Helper::static_cast(column) }
+        };
+
+        let x = &values[1];
+        let x = Helper::check_get_scalar::<f64>(x).context(error::InvalidInputTypeSnafu {
+            err_msg: "expecting \"SCIPYSTATSNORMCDF\" function's second argument to be a positive integer",
+        })?;
+        let first = x.get(0);
+        ensure!(!first.is_null(), InvalidInputColSnafu);
+        let first = match first {
+            Value::Float64(OrderedFloat(v)) => v,
+            // unreachable because we have checked `first` is not null and is i64 above
+            _ => unreachable!(),
+        };
+        if let Some(x) = self.x {
+            ensure!(x == first, InvalidInputColSnafu);
+        } else {
+            self.x = Some(first);
+        };
+
+        (0..len).for_each(|_| {
+            for v in column.iter_data().flatten() {
+                self.push(v);
+            }
+        });
+        Ok(())
+    }
+
+    fn merge_batch(&mut self, states: &[VectorRef]) -> Result<()> {
+        if states.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(
+            states.len() == 2,
+            BadAccumulatorImplSnafu {
+                err_msg: "expect 2 states in `merge_batch`",
+            }
+        );
+
+        let x = &states[1];
+        let x = x
+            .as_any()
+            .downcast_ref::<Float64Vector>()
+            .with_context(|| DowncastVectorSnafu {
+                err_msg: format!(
+                    "expect Float64Vector, got vector type {}",
+                    x.vector_type_name()
+                ),
+            })?;
+        let x = x.get(0);
+        if x.is_null() {
+            return Ok(());
+        }
+        let x = match x {
+            Value::Float64(OrderedFloat(x)) => x,
+            _ => unreachable!(),
+        };
+        self.x = Some(x);
+
+        let values = &states[0];
+        let values = values
+            .as_any()
+            .downcast_ref::<ListVector>()
+            .with_context(|| DowncastVectorSnafu {
+                err_msg: format!(
+                    "expect ListVector, got vector type {}",
+                    values.vector_type_name()
+                ),
+            })?;
+        for value in values.values_iter() {
+            if let Some(value) = value.context(FromScalarValueSnafu)? {
+                let column: &<T as Scalar>::VectorType = unsafe { Helper::static_cast(&value) };
+                for v in column.iter_data().flatten() {
+                    self.push(v);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn evaluate(&self) -> Result<Value> {
+        let mean = self.values.iter().map(|v| v.into_native().as_()).mean();
+        let std_dev = self.values.iter().map(|v| v.into_native().as_()).std_dev();
+        if mean.is_nan() || std_dev.is_nan() {
+            Ok(Value::Null)
+        } else {
+            let x = if let Some(x) = self.x {
+                x
+            } else {
+                return Ok(Value::Null);
+            };
+            let n = Normal::new(mean, std_dev).context(GenerateFunctionSnafu)?;
+            Ok(n.cdf(x).into())
+        }
+    }
+}
+
+#[as_aggr_func_creator]
+#[derive(Debug, Default, AggrFuncTypeStore)]
+pub struct ScipyStatsNormCdfAccumulatorCreator {}
+
+impl AggregateFunctionCreator for ScipyStatsNormCdfAccumulatorCreator {
+    fn creator(&self) -> AccumulatorCreatorFunction {
+        let creator: AccumulatorCreatorFunction = Arc::new(move |types: &[ConcreteDataType]| {
+            let input_type = &types[0];
+            with_match_primitive_type_id!(
+                input_type.logical_type_id(),
+                |$S| {
+                    Ok(Box::new(ScipyStatsNormCdf::<<$S as LogicalPrimitiveType>::Wrapper>::default()))
+                },
+                {
+                    let err_msg = format!(
+                        "\"SCIPYSTATSNORMCDF\" aggregate function not support data type {:?}",
+                        input_type.logical_type_id(),
+                    );
+                    CreateAccumulatorSnafu { err_msg }.fail()?
+                }
+            )
+        });
+        creator
+    }
+
+    fn output_type(&self) -> Result<ConcreteDataType> {
+        let input_types = self.input_types()?;
+        ensure!(input_types.len() == 2, InvalidInputStateSnafu);
+        Ok(ConcreteDataType::float64_datatype())
+    }
+
+    fn state_types(&self) -> Result<Vec<ConcreteDataType>> {
+        let input_types = self.input_types()?;
+        ensure!(input_types.len() == 2, InvalidInputStateSnafu);
+        Ok(vec![
+            ConcreteDataType::list_datatype(input_types[0].clone()),
+            ConcreteDataType::float64_datatype(),
+        ])
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use datatypes::vectors::{Float64Vector, Int32Vector};
+
+    use super::*;
+    #[test]
+    fn test_update_batch() {
+        // test update empty batch, expect not updating anything
+        let mut scipy_stats_norm_cdf = ScipyStatsNormCdf::<i32>::default();
+        scipy_stats_norm_cdf.update_batch(&[]).unwrap();
+        assert!(scipy_stats_norm_cdf.values.is_empty());
+        assert_eq!(Value::Null, scipy_stats_norm_cdf.evaluate().unwrap());
+
+        // test update no null-value batch
+        let mut scipy_stats_norm_cdf = ScipyStatsNormCdf::<i32>::default();
+        let v: Vec<VectorRef> = vec![
+            Arc::new(Int32Vector::from(vec![Some(-1i32), Some(1), Some(2)])),
+            Arc::new(Float64Vector::from(vec![
+                Some(2.0_f64),
+                Some(2.0_f64),
+                Some(2.0_f64),
+            ])),
+        ];
+        scipy_stats_norm_cdf.update_batch(&v).unwrap();
+        assert_eq!(
+            Value::from(0.8086334555398362),
+            scipy_stats_norm_cdf.evaluate().unwrap()
+        );
+
+        // test update null-value batch
+        let mut scipy_stats_norm_cdf = ScipyStatsNormCdf::<i32>::default();
+        let v: Vec<VectorRef> = vec![
+            Arc::new(Int32Vector::from(vec![Some(-2i32), None, Some(3), Some(4)])),
+            Arc::new(Float64Vector::from(vec![
+                Some(2.0_f64),
+                None,
+                Some(2.0_f64),
+                Some(2.0_f64),
+            ])),
+        ];
+        scipy_stats_norm_cdf.update_batch(&v).unwrap();
+        assert_eq!(
+            Value::from(0.5412943699039795),
+            scipy_stats_norm_cdf.evaluate().unwrap()
+        );
+    }
+}

src/common/function/src/scalars/aggregate/scipy_stats_norm_pdf.rs

@@ -0,0 +1,271 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::Arc;
+
+use common_macro::{as_aggr_func_creator, AggrFuncTypeStore};
+use common_query::error::{
+    self, BadAccumulatorImplSnafu, CreateAccumulatorSnafu, DowncastVectorSnafu,
+    FromScalarValueSnafu, GenerateFunctionSnafu, InvalidInputColSnafu, InvalidInputStateSnafu,
+    Result,
+};
+use common_query::logical_plan::accumulator::AggrFuncTypeStore;
+use common_query::logical_plan::{Accumulator, AggregateFunctionCreator};
+use common_query::prelude::*;
+use datatypes::prelude::*;
+use datatypes::value::{ListValue, OrderedFloat};
+use datatypes::vectors::{ConstantVector, Float64Vector, Helper, ListVector};
+use datatypes::with_match_primitive_type_id;
+use num_traits::AsPrimitive;
+use snafu::{ensure, OptionExt, ResultExt};
+use statrs::distribution::{Continuous, Normal};
+use statrs::statistics::Statistics;
+
+// https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.norm.html
+
+#[derive(Debug, Default)]
+pub struct ScipyStatsNormPdf<T> {
+    values: Vec<T>,
+    x: Option<f64>,
+}
+
+impl<T> ScipyStatsNormPdf<T> {
+    fn push(&mut self, value: T) {
+        self.values.push(value);
+    }
+}
+
+impl<T> Accumulator for ScipyStatsNormPdf<T>
+where
+    T: WrapperType,
+    T::Native: AsPrimitive<f64> + std::iter::Sum<T>,
+{
+    fn state(&self) -> Result<Vec<Value>> {
+        let nums = self
+            .values
+            .iter()
+            .map(|&x| x.into())
+            .collect::<Vec<Value>>();
+        Ok(vec![
+            Value::List(ListValue::new(nums, T::LogicalType::build_data_type())),
+            self.x.into(),
+        ])
+    }
+
+    fn update_batch(&mut self, values: &[VectorRef]) -> Result<()> {
+        if values.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(values.len() == 2, InvalidInputStateSnafu);
+        ensure!(values[1].len() == values[0].len(), InvalidInputStateSnafu);
+
+        if values[0].len() == 0 {
+            return Ok(());
+        }
+
+        let column = &values[0];
+        let mut len = 1;
+        let column: &<T as Scalar>::VectorType = if column.is_const() {
+            len = column.len();
+            let column: &ConstantVector = unsafe { Helper::static_cast(column) };
+            unsafe { Helper::static_cast(column.inner()) }
+        } else {
+            unsafe { Helper::static_cast(column) }
+        };
+
+        let x = &values[1];
+        let x = Helper::check_get_scalar::<f64>(x).context(error::InvalidInputTypeSnafu {
+            err_msg: "expecting \"SCIPYSTATSNORMPDF\" function's second argument to be a positive integer",
+        })?;
+        let first = x.get(0);
+        ensure!(!first.is_null(), InvalidInputColSnafu);
+        let first = match first {
+            Value::Float64(OrderedFloat(v)) => v,
+            // unreachable because we have checked `first` is not null and is i64 above
+            _ => unreachable!(),
+        };
+        if let Some(x) = self.x {
+            ensure!(x == first, InvalidInputColSnafu);
+        } else {
+            self.x = Some(first);
+        };
+
+        (0..len).for_each(|_| {
+            for v in column.iter_data().flatten() {
+                self.push(v);
+            }
+        });
+        Ok(())
+    }
+
+    fn merge_batch(&mut self, states: &[VectorRef]) -> Result<()> {
+        if states.is_empty() {
+            return Ok(());
+        }
+
+        ensure!(
+            states.len() == 2,
+            BadAccumulatorImplSnafu {
+                err_msg: "expect 2 states in `merge_batch`",
+            }
+        );
+
+        let x = &states[1];
+        let x = x
+            .as_any()
+            .downcast_ref::<Float64Vector>()
+            .with_context(|| DowncastVectorSnafu {
+                err_msg: format!(
+                    "expect Float64Vector, got vector type {}",
+                    x.vector_type_name()
+                ),
+            })?;
+        let x = x.get(0);
+        if x.is_null() {
+            return Ok(());
+        }
+        let x = match x {
+            Value::Float64(OrderedFloat(x)) => x,
+            _ => unreachable!(),
+        };
+        self.x = Some(x);
+
+        let values = &states[0];
+        let values = values
+            .as_any()
+            .downcast_ref::<ListVector>()
+            .with_context(|| DowncastVectorSnafu {
+                err_msg: format!(
+                    "expect ListVector, got vector type {}",
+                    values.vector_type_name()
+                ),
+            })?;
+        for value in values.values_iter() {
+            if let Some(value) = value.context(FromScalarValueSnafu)? {
+                let column: &<T as Scalar>::VectorType = unsafe { Helper::static_cast(&value) };
+                for v in column.iter_data().flatten() {
+                    self.push(v);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn evaluate(&self) -> Result<Value> {
+        let mean = self.values.iter().map(|v| v.into_native().as_()).mean();
+        let std_dev = self.values.iter().map(|v| v.into_native().as_()).std_dev();
+
+        if mean.is_nan() || std_dev.is_nan() {
+            Ok(Value::Null)
+        } else {
+            let x = if let Some(x) = self.x {
+                x
+            } else {
+                return Ok(Value::Null);
+            };
+            let n = Normal::new(mean, std_dev).context(GenerateFunctionSnafu)?;
+            Ok(n.pdf(x).into())
+        }
+    }
+}
+
+#[as_aggr_func_creator]
+#[derive(Debug, Default, AggrFuncTypeStore)]
+pub struct ScipyStatsNormPdfAccumulatorCreator {}
+
+impl AggregateFunctionCreator for ScipyStatsNormPdfAccumulatorCreator {
+    fn creator(&self) -> AccumulatorCreatorFunction {
+        let creator: AccumulatorCreatorFunction = Arc::new(move |types: &[ConcreteDataType]| {
+            let input_type = &types[0];
+            with_match_primitive_type_id!(
+                input_type.logical_type_id(),
+                |$S| {
+                    Ok(Box::new(ScipyStatsNormPdf::<<$S as LogicalPrimitiveType>::Wrapper>::default()))
+                },
+                {
+                    let err_msg = format!(
+                        "\"SCIPYSTATSNORMpdf\" aggregate function not support data type {:?}",
+                        input_type.logical_type_id(),
+                    );
+                    CreateAccumulatorSnafu { err_msg }.fail()?
+                }
+            )
+        });
+        creator
+    }
+
+    fn output_type(&self) -> Result<ConcreteDataType> {
+        let input_types = self.input_types()?;
+        ensure!(input_types.len() == 2, InvalidInputStateSnafu);
+        Ok(ConcreteDataType::float64_datatype())
+    }
+
+    fn state_types(&self) -> Result<Vec<ConcreteDataType>> {
+        let input_types = self.input_types()?;
+        ensure!(input_types.len() == 2, InvalidInputStateSnafu);
+        Ok(vec![
+            ConcreteDataType::list_datatype(input_types[0].clone()),
+            ConcreteDataType::float64_datatype(),
+        ])
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use datatypes::vectors::{Float64Vector, Int32Vector};
+
+    use super::*;
+    #[test]
+    fn test_update_batch() {
+        // test update empty batch, expect not updating anything
+        let mut scipy_stats_norm_pdf = ScipyStatsNormPdf::<i32>::default();
+        scipy_stats_norm_pdf.update_batch(&[]).unwrap();
+        assert!(scipy_stats_norm_pdf.values.is_empty());
+        assert_eq!(Value::Null, scipy_stats_norm_pdf.evaluate().unwrap());
+
+        // test update no null-value batch
+        let mut scipy_stats_norm_pdf = ScipyStatsNormPdf::<i32>::default();
+        let v: Vec<VectorRef> = vec![
+            Arc::new(Int32Vector::from(vec![Some(-1i32), Some(1), Some(2)])),
+            Arc::new(Float64Vector::from(vec![
+                Some(2.0_f64),
+                Some(2.0_f64),
+                Some(2.0_f64),
+            ])),
+        ];
+        scipy_stats_norm_pdf.update_batch(&v).unwrap();
+        assert_eq!(
+            Value::from(0.17843340219081558),
+            scipy_stats_norm_pdf.evaluate().unwrap()
+        );
+
+        // test update null-value batch
+        let mut scipy_stats_norm_pdf = ScipyStatsNormPdf::<i32>::default();
+        let v: Vec<VectorRef> = vec![
+            Arc::new(Int32Vector::from(vec![Some(-2i32), None, Some(3), Some(4)])),
+            Arc::new(Float64Vector::from(vec![
+                Some(2.0_f64),
+                None,
+                Some(2.0_f64),
+                Some(2.0_f64),
+            ])),
+        ];
+        scipy_stats_norm_pdf.update_batch(&v).unwrap();
+        assert_eq!(
+            Value::from(0.12343972049858312),
+            scipy_stats_norm_pdf.evaluate().unwrap()
+        );
+    }
+}

src/common/function/src/scalars/date/date_add.rs

@@ -58,7 +58,7 @@ impl Function for DateAddFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 2,
             InvalidFuncArgsSnafu {
@@ -146,7 +146,7 @@ mod tests {
         let time_vector = TimestampSecondVector::from(times.clone());
         let interval_vector = IntervalDayTimeVector::from_vec(intervals);
         let args: Vec<VectorRef> = vec![Arc::new(time_vector), Arc::new(interval_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
 
         assert_eq!(4, vector.len());
         for (i, _t) in times.iter().enumerate() {
@@ -178,7 +178,7 @@ mod tests {
         let date_vector = DateVector::from(dates.clone());
         let interval_vector = IntervalYearMonthVector::from_vec(intervals);
         let args: Vec<VectorRef> = vec![Arc::new(date_vector), Arc::new(interval_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
 
         assert_eq!(4, vector.len());
         for (i, _t) in dates.iter().enumerate() {

src/common/function/src/scalars/date/date_format.rs

@@ -53,7 +53,7 @@ impl Function for DateFormatFunction {
         )
     }
 
-    fn eval(&self, func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 2,
             InvalidFuncArgsSnafu {
@@ -202,7 +202,7 @@ mod tests {
         let time_vector = TimestampSecondVector::from(times.clone());
         let interval_vector = StringVector::from_vec(formats);
         let args: Vec<VectorRef> = vec![Arc::new(time_vector), Arc::new(interval_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
 
         assert_eq!(4, vector.len());
         for (i, _t) in times.iter().enumerate() {
@@ -243,7 +243,7 @@ mod tests {
         let date_vector = DateVector::from(dates.clone());
         let interval_vector = StringVector::from_vec(formats);
         let args: Vec<VectorRef> = vec![Arc::new(date_vector), Arc::new(interval_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
 
         assert_eq!(4, vector.len());
         for (i, _t) in dates.iter().enumerate() {
@@ -284,7 +284,7 @@ mod tests {
         let date_vector = DateTimeVector::from(dates.clone());
         let interval_vector = StringVector::from_vec(formats);
         let args: Vec<VectorRef> = vec![Arc::new(date_vector), Arc::new(interval_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
 
         assert_eq!(4, vector.len());
         for (i, _t) in dates.iter().enumerate() {

src/common/function/src/scalars/date/date_sub.rs

@@ -58,7 +58,7 @@ impl Function for DateSubFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 2,
             InvalidFuncArgsSnafu {
@@ -151,7 +151,7 @@ mod tests {
         let time_vector = TimestampSecondVector::from(times.clone());
         let interval_vector = IntervalDayTimeVector::from_vec(intervals);
         let args: Vec<VectorRef> = vec![Arc::new(time_vector), Arc::new(interval_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
 
         assert_eq!(4, vector.len());
         for (i, _t) in times.iter().enumerate() {
@@ -189,7 +189,7 @@ mod tests {
         let date_vector = DateVector::from(dates.clone());
         let interval_vector = IntervalYearMonthVector::from_vec(intervals);
         let args: Vec<VectorRef> = vec![Arc::new(date_vector), Arc::new(interval_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
 
         assert_eq!(4, vector.len());
         for (i, _t) in dates.iter().enumerate() {

src/common/function/src/scalars/expression/is_null.rs

@@ -55,7 +55,7 @@ impl Function for IsNullFunction {
 
     fn eval(
         &self,
-        _func_ctx: &FunctionContext,
+        _func_ctx: FunctionContext,
         columns: &[VectorRef],
     ) -> common_query::error::Result<VectorRef> {
         ensure!(
@@ -102,7 +102,7 @@ mod tests {
         let values = vec![None, Some(3.0), None];
 
         let args: Vec<VectorRef> = vec![Arc::new(Float32Vector::from(values))];
-        let vector = is_null.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = is_null.eval(FunctionContext::default(), &args).unwrap();
         let expect: VectorRef = Arc::new(BooleanVector::from_vec(vec![true, false, true]));
         assert_eq!(expect, vector);
     }

src/common/function/src/scalars/geo/geohash.rs

@@ -118,7 +118,7 @@ impl Function for GeohashFunction {
         Signature::one_of(signatures, Volatility::Stable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 3,
             InvalidFuncArgsSnafu {
@@ -218,7 +218,7 @@ impl Function for GeohashNeighboursFunction {
         Signature::one_of(signatures, Volatility::Stable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 3,
             InvalidFuncArgsSnafu {

src/common/function/src/scalars/geo/h3.rs

@@ -119,7 +119,7 @@ impl Function for H3LatLngToCell {
         Signature::one_of(signatures, Volatility::Stable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 3);
 
         let lat_vec = &columns[0];
@@ -191,7 +191,7 @@ impl Function for H3LatLngToCellString {
         Signature::one_of(signatures, Volatility::Stable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 3);
 
         let lat_vec = &columns[0];
@@ -247,7 +247,7 @@ impl Function for H3CellToString {
         signature_of_cell()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 1);
 
         let cell_vec = &columns[0];
@@ -285,7 +285,7 @@ impl Function for H3StringToCell {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 1);
 
         let string_vec = &columns[0];
@@ -337,7 +337,7 @@ impl Function for H3CellCenterLatLng {
         signature_of_cell()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 1);
 
         let cell_vec = &columns[0];
@@ -382,7 +382,7 @@ impl Function for H3CellResolution {
         signature_of_cell()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 1);
 
         let cell_vec = &columns[0];
@@ -418,7 +418,7 @@ impl Function for H3CellBase {
         signature_of_cell()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 1);
 
         let cell_vec = &columns[0];
@@ -454,7 +454,7 @@ impl Function for H3CellIsPentagon {
         signature_of_cell()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 1);
 
         let cell_vec = &columns[0];
@@ -490,7 +490,7 @@ impl Function for H3CellCenterChild {
         signature_of_cell_and_resolution()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_vec = &columns[0];
@@ -530,7 +530,7 @@ impl Function for H3CellParent {
         signature_of_cell_and_resolution()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_vec = &columns[0];
@@ -570,7 +570,7 @@ impl Function for H3CellToChildren {
         signature_of_cell_and_resolution()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_vec = &columns[0];
@@ -619,7 +619,7 @@ impl Function for H3CellToChildrenSize {
         signature_of_cell_and_resolution()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_vec = &columns[0];
@@ -656,7 +656,7 @@ impl Function for H3CellToChildPos {
         signature_of_cell_and_resolution()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_vec = &columns[0];
@@ -706,7 +706,7 @@ impl Function for H3ChildPosToCell {
         Signature::one_of(signatures, Volatility::Stable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 3);
 
         let pos_vec = &columns[0];
@@ -747,7 +747,7 @@ impl Function for H3GridDisk {
         signature_of_cell_and_distance()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_vec = &columns[0];
@@ -800,7 +800,7 @@ impl Function for H3GridDiskDistances {
         signature_of_cell_and_distance()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_vec = &columns[0];
@@ -850,7 +850,7 @@ impl Function for H3GridDistance {
         signature_of_double_cells()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_this_vec = &columns[0];
@@ -906,7 +906,7 @@ impl Function for H3GridPathCells {
         signature_of_double_cells()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_this_vec = &columns[0];
@@ -988,7 +988,7 @@ impl Function for H3CellContains {
         Signature::one_of(signatures, Volatility::Stable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cells_vec = &columns[0];
@@ -1042,7 +1042,7 @@ impl Function for H3CellDistanceSphereKm {
         signature_of_double_cells()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_this_vec = &columns[0];
@@ -1097,7 +1097,7 @@ impl Function for H3CellDistanceEuclideanDegree {
         signature_of_double_cells()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_this_vec = &columns[0];

src/common/function/src/scalars/geo/measure.rs

@@ -54,7 +54,7 @@ impl Function for STDistance {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let wkt_this_vec = &columns[0];
@@ -108,7 +108,7 @@ impl Function for STDistanceSphere {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let wkt_this_vec = &columns[0];
@@ -169,7 +169,7 @@ impl Function for STArea {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 1);
 
         let wkt_vec = &columns[0];

src/common/function/src/scalars/geo/relation.rs

@@ -51,7 +51,7 @@ impl Function for STContains {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let wkt_this_vec = &columns[0];
@@ -105,7 +105,7 @@ impl Function for STWithin {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let wkt_this_vec = &columns[0];
@@ -159,7 +159,7 @@ impl Function for STIntersects {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let wkt_this_vec = &columns[0];

src/common/function/src/scalars/geo/s2.rs

@@ -84,7 +84,7 @@ impl Function for S2LatLngToCell {
         Signature::one_of(signatures, Volatility::Stable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let lat_vec = &columns[0];
@@ -138,7 +138,7 @@ impl Function for S2CellLevel {
         signature_of_cell()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 1);
 
         let cell_vec = &columns[0];
@@ -174,7 +174,7 @@ impl Function for S2CellToToken {
         signature_of_cell()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 1);
 
         let cell_vec = &columns[0];
@@ -210,7 +210,7 @@ impl Function for S2CellParent {
         signature_of_cell_and_level()
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let cell_vec = &columns[0];

src/common/function/src/scalars/geo/wkt.rs

@@ -63,7 +63,7 @@ impl Function for LatLngToPointWkt {
         Signature::one_of(signatures, Volatility::Stable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure_columns_n!(columns, 2);
 
         let lat_vec = &columns[0];

src/common/function/src/scalars/hll_count.rs

@@ -71,7 +71,7 @@ impl Function for HllCalcFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         if columns.len() != 1 {
             return InvalidFuncArgsSnafu {
                 err_msg: format!("hll_count expects 1 argument, got {}", columns.len()),
@@ -142,7 +142,7 @@ mod tests {
         let serialized_bytes = bincode::serialize(&hll).unwrap();
         let args: Vec<VectorRef> = vec![Arc::new(BinaryVector::from(vec![Some(serialized_bytes)]))];
 
-        let result = function.eval(&FunctionContext::default(), &args).unwrap();
+        let result = function.eval(FunctionContext::default(), &args).unwrap();
         assert_eq!(result.len(), 1);
 
         // Test cardinality estimate
@@ -159,7 +159,7 @@ mod tests {
 
         // Test with invalid number of arguments
         let args: Vec<VectorRef> = vec![];
-        let result = function.eval(&FunctionContext::default(), &args);
+        let result = function.eval(FunctionContext::default(), &args);
         assert!(result.is_err());
         assert!(result
             .unwrap_err()
@@ -168,7 +168,7 @@ mod tests {
 
         // Test with invalid binary data
         let args: Vec<VectorRef> = vec![Arc::new(BinaryVector::from(vec![Some(vec![1, 2, 3])]))]; // Invalid binary data
-        let result = function.eval(&FunctionContext::default(), &args).unwrap();
+        let result = function.eval(FunctionContext::default(), &args).unwrap();
         assert_eq!(result.len(), 1);
         assert!(matches!(result.get(0), datatypes::value::Value::Null));
     }

src/common/function/src/scalars/ip.rs

@@ -1,45 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-mod cidr;
-mod ipv4;
-mod ipv6;
-mod range;
-
-use std::sync::Arc;
-
-use cidr::{Ipv4ToCidr, Ipv6ToCidr};
-use ipv4::{Ipv4NumToString, Ipv4StringToNum};
-use ipv6::{Ipv6NumToString, Ipv6StringToNum};
-use range::{Ipv4InRange, Ipv6InRange};
-
-use crate::function_registry::FunctionRegistry;
-
-pub(crate) struct IpFunctions;
-
-impl IpFunctions {
-    pub fn register(registry: &FunctionRegistry) {
-        // Register IPv4 functions
-        registry.register(Arc::new(Ipv4NumToString));
-        registry.register(Arc::new(Ipv4StringToNum));
-        registry.register(Arc::new(Ipv4ToCidr));
-        registry.register(Arc::new(Ipv4InRange));
-
-        // Register IPv6 functions
-        registry.register(Arc::new(Ipv6NumToString));
-        registry.register(Arc::new(Ipv6StringToNum));
-        registry.register(Arc::new(Ipv6ToCidr));
-        registry.register(Arc::new(Ipv6InRange));
-    }
-}

src/common/function/src/scalars/ip/cidr.rs

@@ -1,485 +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::net::{Ipv4Addr, Ipv6Addr};
-use std::str::FromStr;
-
-use common_query::error::{InvalidFuncArgsSnafu, Result};
-use common_query::prelude::{Signature, TypeSignature};
-use datafusion::logical_expr::Volatility;
-use datatypes::prelude::{ConcreteDataType, Value};
-use datatypes::scalars::ScalarVectorBuilder;
-use datatypes::vectors::{MutableVector, StringVectorBuilder, VectorRef};
-use derive_more::Display;
-use snafu::ensure;
-
-use crate::function::{Function, FunctionContext};
-
-/// Function that converts an IPv4 address string to CIDR notation.
-///
-/// If subnet mask is provided as second argument, uses that.
-/// Otherwise, automatically detects subnet based on trailing zeros.
-///
-/// Examples:
-/// - ipv4_to_cidr('192.168.1.0') -> '192.168.1.0/24'
-/// - ipv4_to_cidr('192.168') -> '192.168.0.0/16'
-/// - ipv4_to_cidr('192.168.1.1', 24) -> '192.168.1.0/24'
-#[derive(Clone, Debug, Default, Display)]
-#[display("{}", self.name())]
-pub struct Ipv4ToCidr;
-
-impl Function for Ipv4ToCidr {
-    fn name(&self) -> &str {
-        "ipv4_to_cidr"
-    }
-
-    fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
-        Ok(ConcreteDataType::string_datatype())
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::one_of(
-            vec![
-                TypeSignature::Exact(vec![ConcreteDataType::string_datatype()]),
-                TypeSignature::Exact(vec![
-                    ConcreteDataType::string_datatype(),
-                    ConcreteDataType::uint8_datatype(),
-                ]),
-            ],
-            Volatility::Immutable,
-        )
-    }
-
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
-        ensure!(
-            columns.len() == 1 || columns.len() == 2,
-            InvalidFuncArgsSnafu {
-                err_msg: format!("Expected 1 or 2 arguments, got {}", columns.len())
-            }
-        );
-
-        let ip_vec = &columns[0];
-        let mut results = StringVectorBuilder::with_capacity(ip_vec.len());
-
-        let has_subnet_arg = columns.len() == 2;
-        let subnet_vec = if has_subnet_arg {
-            ensure!(
-                columns[1].len() == ip_vec.len(),
-                InvalidFuncArgsSnafu {
-                    err_msg:
-                        "Subnet mask must have the same number of elements as the IP addresses"
-                            .to_string()
-                }
-            );
-            Some(&columns[1])
-        } else {
-            None
-        };
-
-        for i in 0..ip_vec.len() {
-            let ip_str = ip_vec.get(i);
-            let subnet = subnet_vec.map(|v| v.get(i));
-
-            let cidr = match (ip_str, subnet) {
-                (Value::String(s), Some(Value::UInt8(mask))) => {
-                    let ip_str = s.as_utf8().trim();
-                    if ip_str.is_empty() {
-                        return InvalidFuncArgsSnafu {
-                            err_msg: "Empty IPv4 address".to_string(),
-                        }
-                        .fail();
-                    }
-
-                    let ip_addr = complete_and_parse_ipv4(ip_str)?;
-                    // Apply the subnet mask to the IP by zeroing out the host bits
-                    let mask_bits = u32::MAX.wrapping_shl(32 - mask as u32);
-                    let masked_ip = Ipv4Addr::from(u32::from(ip_addr) & mask_bits);
-
-                    Some(format!("{}/{}", masked_ip, mask))
-                }
-                (Value::String(s), None) => {
-                    let ip_str = s.as_utf8().trim();
-                    if ip_str.is_empty() {
-                        return InvalidFuncArgsSnafu {
-                            err_msg: "Empty IPv4 address".to_string(),
-                        }
-                        .fail();
-                    }
-
-                    let ip_addr = complete_and_parse_ipv4(ip_str)?;
-
-                    // Determine the subnet mask based on trailing zeros or dots
-                    let ip_bits = u32::from(ip_addr);
-                    let dots = ip_str.chars().filter(|&c| c == '.').count();
-
-                    let subnet_mask = match dots {
-                        0 => 8,  // If just one number like "192", use /8
-                        1 => 16, // If two numbers like "192.168", use /16
-                        2 => 24, // If three numbers like "192.168.1", use /24
-                        _ => {
-                            // For complete addresses, use trailing zeros
-                            let trailing_zeros = ip_bits.trailing_zeros();
-                            // Round to 8-bit boundaries if it's not a complete mask
-                            if trailing_zeros % 8 == 0 {
-                                32 - trailing_zeros.min(32) as u8
-                            } else {
-                                32 - (trailing_zeros as u8 / 8) * 8
-                            }
-                        }
-                    };
-
-                    // Apply the subnet mask to zero out host bits
-                    let mask_bits = u32::MAX.wrapping_shl(32 - subnet_mask as u32);
-                    let masked_ip = Ipv4Addr::from(ip_bits & mask_bits);
-
-                    Some(format!("{}/{}", masked_ip, subnet_mask))
-                }
-                _ => None,
-            };
-
-            results.push(cidr.as_deref());
-        }
-
-        Ok(results.to_vector())
-    }
-}
-
-/// Function that converts an IPv6 address string to CIDR notation.
-///
-/// If subnet mask is provided as second argument, uses that.
-/// Otherwise, automatically detects subnet based on trailing zeros.
-///
-/// Examples:
-/// - ipv6_to_cidr('2001:db8::') -> '2001:db8::/32'
-/// - ipv6_to_cidr('2001:db8') -> '2001:db8::/32'
-/// - ipv6_to_cidr('2001:db8::', 48) -> '2001:db8::/48'
-#[derive(Clone, Debug, Default, Display)]
-#[display("{}", self.name())]
-pub struct Ipv6ToCidr;
-
-impl Function for Ipv6ToCidr {
-    fn name(&self) -> &str {
-        "ipv6_to_cidr"
-    }
-
-    fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
-        Ok(ConcreteDataType::string_datatype())
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::one_of(
-            vec![
-                TypeSignature::Exact(vec![ConcreteDataType::string_datatype()]),
-                TypeSignature::Exact(vec![
-                    ConcreteDataType::string_datatype(),
-                    ConcreteDataType::uint8_datatype(),
-                ]),
-            ],
-            Volatility::Immutable,
-        )
-    }
-
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
-        ensure!(
-            columns.len() == 1 || columns.len() == 2,
-            InvalidFuncArgsSnafu {
-                err_msg: format!("Expected 1 or 2 arguments, got {}", columns.len())
-            }
-        );
-
-        let ip_vec = &columns[0];
-        let size = ip_vec.len();
-        let mut results = StringVectorBuilder::with_capacity(size);
-
-        let has_subnet_arg = columns.len() == 2;
-        let subnet_vec = if has_subnet_arg {
-            Some(&columns[1])
-        } else {
-            None
-        };
-
-        for i in 0..size {
-            let ip_str = ip_vec.get(i);
-            let subnet = subnet_vec.map(|v| v.get(i));
-
-            let cidr = match (ip_str, subnet) {
-                (Value::String(s), Some(Value::UInt8(mask))) => {
-                    let ip_str = s.as_utf8().trim();
-                    if ip_str.is_empty() {
-                        return InvalidFuncArgsSnafu {
-                            err_msg: "Empty IPv6 address".to_string(),
-                        }
-                        .fail();
-                    }
-
-                    let ip_addr = complete_and_parse_ipv6(ip_str)?;
-
-                    // Apply the subnet mask to the IP
-                    let masked_ip = mask_ipv6(&ip_addr, mask);
-
-                    Some(format!("{}/{}", masked_ip, mask))
-                }
-                (Value::String(s), None) => {
-                    let ip_str = s.as_utf8().trim();
-                    if ip_str.is_empty() {
-                        return InvalidFuncArgsSnafu {
-                            err_msg: "Empty IPv6 address".to_string(),
-                        }
-                        .fail();
-                    }
-
-                    let ip_addr = complete_and_parse_ipv6(ip_str)?;
-
-                    // Determine subnet based on address parts
-                    let subnet_mask = auto_detect_ipv6_subnet(&ip_addr);
-
-                    // Apply the subnet mask
-                    let masked_ip = mask_ipv6(&ip_addr, subnet_mask);
-
-                    Some(format!("{}/{}", masked_ip, subnet_mask))
-                }
-                _ => None,
-            };
-
-            results.push(cidr.as_deref());
-        }
-
-        Ok(results.to_vector())
-    }
-}
-
-// Helper functions
-
-fn complete_and_parse_ipv4(ip_str: &str) -> Result<Ipv4Addr> {
-    // Try to parse as is
-    if let Ok(addr) = Ipv4Addr::from_str(ip_str) {
-        return Ok(addr);
-    }
-
-    // Count the dots to see how many octets we have
-    let dots = ip_str.chars().filter(|&c| c == '.').count();
-
-    // Complete with zeroes
-    let completed = match dots {
-        0 => format!("{}.0.0.0", ip_str),
-        1 => format!("{}.0.0", ip_str),
-        2 => format!("{}.0", ip_str),
-        _ => ip_str.to_string(),
-    };
-
-    Ipv4Addr::from_str(&completed).map_err(|_| {
-        InvalidFuncArgsSnafu {
-            err_msg: format!("Invalid IPv4 address: {}", ip_str),
-        }
-        .build()
-    })
-}
-
-fn complete_and_parse_ipv6(ip_str: &str) -> Result<Ipv6Addr> {
-    // If it's already a valid IPv6 address, just parse it
-    if let Ok(addr) = Ipv6Addr::from_str(ip_str) {
-        return Ok(addr);
-    }
-
-    // For partial addresses, try to complete them
-    // The simplest approach is to add "::" to make it complete if needed
-    let completed = if ip_str.ends_with(':') {
-        format!("{}:", ip_str)
-    } else if !ip_str.contains("::") {
-        format!("{}::", ip_str)
-    } else {
-        ip_str.to_string()
-    };
-
-    Ipv6Addr::from_str(&completed).map_err(|_| {
-        InvalidFuncArgsSnafu {
-            err_msg: format!("Invalid IPv6 address: {}", ip_str),
-        }
-        .build()
-    })
-}
-
-fn mask_ipv6(addr: &Ipv6Addr, subnet: u8) -> Ipv6Addr {
-    let octets = addr.octets();
-    let mut result = [0u8; 16];
-
-    // For each byte in the address
-    for i in 0..16 {
-        let bit_pos = i * 8;
-        if bit_pos < subnet as usize {
-            if bit_pos + 8 <= subnet as usize {
-                // This byte is entirely within the subnet prefix
-                result[i] = octets[i];
-            } else {
-                // This byte contains the boundary between prefix and host
-                let shift = 8 - (subnet as usize - bit_pos);
-                result[i] = octets[i] & (0xFF << shift);
-            }
-        }
-        // Else this byte is entirely within the host portion, leave as 0
-    }
-
-    Ipv6Addr::from(result)
-}
-
-fn auto_detect_ipv6_subnet(addr: &Ipv6Addr) -> u8 {
-    let segments = addr.segments();
-    let str_addr = addr.to_string();
-
-    // Special cases to match expected test outputs
-    // This is to fix the test case for "2001:db8" that expects "2001:db8::/32"
-    if str_addr.starts_with("2001:db8::") || str_addr.starts_with("2001:db8:") {
-        return 32;
-    }
-
-    if str_addr == "::1" {
-        return 128; // Special case for localhost
-    }
-
-    if str_addr.starts_with("fe80::") {
-        return 16; // Special case for link-local
-    }
-
-    // Count trailing zero segments to determine subnet
-    let mut subnet = 128;
-    for i in (0..8).rev() {
-        if segments[i] != 0 {
-            // Found the last non-zero segment
-            if segments[i] & 0xFF == 0 {
-                // If the lower byte is zero, it suggests a /120 network
-                subnet = (i * 16) + 8;
-            } else {
-                // Otherwise, use a multiple of 16 bits
-                subnet = (i + 1) * 16; // Changed to include the current segment
-            }
-            break;
-        }
-    }
-
-    // Default to /64 if we couldn't determine or got less than 16
-    if subnet < 16 {
-        subnet = 64;
-    }
-
-    subnet as u8
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use datatypes::scalars::ScalarVector;
-    use datatypes::vectors::{StringVector, UInt8Vector};
-
-    use super::*;
-
-    #[test]
-    fn test_ipv4_to_cidr_auto() {
-        let func = Ipv4ToCidr;
-        let ctx = FunctionContext::default();
-
-        // Test data with auto subnet detection
-        let values = vec!["192.168.1.0", "10.0.0.0", "172.16", "192"];
-        let input = Arc::new(StringVector::from_slice(&values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[input]).unwrap();
-        let result = result.as_any().downcast_ref::<StringVector>().unwrap();
-
-        assert_eq!(result.get_data(0).unwrap(), "192.168.1.0/24");
-        assert_eq!(result.get_data(1).unwrap(), "10.0.0.0/8");
-        assert_eq!(result.get_data(2).unwrap(), "172.16.0.0/16");
-        assert_eq!(result.get_data(3).unwrap(), "192.0.0.0/8");
-    }
-
-    #[test]
-    fn test_ipv4_to_cidr_with_subnet() {
-        let func = Ipv4ToCidr;
-        let ctx = FunctionContext::default();
-
-        // Test data with explicit subnet
-        let ip_values = vec!["192.168.1.1", "10.0.0.1", "172.16.5.5"];
-        let subnet_values = vec![24u8, 16u8, 12u8];
-        let ip_input = Arc::new(StringVector::from_slice(&ip_values)) as VectorRef;
-        let subnet_input = Arc::new(UInt8Vector::from_vec(subnet_values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[ip_input, subnet_input]).unwrap();
-        let result = result.as_any().downcast_ref::<StringVector>().unwrap();
-
-        assert_eq!(result.get_data(0).unwrap(), "192.168.1.0/24");
-        assert_eq!(result.get_data(1).unwrap(), "10.0.0.0/16");
-        assert_eq!(result.get_data(2).unwrap(), "172.16.0.0/12");
-    }
-
-    #[test]
-    fn test_ipv6_to_cidr_auto() {
-        let func = Ipv6ToCidr;
-        let ctx = FunctionContext::default();
-
-        // Test data with auto subnet detection
-        let values = vec!["2001:db8::", "2001:db8", "fe80::1", "::1"];
-        let input = Arc::new(StringVector::from_slice(&values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[input]).unwrap();
-        let result = result.as_any().downcast_ref::<StringVector>().unwrap();
-
-        assert_eq!(result.get_data(0).unwrap(), "2001:db8::/32");
-        assert_eq!(result.get_data(1).unwrap(), "2001:db8::/32");
-        assert_eq!(result.get_data(2).unwrap(), "fe80::/16");
-        assert_eq!(result.get_data(3).unwrap(), "::1/128"); // Special case for ::1
-    }
-
-    #[test]
-    fn test_ipv6_to_cidr_with_subnet() {
-        let func = Ipv6ToCidr;
-        let ctx = FunctionContext::default();
-
-        // Test data with explicit subnet
-        let ip_values = vec!["2001:db8::", "fe80::1", "2001:db8:1234::"];
-        let subnet_values = vec![48u8, 10u8, 56u8];
-        let ip_input = Arc::new(StringVector::from_slice(&ip_values)) as VectorRef;
-        let subnet_input = Arc::new(UInt8Vector::from_vec(subnet_values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[ip_input, subnet_input]).unwrap();
-        let result = result.as_any().downcast_ref::<StringVector>().unwrap();
-
-        assert_eq!(result.get_data(0).unwrap(), "2001:db8::/48");
-        assert_eq!(result.get_data(1).unwrap(), "fe80::/10");
-        assert_eq!(result.get_data(2).unwrap(), "2001:db8:1234::/56");
-    }
-
-    #[test]
-    fn test_invalid_inputs() {
-        let ipv4_func = Ipv4ToCidr;
-        let ipv6_func = Ipv6ToCidr;
-        let ctx = FunctionContext::default();
-
-        // Empty string should fail
-        let empty_values = vec![""];
-        let empty_input = Arc::new(StringVector::from_slice(&empty_values)) as VectorRef;
-
-        let ipv4_result = ipv4_func.eval(&ctx, &[empty_input.clone()]);
-        let ipv6_result = ipv6_func.eval(&ctx, &[empty_input.clone()]);
-
-        assert!(ipv4_result.is_err());
-        assert!(ipv6_result.is_err());
-
-        // Invalid IP formats should fail
-        let invalid_values = vec!["not an ip", "192.168.1.256", "zzzz::ffff"];
-        let invalid_input = Arc::new(StringVector::from_slice(&invalid_values)) as VectorRef;
-
-        let ipv4_result = ipv4_func.eval(&ctx, &[invalid_input.clone()]);
-
-        assert!(ipv4_result.is_err());
-    }
-}

src/common/function/src/scalars/ip/ipv4.rs

@@ -1,217 +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::net::Ipv4Addr;
-use std::str::FromStr;
-
-use common_query::error::{InvalidFuncArgsSnafu, Result};
-use common_query::prelude::{Signature, TypeSignature};
-use datafusion::logical_expr::Volatility;
-use datatypes::prelude::ConcreteDataType;
-use datatypes::scalars::ScalarVectorBuilder;
-use datatypes::vectors::{MutableVector, StringVectorBuilder, UInt32VectorBuilder, VectorRef};
-use derive_more::Display;
-use snafu::ensure;
-
-use crate::function::{Function, FunctionContext};
-
-/// Function that converts a UInt32 number to an IPv4 address string.
-///
-/// Interprets the number as an IPv4 address in big endian and returns
-/// a string in the format A.B.C.D (dot-separated numbers in decimal form).
-///
-/// For example:
-/// - 167772160 (0x0A000000) returns "10.0.0.0"
-/// - 3232235521 (0xC0A80001) returns "192.168.0.1"
-#[derive(Clone, Debug, Default, Display)]
-#[display("{}", self.name())]
-pub struct Ipv4NumToString;
-
-impl Function for Ipv4NumToString {
-    fn name(&self) -> &str {
-        "ipv4_num_to_string"
-    }
-
-    fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
-        Ok(ConcreteDataType::string_datatype())
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::new(
-            TypeSignature::Exact(vec![ConcreteDataType::uint32_datatype()]),
-            Volatility::Immutable,
-        )
-    }
-
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
-        ensure!(
-            columns.len() == 1,
-            InvalidFuncArgsSnafu {
-                err_msg: format!("Expected 1 argument, got {}", columns.len())
-            }
-        );
-
-        let uint_vec = &columns[0];
-        let size = uint_vec.len();
-        let mut results = StringVectorBuilder::with_capacity(size);
-
-        for i in 0..size {
-            let ip_num = uint_vec.get(i);
-            let ip_str = match ip_num {
-                datatypes::value::Value::UInt32(num) => {
-                    // Convert UInt32 to IPv4 string (A.B.C.D format)
-                    let a = (num >> 24) & 0xFF;
-                    let b = (num >> 16) & 0xFF;
-                    let c = (num >> 8) & 0xFF;
-                    let d = num & 0xFF;
-                    Some(format!("{}.{}.{}.{}", a, b, c, d))
-                }
-                _ => None,
-            };
-
-            results.push(ip_str.as_deref());
-        }
-
-        Ok(results.to_vector())
-    }
-}
-
-/// Function that converts a string representation of an IPv4 address to a UInt32 number.
-///
-/// For example:
-/// - "10.0.0.1" returns 167772161
-/// - "192.168.0.1" returns 3232235521
-/// - Invalid IPv4 format throws an exception
-#[derive(Clone, Debug, Default, Display)]
-#[display("{}", self.name())]
-pub struct Ipv4StringToNum;
-
-impl Function for Ipv4StringToNum {
-    fn name(&self) -> &str {
-        "ipv4_string_to_num"
-    }
-
-    fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
-        Ok(ConcreteDataType::uint32_datatype())
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::new(
-            TypeSignature::Exact(vec![ConcreteDataType::string_datatype()]),
-            Volatility::Immutable,
-        )
-    }
-
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
-        ensure!(
-            columns.len() == 1,
-            InvalidFuncArgsSnafu {
-                err_msg: format!("Expected 1 argument, got {}", columns.len())
-            }
-        );
-
-        let ip_vec = &columns[0];
-        let size = ip_vec.len();
-        let mut results = UInt32VectorBuilder::with_capacity(size);
-
-        for i in 0..size {
-            let ip_str = ip_vec.get(i);
-            let ip_num = match ip_str {
-                datatypes::value::Value::String(s) => {
-                    let ip_str = s.as_utf8();
-                    let ip_addr = Ipv4Addr::from_str(ip_str).map_err(|_| {
-                        InvalidFuncArgsSnafu {
-                            err_msg: format!("Invalid IPv4 address format: {}", ip_str),
-                        }
-                        .build()
-                    })?;
-                    Some(u32::from(ip_addr))
-                }
-                _ => None,
-            };
-
-            results.push(ip_num);
-        }
-
-        Ok(results.to_vector())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use datatypes::scalars::ScalarVector;
-    use datatypes::vectors::{StringVector, UInt32Vector};
-
-    use super::*;
-
-    #[test]
-    fn test_ipv4_num_to_string() {
-        let func = Ipv4NumToString;
-        let ctx = FunctionContext::default();
-
-        // Test data
-        let values = vec![167772161u32, 3232235521u32, 0u32, 4294967295u32];
-        let input = Arc::new(UInt32Vector::from_vec(values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[input]).unwrap();
-        let result = result.as_any().downcast_ref::<StringVector>().unwrap();
-
-        assert_eq!(result.get_data(0).unwrap(), "10.0.0.1");
-        assert_eq!(result.get_data(1).unwrap(), "192.168.0.1");
-        assert_eq!(result.get_data(2).unwrap(), "0.0.0.0");
-        assert_eq!(result.get_data(3).unwrap(), "255.255.255.255");
-    }
-
-    #[test]
-    fn test_ipv4_string_to_num() {
-        let func = Ipv4StringToNum;
-        let ctx = FunctionContext::default();
-
-        // Test data
-        let values = vec!["10.0.0.1", "192.168.0.1", "0.0.0.0", "255.255.255.255"];
-        let input = Arc::new(StringVector::from_slice(&values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[input]).unwrap();
-        let result = result.as_any().downcast_ref::<UInt32Vector>().unwrap();
-
-        assert_eq!(result.get_data(0).unwrap(), 167772161);
-        assert_eq!(result.get_data(1).unwrap(), 3232235521);
-        assert_eq!(result.get_data(2).unwrap(), 0);
-        assert_eq!(result.get_data(3).unwrap(), 4294967295);
-    }
-
-    #[test]
-    fn test_ipv4_conversions_roundtrip() {
-        let to_num = Ipv4StringToNum;
-        let to_string = Ipv4NumToString;
-        let ctx = FunctionContext::default();
-
-        // Test data for string to num to string
-        let values = vec!["10.0.0.1", "192.168.0.1", "0.0.0.0", "255.255.255.255"];
-        let input = Arc::new(StringVector::from_slice(&values)) as VectorRef;
-
-        let num_result = to_num.eval(&ctx, &[input]).unwrap();
-        let back_to_string = to_string.eval(&ctx, &[num_result]).unwrap();
-        let str_result = back_to_string
-            .as_any()
-            .downcast_ref::<StringVector>()
-            .unwrap();
-
-        for (i, expected) in values.iter().enumerate() {
-            assert_eq!(str_result.get_data(i).unwrap(), *expected);
-        }
-    }
-}

src/common/function/src/scalars/ip/ipv6.rs

@@ -1,366 +0,0 @@
-// Copyright 2023 Greptime Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::net::{Ipv4Addr, Ipv6Addr};
-use std::str::FromStr;
-
-use common_query::error::{InvalidFuncArgsSnafu, Result};
-use common_query::prelude::{Signature, TypeSignature};
-use datafusion::logical_expr::Volatility;
-use datatypes::prelude::{ConcreteDataType, Value};
-use datatypes::scalars::ScalarVectorBuilder;
-use datatypes::vectors::{BinaryVectorBuilder, MutableVector, StringVectorBuilder, VectorRef};
-use derive_more::Display;
-use snafu::ensure;
-
-use crate::function::{Function, FunctionContext};
-
-/// Function that converts a hex string representation of an IPv6 address to a formatted string.
-///
-/// For example:
-/// - "20010DB8000000000000000000000001" returns "2001:db8::1"
-/// - "00000000000000000000FFFFC0A80001" returns "::ffff:192.168.0.1"
-#[derive(Clone, Debug, Default, Display)]
-#[display("{}", self.name())]
-pub struct Ipv6NumToString;
-
-impl Function for Ipv6NumToString {
-    fn name(&self) -> &str {
-        "ipv6_num_to_string"
-    }
-
-    fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
-        Ok(ConcreteDataType::string_datatype())
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::new(
-            TypeSignature::Exact(vec![ConcreteDataType::string_datatype()]),
-            Volatility::Immutable,
-        )
-    }
-
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
-        ensure!(
-            columns.len() == 1,
-            InvalidFuncArgsSnafu {
-                err_msg: format!("Expected 1 argument, got {}", columns.len())
-            }
-        );
-
-        let hex_vec = &columns[0];
-        let size = hex_vec.len();
-        let mut results = StringVectorBuilder::with_capacity(size);
-
-        for i in 0..size {
-            let hex_str = hex_vec.get(i);
-            let ip_str = match hex_str {
-                Value::String(s) => {
-                    let hex_str = s.as_utf8().to_lowercase();
-
-                    // Validate and convert hex string to bytes
-                    let bytes = if hex_str.len() == 32 {
-                        let mut bytes = [0u8; 16];
-                        for i in 0..16 {
-                            let byte_str = &hex_str[i * 2..i * 2 + 2];
-                            bytes[i] = u8::from_str_radix(byte_str, 16).map_err(|_| {
-                                InvalidFuncArgsSnafu {
-                                    err_msg: format!("Invalid hex characters in '{}'", byte_str),
-                                }
-                                .build()
-                            })?;
-                        }
-                        bytes
-                    } else {
-                        return InvalidFuncArgsSnafu {
-                            err_msg: format!("Expected 32 hex characters, got {}", hex_str.len()),
-                        }
-                        .fail();
-                    };
-
-                    // Convert bytes to IPv6 address
-                    let addr = Ipv6Addr::from(bytes);
-
-                    // Special handling for IPv6-mapped IPv4 addresses
-                    if let Some(ipv4) = addr.to_ipv4() {
-                        if addr.octets()[0..10].iter().all(|&b| b == 0)
-                            && addr.octets()[10] == 0xFF
-                            && addr.octets()[11] == 0xFF
-                        {
-                            Some(format!("::ffff:{}", ipv4))
-                        } else {
-                            Some(addr.to_string())
-                        }
-                    } else {
-                        Some(addr.to_string())
-                    }
-                }
-                _ => None,
-            };
-
-            results.push(ip_str.as_deref());
-        }
-
-        Ok(results.to_vector())
-    }
-}
-
-/// Function that converts a string representation of an IPv6 address to its binary representation.
-///
-/// For example:
-/// - "2001:db8::1" returns its binary representation
-/// - If the input string contains a valid IPv4 address, returns its IPv6 equivalent
-/// - HEX can be uppercase or lowercase
-/// - Invalid IPv6 format throws an exception
-#[derive(Clone, Debug, Default, Display)]
-#[display("{}", self.name())]
-pub struct Ipv6StringToNum;
-
-impl Function for Ipv6StringToNum {
-    fn name(&self) -> &str {
-        "ipv6_string_to_num"
-    }
-
-    fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
-        Ok(ConcreteDataType::binary_datatype())
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::new(
-            TypeSignature::Exact(vec![ConcreteDataType::string_datatype()]),
-            Volatility::Immutable,
-        )
-    }
-
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
-        ensure!(
-            columns.len() == 1,
-            InvalidFuncArgsSnafu {
-                err_msg: format!("Expected 1 argument, got {}", columns.len())
-            }
-        );
-
-        let ip_vec = &columns[0];
-        let size = ip_vec.len();
-        let mut results = BinaryVectorBuilder::with_capacity(size);
-
-        for i in 0..size {
-            let ip_str = ip_vec.get(i);
-            let ip_binary = match ip_str {
-                Value::String(s) => {
-                    let addr_str = s.as_utf8();
-
-                    let addr = if let Ok(ipv6) = Ipv6Addr::from_str(addr_str) {
-                        // Direct IPv6 address
-                        ipv6
-                    } else if let Ok(ipv4) = Ipv4Addr::from_str(addr_str) {
-                        // IPv4 address to be converted to IPv6
-                        ipv4.to_ipv6_mapped()
-                    } else {
-                        // Invalid format
-                        return InvalidFuncArgsSnafu {
-                            err_msg: format!("Invalid IPv6 address format: {}", addr_str),
-                        }
-                        .fail();
-                    };
-
-                    // Convert IPv6 address to binary (16 bytes)
-                    let octets = addr.octets();
-                    Some(octets.to_vec())
-                }
-                _ => None,
-            };
-
-            results.push(ip_binary.as_deref());
-        }
-
-        Ok(results.to_vector())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::fmt::Write;
-    use std::sync::Arc;
-
-    use datatypes::scalars::ScalarVector;
-    use datatypes::vectors::{BinaryVector, StringVector, Vector};
-
-    use super::*;
-
-    #[test]
-    fn test_ipv6_num_to_string() {
-        let func = Ipv6NumToString;
-        let ctx = FunctionContext::default();
-
-        // Hex string for "2001:db8::1"
-        let hex_str1 = "20010db8000000000000000000000001";
-
-        // Hex string for IPv4-mapped IPv6 address "::ffff:192.168.0.1"
-        let hex_str2 = "00000000000000000000ffffc0a80001";
-
-        let values = vec![hex_str1, hex_str2];
-        let input = Arc::new(StringVector::from_slice(&values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[input]).unwrap();
-        let result = result.as_any().downcast_ref::<StringVector>().unwrap();
-
-        assert_eq!(result.get_data(0).unwrap(), "2001:db8::1");
-        assert_eq!(result.get_data(1).unwrap(), "::ffff:192.168.0.1");
-    }
-
-    #[test]
-    fn test_ipv6_num_to_string_uppercase() {
-        let func = Ipv6NumToString;
-        let ctx = FunctionContext::default();
-
-        // Uppercase hex string for "2001:db8::1"
-        let hex_str = "20010DB8000000000000000000000001";
-
-        let values = vec![hex_str];
-        let input = Arc::new(StringVector::from_slice(&values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[input]).unwrap();
-        let result = result.as_any().downcast_ref::<StringVector>().unwrap();
-
-        assert_eq!(result.get_data(0).unwrap(), "2001:db8::1");
-    }
-
-    #[test]
-    fn test_ipv6_num_to_string_error() {
-        let func = Ipv6NumToString;
-        let ctx = FunctionContext::default();
-
-        // Invalid hex string - wrong length
-        let hex_str = "20010db8";
-
-        let values = vec![hex_str];
-        let input = Arc::new(StringVector::from_slice(&values)) as VectorRef;
-
-        // Should return an error
-        let result = func.eval(&ctx, &[input]);
-        assert!(result.is_err());
-
-        // Check that the error message contains expected text
-        let error_msg = result.unwrap_err().to_string();
-        assert!(error_msg.contains("Expected 32 hex characters"));
-    }
-
-    #[test]
-    fn test_ipv6_string_to_num() {
-        let func = Ipv6StringToNum;
-        let ctx = FunctionContext::default();
-
-        let values = vec!["2001:db8::1", "::ffff:192.168.0.1", "192.168.0.1"];
-        let input = Arc::new(StringVector::from_slice(&values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[input]).unwrap();
-        let result = result.as_any().downcast_ref::<BinaryVector>().unwrap();
-
-        // Expected binary for "2001:db8::1"
-        let expected_1 = [
-            0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01,
-        ];
-
-        // Expected binary for "::ffff:192.168.0.1" or "192.168.0.1" (IPv4-mapped)
-        let expected_2 = [
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0xC0, 0xA8, 0, 0x01,
-        ];
-
-        assert_eq!(result.get_data(0).unwrap(), &expected_1);
-        assert_eq!(result.get_data(1).unwrap(), &expected_2);
-        assert_eq!(result.get_data(2).unwrap(), &expected_2);
-    }
-
-    #[test]
-    fn test_ipv6_conversions_roundtrip() {
-        let to_num = Ipv6StringToNum;
-        let to_string = Ipv6NumToString;
-        let ctx = FunctionContext::default();
-
-        // Test data
-        let values = vec!["2001:db8::1", "::ffff:192.168.0.1"];
-        let input = Arc::new(StringVector::from_slice(&values)) as VectorRef;
-
-        // Convert IPv6 addresses to binary
-        let binary_result = to_num.eval(&ctx, &[input.clone()]).unwrap();
-
-        // Convert binary to hex string representation (for ipv6_num_to_string)
-        let mut hex_strings = Vec::new();
-        let binary_vector = binary_result
-            .as_any()
-            .downcast_ref::<BinaryVector>()
-            .unwrap();
-
-        for i in 0..binary_vector.len() {
-            let bytes = binary_vector.get_data(i).unwrap();
-            let hex = bytes.iter().fold(String::new(), |mut acc, b| {
-                write!(&mut acc, "{:02x}", b).unwrap();
-                acc
-            });
-            hex_strings.push(hex);
-        }
-
-        let hex_str_refs: Vec<&str> = hex_strings.iter().map(|s| s.as_str()).collect();
-        let hex_input = Arc::new(StringVector::from_slice(&hex_str_refs)) as VectorRef;
-
-        // Now convert hex to formatted string
-        let string_result = to_string.eval(&ctx, &[hex_input]).unwrap();
-        let str_result = string_result
-            .as_any()
-            .downcast_ref::<StringVector>()
-            .unwrap();
-
-        // Compare with original input
-        assert_eq!(str_result.get_data(0).unwrap(), values[0]);
-        assert_eq!(str_result.get_data(1).unwrap(), values[1]);
-    }
-
-    #[test]
-    fn test_ipv6_conversions_hex_roundtrip() {
-        // Create a new test to verify that the string output from ipv6_num_to_string
-        // can be converted back using ipv6_string_to_num
-        let to_string = Ipv6NumToString;
-        let to_binary = Ipv6StringToNum;
-        let ctx = FunctionContext::default();
-
-        // Hex representation of IPv6 addresses
-        let hex_values = vec![
-            "20010db8000000000000000000000001",
-            "00000000000000000000ffffc0a80001",
-        ];
-        let hex_input = Arc::new(StringVector::from_slice(&hex_values)) as VectorRef;
-
-        // Convert hex to string representation
-        let string_result = to_string.eval(&ctx, &[hex_input]).unwrap();
-
-        // Then convert string representation back to binary
-        let binary_result = to_binary.eval(&ctx, &[string_result]).unwrap();
-        let bin_result = binary_result
-            .as_any()
-            .downcast_ref::<BinaryVector>()
-            .unwrap();
-
-        // Expected binary values
-        let expected_bin1 = [
-            0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01,
-        ];
-        let expected_bin2 = [
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0xC0, 0xA8, 0, 0x01,
-        ];
-
-        assert_eq!(bin_result.get_data(0).unwrap(), &expected_bin1);
-        assert_eq!(bin_result.get_data(1).unwrap(), &expected_bin2);
-    }
-}

src/common/function/src/scalars/ip/range.rs

@@ -1,473 +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::net::{Ipv4Addr, Ipv6Addr};
-use std::str::FromStr;
-
-use common_query::error::{InvalidFuncArgsSnafu, Result};
-use common_query::prelude::{Signature, TypeSignature};
-use datafusion::logical_expr::Volatility;
-use datatypes::prelude::{ConcreteDataType, Value};
-use datatypes::scalars::ScalarVectorBuilder;
-use datatypes::vectors::{BooleanVectorBuilder, MutableVector, VectorRef};
-use derive_more::Display;
-use snafu::ensure;
-
-use crate::function::{Function, FunctionContext};
-
-/// Function that checks if an IPv4 address is within a specified CIDR range.
-///
-/// Both the IP address and the CIDR range are provided as strings.
-/// Returns boolean result indicating whether the IP is in the range.
-///
-/// Examples:
-/// - ipv4_in_range('192.168.1.5', '192.168.1.0/24') -> true
-/// - ipv4_in_range('192.168.2.1', '192.168.1.0/24') -> false
-/// - ipv4_in_range('10.0.0.1', '10.0.0.0/8') -> true
-#[derive(Clone, Debug, Default, Display)]
-#[display("{}", self.name())]
-pub struct Ipv4InRange;
-
-impl Function for Ipv4InRange {
-    fn name(&self) -> &str {
-        "ipv4_in_range"
-    }
-
-    fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
-        Ok(ConcreteDataType::boolean_datatype())
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::new(
-            TypeSignature::Exact(vec![
-                ConcreteDataType::string_datatype(),
-                ConcreteDataType::string_datatype(),
-            ]),
-            Volatility::Immutable,
-        )
-    }
-
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
-        ensure!(
-            columns.len() == 2,
-            InvalidFuncArgsSnafu {
-                err_msg: format!("Expected 2 arguments, got {}", columns.len())
-            }
-        );
-
-        let ip_vec = &columns[0];
-        let range_vec = &columns[1];
-        let size = ip_vec.len();
-
-        ensure!(
-            range_vec.len() == size,
-            InvalidFuncArgsSnafu {
-                err_msg: "IP addresses and CIDR ranges must have the same number of rows"
-                    .to_string()
-            }
-        );
-
-        let mut results = BooleanVectorBuilder::with_capacity(size);
-
-        for i in 0..size {
-            let ip = ip_vec.get(i);
-            let range = range_vec.get(i);
-
-            let in_range = match (ip, range) {
-                (Value::String(ip_str), Value::String(range_str)) => {
-                    let ip_str = ip_str.as_utf8().trim();
-                    let range_str = range_str.as_utf8().trim();
-
-                    if ip_str.is_empty() || range_str.is_empty() {
-                        return InvalidFuncArgsSnafu {
-                            err_msg: "IP address and CIDR range cannot be empty".to_string(),
-                        }
-                        .fail();
-                    }
-
-                    // Parse the IP address
-                    let ip_addr = Ipv4Addr::from_str(ip_str).map_err(|_| {
-                        InvalidFuncArgsSnafu {
-                            err_msg: format!("Invalid IPv4 address: {}", ip_str),
-                        }
-                        .build()
-                    })?;
-
-                    // Parse the CIDR range
-                    let (cidr_ip, cidr_prefix) = parse_ipv4_cidr(range_str)?;
-
-                    // Check if the IP is in the CIDR range
-                    is_ipv4_in_range(&ip_addr, &cidr_ip, cidr_prefix)
-                }
-                _ => None,
-            };
-
-            results.push(in_range);
-        }
-
-        Ok(results.to_vector())
-    }
-}
-
-/// Function that checks if an IPv6 address is within a specified CIDR range.
-///
-/// Both the IP address and the CIDR range are provided as strings.
-/// Returns boolean result indicating whether the IP is in the range.
-///
-/// Examples:
-/// - ipv6_in_range('2001:db8::1', '2001:db8::/32') -> true
-/// - ipv6_in_range('2001:db8:1::', '2001:db8::/32') -> true
-/// - ipv6_in_range('2001:db9::1', '2001:db8::/32') -> false
-/// - ipv6_in_range('::1', '::1/128') -> true
-#[derive(Clone, Debug, Default, Display)]
-#[display("{}", self.name())]
-pub struct Ipv6InRange;
-
-impl Function for Ipv6InRange {
-    fn name(&self) -> &str {
-        "ipv6_in_range"
-    }
-
-    fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
-        Ok(ConcreteDataType::boolean_datatype())
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::new(
-            TypeSignature::Exact(vec![
-                ConcreteDataType::string_datatype(),
-                ConcreteDataType::string_datatype(),
-            ]),
-            Volatility::Immutable,
-        )
-    }
-
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
-        ensure!(
-            columns.len() == 2,
-            InvalidFuncArgsSnafu {
-                err_msg: format!("Expected 2 arguments, got {}", columns.len())
-            }
-        );
-
-        let ip_vec = &columns[0];
-        let range_vec = &columns[1];
-        let size = ip_vec.len();
-
-        ensure!(
-            range_vec.len() == size,
-            InvalidFuncArgsSnafu {
-                err_msg: "IP addresses and CIDR ranges must have the same number of rows"
-                    .to_string()
-            }
-        );
-
-        let mut results = BooleanVectorBuilder::with_capacity(size);
-
-        for i in 0..size {
-            let ip = ip_vec.get(i);
-            let range = range_vec.get(i);
-
-            let in_range = match (ip, range) {
-                (Value::String(ip_str), Value::String(range_str)) => {
-                    let ip_str = ip_str.as_utf8().trim();
-                    let range_str = range_str.as_utf8().trim();
-
-                    if ip_str.is_empty() || range_str.is_empty() {
-                        return InvalidFuncArgsSnafu {
-                            err_msg: "IP address and CIDR range cannot be empty".to_string(),
-                        }
-                        .fail();
-                    }
-
-                    // Parse the IP address
-                    let ip_addr = Ipv6Addr::from_str(ip_str).map_err(|_| {
-                        InvalidFuncArgsSnafu {
-                            err_msg: format!("Invalid IPv6 address: {}", ip_str),
-                        }
-                        .build()
-                    })?;
-
-                    // Parse the CIDR range
-                    let (cidr_ip, cidr_prefix) = parse_ipv6_cidr(range_str)?;
-
-                    // Check if the IP is in the CIDR range
-                    is_ipv6_in_range(&ip_addr, &cidr_ip, cidr_prefix)
-                }
-                _ => None,
-            };
-
-            results.push(in_range);
-        }
-
-        Ok(results.to_vector())
-    }
-}
-
-// Helper functions
-
-fn parse_ipv4_cidr(cidr: &str) -> Result<(Ipv4Addr, u8)> {
-    // Split the CIDR string into IP and prefix parts
-    let parts: Vec<&str> = cidr.split('/').collect();
-    ensure!(
-        parts.len() == 2,
-        InvalidFuncArgsSnafu {
-            err_msg: format!("Invalid CIDR notation: {}", cidr),
-        }
-    );
-
-    // Parse the IP address part
-    let ip = Ipv4Addr::from_str(parts[0]).map_err(|_| {
-        InvalidFuncArgsSnafu {
-            err_msg: format!("Invalid IPv4 address in CIDR: {}", parts[0]),
-        }
-        .build()
-    })?;
-
-    // Parse the prefix length
-    let prefix = parts[1].parse::<u8>().map_err(|_| {
-        InvalidFuncArgsSnafu {
-            err_msg: format!("Invalid prefix length: {}", parts[1]),
-        }
-        .build()
-    })?;
-
-    ensure!(
-        prefix <= 32,
-        InvalidFuncArgsSnafu {
-            err_msg: format!("IPv4 prefix length must be <= 32, got {}", prefix),
-        }
-    );
-
-    Ok((ip, prefix))
-}
-
-fn parse_ipv6_cidr(cidr: &str) -> Result<(Ipv6Addr, u8)> {
-    // Split the CIDR string into IP and prefix parts
-    let parts: Vec<&str> = cidr.split('/').collect();
-    ensure!(
-        parts.len() == 2,
-        InvalidFuncArgsSnafu {
-            err_msg: format!("Invalid CIDR notation: {}", cidr),
-        }
-    );
-
-    // Parse the IP address part
-    let ip = Ipv6Addr::from_str(parts[0]).map_err(|_| {
-        InvalidFuncArgsSnafu {
-            err_msg: format!("Invalid IPv6 address in CIDR: {}", parts[0]),
-        }
-        .build()
-    })?;
-
-    // Parse the prefix length
-    let prefix = parts[1].parse::<u8>().map_err(|_| {
-        InvalidFuncArgsSnafu {
-            err_msg: format!("Invalid prefix length: {}", parts[1]),
-        }
-        .build()
-    })?;
-
-    ensure!(
-        prefix <= 128,
-        InvalidFuncArgsSnafu {
-            err_msg: format!("IPv6 prefix length must be <= 128, got {}", prefix),
-        }
-    );
-
-    Ok((ip, prefix))
-}
-
-fn is_ipv4_in_range(ip: &Ipv4Addr, cidr_base: &Ipv4Addr, prefix_len: u8) -> Option<bool> {
-    // Convert both IPs to integers
-    let ip_int = u32::from(*ip);
-    let cidr_int = u32::from(*cidr_base);
-
-    // Calculate the mask from the prefix length
-    let mask = if prefix_len == 0 {
-        0
-    } else {
-        u32::MAX << (32 - prefix_len)
-    };
-
-    // Apply the mask to both IPs and see if they match
-    let ip_network = ip_int & mask;
-    let cidr_network = cidr_int & mask;
-
-    Some(ip_network == cidr_network)
-}
-
-fn is_ipv6_in_range(ip: &Ipv6Addr, cidr_base: &Ipv6Addr, prefix_len: u8) -> Option<bool> {
-    // Get the octets (16 bytes) of both IPs
-    let ip_octets = ip.octets();
-    let cidr_octets = cidr_base.octets();
-
-    // Calculate how many full bytes to compare
-    let full_bytes = (prefix_len / 8) as usize;
-
-    // First, check full bytes for equality
-    for i in 0..full_bytes {
-        if ip_octets[i] != cidr_octets[i] {
-            return Some(false);
-        }
-    }
-
-    // If there's a partial byte to check
-    if prefix_len % 8 != 0 && full_bytes < 16 {
-        let bits_to_check = prefix_len % 8;
-        let mask = 0xFF_u8 << (8 - bits_to_check);
-
-        if (ip_octets[full_bytes] & mask) != (cidr_octets[full_bytes] & mask) {
-            return Some(false);
-        }
-    }
-
-    // If we got here, everything matched
-    Some(true)
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use datatypes::scalars::ScalarVector;
-    use datatypes::vectors::{BooleanVector, StringVector};
-
-    use super::*;
-
-    #[test]
-    fn test_ipv4_in_range() {
-        let func = Ipv4InRange;
-        let ctx = FunctionContext::default();
-
-        // Test IPs
-        let ip_values = vec![
-            "192.168.1.5",
-            "192.168.2.1",
-            "10.0.0.1",
-            "10.1.0.1",
-            "172.16.0.1",
-        ];
-
-        // Corresponding CIDR ranges
-        let cidr_values = vec![
-            "192.168.1.0/24",
-            "192.168.1.0/24",
-            "10.0.0.0/8",
-            "10.0.0.0/8",
-            "172.16.0.0/16",
-        ];
-
-        let ip_input = Arc::new(StringVector::from_slice(&ip_values)) as VectorRef;
-        let cidr_input = Arc::new(StringVector::from_slice(&cidr_values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[ip_input, cidr_input]).unwrap();
-        let result = result.as_any().downcast_ref::<BooleanVector>().unwrap();
-
-        // Expected results
-        assert!(result.get_data(0).unwrap()); // 192.168.1.5 is in 192.168.1.0/24
-        assert!(!result.get_data(1).unwrap()); // 192.168.2.1 is not in 192.168.1.0/24
-        assert!(result.get_data(2).unwrap()); // 10.0.0.1 is in 10.0.0.0/8
-        assert!(result.get_data(3).unwrap()); // 10.1.0.1 is in 10.0.0.0/8
-        assert!(result.get_data(4).unwrap()); // 172.16.0.1 is in 172.16.0.0/16
-    }
-
-    #[test]
-    fn test_ipv6_in_range() {
-        let func = Ipv6InRange;
-        let ctx = FunctionContext::default();
-
-        // Test IPs
-        let ip_values = vec![
-            "2001:db8::1",
-            "2001:db8:1::",
-            "2001:db9::1",
-            "::1",
-            "fe80::1",
-        ];
-
-        // Corresponding CIDR ranges
-        let cidr_values = vec![
-            "2001:db8::/32",
-            "2001:db8::/32",
-            "2001:db8::/32",
-            "::1/128",
-            "fe80::/16",
-        ];
-
-        let ip_input = Arc::new(StringVector::from_slice(&ip_values)) as VectorRef;
-        let cidr_input = Arc::new(StringVector::from_slice(&cidr_values)) as VectorRef;
-
-        let result = func.eval(&ctx, &[ip_input, cidr_input]).unwrap();
-        let result = result.as_any().downcast_ref::<BooleanVector>().unwrap();
-
-        // Expected results
-        assert!(result.get_data(0).unwrap()); // 2001:db8::1 is in 2001:db8::/32
-        assert!(result.get_data(1).unwrap()); // 2001:db8:1:: is in 2001:db8::/32
-        assert!(!result.get_data(2).unwrap()); // 2001:db9::1 is not in 2001:db8::/32
-        assert!(result.get_data(3).unwrap()); // ::1 is in ::1/128
-        assert!(result.get_data(4).unwrap()); // fe80::1 is in fe80::/16
-    }
-
-    #[test]
-    fn test_invalid_inputs() {
-        let ipv4_func = Ipv4InRange;
-        let ipv6_func = Ipv6InRange;
-        let ctx = FunctionContext::default();
-
-        // Invalid IPv4 address
-        let invalid_ip_values = vec!["not-an-ip", "192.168.1.300"];
-        let cidr_values = vec!["192.168.1.0/24", "192.168.1.0/24"];
-
-        let invalid_ip_input = Arc::new(StringVector::from_slice(&invalid_ip_values)) as VectorRef;
-        let cidr_input = Arc::new(StringVector::from_slice(&cidr_values)) as VectorRef;
-
-        let result = ipv4_func.eval(&ctx, &[invalid_ip_input, cidr_input]);
-        assert!(result.is_err());
-
-        // Invalid CIDR notation
-        let ip_values = vec!["192.168.1.1", "2001:db8::1"];
-        let invalid_cidr_values = vec!["192.168.1.0", "2001:db8::/129"];
-
-        let ip_input = Arc::new(StringVector::from_slice(&ip_values)) as VectorRef;
-        let invalid_cidr_input =
-            Arc::new(StringVector::from_slice(&invalid_cidr_values)) as VectorRef;
-
-        let ipv4_result = ipv4_func.eval(&ctx, &[ip_input.clone(), invalid_cidr_input.clone()]);
-        let ipv6_result = ipv6_func.eval(&ctx, &[ip_input, invalid_cidr_input]);
-
-        assert!(ipv4_result.is_err());
-        assert!(ipv6_result.is_err());
-    }
-
-    #[test]
-    fn test_edge_cases() {
-        let ipv4_func = Ipv4InRange;
-        let ctx = FunctionContext::default();
-
-        // Edge cases like prefix length 0 (matches everything) and 32 (exact match)
-        let ip_values = vec!["8.8.8.8", "192.168.1.1", "192.168.1.1"];
-        let cidr_values = vec!["0.0.0.0/0", "192.168.1.1/32", "192.168.1.0/32"];
-
-        let ip_input = Arc::new(StringVector::from_slice(&ip_values)) as VectorRef;
-        let cidr_input = Arc::new(StringVector::from_slice(&cidr_values)) as VectorRef;
-
-        let result = ipv4_func.eval(&ctx, &[ip_input, cidr_input]).unwrap();
-        let result = result.as_any().downcast_ref::<BooleanVector>().unwrap();
-
-        assert!(result.get_data(0).unwrap()); // 8.8.8.8 is in 0.0.0.0/0 (matches everything)
-        assert!(result.get_data(1).unwrap()); // 192.168.1.1 is in 192.168.1.1/32 (exact match)
-        assert!(!result.get_data(2).unwrap()); // 192.168.1.1 is not in 192.168.1.0/32 (no match)
-    }
-}

src/common/function/src/scalars/json/json_get.rs

@@ -72,7 +72,7 @@ macro_rules! json_get {
                     )
                 }
 
-                fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+                fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
                     ensure!(
                         columns.len() == 2,
                         InvalidFuncArgsSnafu {
@@ -175,7 +175,7 @@ impl Function for JsonGetString {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 2,
             InvalidFuncArgsSnafu {
@@ -282,7 +282,7 @@ mod tests {
         let path_vector = StringVector::from_vec(paths);
         let args: Vec<VectorRef> = vec![Arc::new(json_vector), Arc::new(path_vector)];
         let vector = json_get_int
-            .eval(&FunctionContext::default(), &args)
+            .eval(FunctionContext::default(), &args)
             .unwrap();
 
         assert_eq!(3, vector.len());
@@ -335,7 +335,7 @@ mod tests {
         let path_vector = StringVector::from_vec(paths);
         let args: Vec<VectorRef> = vec![Arc::new(json_vector), Arc::new(path_vector)];
         let vector = json_get_float
-            .eval(&FunctionContext::default(), &args)
+            .eval(FunctionContext::default(), &args)
             .unwrap();
 
         assert_eq!(3, vector.len());
@@ -388,7 +388,7 @@ mod tests {
         let path_vector = StringVector::from_vec(paths);
         let args: Vec<VectorRef> = vec![Arc::new(json_vector), Arc::new(path_vector)];
         let vector = json_get_bool
-            .eval(&FunctionContext::default(), &args)
+            .eval(FunctionContext::default(), &args)
             .unwrap();
 
         assert_eq!(3, vector.len());
@@ -441,7 +441,7 @@ mod tests {
         let path_vector = StringVector::from_vec(paths);
         let args: Vec<VectorRef> = vec![Arc::new(json_vector), Arc::new(path_vector)];
         let vector = json_get_string
-            .eval(&FunctionContext::default(), &args)
+            .eval(FunctionContext::default(), &args)
             .unwrap();
 
         assert_eq!(3, vector.len());

src/common/function/src/scalars/json/json_is.rs

@@ -45,7 +45,7 @@ macro_rules! json_is {
                     Signature::exact(vec![ConcreteDataType::json_datatype()], Volatility::Immutable)
                 }
 
-                fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+                fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
                     ensure!(
                         columns.len() == 1,
                         InvalidFuncArgsSnafu {
@@ -202,7 +202,7 @@ mod tests {
         let args: Vec<VectorRef> = vec![Arc::new(json_vector)];
 
         for (func, expected_result) in json_is_functions.iter().zip(expected_results.iter()) {
-            let vector = func.eval(&FunctionContext::default(), &args).unwrap();
+            let vector = func.eval(FunctionContext::default(), &args).unwrap();
             assert_eq!(vector.len(), json_strings.len());
 
             for (i, expected) in expected_result.iter().enumerate() {

src/common/function/src/scalars/json/json_path_exists.rs

@@ -64,7 +64,7 @@ impl Function for JsonPathExistsFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 2,
             InvalidFuncArgsSnafu {
@@ -204,7 +204,7 @@ mod tests {
         let path_vector = StringVector::from_vec(paths);
         let args: Vec<VectorRef> = vec![Arc::new(json_vector), Arc::new(path_vector)];
         let vector = json_path_exists
-            .eval(&FunctionContext::default(), &args)
+            .eval(FunctionContext::default(), &args)
             .unwrap();
 
         // Test for non-nulls.
@@ -222,7 +222,7 @@ mod tests {
         let illegal_path = StringVector::from_vec(vec!["$..a"]);
 
         let args: Vec<VectorRef> = vec![Arc::new(json), Arc::new(illegal_path)];
-        let err = json_path_exists.eval(&FunctionContext::default(), &args);
+        let err = json_path_exists.eval(FunctionContext::default(), &args);
         assert!(err.is_err());
 
         // Test for nulls.
@@ -235,11 +235,11 @@ mod tests {
 
         let args: Vec<VectorRef> = vec![Arc::new(null_json), Arc::new(path)];
         let result1 = json_path_exists
-            .eval(&FunctionContext::default(), &args)
+            .eval(FunctionContext::default(), &args)
             .unwrap();
         let args: Vec<VectorRef> = vec![Arc::new(json), Arc::new(null_path)];
         let result2 = json_path_exists
-            .eval(&FunctionContext::default(), &args)
+            .eval(FunctionContext::default(), &args)
             .unwrap();
 
         assert_eq!(result1.len(), 1);

src/common/function/src/scalars/json/json_path_match.rs

@@ -50,7 +50,7 @@ impl Function for JsonPathMatchFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 2,
             InvalidFuncArgsSnafu {
@@ -180,7 +180,7 @@ mod tests {
         let path_vector = StringVector::from(paths);
         let args: Vec<VectorRef> = vec![Arc::new(json_vector), Arc::new(path_vector)];
         let vector = json_path_match
-            .eval(&FunctionContext::default(), &args)
+            .eval(FunctionContext::default(), &args)
             .unwrap();
 
         assert_eq!(7, vector.len());

src/common/function/src/scalars/json/json_to_string.rs

@@ -47,7 +47,7 @@ impl Function for JsonToStringFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 1,
             InvalidFuncArgsSnafu {
@@ -154,7 +154,7 @@ mod tests {
         let json_vector = BinaryVector::from_vec(jsonbs);
         let args: Vec<VectorRef> = vec![Arc::new(json_vector)];
         let vector = json_to_string
-            .eval(&FunctionContext::default(), &args)
+            .eval(FunctionContext::default(), &args)
             .unwrap();
 
         assert_eq!(3, vector.len());
@@ -168,7 +168,7 @@ mod tests {
         let invalid_jsonb = vec![b"invalid json"];
         let invalid_json_vector = BinaryVector::from_vec(invalid_jsonb);
         let args: Vec<VectorRef> = vec![Arc::new(invalid_json_vector)];
-        let vector = json_to_string.eval(&FunctionContext::default(), &args);
+        let vector = json_to_string.eval(FunctionContext::default(), &args);
         assert!(vector.is_err());
     }
 }

src/common/function/src/scalars/json/parse_json.rs

@@ -47,7 +47,7 @@ impl Function for ParseJsonFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 1,
             InvalidFuncArgsSnafu {
@@ -152,7 +152,7 @@ mod tests {
 
         let json_string_vector = StringVector::from_vec(json_strings.to_vec());
         let args: Vec<VectorRef> = vec![Arc::new(json_string_vector)];
-        let vector = parse_json.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = parse_json.eval(FunctionContext::default(), &args).unwrap();
 
         assert_eq!(3, vector.len());
         for (i, gt) in jsonbs.iter().enumerate() {

src/common/function/src/scalars/matches.rs

@@ -72,7 +72,7 @@ impl Function for MatchesFunction {
     }
 
     // TODO: read case-sensitive config
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 2,
             InvalidFuncArgsSnafu {
@@ -82,12 +82,6 @@ impl Function for MatchesFunction {
                 ),
             }
         );
-
-        let data_column = &columns[0];
-        if data_column.is_empty() {
-            return Ok(Arc::new(BooleanVector::from(Vec::<bool>::with_capacity(0))));
-        }
-
         let pattern_vector = &columns[1]
             .cast(&ConcreteDataType::string_datatype())
             .context(InvalidInputTypeSnafu {
@@ -95,12 +89,12 @@ impl Function for MatchesFunction {
             })?;
         // Safety: both length and type are checked before
         let pattern = pattern_vector.get(0).as_string().unwrap();
-        self.eval(data_column, pattern)
+        self.eval(columns[0].clone(), pattern)
     }
 }
 
 impl MatchesFunction {
-    fn eval(&self, data: &VectorRef, pattern: String) -> Result<VectorRef> {
+    fn eval(&self, data: VectorRef, pattern: String) -> Result<VectorRef> {
         let col_name = "data";
         let parser_context = ParserContext::default();
         let raw_ast = parser_context.parse_pattern(&pattern)?;
@@ -1315,7 +1309,7 @@ mod test {
             "The quick brown fox jumps over          dog",
             "The quick brown fox jumps over the      dog",
         ];
-        let input_vector: VectorRef = Arc::new(StringVector::from(input_data));
+        let input_vector = Arc::new(StringVector::from(input_data));
         let cases = [
             // basic cases
             ("quick", vec![true, false, true, true, true, true, true]),
@@ -1406,7 +1400,7 @@ mod test {
 
         let f = MatchesFunction;
         for (pattern, expected) in cases {
-            let actual: VectorRef = f.eval(&input_vector, pattern.to_string()).unwrap();
+            let actual: VectorRef = f.eval(input_vector.clone(), pattern.to_string()).unwrap();
             let expected: VectorRef = Arc::new(BooleanVector::from(expected)) as _;
             assert_eq!(expected, actual, "{pattern}");
         }

src/common/function/src/scalars/math.rs

@@ -80,7 +80,7 @@ impl Function for RangeFunction {
         Signature::variadic_any(Volatility::Immutable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, _columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, _columns: &[VectorRef]) -> Result<VectorRef> {
         Err(DataFusionError::Internal(
             "range_fn just a empty function used in range select, It should not be eval!".into(),
         ))

src/common/function/src/scalars/math/clamp.rs

@@ -27,7 +27,7 @@ use datatypes::vectors::PrimitiveVector;
 use datatypes::with_match_primitive_type_id;
 use snafu::{ensure, OptionExt};
 
-use crate::function::{Function, FunctionContext};
+use crate::function::Function;
 
 #[derive(Clone, Debug, Default)]
 pub struct ClampFunction;
@@ -49,7 +49,11 @@ impl Function for ClampFunction {
         Signature::uniform(3, ConcreteDataType::numerics(), Volatility::Immutable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(
+        &self,
+        _func_ctx: crate::function::FunctionContext,
+        columns: &[VectorRef],
+    ) -> Result<VectorRef> {
         ensure!(
             columns.len() == 3,
             InvalidFuncArgsSnafu {
@@ -205,7 +209,7 @@ mod test {
                 Arc::new(Int64Vector::from_vec(vec![max])) as _,
             ];
             let result = func
-                .eval(&FunctionContext::default(), args.as_slice())
+                .eval(FunctionContext::default(), args.as_slice())
                 .unwrap();
             let expected: VectorRef = Arc::new(Int64Vector::from(expected));
             assert_eq!(expected, result);
@@ -249,7 +253,7 @@ mod test {
                 Arc::new(UInt64Vector::from_vec(vec![max])) as _,
             ];
             let result = func
-                .eval(&FunctionContext::default(), args.as_slice())
+                .eval(FunctionContext::default(), args.as_slice())
                 .unwrap();
             let expected: VectorRef = Arc::new(UInt64Vector::from(expected));
             assert_eq!(expected, result);
@@ -293,7 +297,7 @@ mod test {
                 Arc::new(Float64Vector::from_vec(vec![max])) as _,
             ];
             let result = func
-                .eval(&FunctionContext::default(), args.as_slice())
+                .eval(FunctionContext::default(), args.as_slice())
                 .unwrap();
             let expected: VectorRef = Arc::new(Float64Vector::from(expected));
             assert_eq!(expected, result);
@@ -313,7 +317,7 @@ mod test {
             Arc::new(Int64Vector::from_vec(vec![max])) as _,
         ];
         let result = func
-            .eval(&FunctionContext::default(), args.as_slice())
+            .eval(FunctionContext::default(), args.as_slice())
             .unwrap();
         let expected: VectorRef = Arc::new(Int64Vector::from(vec![Some(4)]));
         assert_eq!(expected, result);
@@ -331,7 +335,7 @@ mod test {
             Arc::new(Float64Vector::from_vec(vec![min])) as _,
             Arc::new(Float64Vector::from_vec(vec![max])) as _,
         ];
-        let result = func.eval(&FunctionContext::default(), args.as_slice());
+        let result = func.eval(FunctionContext::default(), args.as_slice());
         assert!(result.is_err());
     }
 
@@ -347,7 +351,7 @@ mod test {
             Arc::new(Int64Vector::from_vec(vec![min])) as _,
             Arc::new(UInt64Vector::from_vec(vec![max])) as _,
         ];
-        let result = func.eval(&FunctionContext::default(), args.as_slice());
+        let result = func.eval(FunctionContext::default(), args.as_slice());
         assert!(result.is_err());
     }
 
@@ -363,7 +367,7 @@ mod test {
             Arc::new(Float64Vector::from_vec(vec![min, min])) as _,
             Arc::new(Float64Vector::from_vec(vec![max])) as _,
         ];
-        let result = func.eval(&FunctionContext::default(), args.as_slice());
+        let result = func.eval(FunctionContext::default(), args.as_slice());
         assert!(result.is_err());
     }
 
@@ -377,7 +381,7 @@ mod test {
             Arc::new(Float64Vector::from(input)) as _,
             Arc::new(Float64Vector::from_vec(vec![min])) as _,
         ];
-        let result = func.eval(&FunctionContext::default(), args.as_slice());
+        let result = func.eval(FunctionContext::default(), args.as_slice());
         assert!(result.is_err());
     }
 
@@ -391,7 +395,7 @@ mod test {
             Arc::new(StringVector::from_vec(vec!["bar"])) as _,
             Arc::new(StringVector::from_vec(vec!["baz"])) as _,
         ];
-        let result = func.eval(&FunctionContext::default(), args.as_slice());
+        let result = func.eval(FunctionContext::default(), args.as_slice());
         assert!(result.is_err());
     }
 }

src/common/function/src/scalars/math/modulo.rs

@@ -58,7 +58,7 @@ impl Function for ModuloFunction {
         Signature::uniform(2, ConcreteDataType::numerics(), Volatility::Immutable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 2,
             InvalidFuncArgsSnafu {
@@ -126,7 +126,7 @@ mod tests {
             Arc::new(Int32Vector::from_vec(nums.clone())),
             Arc::new(Int32Vector::from_vec(divs.clone())),
         ];
-        let result = function.eval(&FunctionContext::default(), &args).unwrap();
+        let result = function.eval(FunctionContext::default(), &args).unwrap();
         assert_eq!(result.len(), 4);
         for i in 0..4 {
             let p: i64 = (nums[i] % divs[i]) as i64;
@@ -158,7 +158,7 @@ mod tests {
             Arc::new(UInt32Vector::from_vec(nums.clone())),
             Arc::new(UInt32Vector::from_vec(divs.clone())),
         ];
-        let result = function.eval(&FunctionContext::default(), &args).unwrap();
+        let result = function.eval(FunctionContext::default(), &args).unwrap();
         assert_eq!(result.len(), 4);
         for i in 0..4 {
             let p: u64 = (nums[i] % divs[i]) as u64;
@@ -190,7 +190,7 @@ mod tests {
             Arc::new(Float64Vector::from_vec(nums.clone())),
             Arc::new(Float64Vector::from_vec(divs.clone())),
         ];
-        let result = function.eval(&FunctionContext::default(), &args).unwrap();
+        let result = function.eval(FunctionContext::default(), &args).unwrap();
         assert_eq!(result.len(), 4);
         for i in 0..4 {
             let p: f64 = nums[i] % divs[i];
@@ -209,7 +209,7 @@ mod tests {
             Arc::new(Int32Vector::from_vec(nums.clone())),
             Arc::new(Int32Vector::from_vec(divs.clone())),
         ];
-        let result = function.eval(&FunctionContext::default(), &args);
+        let result = function.eval(FunctionContext::default(), &args);
         assert!(result.is_err());
         let err_msg = result.unwrap_err().output_msg();
         assert_eq!(
@@ -220,7 +220,7 @@ mod tests {
         let nums = vec![27];
 
         let args: Vec<VectorRef> = vec![Arc::new(Int32Vector::from_vec(nums.clone()))];
-        let result = function.eval(&FunctionContext::default(), &args);
+        let result = function.eval(FunctionContext::default(), &args);
         assert!(result.is_err());
         let err_msg = result.unwrap_err().output_msg();
         assert!(
@@ -233,7 +233,7 @@ mod tests {
             Arc::new(StringVector::from(nums.clone())),
             Arc::new(StringVector::from(divs.clone())),
         ];
-        let result = function.eval(&FunctionContext::default(), &args);
+        let result = function.eval(FunctionContext::default(), &args);
         assert!(result.is_err());
         let err_msg = result.unwrap_err().output_msg();
         assert!(err_msg.contains("Invalid arithmetic operation"));

src/common/function/src/scalars/math/pow.rs

@@ -44,7 +44,7 @@ impl Function for PowFunction {
         Signature::uniform(2, ConcreteDataType::numerics(), Volatility::Immutable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         with_match_primitive_type_id!(columns[0].data_type().logical_type_id(), |$S| {
             with_match_primitive_type_id!(columns[1].data_type().logical_type_id(), |$T| {
                 let col = scalar_binary_op::<<$S as LogicalPrimitiveType>::Native, <$T as LogicalPrimitiveType>::Native, f64, _>(&columns[0], &columns[1], scalar_pow, &mut EvalContext::default())?;
@@ -109,7 +109,7 @@ mod tests {
             Arc::new(Int8Vector::from_vec(bases.clone())),
         ];
 
-        let vector = pow.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = pow.eval(FunctionContext::default(), &args).unwrap();
         assert_eq!(3, vector.len());
 
         for i in 0..3 {

src/common/function/src/scalars/math/rate.rs

@@ -48,7 +48,7 @@ impl Function for RateFunction {
         Signature::uniform(2, ConcreteDataType::numerics(), Volatility::Immutable)
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         let val = &columns[0].to_arrow_array();
         let val_0 = val.slice(0, val.len() - 1);
         let val_1 = val.slice(1, val.len() - 1);
@@ -100,7 +100,7 @@ mod tests {
             Arc::new(Float32Vector::from_vec(values)),
             Arc::new(Int64Vector::from_vec(ts)),
         ];
-        let vector = rate.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = rate.eval(FunctionContext::default(), &args).unwrap();
         let expect: VectorRef = Arc::new(Float64Vector::from_vec(vec![2.0, 3.0]));
         assert_eq!(expect, vector);
     }

src/common/function/src/scalars/test.rs

@@ -45,7 +45,7 @@ impl Function for TestAndFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         let col = scalar_binary_op::<bool, bool, bool, _>(
             &columns[0],
             &columns[1],

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

@@ -97,7 +97,7 @@ impl Function for GreatestFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 2,
             InvalidFuncArgsSnafu {
@@ -191,9 +191,7 @@ mod tests {
             ])) as _,
         ];
 
-        let result = function
-            .eval(&FunctionContext::default(), &columns)
-            .unwrap();
+        let result = function.eval(FunctionContext::default(), &columns).unwrap();
         let result = result.as_any().downcast_ref::<DateTimeVector>().unwrap();
         assert_eq!(result.len(), 2);
         assert_eq!(
@@ -224,9 +222,7 @@ mod tests {
             Arc::new(DateVector::from_slice(vec![0, 1])) as _,
         ];
 
-        let result = function
-            .eval(&FunctionContext::default(), &columns)
-            .unwrap();
+        let result = function.eval(FunctionContext::default(), &columns).unwrap();
         let result = result.as_any().downcast_ref::<DateVector>().unwrap();
         assert_eq!(result.len(), 2);
         assert_eq!(
@@ -257,9 +253,7 @@ mod tests {
             Arc::new(DateTimeVector::from_slice(vec![0, 1])) as _,
         ];
 
-        let result = function
-            .eval(&FunctionContext::default(), &columns)
-            .unwrap();
+        let result = function.eval(FunctionContext::default(), &columns).unwrap();
         let result = result.as_any().downcast_ref::<DateTimeVector>().unwrap();
         assert_eq!(result.len(), 2);
         assert_eq!(
@@ -288,7 +282,7 @@ mod tests {
                         Arc::new([<Timestamp $unit Vector>]::from_slice(vec![0, 1])) as _,
                     ];
 
-                    let result = function.eval(&FunctionContext::default(), &columns).unwrap();
+                    let result = function.eval(FunctionContext::default(), &columns).unwrap();
                     let result = result.as_any().downcast_ref::<[<Timestamp $unit Vector>]>().unwrap();
                     assert_eq!(result.len(), 2);
                     assert_eq!(

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

@@ -92,7 +92,7 @@ impl Function for ToUnixtimeFunction {
         )
     }
 
-    fn eval(&self, ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 1,
             InvalidFuncArgsSnafu {
@@ -108,7 +108,7 @@ impl Function for ToUnixtimeFunction {
         match columns[0].data_type() {
             ConcreteDataType::String(_) => Ok(Arc::new(Int64Vector::from(
                 (0..vector.len())
-                    .map(|i| convert_to_seconds(&vector.get(i).to_string(), ctx))
+                    .map(|i| convert_to_seconds(&vector.get(i).to_string(), &func_ctx))
                     .collect::<Vec<_>>(),
             ))),
             ConcreteDataType::Int64(_) | ConcreteDataType::Int32(_) => {
@@ -187,7 +187,7 @@ mod tests {
         ];
         let results = [Some(1677652502), None, Some(1656633600), None];
         let args: Vec<VectorRef> = vec![Arc::new(StringVector::from(times.clone()))];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        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);
@@ -211,7 +211,7 @@ mod tests {
         let times = vec![Some(3_i64), None, Some(5_i64), None];
         let results = [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();
+        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);
@@ -236,7 +236,7 @@ mod tests {
         let results = [Some(10627200), None, Some(3628800), None];
         let date_vector = DateVector::from(times.clone());
         let args: Vec<VectorRef> = vec![Arc::new(date_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        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);
@@ -261,7 +261,7 @@ mod tests {
         let results = [Some(123), None, Some(42), None];
         let date_vector = DateTimeVector::from(times.clone());
         let args: Vec<VectorRef> = vec![Arc::new(date_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        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);
@@ -286,7 +286,7 @@ mod tests {
         let results = [Some(123), None, Some(42), None];
         let ts_vector = TimestampSecondVector::from(times.clone());
         let args: Vec<VectorRef> = vec![Arc::new(ts_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        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);
@@ -306,7 +306,7 @@ mod tests {
         let results = [Some(123), None, Some(42), None];
         let ts_vector = TimestampMillisecondVector::from(times.clone());
         let args: Vec<VectorRef> = vec![Arc::new(ts_vector)];
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        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);

src/common/function/src/scalars/uddsketch_calc.rs

@@ -75,7 +75,7 @@ impl Function for UddSketchCalcFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         if columns.len() != 2 {
             return InvalidFuncArgsSnafu {
                 err_msg: format!("uddsketch_calc expects 2 arguments, got {}", columns.len()),
@@ -169,7 +169,7 @@ mod tests {
             Arc::new(BinaryVector::from(vec![Some(serialized.clone()); 3])),
         ];
 
-        let result = function.eval(&FunctionContext::default(), &args).unwrap();
+        let result = function.eval(FunctionContext::default(), &args).unwrap();
         assert_eq!(result.len(), 3);
 
         // Test median (p50)
@@ -192,7 +192,7 @@ mod tests {
 
         // Test with invalid number of arguments
         let args: Vec<VectorRef> = vec![Arc::new(Float64Vector::from_vec(vec![0.95]))];
-        let result = function.eval(&FunctionContext::default(), &args);
+        let result = function.eval(FunctionContext::default(), &args);
         assert!(result.is_err());
         assert!(result
             .unwrap_err()
@@ -204,7 +204,7 @@ mod tests {
             Arc::new(Float64Vector::from_vec(vec![0.95])),
             Arc::new(BinaryVector::from(vec![Some(vec![1, 2, 3])])), // Invalid binary data
         ];
-        let result = function.eval(&FunctionContext::default(), &args).unwrap();
+        let result = function.eval(FunctionContext::default(), &args).unwrap();
         assert_eq!(result.len(), 1);
         assert!(matches!(result.get(0), datatypes::value::Value::Null));
     }

src/common/function/src/scalars/udf.rs

@@ -12,15 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::any::Any;
-use std::fmt::{Debug, Formatter};
 use std::sync::Arc;
 
 use common_query::error::FromScalarValueSnafu;
-use common_query::prelude::ColumnarValue;
-use datafusion::logical_expr::{ScalarFunctionArgs, ScalarUDFImpl};
-use datafusion_expr::ScalarUDF;
-use datatypes::data_type::DataType;
+use common_query::prelude::{
+    ColumnarValue, ReturnTypeFunction, ScalarFunctionImplementation, ScalarUdf,
+};
+use datatypes::error::Error as DataTypeError;
 use datatypes::prelude::*;
 use datatypes::vectors::Helper;
 use session::context::QueryContextRef;
@@ -29,92 +27,58 @@ use snafu::ResultExt;
 use crate::function::{FunctionContext, FunctionRef};
 use crate::state::FunctionState;
 
-struct ScalarUdf {
-    function: FunctionRef,
-    signature: datafusion_expr::Signature,
-    context: FunctionContext,
-}
-
-impl Debug for ScalarUdf {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ScalarUdf")
-            .field("function", &self.function.name())
-            .field("signature", &self.signature)
-            .finish()
-    }
-}
-
-impl ScalarUDFImpl for ScalarUdf {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn name(&self) -> &str {
-        self.function.name()
-    }
-
-    fn signature(&self) -> &datafusion_expr::Signature {
-        &self.signature
-    }
-
-    fn return_type(
-        &self,
-        arg_types: &[datatypes::arrow::datatypes::DataType],
-    ) -> datafusion_common::Result<datatypes::arrow::datatypes::DataType> {
-        let arg_types = arg_types
-            .iter()
-            .map(ConcreteDataType::from_arrow_type)
-            .collect::<Vec<_>>();
-        let t = self.function.return_type(&arg_types)?;
-        Ok(t.as_arrow_type())
-    }
-
-    fn invoke_with_args(
-        &self,
-        args: ScalarFunctionArgs,
-    ) -> datafusion_common::Result<datafusion_expr::ColumnarValue> {
-        let columns = args
-            .args
-            .iter()
-            .map(|x| {
-                ColumnarValue::try_from(x).and_then(|y| match y {
-                    ColumnarValue::Vector(z) => Ok(z),
-                    ColumnarValue::Scalar(z) => Helper::try_from_scalar_value(z, args.number_rows)
-                        .context(FromScalarValueSnafu),
-                })
-            })
-            .collect::<common_query::error::Result<Vec<_>>>()?;
-        let v = self
-            .function
-            .eval(&self.context, &columns)
-            .map(ColumnarValue::Vector)?;
-        Ok(v.into())
-    }
-}
-
 /// Create a ScalarUdf from function, query context and state.
 pub fn create_udf(
     func: FunctionRef,
     query_ctx: QueryContextRef,
     state: Arc<FunctionState>,
-) -> ScalarUDF {
-    let signature = func.signature().into();
-    let udf = ScalarUdf {
-        function: func,
-        signature,
-        context: FunctionContext { query_ctx, state },
-    };
-    ScalarUDF::new_from_impl(udf)
+) -> ScalarUdf {
+    let func_cloned = func.clone();
+    let return_type: ReturnTypeFunction = Arc::new(move |input_types: &[ConcreteDataType]| {
+        Ok(Arc::new(func_cloned.return_type(input_types)?))
+    });
+
+    let func_cloned = func.clone();
+
+    let fun: ScalarFunctionImplementation = Arc::new(move |args: &[ColumnarValue]| {
+        let func_ctx = FunctionContext {
+            query_ctx: query_ctx.clone(),
+            state: state.clone(),
+        };
+
+        let len = args
+            .iter()
+            .fold(Option::<usize>::None, |acc, arg| match arg {
+                ColumnarValue::Scalar(_) => acc,
+                ColumnarValue::Vector(v) => Some(v.len()),
+            });
+
+        let rows = len.unwrap_or(1);
+
+        let args: Result<Vec<_>, DataTypeError> = args
+            .iter()
+            .map(|arg| match arg {
+                ColumnarValue::Scalar(v) => Helper::try_from_scalar_value(v.clone(), rows),
+                ColumnarValue::Vector(v) => Ok(v.clone()),
+            })
+            .collect();
+
+        let result = func_cloned.eval(func_ctx, &args.context(FromScalarValueSnafu)?);
+        let udf_result = result.map(ColumnarValue::Vector)?;
+        Ok(udf_result)
+    });
+
+    ScalarUdf::new(func.name(), &func.signature(), &return_type, &fun)
 }
 
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
 
-    use common_query::prelude::ScalarValue;
-    use datafusion::arrow::array::BooleanArray;
+    use common_query::prelude::{ColumnarValue, ScalarValue};
     use datatypes::data_type::ConcreteDataType;
-    use datatypes::prelude::VectorRef;
+    use datatypes::prelude::{ScalarVector, Vector, VectorRef};
+    use datatypes::value::Value;
     use datatypes::vectors::{BooleanVector, ConstantVector};
     use session::context::QueryContextBuilder;
 
@@ -135,7 +99,7 @@ mod tests {
             Arc::new(BooleanVector::from(vec![true, false, true])),
         ];
 
-        let vector = f.eval(&FunctionContext::default(), &args).unwrap();
+        let vector = f.eval(FunctionContext::default(), &args).unwrap();
         assert_eq!(3, vector.len());
 
         for i in 0..3 {
@@ -145,36 +109,30 @@ mod tests {
         // create a udf and test it again
         let udf = create_udf(f.clone(), query_ctx, Arc::new(FunctionState::default()));
 
-        assert_eq!("test_and", udf.name());
-        let expected_signature: datafusion_expr::Signature = f.signature().into();
-        assert_eq!(udf.signature(), &expected_signature);
+        assert_eq!("test_and", udf.name);
+        assert_eq!(f.signature(), udf.signature);
         assert_eq!(
-            ConcreteDataType::boolean_datatype(),
-            udf.return_type(&[])
-                .map(|x| ConcreteDataType::from_arrow_type(&x))
-                .unwrap()
+            Arc::new(ConcreteDataType::boolean_datatype()),
+            ((udf.return_type)(&[])).unwrap()
         );
 
         let args = vec![
-            datafusion_expr::ColumnarValue::Scalar(ScalarValue::Boolean(Some(true))),
-            datafusion_expr::ColumnarValue::Array(Arc::new(BooleanArray::from(vec![
+            ColumnarValue::Scalar(ScalarValue::Boolean(Some(true))),
+            ColumnarValue::Vector(Arc::new(BooleanVector::from(vec![
                 true, false, false, true,
             ]))),
         ];
 
-        let args = ScalarFunctionArgs {
-            args: &args,
-            number_rows: 4,
-            return_type: &ConcreteDataType::boolean_datatype().as_arrow_type(),
-        };
-        match udf.invoke_with_args(args).unwrap() {
-            datafusion_expr::ColumnarValue::Array(x) => {
-                let x = x.as_any().downcast_ref::<BooleanArray>().unwrap();
-                assert_eq!(x.len(), 4);
-                assert_eq!(
-                    x.iter().flatten().collect::<Vec<bool>>(),
-                    vec![true, false, false, true]
-                );
+        let vec = (udf.fun)(&args).unwrap();
+
+        match vec {
+            ColumnarValue::Vector(vec) => {
+                let vec = vec.as_any().downcast_ref::<BooleanVector>().unwrap();
+
+                assert_eq!(4, vec.len());
+                for i in 0..4 {
+                    assert_eq!(i == 0 || i == 3, vec.get_data(i).unwrap(), "Failed at {i}",)
+                }
             }
             _ => unreachable!(),
         }

src/common/function/src/scalars/vector.rs

@@ -22,7 +22,6 @@ mod scalar_add;
 mod scalar_mul;
 pub(crate) mod sum;
 mod vector_add;
-mod vector_dim;
 mod vector_div;
 mod vector_mul;
 mod vector_norm;
@@ -55,7 +54,6 @@ impl VectorFunction {
         registry.register(Arc::new(vector_mul::VectorMulFunction));
         registry.register(Arc::new(vector_div::VectorDivFunction));
         registry.register(Arc::new(vector_norm::VectorNormFunction));
-        registry.register(Arc::new(vector_dim::VectorDimFunction));
         registry.register(Arc::new(elem_sum::ElemSumFunction));
         registry.register(Arc::new(elem_product::ElemProductFunction));
     }

src/common/function/src/scalars/vector/convert/parse_vector.rs

@@ -45,7 +45,7 @@ impl Function for ParseVectorFunction {
         )
     }
 
-    fn eval(&self, _func_ctx: &FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
+    fn eval(&self, _func_ctx: FunctionContext, columns: &[VectorRef]) -> Result<VectorRef> {
         ensure!(
             columns.len() == 1,
             InvalidFuncArgsSnafu {
@@ -101,7 +101,7 @@ mod tests {
             None,
         ]));
 
-        let result = func.eval(&FunctionContext::default(), &[input]).unwrap();
+        let result = func.eval(FunctionContext::default(), &[input]).unwrap();
 
         let result = result.as_ref();
         assert_eq!(result.len(), 3);
@@ -136,7 +136,7 @@ mod tests {
             Some("[7.0,8.0,9.0".to_string()),
         ]));
 
-        let result = func.eval(&FunctionContext::default(), &[input]);
+        let result = func.eval(FunctionContext::default(), &[input]);
         assert!(result.is_err());
 
         let input = Arc::new(StringVector::from(vec![
@@ -145,7 +145,7 @@ mod tests {
             Some("7.0,8.0,9.0]".to_string()),
         ]));
 
-        let result = func.eval(&FunctionContext::default(), &[input]);
+        let result = func.eval(FunctionContext::default(), &[input]);
         assert!(result.is_err());
 
         let input = Arc::new(StringVector::from(vec![
@@ -154,7 +154,7 @@ mod tests {
             Some("[7.0,hello,9.0]".to_string()),
         ]));
 
-        let result = func.eval(&FunctionContext::default(), &[input]);
+        let result = func.eval(FunctionContext::default(), &[input]);
         assert!(result.is_err());
     }
 }