diff --git a/.cargo/config.toml b/.cargo/config.toml
index fd372c95b84..8291bf467e4 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -21,5 +21,6 @@ checkout = true
 list_files = true
 internal_use_git2 = false
 
-[env]
-CARGO_WORKSPACE_DIR = { value = "", relative = true }
+# Avoid globally injecting a checkout-specific workspace path. The version build script
+# resolves the absolute workspace path from layout at build time; set CARGO_WORKSPACE_DIR
+# explicitly when this repo is built as a submodule.
diff --git a/.github/actions/start-runner/action.yml b/.github/actions/start-runner/action.yml
index 78568e26d76..44a5ff3feb3 100644
--- a/.github/actions/start-runner/action.yml
+++ b/.github/actions/start-runner/action.yml
@@ -56,7 +56,7 @@ runs:
 
     - name: Start EC2 runner
       if: startsWith(inputs.runner, 'ec2')
-      uses: machulav/ec2-github-runner@v2.3.8
+      uses: machulav/ec2-github-runner@v2.6.1
       id: start-linux-arm64-ec2-runner
       with:
         mode: start
diff --git a/.github/actions/stop-runner/action.yml b/.github/actions/stop-runner/action.yml
index e25a1d8dad7..fb84f2b7181 100644
--- a/.github/actions/stop-runner/action.yml
+++ b/.github/actions/stop-runner/action.yml
@@ -33,7 +33,7 @@ runs:
 
     - name: Stop EC2 runner
       if: ${{ inputs.label && inputs.ec2-instance-id }}
-      uses: machulav/ec2-github-runner@v2.3.8
+      uses: machulav/ec2-github-runner@v2.6.1
       with:
         mode: stop
         label: ${{ inputs.label }}
diff --git a/.github/scripts/agent-observability-summary.py b/.github/scripts/agent-observability-summary.py
index 38ba4e9dbdd..33ba3ad7e6e 100644
--- a/.github/scripts/agent-observability-summary.py
+++ b/.github/scripts/agent-observability-summary.py
@@ -18,6 +18,8 @@ import json
 import math
 from pathlib import Path
 
+from benchmark_resource_summary import render_resources
+
 TARGETS = ('greptimedb', 'clickhouse', 'victorialogs')
 
 
@@ -201,6 +203,7 @@ def lifecycle(root, targets):
             rows.append([context, entry.get('phase'), duration(entry.get('elapsed_ms')) if valid else
                          'invalid timestamp units (legacy artifact)', entry.get('exit_code')])
     lines += ['## Phase timings', '', 'Phase duration includes orchestration overhead. Container cleanup does not prove ECS teardown.', '', table(['DB / scope', 'Phase', 'Duration', 'Exit code'], rows), '']
+    lines.append(render_resources([('dataset', root)] + [(t, root / f'{t}-1') for t in targets], table))
     return '\n'.join(lines)
 
 
diff --git a/.github/scripts/benchmark-version-comparison.py b/.github/scripts/benchmark-version-comparison.py
new file mode 100644
index 00000000000..1aa744df9ad
--- /dev/null
+++ b/.github/scripts/benchmark-version-comparison.py
@@ -0,0 +1,191 @@
+# 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.
+
+"""Compare validated GreptimeDB query results; never gate CI on noisy latency deltas."""
+import argparse
+import html
+import json
+import math
+import os
+from pathlib import Path
+import re
+import statistics
+
+
+def read(path):
+    return json.loads(path.read_text()) if path.is_file() else {}
+
+
+def validate(env):
+    enabled = env.get('COMPARE_GREPTIMEDB', 'false')
+    if enabled not in ('true', 'false'):
+        raise ValueError('COMPARE_GREPTIMEDB must be true or false')
+    if enabled == 'false':
+        return
+    if env.get('RUN_GREPTIMEDB') != 'true':
+        raise ValueError('Version comparison requires Run GreptimeDB')
+    for key in ('BASELINE_GREPTIMEDB_TAG', 'GREPTIMEDB_TAG'):
+        if not re.fullmatch(r'[a-zA-Z0-9_][a-zA-Z0-9_.-]{0,127}(@sha256:[0-9a-f]{64})?', env.get(key, '')):
+            raise ValueError(f'Invalid {key}')
+    if env['BASELINE_GREPTIMEDB_TAG'] == env['GREPTIMEDB_TAG']:
+        raise ValueError('Baseline and candidate must have different image tags')
+
+
+def same(a, b, fields):
+    return all(a.get(k) is not None and a.get(k) == b.get(k) for k in fields)
+
+
+def finite(value):
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value) and value >= 0
+
+
+def improvement(old, new, throughput=False):
+    if not finite(old) or not finite(new) or old <= 0:
+        return None
+    return (new / old - 1 if throughput else 1 - new / old) * 100
+
+
+def row(query, metric, old, new, compatible, reason):
+    delta = improvement(old, new, metric == 'QPS') if compatible else None
+    return dict(query=query, metric=metric, baseline=old, candidate=new,
+                improvement_percent=delta, status='comparable' if delta is not None else reason)
+
+
+def agent(root):
+    def load(r):
+        return read(r / 'greptimedb-1/greptimedb-1/measured-summary.json')
+    a, b = load(root / 'baseline'), load(root)
+    finished = [r / 'greptimedb-1/exit-code.txt' for r in (root / 'baseline', root)]
+    compatible = (all(p.is_file() and p.read_text().strip() == '0' for p in finished)
+                  and a.get('passed') is True and b.get('passed') is True
+                  and same(a, b, ('contract_sha256', 'data_profile', 'query_window', 'warmup_runs', 'measured_runs')))
+    qa, qb = ({q['query_id']: q for q in x.get('per_query', [])} for x in (a, b))
+    rows = []
+    for q in sorted(qa.keys() | qb.keys()):
+        old, new = qa.get(q, {}), qb.get(q, {})
+        ok = compatible and same(old, new, ('result_fingerprint', 'success')) and old.get('success', 0) > 0
+        ok = ok and all(v.get('errors') == 0 and v.get('timeouts') == 0 for v in (old, new))
+        for key in ('p50_ms', 'p95_ms', 'p99_ms'):
+            rows.append(row(q, key, old.get(key), new.get(key), ok, 'failed, missing or incompatible result'))
+    return rows
+
+
+def traces(root):
+    a, b = (read(r / 'runs/greptimedb/run.json') for r in (root / 'baseline', root))
+    compatible = (a.get('success') is True and b.get('success') is True
+                  and same(a, b, ('expected', 'protocol', 'audit_expected', 'corpus'))
+                  and same(a.get('execution', {}), b.get('execution', {}),
+                           ('db_cpus', 'db_memory', 'load_workers_requested', 'max_in_flight')))
+    rows = []
+    for q in (f'T{i:02}' for i in range(1, 9)):
+        values, identities, counts = [], [], []
+        ok = compatible
+        for run in (a, b):
+            correctness = [s for s in run.get('correctness', []) if s.get('query_id') == q]
+            all_samples = [s for s in run.get('samples', []) if s.get('query_id') == q]
+            measured = [s for s in all_samples if s.get('phase') == 'measured']
+            passed = bool(correctness and measured) and all(s.get('outcome') == 'passed' for s in correctness + all_samples)
+            expected = run.get('expected', {}).get('contracts', {}).get(q, {})
+            passed = passed and all(s.get('fingerprint') == expected.get('fingerprint') and s.get('fingerprint') is not None
+                                    and s.get('row_count') == expected.get('row_count') for s in correctness + all_samples)
+            elapsed = [s.get('elapsed_ms') for s in measured]
+            passed = passed and all(finite(v) for v in elapsed)
+            ok = ok and passed
+            values.append(statistics.median(elapsed) if passed else None)
+            identities.append(expected)
+            counts.append((len(correctness), len(all_samples), len(measured)))
+        ok = ok and identities[0] == identities[1] and counts[0] == counts[1]
+        rows.append(row(q, 'median_ms', *values, ok, 'failed, skipped, missing or incompatible result'))
+    return rows
+
+
+def long_range(root):
+    rows = []
+    manifest = read(root / 'run-manifest.json')
+    healthy = all(
+        all(field in (manifest.get(phase, {}).get(target, {}).get('docker', {}) if phase == 'post_load_results'
+                      else manifest.get(phase, {}).get(target, {})).get('state', '').split()
+            for field in ('Running=true', 'ExitCode=0', 'OOMKilled=false'))
+        for phase in ('post_load_results', 'post_query_results')
+        for target in ('greptimedb-baseline', 'greptimedb'))
+    for mode in ('serial', 'concurrent-duration-c1', 'concurrent-duration-c4'):
+        a, b = (read(root / name / 'results-vmbench-long-range' / (mode + '-summary.json'))
+                for name in ('greptimedb-baseline', 'greptimedb'))
+        fields = ('workload', 'query_file_sha256', 'start', 'end', 'step', 'profile', 'data_duration',
+                  'scrape_interval', 'cache_policy_effective', 'mode', 'connection_mode', 'request_timeout_seconds')
+        fields += ('tries', 'warmup_runs') if mode == 'serial' else ('concurrency', 'duration_seconds', 'warmup_seconds')
+        compatible = healthy and same(a, b, fields) and all(x.get('errors') == 0 and x.get('timeouts') == 0 for x in (a, b))
+        qa, qb = ({q['query_index']: q for q in x.get('per_query', [])} for x in (a, b))
+        for q in sorted(qa.keys() | qb.keys()):
+            old, new = qa.get(q, {}), qb.get(q, {})
+            ok = compatible and same(old, new, ('query', 'series', 'points'))
+            ok = ok and all(v.get('success', 0) > 0 and v.get('series', 0) > 0 and v.get('points', 0) > 0
+                            and v.get('errors') == 0 and v.get('timeouts') == 0 for v in (old, new))
+            for key in ('p50_ms', 'qps') if mode != 'serial' else ('p50_ms',):
+                rows.append(row(f'{mode}/Q{q}', 'QPS' if key == 'qps' else key,
+                                old.get(key), new.get(key), ok, 'failed, missing or incompatible result'))
+    return rows
+
+
+def render(document):
+    def cell(value):
+        return html.escape(str(value)).replace('|', '&#124;').replace('\n', ' ')
+    def value(v, metric):
+        if not finite(v):
+            return '—'
+        if metric == 'QPS':
+            return f'{v:.3f}'
+        return f'{v / 1000:.2f} s' if v >= 1000 else f'{v:.2f} ms'
+    lines = ['# GreptimeDB version comparison', '',
+             f'Baseline: `{cell(document["baseline_tag"])}` → candidate: `{cell(document["candidate_tag"])}`.', '',
+             'Same-host sequential runs with fresh databases and shared input data. Positive = improvement; '
+             'latency: (baseline − candidate) / baseline; QPS: (candidate − baseline) / baseline. '
+             'Single runs are diagnostic, not a statistically established regression. No performance threshold gates CI.', '',
+             '| Query | Metric | Baseline | Candidate | Improvement | Status |',
+             '| --- | --- | --- | --- | --- | --- |']
+    for r in document['rows']:
+        delta = r['improvement_percent']
+        lines.append('| ' + ' | '.join(map(cell, [r['query'], r['metric'], value(r['baseline'], r['metric']),
+                     value(r['candidate'], r['metric']), f'{delta:+.1f}%' if delta is not None else '—', r['status']])) + ' |')
+    if document.get('kind') == 'long-range':
+        lines += ['', 'Long-range retains the existing non-empty series/point-count checks; these do not establish equality of every returned value.']
+    if not document['rows']:
+        lines += ['', 'Results unavailable; comparison not performed.']
+    return '\n'.join(lines) + '\n'
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('command', choices=('validate', 'report'))
+    parser.add_argument('--kind', choices=('agent', 'traces', 'long-range'))
+    parser.add_argument('--root', type=Path)
+    args = parser.parse_args()
+    if args.command == 'validate':
+        validate(os.environ)
+        return
+    if args.root is None or args.kind is None:
+        parser.error('report requires --root and --kind')
+    document = {'kind': args.kind, 'baseline_tag': os.environ.get('BASELINE_GREPTIMEDB_TAG', ''),
+                'candidate_tag': os.environ.get('GREPTIMEDB_TAG', ''),
+                'rows': {'agent': agent, 'traces': traces, 'long-range': long_range}[args.kind](args.root)}
+    text = render(document)
+    # Preserve partial comparisons even if a target failed before creating output.
+    args.root.mkdir(parents=True, exist_ok=True)
+    (args.root / 'version-comparison.json').write_text(json.dumps(document, indent=2, allow_nan=False) + '\n')
+    (args.root / 'version-comparison.md').write_text(text)
+    print(text, end='')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/.github/scripts/benchmark_resource_summary.py b/.github/scripts/benchmark_resource_summary.py
new file mode 100644
index 00000000000..3a0a896c46e
--- /dev/null
+++ b/.github/scripts/benchmark_resource_summary.py
@@ -0,0 +1,99 @@
+# 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.
+
+"""Render shared O11yBench sampled resource artifacts for lifecycle summaries."""
+import json
+import math
+
+
+def number(value):
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value) and value >= 0
+
+
+def metric(values, key, statistic):
+    entry = values.get(key, {})
+    value = entry.get(statistic)
+    return value if number(entry.get('samples')) and entry['samples'] > 0 and number(value) else None
+
+
+def decimal(value, suffix=''):
+    return f'{value:.2f}{suffix}' if number(value) else '—'
+
+
+def memory(value):
+    if not number(value):
+        return '—'
+    for unit in ('B', 'KiB', 'MiB', 'GiB', 'TiB'):
+        if value < 1024 or unit == 'TiB':
+            return decimal(value, f' {unit}')
+        value /= 1024
+
+
+def capacities(path):
+    # Quotas are metadata, not recomputed CPU statistics. Bound reads on long runs.
+    result = {}
+    try:
+        with path.open() as source:
+            for index, line in enumerate(source):
+                if index == 256:
+                    break
+                record = json.loads(line)
+                cores = record.get('host', {}).get('cpu_count')
+                if number(cores) and cores > 0:
+                    result.setdefault('host', cores)
+                for role, values in record.get('containers', {}).items():
+                    quota = values.get('configured_cpu_limit_cores')
+                    if number(quota):
+                        result.setdefault(role, quota)
+                if all(role in result for role in ('host', 'runtime', 'db')):
+                    break
+    except (OSError, ValueError, TypeError, AttributeError):
+        pass
+    return result
+
+
+def render_resources(scopes, table):
+    rows = []
+    for scope, directory in scopes:
+        try:
+            summary = json.loads((directory / 'resources.summary.json').read_text())
+            phases = summary.get('phases', {}) if summary.get('schema') == 'o11ybench-resources-v1' else {}
+        except (OSError, ValueError, TypeError, AttributeError):
+            phases = {}
+        if not isinstance(phases, dict) or not phases:
+            rows.append([scope, 'unavailable', *['—'] * 9])
+            continue
+        limits = capacities(directory / 'resources.jsonl')
+        for phase, data in phases.items():
+            for role in ('host', 'runtime', 'db'):
+                values = data.get('host', {}) if role == 'host' else data.get('containers', {}).get(role, {})
+                if role == 'db' and scope == 'dataset':
+                    continue
+                quota = limits.get(role)
+                cpu_samples = values.get('cpu_used_cores', {}).get('samples')
+                rows.append([scope, phase, role, cpu_samples,
+                             decimal(metric(values, 'cpu_used_cores', 'mean')),
+                             decimal(metric(values, 'cpu_used_cores', 'max')),
+                             'unlimited' if quota == 0 else decimal(quota),
+                             memory(metric(values, 'memory_used_bytes' if role == 'host' else 'memory_usage_bytes', 'max')),
+                             decimal(metric(values, 'io_wait_percent', 'mean'), '%'),
+                             decimal(metric(values, 'io_wait_percent', 'max'), '%'),
+                             memory(metric(values, 'swap_used_bytes', 'max'))])
+    return '\n'.join(['## Sampled resources', '',
+                      'CPU is measured in cores. Mean/max summarize available samples, not continuous peaks; '
+                      'short phases may have no CPU sample. CPU capacity is host cores or the configured container quota. '
+                      'Host memory is total minus available; Docker memory excludes cache where supported. '
+                      'Swap is host-wide usage, not swap activity. Missing evidence stays —.', '',
+                      table(['Scope', 'Phase', 'Component', 'CPU samples', 'Mean CPU cores', 'Max CPU cores',
+                             'CPU capacity', 'Max memory', 'Mean I/O wait', 'Max I/O wait', 'Max swap'], rows), ''])
diff --git a/.github/scripts/check-nightly-release.sh b/.github/scripts/check-nightly-release.sh
new file mode 100755
index 00000000000..82eb910d6fd
--- /dev/null
+++ b/.github/scripts/check-nightly-release.sh
@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+# Returns whether the current release run should proceed, 'true' or 'false'.
+#
+# The nightly schedule runs every weekday, but a scheduled release only proceeds
+# when the latest published nightly release is older than
+# NIGHTLY_RELEASE_MAX_AGE_DAYS days. This way, a failed nightly run is retried
+# by the next weekday schedule, instead of leaving a whole week without nightly
+# builds. Non-scheduled runs (tag pushes and manual dispatches) always proceed.
+#
+# Only the result is written to stdout, so that it can be used in GitHub Actions
+# outputs; all diagnostics go to stderr.
+#
+# You can run as following examples:
+#   GITHUB_EVENT_NAME=push ./check-nightly-release.sh
+#   GITHUB_EVENT_NAME=schedule GITHUB_REPOSITORY=GreptimeTeam/greptimedb GH_TOKEN=ghp_xxx ./check-nightly-release.sh
+#   GITHUB_EVENT_NAME=schedule NIGHTLY_RELEASE_MAX_AGE_DAYS=5 GITHUB_REPOSITORY=GreptimeTeam/greptimedb GH_TOKEN=ghp_xxx ./check-nightly-release.sh
+if [ -z "$GITHUB_EVENT_NAME" ]; then
+    echo "GITHUB_EVENT_NAME is empty" >&2
+    exit 1
+fi
+
+if [ "$GITHUB_EVENT_NAME" != "schedule" ]; then
+    echo "Not a scheduled run, the nightly check is skipped." >&2
+    echo "true"
+    exit 0
+fi
+
+MAX_AGE_DAYS="${NIGHTLY_RELEASE_MAX_AGE_DAYS:-5}"
+if ! [[ "$MAX_AGE_DAYS" =~ ^[0-9]+$ ]]; then
+    echo "Invalid NIGHTLY_RELEASE_MAX_AGE_DAYS: ${MAX_AGE_DAYS}" >&2
+    exit 1
+fi
+
+SECONDS_PER_DAY=86400
+
+# The publish time of the latest published nightly release, like the tag
+# 'v0.2.0-nightly-20230313'. Fail open on GitHub API errors: proceeding with
+# the release is safer than skipping it.
+if ! latest_nightly_published_at="$(gh api "repos/${GITHUB_REPOSITORY}/releases?per_page=100" \
+    --jq '[.[] | select(.draft == false and (.tag_name | contains("nightly")))][0].published_at // empty')"; then
+    echo "::warning::Failed to query the latest nightly release from the GitHub API, will proceed with the nightly release." >&2
+    echo "true"
+    exit 0
+fi
+
+if [ -z "$latest_nightly_published_at" ]; then
+    echo "No published nightly release found, will proceed with the nightly release." >&2
+    echo "true"
+    exit 0
+fi
+
+published_at_epoch="$(date --date="$latest_nightly_published_at" +%s)"
+now_epoch="$(date +%s)"
+age_seconds=$(( now_epoch - published_at_epoch ))
+age_days=$(( age_seconds / SECONDS_PER_DAY ))
+
+echo "The latest nightly release was published at ${latest_nightly_published_at} (${age_days} days ago)." >&2
+
+if [ "$age_seconds" -gt $(( MAX_AGE_DAYS * SECONDS_PER_DAY )) ]; then
+    echo "The latest nightly release is older than ${MAX_AGE_DAYS} days, will proceed with the nightly release." >&2
+    echo "true"
+else
+    echo "The latest nightly release is not older than ${MAX_AGE_DAYS} days, will skip the nightly release." >&2
+    echo "false"
+fi
diff --git a/.github/scripts/oswal-s3-bench-run.sh b/.github/scripts/oswal-s3-bench-run.sh
new file mode 100644
index 00000000000..a9835c1e5f1
--- /dev/null
+++ b/.github/scripts/oswal-s3-bench-run.sh
@@ -0,0 +1,179 @@
+#!/usr/bin/env bash
+# Host side of oswal-s3-bench.yml: one subcommand per step; each cell of $PLAN gets a fresh GreptimeDB.
+set -euo pipefail
+
+here=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+
+# Same isolation as the o11ybench runtime's own docker run.
+runtime() {
+    docker run --rm --user "$(id -u):$(id -g)" --label "o11ybench.owner=$OWNER" \
+        --security-opt no-new-privileges --cap-drop ALL "$@"
+}
+
+check_runtime() {
+    local image=$1 resolved
+    [[ "$image" == public.ecr.aws/* ]] || { echo 'The runtime image must come from AWS ECR Public' >&2; return 1; }
+    bash "$here/pull-benchmark-image.sh" "$image"
+    resolved=$(docker image inspect "$image" | jq -er '.[0].RepoDigests[0]')
+    docker run --rm --entrypoint sh "$resolved" -c \
+        'test -f scripts/agent-observability/greptimedb.sh && test -f scripts/generate_agent_observations.py' \
+        || { echo 'The runtime image lacks the agent observability loader or generator' >&2; return 1; }
+    printf 'runtime_image=%s\n' "$resolved" >> "${GITHUB_OUTPUT:-/dev/stdout}"
+}
+
+pull_images() {
+    : "${RESULTS:?}" "${RUNTIME_IMAGE:?}" "${GREPTIMEDB_TAG:?}"
+    mkdir -p "$RESULTS/images"
+    bash "$here/pull-benchmark-image.sh" "$RUNTIME_IMAGE"
+    bash "$here/pull-benchmark-image.sh" "greptime/greptimedb:$GREPTIMEDB_TAG"
+    docker image inspect "$RUNTIME_IMAGE" > "$RESULTS/images/runtime.json"
+    docker image inspect "greptime/greptimedb:$GREPTIMEDB_TAG" > "$RESULTS/images/greptimedb.json"
+}
+
+wal_disk() {
+    : "${RESULTS:?}"
+    local root=$1 device
+    device=$(lsblk -dnpo NAME,MODEL | awk '/Instance Storage/ {print $1; exit}')
+    # Only a smoke run may keep the Raft Engine WAL on the root volume.
+    [[ -n "$device" || "${SMOKE:-}" == true ]] || { echo 'No local NVMe instance store; choose an instance type with one' >&2; return 1; }
+    sudo -n mkdir -p "$root"
+    if [[ -n "$device" ]]; then
+        sudo -n umount "$device" 2>/dev/null || true
+        sudo -n mkfs.ext4 -q -F "$device"
+        sudo -n mount -o noatime "$device" "$root"
+    fi
+    sudo -n chown "$(id -u):$(id -g)" "$root"
+    findmnt -no SOURCE,FSTYPE -T "$root" | tee "$RESULTS/wal-disk.txt"
+}
+
+generate() {
+    : "${PLAN:?}" "${RESULTS:?}" "${CORPUS_DIR:?}" "${OWNER:?}" "${RUNTIME_IMAGE:?}"
+    local args=() arg
+    while IFS= read -r arg; do args+=("$arg"); done < <(jq -r '.generator_args[]' "$PLAN")
+    mkdir -p "$CORPUS_DIR"
+    runtime --name "$OWNER-generator" --mount "type=bind,src=$CORPUS_DIR,dst=/work/corpus" \
+        "$RUNTIME_IMAGE" scripts/generate_agent_observations.py "${args[@]}" \
+        --output /work/corpus/agent_observations.jsonl \
+        --summary-output /work/corpus/summary.json --evidence-output /work/corpus/evidence.json \
+        > "$RESULTS/generator.log" 2>&1
+    jq -e --argjson rows "$(jq .rows "$PLAN")" '.line_count == $rows' "$CORPUS_DIR/summary.json" >/dev/null
+}
+
+# Scrape once, after the load succeeded or failed, while the server still runs.
+scrape_metrics() {
+    curl --noproxy '*' -fsS --max-time 30 http://127.0.0.1:4000/metrics > "$dir/metrics.all" || { rm -f "$dir/metrics.all"; return 1; }
+    grep -E '^(# (HELP|TYPE) )?greptime_logstore_object_store_wal_' "$dir/metrics.all" > "$dir/metrics.prom" || true
+    rm -f "$dir/metrics.all"
+    metrics_scraped=true
+}
+
+finish() {
+    local rc=$?
+    trap - EXIT
+    set +e
+    if [[ -n "$cid" ]]; then
+        # A load that succeeded without its metrics is not a measurement.
+        scrape_metrics || { echo "$id: metrics scrape failed" >&2; [[ $rc != 0 ]] || rc=4; }
+        docker stop -t 120 "$cid" >/dev/null
+        docker logs "$cid" > "$dir/server.log" 2>&1
+        docker rm -fv "$cid" >/dev/null
+    fi
+    [[ -z "$wal_dir" ]] || sudo -n rm -rf "$wal_dir"
+    jq -n --argjson spec "$spec" --arg device "$wal_device" --arg version "$version" \
+        --arg load_seconds "$load_seconds" --argjson exit_code "$rc" --argjson scraped "$metrics_scraped" \
+        '$spec + {wal_device: $device, version: $version, exit_code: $exit_code, metrics_scraped: $scraped,
+          load_wall_seconds: ($load_seconds | tonumber? // null)}' > "$dir/cell.json"
+    exit "$rc"
+}
+
+# One cell in its own process, so errexit holds inside it. The cell's state is
+# global because the EXIT trap runs after this function returns.
+cell() {
+    : "${PLAN:?}" "${RESULTS:?}" "${CORPUS_DIR:?}" "${OWNER:?}" "${RUNTIME_IMAGE:?}" "${GREPTIMEDB_IMAGE:?}"
+    : "${RUN_PREFIX:?}" "${WAL_ROOT:?}" "${S3_BUCKET:?}" "${S3_REGION:?}" "${AWS_ACCESS_KEY_ID:?}" "${AWS_SECRET_ACCESS_KEY:?}"
+    spec=$1 cid= wal_dir= version= load_seconds= metrics_scraped=false id=
+    local concurrency name setting started ended
+    id=$(jq -r .id <<< "$spec"); concurrency=$(jq -r .concurrency <<< "$spec")
+    dir="$RESULTS/cells/$id"; name="$OWNER-$id"
+    mkdir -p "$dir"
+    # The root holds data/ and the WAL's default prefix wal/ side by side.
+    local settings=(STORAGE__TYPE=S3 "STORAGE__BUCKET=$S3_BUCKET" "STORAGE__REGION=$S3_REGION"
+        "STORAGE__ROOT=$RUN_PREFIX/$id")
+    [[ -z "${S3_CONTAINER_ENDPOINT:-}" ]] || settings+=("STORAGE__ENDPOINT=$S3_CONTAINER_ENDPOINT")
+    while IFS= read -r setting; do settings+=("$setting"); done \
+        < <(jq -r '.wal | to_entries[] | "WAL__\(.key)=\(.value)"' <<< "$spec")
+    local docker_env=() mounts=()
+    for setting in "${settings[@]}"; do
+        docker_env+=(-e "GREPTIMEDB_STANDALONE__$setting")
+        printf 'GREPTIMEDB_STANDALONE__%s\n' "$setting" >> "$dir/config.env"
+    done
+    # Pass the two keys by name: their values never reach argv, a file or the artifact.
+    export GREPTIMEDB_STANDALONE__STORAGE__ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID
+    export GREPTIMEDB_STANDALONE__STORAGE__SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY
+    docker_env+=(-e GREPTIMEDB_STANDALONE__STORAGE__ACCESS_KEY_ID -e GREPTIMEDB_STANDALONE__STORAGE__SECRET_ACCESS_KEY)
+    printf 'GREPTIMEDB_STANDALONE__STORAGE__%s=<redacted>\n' ACCESS_KEY_ID SECRET_ACCESS_KEY >> "$dir/config.env"
+    if jq -e '.wal.DIR' <<< "$spec" >/dev/null; then
+        wal_dir="$WAL_ROOT/$id"; mkdir -p "$wal_dir"
+        mounts=(--mount "type=bind,src=$wal_dir,dst=$(jq -r .wal.DIR <<< "$spec")")
+        wal_device=$(findmnt -no SOURCE -T "$wal_dir")
+    else
+        wal_device="s3://$S3_BUCKET/$RUN_PREFIX/$id/wal"
+    fi
+    trap finish EXIT
+    cid=$(docker run -d --init --name "$name" --label "o11ybench.owner=$OWNER" \
+        --add-host host.docker.internal:host-gateway \
+        -p 127.0.0.1:4000:4000 -p 127.0.0.1:4001:4001 "${docker_env[@]}" ${mounts[@]+"${mounts[@]}"} \
+        "$GREPTIMEDB_IMAGE" standalone start --http-addr=0.0.0.0:4000 --grpc-bind-addr=0.0.0.0:4001)
+    local deadline=$((SECONDS + 300))
+    until curl --noproxy '*' -fsS --max-time 5 http://127.0.0.1:4000/health >/dev/null 2>&1; do
+        [[ $(docker inspect --format '{{.State.Running}}' "$cid") == true ]] || { echo "$id: server exited" >&2; exit 1; }
+        ((SECONDS < deadline)) || { echo "$id: server not healthy in 300s" >&2; exit 1; }
+        sleep 2
+    done
+    version=$(docker exec "$cid" greptime --version | sed -n 's/^version: //p')
+    [[ -n "$version" ]]
+    started=$(date +%s.%N)
+    # Only the load phase, run exactly as run-agent-observability.sh runs it.
+    runtime --name "$name-load" --network host \
+        --mount "type=bind,src=$CORPUS_DIR,dst=/work/corpus,readonly" --mount "type=bind,src=$dir,dst=/results" \
+        -e GRPC_ENDPOINT=127.0.0.1:4001 -e "DATA_PROFILE=$(jq -r .data_profile "$PLAN")" -e RESULT_NAME=greptimedb-1 \
+        -e "ENDPOINT=http://127.0.0.1:4000/v1/sql?db=public&format=greptimedb_v1" \
+        -e "TARGET_IMAGE=$GREPTIMEDB_IMAGE" -e "TARGET_VERSION=$version" -e "TARGET_DIGEST=${GREPTIMEDB_IMAGE##*@}" \
+        -e "TARGET_ID=$name" -e TARGET_HOST=127.0.0.1 -e PREPARE_WORKERS= -e "MAX_IN_FLIGHT=$concurrency" \
+        -e "GREPTIMEDB_BATCH_SIZE=$(jq -r .batch_rows "$PLAN")" --entrypoint /bin/bash \
+        "$RUNTIME_IMAGE" scripts/agent-observability/greptimedb.sh load > "$dir/load.log" 2>&1
+    ended=$(date +%s.%N)
+    load_seconds=$(awk -v a="$started" -v b="$ended" 'BEGIN {printf "%.3f", b - a}')
+    jq -e --argjson rows "$(jq .rows "$PLAN")" '.count_before == 0 and .count_after == $rows' \
+        "$dir/greptimedb-1/load-result.json" >/dev/null
+}
+
+scrub() {
+    : "${RESULTS:?}"
+    [[ -n "${AWS_ACCESS_KEY_ID:-}" && -n "${AWS_SECRET_ACCESS_KEY:-}" && -d "$RESULTS" ]] || return 0
+    if grep -rqF -e "$AWS_ACCESS_KEY_ID" -e "$AWS_SECRET_ACCESS_KEY" "$RESULTS"; then
+        echo '::error::A credential value appears in the results; removing them instead of uploading' >&2
+        rm -rf "$RESULTS"
+        return 1
+    fi
+}
+
+case "${1:-}" in
+    check-runtime) check_runtime "${2:?}" ;;
+    pull) pull_images ;;
+    wal-disk) wal_disk "${2:?}" ;;
+    generate) generate ;;
+    cell) cell "${2:?}" ;;
+    cells)
+        : "${PLAN:?}"
+        failed=0
+        while IFS= read -r spec; do
+            id=$(jq -r .id <<< "$spec")
+            echo "::group::cell $id"
+            bash "${BASH_SOURCE[0]}" cell "$spec" < /dev/null || { echo "::error::cell $id failed"; failed=1; }
+            echo '::endgroup::'
+        done < <(jq -c '.cells[]' "$PLAN")
+        exit "$failed" ;;
+    scrub) scrub ;;
+    *) echo "usage: $0 check-runtime IMAGE | pull | wal-disk DIR | generate | cells | scrub" >&2; exit 2 ;;
+esac
diff --git a/.github/scripts/oswal-s3-bench-summary.py b/.github/scripts/oswal-s3-bench-summary.py
new file mode 100644
index 00000000000..67186d422da
--- /dev/null
+++ b/.github/scripts/oswal-s3-bench-summary.py
@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+# 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.
+
+"""Summarize the object store WAL S3 benchmark as Markdown and summary.json."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+from pathlib import Path
+
+PREFIX = "greptime_logstore_object_store_wal_"
+COUNTERS = ("created_objects_total", "stalled_appends_total", "poisoned_total",
+            "create_failures_total", "create_conflicts_total")
+SAMPLE = re.compile(r'([a-zA-Z_:][a-zA-Z0-9_:]*)(?:\{([^}]*)\})?\s+(\S+)')
+
+
+def parse_metrics(text: str) -> dict:
+    """Map each unlabeled sample to its value and each histogram to its buckets."""
+    samples, buckets = {}, {}
+    for line in text.splitlines():
+        match = SAMPLE.fullmatch(line.strip())
+        if not match or not match.group(1).startswith(PREFIX):
+            continue
+        name, labels, value = match.group(1)[len(PREFIX):], match.group(2) or "", float(match.group(3))
+        le = re.search(r'le="([^"]+)"', labels)
+        if name.endswith("_bucket") and le:
+            buckets.setdefault(name[:-len("_bucket")], []).append((float(le.group(1)), value))
+        else:
+            samples[name] = value
+    return {"samples": samples, "buckets": {name: sorted(items) for name, items in buckets.items()}}
+
+
+def quantile(q: float, buckets: list) -> float | None:
+    """Prometheus histogram_quantile over cumulative (upper bound, count) buckets."""
+    if not buckets or buckets[-1][1] == 0:
+        return None
+    rank = q * buckets[-1][1]
+    lower, below = 0.0, 0.0
+    for upper, count in buckets:
+        if count >= rank:
+            if math.isinf(upper):
+                return lower
+            return lower + (upper - lower) * (rank - below) / (count - below) if count > below else upper
+        lower, below = upper, count
+    return lower
+
+
+def geomean(values: list) -> float | None:
+    return math.exp(sum(map(math.log, values)) / len(values)) if values and all(v > 0 for v in values) else None
+
+
+def load_cell(path: Path, spec: dict | None = None) -> dict:
+    """One cell's row; a planned cell that never recorded a result has no values, so no ratio uses its round."""
+    recorded = path / "cell.json"
+    cell = json.loads(recorded.read_text()) if recorded.exists() else spec | {"exit_code": None, "missing": True}
+    result_path = path / "greptimedb-1" / "load-result.json"
+    result = json.loads(result_path.read_text()) if result_path.exists() else {}
+    metrics_path = path / "metrics.prom"
+    metrics = parse_metrics(metrics_path.read_text() if metrics_path.exists() else "")
+    ack = metrics["buckets"].get("append_ack_seconds", [])
+    load_seconds = result.get("load_seconds")
+    row = {
+        "id": cell["id"], "round": cell["round"], "concurrency": cell["concurrency"],
+        "config": cell["config"], "exit_code": cell["exit_code"], "wal_device": cell.get("wal_device"),
+        "missing": cell.get("missing", False),
+        "version": cell.get("version"), "load_wall_seconds": cell.get("load_wall_seconds"),
+        "rows": result.get("count_after"), "load_seconds": load_seconds,
+        "rows_per_second": result.get("rows_per_second") if cell["exit_code"] == 0 else None,
+        "append_ack_p50_seconds": quantile(0.5, ack), "append_ack_p99_seconds": quantile(0.99, ack),
+    }
+    # The counters register on their first event, so a scrape of an object store WAL
+    # that created objects omits the ones that never moved: those are zero, not unknown.
+    active = (cell.get("metrics_scraped") and cell.get("wal", {}).get("PROVIDER") == "experimental_object_store"
+              and metrics["samples"].get("created_objects_total"))
+    for counter in COUNTERS:
+        row[counter] = metrics["samples"].get(counter, 0 if active else None)
+    created = row["created_objects_total"]
+    row["creates_per_minute"] = created * 60 / load_seconds if created is not None and load_seconds else None
+    return row
+
+
+def ratios(rows: list) -> list:
+    """D/R and E/R per round and their geometric mean over the rounds, per concurrency."""
+    speed = {(r["round"], r["concurrency"], r["config"]): r["rows_per_second"] for r in rows}
+    result = []
+    for concurrency in sorted({r["concurrency"] for r in rows}):
+        rounds = sorted({r["round"] for r in rows if r["concurrency"] == concurrency})
+        for config in ("D", "E"):
+            per_round = []
+            for round_number in rounds:
+                base, value = speed.get((round_number, concurrency, "R")), speed.get((round_number, concurrency, config))
+                per_round.append(value / base if base and value else None)
+            complete = [value for value in per_round if value is not None]
+            result.append({"concurrency": concurrency, "ratio": f"{config}/R", "per_round": per_round,
+                           "geomean": geomean(complete) if len(complete) == len(per_round) else None})
+    return result
+
+
+def fmt(value, digits=0, scale=1.0) -> str:
+    return "—" if value is None else f"{value * scale:,.{digits}f}"
+
+
+def render(run: dict, rows: list, pairs: list) -> str:
+    lines = [f"## Object store WAL against S3 ({'smoke, MinIO' if run.get('smoke') else run.get('instance_type')})", ""]
+    lines += [f"GreptimeDB `{run.get('greptimedb_image')}` ({next((r['version'] for r in rows if r['version']), '—')}); "
+              f"{fmt(run.get('rows'))} rows in {run.get('batch_rows')}-row batches; bucket region {run.get('region')}.", ""]
+    lines += ["| Cell | Rows/s | Load s | Wall s | Rows | Ack p50 ms | Ack p99 ms | Creates | Creates/min "
+              "| Stalled | Poisoned | Create failures | Conflicts | WAL on |",
+              "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |"]
+    for r in rows:
+        cell = f"{r['id']} (not run)" if r["missing"] else r["id"] if r["exit_code"] == 0 \
+            else f"{r['id']} (failed, exit {r['exit_code']})"
+        lines.append(" | ".join([
+            f"| {cell}", fmt(r["rows_per_second"]), fmt(r["load_seconds"], 1), fmt(r["load_wall_seconds"], 1),
+            fmt(r["rows"]), fmt(r["append_ack_p50_seconds"], 1, 1000), fmt(r["append_ack_p99_seconds"], 1, 1000),
+            *(fmt(r[c]) for c in COUNTERS[:1]), fmt(r["creates_per_minute"], 1),
+            *(fmt(r[c]) for c in COUNTERS[1:]), f"`{r['wal_device'] or '—'}` |"]))
+    lines += ["", "| Concurrency | Ratio | Per round | Geometric mean |", "| ---: | --- | --- | ---: |"]
+    for p in pairs:
+        lines.append(f"| {p['concurrency']} | {p['ratio']} | {', '.join(fmt(v, 3) for v in p['per_round'])} "
+                     f"| {fmt(p['geomean'], 3)} |")
+    return "\n".join(lines) + "\n"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, required=True)
+    args = parser.parse_args()
+    args.root.mkdir(parents=True, exist_ok=True)
+    run_path = args.root / "run.json"
+    run = json.loads(run_path.read_text()) if run_path.exists() else {}
+    plan_path = args.root / "plan.json"
+    planned = json.loads(plan_path.read_text())["cells"] if plan_path.exists() else []
+    # The plan, not what happened to run, defines the expected cells and rounds.
+    rows = [load_cell(args.root / "cells" / spec["id"], spec) for spec in planned]
+    rows += [load_cell(path) for path in sorted((args.root / "cells").glob("*"))
+             if path.name not in {spec["id"] for spec in planned} and (path / "cell.json").exists()]
+    pairs = ratios(rows)
+    missing = [r["id"] for r in rows if r["missing"]]
+    (args.root / "summary.json").write_text(json.dumps(
+        {"run": run, "planned_cells": len(planned), "missing_cells": missing, "cells": rows, "ratios": pairs},
+        indent=2) + "\n")
+    print(render(run, rows, pairs) if rows else "No benchmark cell completed.\n")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/scripts/oswal-s3-bench.py b/.github/scripts/oswal-s3-bench.py
new file mode 100644
index 00000000000..faad8ace674
--- /dev/null
+++ b/.github/scripts/oswal-s3-bench.py
@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+# 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.
+
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["boto3>=1.35,<2"]
+# ///
+
+"""Helpers of the object store WAL S3 benchmark; only `probe` and `cleanup` need boto3 (`uv run`)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import time
+import urllib.request
+from pathlib import Path
+
+SMOKE_ROWS = 50_000
+# The o11ybench data profiles; a matching row count generates the canonical dataset.
+DATA_PROFILES = {5_000: "S", 2_000_000: "D", 10_000_000: "P", 100_000_000: "M"}
+# Identical [storage] for every configuration; only [wal] differs.
+WAL_CONFIGS = {
+    "R": {"PROVIDER": "raft_engine", "SYNC_WRITE": "true", "DIR": "/wal"},
+    "D": {"PROVIDER": "experimental_object_store", "ACK_MODE": "durable"},
+    "E": {"PROVIDER": "experimental_object_store", "ACK_MODE": "enqueued"},
+}
+ORDERS = (("R", "D", "E"), ("E", "D", "R"))
+NIGHTLY = re.compile(r"v\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?-nightly-(\d{8})")
+TAG = re.compile(r"[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}")
+DIGEST = re.compile(r".+@sha256:[0-9a-f]{64}")
+
+
+def append_github(variable: str, name: str, value: str) -> None:
+    if path := os.environ.get(variable):
+        with open(path, "a") as output:
+            output.write(f"{name}={value}\n")
+
+
+def positive(name: str, value: str, upper: int) -> int:
+    if not re.fullmatch(r"[1-9][0-9]*", value) or int(value) > upper:
+        raise ValueError(f"{name} must be an integer in 1..{upper}, got {value!r}")
+    return int(value)
+
+
+def validate_budgets(timeout_minutes: str, ttl_hours: str) -> None:
+    timeout, ttl = positive("timeout", timeout_minutes, 360), positive("ttl", ttl_hours, 168)
+    # Provisioning, teardown and queueing need two hours beyond the benchmark job.
+    if ttl * 60 < timeout + 120:
+        raise ValueError(f"janitor TTL {ttl}h must cover the {timeout}-minute timeout plus 2 hours")
+
+
+def check_regions(bucket: str, runner: str) -> None:
+    if not bucket or bucket != runner:
+        raise ValueError(f"bucket region {bucket!r} differs from runner region {runner!r}; "
+                         "a cross-region bucket measures the WAN, not S3")
+
+
+def build_manifest(plan: dict, greptimedb_inspect: list, runtime_image: str,
+                   instance_type: str, region: str, prefix: str) -> dict:
+    image = next((d for d in greptimedb_inspect[0].get("RepoDigests") or [] if DIGEST.fullmatch(d)), None)
+    if image is None:
+        raise ValueError("the GreptimeDB image has no sha256 repository digest")
+    return {"smoke": plan["smoke"], "rows": plan["rows"], "rounds": plan["rounds"],
+            "concurrency": plan["concurrency"], "batch_rows": plan["batch_rows"],
+            "greptimedb_image": image, "runtime_image": runtime_image,
+            "instance_type": instance_type, "region": region, "prefix": prefix}
+
+
+def build_plan(concurrency: str, rows: str, batch_rows: str, rounds: str, smoke: bool) -> dict:
+    levels = [positive("concurrency", level.strip(), 256) for level in concurrency.split(",")]
+    if len(set(levels)) != len(levels):
+        raise ValueError(f"concurrency repeats a level: {concurrency!r}")
+    row_count = SMOKE_ROWS if smoke else positive("rows", rows, 100_000_000)
+    round_count = 1 if smoke else positive("rounds", rounds, 10)
+    profile = DATA_PROFILES.get(row_count)
+    cells = []
+    for round_number in range(1, round_count + 1):
+        # Alternate the order between rounds so no configuration always runs first.
+        for level in levels:
+            for config in ORDERS[(round_number - 1) % 2]:
+                cells.append({
+                    "id": f"{round_number}-{level}-{config}", "round": round_number,
+                    "concurrency": level, "config": config, "wal": WAL_CONFIGS[config],
+                })
+    return {
+        "smoke": smoke, "rows": row_count, "rounds": round_count,
+        "batch_rows": positive("batch_rows", batch_rows, 100_000), "concurrency": levels,
+        "data_profile": profile or "custom",
+        "generator_args": ["--data-profile", profile] if profile else ["--line-count", str(row_count)],
+        "cells": cells,
+    }
+
+
+def newest_nightly(tags: list[str]) -> str:
+    dated = [(match.group(1), tag) for tag in tags if (match := NIGHTLY.fullmatch(tag))]
+    if not dated:
+        raise ValueError("no v*-nightly-* tag found")
+    return max(dated)[1]
+
+
+def resolve_tag(requested: str) -> str:
+    if requested != "nightly":
+        if not TAG.fullmatch(requested):
+            raise ValueError(f"invalid image tag: {requested!r}")
+        return requested
+    url = ("https://hub.docker.com/v2/repositories/greptime/greptimedb/tags"
+           "?page_size=100&name=nightly&ordering=last_updated")
+    with urllib.request.urlopen(url, timeout=30) as response:
+        return newest_nightly([tag["name"] for tag in json.load(response)["results"]])
+
+
+def s3_client(args):
+    import boto3
+    from botocore.config import Config
+
+    return boto3.client("s3", region_name=args.region, endpoint_url=args.endpoint or None,
+                        config=Config(retries={"mode": "standard", "max_attempts": 5}))
+
+
+def probe(args) -> None:
+    client, key = s3_client(args), f"{args.prefix}/probe/object"
+    deadline = time.monotonic() + 60
+    while True:
+        try:
+            client.put_object(Bucket=args.bucket, Key=key, Body=b"probe")
+            break
+        except Exception:
+            # A fresh MinIO creates its bucket after the container starts.
+            if time.monotonic() > deadline:
+                raise
+            time.sleep(3)
+    listed = client.list_objects_v2(Bucket=args.bucket, Prefix=f"{args.prefix}/probe/")
+    if [item["Key"] for item in listed.get("Contents", [])] != [key]:
+        raise RuntimeError(f"listing {args.prefix}/probe/ did not return exactly {key}")
+    client.delete_object(Bucket=args.bucket, Key=key)
+    print(f"put, list and delete succeeded under s3://{args.bucket}/{args.prefix}/probe/")
+
+
+def cleanup(args) -> None:
+    # One DeleteObject per key: DeleteObjects needs a checksum header the MinIO fixture rejects.
+    client, deleted = s3_client(args), 0
+    for page in client.get_paginator("list_objects_v2").paginate(Bucket=args.bucket, Prefix=f"{args.prefix}/"):
+        for item in page.get("Contents", []):
+            client.delete_object(Bucket=args.bucket, Key=item["Key"])
+            deleted += 1
+    print(f"deleted {deleted} objects under s3://{args.bucket}/{args.prefix}/")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    plan = commands.add_parser("plan")
+    for name in ("concurrency", "rows", "batch-rows", "rounds"):
+        plan.add_argument(f"--{name}", required=True)
+    plan.add_argument("--smoke", choices=("true", "false"), required=True)
+    for name in ("timeout-minutes", "ttl-hours", "output"):
+        plan.add_argument(f"--{name}")
+    commands.add_parser("tag").add_argument("requested")
+    regions = commands.add_parser("regions")
+    for name in ("bucket", "runner"):
+        regions.add_argument(f"--{name}", required=True)
+    manifest = commands.add_parser("manifest")
+    for name in ("results", "runtime-image", "instance-type", "region", "prefix"):
+        manifest.add_argument(f"--{name}", required=True)
+    for name in ("probe", "cleanup"):
+        bucket = commands.add_parser(name)
+        bucket.add_argument("--endpoint", default="")
+        for option in ("bucket", "region", "prefix"):
+            bucket.add_argument(f"--{option}", required=True)
+    args = parser.parse_args()
+    if args.command == "plan":
+        if args.timeout_minutes or args.ttl_hours:
+            validate_budgets(args.timeout_minutes or "", args.ttl_hours or "")
+        result = build_plan(args.concurrency, args.rows, args.batch_rows, args.rounds, args.smoke == "true")
+        if args.output:
+            with open(args.output, "w") as output:
+                json.dump(result, output, indent=2)
+        print(f"{len(result['cells'])} cells, {result['rows']} rows, profile {result['data_profile']}")
+    elif args.command == "tag":
+        tag = resolve_tag(args.requested)
+        append_github("GITHUB_OUTPUT", "greptimedb_tag", tag)
+        print(f"GreptimeDB image tag: {tag}")
+    elif args.command == "regions":
+        check_regions(args.bucket, args.runner)
+        print(f"bucket and runner both in {args.runner}")
+    elif args.command == "manifest":
+        results = Path(args.results)
+        manifest = build_manifest(json.loads((results / "plan.json").read_text()),
+                                  json.loads((results / "images" / "greptimedb.json").read_text()),
+                                  args.runtime_image, args.instance_type, args.region, args.prefix)
+        (results / "run.json").write_text(json.dumps(manifest, indent=2) + "\n")
+        append_github("GITHUB_ENV", "GREPTIMEDB_IMAGE", manifest["greptimedb_image"])
+        print(f"GreptimeDB image: {manifest['greptimedb_image']}")
+    else:
+        if not re.fullmatch(r"oswal-bench/[0-9]+-[0-9]+", args.prefix):
+            raise ValueError(f"refusing a prefix outside oswal-bench/<run>: {args.prefix!r}")
+        (probe if args.command == "probe" else cleanup)(args)
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except ValueError as error:
+        print(f"::error::{error}", file=sys.stderr)
+        sys.exit(1)
diff --git a/.github/scripts/pull-benchmark-image.sh b/.github/scripts/pull-benchmark-image.sh
new file mode 100644
index 00000000000..1a26a4aeaee
--- /dev/null
+++ b/.github/scripts/pull-benchmark-image.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Pull only: never retry database writes, benchmarks, or cloud provisioning.
+set -euo pipefail
+
+if [[ $# != 1 || -z "$1" || "$1" == -* ]]; then
+    echo "Usage: $0 IMAGE" >&2
+    exit 2
+fi
+image=$1
+attempts=3
+for ((attempt=1; attempt<=attempts; attempt++)); do
+    echo "Pulling $image (attempt $attempt/$attempts)" >&2
+    if timeout --kill-after=10s 180s docker pull "$image"; then
+        exit 0
+    else
+        status=$?
+    fi
+    if ((attempt == attempts)); then
+        echo "Failed to pull $image after $attempts attempts (exit $status)" >&2
+        exit "$status"
+    fi
+    delay=$((attempt * 10))
+    echo "Pull failed (exit $status); retrying in ${delay}s" >&2
+    sleep "$delay"
+done
diff --git a/.github/scripts/tracesbench-summary.py b/.github/scripts/tracesbench-summary.py
new file mode 100644
index 00000000000..087a67498f4
--- /dev/null
+++ b/.github/scripts/tracesbench-summary.py
@@ -0,0 +1,169 @@
+# 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 argparse
+import json
+import html
+import math
+from pathlib import Path
+
+from benchmark_resource_summary import render_resources
+
+TARGETS = ('greptimedb', 'victoriatraces', 'tempo')
+
+
+def duration(ms):
+    if not isinstance(ms, (int, float)) or not math.isfinite(ms) or ms < 0:
+        return '—'
+    if ms < 1:
+        return f'{ms * 1000:.0f} µs'
+    if ms < 1000:
+        return f'{ms:.1f} ms'
+    if ms < 60_000:
+        return f'{ms / 1000:.2f} s'
+    minutes, seconds = divmod(round(ms / 1000), 60)
+    hours, minutes = divmod(minutes, 60)
+    return f'{hours}h {minutes}m {seconds}s' if hours else f'{minutes}m {seconds}s'
+
+
+def cell(value):
+    return html.escape(str(value if value is not None else '—')).replace('|', '&#124;').replace('\n', ' ')
+
+
+def read(path):
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text())
+
+
+def table(headers, rows):
+    return '\n'.join(['| ' + ' | '.join(map(cell, headers)) + ' |',
+                      '| ' + ' | '.join('---' for _ in headers) + ' |'] +
+                     ['| ' + ' | '.join(map(cell, row)) + ' |' for row in rows])
+
+
+def delta(value, baseline):
+    if not all(isinstance(v, (int, float)) and math.isfinite(v) for v in (value, baseline)):
+        return '—'
+    return f'{(value / baseline - 1) * 100:+.1f}%' if baseline > 0 and value >= 0 else '—'
+
+
+
+def load(root):
+    report = read(root / 'report.json')
+    runs = [read(p) for p in sorted((root / 'runs').glob('*/run.json'))]
+    return report, runs
+
+
+def benchmark(report, runs, targets=TARGETS):
+    lines = ['# Tracesbench benchmark summary', '',
+             'Median Δ = (target / GreptimeDB − 1) × 100%; negative is faster. '
+             'Min/median/max come from the validated report, not recalculated samples. '
+             'Counts exclude warmup. Missing or excluded results have no latency comparison.',
+             '', f'Classification: {cell(report.get("classification"))}. '
+             'See the uploaded HTML for query semantics and client-side compensation.', '']
+    statistics = {}
+    for corpus in report.get('per_corpus', []):
+        for stat in corpus.get('statistics', []):
+            if stat['target'] not in targets:
+                continue
+            statistics[(corpus['corpus'], stat['round'], stat['target'], stat['query_id'])] = stat
+    rows, details = [], []
+    for target in targets:
+        selected = [run for run in runs if run.get('target') == target]
+        if not selected:
+            lines.append(f'- **{target}**: unavailable / not run.')
+        for run in selected:
+            lines.append(f'- **{target}**: lifecycle '
+                         f'{"completed" if run.get("success") is True else "failed / incomplete"}; '
+                         f'query failures: {len(run.get("query_failures", []))}.')
+            for qid in (f'T{i:02}' for i in range(1, 9)):
+                correct = [q for q in run.get('correctness', []) if q.get('query_id') == qid]
+                measured = [q for q in run.get('samples', [])
+                            if q.get('query_id') == qid and q.get('phase') == 'measured']
+                errors = [q for q in correct + run.get('samples', [])
+                          if q.get('query_id') == qid and q.get('outcome') not in ('passed', 'not_executed')]
+                reason = (run.get('exclusions', {}).get(qid) or
+                          run.get('execution', {}).get('query_skips', {}).get(qid))
+                stat = statistics.get((run.get('corpus'), run.get('round'), target, qid), {})
+                base = statistics.get((run.get('corpus'), run.get('round'), 'greptimedb', qid), {})
+                status = ('failed' if errors else 'excluded' if reason else
+                          'passed' if stat else
+                          'correctness passed; report unavailable' if correct and
+                          all(q.get('outcome') == 'passed' for q in correct) else 'unavailable / incomplete')
+                rows.append([run.get('corpus'), run.get('round'), qid, target, status,
+                             duration(stat.get('min_ms')), duration(stat.get('median_ms')),
+                             duration(stat.get('max_ms')),
+                             delta(stat.get('median_ms'), base.get('median_ms')) if target != 'greptimedb' else '—',
+                             sum(q.get('outcome') == 'passed' for q in measured),
+                             sum(q.get('outcome') != 'passed' for q in measured)])
+                if reason or errors:
+                    messages = [str(q.get('error') or q.get('outcome')) for q in errors]
+                    details.append(f'- **{target} / {qid}**: {cell(str(reason or "") + " " + "; ".join(messages))[:4000]}')
+    lines += ['', table(['Dataset', 'Round', 'Query', 'DB', 'Status', 'Min', 'Median', 'Max',
+                         'Median Δ', 'Measured success', 'Measured errors'], rows), '',
+              '<details>', '<summary>Query failures and exclusions</summary>', '', *details, '', '</details>']
+    if not report:
+        lines += ['', 'Validated report unavailable; raw outcomes are shown without latency statistics.']
+    return '\n'.join(lines)
+
+
+def lifecycle(report, runs, root, targets=TARGETS):
+    rows = []
+    for target in targets:
+        selected = [r for r in runs if r.get('target') == target] or [{}]
+        for run in selected:
+            load = run.get('load', {})
+            ingest = load.get('ingest', {})
+            if target == 'tempo' and 'ingest' not in load:
+                ingest = load.get('transport', {}).get('ingest', {})
+            health = run.get('post_load_health', {})
+            execution = run.get('execution', {})
+            start, finish = run.get('started_unix_ns'), run.get('finished_unix_ns')
+            elapsed = (finish - start) / 1_000_000 if isinstance(start, int) and isinstance(finish, int) else None
+            seconds = ingest.get('wall_seconds')
+            rows.append([target, run.get('corpus'), run.get('load_summary', {}).get('after'),
+                         duration(elapsed), duration(seconds * 1000 if isinstance(seconds, (int, float)) else None),
+                         ingest.get('successful_requests'), ingest.get('failed_requests'),
+                         execution.get('load_workers_requested'), execution.get('max_in_flight'),
+                         execution.get('db_cpus'), execution.get('db_memory'),
+                         health.get('running'), health.get('oom_killed'),
+                         run.get('cleanup', {}).get('verified_absent')])
+    return '\n'.join(['# Tracesbench load / lifecycle summary', '',
+                       'Total is the recorded target lifecycle; ingest is the sender wall time, '
+                       'not the entire load/readiness phase. Health is the post-load snapshot. '
+                       'Missing evidence remains blank.', '',
+                       table(['DB', 'Dataset', 'Loaded spans', 'Total', 'Ingest',
+                              'Write success', 'Write errors', 'Load workers', 'Max in flight',
+                              'DB CPU', 'DB memory', 'Running after load', 'OOM after load',
+                              'Container removed'], rows), '',
+                       render_resources([('dataset', root / 'runs' / 'generate')] +
+                                        [(t, root / 'runs' / t) for t in targets], table)])
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--root', type=Path, required=True)
+    parser.add_argument('--section', choices=('benchmark', 'lifecycle'), required=True)
+    parser.add_argument('--targets', default=','.join(TARGETS), help='Comma-separated selected engines')
+    args = parser.parse_args()
+    targets = args.targets.split(',')
+    if not targets or any(t not in TARGETS for t in targets) or len(set(targets)) != len(targets):
+        parser.error('targets must be a non-empty comma-separated subset of greptimedb,victoriatraces,tempo')
+    report, runs = load(args.root)
+    print(benchmark(report, runs, targets) if args.section == 'benchmark' else lifecycle(report, runs, args.root, targets))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/.github/workflows/agent-observability.yml b/.github/workflows/agent-observability.yml
index 86713c911ed..d265801d4a0 100644
--- a/.github/workflows/agent-observability.yml
+++ b/.github/workflows/agent-observability.yml
@@ -26,8 +26,18 @@ on:
           - M
         default: S
         required: true
+      compare_greptimedb:
+        description: Compare baseline and candidate sequentially on the same host (adds one full GreptimeDB run)
+        type: boolean
+        default: false
+        required: false
+      baseline_greptimedb_tag:
+        description: Baseline Docker Hub greptime/greptimedb tag; required when comparison is enabled
+        type: string
+        default: v1.2.1
+        required: false
       greptimedb_tag:
-        description: Docker Hub greptime/greptimedb tag
+        description: Candidate Docker Hub greptime/greptimedb tag
         type: string
         default: latest
         required: true
@@ -46,9 +56,9 @@ on:
         type: string
         required: false
       runtime_image:
-        description: Aliyun runtime image (tag or digest reference)
+        description: 'Runtime image: auto = AWS ECR Public or Aliyun ACR by provider; explicit tag/digest overrides'
         type: string
-        default: greptime-registry.cn-hangzhou.cr.aliyuncs.com/tools/o11ybench-runtime:20260917-8111034e@sha256:ce9dee2abb1e70f907a09ea01854904a91cc97748b0c4ef6f33d9ec34044bec0
+        default: auto
         required: true
       provider:
         description: Cloud provider for the benchmark runner
@@ -89,12 +99,14 @@ on:
 permissions:
   contents: read
 env:
+  COMPARE_GREPTIMEDB: ${{ inputs.compare_greptimedb }}
+  BASELINE_GREPTIMEDB_TAG: ${{ inputs.baseline_greptimedb_tag }}
   PROFILE: ${{ inputs.dataset }}
   GREPTIMEDB_TAG: ${{ inputs.greptimedb_tag }}
   CLICKHOUSE_TAG: ${{ inputs.clickhouse_tag }}
   VICTORIALOGS_TAG: ${{ inputs.victorialogs_tag }}
   O11YBENCH_REF: ${{ inputs.o11ybench_ref }}
-  RUNTIME_IMAGE: ${{ inputs.runtime_image }}
+  RUNTIME_IMAGE: ${{ inputs.runtime_image != 'auto' && inputs.runtime_image || inputs.provider == 'AWS' && 'public.ecr.aws/i8k6a5e1/greptime/o11ybenchruntime:2f40fb3fdbdc@sha256:8940782216bf5d066308fd71f6e346d950073c41cfb5756c5f3dc8aacf069cbc' || 'greptime-registry.cn-hangzhou.cr.aliyuncs.com/tools/o11ybench-runtime:2f40fb3fdbdc@sha256:8940782216bf5d066308fd71f6e346d950073c41cfb5756c5f3dc8aacf069cbc' }}
   PROVIDER: ${{ inputs.provider }}
   REQUESTED_INSTANCE_TYPE: ${{ inputs.instance_type }}
   SYSTEM_DISK_GIB: ${{ inputs.system_disk_gib }}
@@ -118,6 +130,12 @@ jobs:
         with:
           path: greptimedb
           persist-credentials: false
+      - name: Validate version comparison
+        env:
+          RUN_GREPTIMEDB: ${{ inputs.run_greptimedb }}
+        run: |
+          python3 greptimedb/tests/perf/test_benchmark_version_comparison.py
+          python3 greptimedb/.github/scripts/benchmark-version-comparison.py validate
       - name: Resolve CI runner
         id: runner
         run: python3 greptimedb/.github/scripts/ci-runner-config.py --provider "$PROVIDER" --instance-type "$REQUESTED_INSTANCE_TYPE"
@@ -126,6 +144,16 @@ jobs:
           python3 greptimedb/tests/perf/test_aliyun_ecs_runner_scripts.py
           python3 greptimedb/tests/perf/test_ci_runner_scripts.py
           python3 greptimedb/tests/perf/test_agent_observability_summary.py
+      - name: Check runtime supports shared version-comparison data
+        if: inputs.compare_greptimedb
+        run: |
+          bash greptimedb/.github/scripts/pull-benchmark-image.sh "$RUNTIME_IMAGE"
+          docker run --rm --entrypoint grep "$RUNTIME_IMAGE" -q -- '--data-root)' /opt/o11ybench/scripts/run-agent-observability.sh \
+            || { echo 'Comparison requires a runtime with --data-root support'; exit 1; }
+      - name: Validate dataset admission in runtime
+        run: |
+          bash greptimedb/.github/scripts/pull-benchmark-image.sh "$RUNTIME_IMAGE"
+          docker run --rm "$RUNTIME_IMAGE" scripts/logbench_agent_observability_measured.py --preflight-profile "$PROFILE"
       - name: Validate requested benchmark
         id: inputs
         shell: bash
@@ -262,11 +290,11 @@ jobs:
         run: |
           set -euo pipefail
           actual=
-          [[ "$RUNTIME_IMAGE" == *.cr.aliyuncs.com/* ]]
+          [[ "$RUNTIME_IMAGE" == *.cr.aliyuncs.com/* || "$RUNTIME_IMAGE" == public.ecr.aws/* ]]
           images='{}'
           resolve_image() {
             local target=$1 reference=$2 variable=$3 metadata resolved revision
-            docker pull "$reference"
+            bash greptimedb/.github/scripts/pull-benchmark-image.sh "$reference"
             metadata=$(docker image inspect "$reference")
             resolved=$(jq -er '.[0].RepoDigests[0]' <<< "$metadata")
             if [[ "$target" == runtime ]]; then
@@ -289,6 +317,9 @@ jobs:
               victorialogs) resolve_image "$target" "victoriametrics/victoria-logs:$VICTORIALOGS_TAG" VICTORIALOGS_IMAGE ;;
             esac
           done
+          if [[ "$COMPARE_GREPTIMEDB" == true ]]; then
+            resolve_image greptimedb-baseline "greptime/greptimedb:$BASELINE_GREPTIMEDB_TAG" BASELINE_GREPTIMEDB_IMAGE
+          fi
           jq -n --arg sha "$actual" --arg targets "$TARGETS" --arg profile "$PROFILE" \
             --arg cpus "$DB_CPUS" --arg memory "$DB_MEMORY" --argjson images "$images" \
             --arg provider "$PROVIDER" --arg instance_type "$INSTANCE_TYPE" --argjson disk_gib "$SYSTEM_DISK_GIB" \
@@ -312,6 +343,15 @@ jobs:
             --owner "$OWNER" --runtime-image "$RESOLVED_RUNTIME_IMAGE" \
             --root "$ARTIFACT_ROOT" --profile "$PROFILE" --db-cpus "$DB_CPUS" --db-memory "$DB_MEMORY"
           cp "$MANIFEST_PATH" "$ARTIFACT_ROOT/run-manifest.json"
+      - name: Load and benchmark baseline GreptimeDB
+        id: baseline_greptimedb
+        if: ${{ !cancelled() && steps.generate.outcome == 'success' && needs.validate.outputs.greptimedb == 'true' && inputs.compare_greptimedb }}
+        run: |-
+          GITHUB_STEP_SUMMARY= bash o11ybench/scripts/run-agent-observability.sh --stage target --execute \
+            --owner "$OWNER-base" --runtime-image "$RESOLVED_RUNTIME_IMAGE" --root "$ARTIFACT_ROOT/baseline" --data-root "$ARTIFACT_ROOT" \
+            --profile "$PROFILE" --db-cpus "$DB_CPUS" --db-memory "$DB_MEMORY" \
+            --target greptimedb --image "$BASELINE_GREPTIMEDB_IMAGE" \
+            --greptimedb-http-port "$GREPTIMEDB_HTTP_PORT" --greptimedb-grpc-port "$GREPTIMEDB_GRPC_PORT"
       - name: Load and benchmark greptimedb
         id: greptimedb
         if: ${{ !cancelled() && steps.generate.outcome == 'success' && needs.validate.outputs.greptimedb == 'true' }}
@@ -357,6 +397,13 @@ jobs:
             GITHUB_STEP_SUMMARY= bash o11ybench/scripts/run-agent-observability.sh --stage cleanup --execute \
               --owner "$OWNER" --root "$ARTIFACT_ROOT"
           fi
+      - name: Clean up baseline containers
+        if: always() && inputs.compare_greptimedb
+        run: |-
+          if [[ -f o11ybench/scripts/run-agent-observability.sh ]]; then
+            GITHUB_STEP_SUMMARY= bash o11ybench/scripts/run-agent-observability.sh --stage cleanup --execute \
+              --owner "$OWNER-base" --root "$ARTIFACT_ROOT/baseline"
+          fi
       - name: Benchmark summary
         if: always()
         run: |
@@ -367,6 +414,16 @@ jobs:
         run: |
           python3 greptimedb/.github/scripts/agent-observability-summary.py \
             --root "$ARTIFACT_ROOT" --targets "$TARGETS" --section lifecycle >> "$GITHUB_STEP_SUMMARY"
+      - name: Baseline load / lifecycle summary
+        if: always() && inputs.compare_greptimedb
+        run: |
+          echo '## Baseline GreptimeDB' >> "$GITHUB_STEP_SUMMARY"
+          python3 greptimedb/.github/scripts/agent-observability-summary.py \
+            --root "$ARTIFACT_ROOT/baseline" --targets greptimedb --section lifecycle >> "$GITHUB_STEP_SUMMARY"
+      - name: GreptimeDB version comparison
+        if: always() && inputs.compare_greptimedb
+        run: |
+          python3 greptimedb/.github/scripts/benchmark-version-comparison.py report --kind agent --root "$ARTIFACT_ROOT" >> "$GITHUB_STEP_SUMMARY"
       - name: Upload results (no dataset)
         if: always()
         uses: actions/upload-artifact@v4
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index d3bad06f41d..deba5010c80 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -99,6 +99,7 @@ jobs:
           python3 tests/perf/test_aliyun_ecs_runner_scripts.py
           python3 tests/perf/test_ci_runner_scripts.py
           python3 tests/perf/test_agent_observability_summary.py
+          python3 tests/perf/test_tracesbench_summary.py
 
   check:
     if: ${{ github.repository == 'GreptimeTeam/greptimedb' && (github.event_name != 'pull_request' || github.event.pull_request.draft == false || github.run_attempt > 1) }}
diff --git a/.github/workflows/oswal-s3-bench.yml b/.github/workflows/oswal-s3-bench.yml
new file mode 100644
index 00000000000..c31dfe8f1c3
--- /dev/null
+++ b/.github/workflows/oswal-s3-bench.yml
@@ -0,0 +1,229 @@
+name: Object Store WAL S3 Benchmark
+on:
+  workflow_dispatch:
+    inputs:
+      smoke:
+        description: 'Smoke run: ubuntu-latest and the MinIO fixture instead of EC2 and S3, 50000 rows, one round; its numbers mean nothing'
+        type: boolean
+        default: false
+      greptimedb_tag:
+        description: 'Docker Hub greptime/greptimedb tag; nightly = the newest v*-nightly-* tag (latest is a release without the object store WAL)'
+        type: string
+        default: nightly
+      instance_type:
+        description: EC2 instance type in the bucket region; the d of c6id gives a local NVMe instance store for the Raft Engine WAL
+        type: string
+        default: c6id.2xlarge
+      concurrency:
+        description: Comma-separated loader concurrency levels
+        type: string
+        default: '1,8'
+      rows:
+        description: Dataset rows (2000000 = o11ybench profile D)
+        type: number
+        default: 2000000
+      batch_rows:
+        description: Rows per write request
+        type: number
+        default: 1000
+      rounds:
+        description: Rounds; the configuration order alternates between rounds (R, D, E then E, D, R)
+        type: number
+        default: 2
+      runtime_image:
+        description: 'o11ybench runtime image: auto = AWS ECR Public; explicit tag/digest overrides'
+        type: string
+        default: auto
+      benchmark_timeout_minutes:
+        description: Benchmark job timeout in minutes (1..360)
+        type: number
+        default: 240
+      janitor_ttl_hours:
+        description: Instance lifetime before janitor eligibility (1..168 hours; at least timeout + 2h)
+        type: number
+        default: 8
+permissions:
+  contents: read
+env:
+  SMOKE: ${{ inputs.smoke }}
+  GREPTIMEDB_TAG: ${{ inputs.greptimedb_tag }}
+  REQUESTED_INSTANCE_TYPE: ${{ inputs.instance_type }}
+  CONCURRENCY: ${{ inputs.concurrency }}
+  ROWS: ${{ inputs.rows }}
+  BATCH_ROWS: ${{ inputs.batch_rows }}
+  ROUNDS: ${{ inputs.rounds }}
+  RUNTIME_IMAGE: ${{ inputs.runtime_image != 'auto' && inputs.runtime_image || 'public.ecr.aws/i8k6a5e1/greptime/o11ybenchruntime:77a84e1c8136@sha256:c482993ec177b026235d6cd0c61d4fb6d6f1088bc78bdc0e5964a5398de6dba0' }}
+  BENCHMARK_TIMEOUT_MINUTES: ${{ inputs.benchmark_timeout_minutes }}
+  JANITOR_TTL_HOURS: ${{ inputs.janitor_ttl_hours }}
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    outputs:
+      instance_type: ${{ steps.runner.outputs.instance_type }}
+      greptimedb_tag: ${{ steps.plan.outputs.greptimedb_tag }}
+      runtime_image: ${{ steps.runtime.outputs.runtime_image }}
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        path: greptimedb
+        persist-credentials: false
+    - name: Test benchmark scripts
+      run: |
+        python3 greptimedb/tests/perf/test_oswal_s3_bench_scripts.py
+        python3 greptimedb/tests/perf/test_ci_runner_scripts.py
+    - name: Validate plan, budgets and image tag
+      id: plan
+      run: |
+        python3 greptimedb/.github/scripts/oswal-s3-bench.py plan --smoke "$SMOKE" \
+          --concurrency "$CONCURRENCY" --rows "$ROWS" --batch-rows "$BATCH_ROWS" --rounds "$ROUNDS" \
+          --timeout-minutes "$BENCHMARK_TIMEOUT_MINUTES" --ttl-hours "$JANITOR_TTL_HOURS"
+        python3 greptimedb/.github/scripts/oswal-s3-bench.py tag "$GREPTIMEDB_TAG"
+    - name: Resolve CI runner
+      id: runner
+      run: python3 greptimedb/.github/scripts/ci-runner-config.py --provider AWS --instance-type "$REQUESTED_INSTANCE_TYPE"
+    - name: Check bucket and runner regions
+      env:
+        BUCKET_REGION: ${{ vars.AWS_CI_TEST_BUCKET_REGION }}
+        RUNNER_REGION: ${{ vars.EC2_RUNNER_REGION }}
+      run: python3 greptimedb/.github/scripts/oswal-s3-bench.py regions --bucket "$BUCKET_REGION" --runner "$RUNNER_REGION"
+    - name: Check the runtime image
+      id: runtime
+      run: bash greptimedb/.github/scripts/oswal-s3-bench-run.sh check-runtime "$RUNTIME_IMAGE"
+  provision:
+    needs: validate
+    if: ${{ !inputs.smoke }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    outputs:
+      label: ${{ steps.aws.outputs.label }}
+      instance_id: ${{ steps.aws.outputs.instance_id }}
+      runner_name: ${{ steps.aws.outputs.runner_name }}
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        path: greptimedb
+        persist-credentials: false
+    - uses: aws-actions/configure-aws-credentials@v4
+      with:
+        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws-region: ${{ vars.EC2_RUNNER_REGION }}
+    - uses: astral-sh/setup-uv@v6
+    - name: Create ephemeral EC2 runner
+      id: aws
+      env:
+        GH_PERSONAL_ACCESS_TOKEN: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
+        AWS_REGION: ${{ vars.EC2_RUNNER_REGION }}
+        AWS_EC2_IMAGE_ID: ${{ vars.BENCHMARK_EC2_IMAGE_ID || 'auto' }}
+        AWS_EC2_INSTANCE_TYPE: ${{ needs.validate.outputs.instance_type }}
+        AWS_EC2_SUBNET_ID: ${{ vars.EC2_RUNNER_SUBNET_ID }}
+        AWS_EC2_SECURITY_GROUP_ID: ${{ vars.EC2_RUNNER_SECURITY_GROUP_ID }}
+        AWS_EC2_SYSTEM_DISK_GIB: '60'
+        AWS_EC2_TTL_HOURS: ${{ inputs.janitor_ttl_hours }}
+        AWS_EC2_RUN_ID: ${{ github.run_id }}-${{ github.run_attempt }}
+      run: uv run greptimedb/.github/scripts/aws-ec2-runner-provision.py
+  benchmark:
+    needs:
+    - validate
+    - provision
+    if: ${{ !cancelled() && needs.validate.result == 'success' && (inputs.smoke || needs.provision.result == 'success') }}
+    runs-on: ${{ inputs.smoke && 'ubuntu-latest' || needs.provision.outputs.label }}
+    timeout-minutes: ${{ fromJSON(format('{0}', inputs.benchmark_timeout_minutes)) }}
+    env:
+      INSTANCE_TYPE: ${{ inputs.smoke && 'ubuntu-latest' || needs.validate.outputs.instance_type }}
+      GREPTIMEDB_TAG: ${{ needs.validate.outputs.greptimedb_tag }}
+      RUNTIME_IMAGE: ${{ needs.validate.outputs.runtime_image }}
+      RUN_PREFIX: oswal-bench/${{ github.run_id }}-${{ github.run_attempt }}
+      OWNER: o11ybench-oswal-${{ github.run_id }}-${{ github.run_attempt }}
+      RESULTS: ${{ github.workspace }}/oswal-results
+      CORPUS_DIR: ${{ github.workspace }}/oswal-corpus
+      PLAN: ${{ github.workspace }}/oswal-results/plan.json
+      WAL_ROOT: /mnt/oswal-wal
+      S3_BUCKET: ${{ inputs.smoke && 'greptime' || vars.AWS_CI_TEST_BUCKET }}
+      S3_REGION: ${{ inputs.smoke && 'us-west-2' || vars.AWS_CI_TEST_BUCKET_REGION }}
+      S3_ENDPOINT: ${{ inputs.smoke && 'http://127.0.0.1:9000' || '' }}
+      S3_CONTAINER_ENDPOINT: ${{ inputs.smoke && 'http://host.docker.internal:9000' || '' }}
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        path: greptimedb
+        persist-credentials: false
+    - name: Set up benchmark dependencies
+      uses: ./greptimedb/.github/actions/setup-benchmark
+    - uses: astral-sh/setup-uv@v6
+    - name: Start the MinIO fixture
+      if: inputs.smoke
+      run: |
+        bash greptimedb/.github/scripts/pull-benchmark-image.sh greptime/minio:2024
+        docker compose -f greptimedb/tests-integration/fixtures/docker-compose.yml up -d --wait minio
+    - name: Pull images and write the plan
+      run: |
+        bash greptimedb/.github/scripts/oswal-s3-bench-run.sh pull
+        python3 greptimedb/.github/scripts/oswal-s3-bench.py plan --smoke "$SMOKE" --output "$PLAN" \
+          --concurrency "$CONCURRENCY" --rows "$ROWS" --batch-rows "$BATCH_ROWS" --rounds "$ROUNDS"
+        python3 greptimedb/.github/scripts/oswal-s3-bench.py manifest --results "$RESULTS" \
+          --runtime-image "$RUNTIME_IMAGE" --instance-type "$INSTANCE_TYPE" --region "$S3_REGION" --prefix "$RUN_PREFIX"
+    - name: Probe the bucket
+      env:
+        AWS_ACCESS_KEY_ID: ${{ inputs.smoke && 'superpower_ci_user' || secrets.AWS_CI_TEST_ACCESS_KEY_ID }}
+        AWS_SECRET_ACCESS_KEY: ${{ inputs.smoke && 'superpower_password' || secrets.AWS_CI_TEST_SECRET_ACCESS_KEY }}
+      run: uv run greptimedb/.github/scripts/oswal-s3-bench.py probe --bucket "$S3_BUCKET" --region "$S3_REGION" --endpoint "$S3_ENDPOINT" --prefix "$RUN_PREFIX"
+    - name: Put the Raft Engine WAL on the instance store
+      run: bash greptimedb/.github/scripts/oswal-s3-bench-run.sh wal-disk "$WAL_ROOT"
+    - name: Generate the dataset once
+      run: bash greptimedb/.github/scripts/oswal-s3-bench-run.sh generate
+    - name: Load every cell
+      env:
+        AWS_ACCESS_KEY_ID: ${{ inputs.smoke && 'superpower_ci_user' || secrets.AWS_CI_TEST_ACCESS_KEY_ID }}
+        AWS_SECRET_ACCESS_KEY: ${{ inputs.smoke && 'superpower_password' || secrets.AWS_CI_TEST_SECRET_ACCESS_KEY }}
+      run: bash greptimedb/.github/scripts/oswal-s3-bench-run.sh cells
+    - name: Summary
+      if: always()
+      run: python3 greptimedb/.github/scripts/oswal-s3-bench-summary.py --root "$RESULTS" >> "$GITHUB_STEP_SUMMARY"
+    - name: Delete the run's S3 prefix
+      if: always()
+      env:
+        AWS_ACCESS_KEY_ID: ${{ inputs.smoke && 'superpower_ci_user' || secrets.AWS_CI_TEST_ACCESS_KEY_ID }}
+        AWS_SECRET_ACCESS_KEY: ${{ inputs.smoke && 'superpower_password' || secrets.AWS_CI_TEST_SECRET_ACCESS_KEY }}
+      run: uv run greptimedb/.github/scripts/oswal-s3-bench.py cleanup --bucket "$S3_BUCKET" --region "$S3_REGION" --endpoint "$S3_ENDPOINT" --prefix "$RUN_PREFIX"
+    - name: Check the results hold no credentials
+      if: always()
+      env:
+        AWS_ACCESS_KEY_ID: ${{ inputs.smoke && 'superpower_ci_user' || secrets.AWS_CI_TEST_ACCESS_KEY_ID }}
+        AWS_SECRET_ACCESS_KEY: ${{ inputs.smoke && 'superpower_password' || secrets.AWS_CI_TEST_SECRET_ACCESS_KEY }}
+      run: bash greptimedb/.github/scripts/oswal-s3-bench-run.sh scrub
+    - name: Upload results (no corpus)
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: oswal-s3-bench-${{ inputs.smoke && 'smoke' || 'ec2' }}-${{ github.run_id }}-${{ github.run_attempt }}
+        path: ${{ env.RESULTS }}
+        if-no-files-found: warn
+        retention-days: 14
+  teardown:
+    needs:
+    - provision
+    - benchmark
+    if: ${{ always() && !inputs.smoke && (needs.provision.outputs.instance_id != '' || needs.provision.result != 'skipped') }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        path: greptimedb
+        persist-credentials: false
+    - uses: aws-actions/configure-aws-credentials@v4
+      with:
+        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws-region: ${{ vars.EC2_RUNNER_REGION }}
+    - uses: astral-sh/setup-uv@v6
+    - name: Delete EC2 and unregister runner
+      env:
+        GH_PERSONAL_ACCESS_TOKEN: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
+        AWS_REGION: ${{ vars.EC2_RUNNER_REGION }}
+        AWS_EC2_INSTANCE_ID: ${{ needs.provision.outputs.instance_id }}
+        AWS_EC2_RUNNER_NAME: ${{ needs.provision.outputs.runner_name }}
+        AWS_EC2_RUN_ID: ${{ github.run_id }}-${{ github.run_attempt }}
+      run: uv run greptimedb/.github/scripts/aws-ec2-runner-teardown.py
diff --git a/.github/workflows/query-regression.yml b/.github/workflows/query-regression.yml
index 47daa3f0435..6a368c455d6 100644
--- a/.github/workflows/query-regression.yml
+++ b/.github/workflows/query-regression.yml
@@ -549,7 +549,7 @@ jobs:
           readonly EXPECTED_SCCACHE_DIR="/home/runner/.cache/sccache"
           readonly EXPECTED_RUSTC_WRAPPER="/usr/local/bin/sccache"
           readonly RUNNER_IMAGE_DIGEST="sha256:e713b294e23b7e15184e558866c90025e59930033e72c97650dbc7f1ca022d11"
-          readonly RUNNER_IMAGE_EPOCH="6"
+          readonly RUNNER_IMAGE_EPOCH="7"
 
           require_expected_root() {
             local name="$1"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 6c0c36c895e..0fb22f23e61 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -4,15 +4,20 @@ name: Release
 # 1. The tag('v*.*.*') push release: the release workflow will be triggered by the tag push event.
 # 2. The scheduled release(the version will be '<base-version>-nightly-YYYYMMDD', any pre-release
 #    extension in the next release version like '-alpha.1' is stripped, so 'nightly' is the extension):
-#    the release workflow will be triggered by the schedule event.
+#    the release workflow will be triggered by the schedule event. The schedule runs every weekday,
+#    but the release only proceeds when the latest published nightly release is older than
+#    NIGHTLY_RELEASE_MAX_AGE_DAYS days, so a failed nightly run is retried by the next weekday
+#    schedule instead of leaving a whole week without nightly builds.
 # A failed tag push release can be manually dispatched on the same tag to recover it without changing the formal release version.
 on:
   push:
     tags:
       - "v*.*.*"
   schedule:
-    # At 00:00 on Monday.
-    - cron: '0 0 * * 1'
+    # At 00:00 on every weekday (Monday to Friday). The scheduled nightly release only
+    # proceeds when the latest published nightly release is older than
+    # NIGHTLY_RELEASE_MAX_AGE_DAYS days, see the 'Check nightly release necessity' step.
+    - cron: '0 0 * * 1-5'
   workflow_dispatch: # Allows you to run this workflow manually.
     # Notes: The GitHub Actions ONLY support 10 inputs; this final input is the tenth.
     inputs:
@@ -79,7 +84,7 @@ on:
         default: false
       release_validation:
         type: choice
-        description: Manual policy for accepted perf regressions or runner failures; automatic releases always run all validation
+        description: Manual policy for accepted perf regressions or runner failures; automatic releases always run all validation (scheduled nightlies run query regression non-blocking)
         required: true
         default: all
         options:
@@ -100,6 +105,10 @@ env:
   # the pre-release extension of the next release version is stripped, e.g. v0.2.0-alpha.1 -> v0.2.0-nightly-20230313.
   NIGHTLY_RELEASE_PREFIX: nightly
 
+  # The maximum age (in days) of the latest published nightly release before a scheduled
+  # nightly release may run again; see the 'Check nightly release necessity' step.
+  NIGHTLY_RELEASE_MAX_AGE_DAYS: 5
+
 jobs:
   allocate-runners:
     name: Allocate runners
@@ -123,6 +132,10 @@ jobs:
       # The 'is-current-version-latest' determines whether to update 'latest' Docker tags and downstream repositories.
       is-current-version-latest: ${{ steps.check-version.outputs.is-current-version-latest }}
       is-current-version-stable: ${{ steps.check-version.outputs.is-current-version-stable }}
+
+      # Whether a scheduled nightly release should run: it only runs when the latest published
+      # nightly release is older than NIGHTLY_RELEASE_MAX_AGE_DAYS days. Always 'true' for other events.
+      nightly-required: ${{ steps.check-nightly.outputs.nightly-required }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -135,6 +148,19 @@ jobs:
         run: |
           ./scripts/check-builder-rust-version.sh
 
+      # A scheduled run only proceeds when the latest published nightly release is older than
+      # NIGHTLY_RELEASE_MAX_AGE_DAYS days, so a failed nightly run is retried by the next weekday
+      # schedule. The check runs before the runners are allocated to avoid wasting EC2 resources.
+      - name: Check nightly release necessity
+        id: check-nightly
+        run: |
+          echo "nightly-required=$(./.github/scripts/check-nightly-release.sh)" >> "$GITHUB_OUTPUT"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_EVENT_NAME: ${{ github.event_name }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          NIGHTLY_RELEASE_MAX_AGE_DAYS: ${{ env.NIGHTLY_RELEASE_MAX_AGE_DAYS }}
+
       # The create-version will create a global variable named 'version' in the global workflows.
       # - If it's a tag push release or manual dispatch on a tag with REUSE_EXISTING_RELEASE_TAG=true, the version is the tag name(${{ github.ref_name }});
       # - If it's a scheduled release, the version is '<base-version>-nightly-$buildTime', like v0.2.0-nightly-20230313 (pre-release extensions like '-alpha.1' are stripped);
@@ -156,7 +182,7 @@ jobs:
           ./.github/scripts/check-version.sh "${{ steps.create-version.outputs.version }}"
 
       - name: Allocate linux-amd64 runner
-        if: ${{ inputs.build_linux_artifacts || inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
+        if: ${{ (inputs.build_linux_artifacts || inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule') && steps.check-nightly.outputs.nightly-required == 'true' }}
         uses: ./.github/actions/start-runner
         id: start-linux-amd64-runner
         with:
@@ -170,7 +196,7 @@ jobs:
           subnet-id: ${{ vars.EC2_RUNNER_SUBNET_ID }}
 
       - name: Allocate linux-arm64 runner
-        if: ${{ inputs.build_linux_artifacts || inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
+        if: ${{ (inputs.build_linux_artifacts || inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule') && steps.check-nightly.outputs.nightly-required == 'true' }}
         uses: ./.github/actions/start-runner
         id: start-linux-arm64-runner
         with:
@@ -185,7 +211,7 @@ jobs:
 
   build-linux-amd64-artifacts:
     name: Build linux-amd64 artifacts
-    if: ${{ inputs.build_linux_artifacts || inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
+    if: ${{ (inputs.build_linux_artifacts || inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule') && (github.event_name != 'schedule' || needs.allocate-runners.outputs.nightly-required == 'true') }}
     needs: [
       allocate-runners,
     ]
@@ -211,7 +237,7 @@ jobs:
 
   build-linux-arm64-artifacts:
     name: Build linux-arm64 artifacts
-    if: ${{ inputs.build_linux_artifacts || inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
+    if: ${{ (inputs.build_linux_artifacts || inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule') && (github.event_name != 'schedule' || needs.allocate-runners.outputs.nightly-required == 'true') }}
     needs: [
       allocate-runners,
     ]
@@ -238,7 +264,7 @@ jobs:
 
   build-linux-riscv64-artifacts:
     name: Build linux-riscv64 artifacts
-    if: ${{ inputs.build_linux_artifacts || inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
+    if: ${{ (inputs.build_linux_artifacts || inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule') && (github.event_name != 'schedule' || needs.allocate-runners.outputs.nightly-required == 'true') }}
     needs: [
       allocate-runners,
     ]
@@ -302,7 +328,7 @@ jobs:
     needs: [
       allocate-runners,
     ]
-    if: ${{ inputs.build_macos_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
+    if: ${{ (inputs.build_macos_artifacts || github.event_name == 'push' || github.event_name == 'schedule') && (github.event_name != 'schedule' || needs.allocate-runners.outputs.nightly-required == 'true') }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -340,7 +366,7 @@ jobs:
     needs: [
       allocate-runners,
     ]
-    if: ${{ inputs.build_windows_artifacts || github.event_name == 'push' || github.event_name == 'schedule' }}
+    if: ${{ (inputs.build_windows_artifacts || github.event_name == 'push' || github.event_name == 'schedule') && (github.event_name != 'schedule' || needs.allocate-runners.outputs.nightly-required == 'true') }}
     steps:
       - run: git config --global core.autocrlf false
 
@@ -365,7 +391,7 @@ jobs:
 
   prepare-release-validation:
     name: Prepare release validation
-    if: ${{ inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
+    if: ${{ (inputs.publish_github_release || inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule') && (github.event_name != 'schedule' || needs.allocate-runners.outputs.nightly-required == 'true') }}
     needs: [
       allocate-runners,
     ]
@@ -442,6 +468,9 @@ jobs:
             if [[ "${validation_policy}" != "all" ]]; then
               echo "- ⚠️ Validation bypassed: compatibility=${run_compat}, query-regression=${run_query_regression}"
             fi
+            if [[ "${GITHUB_EVENT_NAME}" == "schedule" ]]; then
+              echo "- ℹ️ Query-regression failure or cancellation is non-blocking for scheduled nightly releases"
+            fi
           } >> "${GITHUB_STEP_SUMMARY}"
 
   compat-release:
@@ -525,9 +554,13 @@ jobs:
 
   release-images-to-dockerhub:
     name: Build and push images to DockerHub
+    # Scheduled nightly releases do not gate on query regression: the test
+    # still runs and reports, but a failure or cancellation does not block
+    # the nightly release.
     if: |
       always() &&
       (inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule') &&
+      (github.event_name != 'schedule' || needs.allocate-runners.outputs.nightly-required == 'true') &&
       needs.allocate-runners.result == 'success' &&
       needs.build-linux-amd64-artifacts.result == 'success' &&
       needs.build-linux-arm64-artifacts.result == 'success' &&
@@ -535,7 +568,8 @@ jobs:
       (needs.compat-release.result == 'success' ||
        (needs.prepare-release-validation.outputs.run-compat == 'false' && needs.compat-release.result == 'skipped')) &&
       (needs.query-regression-release.result == 'success' ||
-       (needs.prepare-release-validation.outputs.run-query-regression == 'false' && needs.query-regression-release.result == 'skipped'))
+       (needs.prepare-release-validation.outputs.run-query-regression == 'false' && needs.query-regression-release.result == 'skipped') ||
+       github.event_name == 'schedule')
     needs: [
       allocate-runners,
       build-linux-amd64-artifacts,
@@ -571,7 +605,18 @@ jobs:
 
   release-cn-artifacts:
     name: Release artifacts to CN region
-    if: ${{ inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule' }}
+    # A non-blocking query regression failure must not skip downstream releases.
+    if: |
+      always() &&
+      (inputs.release_images || github.event_name == 'push' || github.event_name == 'schedule') &&
+      (github.event_name != 'schedule' || needs.allocate-runners.outputs.nightly-required == 'true') &&
+      needs.allocate-runners.result == 'success' &&
+      needs.build-linux-amd64-artifacts.result == 'success' &&
+      needs.build-linux-arm64-artifacts.result == 'success' &&
+      needs.build-linux-riscv64-artifacts.result == 'success' &&
+      needs.build-macos-artifacts.result == 'success' &&
+      needs.build-windows-artifacts.result == 'success' &&
+      needs.release-images-to-dockerhub.result == 'success'
     needs: [ # The job have to wait for all the artifacts are built.
       allocate-runners,
       build-linux-amd64-artifacts,
@@ -615,15 +660,19 @@ jobs:
     name: Create GitHub release and upload artifacts
     # Use always() to run even when optional jobs (macos, windows) are skipped.
     # Then check that required jobs succeeded and optional jobs didn't fail.
+    # Scheduled nightly releases do not gate on query regression either
+    # (see release-images-to-dockerhub); the test still runs and reports.
     if: |
       always() &&
       (inputs.publish_github_release || github.event_name == 'push' || github.event_name == 'schedule') &&
+      (github.event_name != 'schedule' || needs.allocate-runners.outputs.nightly-required == 'true') &&
       needs.allocate-runners.result == 'success' &&
       needs.prepare-release-validation.result == 'success' &&
       (needs.compat-release.result == 'success' ||
        (needs.prepare-release-validation.outputs.run-compat == 'false' && needs.compat-release.result == 'skipped')) &&
       (needs.query-regression-release.result == 'success' ||
-       (needs.prepare-release-validation.outputs.run-query-regression == 'false' && needs.query-regression-release.result == 'skipped')) &&
+       (needs.prepare-release-validation.outputs.run-query-regression == 'false' && needs.query-regression-release.result == 'skipped') ||
+       github.event_name == 'schedule') &&
       needs.build-linux-amd64-artifacts.result == 'success' &&
       needs.build-linux-arm64-artifacts.result == 'success' &&
       needs.build-linux-riscv64-artifacts.result == 'success' &&
@@ -726,7 +775,21 @@ jobs:
 
   bump-downstream-repo-versions:
     name: Bump downstream repo versions
-    if: ${{ github.event_name == 'schedule' || ((github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref_type == 'tag' && !contains(github.ref_name, 'nightly')) && (needs.allocate-runners.outputs.is-current-version-stable == 'true' && needs.allocate-runners.outputs.is-current-version-latest == 'true') }}
+    # A non-blocking query regression failure must not skip downstream updates.
+    if: |
+      always() &&
+      needs.allocate-runners.result == 'success' &&
+      needs.publish-github-release.result == 'success' &&
+      (
+        (github.event_name == 'schedule' && needs.allocate-runners.outputs.nightly-required == 'true') ||
+        (
+          (github.event_name == 'push' || github.event_name == 'workflow_dispatch') &&
+          github.ref_type == 'tag' &&
+          !contains(github.ref_name, 'nightly') &&
+          needs.allocate-runners.outputs.is-current-version-stable == 'true' &&
+          needs.allocate-runners.outputs.is-current-version-latest == 'true'
+        )
+      )
     needs: [allocate-runners, publish-github-release]
     runs-on: ubuntu-latest
     # Permission reference: https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs
@@ -793,9 +856,10 @@ jobs:
           ./.github/scripts/update-homebrew-greptme-version.sh
 
   notification:
-    if: ${{ github.repository == 'GreptimeTeam/greptimedb' && (github.event_name == 'push' || github.event_name == 'schedule') && always() }}
+    if: ${{ github.repository == 'GreptimeTeam/greptimedb' && (github.event_name == 'push' || (github.event_name == 'schedule' && needs.allocate-runners.outputs.nightly-required == 'true')) && always() }}
     name: Send notification to Greptime team
     needs: [
+      allocate-runners,
       release-images-to-dockerhub,
       build-macos-artifacts,
       build-windows-artifacts,
diff --git a/.github/workflows/tracesbench.yml b/.github/workflows/tracesbench.yml
index 60081d69ad9..049faaef1a7 100644
--- a/.github/workflows/tracesbench.yml
+++ b/.github/workflows/tracesbench.yml
@@ -2,6 +2,36 @@ name: Tracesbench
 on:
   workflow_dispatch:
     inputs:
+      run_greptimedb:
+        description: Run GreptimeDB
+        type: boolean
+        default: true
+        required: false
+      run_victoriatraces:
+        description: Run VictoriaTraces
+        type: boolean
+        default: false
+        required: false
+      run_tempo:
+        description: Run Tempo
+        type: boolean
+        default: false
+        required: false
+      compare_greptimedb:
+        description: Compare baseline and candidate sequentially on the same host (adds one full GreptimeDB run)
+        type: boolean
+        default: false
+        required: false
+      baseline_greptimedb_tag:
+        description: Baseline Docker Hub greptime/greptimedb tag; required when comparison is enabled
+        type: string
+        default: v1.2.1
+        required: false
+      greptimedb_tag:
+        description: Candidate Docker Hub greptime/greptimedb tag
+        type: string
+        default: latest
+        required: true
       dataset:
         description: Dataset profile (main is experimental; native queries may exceed memory limits)
         type: choice
@@ -9,9 +39,9 @@ on:
         default: sanity
         required: true
       runtime_image:
-        description: Aliyun runtime image (tag or digest reference)
+        description: 'Runtime image: auto = AWS ECR Public or Aliyun ACR by provider; explicit tag/digest overrides'
         type: string
-        default: greptime-registry.cn-hangzhou.cr.aliyuncs.com/tools/o11ybench-runtime:20260928-4e52d0b0@sha256:39d2d87593788e0c47a54768f6323679b8e03d7dc72a8158a9b22cf29f883baa
+        default: auto
         required: true
       provider:
         description: Cloud provider for the benchmark runner
@@ -20,7 +50,7 @@ on:
         default: Aliyun
         required: true
       instance_type:
-        description: 'Instance type; auto = Aliyun: ecs.c9i.2xlarge, AWS: c7i.2xlarge (both 8 vCPU / 16 GiB). Enter a specific type to override.'
+        description: 'Instance type; auto = Aliyun: ecs.g9i.2xlarge, AWS: m7i.2xlarge (both 8 vCPU / 32 GiB). Enter a specific type to override.'
         type: string
         default: auto
         required: true
@@ -45,33 +75,46 @@ on:
         default: 8
         required: true
       db_cpus:
-        description: CPU limit per DB container
+        description: CPU limit per DB container (default 8 vCPU)
         type: string
         default: '8'
         required: true
       db_memory:
-        description: Memory limit per DB container
+        description: Memory limit per DB container (default 32 GiB; shared host also runs the runtime and runner)
         type: string
-        default: 16g
+        default: 32g
+        required: true
+      load_workers:
+        description: CPU workers for parallel import reading/parsing across all engines (separate from write concurrency)
+        type: number
+        default: 4
+        required: true
+      query_timeout_seconds:
+        description: Timeout per query request in seconds (correctness, warmup and measurement; 1..3600)
+        type: number
+        default: 300
         required: true
       runtime_cpus:
-        description: CPU limit per runtime container
+        description: CPU limit per runtime container (0 = unrestricted)
         type: string
-        default: '2'
+        default: '0'
         required: true
       runtime_memory:
-        description: Memory limit per runtime container (separate from DB memory)
+        description: Memory limit per runtime container (0 = unrestricted; separate from DB memory)
         type: string
-        default: 4g
+        default: '0'
         required: true
 permissions:
   contents: read
 env:
+  COMPARE_GREPTIMEDB: ${{ inputs.compare_greptimedb }}
+  BASELINE_GREPTIMEDB_TAG: ${{ inputs.baseline_greptimedb_tag }}
   DATASET: ${{ inputs.dataset }}
+  GREPTIMEDB_TAG: ${{ inputs.greptimedb_tag }}
   RUNTIME_CPUS: ${{ inputs.runtime_cpus }}
   RUNTIME_MEMORY: ${{ inputs.runtime_memory }}
   BENCHMARK_ROOT: ${{ inputs.benchmark_root }}
-  RUNTIME_IMAGE: ${{ inputs.runtime_image }}
+  RUNTIME_IMAGE: ${{ inputs.runtime_image != 'auto' && inputs.runtime_image || inputs.provider == 'AWS' && 'public.ecr.aws/i8k6a5e1/greptime/o11ybenchruntime:77a84e1c8136@sha256:c482993ec177b026235d6cd0c61d4fb6d6f1088bc78bdc0e5964a5398de6dba0' || 'greptime-registry.cn-hangzhou.cr.aliyuncs.com/tools/o11ybench-runtime:77a84e1c8136@sha256:c482993ec177b026235d6cd0c61d4fb6d6f1088bc78bdc0e5964a5398de6dba0' }}
   PROVIDER: ${{ inputs.provider }}
   REQUESTED_INSTANCE_TYPE: ${{ inputs.instance_type }}
   SYSTEM_DISK_GIB: ${{ inputs.system_disk_gib }}
@@ -79,12 +122,18 @@ env:
   JANITOR_TTL_HOURS: ${{ inputs.janitor_ttl_hours }}
   DB_CPUS: ${{ inputs.db_cpus }}
   DB_MEMORY: ${{ inputs.db_memory }}
+  QUERY_TIMEOUT_SECONDS: ${{ inputs.query_timeout_seconds }}
+  LOAD_WORKERS: ${{ inputs.load_workers }}
 jobs:
   validate:
     runs-on: ubuntu-latest
     timeout-minutes: 15
     outputs:
       instance_type: ${{ steps.runner.outputs.instance_type }}
+      targets: ${{ steps.inputs.outputs.targets }}
+      greptimedb: ${{ steps.inputs.outputs.greptimedb }}
+      victoriatraces: ${{ steps.inputs.outputs.victoriatraces }}
+      tempo: ${{ steps.inputs.outputs.tempo }}
       system_disk_gib: ${{ steps.runtime.outputs.system_disk_gib }}
       runtime_image: ${{ steps.runtime.outputs.runtime_image }}
       o11ybench_ref: ${{ steps.runtime.outputs.o11ybench_ref }}
@@ -93,9 +142,44 @@ jobs:
       with:
         path: greptimedb
         persist-credentials: false
+    - name: Validate selected targets
+      id: inputs
+      env:
+        greptimedb: ${{ inputs.run_greptimedb }}
+        victoriatraces: ${{ inputs.run_victoriatraces }}
+        tempo: ${{ inputs.run_tempo }}
+      run: |
+        set -euo pipefail
+        selected=
+        for target in greptimedb victoriatraces tempo; do
+          enabled=${!target}
+          [[ "$enabled" == true || "$enabled" == false ]]
+          printf '%s=%s\n' "$target" "$enabled" >> "$GITHUB_OUTPUT"
+          if [[ "$enabled" == true ]]; then selected="${selected:+$selected,}$target"; fi
+        done
+        [[ -n "$selected" ]] || { echo 'Select at least one database' >&2; exit 1; }
+        if [[ "$greptimedb" == true ]]; then
+          [[ "$GREPTIMEDB_TAG" =~ ^[a-zA-Z0-9_][a-zA-Z0-9_.-]{0,127}$ ]] || { echo 'Invalid GreptimeDB image tag' >&2; exit 1; }
+        fi
+        printf 'targets=%s\n' "$selected" >> "$GITHUB_OUTPUT"
+    - name: Validate version comparison
+      env:
+        RUN_GREPTIMEDB: ${{ inputs.run_greptimedb }}
+      run: |
+        python3 greptimedb/tests/perf/test_benchmark_version_comparison.py
+        python3 greptimedb/.github/scripts/benchmark-version-comparison.py validate
     - name: Resolve CI runner
       id: runner
-      run: python3 greptimedb/.github/scripts/ci-runner-config.py --provider "$PROVIDER" --instance-type "$REQUESTED_INSTANCE_TYPE"
+      run: |
+        set -euo pipefail
+        instance_type="$REQUESTED_INSTANCE_TYPE"
+        if [[ "$instance_type" == auto ]]; then
+          case "$PROVIDER" in
+            Aliyun) instance_type=ecs.g9i.2xlarge ;;
+            AWS) instance_type=m7i.2xlarge ;;
+          esac
+        fi
+        python3 greptimedb/.github/scripts/ci-runner-config.py --provider "$PROVIDER" --instance-type "$instance_type"
     - name: Validate budgets and shared runtime
       id: runtime
       run: |
@@ -115,19 +199,38 @@ jobs:
         ((BENCHMARK_TIMEOUT_MINUTES <= 360 && JANITOR_TTL_HOURS <= 168))
         ((JANITOR_TTL_HOURS * 60 >= BENCHMARK_TIMEOUT_MINUTES + 120))
         [[ "$DB_CPUS" =~ ^[1-9][0-9]*$ && "$DB_MEMORY" =~ ^[1-9][0-9]*[mMgG]$ ]]
-        [[ "$RUNTIME_CPUS" =~ ^[1-9][0-9]*$ && "$RUNTIME_MEMORY" =~ ^[1-9][0-9]*[mMgG]$ ]]
-        [[ "$RUNTIME_IMAGE" == *.cr.aliyuncs.com/* ]]
-        docker pull "$RUNTIME_IMAGE"
+        [[ "$RUNTIME_CPUS" =~ ^(0|[1-9][0-9]*)$ && "$RUNTIME_MEMORY" =~ ^(0|[1-9][0-9]*[mMgG])$ ]]
+        [[ "$QUERY_TIMEOUT_SECONDS" =~ ^[1-9][0-9]{0,3}$ ]]
+        ((QUERY_TIMEOUT_SECONDS <= 3600))
+        [[ "$LOAD_WORKERS" =~ ^[1-9][0-9]{0,2}$ ]]
+        ((LOAD_WORKERS <= 256))
+        runtime_limits=()
+        [[ "$RUNTIME_CPUS" == 0 ]] || runtime_limits+=(--cpus "$RUNTIME_CPUS")
+        [[ "$RUNTIME_MEMORY" == 0 ]] || runtime_limits+=(--memory "$RUNTIME_MEMORY" --memory-swap "$RUNTIME_MEMORY")
+        [[ "$RUNTIME_IMAGE" == *.cr.aliyuncs.com/* || "$RUNTIME_IMAGE" == public.ecr.aws/* ]]
+        bash greptimedb/.github/scripts/pull-benchmark-image.sh "$RUNTIME_IMAGE"
         metadata=$(docker image inspect "$RUNTIME_IMAGE")
         resolved=$(jq -er '.[0].RepoDigests[0]' <<< "$metadata")
+        if [[ "$COMPARE_GREPTIMEDB" == true ]]; then
+          docker run --rm "$resolved" scripts/run_tracesbench_docker.py --help | grep -q -- '--data-root' \
+            || { echo 'Comparison requires a runtime with --data-root support'; exit 1; }
+        fi
         revision=$(jq -er '.[0].Config.Labels["org.opencontainers.image.revision"]' <<< "$metadata")
         [[ "$revision" =~ ^[0-9a-f]{40}$ ]]
         # Refuse runtimes without the trace runner and its validated dataset/report contract.
-        help=$(docker run --rm --cpus "$RUNTIME_CPUS" --memory "$RUNTIME_MEMORY" --memory-swap "$RUNTIME_MEMORY" "$resolved" scripts/run_tracesbench_docker.py --help)
+        help=$(docker run --rm "${runtime_limits[@]}" "$resolved" scripts/run_tracesbench_docker.py --help)
+        if [[ "$COMPARE_GREPTIMEDB" == true ]]; then
+          grep -F -- '--baseline-run' <<< "$help" \
+            || { echo 'Comparison requires a runtime with --baseline-run report support'; exit 1; }
+        fi
         grep -F -- '--dataset {sanity,preflight,main}' <<< "$help"
         grep -F -- '--runtime-cpus' <<< "$help"
         grep -F -- '--runtime-memory' <<< "$help"
-        docker run --rm --cpus "$RUNTIME_CPUS" --memory "$RUNTIME_MEMORY" --memory-swap "$RUNTIME_MEMORY" "$resolved" scripts/check_run_tracesbench_docker.py
+        grep -F -- '--query-timeout-seconds' <<< "$help"
+        grep -F -- '--load-workers' <<< "$help"
+        grep -F -- '--targets' <<< "$help"
+        grep -F -- '--greptimedb-image' <<< "$help"
+        docker run --rm "${runtime_limits[@]}" "$resolved" scripts/check_run_tracesbench_docker.py
         printf 'runtime_image=%s\no11ybench_ref=%s\nsystem_disk_gib=%s\n' "$resolved" "$revision" "$SYSTEM_DISK_GIB" >> "$GITHUB_OUTPUT"
   provision:
     needs: validate
@@ -190,6 +293,7 @@ jobs:
     runs-on: ${{ needs.provision.outputs.label }}
     timeout-minutes: ${{ fromJSON(format('{0}', inputs.benchmark_timeout_minutes)) }}
     env:
+      TARGETS: ${{ needs.validate.outputs.targets }}
       RESOLVED_RUNTIME_IMAGE: ${{ needs.validate.outputs.runtime_image }}
       RESOLVED_O11YBENCH_REF: ${{ needs.validate.outputs.o11ybench_ref }}
       RUN_ROOT: ${{ inputs.benchmark_root }}/tracesbench-${{ github.run_id }}-${{ github.run_attempt }}
@@ -224,36 +328,83 @@ jobs:
           available=$(df -Pk "$path" | awk 'NR == 2 {print $4}')
           ((available >= minimum_gib * 1024 * 1024)) || { echo "Need at least $minimum_gib GiB free on $path"; exit 1; }
         done
-        docker pull "$RESOLVED_RUNTIME_IMAGE"
+        bash greptimedb/.github/scripts/pull-benchmark-image.sh "$RESOLVED_RUNTIME_IMAGE"
         docker image inspect "$RESOLVED_RUNTIME_IMAGE" > "$METADATA_ROOT/runtime-image.json"
         test "$(jq -r '.[0].Config.Labels["org.opencontainers.image.revision"]' "$METADATA_ROOT/runtime-image.json")" = "$RESOLVED_O11YBENCH_REF"
-    # Preserve the pinned catalog images and require all three targets in the report.
+    - name: Pull database images before generating data
+      run: |
+        set -euo pipefail
+        IFS=, read -ra targets <<< "$TARGETS"
+        for target in "${targets[@]}"; do
+          if [[ "$target" == greptimedb ]]; then
+            image="greptime/greptimedb:$GREPTIMEDB_TAG"
+          else
+            image=$(jq -er '.target_identity.image | select(test("@sha256:[a-f0-9]{64}$"))' \
+              "o11ybench/workloads/tracesbench/catalogs/$target.json")
+          fi
+          bash greptimedb/.github/scripts/pull-benchmark-image.sh "$image"
+          docker image inspect "$image" > "$METADATA_ROOT/$target-image.json"
+          if [[ "$target" == greptimedb ]]; then
+            resolved=$(jq -er '.[0].RepoDigests[0] | select(test("@sha256:[a-f0-9]{64}$"))' "$METADATA_ROOT/$target-image.json")
+            printf 'GREPTIMEDB_IMAGE=%s\n' "$resolved" >> "$GITHUB_ENV"
+          fi
+        done
+        if [[ "$COMPARE_GREPTIMEDB" == true ]]; then
+          image="greptime/greptimedb:$BASELINE_GREPTIMEDB_TAG"
+          bash greptimedb/.github/scripts/pull-benchmark-image.sh "$image"
+          docker image inspect "$image" > "$METADATA_ROOT/greptimedb-baseline-image.json"
+          resolved=$(jq -er '.[0].RepoDigests[0] | select(test("@sha256:[a-f0-9]{64}$"))' "$METADATA_ROOT/greptimedb-baseline-image.json")
+          printf 'BASELINE_GREPTIMEDB_IMAGE=%s\n' "$resolved" >> "$GITHUB_ENV"
+        fi
     - name: Generate selected dataset once
+      id: generate
       run: |
         python3 o11ybench/scripts/run_tracesbench_docker.py --stage generate \
           --dataset "$DATASET" --runtime-cpus "$RUNTIME_CPUS" --runtime-memory "$RUNTIME_MEMORY" \
           --root "$RUN_ROOT" --owner "$OWNER" --runtime-image "$RESOLVED_RUNTIME_IMAGE"
-    - name: GreptimeDB load, correctness and benchmark
+    - name: Baseline GreptimeDB load, correctness and benchmark
+      if: ${{ !cancelled() && steps.generate.outcome == 'success' && needs.validate.outputs.greptimedb == 'true' && inputs.compare_greptimedb }}
       run: |
-        python3 o11ybench/scripts/run_tracesbench_docker.py --stage target --target greptimedb --port 14000 \
-          --db-cpus "$DB_CPUS" --db-memory "$DB_MEMORY" \
+        python3 o11ybench/scripts/run_tracesbench_docker.py --stage target --target greptimedb --port 14000 --greptimedb-image "$BASELINE_GREPTIMEDB_IMAGE" \
+          --db-cpus "$DB_CPUS" --db-memory "$DB_MEMORY" --query-timeout-seconds "$QUERY_TIMEOUT_SECONDS" --load-workers "$LOAD_WORKERS" \
+          --dataset "$DATASET" --runtime-cpus "$RUNTIME_CPUS" --runtime-memory "$RUNTIME_MEMORY" \
+          --root "$RUN_ROOT/baseline" --data-root "$RUN_ROOT" --owner "$OWNER-base" --runtime-image "$RESOLVED_RUNTIME_IMAGE"
+        python3 o11ybench/scripts/check_tracesbench_query_plans.py "$RUN_ROOT/baseline/runs/greptimedb"
+    - name: GreptimeDB load, correctness and benchmark
+      if: ${{ !cancelled() && steps.generate.outcome == 'success' && needs.validate.outputs.greptimedb == 'true' }}
+      run: |
+        python3 o11ybench/scripts/run_tracesbench_docker.py --stage target --target greptimedb --port 14000 --greptimedb-image "$GREPTIMEDB_IMAGE" \
+          --db-cpus "$DB_CPUS" --db-memory "$DB_MEMORY" --query-timeout-seconds "$QUERY_TIMEOUT_SECONDS" --load-workers "$LOAD_WORKERS" \
           --dataset "$DATASET" --runtime-cpus "$RUNTIME_CPUS" --runtime-memory "$RUNTIME_MEMORY" \
           --root "$RUN_ROOT" --owner "$OWNER" --runtime-image "$RESOLVED_RUNTIME_IMAGE"
+        python3 o11ybench/scripts/check_tracesbench_query_plans.py "$RUN_ROOT/runs/greptimedb"
     - name: VictoriaTraces load, correctness and benchmark
+      if: ${{ !cancelled() && steps.generate.outcome == 'success' && needs.validate.outputs.victoriatraces == 'true' }}
       run: |
         python3 o11ybench/scripts/run_tracesbench_docker.py --stage target --target victoriatraces --port 19428 \
-          --db-cpus "$DB_CPUS" --db-memory "$DB_MEMORY" \
+          --db-cpus "$DB_CPUS" --db-memory "$DB_MEMORY" --query-timeout-seconds "$QUERY_TIMEOUT_SECONDS" --load-workers "$LOAD_WORKERS" \
           --dataset "$DATASET" --runtime-cpus "$RUNTIME_CPUS" --runtime-memory "$RUNTIME_MEMORY" \
           --root "$RUN_ROOT" --owner "$OWNER" --runtime-image "$RESOLVED_RUNTIME_IMAGE"
     - name: Tempo load, correctness and benchmark
+      if: ${{ !cancelled() && steps.generate.outcome == 'success' && needs.validate.outputs.tempo == 'true' }}
       run: |
         python3 o11ybench/scripts/run_tracesbench_docker.py --stage target --target tempo --port 13200 \
-          --db-cpus "$DB_CPUS" --db-memory "$DB_MEMORY" \
+          --db-cpus "$DB_CPUS" --db-memory "$DB_MEMORY" --query-timeout-seconds "$QUERY_TIMEOUT_SECONDS" --load-workers "$LOAD_WORKERS" \
           --dataset "$DATASET" --runtime-cpus "$RUNTIME_CPUS" --runtime-memory "$RUNTIME_MEMORY" \
           --root "$RUN_ROOT" --owner "$OWNER" --runtime-image "$RESOLVED_RUNTIME_IMAGE"
-    - name: Validate and render report
+    - name: GreptimeDB version comparison
+      if: always() && inputs.compare_greptimedb
       run: |
-        python3 o11ybench/scripts/run_tracesbench_docker.py --stage report \
+        python3 greptimedb/.github/scripts/benchmark-version-comparison.py report --kind traces --root "$RUN_ROOT" >> "$GITHUB_STEP_SUMMARY"
+    - name: Validate and render report
+      env:
+        COMPARE_GREPTIMEDB: ${{ inputs.compare_greptimedb }}
+      run: |
+        comparison_args=()
+        if [[ "$COMPARE_GREPTIMEDB" == true ]]; then
+          comparison_args+=(--baseline-run "$RUN_ROOT/baseline/runs/greptimedb/run.json")
+        fi
+        python3 o11ybench/scripts/run_tracesbench_docker.py --stage report --targets "$TARGETS" "${comparison_args[@]}" \
           --dataset "$DATASET" --runtime-cpus "$RUNTIME_CPUS" --runtime-memory "$RUNTIME_MEMORY" \
           --root "$RUN_ROOT" --owner "$OWNER" --runtime-image "$RESOLVED_RUNTIME_IMAGE"
     - name: Clean up owned containers
@@ -262,6 +413,23 @@ jobs:
         python3 o11ybench/scripts/run_tracesbench_docker.py --stage cleanup \
           --dataset "$DATASET" --runtime-cpus "$RUNTIME_CPUS" --runtime-memory "$RUNTIME_MEMORY" \
           --root "$RUN_ROOT" --owner "$OWNER" --runtime-image "$RESOLVED_RUNTIME_IMAGE"
+    - name: Clean up baseline containers
+      if: always() && steps.runtime.outcome == 'success' && inputs.compare_greptimedb
+      run: |
+        python3 o11ybench/scripts/run_tracesbench_docker.py --stage cleanup \
+          --root "$RUN_ROOT/baseline" --owner "$OWNER-base" --runtime-image "$RESOLVED_RUNTIME_IMAGE"
+    - name: Benchmark summary
+      if: always()
+      run: python3 greptimedb/.github/scripts/tracesbench-summary.py --root "$RUN_ROOT" --targets "$TARGETS" --section benchmark >> "$GITHUB_STEP_SUMMARY"
+    - name: Load / lifecycle summary
+      if: always()
+      run: python3 greptimedb/.github/scripts/tracesbench-summary.py --root "$RUN_ROOT" --targets "$TARGETS" --section lifecycle >> "$GITHUB_STEP_SUMMARY"
+    - name: Baseline load / lifecycle summary
+      if: always() && inputs.compare_greptimedb
+      run: |
+        echo '## Baseline GreptimeDB' >> "$GITHUB_STEP_SUMMARY"
+        python3 greptimedb/.github/scripts/tracesbench-summary.py \
+          --root "$RUN_ROOT/baseline" --targets greptimedb --section lifecycle >> "$GITHUB_STEP_SUMMARY"
     - name: Stage benchmark artifacts
       if: always()
       run: |
@@ -269,11 +437,15 @@ jobs:
         if [[ -d "$METADATA_ROOT" ]]; then
           rsync -a --no-owner --no-group "$METADATA_ROOT" "$RUNNER_TEMP/tracesbench-artifacts/"
         fi
-        for entry in runs report report.json report.md; do
+        for entry in runs report report.json report.md version-comparison.json version-comparison.md; do
           if [[ -e "$RUN_ROOT/$entry" ]]; then
             rsync -a --no-owner --no-group "$RUN_ROOT/$entry" "$RUNNER_TEMP/tracesbench-artifacts/"
           fi
         done
+        if [[ -d "$RUN_ROOT/baseline/runs" ]]; then
+          mkdir -p "$RUNNER_TEMP/tracesbench-artifacts/baseline"
+          rsync -a --no-owner --no-group "$RUN_ROOT/baseline/runs" "$RUNNER_TEMP/tracesbench-artifacts/baseline/"
+        fi
     - name: Upload HTML and results (no corpus)
       if: always()
       uses: actions/upload-artifact@v4
diff --git a/.github/workflows/vmbench-long-range.yml b/.github/workflows/vmbench-long-range.yml
index 357d2b21c69..aaf2dd7f437 100644
--- a/.github/workflows/vmbench-long-range.yml
+++ b/.github/workflows/vmbench-long-range.yml
@@ -20,8 +20,18 @@ on:
         - 1mo
         default: 1w
         required: true
+      compare_greptimedb:
+        description: Compare baseline and candidate sequentially on the same host (adds one full GreptimeDB run)
+        type: boolean
+        default: false
+        required: false
+      baseline_greptimedb_tag:
+        description: Baseline Docker Hub greptime/greptimedb tag; required when comparison is enabled
+        type: string
+        default: v1.2.1
+        required: false
       greptimedb_tag:
-        description: Docker Hub greptime/greptimedb tag
+        description: Candidate Docker Hub greptime/greptimedb tag
         type: string
         default: latest
         required: true
@@ -31,9 +41,9 @@ on:
         default: v1.114.0@sha256:227ad53fd57a4b4430624898a1be0cac39431e1235fa0dc92f567cce38969344
         required: true
       runtime_image:
-        description: Aliyun runtime image (tag or digest reference)
+        description: 'Runtime image: auto = AWS ECR Public or Aliyun ACR by provider; explicit tag/digest overrides'
         type: string
-        default: greptime-registry.cn-hangzhou.cr.aliyuncs.com/tools/o11ybench-runtime:20260918-545dc570@sha256:0ff03e7e690575e875bb85b3054a03486dd9359073546dc715da177153cf7a29
+        default: auto
         required: true
       provider:
         description: Cloud provider for the benchmark runner
@@ -79,11 +89,13 @@ on:
 permissions:
   contents: read
 env:
+  COMPARE_GREPTIMEDB: ${{ inputs.compare_greptimedb }}
+  BASELINE_GREPTIMEDB_TAG: ${{ inputs.baseline_greptimedb_tag }}
   BENCHMARK_ROOT: ${{ inputs.benchmark_root }}
   RANGE_PRESET: ${{ inputs.range_preset }}
   GREPTIMEDB_TAG: ${{ inputs.greptimedb_tag }}
   VICTORIAMETRICS_TAG: ${{ inputs.victoriametrics_tag }}
-  RUNTIME_IMAGE: ${{ inputs.runtime_image }}
+  RUNTIME_IMAGE: ${{ inputs.runtime_image != 'auto' && inputs.runtime_image || inputs.provider == 'AWS' && 'public.ecr.aws/i8k6a5e1/greptime/o11ybenchruntime:b43785b56f42@sha256:e38811eb68caf3682ba56f5591a3e8e27e78e7983a923abb29fa2d7cd8fdbd46' || 'greptime-registry.cn-hangzhou.cr.aliyuncs.com/tools/o11ybench-runtime:b43785b56f42@sha256:e38811eb68caf3682ba56f5591a3e8e27e78e7983a923abb29fa2d7cd8fdbd46' }}
   PROVIDER: ${{ inputs.provider }}
   REQUESTED_INSTANCE_TYPE: ${{ inputs.instance_type }}
   SYSTEM_DISK_GIB: ${{ inputs.system_disk_gib }}
@@ -107,6 +119,12 @@ jobs:
       with:
         path: greptimedb
         persist-credentials: false
+    - name: Validate version comparison
+      env:
+        RUN_GREPTIMEDB: ${{ inputs.run_greptimedb }}
+      run: |
+        python3 greptimedb/tests/perf/test_benchmark_version_comparison.py
+        python3 greptimedb/.github/scripts/benchmark-version-comparison.py validate
     - name: Resolve CI runner
       id: runner
       run: python3 greptimedb/.github/scripts/ci-runner-config.py --provider "$PROVIDER" --instance-type "$REQUESTED_INSTANCE_TYPE"
@@ -135,8 +153,8 @@ jobs:
         ((BENCHMARK_TIMEOUT_MINUTES <= 360 && JANITOR_TTL_HOURS <= 168))
         # Match the existing ECS workflow's provision, teardown and queue headroom.
         ((JANITOR_TTL_HOURS * 60 >= BENCHMARK_TIMEOUT_MINUTES + 120))
-        [[ "$RUNTIME_IMAGE" == *.cr.aliyuncs.com/* ]]
-        docker pull "$RUNTIME_IMAGE"
+        [[ "$RUNTIME_IMAGE" == *.cr.aliyuncs.com/* || "$RUNTIME_IMAGE" == public.ecr.aws/* ]]
+        bash greptimedb/.github/scripts/pull-benchmark-image.sh "$RUNTIME_IMAGE"
         metadata=$(docker image inspect "$RUNTIME_IMAGE")
         resolved=$(jq -er '.[0].RepoDigests[0]' <<< "$metadata")
         revision=$(jq -er '.[0].Config.Labels["org.opencontainers.image.revision"]' <<< "$metadata")
@@ -146,6 +164,9 @@ jobs:
         args=(--workload vmbench-long-range --range-preset "$RANGE_PRESET"
           --db-cpus "$DB_CPUS" --db-memory "$DB_MEMORY"
           --run-classification controlled_server_benchmark --no-open-browser)
+        if [[ "$COMPARE_GREPTIMEDB" == true ]]; then
+          args+=(--target "greptimedb:name=greptimedb-baseline,image=greptime/greptimedb:$BASELINE_GREPTIMEDB_TAG,url=http://127.0.0.1:14000/v1/prometheus/api/v1/query_range")
+        fi
         # Tags become target-spec fields; reject separators before passing them to the planner.
         for target in greptimedb victoriametrics; do
           case "$target" in
@@ -273,13 +294,13 @@ jobs:
           available=$(df -Pk "$path" | awk 'NR == 2 {print $4}')
           ((available >= 10 * 1024 * 1024)) || { echo "Need at least 10 GiB free on $path"; exit 1; }
         done
-        docker pull "$RESOLVED_RUNTIME_IMAGE"
+        bash greptimedb/.github/scripts/pull-benchmark-image.sh "$RESOLVED_RUNTIME_IMAGE"
         docker image inspect "$RESOLVED_RUNTIME_IMAGE" > "$METADATA_ROOT/runtime-image.json"
         test "$(jq -r '.[0].Config.Labels["org.opencontainers.image.revision"]' "$METADATA_ROOT/runtime-image.json")" = "$RESOLVED_O11YBENCH_REF"
         plan="$METADATA_ROOT/warm.json"
         while IFS=$'\t' read -r target reference; do
           echo "Resolving $target: $reference"
-          docker pull "$reference"
+          bash greptimedb/.github/scripts/pull-benchmark-image.sh "$reference"
           docker image inspect "$reference" > "$METADATA_ROOT/$target-image.json"
           digest=$(jq -er '.[0].RepoDigests[0]' "$METADATA_ROOT/$target-image.json")
           jq --arg target "$target" --arg image "$digest" '.targets |= map(if .name == $target then .image = $image else . end)' "$plan" > "$plan.tmp"
@@ -303,6 +324,10 @@ jobs:
       if: always()
       run: |
         docker ps -aq --filter "label=o11ybench.run-id=$RUN_ID-warm" | xargs -r docker rm -fv
+    - name: GreptimeDB version comparison
+      if: always() && inputs.compare_greptimedb
+      run: |
+        python3 greptimedb/.github/scripts/benchmark-version-comparison.py report --kind long-range --root "$ARTIFACT_ROOT-warm" >> "$GITHUB_STEP_SUMMARY"
     - name: Stage benchmark artifacts
       if: always()
       run: |
diff --git a/Cargo.lock b/Cargo.lock
index 51a2a905a40..cbd87363918 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -230,7 +230,7 @@ checksum = "d301b3b94cb4b2f23d7917810addbbaff90738e0ca2be692bd027e70d7e0330c"
 
 [[package]]
 name = "api"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "arrow-schema 59.2.0",
  "common-base",
@@ -959,7 +959,7 @@ checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
 name = "auth"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "async-trait",
@@ -1618,7 +1618,7 @@ dependencies = [
 
 [[package]]
 name = "cache"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "catalog",
  "common-error",
@@ -1684,7 +1684,7 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "catalog"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "arrow 59.2.0",
@@ -2040,7 +2040,7 @@ checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675"
 
 [[package]]
 name = "cli"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -2095,7 +2095,7 @@ dependencies = [
 
 [[package]]
 name = "client"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "arc-swap",
@@ -2127,10 +2127,11 @@ dependencies = [
  "serde_json",
  "snafu 0.8.6",
  "store-api",
- "substrait 1.3.0-beta.1",
+ "substrait 1.3.0-beta.2",
  "tokio",
  "tokio-stream",
  "tonic 0.14.2",
+ "tonic-prost",
 ]
 
 [[package]]
@@ -2175,7 +2176,7 @@ dependencies = [
 
 [[package]]
 name = "cmd"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "async-trait",
@@ -2311,7 +2312,7 @@ dependencies = [
 
 [[package]]
 name = "common-base"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "ahash 0.8.12",
  "anymap2",
@@ -2320,6 +2321,7 @@ dependencies = [
  "bytes",
  "common-test-util",
  "futures",
+ "icu_properties",
  "lazy_static",
  "pin-project",
  "regex",
@@ -2332,7 +2334,7 @@ dependencies = [
 
 [[package]]
 name = "common-batcher"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "dashmap",
  "futures",
@@ -2341,14 +2343,14 @@ dependencies = [
 
 [[package]]
 name = "common-catalog"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "const_format",
 ]
 
 [[package]]
 name = "common-config"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "common-base",
  "common-error",
@@ -2371,7 +2373,7 @@ dependencies = [
 
 [[package]]
 name = "common-datasource"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "arrow 59.2.0",
  "arrow-schema 59.2.0",
@@ -2408,7 +2410,7 @@ dependencies = [
 
 [[package]]
 name = "common-decimal"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "bigdecimal 0.4.8",
  "common-error",
@@ -2421,7 +2423,7 @@ dependencies = [
 
 [[package]]
 name = "common-error"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "common-macro",
  "http 1.5.0",
@@ -2433,7 +2435,7 @@ dependencies = [
 
 [[package]]
 name = "common-event-recorder"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "async-trait",
@@ -2458,7 +2460,7 @@ dependencies = [
 
 [[package]]
 name = "common-frontend"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "async-trait",
@@ -2477,7 +2479,7 @@ dependencies = [
 
 [[package]]
 name = "common-function"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "ahash 0.8.12",
  "api",
@@ -2513,7 +2515,6 @@ dependencies = [
  "geohash",
  "h3o",
  "hyperloglogplus",
- "icu_properties",
  "jsonb",
  "memchr",
  "mito-codec",
@@ -2539,7 +2540,7 @@ dependencies = [
 
 [[package]]
 name = "common-greptimedb-telemetry"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "async-trait",
  "common-runtime",
@@ -2556,7 +2557,7 @@ dependencies = [
 
 [[package]]
 name = "common-grpc"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "arrow-flight",
@@ -2591,7 +2592,7 @@ dependencies = [
 
 [[package]]
 name = "common-grpc-expr"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "common-catalog",
@@ -2609,7 +2610,7 @@ dependencies = [
 
 [[package]]
 name = "common-macro"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "greptime-proto",
  "once_cell",
@@ -2620,7 +2621,7 @@ dependencies = [
 
 [[package]]
 name = "common-mem-prof"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "anyhow",
  "common-error",
@@ -2636,7 +2637,7 @@ dependencies = [
 
 [[package]]
 name = "common-memory-manager"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "common-error",
  "common-macro",
@@ -2648,7 +2649,7 @@ dependencies = [
 
 [[package]]
 name = "common-meta"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "anymap2",
  "api",
@@ -2719,7 +2720,7 @@ dependencies = [
 
 [[package]]
 name = "common-options"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "common-base",
  "common-grpc",
@@ -2730,11 +2731,11 @@ dependencies = [
 
 [[package]]
 name = "common-plugins"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 
 [[package]]
 name = "common-pprof"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "common-error",
  "common-macro",
@@ -2745,7 +2746,7 @@ dependencies = [
 
 [[package]]
 name = "common-procedure"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "async-stream",
@@ -2774,7 +2775,7 @@ dependencies = [
 
 [[package]]
 name = "common-procedure-test"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "async-trait",
  "common-procedure",
@@ -2783,7 +2784,7 @@ dependencies = [
 
 [[package]]
 name = "common-query"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "async-trait",
@@ -2813,7 +2814,7 @@ dependencies = [
 
 [[package]]
 name = "common-recordbatch"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "arc-swap",
  "common-base",
@@ -2838,7 +2839,7 @@ dependencies = [
 
 [[package]]
 name = "common-runtime"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "async-trait",
  "catio",
@@ -2866,7 +2867,7 @@ dependencies = [
 
 [[package]]
 name = "common-session"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "serde",
  "strum 0.27.1",
@@ -2874,7 +2875,7 @@ dependencies = [
 
 [[package]]
 name = "common-sql"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "arrow-schema 59.2.0",
  "common-base",
@@ -2893,7 +2894,7 @@ dependencies = [
 
 [[package]]
 name = "common-stat"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "common-base",
  "common-runtime",
@@ -2907,7 +2908,7 @@ dependencies = [
 
 [[package]]
 name = "common-telemetry"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "backtrace",
  "common-base",
@@ -2937,7 +2938,7 @@ dependencies = [
 
 [[package]]
 name = "common-test-util"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "common-grpc",
  "common-query",
@@ -2949,7 +2950,7 @@ dependencies = [
 
 [[package]]
 name = "common-time"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "arrow 59.2.0",
  "chrono",
@@ -2967,7 +2968,7 @@ dependencies = [
 
 [[package]]
 name = "common-version"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "cargo-manifest",
  "const_format",
@@ -2977,7 +2978,7 @@ dependencies = [
 
 [[package]]
 name = "common-wal"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "common-base",
  "common-error",
@@ -3000,7 +3001,7 @@ dependencies = [
 
 [[package]]
 name = "common-workload"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "common-telemetry",
  "serde",
@@ -4473,7 +4474,7 @@ dependencies = [
 
 [[package]]
 name = "datanode"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "arrow-flight",
@@ -4546,7 +4547,7 @@ checksum = "c286de4e81ea2590afc24d754e0f83810c566f50a1388fa75ebd57928c0d9745"
 
 [[package]]
 name = "datatypes"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "arrow 59.2.0",
  "arrow-array 59.2.0",
@@ -5278,7 +5279,7 @@ checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "file-engine"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "async-trait",
@@ -5419,7 +5420,7 @@ checksum = "8bf7cc16383c4b8d58b9905a8509f02926ce3058053c056376248d958c9df1e8"
 
 [[package]]
 name = "flow"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "arrow 59.2.0",
@@ -5471,7 +5472,7 @@ dependencies = [
  "snafu 0.8.6",
  "sql",
  "store-api",
- "substrait 1.3.0-beta.1",
+ "substrait 1.3.0-beta.2",
  "table",
  "tokio",
  "tokio-stream",
@@ -5568,7 +5569,7 @@ dependencies = [
 
 [[package]]
 name = "frontend"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "arrow-flight",
@@ -6946,7 +6947,7 @@ dependencies = [
 
 [[package]]
 name = "index"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "ahash 0.8.12",
  "async-trait",
@@ -6965,8 +6966,6 @@ dependencies = [
  "futures",
  "greptime-proto",
  "itertools 0.14.0",
- "jieba-rs",
- "lazy_static",
  "mockall",
  "pin-project",
  "prost 0.14.1",
@@ -8097,7 +8096,7 @@ checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
 
 [[package]]
 name = "log-query"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "chrono",
  "common-error",
@@ -8109,7 +8108,7 @@ dependencies = [
 
 [[package]]
 name = "log-store"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -8461,7 +8460,7 @@ dependencies = [
 
 [[package]]
 name = "meta-client"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "async-trait",
@@ -8490,7 +8489,7 @@ dependencies = [
 
 [[package]]
 name = "meta-srv"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "async-trait",
@@ -8581,7 +8580,7 @@ dependencies = [
 
 [[package]]
 name = "metric-engine"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "aquamarine",
@@ -8681,7 +8680,7 @@ dependencies = [
 
 [[package]]
 name = "mito-codec"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "bytes",
@@ -8706,7 +8705,7 @@ dependencies = [
 
 [[package]]
 name = "mito2"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "aquamarine",
@@ -9549,7 +9548,7 @@ dependencies = [
 
 [[package]]
 name = "object-store"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "anyhow",
  "bytes",
@@ -9695,9 +9694,9 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
 [[package]]
 name = "opendal"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fe43e16d96bed57937eb7c4a28559bf4c5fc4a3951656505d1fdd4f856349b4"
+checksum = "3cbd193aec6d62efaff87611dfae52c132aed650bb3cb0c684c0a9394f09a42a"
 dependencies = [
  "ctor",
  "opendal-core",
@@ -9720,9 +9719,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-core"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de4566a412776e3f65d53dd9fceced5b432a0a9c9a1e8d50ccf58823795e5c5b"
+checksum = "54b5555d753dd6a6383dc0891254b72f3cdc40c011ba0372b560e0ae5aa29f5c"
 dependencies = [
  "anyhow",
  "asyncband",
@@ -9746,9 +9745,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-http-transport-reqwest"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f772ce6c137ab43647726116d505a649a88d41928fcd813438eb30b02312bcbb"
+checksum = "4d6588678f3040a3eab1819364dcbc6a746a8286d1ceb23a70a6614faa01dc6c"
 dependencies = [
  "bytes",
  "futures",
@@ -9760,9 +9759,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-layer-concurrent-limit"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3734c648617e5ad724d49175dde8323550624f9614f50e9e81b7aafae30b1734"
+checksum = "db8574309e68bf6d49c5378eaef9d0b3f6786971650b061c69e808254d71cb05"
 dependencies = [
  "asyncband",
  "futures",
@@ -9772,9 +9771,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-layer-logging"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a8daab5a91eac76f94516e7c71e677195c9221840ce8f5e71815e3fc8207742"
+checksum = "4ad43246d2cb7b7ad32b10e22bfa7b6ced8a6677cb6d6f005ae7e1d94cb19c6a"
 dependencies = [
  "log",
  "opendal-core",
@@ -9782,9 +9781,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-layer-observe-metrics-common"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fbe664be117c293cfa3980a0d2fc238bbb38eae5f6c191f376e88ccb830d26b"
+checksum = "3b8bc97d5a00eb41d50f1f6077c4bd5396c1eefea495614084ee9a37202ae06d"
 dependencies = [
  "futures",
  "http 1.5.0",
@@ -9793,9 +9792,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-layer-prometheus"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b32078d8248555ee6271332ec480b78306a44f0d902ea4721ccac00d9b866a21"
+checksum = "404e766cc2e4e4c9225ce08605ae151f768a05a41a448a235e016b1aea9ff98f"
 dependencies = [
  "opendal-core",
  "opendal-layer-observe-metrics-common",
@@ -9804,9 +9803,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-layer-retry"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb8e22cb1f86ef9af771a8947d3ccf380c8f5b76236f628314dd41c9ba73331a"
+checksum = "4aeb54be4940c68609483591934a813f7bdd97d747826783a393914d3139e363"
 dependencies = [
  "backon",
  "log",
@@ -9815,9 +9814,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-layer-timeout"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08ac6c77fe0d1b18e0064a02c19b98dbebcab78bf5e7753ad1f3abbc18850ff4"
+checksum = "1d11d53e67473e8914eacb2e14d586779ae57e1a84759ad25232ef339db77d8a"
 dependencies = [
  "opendal-core",
  "tokio",
@@ -9825,9 +9824,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-layer-tracing"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "603807927a799ea981f62a3b0012e17181e39f468793b78ca8bedda66d19813c"
+checksum = "bbe2ebfc795bf08da77d20bed13d149b478cc8e5002df44d237e460134f00be4"
 dependencies = [
  "futures",
  "http 1.5.0",
@@ -9837,9 +9836,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-service-azblob"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6cf31b02e7b44191d97c07254eea109b5da9c17210a29e478c8d0dc26dffb1f"
+checksum = "c32c3fc2e507c854ce53615b28fc2208f5e00cbe456c4d344ffdfbf4c9cb976d"
 dependencies = [
  "base64 0.23.1",
  "bytes",
@@ -9858,9 +9857,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-service-azure-common"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8107324c3f3cb9970fe20526c2c341b7c5769acbd4699bab73bd525f5fd63d62"
+checksum = "cc93c30bd347a36d93fd46d47f3e2bb6494dcf9458938aa501fe046ff8f7562f"
 dependencies = [
  "http 1.5.0",
  "opendal-core",
@@ -9868,9 +9867,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-service-fs"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0e7d8974aebd33be899200c9d0d50b2141fd5fa5c462b29e20653e3ddbfe339"
+checksum = "ec5c16fe91b77c0364f66546a1c32b2999e9c3c3c75c2e908a282268e0890bac"
 dependencies = [
  "bytes",
  "log",
@@ -9882,9 +9881,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-service-gcs"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d80eca6f9227bdf65d43e5b8d5fe75dca8cfab1da07571442a0420400847bea"
+checksum = "e1b5e42c6606ea1e37fa9cdedf07dc998073a45eb5044317c0fa6f3153e98d6e"
 dependencies = [
  "async-trait",
  "bytes",
@@ -9904,9 +9903,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-service-hdfs-native"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b84340e11a3bcd7f1f0b55df032d040b2907483c546c3021485aba749c3072c"
+checksum = "20fb97b2ac06a87e6720f0f93d5107ac046117deb8ac957030b0962ba4ecc3c5"
 dependencies = [
  "bytes",
  "futures",
@@ -9918,9 +9917,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-service-http"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ac1553d6b57ca79e200e5c7ded9ab708f2016dadb28ede0f2da71e02fd0b960"
+checksum = "65fdde60d1abf14e47eaf19360c08ea1b89c14f03769db448e016781c2e0e32b"
 dependencies = [
  "http 1.5.0",
  "log",
@@ -9930,9 +9929,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-service-mysql"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e15592be32b105cd152ab398b3db847e22c8c5f230d9b34ff095ea3d0dc6fd97"
+checksum = "9ba30e2a0b38aa55579b69bf57f607df7aa613f4d964496407b7998f2dbaefcc"
 dependencies = [
  "asyncband",
  "opendal-core",
@@ -9942,9 +9941,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-service-oss"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0ebfa355b1d4edb0e5b2a5b86d8de9f811fae1d7baca6d65246b230b2afc0bd"
+checksum = "d64d2909b444008e42f00137a50df6b55ba599eeb6c8b46c71a2a84948f91880"
 dependencies = [
  "bytes",
  "http 1.5.0",
@@ -9959,9 +9958,9 @@ dependencies = [
 
 [[package]]
 name = "opendal-service-s3"
-version = "0.59.2"
+version = "0.59.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2942f2d8d3d4953c0e8d07cd1244879628d084948e48ce6b6d808c5938f7858d"
+checksum = "1d83e716c25a81fe2ca701894b8e14b9966acca3812af250e50132accb19da02"
 dependencies = [
  "base64 0.23.1",
  "bytes",
@@ -9981,7 +9980,7 @@ dependencies = [
 [[package]]
 name = "opensrv-mysql"
 version = "0.8.0"
-source = "git+https://github.com/GreptimeTeam/opensrv?rev=f3135e5f00401e06075cf241c0cc26489e45b20a#f3135e5f00401e06075cf241c0cc26489e45b20a"
+source = "git+https://github.com/GreptimeTeam/opensrv?rev=1f3d88ccaafb5721be6cfcc3ccbca48642426119#1f3d88ccaafb5721be6cfcc3ccbca48642426119"
 dependencies = [
  "async-trait",
  "byteorder",
@@ -10094,7 +10093,7 @@ dependencies = [
 
 [[package]]
 name = "operator"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "ahash 0.8.12",
  "api",
@@ -10102,7 +10101,9 @@ dependencies = [
  "async-stream",
  "async-trait",
  "axum 0.8.4",
+ "backon",
  "bytes",
+ "cache",
  "catalog",
  "chrono",
  "client",
@@ -10133,12 +10134,14 @@ dependencies = [
  "futures",
  "futures-util",
  "humantime",
+ "humantime-serde",
  "itertools 0.14.0",
  "jsonb",
  "lazy_static",
  "meta-client",
  "meter-core",
  "meter-macros",
+ "mito-codec",
  "moka",
  "object-store",
  "partition",
@@ -10156,9 +10159,10 @@ dependencies = [
  "sql",
  "sqlparser",
  "store-api",
- "substrait 1.3.0-beta.1",
+ "substrait 1.3.0-beta.2",
  "table",
  "tokio",
+ "tokio-stream",
  "tokio-util",
  "tonic 0.14.2",
  "tracing",
@@ -10490,7 +10494,7 @@ checksum = "e3c406c9e2aa74554e662d2c2ee11cd3e73756988800be7e6f5eddb16fed4699"
 
 [[package]]
 name = "partition"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "common-base",
@@ -10884,7 +10888,7 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "pipeline"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "ahash 0.8.12",
  "api",
@@ -11039,7 +11043,7 @@ dependencies = [
 
 [[package]]
 name = "plugins"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "auth",
  "catalog",
@@ -11382,7 +11386,7 @@ dependencies = [
 
 [[package]]
 name = "promql"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "ahash 0.8.12",
  "async-trait",
@@ -11799,7 +11803,7 @@ dependencies = [
 
 [[package]]
 name = "puffin"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "async-compression",
  "async-trait",
@@ -11851,7 +11855,7 @@ dependencies = [
 
 [[package]]
 name = "query"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "ahash 0.8.12",
  "api",
@@ -11918,7 +11922,7 @@ dependencies = [
  "sql",
  "sqlparser",
  "store-api",
- "substrait 1.3.0-beta.1",
+ "substrait 1.3.0-beta.2",
  "table",
  "tokio",
  "toml 0.8.23",
@@ -13533,7 +13537,7 @@ dependencies = [
 
 [[package]]
 name = "servers"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "ahash 0.8.12",
  "api",
@@ -13676,7 +13680,7 @@ dependencies = [
 
 [[package]]
 name = "session"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "ahash 0.8.12",
  "api",
@@ -14036,7 +14040,7 @@ dependencies = [
 
 [[package]]
 name = "sql"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "arrow-buffer 59.2.0",
@@ -14091,7 +14095,7 @@ dependencies = [
 
 [[package]]
 name = "sqlness-runner"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "async-trait",
  "clap",
@@ -14370,7 +14374,7 @@ dependencies = [
 
 [[package]]
 name = "standalone"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "async-trait",
@@ -14420,7 +14424,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "store-api"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "aquamarine",
@@ -14612,7 +14616,7 @@ dependencies = [
 
 [[package]]
 name = "substrait"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "async-trait",
  "bytes",
@@ -14748,7 +14752,7 @@ dependencies = [
 
 [[package]]
 name = "table"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "arc-swap",
@@ -15028,7 +15032,7 @@ checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
 
 [[package]]
 name = "tests-fuzz"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "arbitrary",
  "async-trait",
@@ -15076,7 +15080,7 @@ dependencies = [
 
 [[package]]
 name = "tests-integration"
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 dependencies = [
  "api",
  "arrow-flight",
@@ -15155,7 +15159,7 @@ dependencies = [
  "sqlx",
  "standalone",
  "store-api",
- "substrait 1.3.0-beta.1",
+ "substrait 1.3.0-beta.2",
  "table",
  "tempfile",
  "time",
diff --git a/Cargo.toml b/Cargo.toml
index 1901ae52767..c002d2c7a18 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -76,7 +76,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "1.3.0-beta.1"
+version = "1.3.0-beta.2"
 edition = "2024"
 license = "Apache-2.0"
 
@@ -271,6 +271,7 @@ url = "2.3"
 # Pin below 0.14.5 to avoid the `connection_timeout_future` "async fn resumed after
 # completion" panic (greptimedb#8265 / grpc-rust#2522). Remove once tonic ships a fix.
 tonic = { version = "0.14, <0.14.5", features = ["tls-aws-lc", "gzip", "zstd"] }
+tonic-prost = "0.14"
 tower = "0.5"
 tracing = "0.1"
 tracing-appender = "0.2"
diff --git a/Makefile b/Makefile
index 9144432b66d..7f92098262f 100644
--- a/Makefile
+++ b/Makefile
@@ -10,7 +10,7 @@ CARGO_BUILD_OPTS := --locked
 IMAGE_REGISTRY ?= docker.io
 IMAGE_NAMESPACE ?= greptime
 IMAGE_TAG ?= latest
-DEV_BUILDER_IMAGE_TAG ?= 1.96.1-822042c7-20260924091315
+DEV_BUILDER_IMAGE_TAG ?= 1.98.1-7f0f592b-20261008091949
 DEV_BUILDER_RISCV64_IMAGE_TAG ?= $(DEV_BUILDER_IMAGE_TAG)
 DEV_BUILDER_RISCV64_BASE_IMAGE ?= ubuntu:22.04
 RISCV64_TARGET ?= riscv64gc-unknown-linux-gnu
diff --git a/config/config.md b/config/config.md
index 29f2d6d2c56..dbd72b5fb1c 100644
--- a/config/config.md
+++ b/config/config.md
@@ -16,17 +16,16 @@
 | `default_column_prefix` | String | Unset | The default column prefix for auto-created time index, value, and native histogram columns.<br/>Legacy OTLP summary columns keep their historical `greptime_` prefix. |
 | `auto_create_table` | Bool | `true` | Server-side global switch for auto table creation on write.<br/>When `false`, a missing table is never auto-created even if the request sets the `auto_create_table` hint to `true`. Default: `true`. |
 | `experimental_metric_export` | Bool | `false` | Enables experimental Parquet COPY DATABASE using shared Metric physical scans.<br/>Resume requires the previous export and storage writes to have ended; HTTP timeout is not confirmation. |
-| `user_provider` | String | Unset | The user provider for authentication.<br/>Examples: "static_user_provider:file:/path/to/users", "static_user_provider:cmd:greptime_user=greptime_pwd"<br/>Password verifier formats: "plain:<password>", "pbkdf2_sha256:<iterations>:<hex_salt>:<hex_hash>",<br/>"mysql_native_password:<hex_sha1_sha1_password>",<br/>"pg_scram_sha256:<iterations>:<hex_salt>:<hex_stored_key>:<hex_server_key>"<br/>"pbkdf2_sha256" and "pg_scram_sha256" protect passwords at rest, but cannot authenticate over MySQL's<br/>native password handshake; a MySQL client must send the password in cleartext for such users.<br/>"mysql_native_password" is MySQL-specific and cannot authenticate over PostgreSQL at all.<br/>PostgreSQL SCRAM only covers "plain" and "pg_scram_sha256" users; if any user is "pbkdf2_sha256" or<br/>"mysql_native_password", PostgreSQL falls back to cleartext password auth for every user.<br/>For "pg_scram_sha256" users, keep the default iteration count (4096) and salt length (16): both are<br/>observable in the SCRAM server-first message, and non-default values weaken resistance to username<br/>enumeration. |
-| `max_in_flight_write_bytes` | String | Unset | Maximum total memory for all concurrent write request bodies and messages (HTTP, gRPC, Flight).<br/>Set to 0 to disable the limit. Default: "0" (unlimited) |
-| `write_bytes_exhausted_policy` | String | Unset | Policy when write bytes quota is exhausted.<br/>Options: "wait" (default, 10s timeout), "wait(<duration>)" (e.g., "wait(30s)"), "fail" |
+| `user_provider` | String | Unset | The user provider for authentication.<br/>Examples: "static_user_provider:file:/path/to/users", "static_user_provider:cmd:greptime_user=greptime_pwd"<br/>Password verifier formats: "plain:<password>", "pbkdf2_sha256:<iterations>:<hex_salt>:<hex_hash>",<br/>"mysql_native_password:<hex_sha1_sha1_password>",<br/>"pg_scram_sha256:<iterations>:<hex_salt>:<hex_stored_key>:<hex_server_key>"<br/>"pbkdf2_sha256" and "pg_scram_sha256" protect passwords at rest, but such users cannot log in over MySQL:<br/>`static_user_provider` and `watch_file_user_provider` only negotiate `mysql_native_password`, which cannot verify these formats.<br/>"mysql_native_password" is MySQL-specific and cannot authenticate over PostgreSQL at all.<br/>PostgreSQL SCRAM only covers "plain" and "pg_scram_sha256" users; if any user is "pbkdf2_sha256" or<br/>"mysql_native_password", PostgreSQL falls back to cleartext password auth for every user.<br/>For "pg_scram_sha256" users, keep the default iteration count (4096) and salt length (16): both are<br/>observable in the SCRAM server-first message, and non-default values weaken resistance to username<br/>enumeration. |
+| `max_in_flight_write_bytes` | String | 0 | Maximum total memory for all concurrent write request bodies and messages (HTTP, gRPC, Flight).<br/>Set to 0 to disable the limit. Default: "0" (unlimited) |
+| `write_bytes_exhausted_policy` | String | `wait` | Policy when write bytes quota is exhausted.<br/>Options: "wait" (default, 10s timeout), "wait(<duration>)" (e.g., "wait(30s)"), "fail" |
 | `init_regions_in_background` | Bool | `false` | Initialize all regions in the background during the startup.<br/>By default, it provides services after all regions have been initialized. |
 | `init_regions_parallelism` | Integer | `16` | Parallelism of initializing regions. |
-| `max_concurrent_queries` | Integer | `0` | The maximum concurrent queries allowed to be executed. Zero means unlimited. |
 | `enable_telemetry` | Bool | `true` | Enable telemetry to collect anonymous usage data. Enabled by default. |
 | `runtime` | -- | -- | The runtime options. |
-| `runtime.global_rt_size` | Integer | `8` | The number of threads to execute the runtime for global read operations. |
-| `runtime.compact_rt_size` | Integer | `4` | The number of threads to execute compact operations. |
-| `runtime.compact_rt_max_blocking_threads` | Integer | `4` | The maximum number of blocking threads for compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
+| `runtime.global_rt_size` | Integer | Auto | The number of threads to execute the runtime for global read operations.<br/>Defaults to max(num_cpus, 2). |
+| `runtime.compact_rt_size` | Integer | Auto | The number of threads to execute compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
+| `runtime.compact_rt_max_blocking_threads` | Integer | Auto | The maximum number of blocking threads for compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
 | `runtime.experimental_workload_scheduler` | -- | -- | Experimental weighted, work-conserving query/write task scheduler. |
 | `runtime.experimental_workload_scheduler.enable` | Bool | `false` | Enable when concurrent queries and writes interfere with each other—for example, when long-running queries increase ingestion latency.<br/>The weights set their relative runtime shares while both are backlogged. Disabled by default. |
 | `runtime.experimental_workload_scheduler.query_weight` | Integer | `2` | Relative query share while both query and write workloads are backlogged. |
@@ -110,7 +109,7 @@
 | `wal.enable_log_recycle` | Bool | `true` | Whether to reuse logically truncated log files.<br/>**It's only used when the provider is `raft_engine`**. |
 | `wal.prefill_log_files` | Bool | `false` | Whether to pre-create log files on start up.<br/>**It's only used when the provider is `raft_engine`**. |
 | `wal.sync_period` | String | `5s` | Duration for fsyncing log files.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.recovery_parallelism` | Integer | `2` | Parallelism during WAL recovery. |
+| `wal.recovery_parallelism` | Integer | Auto | Parallelism during WAL recovery. Defaults to the number of CPU cores; this example sets it to 2. |
 | `wal.broker_endpoints` | Array | -- | The Kafka broker endpoints.<br/>**It's only used when the provider is `kafka`**. |
 | `wal.connect_timeout` | String | `3s` | The connect timeout for kafka client.<br/>**It's only used when the provider is `kafka`**. |
 | `wal.timeout` | String | `5s` | The total request timeout for kafka client.<br/>**It's only used when the provider is `kafka`**. |
@@ -140,7 +139,7 @@
 | `procedure.max_running_procedures` | Integer | `128` | Max running procedures.<br/>The maximum number of procedures that can be running at the same time.<br/>If the number of running procedures exceeds this limit, the procedure will be rejected. |
 | `query` | -- | -- | The query engine options. |
 | `query.parallelism` | Integer | `0` | Parallelism of the query engine.<br/>Default to 0, which means the number of CPU cores. |
-| `query.memory_pool_size` | String | `50%` | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "2GB", "4GB") or percentage of system memory (e.g., "20%").<br/>Setting it to 0 disables the limit (unbounded, default behavior).<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans. |
+| `query.memory_pool_size` | String | 0 | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "2GB", "4GB") or percentage of system memory (e.g., "20%").<br/>Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans. |
 | `query.experimental_memory_pool_policy` | String | `greedy` | Experimental memory pool allocation policy:<br/>- "greedy" (default): first-come-first-served allocation; preserves current behavior.<br/>- "fair": divides available memory among spillable operators and may spill earlier.<br/>Only effective when `memory_pool_size` is bounded (>0). |
 | `query.experimental_spill_mode` | String | `default` | Spill mode:<br/>- "default": preserve DataFusion built-in OS temp directory (default).<br/>- "custom": explicitly configure spill path, quota, and compression.<br/>- "disabled": explicitly disable disk spilling.<br/>Set this to "custom" before using the path/quota/compression keys below. |
 | `query.experimental_spill_path` | String | Unset | Spill directory path. Ignored unless mode is "custom". |
@@ -174,7 +173,7 @@
 | `storage.http_client.skip_ssl_validation` | Bool | `false` | To skip the ssl verification<br/>**Security Notice**: Setting `skip_ssl_validation = true` disables certificate verification, making connections vulnerable to man-in-the-middle attacks. Only use this in development or trusted private networks. |
 | `[[region_engine]]` | -- | -- | The region engine options. You can configure multiple region engines.<br/>Each engine type (mito, file, metric) may appear only once; duplicates cause startup to fail. |
 | `region_engine.mito` | -- | -- | The Mito engine options. |
-| `region_engine.mito.num_workers` | Integer | `8` | Number of region workers. |
+| `region_engine.mito.num_workers` | Integer | Auto | Number of region workers. Defaults to half of the available CPU cores, rounded up. |
 | `region_engine.mito.worker_channel_size` | Integer | `128` | Request channel size of each worker. |
 | `region_engine.mito.worker_request_batch_size` | Integer | `64` | Max batch size for a worker to handle requests. |
 | `region_engine.mito.manifest_checkpoint_distance` | Integer | `10` | Number of meta action updated to trigger a new checkpoint for the manifest. |
@@ -258,17 +257,18 @@
 | `logging.tracing_sample_ratio` | -- | Unset | The percentage of tracing will be sampled and exported.<br/>Valid range `[0, 1]`, 1 means all traces are sampled, 0 means all traces are not sampled, the default value is 1.<br/>ratio > 1 are treated as 1. Fractions < 0 are treated as 0 |
 | `logging.tracing_sample_ratio.default_ratio` | Float | `1.0` | -- |
 | `slow_query` | -- | -- | The slow query log options. |
-| `slow_query.enable` | Bool | `false` | Whether to enable slow query log. |
-| `slow_query.record_type` | String | Unset | The record type of slow queries. It can be `system_table` or `log`. |
-| `slow_query.threshold` | String | Unset | The threshold of slow query. |
-| `slow_query.sample_ratio` | Float | Unset | The sampling ratio of slow query log. The value should be in the range of (0, 1]. |
+| `slow_query.enable` | Bool | `true` | Whether to enable slow query log. |
+| `slow_query.record_type` | String | `system_table` | The record type of slow queries. It can be `system_table` or `log`.<br/>If `system_table` is selected, the slow queries will be recorded in a system table `greptime_private.slow_queries`.<br/>If `log` is selected, the slow queries will be logged in a log file `greptimedb-slow-queries.*`. |
+| `slow_query.threshold` | String | `30s` | The threshold of slow query. It can be human readable time string, for example: `10s`, `100ms`, `1s`. |
+| `slow_query.sample_ratio` | Float | `1.0` | The sampling ratio of slow query log. The value should be in the range of (0, 1]. For example, `0.1` means 10% of the slow queries will be logged and `1.0` means all slow queries will be logged. |
+| `slow_query.ttl` | String | `90d` | The TTL of the `slow_queries` system table. Default is `90d` when `record_type` is `system_table`. |
 | `tracing` | -- | -- | The tracing options. Only effect when compiled with `tokio-console` feature. |
 | `tracing.tokio_console_addr` | String | Unset | The tokio console address. |
 | `pipeline` | -- | -- | The pipeline options. |
 | `pipeline.cache_ttl` | String | `10s` | Time to live of the local pipeline cache. Default is `10s`. |
 | `event_recorder` | -- | -- | Configuration options for the event recorder. |
 | `event_recorder.ttl` | String | `90d` | TTL for the events table that will be used to store the events. Default is `90d`. |
-| `event_recorder.event_types` | Array | -- | Event types to record. Current available event types: `create_database`,<br/>`alter_database`, `drop_database`, `create_flow`, `drop_flow`,<br/>`create_table`, `create_logical_tables`, `alter_table`, `alter_logical_tables`,<br/>`drop_table`, `undrop_table`, `purge_dropped_table`, `truncate_table`,<br/>`create_view`, `drop_view`, `admin_function`, `reconcile_catalog`,<br/>`reconcile_database`, `reconcile_table`, `reconcile_logical_tables`.<br/>When omitted, all current and future event types are recorded.<br/>Set to an empty array to disable event recording. |
+| `event_recorder.event_types` | Array | All | Event types to record. Current available event types: `create_database`,<br/>`alter_database`, `drop_database`, `create_flow`, `drop_flow`,<br/>`create_table`, `create_logical_tables`, `alter_table`, `alter_logical_tables`,<br/>`drop_table`, `undrop_table`, `purge_dropped_table`, `truncate_table`,<br/>`create_view`, `drop_view`, `admin_function`, `reconcile_catalog`,<br/>`reconcile_database`, `reconcile_table`, `reconcile_logical_tables`.<br/>When omitted, all current and future event types are recorded.<br/>Set to an empty array to disable event recording. |
 | `memory` | -- | -- | The memory options. |
 | `memory.enable_heap_profiling` | Bool | `true` | Whether to enable heap profiling activation during startup.<br/>When enabled, heap profiling will be activated if the `MALLOC_CONF` environment variable<br/>is set to "prof:true,prof_active:false". The official image adds this env variable.<br/>Default is true. |
 
@@ -283,13 +283,13 @@
 | `default_column_prefix` | String | Unset | The default column prefix for auto-created time index, value, and native histogram columns.<br/>Legacy OTLP summary columns keep their historical `greptime_` prefix. |
 | `auto_create_table` | Bool | `true` | Server-side global switch for auto table creation on write.<br/>When `false`, a missing table is never auto-created even if the request sets the `auto_create_table` hint to `true`. Default: `true`. |
 | `experimental_metric_export` | Bool | `false` | Enables experimental Parquet COPY DATABASE using shared Metric physical scans.<br/>Resume requires the previous export and storage writes to have ended; HTTP timeout is not confirmation. |
-| `user_provider` | String | Unset | The user provider for authentication.<br/>Examples: "static_user_provider:file:/path/to/users", "static_user_provider:cmd:greptime_user=greptime_pwd"<br/>Password verifier formats: "plain:<password>", "pbkdf2_sha256:<iterations>:<hex_salt>:<hex_hash>",<br/>"mysql_native_password:<hex_sha1_sha1_password>",<br/>"pg_scram_sha256:<iterations>:<hex_salt>:<hex_stored_key>:<hex_server_key>"<br/>"pbkdf2_sha256" and "pg_scram_sha256" protect passwords at rest, but cannot authenticate over MySQL's<br/>native password handshake; a MySQL client must send the password in cleartext for such users.<br/>"mysql_native_password" is MySQL-specific and cannot authenticate over PostgreSQL at all.<br/>PostgreSQL SCRAM only covers "plain" and "pg_scram_sha256" users; if any user is "pbkdf2_sha256" or<br/>"mysql_native_password", PostgreSQL falls back to cleartext password auth for every user.<br/>For "pg_scram_sha256" users, keep the default iteration count (4096) and salt length (16): both are<br/>observable in the SCRAM server-first message, and non-default values weaken resistance to username<br/>enumeration. |
-| `max_in_flight_write_bytes` | String | Unset | Maximum total memory for all concurrent write request bodies and messages (HTTP, gRPC, Flight).<br/>Set to 0 to disable the limit. Default: "0" (unlimited) |
-| `write_bytes_exhausted_policy` | String | Unset | Policy when write bytes quota is exhausted.<br/>Options: "wait" (default, 10s timeout), "wait(<duration>)" (e.g., "wait(30s)"), "fail" |
+| `user_provider` | String | Unset | The user provider for authentication.<br/>Examples: "static_user_provider:file:/path/to/users", "static_user_provider:cmd:greptime_user=greptime_pwd"<br/>Password verifier formats: "plain:<password>", "pbkdf2_sha256:<iterations>:<hex_salt>:<hex_hash>",<br/>"mysql_native_password:<hex_sha1_sha1_password>",<br/>"pg_scram_sha256:<iterations>:<hex_salt>:<hex_stored_key>:<hex_server_key>"<br/>"pbkdf2_sha256" and "pg_scram_sha256" protect passwords at rest, but such users cannot log in over MySQL:<br/>`static_user_provider` and `watch_file_user_provider` only negotiate `mysql_native_password`, which cannot verify these formats.<br/>"mysql_native_password" is MySQL-specific and cannot authenticate over PostgreSQL at all.<br/>PostgreSQL SCRAM only covers "plain" and "pg_scram_sha256" users; if any user is "pbkdf2_sha256" or<br/>"mysql_native_password", PostgreSQL falls back to cleartext password auth for every user.<br/>For "pg_scram_sha256" users, keep the default iteration count (4096) and salt length (16): both are<br/>observable in the SCRAM server-first message, and non-default values weaken resistance to username<br/>enumeration. |
+| `max_in_flight_write_bytes` | String | 0 | Maximum total memory for all concurrent write request bodies and messages (HTTP, gRPC, Flight).<br/>Set to 0 to disable the limit. Default: "0" (unlimited) |
+| `write_bytes_exhausted_policy` | String | `wait` | Policy when write bytes quota is exhausted.<br/>Options: "wait" (default, 10s timeout), "wait(<duration>)" (e.g., "wait(30s)"), "fail" |
 | `runtime` | -- | -- | The runtime options. |
-| `runtime.global_rt_size` | Integer | `8` | The number of threads to execute the runtime for global read operations. |
-| `runtime.compact_rt_size` | Integer | `4` | The number of threads to execute compact operations. |
-| `runtime.compact_rt_max_blocking_threads` | Integer | `4` | The maximum number of blocking threads for compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
+| `runtime.global_rt_size` | Integer | Auto | The number of threads to execute the runtime for global read operations.<br/>Defaults to max(num_cpus, 2). |
+| `runtime.compact_rt_size` | Integer | Auto | The number of threads to execute compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
+| `runtime.compact_rt_max_blocking_threads` | Integer | Auto | The maximum number of blocking threads for compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
 | `http` | -- | -- | The HTTP server options. |
 | `http.addr` | String | `127.0.0.1:4000` | The address to bind the HTTP server. |
 | `http.timeout` | String | `0s` | HTTP request timeout. Set to 0 to disable timeout.<br/>When synchronous Prometheus, OTLP metrics, or ordinary-table batching is enabled, a nonzero timeout is<br/>raised to at least the largest active flush interval plus 1 second. The intervals come from<br/>`pending_rows_batcher.logical_table.pending_rows_flush_interval` and `pending_rows_batcher.pending_rows_flush_interval`. |
@@ -300,20 +300,20 @@
 | `http.api_server_addr` | String | `127.0.0.1:4006` | The address to bind the dedicated HTTP API server, in the same form as `addr`.<br/>Defaults to `127.0.0.1:4006`. |
 | `grpc` | -- | -- | The gRPC server options. |
 | `grpc.bind_addr` | String | `127.0.0.1:4001` | The address to bind the gRPC server. |
-| `grpc.server_addr` | String | `127.0.0.1:4001` | The address advertised to the metasrv, and used for connections from outside the host.<br/>If left empty or unset, the server will automatically use the IP address of the first network interface<br/>on the host, with the same port number as the one specified in `grpc.bind_addr`. |
+| `grpc.server_addr` | String | Unset | The address advertised to the metasrv, and used for connections from outside the host.<br/>If left empty or unset, the server will automatically use the IP address of the first network interface<br/>on the host, with the same port number as the one specified in `grpc.bind_addr`. |
 | `grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
-| `grpc.flight_compression` | String | `arrow_ipc` | Compression mode for frontend side Arrow IPC service. Available options:<br/>- `none`: disable all compression<br/>- `transport`: only enable gRPC transport compression (zstd)<br/>- `arrow_ipc`: only enable Arrow IPC compression (lz4)<br/>- `all`: enable all compression.<br/>Default to `none` |
+| `grpc.flight_compression` | String | `arrow_ipc` | Compression mode for frontend side Arrow IPC service. Available options:<br/>- `none`: disable all compression<br/>- `transport`: only enable gRPC transport compression (zstd)<br/>- `arrow_ipc`: only enable Arrow IPC compression (lz4)<br/>- `all`: enable all compression.<br/>Default to `arrow_ipc`. |
 | `grpc.max_connection_age` | String | Unset | The maximum connection age for gRPC connection.<br/>The value can be a human-readable time string. For example: `10m` for ten minutes or `1h` for one hour.<br/>Refer to https://grpc.io/docs/guides/keepalive/ for more details. |
 | `grpc.tls` | -- | -- | gRPC server TLS options, see `mysql.tls` section. |
 | `grpc.tls.mode` | String | `disable` | TLS mode. |
 | `grpc.tls.cert_path` | String | Unset | Certificate file path. |
 | `grpc.tls.key_path` | String | Unset | Private key file path. |
 | `grpc.tls.watch` | Bool | `false` | Watch for Certificate and key file change and auto reload.<br/>For now, gRPC tls config does not support auto reload. |
-| `internal_grpc` | -- | -- | The internal gRPC server options. Internal gRPC port for nodes inside cluster to access frontend. |
-| `internal_grpc.bind_addr` | String | `127.0.0.1:4010` | The address to bind the gRPC server. |
-| `internal_grpc.server_addr` | String | `127.0.0.1:4010` | The address advertised to the metasrv, and used for connections from outside the host.<br/>If left empty or unset, the server will automatically use the IP address of the first network interface<br/>on the host, with the same port number as the one specified in `internal_grpc.bind_addr`. |
+| `internal_grpc` | -- | -- | The internal gRPC server options. Internal gRPC port for nodes inside cluster to access frontend.<br/>The internal gRPC server starts only when this section is set. |
+| `internal_grpc.bind_addr` | String | Unset | The address to bind the gRPC server.<br/>If unset, it falls back to `127.0.0.1:4001`, the same address as `grpc.bind_addr`. |
+| `internal_grpc.server_addr` | String | Unset | The address advertised to the metasrv, and used for connections from outside the host.<br/>Unlike `grpc.server_addr`, it is not detected automatically; set it explicitly. |
 | `internal_grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
-| `internal_grpc.flight_compression` | String | `arrow_ipc` | Compression mode for frontend side Arrow IPC service. Available options:<br/>- `none`: disable all compression<br/>- `transport`: only enable gRPC transport compression (zstd)<br/>- `arrow_ipc`: only enable Arrow IPC compression (lz4)<br/>- `all`: enable all compression.<br/>Default to `none` |
+| `internal_grpc.flight_compression` | String | `arrow_ipc` | Compression mode for frontend side Arrow IPC service. Available options:<br/>- `none`: disable all compression<br/>- `transport`: only enable gRPC transport compression (zstd)<br/>- `arrow_ipc`: only enable Arrow IPC compression (lz4)<br/>- `all`: enable all compression.<br/>Default to `arrow_ipc`. |
 | `internal_grpc.tls` | -- | -- | internal gRPC server TLS options, see `mysql.tls` section. |
 | `internal_grpc.tls.mode` | String | `disable` | TLS mode. |
 | `internal_grpc.tls.cert_path` | String | Unset | Certificate file path. |
@@ -381,15 +381,20 @@
 | `query` | -- | -- | The query engine options. |
 | `query.parallelism` | Integer | `0` | Parallelism of the query engine.<br/>Default to 0, which means the number of CPU cores. |
 | `query.allow_query_fallback` | Bool | `false` | Whether to allow query fallback when push down optimize fails.<br/>Default to false, meaning when push down optimize failed, return error msg |
-| `query.memory_pool_size` | String | `50%` | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "4GB", "8GB") or percentage of system memory (e.g., "30%").<br/>Setting it to 0 disables the limit (unbounded, default behavior).<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans (only applies to datanodes). |
+| `query.memory_pool_size` | String | 0 | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "4GB", "8GB") or percentage of system memory (e.g., "30%").<br/>Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans (only applies to datanodes). |
 | `query.experimental_memory_pool_policy` | String | `greedy` | Experimental memory pool allocation policy:<br/>- "greedy" (default): first-come-first-served allocation; preserves current behavior.<br/>- "fair": divides available memory among spillable operators and may spill earlier.<br/>Only effective when `memory_pool_size` is bounded (>0). |
 | `query.experimental_spill_mode` | String | `default` | Spill mode:<br/>- "default": preserve DataFusion built-in OS temp directory (default).<br/>- "custom": explicitly configure spill path, quota, and compression.<br/>- "disabled": explicitly disable disk spilling.<br/>Set this to "custom" before using the path/quota/compression keys below. |
 | `query.experimental_spill_path` | String | Unset | Spill directory path. Ignored unless mode is "custom". |
 | `query.experimental_spill_max_temp_directory_size` | String | `1GiB` | Maximum total size of spill directory (default: "1GiB").<br/>Ignored unless mode is "custom". |
 | `query.experimental_spill_compression` | String | `uncompressed` | Compression for spilled data files: "uncompressed" (default), "lz4_frame", "zstd".<br/>Ignored unless mode is "custom". |
+| `write_retry` | -- | -- | Retry retryable distributed write failures.<br/>Backoff grows exponentially, with jitter to spread concurrent retries. |
+| `write_retry.max_retries` | Integer | `3` | Maximum retries after the initial write attempt. Set to 0 to disable retries. |
+| `write_retry.initial_backoff` | String | `1500ms` | Initial backoff before jitter is applied. Must be positive. |
+| `write_retry.max_backoff` | String | `10s` | Maximum backoff before jitter is applied. Must be at least initial_backoff. |
+| `write_retry.backoff_multiplier` | Float | `2.0` | Backoff multiplier. Must be finite and at least 1. |
 | `datanode` | -- | -- | Datanode options. |
 | `datanode.client` | -- | -- | Datanode client options. |
-| `datanode.client.connect_timeout` | String | `10s` | -- |
+| `datanode.client.connect_timeout` | String | 1s | Connect server timeout. Defaults to `1s`; this example sets it to `10s`. |
 | `datanode.client.tcp_nodelay` | Bool | `true` | -- |
 | `datanode.client.max_recv_message_size` | String | `512MB` | The maximum receive message size for the gRPC client. |
 | `datanode.client.max_send_message_size` | String | `512MB` | The maximum send message size for the gRPC client. |
@@ -422,7 +427,7 @@
 | `pipeline.cache_ttl` | String | `10s` | Time to live of the frontend-local pipeline cache. A pipeline created or deleted on<br/>another frontend takes effect on this one after at most this duration. |
 | `event_recorder` | -- | -- | Configuration options for the event recorder. |
 | `event_recorder.ttl` | String | `90d` | TTL for the events table that will be used to store the events. Default is `90d`. |
-| `event_recorder.event_types` | Array | -- | Event types to record. Current available event type: `admin_function`.<br/>When omitted, all current and future event types are recorded.<br/>Set to an empty array to disable event recording. |
+| `event_recorder.event_types` | Array | All | Event types to record. Current available event type: `admin_function`.<br/>When omitted, all current and future event types are recorded.<br/>Set to an empty array to disable event recording. |
 
 
 ### Metasrv
@@ -434,7 +439,7 @@
 | `store_key_prefix` | String | `""` | If it's not empty, the metasrv will store all data with this key prefix. |
 | `backend` | String | `etcd_store` | The datastore for meta server.<br/>Available values:<br/>- `etcd_store` (default value)<br/>- `memory_store`<br/>- `postgres_store`<br/>- `mysql_store` |
 | `meta_table_name` | String | `greptime_metakv` | Table name in RDS to store metadata. Effect when using a RDS kvbackend.<br/>**Only used when backend is `postgres_store`.** |
-| `meta_schema_name` | String | `greptime_schema` | Optional PostgreSQL schema for metadata table and election table name qualification.<br/>When PostgreSQL public schema is not writable (e.g., PostgreSQL 15+ with restricted public),<br/>set this to a writable schema. GreptimeDB will use `meta_schema_name`.`meta_table_name`.<br/>**Only used when backend is `postgres_store`.** |
+| `meta_schema_name` | String | Unset | Optional PostgreSQL schema for metadata table and election table name qualification.<br/>When PostgreSQL public schema is not writable (e.g., PostgreSQL 15+ with restricted public),<br/>set this to a writable schema. GreptimeDB will use `meta_schema_name`.`meta_table_name`.<br/>**Only used when backend is `postgres_store`.**<br/>Unset by default; this example sets it to `greptime_schema`. |
 | `auto_create_schema` | Bool | `true` | Automatically create PostgreSQL schema if it doesn't exist.<br/>When enabled, the system will execute `CREATE SCHEMA IF NOT EXISTS <schema_name>`<br/>before creating metadata tables. This is useful in production environments where<br/>manual schema creation may be restricted.<br/>Default is true.<br/>Note: The PostgreSQL user must have CREATE SCHEMA permission for this to work.<br/>**Only used when backend is `postgres_store`.** |
 | `meta_election_lock_id` | Integer | `1` | Advisory lock id in PostgreSQL for election. Effect when using PostgreSQL as kvbackend<br/>Only used when backend is `postgres_store`. |
 | `selector` | String | `round_robin` | Datanode selector type.<br/>- `round_robin` (default value)<br/>- `lease_based`<br/>- `load_based`<br/>For details, please see "https://docs.greptime.com/developer-guide/metasrv/selector". |
@@ -445,9 +450,9 @@
 | `heartbeat_interval` | String | `3s` | Base heartbeat interval for calculating distributed time constants.<br/>The frontend heartbeat interval is 6 times of the base heartbeat interval.<br/>The flownode/datanode heartbeat interval is 1 times of the base heartbeat interval.<br/>e.g., If the base heartbeat interval is 3s, the frontend heartbeat interval is 18s, the flownode/datanode heartbeat interval is 3s.<br/>Heartbeat intervals are negotiated from metasrv during handshake; local node configs do not override this. |
 | `enable_telemetry` | Bool | `true` | Whether to enable greptimedb telemetry. Enabled by default. |
 | `runtime` | -- | -- | The runtime options. |
-| `runtime.global_rt_size` | Integer | `8` | The number of threads to execute the runtime for global read operations. |
-| `runtime.compact_rt_size` | Integer | `4` | The number of threads to execute compact operations. |
-| `runtime.compact_rt_max_blocking_threads` | Integer | `4` | The maximum number of blocking threads for compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
+| `runtime.global_rt_size` | Integer | Auto | The number of threads to execute the runtime for global read operations.<br/>Defaults to max(num_cpus, 2). |
+| `runtime.compact_rt_size` | Integer | Auto | The number of threads to execute compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
+| `runtime.compact_rt_max_blocking_threads` | Integer | Auto | The maximum number of blocking threads for compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
 | `backend_tls` | -- | -- | TLS configuration for kv store backend (applicable for etcd, PostgreSQL, and MySQL backends)<br/>When using etcd, PostgreSQL, or MySQL as metadata store, you can configure TLS here<br/><br/>Note: if TLS is configured in both this section and the `store_addrs` connection string, the<br/>settings here will override the TLS settings in `store_addrs`. |
 | `backend_tls.mode` | String | `prefer` | TLS mode, refer to https://www.postgresql.org/docs/current/libpq-ssl.html<br/>- "disable" - No TLS<br/>- "prefer" (default) - Try TLS, fallback to plain<br/>- "require" - Require TLS<br/>- "verify_ca" - Require TLS and verify CA<br/>- "verify_full" - Require TLS and verify hostname |
 | `backend_tls.cert_path` | String | `""` | Path to client certificate file (for client authentication)<br/>Like "/path/to/client.crt" |
@@ -459,7 +464,7 @@
 | `backend_client.connect_timeout` | String | `3s` | The connect timeout for backend client. |
 | `grpc` | -- | -- | The gRPC server options. |
 | `grpc.bind_addr` | String | `127.0.0.1:3002` | The address to bind the gRPC server. |
-| `grpc.server_addr` | String | `127.0.0.1:3002` | The communication server address for the frontend and datanode to connect to metasrv.<br/>If left empty or unset, the server will automatically use the IP address of the first network interface<br/>on the host, with the same port number as the one specified in `grpc.bind_addr`. |
+| `grpc.server_addr` | String | Unset | The communication server address for the frontend and datanode to connect to metasrv.<br/>If left empty or unset, the server will automatically use the IP address of the first network interface<br/>on the host, with the same port number as the one specified in `grpc.bind_addr`. |
 | `grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
 | `grpc.max_recv_message_size` | String | `512MB` | The maximum receive message size for gRPC server. |
 | `grpc.max_send_message_size` | String | `512MB` | The maximum send message size for gRPC server. |
@@ -481,7 +486,7 @@
 | `datanode` | -- | -- | Datanode options. |
 | `datanode.client` | -- | -- | Datanode client options. |
 | `datanode.client.timeout` | String | `10s` | Operation timeout. |
-| `datanode.client.connect_timeout` | String | `10s` | Connect server timeout. |
+| `datanode.client.connect_timeout` | String | 1s | Connect server timeout. Defaults to `1s`; this example sets it to `10s`. |
 | `datanode.client.tcp_nodelay` | Bool | `true` | `TCP_NODELAY` option for accepted connections. |
 | `datanode.client.max_recv_message_size` | String | `512MB` | The maximum receive message size for the gRPC client. |
 | `datanode.client.max_send_message_size` | String | `512MB` | The maximum send message size for the gRPC client. |
@@ -503,7 +508,7 @@
 | `wal.create_topic_timeout` | String | `30s` | The timeout for creating a Kafka topic.<br/>**It's only used when the provider is `kafka`**. |
 | `event_recorder` | -- | -- | Configuration options for the event recorder. |
 | `event_recorder.ttl` | String | `90d` | TTL for the events table that will be used to store the events. Default is `90d`. |
-| `event_recorder.event_types` | Array | -- | Event types to record. Current available event types: `region_migration`,<br/>`create_database`, `alter_database`, `drop_database`, `create_flow`,<br/>`drop_flow`, `create_table`, `create_logical_tables`, `alter_table`,<br/>`alter_logical_tables`, `drop_table`, `undrop_table`, `purge_dropped_table`,<br/>`truncate_table`, `create_view`, `drop_view`, `repartition`,<br/>`repartition_group`, `wal_prune`, `batch_gc`, `reconcile_catalog`,<br/>`reconcile_database`, `reconcile_table`, `reconcile_logical_tables`.<br/>When omitted, all current and future event types are recorded.<br/>Set to an empty array to disable event recording. |
+| `event_recorder.event_types` | Array | All | Event types to record. Current available event types: `region_migration`,<br/>`create_database`, `alter_database`, `drop_database`, `create_flow`,<br/>`drop_flow`, `create_table`, `create_logical_tables`, `alter_table`,<br/>`alter_logical_tables`, `drop_table`, `undrop_table`, `purge_dropped_table`,<br/>`truncate_table`, `create_view`, `drop_view`, `repartition`,<br/>`repartition_group`, `wal_prune`, `batch_gc`, `reconcile_catalog`,<br/>`reconcile_database`, `reconcile_table`, `reconcile_logical_tables`.<br/>When omitted, all current and future event types are recorded.<br/>Set to an empty array to disable event recording. |
 | `stats_persistence` | -- | -- | Configuration options for the stats persistence. |
 | `stats_persistence.ttl` | String | `0s` | TTL for the stats table that will be used to store the stats.<br/>Set to `0s` to disable stats persistence.<br/>Default is `0s`.<br/>If you want to enable stats persistence, set the TTL to a value greater than 0.<br/>It is recommended to set a small value, e.g., `3h`. |
 | `stats_persistence.interval` | String | `10m` | The interval to persist the stats. Default is `10m`.<br/>The minimum value is `10m`, if the value is less than `10m`, it will be overridden to `10m`. |
@@ -548,22 +553,22 @@
 | `http.body_limit` | String | `64MB` | HTTP request body limit.<br/>The following units are supported: `B`, `KB`, `KiB`, `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`, `PB`, `PiB`.<br/>Set to 0 to disable limit. |
 | `grpc` | -- | -- | The gRPC server options. |
 | `grpc.bind_addr` | String | `127.0.0.1:3001` | The address to bind the gRPC server. |
-| `grpc.server_addr` | String | `127.0.0.1:3001` | The address advertised to the metasrv, and used for connections from outside the host.<br/>If left empty or unset, the server will automatically use the IP address of the first network interface<br/>on the host, with the same port number as the one specified in `grpc.bind_addr`. |
+| `grpc.server_addr` | String | Unset | The address advertised to the metasrv, and used for connections from outside the host.<br/>If left empty or unset, the server will automatically use the IP address of the first network interface<br/>on the host, with the same port number as the one specified in `grpc.bind_addr`. |
 | `grpc.runtime_size` | Integer | `8` | The number of server worker threads. |
 | `grpc.max_recv_message_size` | String | `512MB` | The maximum receive message size for gRPC server. |
 | `grpc.max_send_message_size` | String | `512MB` | The maximum send message size for gRPC server. |
-| `grpc.flight_compression` | String | `arrow_ipc` | Compression mode for datanode side Arrow IPC service. Available options:<br/>- `none`: disable all compression<br/>- `transport`: only enable gRPC transport compression (zstd)<br/>- `arrow_ipc`: only enable Arrow IPC compression (lz4)<br/>- `all`: enable all compression.<br/>Default to `none` |
+| `grpc.flight_compression` | String | `arrow_ipc` | Compression mode for datanode side Arrow IPC service. Available options:<br/>- `none`: disable all compression<br/>- `transport`: only enable gRPC transport compression (zstd)<br/>- `arrow_ipc`: only enable Arrow IPC compression (lz4)<br/>- `all`: enable all compression.<br/>Default to `arrow_ipc`. |
 | `grpc.tls` | -- | -- | gRPC server TLS options, see `mysql.tls` section. |
 | `grpc.tls.mode` | String | `disable` | TLS mode. |
 | `grpc.tls.cert_path` | String | Unset | Certificate file path. |
 | `grpc.tls.key_path` | String | Unset | Private key file path. |
 | `grpc.tls.watch` | Bool | `false` | Watch for Certificate and key file change and auto reload.<br/>For now, gRPC tls config does not support auto reload. |
 | `runtime` | -- | -- | The runtime options. |
-| `runtime.global_rt_size` | Integer | `8` | The number of threads to execute the runtime for global read operations. |
-| `runtime.compact_rt_size` | Integer | `4` | The number of threads to execute compact operations. |
-| `runtime.compact_rt_max_blocking_threads` | Integer | `4` | The maximum number of blocking threads for compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
-| `runtime.query_rt_size` | Integer | `7` | The number of threads to execute datanode query operations.<br/>Defaults to max(num_cpus - 1, 2). |
-| `runtime.ingest_rt_size` | Integer | `8` | The number of threads to execute datanode ingestion operations. |
+| `runtime.global_rt_size` | Integer | Auto | The number of threads to execute the runtime for global read operations.<br/>Defaults to max(num_cpus, 2). |
+| `runtime.compact_rt_size` | Integer | Auto | The number of threads to execute compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
+| `runtime.compact_rt_max_blocking_threads` | Integer | Auto | The maximum number of blocking threads for compact operations.<br/>Defaults to max(num_cpus / 2, 2). |
+| `runtime.query_rt_size` | Integer | Auto | The number of threads to execute datanode query operations.<br/>Defaults to max(num_cpus - 1, 2). |
+| `runtime.ingest_rt_size` | Integer | Auto | The number of threads to execute datanode ingestion operations.<br/>Defaults to max(num_cpus, 2). |
 | `runtime.experimental_workload_scheduler` | -- | -- | Experimental weighted, work-conserving query/write task scheduler. |
 | `runtime.experimental_workload_scheduler.enable` | Bool | `false` | Enable when concurrent queries and writes interfere with each other—for example, when long-running queries increase ingestion latency.<br/>The weights set their relative runtime shares while both are backlogged. Disabled by default. |
 | `runtime.experimental_workload_scheduler.query_weight` | Integer | `2` | Relative query share while both query and write workloads are backlogged. |
@@ -589,7 +594,7 @@
 | `wal.enable_log_recycle` | Bool | `true` | Whether to reuse logically truncated log files.<br/>**It's only used when the provider is `raft_engine`**. |
 | `wal.prefill_log_files` | Bool | `false` | Whether to pre-create log files on start up.<br/>**It's only used when the provider is `raft_engine`**. |
 | `wal.sync_period` | String | `5s` | Duration for fsyncing log files.<br/>**It's only used when the provider is `raft_engine`**. |
-| `wal.recovery_parallelism` | Integer | `2` | Parallelism during WAL recovery. |
+| `wal.recovery_parallelism` | Integer | Auto | Parallelism during WAL recovery. Defaults to the number of CPU cores; this example sets it to 2. |
 | `wal.broker_endpoints` | Array | -- | The Kafka broker endpoints.<br/>**It's only used when the provider is `kafka`**. |
 | `wal.connect_timeout` | String | `3s` | The connect timeout for kafka client.<br/>**It's only used when the provider is `kafka`**. |
 | `wal.timeout` | String | `5s` | The total request timeout for kafka client.<br/>**It's only used when the provider is `kafka`**. |
@@ -607,7 +612,7 @@
 | `wal.on_corrupted_segment` | String | `skip` | What a read does with a segment that still does not decode after a second fetch, because its checksum does not match or its content disagrees with its footer entry.<br/>- `skip`: the segment is skipped and recorded as a WAL hole of its region, a metric is incremented and a warning is logged; the other regions of the object are unaffected (the default).<br/>- `fail`: the read fails, so the region does not open.<br/>**It's only used when the provider is `experimental_object_store`**. |
 | `query` | -- | -- | The query engine options. |
 | `query.parallelism` | Integer | `0` | Parallelism of the query engine.<br/>Default to 0, which means the number of CPU cores. |
-| `query.memory_pool_size` | String | `50%` | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "2GB", "4GB") or percentage of system memory (e.g., "20%").<br/>Setting it to 0 disables the limit (unbounded, default behavior).<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans. |
+| `query.memory_pool_size` | String | 0 | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "2GB", "4GB") or percentage of system memory (e.g., "20%").<br/>Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans. |
 | `query.experimental_memory_pool_policy` | String | `greedy` | Experimental memory pool allocation policy:<br/>- "greedy" (default): first-come-first-served allocation; preserves current behavior.<br/>- "fair": divides available memory among spillable operators and may spill earlier.<br/>Only effective when `memory_pool_size` is bounded (>0). |
 | `query.experimental_spill_mode` | String | `default` | Spill mode:<br/>- "default": preserve DataFusion built-in OS temp directory (default).<br/>- "custom": explicitly configure spill path, quota, and compression.<br/>- "disabled": explicitly disable disk spilling.<br/>Set this to "custom" before using the path/quota/compression keys below. |
 | `query.experimental_spill_path` | String | Unset | Spill directory path. Ignored unless mode is "custom". |
@@ -640,7 +645,7 @@
 | `storage.http_client.skip_ssl_validation` | Bool | `false` | To skip the ssl verification<br/>**Security Notice**: Setting `skip_ssl_validation = true` disables certificate verification, making connections vulnerable to man-in-the-middle attacks. Only use this in development or trusted private networks. |
 | `[[region_engine]]` | -- | -- | The region engine options. You can configure multiple region engines.<br/>Each engine type (mito, file, metric) may appear only once; duplicates cause startup to fail. |
 | `region_engine.mito` | -- | -- | The Mito engine options. |
-| `region_engine.mito.num_workers` | Integer | `8` | Number of region workers. |
+| `region_engine.mito.num_workers` | Integer | Auto | Number of region workers. Defaults to half of the available CPU cores, rounded up. |
 | `region_engine.mito.worker_channel_size` | Integer | `128` | Request channel size of each worker. |
 | `region_engine.mito.worker_request_batch_size` | Integer | `64` | Max batch size for a worker to handle requests. |
 | `region_engine.mito.manifest_checkpoint_distance` | Integer | `10` | Number of meta action updated to trigger a new checkpoint for the manifest. |
@@ -757,9 +762,9 @@
 | `flow.batching_mode.frontend_tls.client_cert_path` | String | Unset | Client Certificate file path. |
 | `flow.batching_mode.frontend_tls.client_key_path` | String | Unset | Client Private key file path. |
 | `grpc` | -- | -- | The gRPC server options. |
-| `grpc.bind_addr` | String | `127.0.0.1:6800` | The address to bind the gRPC server. |
-| `grpc.server_addr` | String | `127.0.0.1:6800` | The address advertised to the metasrv,<br/>and used for connections from outside the host |
-| `grpc.runtime_size` | Integer | `2` | The number of server worker threads. |
+| `grpc.bind_addr` | String | 127.0.0.1:3004 | The address to bind the gRPC server. Defaults to `127.0.0.1:3004`; this example sets it to `127.0.0.1:6800`. |
+| `grpc.server_addr` | String | Unset | The address advertised to the metasrv, and used for connections from outside the host.<br/>If left empty or unset, the server will automatically use the IP address of the first network interface<br/>on the host, with the same port number as the one specified in `grpc.bind_addr`. |
+| `grpc.runtime_size` | Integer | 8 | The number of server worker threads. Defaults to 8; this example sets it to 2. |
 | `grpc.max_recv_message_size` | String | `512MB` | The maximum receive message size for gRPC server. |
 | `grpc.max_send_message_size` | String | `512MB` | The maximum send message size for gRPC server. |
 | `http` | -- | -- | The HTTP server options. |
@@ -793,7 +798,7 @@
 | `tracing.tokio_console_addr` | String | Unset | The tokio console address. |
 | `query` | -- | -- | -- |
 | `query.parallelism` | Integer | `1` | Parallelism of the query engine for query sent by flownode.<br/>Default to 1, so it won't use too much cpu or memory |
-| `query.memory_pool_size` | String | `50%` | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "1GB", "2GB") or percentage of system memory (e.g., "20%").<br/>Setting it to 0 disables the limit (unbounded, default behavior).<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans. |
+| `query.memory_pool_size` | String | 0 | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "1GB", "2GB") or percentage of system memory (e.g., "20%").<br/>Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans. |
 | `query.experimental_memory_pool_policy` | String | `greedy` | Experimental memory pool allocation policy:<br/>- "greedy" (default): first-come-first-served allocation; preserves current behavior.<br/>- "fair": divides available memory among spillable operators and may spill earlier.<br/>Only effective when `memory_pool_size` is bounded (>0). |
 | `query.experimental_spill_mode` | String | `default` | Spill mode:<br/>- "default": preserve DataFusion built-in OS temp directory (default).<br/>- "custom": explicitly configure spill path, quota, and compression.<br/>- "disabled": explicitly disable disk spilling.<br/>Set this to "custom" before using the path/quota/compression keys below. |
 | `query.experimental_spill_path` | String | Unset | Spill directory path. Ignored unless mode is "custom". |
diff --git a/config/datanode.example.toml b/config/datanode.example.toml
index e61ef3fbf22..d0f7da36acd 100644
--- a/config/datanode.example.toml
+++ b/config/datanode.example.toml
@@ -45,6 +45,7 @@ bind_addr = "127.0.0.1:3001"
 ## The address advertised to the metasrv, and used for connections from outside the host.
 ## If left empty or unset, the server will automatically use the IP address of the first network interface
 ## on the host, with the same port number as the one specified in `grpc.bind_addr`.
+## @toml2docs:none-default
 server_addr = "127.0.0.1:3001"
 ## The number of server worker threads.
 runtime_size = 8
@@ -57,7 +58,7 @@ max_send_message_size = "512MB"
 ## - `transport`: only enable gRPC transport compression (zstd)
 ## - `arrow_ipc`: only enable Arrow IPC compression (lz4)
 ## - `all`: enable all compression.
-## Default to `none`
+## Default to `arrow_ipc`.
 flight_compression = "arrow_ipc"
 
 ## gRPC server TLS options, see `mysql.tls` section.
@@ -80,16 +81,24 @@ watch = false
 ## The runtime options.
 #+ [runtime]
 ## The number of threads to execute the runtime for global read operations.
+## Defaults to max(num_cpus, 2).
+## @toml2docs:none-default="Auto"
 #+ global_rt_size = 8
 ## The number of threads to execute compact operations.
+## Defaults to max(num_cpus / 2, 2).
+## @toml2docs:none-default="Auto"
 #+ compact_rt_size = 4
 ## The maximum number of blocking threads for compact operations.
 ## Defaults to max(num_cpus / 2, 2).
+## @toml2docs:none-default="Auto"
 #+ compact_rt_max_blocking_threads = 4
 ## The number of threads to execute datanode query operations.
 ## Defaults to max(num_cpus - 1, 2).
+## @toml2docs:none-default="Auto"
 #+ query_rt_size = 7
 ## The number of threads to execute datanode ingestion operations.
+## Defaults to max(num_cpus, 2).
+## @toml2docs:none-default="Auto"
 #+ ingest_rt_size = 8
 
 ## Experimental weighted, work-conserving query/write task scheduler.
@@ -176,7 +185,8 @@ prefill_log_files = false
 ## **It's only used when the provider is `raft_engine`**.
 sync_period = "5s"
 
-## Parallelism during WAL recovery.
+## Parallelism during WAL recovery. Defaults to the number of CPU cores; this example sets it to 2.
+## @toml2docs:none-default="Auto"
 recovery_parallelism = 2
 
 ## The Kafka broker endpoints.
@@ -330,9 +340,10 @@ parallelism = 0
 
 ## Memory pool size for query execution operators (aggregation, sorting, join).
 ## Supports absolute size (e.g., "2GB", "4GB") or percentage of system memory (e.g., "20%").
-## Setting it to 0 disables the limit (unbounded, default behavior).
+## Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.
 ## When this limit is reached, queries will fail with ResourceExhausted error.
 ## NOTE: This does NOT limit memory used by table scans.
+## @toml2docs:none-default="0"
 memory_pool_size = "50%"
 
 ## Experimental memory pool allocation policy:
@@ -503,7 +514,8 @@ skip_ssl_validation = false
 ## The Mito engine options.
 [region_engine.mito]
 
-## Number of region workers.
+## Number of region workers. Defaults to half of the available CPU cores, rounded up.
+## @toml2docs:none-default="Auto"
 #+ num_workers = 8
 
 ## Request channel size of each worker.
diff --git a/config/flownode.example.toml b/config/flownode.example.toml
index b0a53bee54a..fab31fed510 100644
--- a/config/flownode.example.toml
+++ b/config/flownode.example.toml
@@ -44,12 +44,16 @@ node_id = 14
 
 ## The gRPC server options.
 [grpc]
-## The address to bind the gRPC server.
+## The address to bind the gRPC server. Defaults to `127.0.0.1:3004`; this example sets it to `127.0.0.1:6800`.
+## @toml2docs:none-default="127.0.0.1:3004"
 bind_addr = "127.0.0.1:6800"
-## The address advertised to the metasrv,
-## and used for connections from outside the host
+## The address advertised to the metasrv, and used for connections from outside the host.
+## If left empty or unset, the server will automatically use the IP address of the first network interface
+## on the host, with the same port number as the one specified in `grpc.bind_addr`.
+## @toml2docs:none-default
 server_addr = "127.0.0.1:6800"
-## The number of server worker threads.
+## The number of server worker threads. Defaults to 8; this example sets it to 2.
+## @toml2docs:none-default="8"
 runtime_size = 2
 ## The maximum receive message size for gRPC server.
 max_recv_message_size = "512MB"
@@ -153,9 +157,10 @@ parallelism = 1
 
 ## Memory pool size for query execution operators (aggregation, sorting, join).
 ## Supports absolute size (e.g., "1GB", "2GB") or percentage of system memory (e.g., "20%").
-## Setting it to 0 disables the limit (unbounded, default behavior).
+## Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.
 ## When this limit is reached, queries will fail with ResourceExhausted error.
 ## NOTE: This does NOT limit memory used by table scans.
+## @toml2docs:none-default="0"
 memory_pool_size = "50%"
 
 ## Experimental memory pool allocation policy:
diff --git a/config/frontend.example.toml b/config/frontend.example.toml
index b528da0304f..0e7c0482fa3 100644
--- a/config/frontend.example.toml
+++ b/config/frontend.example.toml
@@ -20,8 +20,8 @@ default_column_prefix = "greptime"
 ## Password verifier formats: "plain:<password>", "pbkdf2_sha256:<iterations>:<hex_salt>:<hex_hash>",
 ## "mysql_native_password:<hex_sha1_sha1_password>",
 ## "pg_scram_sha256:<iterations>:<hex_salt>:<hex_stored_key>:<hex_server_key>"
-## "pbkdf2_sha256" and "pg_scram_sha256" protect passwords at rest, but cannot authenticate over MySQL's
-## native password handshake; a MySQL client must send the password in cleartext for such users.
+## "pbkdf2_sha256" and "pg_scram_sha256" protect passwords at rest, but such users cannot log in over MySQL:
+## `static_user_provider` and `watch_file_user_provider` only negotiate `mysql_native_password`, which cannot verify these formats.
 ## "mysql_native_password" is MySQL-specific and cannot authenticate over PostgreSQL at all.
 ## PostgreSQL SCRAM only covers "plain" and "pg_scram_sha256" users; if any user is "pbkdf2_sha256" or
 ## "mysql_native_password", PostgreSQL falls back to cleartext password auth for every user.
@@ -33,22 +33,26 @@ default_column_prefix = "greptime"
 
 ## Maximum total memory for all concurrent write request bodies and messages (HTTP, gRPC, Flight).
 ## Set to 0 to disable the limit. Default: "0" (unlimited)
-## @toml2docs:none-default
+## @toml2docs:none-default="0"
 #+ max_in_flight_write_bytes = "1GB"
 
 ## Policy when write bytes quota is exhausted.
 ## Options: "wait" (default, 10s timeout), "wait(<duration>)" (e.g., "wait(30s)"), "fail"
-## @toml2docs:none-default
 #+ write_bytes_exhausted_policy = "wait"
 
 ## The runtime options.
 #+ [runtime]
 ## The number of threads to execute the runtime for global read operations.
+## Defaults to max(num_cpus, 2).
+## @toml2docs:none-default="Auto"
 #+ global_rt_size = 8
 ## The number of threads to execute compact operations.
+## Defaults to max(num_cpus / 2, 2).
+## @toml2docs:none-default="Auto"
 #+ compact_rt_size = 4
 ## The maximum number of blocking threads for compact operations.
 ## Defaults to max(num_cpus / 2, 2).
+## @toml2docs:none-default="Auto"
 #+ compact_rt_max_blocking_threads = 4
 
 ## The HTTP server options.
@@ -86,6 +90,7 @@ bind_addr = "127.0.0.1:4001"
 ## The address advertised to the metasrv, and used for connections from outside the host.
 ## If left empty or unset, the server will automatically use the IP address of the first network interface
 ## on the host, with the same port number as the one specified in `grpc.bind_addr`.
+## @toml2docs:none-default
 server_addr = "127.0.0.1:4001"
 ## The number of server worker threads.
 runtime_size = 8
@@ -94,7 +99,7 @@ runtime_size = 8
 ## - `transport`: only enable gRPC transport compression (zstd)
 ## - `arrow_ipc`: only enable Arrow IPC compression (lz4)
 ## - `all`: enable all compression.
-## Default to `none`
+## Default to `arrow_ipc`.
 flight_compression = "arrow_ipc"
 ## The maximum connection age for gRPC connection.
 ## The value can be a human-readable time string. For example: `10m` for ten minutes or `1h` for one hour.
@@ -120,12 +125,15 @@ key_path = ""
 watch = false
 
 ## The internal gRPC server options. Internal gRPC port for nodes inside cluster to access frontend.
+## The internal gRPC server starts only when this section is set.
 [internal_grpc]
 ## The address to bind the gRPC server.
+## If unset, it falls back to `127.0.0.1:4001`, the same address as `grpc.bind_addr`.
+## @toml2docs:none-default
 bind_addr = "127.0.0.1:4010"
 ## The address advertised to the metasrv, and used for connections from outside the host.
-## If left empty or unset, the server will automatically use the IP address of the first network interface
-## on the host, with the same port number as the one specified in `internal_grpc.bind_addr`.
+## Unlike `grpc.server_addr`, it is not detected automatically; set it explicitly.
+## @toml2docs:none-default
 server_addr = "127.0.0.1:4010"
 ## The number of server worker threads.
 runtime_size = 8
@@ -134,7 +142,7 @@ runtime_size = 8
 ## - `transport`: only enable gRPC transport compression (zstd)
 ## - `arrow_ipc`: only enable Arrow IPC compression (lz4)
 ## - `all`: enable all compression.
-## Default to `none`
+## Default to `arrow_ipc`.
 flight_compression = "arrow_ipc"
 
 ## internal gRPC server TLS options, see `mysql.tls` section.
@@ -352,9 +360,10 @@ allow_query_fallback = false
 
 ## Memory pool size for query execution operators (aggregation, sorting, join).
 ## Supports absolute size (e.g., "4GB", "8GB") or percentage of system memory (e.g., "30%").
-## Setting it to 0 disables the limit (unbounded, default behavior).
+## Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.
 ## When this limit is reached, queries will fail with ResourceExhausted error.
 ## NOTE: This does NOT limit memory used by table scans (only applies to datanodes).
+## @toml2docs:none-default="0"
 memory_pool_size = "50%"
 
 ## Experimental memory pool allocation policy:
@@ -381,10 +390,24 @@ memory_pool_size = "50%"
 #+ experimental_spill_compression = "uncompressed"
 # --- End spill-to-disk ---
 
+## Retry retryable distributed write failures.
+## Backoff grows exponentially, with jitter to spread concurrent retries.
+[write_retry]
+## Maximum retries after the initial write attempt. Set to 0 to disable retries.
+max_retries = 3
+## Initial backoff before jitter is applied. Must be positive.
+initial_backoff = "1500ms"
+## Maximum backoff before jitter is applied. Must be at least initial_backoff.
+max_backoff = "10s"
+## Backoff multiplier. Must be finite and at least 1.
+backoff_multiplier = 2.0
+
 ## Datanode options.
 [datanode]
 ## Datanode client options.
 [datanode.client]
+## Connect server timeout. Defaults to `1s`; this example sets it to `10s`.
+## @toml2docs:none-default="1s"
 connect_timeout = "10s"
 tcp_nodelay = true
 ## The maximum receive message size for the gRPC client.
@@ -489,4 +512,5 @@ ttl = "90d"
 ## Event types to record. Current available event type: `admin_function`.
 ## When omitted, all current and future event types are recorded.
 ## Set to an empty array to disable event recording.
+## @toml2docs:none-default="All"
 #+ event_types = ["admin_function"]
diff --git a/config/metasrv.example.toml b/config/metasrv.example.toml
index b923c5a549c..fe4c38d02f9 100644
--- a/config/metasrv.example.toml
+++ b/config/metasrv.example.toml
@@ -35,6 +35,8 @@ meta_table_name = "greptime_metakv"
 ## When PostgreSQL public schema is not writable (e.g., PostgreSQL 15+ with restricted public),
 ## set this to a writable schema. GreptimeDB will use `meta_schema_name`.`meta_table_name`.
 ## **Only used when backend is `postgres_store`.**
+## Unset by default; this example sets it to `greptime_schema`.
+## @toml2docs:none-default
 meta_schema_name = "greptime_schema"
 
 ## Automatically create PostgreSQL schema if it doesn't exist.
@@ -88,11 +90,16 @@ node_max_idle_time = "24hours"
 ## The runtime options.
 #+ [runtime]
 ## The number of threads to execute the runtime for global read operations.
+## Defaults to max(num_cpus, 2).
+## @toml2docs:none-default="Auto"
 #+ global_rt_size = 8
 ## The number of threads to execute compact operations.
+## Defaults to max(num_cpus / 2, 2).
+## @toml2docs:none-default="Auto"
 #+ compact_rt_size = 4
 ## The maximum number of blocking threads for compact operations.
 ## Defaults to max(num_cpus / 2, 2).
+## @toml2docs:none-default="Auto"
 #+ compact_rt_max_blocking_threads = 4
 
 ## TLS configuration for kv store backend (applicable for etcd, PostgreSQL, and MySQL backends)
@@ -140,6 +147,7 @@ bind_addr = "127.0.0.1:3002"
 ## The communication server address for the frontend and datanode to connect to metasrv.
 ## If left empty or unset, the server will automatically use the IP address of the first network interface
 ## on the host, with the same port number as the one specified in `grpc.bind_addr`.
+## @toml2docs:none-default
 server_addr = "127.0.0.1:3002"
 ## The number of server worker threads.
 runtime_size = 8
@@ -206,7 +214,8 @@ acceptable_heartbeat_pause = "10000ms"
 ## Operation timeout.
 timeout = "10s"
 
-## Connect server timeout.
+## Connect server timeout. Defaults to `1s`; this example sets it to `10s`.
+## @toml2docs:none-default="1s"
 connect_timeout = "10s"
 
 ## `TCP_NODELAY` option for accepted connections.
@@ -332,6 +341,7 @@ ttl = "90d"
 ## `reconcile_database`, `reconcile_table`, `reconcile_logical_tables`.
 ## When omitted, all current and future event types are recorded.
 ## Set to an empty array to disable event recording.
+## @toml2docs:none-default="All"
 #+ event_types = ["region_migration"]
 
 ## Configuration options for the stats persistence.
diff --git a/config/standalone.example.toml b/config/standalone.example.toml
index 417a3da6220..cebbf8ac265 100644
--- a/config/standalone.example.toml
+++ b/config/standalone.example.toml
@@ -20,8 +20,8 @@ default_column_prefix = "greptime"
 ## Password verifier formats: "plain:<password>", "pbkdf2_sha256:<iterations>:<hex_salt>:<hex_hash>",
 ## "mysql_native_password:<hex_sha1_sha1_password>",
 ## "pg_scram_sha256:<iterations>:<hex_salt>:<hex_stored_key>:<hex_server_key>"
-## "pbkdf2_sha256" and "pg_scram_sha256" protect passwords at rest, but cannot authenticate over MySQL's
-## native password handshake; a MySQL client must send the password in cleartext for such users.
+## "pbkdf2_sha256" and "pg_scram_sha256" protect passwords at rest, but such users cannot log in over MySQL:
+## `static_user_provider` and `watch_file_user_provider` only negotiate `mysql_native_password`, which cannot verify these formats.
 ## "mysql_native_password" is MySQL-specific and cannot authenticate over PostgreSQL at all.
 ## PostgreSQL SCRAM only covers "plain" and "pg_scram_sha256" users; if any user is "pbkdf2_sha256" or
 ## "mysql_native_password", PostgreSQL falls back to cleartext password auth for every user.
@@ -33,12 +33,11 @@ default_column_prefix = "greptime"
 
 ## Maximum total memory for all concurrent write request bodies and messages (HTTP, gRPC, Flight).
 ## Set to 0 to disable the limit. Default: "0" (unlimited)
-## @toml2docs:none-default
+## @toml2docs:none-default="0"
 #+ max_in_flight_write_bytes = "1GB"
 
 ## Policy when write bytes quota is exhausted.
 ## Options: "wait" (default, 10s timeout), "wait(<duration>)" (e.g., "wait(30s)"), "fail"
-## @toml2docs:none-default
 #+ write_bytes_exhausted_policy = "wait"
 
 ## Initialize all regions in the background during the startup.
@@ -48,20 +47,22 @@ init_regions_in_background = false
 ## Parallelism of initializing regions.
 init_regions_parallelism = 16
 
-## The maximum concurrent queries allowed to be executed. Zero means unlimited.
-max_concurrent_queries = 0
-
 ## Enable telemetry to collect anonymous usage data. Enabled by default.
 #+ enable_telemetry = true
 
 ## The runtime options.
 #+ [runtime]
 ## The number of threads to execute the runtime for global read operations.
+## Defaults to max(num_cpus, 2).
+## @toml2docs:none-default="Auto"
 #+ global_rt_size = 8
 ## The number of threads to execute compact operations.
+## Defaults to max(num_cpus / 2, 2).
+## @toml2docs:none-default="Auto"
 #+ compact_rt_size = 4
 ## The maximum number of blocking threads for compact operations.
 ## Defaults to max(num_cpus / 2, 2).
+## @toml2docs:none-default="Auto"
 #+ compact_rt_max_blocking_threads = 4
 
 ## Experimental weighted, work-conserving query/write task scheduler.
@@ -339,7 +340,8 @@ prefill_log_files = false
 ## **It's only used when the provider is `raft_engine`**.
 sync_period = "5s"
 
-## Parallelism during WAL recovery.
+## Parallelism during WAL recovery. Defaults to the number of CPU cores; this example sets it to 2.
+## @toml2docs:none-default="Auto"
 recovery_parallelism = 2
 
 ## The Kafka broker endpoints.
@@ -533,9 +535,10 @@ parallelism = 0
 
 ## Memory pool size for query execution operators (aggregation, sorting, join).
 ## Supports absolute size (e.g., "2GB", "4GB") or percentage of system memory (e.g., "20%").
-## Setting it to 0 disables the limit (unbounded, default behavior).
+## Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.
 ## When this limit is reached, queries will fail with ResourceExhausted error.
 ## NOTE: This does NOT limit memory used by table scans.
+## @toml2docs:none-default="0"
 memory_pool_size = "50%"
 
 ## Experimental memory pool allocation policy:
@@ -715,7 +718,8 @@ skip_ssl_validation = false
 ## The Mito engine options.
 [region_engine.mito]
 
-## Number of region workers.
+## Number of region workers. Defaults to half of the available CPU cores, rounded up.
+## @toml2docs:none-default="Auto"
 #+ num_workers = 8
 
 ## Request channel size of each worker.
@@ -1057,19 +1061,21 @@ default_ratio = 1.0
 ## The slow query log options.
 [slow_query]
 ## Whether to enable slow query log.
-#+ enable = false
+enable = true
 
 ## The record type of slow queries. It can be `system_table` or `log`.
-## @toml2docs:none-default
-#+ record_type = "system_table"
+## If `system_table` is selected, the slow queries will be recorded in a system table `greptime_private.slow_queries`.
+## If `log` is selected, the slow queries will be logged in a log file `greptimedb-slow-queries.*`.
+record_type = "system_table"
 
-## The threshold of slow query.
-## @toml2docs:none-default
-#+ threshold = "10s"
+## The threshold of slow query. It can be human readable time string, for example: `10s`, `100ms`, `1s`.
+threshold = "30s"
 
-## The sampling ratio of slow query log. The value should be in the range of (0, 1].
-## @toml2docs:none-default
-#+ sample_ratio = 1.0
+## The sampling ratio of slow query log. The value should be in the range of (0, 1]. For example, `0.1` means 10% of the slow queries will be logged and `1.0` means all slow queries will be logged.
+sample_ratio = 1.0
+
+## The TTL of the `slow_queries` system table. Default is `90d` when `record_type` is `system_table`.
+ttl = "90d"
 
 ## The tracing options. Only effect when compiled with `tokio-console` feature.
 #+ [tracing]
@@ -1094,6 +1100,7 @@ ttl = "90d"
 ## `reconcile_database`, `reconcile_table`, `reconcile_logical_tables`.
 ## When omitted, all current and future event types are recorded.
 ## Set to an empty array to disable event recording.
+## @toml2docs:none-default="All"
 #+ event_types = ["create_database"]
 
 ## The memory options.
diff --git a/flake.lock b/flake.lock
index 27c1797f10b..621f1e2f3a0 100644
--- a/flake.lock
+++ b/flake.lock
@@ -8,11 +8,11 @@
         "rust-analyzer-src": "rust-analyzer-src"
       },
       "locked": {
-        "lastModified": 1785314864,
-        "narHash": "sha256-imz9J5iMNersDeQ1ymenFg35N6C2R3MCaGg2i0XCIrE=",
+        "lastModified": 1790642863,
+        "narHash": "sha256-JIwE6EnebvxW7QFFEitWHuZDXwN6Qcf6ZC8DIvYW3y8=",
         "owner": "nix-community",
         "repo": "fenix",
-        "rev": "594418b2c9ea0731bee6988236ef5bfd97e81dca",
+        "rev": "a8f386c482e78e9a48be5abecdc17a9b098a95a1",
         "type": "github"
       },
       "original": {
@@ -41,11 +41,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1785133411,
-        "narHash": "sha256-Yjv0WEg39KRYS0rBdTbu6Fc/or/ihAKk13W9sQ6VWd0=",
+        "lastModified": 1790533781,
+        "narHash": "sha256-F+b8u43BVF5DlM0pz7JQSbtbwKy5PrHIT5zQUekXsD0=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "2f5a153c270b70cb0f8c11f46d96d6d3bc39f4e3",
+        "rev": "cf5e76507c6e23b59f7e0ffcc7baa2a39ddd8442",
         "type": "github"
       },
       "original": {
@@ -65,11 +65,11 @@
     "rust-analyzer-src": {
       "flake": false,
       "locked": {
-        "lastModified": 1785261141,
-        "narHash": "sha256-sA+DHPejWD68mLA7gtTiHGd5T41F6W+NKf0g+ibFCW4=",
+        "lastModified": 1790532271,
+        "narHash": "sha256-j8y/AO3AMDF9p+11aIDhnA21JnNj5PjvcejTI43vI8Q=",
         "owner": "rust-lang",
         "repo": "rust-analyzer",
-        "rev": "bec66814323579659ffd77c909b3d963af118ece",
+        "rev": "03fcb77246f2568adb0e9b2fa60d19c6cc1686f4",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index 6e4151fb3e8..df71403b24f 100644
--- a/flake.nix
+++ b/flake.nix
@@ -22,7 +22,7 @@
         lib = nixpkgs.lib;
         rustToolchain = fenix.packages.${system}.fromToolchainName {
           name = (lib.importTOML ./rust-toolchain.toml).toolchain.channel;
-          sha256 = "sha256-h+t2xTBz5yt2YIO+1VMIIGlCU7gyp2LYOFvaV1nwOXU=";
+          sha256 = "sha256-p8h3Sl/YRByZfZTAKXdsvF6xEenXKrXSVvpphmZENH4=";
         };
       in
       {
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 2d45363a5be..642220914d8 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,2 +1,2 @@
 [toolchain]
-channel = "1.96.1"
+channel = "1.98.1"
diff --git a/src/catalog/src/kvbackend/client.rs b/src/catalog/src/kvbackend/client.rs
index 69b31d62322..402af1d9865 100644
--- a/src/catalog/src/kvbackend/client.rs
+++ b/src/catalog/src/kvbackend/client.rs
@@ -192,6 +192,10 @@ impl KvBackend for CachedKvBackend {
             }
         }
 
+        if miss_keys.is_empty() {
+            return Ok(BatchGetResponse { kvs });
+        }
+
         let batch_get_req = BatchGetRequest::new().with_keys(miss_keys.clone());
 
         let pre_version = self.version();
@@ -503,6 +507,7 @@ mod tests {
     pub struct SimpleKvBackend {
         inner_map: DashMap<Vec<u8>, Vec<u8>>,
         get_execute_times: Arc<AtomicU32>,
+        batch_get_execute_times: Arc<AtomicU32>,
     }
 
     impl TxnService for SimpleKvBackend {
@@ -520,6 +525,7 @@ mod tests {
         }
 
         async fn batch_get(&self, req: BatchGetRequest) -> Result<BatchGetResponse, Self::Error> {
+            self.batch_get_execute_times.fetch_add(1, Ordering::SeqCst);
             let mut kvs = Vec::with_capacity(req.keys.len());
             for key in req.keys.iter() {
                 if let Some(kv) = self.get(key).await? {
@@ -571,6 +577,7 @@ mod tests {
     async fn test_cached_kv_backend() {
         let simple_kv = Arc::new(SimpleKvBackend::default());
         let get_execute_times = simple_kv.get_execute_times.clone();
+        let batch_get_execute_times = simple_kv.batch_get_execute_times.clone();
         let cached_kv = CachedKvBackend::wrap(simple_kv);
 
         add_some_vals(&cached_kv).await;
@@ -582,9 +589,11 @@ mod tests {
         assert_eq!(get_execute_times.load(Ordering::SeqCst), 0);
 
         for _ in 0..10 {
-            let _batch_get_resp = cached_kv.batch_get(batch_get_req.clone()).await.unwrap();
+            let batch_get_resp = cached_kv.batch_get(batch_get_req.clone()).await.unwrap();
 
+            assert_eq!(batch_get_resp.kvs.len(), 2);
             assert_eq!(get_execute_times.load(Ordering::SeqCst), 2);
+            assert_eq!(batch_get_execute_times.load(Ordering::SeqCst), 1);
         }
 
         let batch_get_req = BatchGetRequest {
@@ -594,14 +603,29 @@ mod tests {
         let _batch_get_resp = cached_kv.batch_get(batch_get_req.clone()).await.unwrap();
 
         assert_eq!(get_execute_times.load(Ordering::SeqCst), 3);
+        assert_eq!(batch_get_execute_times.load(Ordering::SeqCst), 2);
 
         for _ in 0..10 {
-            let _batch_get_resp = cached_kv.batch_get(batch_get_req.clone()).await.unwrap();
+            let batch_get_resp = cached_kv.batch_get(batch_get_req.clone()).await.unwrap();
 
+            assert_eq!(batch_get_resp.kvs.len(), 3);
             assert_eq!(get_execute_times.load(Ordering::SeqCst), 3);
+            assert_eq!(batch_get_execute_times.load(Ordering::SeqCst), 2);
         }
     }
 
+    #[tokio::test]
+    async fn test_cached_kv_backend_empty_batch_get() {
+        let simple_kv = Arc::new(SimpleKvBackend::default());
+        let cached_kv = CachedKvBackend::wrap(simple_kv.clone());
+
+        let response = cached_kv.batch_get(BatchGetRequest::new()).await.unwrap();
+
+        assert!(response.kvs.is_empty());
+        assert_eq!(simple_kv.batch_get_execute_times.load(Ordering::SeqCst), 0);
+        assert_eq!(simple_kv.get_execute_times.load(Ordering::SeqCst), 0);
+    }
+
     #[tokio::test]
     async fn test_cached_kv_backend_rejects_writes_with_read_only_inner() {
         let inner = Arc::new(MemoryKvBackend::<common_meta::error::Error>::new());
diff --git a/src/catalog/src/system_schema/information_schema/partitions.rs b/src/catalog/src/system_schema/information_schema/partitions.rs
index 4b00d367129..3bb3c29b704 100644
--- a/src/catalog/src/system_schema/information_schema/partitions.rs
+++ b/src/catalog/src/system_schema/information_schema/partitions.rs
@@ -263,6 +263,51 @@ impl InformationSchemaPartitionsBuilder {
 
         let predicates = Predicates::from_scan_request(&request);
 
+        // Fast path: when the predicates pin both the schema and the table name
+        // with equality, resolve the table directly instead of enumerating all
+        // tables in all schemas and fetching partition metadata for each of them.
+        if let (Some(schema_name), Some(table_name)) = (
+            predicates
+                .find_eq_value(TABLE_SCHEMA)
+                .and_then(Value::as_string),
+            predicates
+                .find_eq_value(TABLE_NAME)
+                .and_then(Value::as_string),
+        ) {
+            if let Some(table) = catalog_manager
+                .table(&catalog_name, &schema_name, &table_name, None)
+                .await?
+            {
+                let table_info = table.table_info();
+
+                // The enumeration path below skips temporary tables, keep the
+                // behavior identical.
+                if table_info.table_type != TableType::Temporary {
+                    let mut table_partitions = partition_manager
+                        .batch_find_table_partitions(&[table_info.table_id()])
+                        .await
+                        .context(FindPartitionsSnafu)?;
+
+                    let partitions = table_partitions
+                        .remove(&table_info.table_id())
+                        .unwrap_or_default();
+
+                    self.add_partitions(
+                        &predicates,
+                        &table_info,
+                        &catalog_name,
+                        &schema_name,
+                        &table_info.name,
+                        &partitions,
+                    );
+                }
+            }
+
+            // The pinned table fully determines the result: the table above was
+            // found (or not) unambiguously, so no other table can contribute rows.
+            return self.finish();
+        }
+
         for schema_name in catalog_manager.schema_names(&catalog_name, None).await? {
             let table_info_stream = catalog_manager
                 .tables(&catalog_name, &schema_name, None)
@@ -430,3 +475,253 @@ impl DfPartitionStream for InformationSchemaPartitions {
         ))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use api::v1::meta::Peer;
+    use cache::{build_fundamental_cache_registry, with_default_composite_cache_registry};
+    use common_catalog::consts::{DEFAULT_CATALOG_NAME, INFORMATION_SCHEMA_NAME};
+    use common_meta::cache::{CacheRegistryBuilder, LayeredCacheRegistryBuilder};
+    use common_meta::key::schema_name::SchemaNameKey;
+    use common_meta::key::table_route::TableRouteValue;
+    use common_meta::kv_backend::memory::MemoryKvBackend;
+    use common_meta::rpc::router::{Region, RegionRoute};
+    use common_meta::wal_provider::RegionWalOptions;
+    use datafusion::logical_expr::{BinaryExpr, Expr, Operator, col, lit};
+    use futures::TryStreamExt;
+    use store_api::storage::RegionId;
+
+    use super::*;
+    use crate::information_schema::NoopInformationExtension;
+    use crate::kvbackend::KvBackendCatalogManagerBuilder;
+
+    const SCHEMA_1: &str = "partitions_schema_1";
+    const SCHEMA_2: &str = "partitions_schema_2";
+    const PARTITIONED_TABLE: &str = "partitioned_table";
+    const MISSING_TABLE: &str = "missing_table";
+    const TABLE_ID_1: TableId = 1;
+    const TABLE_ID_2: TableId = 2;
+    const REGION_NUMBER_1: u32 = 1;
+    const REGION_NUMBER_2: u32 = 2;
+    const REGION_NUMBER_7: u32 = 7;
+
+    fn kv_catalog_manager() -> Arc<KvBackendCatalogManager> {
+        let backend = Arc::new(MemoryKvBackend::default());
+        let layered_cache_builder = LayeredCacheRegistryBuilder::default()
+            .add_cache_registry(CacheRegistryBuilder::default().build());
+        let fundamental_cache_registry = build_fundamental_cache_registry(backend.clone());
+        let layered_cache_registry = Arc::new(
+            with_default_composite_cache_registry(
+                layered_cache_builder.add_cache_registry(fundamental_cache_registry),
+            )
+            .unwrap()
+            .build(),
+        );
+
+        KvBackendCatalogManagerBuilder::new(
+            Arc::new(NoopInformationExtension),
+            backend,
+            layered_cache_registry,
+        )
+        .build()
+    }
+
+    fn region_route(table_id: TableId, region_number: u32) -> RegionRoute {
+        RegionRoute {
+            region: Region {
+                id: RegionId::new(table_id, region_number),
+                ..Default::default()
+            },
+            leader_peer: Some(Peer {
+                id: 1,
+                addr: "127.0.0.1:3001".to_string(),
+            }),
+            ..Default::default()
+        }
+    }
+
+    fn table_info(schema: &str, table: &str, table_id: TableId) -> TableInfo {
+        // The catalog defaults to the default catalog name.
+        let mut table_info =
+            common_meta::key::test_utils::new_test_table_info_with_name(table_id, table);
+        table_info.schema_name = schema.to_string();
+        table_info
+    }
+
+    /// Creates a catalog with two partitioned tables named `PARTITIONED_TABLE`
+    /// in two different schemas:
+    ///
+    /// - `SCHEMA_1.PARTITIONED_TABLE` has two regions.
+    /// - `SCHEMA_2.PARTITIONED_TABLE` has one region.
+    async fn setup_catalog() -> Arc<KvBackendCatalogManager> {
+        let manager = kv_catalog_manager();
+        let metadata = manager.table_metadata_manager_ref().clone();
+
+        for schema in [SCHEMA_1, SCHEMA_2] {
+            metadata
+                .schema_manager()
+                .create(SchemaNameKey::new(DEFAULT_CATALOG_NAME, schema), None, true)
+                .await
+                .unwrap();
+        }
+
+        for (table_id, schema, region_numbers) in [
+            (TABLE_ID_1, SCHEMA_1, vec![REGION_NUMBER_1, REGION_NUMBER_2]),
+            (TABLE_ID_2, SCHEMA_2, vec![REGION_NUMBER_7]),
+        ] {
+            let routes = region_numbers
+                .into_iter()
+                .map(|region_number| region_route(table_id, region_number))
+                .collect();
+            metadata
+                .create_table_metadata(
+                    table_info(schema, PARTITIONED_TABLE, table_id),
+                    TableRouteValue::physical(routes),
+                    RegionWalOptions::default(),
+                )
+                .await
+                .unwrap();
+        }
+
+        manager
+    }
+
+    /// Scans `information_schema.partitions` and returns the total row count
+    /// and the pretty printed batches.
+    async fn scan_partitions(
+        manager: &Arc<dyn CatalogManager>,
+        filters: Vec<Expr>,
+    ) -> (usize, String) {
+        let table = manager
+            .table(
+                DEFAULT_CATALOG_NAME,
+                INFORMATION_SCHEMA_NAME,
+                PARTITIONS,
+                None,
+            )
+            .await
+            .unwrap()
+            .unwrap();
+        let stream = table
+            .scan_to_stream(ScanRequest {
+                filters,
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+        let batches = stream.try_collect::<Vec<_>>().await.unwrap();
+        let rows = batches.iter().map(|batch| batch.num_rows()).sum();
+        let output = batches
+            .iter()
+            .map(|batch| batch.pretty_print())
+            .collect::<Vec<_>>()
+            .join("\n");
+        (rows, output)
+    }
+
+    fn eq_filter(column: &str, value: &str) -> Expr {
+        Expr::BinaryExpr(BinaryExpr::new(
+            Box::new(col(column)),
+            Operator::Eq,
+            Box::new(lit(value)),
+        ))
+    }
+
+    fn not_eq_filter(column: &str, value: &str) -> Expr {
+        Expr::BinaryExpr(BinaryExpr::new(
+            Box::new(col(column)),
+            Operator::NotEq,
+            Box::new(lit(value)),
+        ))
+    }
+
+    #[tokio::test]
+    async fn test_scan_pinned_table_skips_catalog_enumeration() {
+        let manager: Arc<dyn CatalogManager> = setup_catalog().await;
+
+        // No predicates: every partitioned table is listed.
+        let (rows, output) = scan_partitions(&manager, vec![]).await;
+        assert_eq!(3, rows, "{output}");
+
+        // Pins both the schema and the table name, so the scan resolves the
+        // table directly instead of enumerating all catalog entries.
+        let (rows, output) = scan_partitions(
+            &manager,
+            vec![
+                eq_filter(TABLE_SCHEMA, SCHEMA_1),
+                eq_filter(TABLE_NAME, PARTITIONED_TABLE),
+            ],
+        )
+        .await;
+        assert_eq!(2, rows, "{output}");
+        assert!(output.contains(SCHEMA_1), "{output}");
+        assert!(!output.contains(SCHEMA_2), "{output}");
+        assert!(
+            output.contains(
+                &RegionId::new(TABLE_ID_1, REGION_NUMBER_1)
+                    .as_u64()
+                    .to_string()
+            ),
+            "{output}"
+        );
+        assert!(
+            output.contains(
+                &RegionId::new(TABLE_ID_1, REGION_NUMBER_2)
+                    .as_u64()
+                    .to_string()
+            ),
+            "{output}"
+        );
+
+        // The fallback enumeration path must return the identical result. The
+        // inequality on `table_name` doesn't pin a single name, so no direct
+        // lookup happens here.
+        let (fallback_rows, fallback_output) = scan_partitions(
+            &manager,
+            vec![
+                eq_filter(TABLE_SCHEMA, SCHEMA_1),
+                not_eq_filter(TABLE_NAME, MISSING_TABLE),
+            ],
+        )
+        .await;
+        assert_eq!(rows, fallback_rows, "{fallback_output}");
+        assert_eq!(output, fallback_output);
+
+        // Only the table name is pinned: the schema can't be resolved and both
+        // tables of that name are kept.
+        let (rows, output) =
+            scan_partitions(&manager, vec![eq_filter(TABLE_NAME, PARTITIONED_TABLE)]).await;
+        assert_eq!(3, rows, "{output}");
+        assert!(output.contains(SCHEMA_1), "{output}");
+        assert!(output.contains(SCHEMA_2), "{output}");
+
+        // An unknown table in a pinned schema yields no rows.
+        let (rows, output) = scan_partitions(
+            &manager,
+            vec![
+                eq_filter(TABLE_SCHEMA, SCHEMA_1),
+                eq_filter(TABLE_NAME, MISSING_TABLE),
+            ],
+        )
+        .await;
+        assert_eq!(0, rows, "{output}");
+    }
+
+    #[tokio::test]
+    async fn test_scan_equality_under_disjunction_falls_back_to_enumeration() {
+        let manager: Arc<dyn CatalogManager> = setup_catalog().await;
+
+        // `table_schema = SCHEMA_1 OR table_name = PARTITIONED_TABLE` matches
+        // the tables in both schemas: equality nested under a disjunction must
+        // not pin a single table.
+        let filter = Expr::BinaryExpr(BinaryExpr::new(
+            Box::new(eq_filter(TABLE_SCHEMA, SCHEMA_1)),
+            Operator::Or,
+            Box::new(eq_filter(TABLE_NAME, PARTITIONED_TABLE)),
+        ));
+        let (rows, output) = scan_partitions(&manager, vec![filter]).await;
+        assert_eq!(3, rows, "{output}");
+        assert!(output.contains(SCHEMA_1), "{output}");
+        assert!(output.contains(SCHEMA_2), "{output}");
+    }
+}
diff --git a/src/catalog/src/system_schema/predicate.rs b/src/catalog/src/system_schema/predicate.rs
index 7957ba454d4..cb71e51ed0e 100644
--- a/src/catalog/src/system_schema/predicate.rs
+++ b/src/catalog/src/system_schema/predicate.rs
@@ -214,6 +214,22 @@ impl Predicate {
             _ => None,
         }
     }
+
+    /// Collects the values that constrain `column` to be equal to them at this
+    /// predicate's top-level conjunctions.
+    ///
+    /// Constraints under `Or`/`Not` are ignored because they don't guarantee
+    /// that `column` equals a single value.
+    fn collect_eq_values<'a>(&'a self, column: &str, values: &mut Vec<&'a Value>) {
+        match self {
+            Predicate::Eq(c, v) if c == column => values.push(v),
+            Predicate::And(left, right) => {
+                left.collect_eq_values(column, values);
+                right.collect_eq_values(column, values);
+            }
+            _ => {}
+        }
+    }
 }
 
 /// Perform SQL left LIKE right, return `None` if fail to evaluate.
@@ -269,6 +285,25 @@ impl Predicates {
         }
     }
 
+    /// Returns the single equality value that constrains `column` in the
+    /// top-level conjunctions of the predicates.
+    ///
+    /// Returns `None` if there is no equality constraint on `column`, or if
+    /// the predicates constrain it with multiple distinct values.
+    pub fn find_eq_value(&self, column: &str) -> Option<&Value> {
+        let mut values = Vec::new();
+        for predicate in &self.predicates {
+            predicate.collect_eq_values(column, &mut values);
+        }
+
+        let (first, rest) = values.split_first()?;
+        if rest.iter().all(|v| v == first) {
+            Some(*first)
+        } else {
+            None
+        }
+    }
+
     /// Evaluate the predicates with the row.
     /// returns true when all the predicates are satisfied or can't be evaluated.
     pub fn eval(&self, row: &[(&str, &Value)]) -> bool {
@@ -556,6 +591,71 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_find_eq_value() {
+        fn eq(name: &str, value: &str) -> Predicate {
+            Predicate::Eq(name.to_string(), Value::from(value))
+        }
+
+        fn and(left: Predicate, right: Predicate) -> Predicate {
+            Predicate::And(Box::new(left), Box::new(right))
+        }
+
+        fn or(left: Predicate, right: Predicate) -> Predicate {
+            Predicate::Or(Box::new(left), Box::new(right))
+        }
+
+        fn predicates(predicates: Vec<Predicate>) -> Predicates {
+            Predicates { predicates }
+        }
+
+        // No predicates, no equality value.
+        assert!(predicates(vec![]).find_eq_value("a").is_none());
+
+        // No equality on the column.
+        let p = predicates(vec![Predicate::NotEq("a".to_string(), Value::from("x"))]);
+        assert!(p.find_eq_value("a").is_none());
+        assert!(p.find_eq_value("b").is_none());
+
+        // Simple equality.
+        let p = predicates(vec![eq("a", "x")]);
+        let v = p.find_eq_value("a").unwrap();
+        assert!(match_string_value(v, "x"));
+        assert!(p.find_eq_value("b").is_none());
+
+        // Duplicated equality on the same value.
+        let p = predicates(vec![and(eq("a", "x"), eq("a", "x"))]);
+        let v = p.find_eq_value("a").unwrap();
+        assert!(match_string_value(v, "x"));
+
+        // Conflicting equalities reject the lookup.
+        let p = predicates(vec![and(eq("a", "x"), eq("a", "y"))]);
+        assert!(p.find_eq_value("a").is_none());
+
+        // Conflicting equalities in separate predicates reject the lookup too.
+        let p = predicates(vec![eq("a", "x"), eq("a", "y")]);
+        assert!(p.find_eq_value("a").is_none());
+
+        // Equality nested in deeper conjunctions.
+        let p = predicates(vec![and(and(eq("b", "y"), eq("a", "x")), eq("a", "x"))]);
+        let v = p.find_eq_value("a").unwrap();
+        assert!(match_string_value(v, "x"));
+
+        // Equality under a disjunction or a negation doesn't constrain the column.
+        let p = predicates(vec![or(eq("a", "x"), eq("a", "x"))]);
+        assert!(p.find_eq_value("a").is_none());
+        let p = predicates(vec![Predicate::Not(Box::new(eq("a", "x")))]);
+        assert!(p.find_eq_value("a").is_none());
+
+        // Equality value in a top-level conjunction composed of separate predicates.
+        let p = predicates(vec![
+            eq("a", "x"),
+            Predicate::Like("b".to_string(), "%y".to_string(), false),
+        ]);
+        let v = p.find_eq_value("a").unwrap();
+        assert!(match_string_value(v, "x"));
+    }
+
     #[test]
     fn test_predicates_eval_row() {
         let wrong_row = [
diff --git a/src/cli/src/common/store.rs b/src/cli/src/common/store.rs
index e974037ea4d..c3b8e477ed1 100644
--- a/src/cli/src/common/store.rs
+++ b/src/cli/src/common/store.rs
@@ -86,7 +86,13 @@ pub struct StoreConfig {
 
     /// Automatically create PostgreSQL schema if it doesn't exist (default: true).
     #[cfg(feature = "pg_kvbackend")]
-    #[clap(long, default_value_t = true)]
+    #[clap(
+        long,
+        default_value_t = true,
+        default_missing_value = "true",
+        num_args = 0..=1,
+        action = clap::ArgAction::Set
+    )]
     pub auto_create_schema: bool,
 
     /// TLS mode for backend store connections (etcd, PostgreSQL, MySQL)
@@ -223,3 +229,27 @@ impl StoreConfig {
         }
     }
 }
+
+#[cfg(all(test, feature = "pg_kvbackend"))]
+mod tests {
+    use clap::Parser;
+
+    use super::StoreConfig;
+
+    #[test]
+    fn test_auto_create_schema_accepts_explicit_value() {
+        let config =
+            StoreConfig::try_parse_from(["store", "--auto-create-schema", "false"]).unwrap();
+        assert!(!config.auto_create_schema);
+
+        let config =
+            StoreConfig::try_parse_from(["store", "--auto-create-schema", "true"]).unwrap();
+        assert!(config.auto_create_schema);
+    }
+
+    #[test]
+    fn test_auto_create_schema_defaults_to_true() {
+        let config = StoreConfig::try_parse_from(["store"]).unwrap();
+        assert!(config.auto_create_schema);
+    }
+}
diff --git a/src/client/Cargo.toml b/src/client/Cargo.toml
index 36c3f60a9a4..e5bd479cc7d 100644
--- a/src/client/Cargo.toml
+++ b/src/client/Cargo.toml
@@ -45,3 +45,4 @@ substrait.workspace = true
 tokio.workspace = true
 tokio-stream = { workspace = true, features = ["net"] }
 tonic.workspace = true
+tonic-prost.workspace = true
diff --git a/src/client/src/client.rs b/src/client/src/client.rs
index dfc0e44fad5..1746854cd26 100644
--- a/src/client/src/client.rs
+++ b/src/client/src/client.rs
@@ -20,7 +20,6 @@ use api::v1::HealthCheckRequest;
 use api::v1::flow::flow_client::FlowClient as PbFlowClient;
 use api::v1::health_check_client::HealthCheckClient;
 use api::v1::prometheus_gateway_client::PrometheusGatewayClient;
-use api::v1::region::region_client::RegionClient as PbRegionClient;
 use arrow_flight::flight_service_client::FlightServiceClient;
 use common_grpc::channel_manager::{
     ChannelConfig, ChannelManager, ClientTlsOption, load_client_tls_config,
@@ -526,23 +525,12 @@ impl Client {
         Ok(FlightClient { addr, client })
     }
 
-    pub(crate) fn raw_region_client(&self) -> Result<(String, PbRegionClient<Channel>)> {
+    /// Creates the region gRPC transport with the configured message limits.
+    pub(crate) fn raw_region_client(&self) -> Result<(String, tonic::client::Grpc<Channel>)> {
         let (addr, channel) = self.find_channel()?;
-        let client = PbRegionClient::new(channel)
-            .max_decoding_message_size(
-                self.inner
-                    .control_channel_manager
-                    .config()
-                    .max_recv_message_size
-                    .as_bytes() as usize,
-            )
-            .max_encoding_message_size(
-                self.inner
-                    .control_channel_manager
-                    .config()
-                    .max_send_message_size
-                    .as_bytes() as usize,
-            );
+        let client = tonic::client::Grpc::new(channel)
+            .max_decoding_message_size(self.max_grpc_recv_message_size())
+            .max_encoding_message_size(self.max_grpc_send_message_size());
         Ok((addr, client))
     }
 
diff --git a/src/client/src/database.rs b/src/client/src/database.rs
index e97fff6db00..de3c722a86a 100644
--- a/src/client/src/database.rs
+++ b/src/client/src/database.rs
@@ -16,7 +16,7 @@ use std::collections::HashMap;
 use std::pin::Pin;
 use std::str::FromStr;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, Mutex, RwLock};
 use std::task::{Context, Poll};
 use std::time::Duration;
 
@@ -55,6 +55,7 @@ use futures::future;
 use futures_util::{Stream, StreamExt, TryStreamExt};
 use prost::Message;
 use snafu::{IntoError, ResultExt};
+use tokio::sync::Notify;
 use tonic::metadata::{AsciiMetadataKey, AsciiMetadataValue, MetadataMap, MetadataValue};
 use tonic::transport::Channel;
 
@@ -70,20 +71,47 @@ type FlightDataStream = Pin<Box<dyn Stream<Item = FlightData> + Send>>;
 type DoPutResponseStream = Pin<Box<dyn Stream<Item = Result<DoPutResponse>>>>;
 
 const HINTS_METADATA_KEY: &str = "x-greptime-hints";
+/// Maximum time to wait for the optional trailing metrics message after
+/// affected rows have already been delivered.
+const FLIGHT_TRAILING_METRICS_TIMEOUT: Duration = Duration::from_secs(5);
 
 /// Terminal metrics associated with a query output.
 ///
 /// For streaming outputs, metrics are only final after the stream is fully
-/// drained and [`Self::is_ready`] returns `true`.
+/// drained and [`Self::is_ready`] returns `true`. Affected-row outputs may
+/// briefly await a compatibility trailing metrics message.
 #[derive(Debug, Clone, Default)]
 pub struct OutputMetrics {
     inner: Arc<OutputMetricsInner>,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 struct OutputMetricsInner {
     metrics: RwLock<Option<RecordBatchMetrics>>,
+    completion_error: RwLock<Option<String>>,
     ready: AtomicBool,
+    ready_notify: Notify,
+    compatibility_task: Mutex<Option<tokio::task::AbortHandle>>,
+}
+
+impl Default for OutputMetricsInner {
+    fn default() -> Self {
+        Self {
+            metrics: RwLock::new(None),
+            completion_error: RwLock::new(None),
+            ready: AtomicBool::new(false),
+            ready_notify: Notify::new(),
+            compatibility_task: Mutex::new(None),
+        }
+    }
+}
+
+impl Drop for OutputMetricsInner {
+    fn drop(&mut self) {
+        if let Some(handle) = self.compatibility_task.get_mut().unwrap().take() {
+            handle.abort();
+        }
+    }
 }
 
 impl OutputMetrics {
@@ -98,10 +126,45 @@ impl OutputMetrics {
 
     /// Marks the terminal metrics as final for this output.
     pub fn mark_ready(&self) {
-        let _ = self
+        if self
             .inner
             .ready
-            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire);
+            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .is_ok()
+        {
+            self.inner.ready_notify.notify_waiters();
+        }
+    }
+
+    /// Waits until terminal metrics are final.
+    pub async fn wait_ready(&self) {
+        loop {
+            let notified = self.inner.ready_notify.notified();
+            if self.is_ready() {
+                return;
+            }
+            notified.await;
+        }
+    }
+
+    /// Returns an error encountered while completing the output, if any.
+    pub fn completion_error(&self) -> Option<String> {
+        self.inner.completion_error.read().unwrap().clone()
+    }
+
+    fn set_completion_error(&self, error: impl Into<String>) {
+        *self.inner.completion_error.write().unwrap() = Some(error.into());
+    }
+
+    fn set_compatibility_task(&self, handle: tokio::task::AbortHandle) {
+        let mut task = self.inner.compatibility_task.lock().unwrap();
+        if !self.is_ready() {
+            *task = Some(handle);
+        }
+    }
+
+    fn take_compatibility_task(&self) -> Option<tokio::task::AbortHandle> {
+        self.inner.compatibility_task.lock().unwrap().take()
     }
 
     /// Returns whether terminal metrics are final.
@@ -148,7 +211,8 @@ impl OutputMetrics {
 ///
 /// The contained [`OutputMetrics`] lets callers read stream terminal metrics
 /// after consuming `output`. For non-stream outputs, metrics are ready
-/// immediately.
+/// immediately. Flight affected-row outputs without inline metrics require
+/// [`OutputMetrics::wait_ready`] before compatibility trailing metrics can be read.
 #[derive(Debug)]
 pub struct OutputWithMetrics {
     pub output: Output,
@@ -194,6 +258,55 @@ fn parse_terminal_metrics(metrics_json: &str) -> Result<RecordBatchMetrics> {
     })
 }
 
+fn spawn_affected_rows_trailing_metrics_task<S>(
+    terminal_metrics: &OutputMetrics,
+    mut reader: FlightMessageReader<S>,
+) where
+    S: Stream<Item = Result<FlightMessage>> + Send + Unpin + 'static,
+{
+    let metrics_ref = Arc::downgrade(&terminal_metrics.inner);
+    let remote_addr = reader.remote_addr().to_string();
+    let task = common_runtime::spawn_global(async move {
+        let result =
+            tokio::time::timeout(FLIGHT_TRAILING_METRICS_TIMEOUT, reader.read_next()).await;
+        let Some(inner) = metrics_ref.upgrade() else {
+            return;
+        };
+        let metrics = OutputMetrics { inner };
+        match result {
+            Ok(Ok(Some(FlightMessage::Metrics(s)))) => match parse_terminal_metrics(&s) {
+                Ok(metrics_json) => metrics.update(Some(metrics_json)),
+                Err(error) => {
+                    metrics.set_completion_error(error.to_string());
+                    warn!(
+                        "Failed to decode trailing Flight metrics from {}: {}",
+                        remote_addr, error
+                    );
+                }
+            },
+            Ok(Ok(None)) => {}
+            Ok(Ok(Some(other))) => {
+                let error = format!("Unexpected trailing Flight message: {other:?}");
+                metrics.set_completion_error(error.clone());
+                warn!("{} from {}", error, remote_addr);
+            }
+            Ok(Err(error)) => {
+                let error = flight_stream_error(&remote_addr, error);
+                metrics.set_completion_error(error.to_string());
+                warn!("{}", error);
+            }
+            Err(_) => {
+                let error = "Timed out waiting for trailing Flight metrics";
+                metrics.set_completion_error(error);
+                warn!("{} from {}", error, remote_addr);
+            }
+        }
+        metrics.mark_ready();
+        metrics.take_compatibility_task();
+    });
+    terminal_metrics.set_compatibility_task(task.abort_handle());
+}
+
 struct StreamWithMetrics {
     stream: common_recordbatch::SendableRecordBatchStream,
     metrics: OutputMetrics,
@@ -233,6 +346,9 @@ impl Stream for StreamWithMetrics {
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let polled = Pin::new(&mut self.stream).poll_next(cx);
+        if let Poll::Ready(Some(Err(error))) = &polled {
+            self.metrics.set_completion_error(error.to_string());
+        }
         if let Poll::Ready(None) = &polled {
             self.sync_terminal_metrics();
             self.metrics.mark_ready();
@@ -280,32 +396,12 @@ where
         FlightMessage::AffectedRows { rows, metrics } => {
             let terminal_metrics = OutputMetrics::new();
             if let Some(metrics) = metrics {
+                // Inline metrics are authoritative. They complete the output
+                // without touching the rest of the Flight stream.
                 terminal_metrics.update(Some(parse_terminal_metrics(&metrics)?));
-            }
-            let next_message = reader
-                .read_next()
-                .await
-                .map_err(|error| flight_stream_error(reader.remote_addr(), error))?;
-            match next_message {
-                None => terminal_metrics.mark_ready(),
-                Some(FlightMessage::Metrics(s)) if terminal_metrics.get().is_none() => {
-                    terminal_metrics.update(Some(parse_terminal_metrics(&s)?));
-                    terminal_metrics.mark_ready();
-                }
-                Some(FlightMessage::Metrics(_)) => {
-                    return IllegalFlightMessagesSnafu {
-                        reason: "'AffectedRows' Flight metadata already carries Metrics and cannot be followed by another Metrics message",
-                    }
-                    .fail();
-                }
-                Some(other) => {
-                    return IllegalFlightMessagesSnafu {
-                        reason: format!(
-                            "'AffectedRows' Flight message can only be followed by a Metrics message, got {other:?}"
-                        ),
-                    }
-                    .fail();
-                }
+                terminal_metrics.mark_ready();
+            } else {
+                spawn_affected_rows_trailing_metrics_task(&terminal_metrics, reader);
             }
             Ok(OutputWithMetrics {
                 output: Output::new_with_affected_rows(rows),
@@ -749,7 +845,9 @@ impl Database {
     /// Executes a SQL query and returns the output with terminal metrics.
     ///
     /// For stream outputs, callers must consume the stream before reading final
-    /// terminal metrics from [`OutputWithMetrics::metrics`].
+    /// terminal metrics from [`OutputWithMetrics::metrics`]. For affected-row
+    /// outputs without inline metrics, call [`OutputMetrics::wait_ready`] when
+    /// compatibility trailing metrics are required.
     pub async fn sql_with_terminal_metrics<S>(
         &self,
         sql: S,
@@ -986,6 +1084,7 @@ mod tests {
     use datatypes::schema::{ColumnSchema, Schema};
     use datatypes::vectors::Int32Vector;
     use futures_util::StreamExt;
+    use tokio::sync::oneshot;
     use tonic::codegen::http::{HeaderMap, HeaderValue};
     use tonic::metadata::MetadataMap;
     use tonic::{Code, Status};
@@ -1296,11 +1395,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_parse_terminal_metrics_rejects_invalid_json() {
-        assert!(parse_terminal_metrics("{not-json}").is_err());
-    }
-
     #[tokio::test]
     async fn test_affected_rows_inline_metrics_are_parsed() {
         let output = output_from_flight_message_stream(
@@ -1322,27 +1416,191 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_affected_rows_inline_metrics_rejects_trailing_metrics() {
+    async fn test_affected_rows_inline_metrics_do_not_poll_trailer() {
         let metrics_json = terminal_metrics_json();
-        let err = output_from_flight_message_stream(
+        let output = output_from_flight_message_stream(
             "test-peer".to_string(),
             futures_util::stream::iter(vec![
                 Ok(FlightMessage::AffectedRows {
                     rows: 3,
-                    metrics: Some(metrics_json.clone()),
+                    metrics: Some(metrics_json),
                 }),
-                Ok(FlightMessage::Metrics(metrics_json)),
+                Ok(FlightMessage::Metrics(terminal_metrics_json_with_seq(99))),
             ] as Vec<Result<FlightMessage>>),
         )
         .await
-        .unwrap_err();
+        .unwrap();
 
-        assert!(
-            err.to_string().contains("already carries Metrics"),
-            "unexpected error: {err:?}"
+        assert!(output.metrics.is_ready());
+        assert_eq!(
+            output.metrics.region_watermark_map(),
+            Some(std::collections::HashMap::from([(7, 42)]))
         );
     }
 
+    #[tokio::test]
+    async fn test_affected_rows_without_inline_metrics_becomes_ready_after_trailer() {
+        // Hold the trailer until the not-ready state has been observed.
+        let (trailer_tx, trailer_rx) = oneshot::channel();
+        let trailer = futures_util::stream::once(trailer_rx).map(|ready| {
+            ready.unwrap();
+            Ok(FlightMessage::Metrics(terminal_metrics_json()))
+        });
+        let output = output_from_flight_message_stream(
+            "test-peer".to_string(),
+            futures_util::stream::iter(vec![Ok(FlightMessage::AffectedRows {
+                rows: 3,
+                metrics: None,
+            })])
+            .chain(trailer),
+        )
+        .await
+        .unwrap();
+
+        assert!(!output.metrics.is_ready());
+        trailer_tx.send(()).unwrap();
+        tokio::time::timeout(Duration::from_secs(1), output.metrics.wait_ready())
+            .await
+            .expect("terminal metrics must become ready once the trailer arrives");
+        assert!(output.metrics.completion_error().is_none());
+        assert_eq!(
+            output.metrics.region_watermark_map(),
+            Some(std::collections::HashMap::from([(7, 42)]))
+        );
+    }
+
+    #[tokio::test]
+    async fn test_affected_rows_malformed_trailer_sets_completion_error_and_ready() {
+        let output = output_from_flight_message_stream(
+            "test-peer".to_string(),
+            futures_util::stream::iter(vec![
+                Ok(FlightMessage::AffectedRows {
+                    rows: 3,
+                    metrics: None,
+                }),
+                Ok(FlightMessage::Metrics("{not-json}".to_string())),
+            ] as Vec<Result<FlightMessage>>),
+        )
+        .await
+        .unwrap();
+
+        output.metrics.wait_ready().await;
+        let error = output.metrics.completion_error().unwrap();
+        assert!(error.contains("Invalid terminal metrics message"));
+        assert!(output.metrics.is_ready());
+    }
+
+    #[tokio::test]
+    async fn test_affected_rows_transport_trailer_error_sets_completion_error_and_ready() {
+        let output = output_from_flight_message_stream(
+            "test-peer".to_string(),
+            futures_util::stream::iter(vec![
+                Ok(FlightMessage::AffectedRows {
+                    rows: 3,
+                    metrics: None,
+                }),
+                Err(Status::unavailable("trailer read failed").into()),
+            ] as Vec<Result<FlightMessage>>),
+        )
+        .await
+        .unwrap();
+
+        output.metrics.wait_ready().await;
+        let error = output.metrics.completion_error().unwrap();
+        assert!(error.contains("trailer read failed"));
+        assert!(output.metrics.is_ready());
+    }
+
+    #[tokio::test]
+    async fn test_affected_rows_compatibility_reader_is_cancelled_after_second_poll_begins() {
+        struct DropProbe {
+            first: Option<Result<FlightMessage>>,
+            polled: Option<oneshot::Sender<()>>,
+            dropped: Option<oneshot::Sender<()>>,
+        }
+
+        impl Stream for DropProbe {
+            type Item = Result<FlightMessage>;
+
+            fn poll_next(
+                mut self: Pin<&mut Self>,
+                _cx: &mut Context<'_>,
+            ) -> Poll<Option<Self::Item>> {
+                if let Some(message) = self.first.take() {
+                    return Poll::Ready(Some(message));
+                }
+                if let Some(polled) = self.polled.take() {
+                    let _ = polled.send(());
+                }
+                Poll::Pending
+            }
+        }
+
+        impl Drop for DropProbe {
+            fn drop(&mut self) {
+                if let Some(dropped) = self.dropped.take() {
+                    let _ = dropped.send(());
+                }
+            }
+        }
+
+        let (polled_tx, polled_rx) = oneshot::channel();
+        let (dropped_tx, dropped_rx) = oneshot::channel();
+        let output = output_from_flight_message_stream(
+            "test-peer".to_string(),
+            DropProbe {
+                first: Some(Ok(FlightMessage::AffectedRows {
+                    rows: 3,
+                    metrics: None,
+                })),
+                polled: Some(polled_tx),
+                dropped: Some(dropped_tx),
+            },
+        )
+        .await
+        .unwrap();
+        polled_rx.await.unwrap();
+        drop(output);
+        // Require cancellation before the five-second compatibility timeout.
+        tokio::time::timeout(Duration::from_secs(1), dropped_rx)
+            .await
+            .expect("the compatibility reader must be dropped once the output is dropped")
+            .unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_schema_record_batch_yields_before_pending_message_stream() {
+        let schema = Arc::new(Schema::new(vec![ColumnSchema::new(
+            "v",
+            ConcreteDataType::int32_datatype(),
+            false,
+        )]));
+        let batch = RecordBatch::new(
+            schema.clone(),
+            vec![Arc::new(Int32Vector::from_slice([1])) as VectorRef],
+        )
+        .unwrap();
+        let messages = futures_util::stream::iter(vec![
+            Ok(FlightMessage::Schema(schema.arrow_schema().clone())),
+            Ok(FlightMessage::RecordBatch(batch.into_df_record_batch())),
+        ] as Vec<Result<FlightMessage>>)
+        .chain(futures_util::stream::pending());
+        let output = output_from_flight_message_stream("test-peer".to_string(), messages)
+            .await
+            .unwrap();
+        let OutputData::Stream(mut stream) = output.output.data else {
+            panic!("expected stream output");
+        };
+
+        let batch = tokio::time::timeout(Duration::from_secs(1), stream.next())
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap();
+        assert_eq!(batch.num_rows(), 1);
+        assert!(!output.metrics.is_ready());
+    }
+
     #[tokio::test]
     async fn test_invalid_terminal_metrics_after_record_batch_yields_batch_then_error() {
         let schema = Arc::new(Schema::new(vec![ColumnSchema::new(
diff --git a/src/client/src/error.rs b/src/client/src/error.rs
index 168ba422715..fdf0df9582f 100644
--- a/src/client/src/error.rs
+++ b/src/client/src/error.rs
@@ -18,7 +18,7 @@ use common_error::define_from_tonic_status;
 use common_error::ext::{BoxedError, ErrorExt, RetryHint};
 use common_error::status_code::StatusCode;
 use common_macro::stack_trace_debug;
-use snafu::{Location, Snafu};
+use snafu::{Location, Snafu, location};
 use tonic::Code;
 use tonic::metadata::errors::InvalidMetadataValue;
 
@@ -191,9 +191,22 @@ impl ErrorExt for Error {
             Error::Tonic { retry_hint, .. } => *retry_hint,
             Error::FlightGet { source, .. }
             | Error::FlightStream { source, .. }
-            | Error::RegionServer { source, .. }
             | Error::FlowServer { source, .. }
             | Error::External { source, .. } => source.retry_hint(),
+            Error::RegionServer { code, source, .. } => {
+                let hint = source.retry_hint();
+                // Preserve the transport retry policy previously applied by should_retry().
+                if !hint.is_retryable()
+                    && matches!(
+                        code,
+                        Code::Unavailable | Code::Cancelled | Code::DeadlineExceeded
+                    )
+                {
+                    RetryHint::Retryable
+                } else {
+                    hint
+                }
+            }
             Error::ConvertFlightData { source, .. }
             | Error::CreateChannel { source, .. }
             | Error::CreateTlsChannel { source, .. } => source.retry_hint(),
@@ -205,6 +218,15 @@ impl ErrorExt for Error {
 
 define_from_tonic_status!(Error, Tonic);
 
+impl From<Error> for common_meta::error::Error {
+    fn from(error: Error) -> Self {
+        Self::External {
+            source: BoxedError::new(error),
+            location: location!(),
+        }
+    }
+}
+
 impl Error {
     /// Returns the gRPC status code if this error is caused by a gRPC request failure.
     pub fn tonic_code(&self) -> Option<Code> {
diff --git a/src/client/src/flight.rs b/src/client/src/flight.rs
index 1753fdd5246..3a21e6daa4e 100644
--- a/src/client/src/flight.rs
+++ b/src/client/src/flight.rs
@@ -12,40 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::pin::Pin;
-
 use arrow_flight::FlightData;
 use common_grpc::flight::{FlightDecoder, FlightMessage};
-use futures_util::stream::Peekable;
 use futures_util::{Stream, StreamExt};
 use snafu::{OptionExt, ResultExt};
 
 use crate::Result;
 use crate::error::{ConvertFlightDataSnafu, Error, IllegalFlightMessagesSnafu};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum FlightMessageKind {
-    Schema,
-    RecordBatch,
-    AffectedRows,
-    Metrics,
-}
-
-impl From<&FlightMessage> for FlightMessageKind {
-    fn from(message: &FlightMessage) -> Self {
-        match message {
-            FlightMessage::Schema(_) => Self::Schema,
-            FlightMessage::RecordBatch(_) => Self::RecordBatch,
-            FlightMessage::AffectedRows { .. } => Self::AffectedRows,
-            FlightMessage::Metrics(_) => Self::Metrics,
-        }
-    }
-}
-
 pub(crate) struct FlightMessageReader<S: Stream + Unpin> {
     /// Remote Flight peer associated with this response stream.
     remote_addr: String,
-    messages: Peekable<S>,
+    messages: S,
 }
 
 impl<S> FlightMessageReader<S>
@@ -55,7 +33,7 @@ where
     pub(crate) fn new(remote_addr: impl Into<String>, messages: S) -> Self {
         Self {
             remote_addr: remote_addr.into(),
-            messages: messages.peekable(),
+            messages,
         }
     }
 
@@ -72,21 +50,6 @@ where
     pub(crate) async fn read_next(&mut self) -> Result<Option<FlightMessage>> {
         self.messages.next().await.transpose()
     }
-
-    pub(crate) async fn peek_next_message_kind(&mut self) -> Result<Option<FlightMessageKind>> {
-        match Pin::new(&mut self.messages).peek().await {
-            Some(Ok(message)) => Ok(Some(message.into())),
-            None => Ok(None),
-            Some(Err(_)) => match self.read_next().await {
-                // `peek` only borrows the error; consume it to preserve the source error.
-                Err(error) => Err(error),
-                Ok(_) => IllegalFlightMessagesSnafu {
-                    reason: "Flight stream changed after peek".to_string(),
-                }
-                .fail(),
-            },
-        }
-    }
 }
 
 pub(crate) fn decode_flight_data(
diff --git a/src/client/src/region.rs b/src/client/src/region.rs
index f0c683ec155..f9ebbb0d0bf 100644
--- a/src/client/src/region.rs
+++ b/src/client/src/region.rs
@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+mod codec;
+
+use std::borrow::Borrow;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -48,11 +51,13 @@ use crate::error::{
     self, FlightGetSnafu, IllegalDatabaseResponseSnafu, IllegalFlightMessagesSnafu,
     MissingFieldSnafu, Result, ServerSnafu,
 };
-use crate::flight::{FlightMessageKind, FlightMessageReader, decode_flight_data};
+use crate::flight::{FlightMessageReader, decode_flight_data};
+use crate::region::codec::RegionCodec;
 use crate::{Client, metrics};
 
 const FLIGHT_DO_GET_TIMEOUT: Duration = Duration::from_secs(10);
 
+/// Sends region operations through a configured gRPC client.
 #[derive(Debug)]
 pub struct RegionRequester {
     client: Client,
@@ -62,20 +67,8 @@ pub struct RegionRequester {
 
 #[async_trait]
 impl Datanode for RegionRequester {
-    async fn handle(&self, request: RegionRequest) -> MetaResult<RegionResponse> {
-        self.handle_inner(request).await.map_err(|err| {
-            if err.should_retry() {
-                meta_error::Error::RetryLater {
-                    source: BoxedError::new(err),
-                    clean_poisons: false,
-                }
-            } else {
-                meta_error::Error::External {
-                    source: BoxedError::new(err),
-                    location: location!(),
-                }
-            }
-        })
+    async fn handle_request(&self, request: Arc<RegionRequest>) -> MetaResult<RegionResponse> {
+        self.handle_inner(request).await.map_err(Into::into)
     }
 
     async fn handle_query(&self, request: QueryRequest) -> MetaResult<SendableRecordBatchStream> {
@@ -144,11 +137,49 @@ impl RegionRequester {
         recordbatches_from_flight_message_stream(addr, flight_message_stream).await
     }
 
-    async fn handle_inner(&self, request: RegionRequest) -> Result<RegionResponse> {
+    /// Sends an owned or shared request without deep-cloning its protobuf payload.
+    ///
+    /// Accepts both [`RegionRequest`] and [`Arc<RegionRequest>`]. Callers can retain a
+    /// shared request for another attempt; this method does not retry or determine
+    /// whether replaying the request is safe.
+    pub async fn handle<R>(&self, request: R) -> Result<RegionResponse>
+    where
+        R: Borrow<RegionRequest> + Send + Sync + 'static,
+    {
+        self.handle_inner(request).await
+    }
+
+    /// Sends a remote dynamic filter update to the region service.
+    pub async fn handle_remote_dyn_filter_update(
+        &self,
+        query_id: impl Into<String>,
+        update: RemoteDynFilterUpdate,
+    ) -> Result<RegionResponse> {
+        self.handle_inner(build_remote_dyn_filter_update_request(query_id, update))
+            .await
+    }
+
+    /// Unregisters a remote dynamic filter in the region service.
+    pub async fn handle_remote_dyn_filter_unregister(
+        &self,
+        query_id: impl Into<String>,
+        unregister: RemoteDynFilterUnregister,
+    ) -> Result<RegionResponse> {
+        self.handle_inner(build_remote_dyn_filter_unregister_request(
+            query_id, unregister,
+        ))
+        .await
+    }
+
+    async fn handle_inner<R>(&self, request: R) -> Result<RegionResponse>
+    where
+        R: Borrow<RegionRequest> + Send + Sync + 'static,
+    {
         let request_body = request
+            .borrow()
             .body
             .as_ref()
-            .with_context(|| MissingFieldSnafu { field: "body" })?;
+            .context(MissingFieldSnafu { field: "body" })?;
         let is_insert = matches!(
             request_body,
             region_request::Body::Inserts(_) | region_request::Body::BulkInsert(_)
@@ -168,48 +199,42 @@ impl RegionRequester {
             }
         }
 
-        let response = client
-            .handle(request)
-            .await
-            .map_err(|e| {
-                let code = e.code();
-                // Uses `Error::RegionServer` instead of `Error::Server`
-                error::Error::RegionServer {
-                    addr,
-                    code,
-                    source: BoxedError::new(error::Error::from(e)),
-                    location: location!(),
-                }
-            })?
-            .into_inner();
+        let response = async {
+            client
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::unknown(format!("Service was not ready: {e}")))?;
+            let mut request = tonic::Request::new(request);
+            request.extensions_mut().insert(tonic::GrpcMethod::new(
+                "greptime.v1.region.Region",
+                "Handle",
+            ));
+            client
+                .unary(
+                    request,
+                    tonic::codegen::http::uri::PathAndQuery::from_static(
+                        "/greptime.v1.region.Region/Handle",
+                    ),
+                    RegionCodec::default(),
+                )
+                .await
+        }
+        .await
+        .map_err(|status| map_region_error(status, addr))?
+        .into_inner();
 
         check_response_header(&response.header)?;
 
         Ok(RegionResponse::from_region_response(response))
     }
+}
 
-    pub async fn handle(&self, request: RegionRequest) -> Result<RegionResponse> {
-        self.handle_inner(request).await
-    }
-
-    pub async fn handle_remote_dyn_filter_update(
-        &self,
-        query_id: impl Into<String>,
-        update: RemoteDynFilterUpdate,
-    ) -> Result<RegionResponse> {
-        self.handle_inner(build_remote_dyn_filter_update_request(query_id, update))
-            .await
-    }
-
-    pub async fn handle_remote_dyn_filter_unregister(
-        &self,
-        query_id: impl Into<String>,
-        unregister: RemoteDynFilterUnregister,
-    ) -> Result<RegionResponse> {
-        self.handle_inner(build_remote_dyn_filter_unregister_request(
-            query_id, unregister,
-        ))
-        .await
+fn map_region_error(status: tonic::Status, addr: String) -> error::Error {
+    error::Error::RegionServer {
+        addr,
+        code: status.code(),
+        source: BoxedError::new(error::Error::from(status)),
+        location: location!(),
     }
 }
 
@@ -247,9 +272,7 @@ where
             "poll_flight_data_stream"
         ));
 
-        let mut stream_ended = false;
-
-        while !stream_ended {
+        loop {
             let flight_message = match reader.read_next().await {
                 Ok(Some(message)) => message,
                 Ok(None) => break,
@@ -262,59 +285,27 @@ where
 
             match flight_message {
                 FlightMessage::RecordBatch(record_batch) => {
-                    let result_to_yield =
-                        RecordBatch::from_df_record_batch(schema_cloned.clone(), record_batch);
-
-                    // Metrics follow a batch so MergeScan can observe them before yielding it.
-                    match reader.peek_next_message_kind().await {
-                        Ok(Some(FlightMessageKind::Metrics)) => {
-                            let metrics_message = match reader.read_next().await {
-                                Ok(Some(FlightMessage::Metrics(metrics))) => metrics,
-                                Ok(Some(_) | None) => {
-                                    yield IllegalFlightMessagesSnafu {
-                                        reason: "Flight stream changed after peek",
-                                    }
-                                    .fail()
-                                    .map_err(BoxedError::new)
-                                    .context(ExternalSnafu);
-                                    break;
-                                }
-                                Err(error) => {
-                                    yield Err(BoxedError::new(flight_stream_error(
-                                        &stream_addr,
-                                        error,
-                                    )))
-                                    .context(ExternalSnafu);
-                                    break;
-                                }
-                            };
-                            let metrics = serde_json::from_str(&metrics_message).ok().map(Arc::new);
-                            metrics_ref.swap(metrics);
-                        }
-                        Ok(Some(FlightMessageKind::RecordBatch)) => {}
-                        Ok(Some(FlightMessageKind::Schema | FlightMessageKind::AffectedRows)) => {
-                            yield IllegalFlightMessagesSnafu {
-                                reason: "A RecordBatch message can only be succeeded by a Metrics message or another RecordBatch message"
-                            }
-                            .fail()
-                            .map_err(BoxedError::new)
-                            .context(ExternalSnafu);
-                            break;
-                        }
-                        Ok(None) => stream_ended = true,
-                        Err(error) => {
-                            yield Err(BoxedError::new(flight_stream_error(&stream_addr, error)))
-                                .context(ExternalSnafu);
-                            break;
-                        }
-                    }
-
-                    yield Ok(result_to_yield);
+                    // Deliver each batch immediately. In particular, do not
+                    // wait for a possible following Metrics message; it is
+                    // consumed on the next poll of this stream.
+                    yield Ok(RecordBatch::from_df_record_batch(
+                        schema_cloned.clone(),
+                        record_batch,
+                    ));
                 }
                 FlightMessage::Metrics(s) => {
                     // Metrics may arrive before the next RecordBatch.
-                    let m = serde_json::from_str(&s).ok().map(Arc::new);
-                    metrics_ref.swap(m);
+                    match serde_json::from_str(&s) {
+                        Ok(metrics) => {
+                            metrics_ref.swap(Some(Arc::new(metrics)));
+                        }
+                        Err(error) => {
+                            common_telemetry::warn!(
+                                "Failed to decode region Flight metrics: {}",
+                                error
+                            );
+                        }
+                    }
                     continue;
                 }
                 _ => {
@@ -419,13 +410,22 @@ pub fn check_response_header(header: &Option<ResponseHeader>) -> Result<()> {
 
 #[cfg(test)]
 #[allow(deprecated)]
-mod test {
-    use api::v1::Status as PbStatus;
+mod tests {
+    use std::collections::VecDeque;
+    use std::sync::Mutex;
+
     use api::v1::region::region_server::{Region, RegionServer};
     use api::v1::region::{
-        BulkInsertRequest, RegionResponse as PbRegionResponse, RemoteDynFilterUnregister,
-        RemoteDynFilterUpdate, region_request, remote_dyn_filter_request,
+        BulkInsertRequest, InsertRequest, InsertRequests, RegionResponse as PbRegionResponse,
+        RemoteDynFilterUnregister, RemoteDynFilterUpdate, region_request,
+        remote_dyn_filter_request,
     };
+    use api::v1::value::ValueData;
+    use api::v1::{
+        ColumnDataType, ColumnSchema as PbColumnSchema, Row, Rows, Status as PbStatus, Value,
+    };
+    use common_error::ext::RetryHint;
+    use common_grpc::channel_manager::{ChannelConfig, ChannelManager};
     use common_recordbatch::adapter::RecordBatchMetrics;
     use datatypes::arrow::array::Int32Array;
     use datatypes::prelude::{ConcreteDataType, VectorRef};
@@ -433,74 +433,526 @@ mod test {
     use datatypes::vectors::Int32Vector;
     use futures_util::stream;
     use tokio::net::TcpListener;
+    use tokio::task::JoinHandle;
     use tokio_stream::wrappers::TcpListenerStream;
     use tonic::codec::CompressionEncoding;
     use tonic::{Request, Response, Status};
 
     use super::*;
-    use crate::Error::{self, IllegalDatabaseResponse, Server};
+    use crate::Error;
 
-    #[derive(Clone)]
-    struct CompressionRecordingRegionService {
-        zstd_headers: Arc<std::sync::Mutex<Vec<(bool, bool)>>>,
+    #[derive(Clone, Default)]
+    struct RecordingRegionService {
+        requests: Arc<Mutex<Vec<(RegionRequest, bool, bool)>>>,
+        responses: Arc<Mutex<VecDeque<std::result::Result<PbRegionResponse, Status>>>>,
     }
 
     #[tonic::async_trait]
-    impl Region for CompressionRecordingRegionService {
+    impl Region for RecordingRegionService {
         async fn handle(
             &self,
             request: Request<RegionRequest>,
         ) -> std::result::Result<Response<PbRegionResponse>, Status> {
             let metadata = request.metadata();
-            let sends_zstd = metadata
-                .get("grpc-encoding")
-                .and_then(|v| v.to_str().ok())
-                .is_some_and(|value| value == "zstd");
+            let sends_zstd = metadata.get("grpc-encoding").is_some_and(|v| v == "zstd");
             let accepts_zstd = metadata
                 .get("grpc-accept-encoding")
-                .and_then(|value| value.to_str().ok())
-                .is_some_and(|value| value.split(',').any(|encoding| encoding == "zstd"));
-            self.zstd_headers
+                .and_then(|v| v.to_str().ok())
+                .is_some_and(|v| v.split(',').any(|encoding| encoding == "zstd"));
+            self.requests
                 .lock()
                 .unwrap()
-                .push((sends_zstd, accepts_zstd));
+                .push((request.into_inner(), sends_zstd, accepts_zstd));
+            self.responses
+                .lock()
+                .unwrap()
+                .pop_front()
+                .unwrap_or_else(|| Ok(build_response(StatusCode::Success)))
+                .map(Response::new)
+        }
+    }
 
-            Ok(Response::new(PbRegionResponse {
-                header: Some(ResponseHeader {
-                    status: Some(PbStatus {
-                        status_code: StatusCode::Success as u32,
-                        ..Default::default()
-                    }),
+    struct RegionTestServer {
+        addr: String,
+        service: RecordingRegionService,
+        task: JoinHandle<()>,
+    }
+
+    impl RegionTestServer {
+        async fn start() -> Self {
+            let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+            let addr = listener.local_addr().unwrap().to_string();
+            let service = RecordingRegionService::default();
+            let server_service = service.clone();
+            let task = tokio::spawn(async move {
+                tonic::transport::Server::builder()
+                    .add_service(
+                        RegionServer::new(server_service)
+                            .accept_compressed(CompressionEncoding::Zstd)
+                            .send_compressed(CompressionEncoding::Zstd),
+                    )
+                    .serve_with_incoming(TcpListenerStream::new(listener))
+                    .await
+                    .unwrap();
+            });
+            Self {
+                addr,
+                service,
+                task,
+            }
+        }
+
+        fn create_requester(
+            &self,
+            config: ChannelConfig,
+            send: bool,
+            accept: bool,
+        ) -> RegionRequester {
+            RegionRequester::new(
+                Client::with_manager_and_urls(
+                    ChannelManager::with_config(config, None),
+                    [self.addr.clone()],
+                ),
+                send,
+                accept,
+            )
+        }
+    }
+
+    impl Drop for RegionTestServer {
+        fn drop(&mut self) {
+            self.task.abort();
+        }
+    }
+
+    fn build_response(code: StatusCode) -> PbRegionResponse {
+        PbRegionResponse {
+            header: Some(ResponseHeader {
+                status: Some(PbStatus {
+                    status_code: code as u32,
+                    ..Default::default()
                 }),
+            }),
+            affected_rows: 1,
+            ..Default::default()
+        }
+    }
+
+    fn build_insert_request() -> RegionRequest {
+        RegionRequest {
+            header: Some(RegionRequestHeader {
+                dbname: "shared-request-test".to_string(),
                 ..Default::default()
-            }))
+            }),
+            body: Some(region_request::Body::Inserts(InsertRequests {
+                requests: vec![InsertRequest {
+                    region_id: 42,
+                    rows: Some(Rows {
+                        schema: vec![
+                            PbColumnSchema {
+                                column_name: "message".to_string(),
+                                datatype: ColumnDataType::String as i32,
+                                ..Default::default()
+                            },
+                            PbColumnSchema {
+                                column_name: "payload".to_string(),
+                                datatype: ColumnDataType::Binary as i32,
+                                ..Default::default()
+                            },
+                        ],
+                        rows: vec![Row {
+                            values: vec![
+                                Value {
+                                    value_data: Some(ValueData::StringValue(
+                                        "hello 世界".to_string(),
+                                    )),
+                                },
+                                Value {
+                                    value_data: Some(ValueData::BinaryValue(vec![0, 1, 127, 255])),
+                                },
+                            ],
+                        }],
+                    }),
+                    ..Default::default()
+                }],
+            })),
         }
     }
 
     #[tokio::test]
-    async fn test_inserts_and_bulk_insert_use_transport_compression() {
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let addr = listener.local_addr().unwrap();
-        let zstd_headers = Arc::new(std::sync::Mutex::new(Vec::new()));
-        let service = CompressionRecordingRegionService {
-            zstd_headers: zstd_headers.clone(),
-        };
-        let server = tokio::spawn(async move {
-            tonic::transport::Server::builder()
-                .add_service(
-                    RegionServer::new(service)
-                        .accept_compressed(CompressionEncoding::Zstd)
-                        .send_compressed(CompressionEncoding::Zstd),
-                )
-                .serve_with_incoming(TcpListenerStream::new(listener))
+    async fn test_owned_and_shared_requests_preserve_payload_and_compression() {
+        let server = RegionTestServer::start().await;
+        let shared = Arc::new(build_insert_request());
+        for (send, accept) in [(false, false), (true, false), (false, true), (true, true)] {
+            let requester = server.create_requester(ChannelConfig::default(), send, accept);
+            let channel =
+                tonic::transport::Endpoint::from_shared(format!("http://{}", server.addr))
+                    .unwrap()
+                    .connect()
+                    .await
+                    .unwrap();
+            let mut baseline = api::v1::region::region_client::RegionClient::new(channel);
+            if send {
+                baseline = baseline.send_compressed(CompressionEncoding::Zstd);
+            }
+            if accept {
+                baseline = baseline.accept_compressed(CompressionEncoding::Zstd);
+            }
+            assert_eq!(
+                baseline
+                    .handle(build_insert_request())
+                    .await
+                    .unwrap()
+                    .into_inner()
+                    .affected_rows,
+                1
+            );
+            assert_eq!(
+                requester
+                    .handle(build_insert_request())
+                    .await
+                    .unwrap()
+                    .affected_rows,
+                1
+            );
+            assert_eq!(
+                requester
+                    .handle(Arc::clone(&shared))
+                    .await
+                    .unwrap()
+                    .affected_rows,
+                1
+            );
+        }
+        let requests = server.service.requests.lock().unwrap();
+        assert_eq!(requests.len(), 12);
+        for ((request, sends, accepts), (send, accept)) in requests.iter().zip(
+            [(false, false), (true, false), (false, true), (true, true)]
+                .into_iter()
+                .flat_map(|settings| [settings, settings, settings]),
+        ) {
+            assert_eq!(request, shared.as_ref());
+            assert_eq!((*sends, *accepts), (send, accept));
+        }
+    }
+
+    #[tokio::test]
+    async fn test_shared_request_can_be_resent_after_transport_error() {
+        let server = RegionTestServer::start().await;
+        let mut status = Status::unavailable("migrating");
+        status.metadata_mut().insert(
+            common_error::GREPTIME_DB_HEADER_ERROR_RETRY_HINT,
+            RetryHint::Retryable.as_str().parse().unwrap(),
+        );
+        server
+            .service
+            .responses
+            .lock()
+            .unwrap()
+            .push_back(Err(status));
+        let requester = server.create_requester(ChannelConfig::default(), false, false);
+        let shared = Arc::new(build_insert_request());
+        let error = requester.handle(Arc::clone(&shared)).await.unwrap_err();
+        assert_eq!(error.retry_hint(), RetryHint::Retryable);
+        assert!(
+            matches!(error, Error::RegionServer { addr, code: tonic::Code::Unavailable, .. } if addr == server.addr)
+        );
+        requester.handle(Arc::clone(&shared)).await.unwrap();
+        let requests = server.service.requests.lock().unwrap();
+        assert_eq!(requests.len(), 2);
+        assert_eq!(&requests[0].0, shared.as_ref());
+        assert_eq!(&requests[1].0, shared.as_ref());
+    }
+
+    #[test]
+    fn test_retry_hint_wire_compatibility() {
+        for (name, wire_hint, expected_hint) in [
+            ("legacy_missing", None, RetryHint::NonRetryable),
+            ("legacy_retryable", Some("retryable"), RetryHint::Retryable),
+            (
+                "legacy_non_retryable",
+                Some("non_retryable"),
+                RetryHint::NonRetryable,
+            ),
+            (
+                "route_refresh",
+                Some("retry_after_route_refresh"),
+                RetryHint::RetryAfterRouteRefresh,
+            ),
+            (
+                "unknown_future_hint",
+                Some("future_retry_hint"),
+                RetryHint::NonRetryable,
+            ),
+        ] {
+            let mut status = Status::failed_precondition("region unavailable");
+            status.metadata_mut().insert(
+                common_error::GREPTIME_DB_HEADER_ERROR_CODE,
+                (StatusCode::RegionNotReady as u32)
+                    .to_string()
+                    .parse()
+                    .unwrap(),
+            );
+            if let Some(hint) = wire_hint {
+                status.metadata_mut().insert(
+                    common_error::GREPTIME_DB_HEADER_ERROR_RETRY_HINT,
+                    hint.parse().unwrap(),
+                );
+            }
+            let error: Error = status.into();
+            assert_eq!(error.retry_hint(), expected_hint, "{name}");
+            assert_eq!(error.status_code(), StatusCode::RegionNotReady, "{name}");
+            assert_eq!(
+                error.tonic_code(),
+                Some(tonic::Code::FailedPrecondition),
+                "{name}"
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn test_transport_error_parity_and_datanode_mapping() {
+        let server = RegionTestServer::start().await;
+        let requester = server.create_requester(ChannelConfig::default(), false, false);
+        for hint in [
+            RetryHint::Retryable,
+            RetryHint::RetryAfterRouteRefresh,
+            RetryHint::NonRetryable,
+        ] {
+            let mut status = Status::failed_precondition("region unavailable");
+            status.metadata_mut().insert(
+                common_error::GREPTIME_DB_HEADER_ERROR_RETRY_HINT,
+                hint.as_str().parse().unwrap(),
+            );
+            status.metadata_mut().insert(
+                common_error::GREPTIME_DB_HEADER_ERROR_CODE,
+                (StatusCode::RegionNotFound as u32)
+                    .to_string()
+                    .parse()
+                    .unwrap(),
+            );
+            server
+                .service
+                .responses
+                .lock()
+                .unwrap()
+                .extend((0..4).map(|_| Err(status.clone())));
+            let mut baseline = api::v1::region::region_client::RegionClient::connect(format!(
+                "http://{}",
+                server.addr
+            ))
+            .await
+            .unwrap();
+            let baseline: Error = baseline
+                .handle(build_insert_request())
                 .await
-                .unwrap();
+                .unwrap_err()
+                .into();
+            assert_eq!(baseline.status_code(), StatusCode::RegionNotFound);
+            assert_eq!(baseline.retry_hint(), hint);
+            assert_eq!(baseline.tonic_code(), Some(tonic::Code::FailedPrecondition));
+            let owned = requester.handle(build_insert_request()).await.unwrap_err();
+            let shared = requester
+                .handle(Arc::new(build_insert_request()))
+                .await
+                .unwrap_err();
+            for error in [owned, shared] {
+                assert_eq!(error.status_code(), baseline.status_code());
+                assert_eq!(error.retry_hint(), baseline.retry_hint());
+                assert_eq!(error.tonic_code(), baseline.tonic_code());
+            }
+            let datanode: &dyn Datanode = &requester;
+            let error = datanode.handle(build_insert_request()).await.unwrap_err();
+            assert_eq!(error.status_code(), StatusCode::RegionNotFound);
+            assert_eq!(error.retry_hint(), hint);
+            assert!(matches!(error, meta_error::Error::External { .. }));
+        }
+    }
+
+    #[tokio::test]
+    async fn test_datanode_transport_retry_hints() {
+        let server = RegionTestServer::start().await;
+        let requester = server.create_requester(ChannelConfig::default(), false, false);
+        let datanode: &dyn Datanode = &requester;
+        let statuses = [
+            tonic::Code::Unavailable,
+            tonic::Code::Cancelled,
+            tonic::Code::DeadlineExceeded,
+            tonic::Code::FailedPrecondition,
+        ]
+        .into_iter()
+        .flat_map(|code| {
+            [
+                None,
+                Some(RetryHint::NonRetryable),
+                Some(RetryHint::Retryable),
+                Some(RetryHint::RetryAfterRouteRefresh),
+            ]
+            .into_iter()
+            .map(move |hint| (code, hint))
         });
-        let client = Client::with_urls([addr.to_string()]);
-        let requester = RegionRequester::new(client.clone(), true, true);
-        let send_only_requester = RegionRequester::new(client.clone(), true, false);
-        let accept_only_requester = RegionRequester::new(client.clone(), false, true);
-        let disabled_requester = RegionRequester::new(client, false, false);
+        for (code, hint) in statuses {
+            for body in [
+                region_request::Body::Inserts(Default::default()),
+                region_request::Body::Deletes(Default::default()),
+                region_request::Body::BulkInsert(Default::default()),
+                region_request::Body::Create(Default::default()),
+                region_request::Body::RemoteDynFilter(Default::default()),
+            ] {
+                let request_type = body.as_ref().to_string();
+                let mut status = Status::new(code, "request failed");
+                // Metadata status is deliberately different from the transport status.
+                status.metadata_mut().insert(
+                    common_error::GREPTIME_DB_HEADER_ERROR_CODE,
+                    (StatusCode::RegionNotReady as u32)
+                        .to_string()
+                        .parse()
+                        .unwrap(),
+                );
+                if let Some(hint) = hint {
+                    status.metadata_mut().insert(
+                        common_error::GREPTIME_DB_HEADER_ERROR_RETRY_HINT,
+                        hint.as_str().parse().unwrap(),
+                    );
+                }
+                let original = Error::from(status.clone());
+                let expected = if original.should_retry() && !original.retry_hint().is_retryable() {
+                    RetryHint::Retryable
+                } else {
+                    original.retry_hint()
+                };
+                server
+                    .service
+                    .responses
+                    .lock()
+                    .unwrap()
+                    .extend([Err(status.clone()), Err(status)]);
+                let request = RegionRequest {
+                    header: None,
+                    body: Some(body),
+                };
+                let shared = Arc::new(request);
+                let shared_error = datanode.handle(Arc::clone(&shared)).await.unwrap_err();
+                assert_eq!(Arc::strong_count(&shared), 1);
+                let request = Arc::try_unwrap(shared).unwrap();
+                let owned_error = datanode.handle(request).await.unwrap_err();
+                for error in [owned_error, shared_error] {
+                    assert_eq!(
+                        error.retry_hint(),
+                        expected,
+                        "{code:?}, {hint:?}, {request_type}"
+                    );
+                    assert_eq!(error.retry_hint().is_retryable(), original.should_retry());
+                    assert_eq!(error.status_code(), StatusCode::RegionNotReady);
+                    let meta_error::Error::External { source, .. } = error else {
+                        panic!("expected an external error");
+                    };
+                    assert_eq!(source.retry_hint(), expected);
+                    let Error::RegionServer {
+                        source,
+                        code: actual_code,
+                        ..
+                    } = source.as_any().downcast_ref::<Error>().unwrap()
+                    else {
+                        panic!("expected a region server error");
+                    };
+                    assert_eq!(*actual_code, code);
+                    assert_eq!(source.retry_hint(), original.retry_hint());
+                    assert_eq!(source.to_string(), original.to_string());
+                }
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn test_shared_request_preserves_response_header_errors() {
+        let server = RegionTestServer::start().await;
+        server.service.responses.lock().unwrap().extend([
+            Ok(PbRegionResponse::default()),
+            Ok(build_response(StatusCode::RegionNotFound)),
+        ]);
+        let requester = server.create_requester(ChannelConfig::default(), false, false);
+        let shared = Arc::new(build_insert_request());
+        assert!(matches!(
+            requester.handle(Arc::clone(&shared)).await.unwrap_err(),
+            Error::IllegalDatabaseResponse { .. }
+        ));
+        assert!(matches!(
+            requester.handle(shared).await.unwrap_err(),
+            Error::Server {
+                code: StatusCode::RegionNotFound,
+                ..
+            }
+        ));
+    }
+
+    #[tokio::test]
+    async fn test_shared_request_respects_configured_message_limits() {
+        let server = RegionTestServer::start().await;
+        let shared = Arc::new(build_insert_request());
+        for send_limit in [true, false] {
+            let mut config = ChannelConfig::default();
+            if send_limit {
+                config.max_send_message_size = "1B".parse().unwrap();
+            } else {
+                config.max_recv_message_size = "1B".parse().unwrap();
+            }
+            let mut baseline = api::v1::region::region_client::RegionClient::connect(format!(
+                "http://{}",
+                server.addr
+            ))
+            .await
+            .unwrap()
+            .max_encoding_message_size(config.max_send_message_size.as_bytes() as usize)
+            .max_decoding_message_size(config.max_recv_message_size.as_bytes() as usize);
+            let baseline: Error = baseline
+                .handle(build_insert_request())
+                .await
+                .unwrap_err()
+                .into();
+            if !send_limit {
+                assert_eq!(
+                    baseline.tonic_code(),
+                    Some(tonic::Code::OutOfRange),
+                    "{baseline:?}"
+                );
+            }
+            let requester = server.create_requester(config, false, false);
+            let error = requester.handle(Arc::clone(&shared)).await.unwrap_err();
+            assert_eq!(
+                error.tonic_code(),
+                baseline.tonic_code(),
+                "shared: {error:?}; generated: {baseline:?}"
+            );
+            assert_eq!(
+                error.status_code(),
+                baseline.status_code(),
+                "shared: {error:?}; generated: {baseline:?}"
+            );
+            let Error::RegionServer { source, .. } = &error else {
+                panic!("expected a region server error: {error:?}");
+            };
+            assert_eq!(
+                source.retry_hint(),
+                baseline.retry_hint(),
+                "shared: {error:?}; generated: {baseline:?}"
+            );
+            assert_eq!(
+                server.service.requests.lock().unwrap().len(),
+                if send_limit { 0 } else { 2 }
+            );
+        }
+        let requester = server.create_requester(ChannelConfig::default(), false, false);
+        requester.handle(shared).await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_inserts_and_bulk_insert_use_transport_compression() {
+        let server = RegionTestServer::start().await;
+        let requester = server.create_requester(ChannelConfig::default(), true, true);
+        let send_only_requester = server.create_requester(ChannelConfig::default(), true, false);
+        let accept_only_requester = server.create_requester(ChannelConfig::default(), false, true);
+        let disabled_requester = server.create_requester(ChannelConfig::default(), false, false);
         let inserts = || RegionRequest {
             body: Some(region_request::Body::Inserts(Default::default())),
             ..Default::default()
@@ -536,9 +988,15 @@ mod test {
                 (false, false),
                 (false, false)
             ],
-            *zstd_headers.lock().unwrap()
+            server
+                .service
+                .requests
+                .lock()
+                .unwrap()
+                .iter()
+                .map(|(_, send, accept)| (*send, *accept))
+                .collect::<Vec<_>>()
         );
-        server.abort();
     }
 
     #[test]
@@ -600,13 +1058,13 @@ mod test {
         let result = check_response_header(&None);
         assert!(matches!(
             result.unwrap_err(),
-            IllegalDatabaseResponse { .. }
+            Error::IllegalDatabaseResponse { .. }
         ));
 
         let result = check_response_header(&Some(ResponseHeader { status: None }));
         assert!(matches!(
             result.unwrap_err(),
-            IllegalDatabaseResponse { .. }
+            Error::IllegalDatabaseResponse { .. }
         ));
 
         let result = check_response_header(&Some(ResponseHeader {
@@ -625,7 +1083,7 @@ mod test {
         }));
         assert!(matches!(
             result.unwrap_err(),
-            IllegalDatabaseResponse { .. }
+            Error::IllegalDatabaseResponse { .. }
         ));
 
         let result = check_response_header(&Some(ResponseHeader {
@@ -634,7 +1092,7 @@ mod test {
                 err_msg: "blabla".to_string(),
             }),
         }));
-        let Server { code, msg, .. } = result.unwrap_err() else {
+        let Error::Server { code, msg, .. } = result.unwrap_err() else {
             unreachable!()
         };
         assert_eq!(code, StatusCode::Internal);
@@ -719,7 +1177,34 @@ mod test {
     }
 
     #[tokio::test]
-    async fn test_record_batch_stream_updates_following_metrics_before_yielding_batch() {
+    async fn test_record_batch_is_yielded_without_waiting_for_next_message() {
+        let schema = test_schema();
+        let batch = RecordBatch::new(
+            schema.clone(),
+            vec![Arc::new(Int32Vector::from_slice([1])) as VectorRef],
+        )
+        .unwrap();
+
+        let messages = stream::iter(vec![
+            Ok(FlightMessage::Schema(schema.arrow_schema().clone())),
+            Ok(FlightMessage::RecordBatch(batch.into_df_record_batch())),
+        ])
+        .chain(stream::pending::<Result<FlightMessage>>());
+        let mut recordbatches =
+            recordbatches_from_flight_message_stream("test-peer".to_string(), messages)
+                .await
+                .unwrap();
+
+        let batch = tokio::time::timeout(Duration::from_secs(1), recordbatches.next())
+            .await
+            .expect("the first batch must not wait for lookahead")
+            .unwrap()
+            .unwrap();
+        assert_eq!(batch.num_rows(), 1);
+    }
+
+    #[tokio::test]
+    async fn test_malformed_region_metrics_are_non_fatal() {
         let schema = test_schema();
         let batch = RecordBatch::new(
             schema.clone(),
@@ -730,23 +1215,19 @@ mod test {
             "test-peer".to_string(),
             stream::iter(vec![
                 Ok(FlightMessage::Schema(schema.arrow_schema().clone())),
+                Ok(FlightMessage::Metrics("{not-json}".to_string())),
                 Ok(FlightMessage::RecordBatch(batch.into_df_record_batch())),
-                Ok(FlightMessage::Metrics(test_metrics_json())),
             ]),
         )
         .await
         .unwrap();
 
-        let batch = recordbatches.next().await.unwrap().unwrap();
-        assert_eq!(batch.num_rows(), 1);
-
-        let metrics = recordbatches.metrics().unwrap();
-        assert_eq!(metrics.elapsed_compute, 7);
+        assert_eq!(recordbatches.next().await.unwrap().unwrap().num_rows(), 1);
         assert!(recordbatches.next().await.is_none());
     }
 
     #[tokio::test]
-    async fn test_record_batch_stream_preserves_peeked_record_batch() {
+    async fn test_record_batch_stream_preserves_following_record_batch() {
         let schema = test_schema();
         let first_batch = RecordBatch::new(
             schema.clone(),
diff --git a/src/client/src/region/codec.rs b/src/client/src/region/codec.rs
new file mode 100644
index 00000000000..9476385df36
--- /dev/null
+++ b/src/client/src/region/codec.rs
@@ -0,0 +1,63 @@
+// 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::borrow::Borrow;
+use std::marker::PhantomData;
+
+use api::v1::region::{RegionRequest, RegionResponse};
+use prost::Message;
+use tonic::Status;
+use tonic::codec::{Codec, EncodeBuf, Encoder};
+use tonic_prost::ProstDecoder;
+
+/// Encodes owned or shared region requests using the existing protobuf wire format.
+pub(crate) struct RegionCodec<R>(PhantomData<R>);
+
+impl<R> Default for RegionCodec<R> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<R> Codec for RegionCodec<R>
+where
+    R: Borrow<RegionRequest> + Send + 'static,
+{
+    type Encode = R;
+    type Decode = RegionResponse;
+    type Encoder = RegionEncoder<R>;
+    type Decoder = ProstDecoder<RegionResponse>;
+
+    fn encoder(&mut self) -> Self::Encoder {
+        RegionEncoder(PhantomData)
+    }
+
+    fn decoder(&mut self) -> Self::Decoder {
+        ProstDecoder::default()
+    }
+}
+
+/// Borrows the protobuf payload while consuming its owned or shared container.
+pub(crate) struct RegionEncoder<R>(PhantomData<R>);
+
+impl<R: Borrow<RegionRequest>> Encoder for RegionEncoder<R> {
+    type Item = R;
+    type Error = Status;
+
+    fn encode(&mut self, item: R, buf: &mut EncodeBuf<'_>) -> Result<(), Status> {
+        item.borrow()
+            .encode(buf)
+            .map_err(|error| Status::internal(error.to_string()))
+    }
+}
diff --git a/src/cmd/tests/load_config_test.rs b/src/cmd/tests/load_config_test.rs
index cc095c5c92e..ba38793b8cd 100644
--- a/src/cmd/tests/load_config_test.rs
+++ b/src/cmd/tests/load_config_test.rs
@@ -475,6 +475,261 @@ fn test_load_standalone_example_config() {
     similar_asserts::assert_eq!(options, expected);
 }
 
+/// Renders an example config with its `#+` options enabled, as `config.md`
+/// lists them. With `drop_none_default`, options annotated with
+/// `@toml2docs:none-default` are removed, because `config.md` does not present
+/// their example value as the default.
+fn render_example(example: &str, drop_none_default: bool) -> String {
+    let mut rendered = String::new();
+    let mut none_default = false;
+    for line in example.lines() {
+        let line = line.trim_start();
+        if line.starts_with("##") {
+            none_default |= line.contains("@toml2docs:none-default");
+            continue;
+        }
+        let line = line.strip_prefix("#+").map_or(line, str::trim_start);
+        let is_option = !line.starts_with('[') && line.contains('=');
+        if !(is_option && drop_none_default && none_default) {
+            rendered.push_str(line);
+            rendered.push('\n');
+        }
+        none_default = false;
+    }
+    rendered
+}
+
+/// Flattens leaf values into dotted paths. Arrays of tables such as
+/// `region_engine` are merged, since each element is keyed by its engine name.
+fn leaf_values(value: &toml::Value, prefix: &str, leaves: &mut Vec<(String, toml::Value)>) {
+    match value {
+        toml::Value::Table(table) => {
+            for (key, value) in table {
+                let path = if prefix.is_empty() {
+                    key.clone()
+                } else {
+                    format!("{prefix}.{key}")
+                };
+                leaf_values(value, &path, leaves);
+            }
+        }
+        toml::Value::Array(array)
+            if array.iter().all(toml::Value::is_table) && !array.is_empty() =>
+        {
+            for element in array {
+                leaf_values(element, prefix, leaves);
+            }
+        }
+        _ => leaves.push((prefix.to_string(), value.clone())),
+    }
+}
+
+/// Removes the option at a dotted path produced by [`leaf_values`].
+fn remove_leaf(value: &mut toml::Value, path: &str) -> bool {
+    match value {
+        toml::Value::Array(array) => array.iter_mut().any(|element| remove_leaf(element, path)),
+        toml::Value::Table(table) => match path.split_once('.') {
+            None => table.remove(path).is_some(),
+            Some((head, rest)) => table
+                .get_mut(head)
+                .is_some_and(|value| remove_leaf(value, rest)),
+        },
+        _ => false,
+    }
+}
+
+fn load_as_leaves<T>(
+    config: Option<&str>,
+) -> common_config::error::Result<std::collections::HashMap<String, toml::Value>>
+where
+    T: Configurable + serde::Serialize,
+{
+    let file = config.map(|config| {
+        let mut file = create_named_temp_file();
+        file.write_all(config.as_bytes()).unwrap();
+        file
+    });
+    let options = GreptimeOptions::<T>::load_layered_options(
+        file.as_ref().map(|file| file.path().to_str().unwrap()),
+        "",
+    )?;
+    let mut leaves = Vec::new();
+    leaf_values(&toml::Value::try_from(&options).unwrap(), "", &mut leaves);
+    Ok(leaves.into_iter().collect())
+}
+
+/// Returns the default of an option inside the example's other settings, so
+/// that options in sections absent by default still have one to compare with.
+/// Removes the closest enclosing table that still loads without the option.
+fn default_within_example<T>(full: &toml::Value, path: &str) -> Option<toml::Value>
+where
+    T: Configurable + serde::Serialize,
+{
+    let mut removed = path;
+    loop {
+        let mut without = full.clone();
+        assert!(remove_leaf(&mut without, removed));
+        if let Ok(defaults) = load_as_leaves::<T>(Some(&toml::to_string(&without).unwrap())) {
+            return defaults.get(path).cloned();
+        }
+        removed = removed
+            .rsplit_once('.')
+            .unwrap_or_else(|| panic!("the example does not load without `{path}`"))
+            .0;
+    }
+}
+
+/// Checks that every option in an example config exists, and that every value
+/// `config.md` presents as a default is the actual default.
+///
+/// `variants` lists tagged sections, e.g. `("wal", "provider", ["kafka"])`,
+/// whose options only deserialize under a specific tag value.
+fn check_example_defaults<T>(name: &str, variants: &[(&str, &str, &[&str])]) -> Vec<String>
+where
+    T: Configurable + serde::Serialize,
+{
+    let example = std::fs::read_to_string(common_test_util::find_workspace_path(&format!(
+        "config/{name}"
+    )))
+    .unwrap();
+    let full: toml::Value = toml::from_str(&render_example(&example, false)).unwrap();
+    let documented: toml::Value = toml::from_str(&render_example(&example, true)).unwrap();
+
+    // (options loaded from the example, options loaded without config) per variant
+    let mut loaded = vec![(
+        load_as_leaves::<T>(Some(&toml::to_string(&full).unwrap())).unwrap(),
+        load_as_leaves::<T>(None).unwrap(),
+    )];
+    for (section, tag, values) in variants {
+        for value in *values {
+            let mut variant = full.clone();
+            variant[section][tag] = toml::Value::String(value.to_string());
+            loaded.push((
+                load_as_leaves::<T>(Some(&toml::to_string(&variant).unwrap())).unwrap(),
+                load_as_leaves::<T>(Some(&format!("[{section}]\n{tag} = \"{value}\"\n"))).unwrap(),
+            ));
+        }
+    }
+
+    // Deserialize-only fields, invisible in the serialized options.
+    const SKIP_SERIALIZING: &[&str] = &[
+        "storage.access_key_id",
+        "storage.secret_access_key",
+        "storage.access_key_secret",
+        "storage.account_name",
+        "storage.account_key",
+        "storage.credential_path",
+        "storage.credential",
+        "region_engine.mito.inverted_index.intermediate_path",
+    ];
+
+    let mut errors = Vec::new();
+    let mut full_leaves = Vec::new();
+    leaf_values(&full, "", &mut full_leaves);
+    for (path, _) in full_leaves {
+        if SKIP_SERIALIZING.contains(&path.as_str())
+            || (path == "tracing.tokio_console_addr" && !cfg!(feature = "tokio-console"))
+        {
+            continue;
+        }
+        if !loaded
+            .iter()
+            .any(|(example, _)| example.contains_key(&path))
+        {
+            errors.push(format!("{name}: `{path}` is not a known option"));
+        }
+    }
+
+    // Options left unset by default and resolved where they are used.
+    let resolved_at_runtime: [(&str, toml::Value); 7] = [
+        (
+            "logging.dir",
+            format!("{DEFAULT_DATA_HOME}/{DEFAULT_LOGGING_DIR}").into(),
+        ),
+        ("logging.otlp_endpoint", DEFAULT_OTLP_HTTP_ENDPOINT.into()),
+        ("logging.otlp_export_protocol", "http".into()),
+        ("logging.tracing_sample_ratio.default_ratio", 1.0.into()),
+        ("wal.sync_period", "5s".into()),
+        (
+            "storage.copy_root",
+            format!("{DEFAULT_DATA_HOME}/copy").into(),
+        ),
+        ("flow.batching_mode.frontend_tls.enabled", false.into()),
+    ];
+
+    let mut documented_leaves = Vec::new();
+    leaf_values(&documented, "", &mut documented_leaves);
+    for (path, documented_value) in documented_leaves {
+        if SKIP_SERIALIZING.contains(&path.as_str()) {
+            continue;
+        }
+        if let Some((_, resolved)) = resolved_at_runtime.iter().find(|(p, _)| *p == path) {
+            if &documented_value != resolved {
+                errors.push(format!(
+                    "{name}: `{path}` is documented as default `{documented_value}`, but resolves to `{resolved}`"
+                ));
+            }
+            continue;
+        }
+        let mut pairs = loaded
+            .iter()
+            .filter_map(|(example, default)| Some((example.get(&path)?, default.get(&path)?)))
+            .map(|(example, default)| (example.clone(), default.clone()))
+            .collect::<Vec<_>>();
+        if pairs.is_empty() {
+            // The option sits in a section that is absent without config, or
+            // is itself optional.
+            match default_within_example::<T>(&full, &path) {
+                Some(default) => pairs.push((loaded[0].0[&path].clone(), default)),
+                None => {
+                    errors.push(format!(
+                        "{name}: `{path}` has no default to compare with; annotate it with \
+                         `@toml2docs:none-default` or list its runtime default in this test"
+                    ));
+                    continue;
+                }
+            }
+        }
+        if pairs.iter().all(|(example, default)| example != default) {
+            let (example, default) = &pairs[0];
+            errors.push(format!(
+                "{name}: `{path}` is documented as default `{example}`, but the default is `{default}`; \
+                 fix the value or annotate it with `@toml2docs:none-default`"
+            ));
+        }
+    }
+    errors
+}
+
+// The examples document HDFS storage options.
+#[cfg(feature = "hdfs-object-store")]
+#[test]
+fn test_example_configs_document_actual_defaults() {
+    const WAL: (&str, &str, &[&str]) = ("wal", "provider", &["kafka", "experimental_object_store"]);
+    const STORAGE: (&str, &str, &[&str]) =
+        ("storage", "type", &["S3", "Oss", "Azblob", "Gcs", "Hdfs"]);
+
+    let mut errors =
+        check_example_defaults::<StandaloneOptions>("standalone.example.toml", &[WAL, STORAGE]);
+    errors.extend(check_example_defaults::<FrontendOptions>(
+        "frontend.example.toml",
+        &[],
+    ));
+    errors.extend(check_example_defaults::<DatanodeOptions>(
+        "datanode.example.toml",
+        &[WAL, STORAGE],
+    ));
+    errors.extend(check_example_defaults::<MetasrvOptions>(
+        "metasrv.example.toml",
+        &[("wal", "provider", &["kafka"])],
+    ));
+    errors.extend(check_example_defaults::<FlownodeOptions>(
+        "flownode.example.toml",
+        &[],
+    ));
+    assert!(errors.is_empty(), "{}", errors.join("\n"));
+}
+
 #[test]
 fn test_load_removed_histogram_options() {
     for enabled in [false, true] {
diff --git a/src/common/base/Cargo.toml b/src/common/base/Cargo.toml
index 702171e9d67..6df2283c2cf 100644
--- a/src/common/base/Cargo.toml
+++ b/src/common/base/Cargo.toml
@@ -14,6 +14,7 @@ async-trait.workspace = true
 bitvec = "1.0"
 bytes.workspace = true
 futures.workspace = true
+icu_properties.workspace = true
 lazy_static.workspace = true
 pin-project.workspace = true
 regex.workspace = true
diff --git a/src/common/base/src/lib.rs b/src/common/base/src/lib.rs
index 04fc7038018..2d5a6fbd894 100644
--- a/src/common/base/src/lib.rs
+++ b/src/common/base/src/lib.rs
@@ -25,6 +25,7 @@ pub mod readable_size;
 pub mod regex_pattern;
 pub mod secrets;
 pub mod serde;
+pub mod term_token;
 
 pub type AffectedRows = usize;
 
diff --git a/src/common/base/src/term_token.rs b/src/common/base/src/term_token.rs
new file mode 100644
index 00000000000..a6121559a67
--- /dev/null
+++ b/src/common/base/src/term_token.rs
@@ -0,0 +1,280 @@
+// 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.
+
+//! Word boundaries shared by `matches_term` and the fulltext bloom index.
+//!
+//! Bloom pruning is only sound if the index splits text exactly where
+//! `matches_term` sees word boundaries, so both use [`classify_char`], and the
+//! query side derives its probes with [`extract_term_probes`] and [`extract_like_probes`].
+
+use std::ops::Range;
+
+use icu_properties::props::Script;
+use icu_properties::{CodePointMapData, CodePointMapDataBorrowed};
+
+/// Classes of characters that decide where `matches_term` sees a word boundary.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum CharClass {
+    /// `[0-9A-Za-z]`.
+    AsciiWord,
+    /// Characters of the Han script, alphanumeric or not.
+    Han,
+    /// Non-ASCII alphanumerics outside the Han script, such as `é` or `д`.
+    UnicodeWord,
+    /// Everything else, including `_`.
+    Other,
+}
+
+/// Returns the [`CharClass`] of `c`. [`tokenize`] splits text wherever the class
+/// changes and at every [`CharClass::Other`] character.
+pub fn classify_char(c: char) -> CharClass {
+    if c.is_ascii_alphanumeric() {
+        CharClass::AsciiWord
+    } else if is_han(c) {
+        CharClass::Han
+    } else if c.is_alphanumeric() {
+        CharClass::UnicodeWord
+    } else {
+        CharClass::Other
+    }
+}
+
+static HAN_SCRIPT_DATA: CodePointMapDataBorrowed<'static, Script> =
+    CodePointMapData::<Script>::new();
+
+fn is_han(c: char) -> bool {
+    HAN_SCRIPT_DATA.get(c) == Script::Han
+}
+
+/// Returns whether lowercasing `text` as a whole can produce tokens that lowercasing
+/// each token of `text` doesn't, which `matches_term(lower(col), ..)` and
+/// `lower(col) LIKE ..` rely on. Every other character lowercases to one character
+/// of the same class, but U+0130 and U+212A change length or class, and `Σ`
+/// lowercases depending on the characters after it.
+pub fn has_irregular_lowercase(text: &str) -> bool {
+    !text.is_ascii() && text.contains(['\u{130}', '\u{212A}', 'Σ'])
+}
+
+/// Returns the tokens the fulltext bloom index stores for `text`.
+///
+/// A token is a maximal run of ASCII alphanumerics or of non-Han alphanumerics;
+/// `_` and other symbols only separate tokens. A run of Han characters is
+/// emitted as its bigrams, or as itself when it has a single character, since
+/// `matches_term` matches Han terms as plain substrings.
+pub fn tokenize(text: &str) -> Vec<&str> {
+    let mut tokens = Vec::new();
+    for_each_word_run(text, |class, range| {
+        let run = &text[range];
+        if class == CharClass::Han {
+            push_han_tokens(run, &mut tokens);
+        } else {
+            tokens.push(run);
+        }
+    });
+    tokens
+}
+
+/// Calls `f` on every maximal run of word characters of the same class.
+fn for_each_word_run(text: &str, mut f: impl FnMut(CharClass, Range<usize>)) {
+    if text.is_ascii() {
+        // ASCII text only has `AsciiWord` and `Other` characters, so scan bytes
+        // instead of decoding chars. Most log lines take this path.
+        let mut start = None;
+        for (i, b) in text.bytes().enumerate() {
+            match (b.is_ascii_alphanumeric(), start) {
+                (true, None) => start = Some(i),
+                (false, Some(s)) => {
+                    f(CharClass::AsciiWord, s..i);
+                    start = None;
+                }
+                _ => {}
+            }
+        }
+        if let Some(s) = start {
+            f(CharClass::AsciiWord, s..text.len());
+        }
+        return;
+    }
+
+    let mut run: Option<(CharClass, usize)> = None;
+    for (i, c) in text.char_indices() {
+        let class = classify_char(c);
+        if let Some((run_class, start)) = run {
+            if run_class == class {
+                continue;
+            }
+            f(run_class, start..i);
+            run = None;
+        }
+        if class != CharClass::Other {
+            run = Some((class, i));
+        }
+    }
+    if let Some((run_class, start)) = run {
+        f(run_class, start..text.len());
+    }
+}
+
+fn push_han_tokens<'a>(run: &'a str, tokens: &mut Vec<&'a str>) {
+    let mut starts = run.char_indices().map(|(i, _)| i).skip(1);
+    let Some(mut second) = starts.next() else {
+        tokens.push(run);
+        return;
+    };
+    let mut first = 0;
+    for next in starts.chain(std::iter::once(run.len())) {
+        tokens.push(&run[first..next]);
+        first = second;
+        second = next;
+    }
+}
+
+/// Returns tokens that every text satisfying `matches_term(text, term)` contains,
+/// as produced by [`tokenize`].
+pub fn extract_term_probes(term: &str) -> Vec<String> {
+    // Non-Han terms only match between word boundaries that `tokenize` also
+    // splits at, so their edge runs are whole tokens. Han-containing terms match
+    // as plain substrings and give no such guarantee at their edges.
+    let bounded = !term.chars().any(|c| classify_char(c) == CharClass::Han);
+    let mut probes = Vec::new();
+    push_literal_probes(term, bounded, bounded, &mut probes);
+    probes
+}
+
+/// Returns tokens that every text satisfying `text LIKE pattern` contains, as
+/// produced by [`tokenize`]. `\` escapes the next character, following
+/// arrow's `like` kernel; a trailing `\` is a literal backslash.
+pub fn extract_like_probes(pattern: &str) -> Vec<String> {
+    let mut probes = Vec::new();
+    let mut literal = String::new();
+    // The pattern start and end are anchors; a wildcard can stand for word
+    // characters, so a run touching it may be part of a longer token.
+    let mut anchored_left = true;
+    let mut chars = pattern.chars();
+    while let Some(c) = chars.next() {
+        match c {
+            '%' | '_' => {
+                push_literal_probes(&literal, anchored_left, false, &mut probes);
+                literal.clear();
+                anchored_left = false;
+            }
+            '\\' => literal.push(chars.next().unwrap_or('\\')),
+            c => literal.push(c),
+        }
+    }
+    push_literal_probes(&literal, anchored_left, true, &mut probes);
+    probes
+}
+
+/// Pushes the tokens of `literal` that stay whole tokens wherever `literal`
+/// occurs. A side is bounded when the character beyond it can't extend the
+/// adjacent run.
+fn push_literal_probes(
+    literal: &str,
+    left_bounded: bool,
+    right_bounded: bool,
+    probes: &mut Vec<String>,
+) {
+    for_each_word_run(literal, |class, range| {
+        let whole =
+            (range.start > 0 || left_bounded) && (range.end < literal.len() || right_bounded);
+        let run = &literal[range];
+        if class == CharClass::Han && run.chars().nth(1).is_some() {
+            // Bigrams inside the run occur in every text containing it.
+            let mut tokens = Vec::new();
+            push_han_tokens(run, &mut tokens);
+            probes.extend(tokens.into_iter().map(str::to_string));
+        } else if whole {
+            probes.push(run.to_string());
+        }
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn han_detection_uses_script_not_all_cjk() {
+        assert!(is_han('汉'));
+        assert!(is_han('\u{30000}'));
+        assert!(!is_han('あ'));
+        assert!(!is_han('한'));
+    }
+
+    #[test]
+    fn test_script_tokenizer() {
+        let cases: [(&str, &[&str]); 7] = [
+            ("hello_world __x__", &["hello", "world", "x"]),
+            ("trace_id=abc", &["trace", "id", "abc"]),
+            ("错误error日志", &["错误", "error", "日志"]),
+            ("连接timeout.5次", &["连接", "timeout", "5", "次"]),
+            ("用户user-123登录", &["用户", "user", "123", "登录"]),
+            ("中国农业银行", &["中国", "国农", "农业", "业银", "银行"]),
+            ("Größe日x", &["Gr", "öß", "e", "日", "x"]),
+        ];
+        for (text, expected) in cases {
+            assert_eq!(tokenize(text), expected, "text: {text}");
+        }
+    }
+
+    #[test]
+    fn test_irregular_lowercase_chars() {
+        for c in (0..=0x10FFFF).filter_map(char::from_u32) {
+            let lower = c.to_lowercase().collect::<Vec<_>>();
+            let regular = lower.len() == 1 && classify_char(lower[0]) == classify_char(c);
+            let expect_regular = !matches!(c, '\u{130}' | '\u{212A}');
+            assert_eq!(regular, expect_regular, "U+{:04X}", c as u32);
+        }
+    }
+
+    #[test]
+    fn test_term_probes() {
+        let cases: [(&str, &[&str]); 8] = [
+            ("world", &["world"]),
+            ("hello world", &["hello", "world"]),
+            ("/start", &["start"]),
+            ("naïve", &["na", "ï", "ve"]),
+            // Han terms match as substrings: only bigrams and runs enclosed by
+            // other characters of the term are safe.
+            ("农业", &["农业"]),
+            ("农", &[]),
+            ("机号1888", &["机号"]),
+            ("x错误y日z", &["错误", "y", "日"]),
+        ];
+        for (term, expected) in cases {
+            assert_eq!(extract_term_probes(term), expected, "term: {term}");
+        }
+    }
+
+    #[test]
+    fn test_like_probes() {
+        let cases: [(&str, &[&str]); 11] = [
+            ("%timeout%", &[]),
+            ("% timeout %", &["timeout"]),
+            ("timeout%", &[]),
+            ("timeout: %", &["timeout"]),
+            ("%: timeout", &["timeout"]),
+            ("a_b c", &["c"]),
+            (r"trace\_id=%", &["trace", "id"]),
+            (r"100\% done", &["100", "done"]),
+            (r"x\\y", &["x", "y"]),
+            ("%错误error日%", &["错误", "error"]),
+            ("%错误 x%", &["错误"]),
+        ];
+        for (pattern, expected) in cases {
+            assert_eq!(extract_like_probes(pattern), expected, "pattern: {pattern}");
+        }
+    }
+}
diff --git a/src/common/error/src/ext.rs b/src/common/error/src/ext.rs
index 0c267dc15b2..f2d01914818 100644
--- a/src/common/error/src/ext.rs
+++ b/src/common/error/src/ext.rs
@@ -46,6 +46,10 @@ use crate::status_code::StatusCode;
 pub enum RetryHint {
     /// The operation may succeed if retried later.
     Retryable,
+    /// The operation may succeed after refreshing routing and partition information.
+    /// The request may need rebuilding when its partition assignment changes.
+    /// This hint does not imply that a failed operation had no side effects.
+    RetryAfterRouteRefresh,
     /// Retrying the same operation is not expected to help.
     ///
     /// This is the default for errors that do not explicitly opt in to retry.
@@ -53,16 +57,23 @@ pub enum RetryHint {
 }
 
 const RETRY_HINT_RETRYABLE: &str = "retryable";
+const RETRY_HINT_AFTER_ROUTE_REFRESH: &str = "retry_after_route_refresh";
 const RETRY_HINT_NON_RETRYABLE: &str = "non_retryable";
 
 impl RetryHint {
+    /// Returns whether another attempt may succeed, possibly after refreshing routes.
     pub fn is_retryable(self) -> bool {
-        matches!(self, RetryHint::Retryable)
+        matches!(
+            self,
+            RetryHint::Retryable | RetryHint::RetryAfterRouteRefresh
+        )
     }
 
+    /// Returns the retry hint encoded in gRPC error metadata.
     pub fn as_str(self) -> &'static str {
         match self {
             RetryHint::Retryable => RETRY_HINT_RETRYABLE,
+            RetryHint::RetryAfterRouteRefresh => RETRY_HINT_AFTER_ROUTE_REFRESH,
             RetryHint::NonRetryable => RETRY_HINT_NON_RETRYABLE,
         }
     }
@@ -90,6 +101,7 @@ impl FromStr for RetryHint {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             RETRY_HINT_RETRYABLE => Ok(RetryHint::Retryable),
+            RETRY_HINT_AFTER_ROUTE_REFRESH => Ok(RetryHint::RetryAfterRouteRefresh),
             RETRY_HINT_NON_RETRYABLE => Ok(RetryHint::NonRetryable),
             _ => Err(()),
         }
@@ -133,7 +145,9 @@ pub trait ErrorExt: StackError {
     ///
     /// Implementations should return [`RetryHint::Retryable`] only when retrying the
     /// same operation may succeed without changing the request. The default is
-    /// [`RetryHint::NonRetryable`] to avoid accidental retry loops.
+    /// [`RetryHint::NonRetryable`] to avoid accidental retry loops. Use
+    /// [`RetryHint::RetryAfterRouteRefresh`] when routing or partition information
+    /// must be refreshed before another attempt.
     fn retry_hint(&self) -> RetryHint {
         RetryHint::NonRetryable
     }
diff --git a/src/common/error/tests/ext.rs b/src/common/error/tests/ext.rs
index 8be8afa4748..c34a47c400f 100644
--- a/src/common/error/tests/ext.rs
+++ b/src/common/error/tests/ext.rs
@@ -164,6 +164,15 @@ fn test_transparent_flag() {
 #[test]
 fn test_retry_hint_helpers() {
     assert!(RetryHint::Retryable.is_retryable());
+    assert!(RetryHint::RetryAfterRouteRefresh.is_retryable());
+    assert_eq!(
+        RetryHint::RetryAfterRouteRefresh.as_str(),
+        "retry_after_route_refresh"
+    );
+    assert_eq!(
+        RetryHint::from_str("retry_after_route_refresh").unwrap(),
+        RetryHint::RetryAfterRouteRefresh
+    );
     assert!(!RetryHint::NonRetryable.is_retryable());
 
     assert_eq!(RetryHint::Retryable.as_str(), "retryable");
diff --git a/src/common/function/Cargo.toml b/src/common/function/Cargo.toml
index 3a5da30c136..f5fdf200726 100644
--- a/src/common/function/Cargo.toml
+++ b/src/common/function/Cargo.toml
@@ -46,7 +46,6 @@ geo-types = { version = "0.7", optional = true }
 geohash = { version = "0.13", optional = true }
 h3o = { version = "0.6", optional = true }
 hyperloglogplus = "0.4"
-icu_properties.workspace = true
 jsonb.workspace = true
 memchr = "2.7"
 mito-codec.workspace = true
diff --git a/src/common/function/src/aggrs.rs b/src/common/function/src/aggrs.rs
index e618921a18d..bad38a075d4 100644
--- a/src/common/function/src/aggrs.rs
+++ b/src/common/function/src/aggrs.rs
@@ -14,6 +14,7 @@
 
 pub mod approximate;
 pub mod count_hash;
+pub mod extremum;
 #[cfg(feature = "geo")]
 pub mod geo;
 pub mod vector;
diff --git a/src/common/function/src/aggrs/aggr_wrapper.rs b/src/common/function/src/aggrs/aggr_wrapper.rs
index 710c383a834..8c0c475c265 100644
--- a/src/common/function/src/aggrs/aggr_wrapper.rs
+++ b/src/common/function/src/aggrs/aggr_wrapper.rs
@@ -22,6 +22,7 @@
 //! `foo_merge`'s input arg is the same as `foo_state`'s output, and its output is the same as `foo`'s input.
 //!
 
+use std::collections::HashSet;
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
@@ -183,7 +184,13 @@ impl StateMergeHelper {
                 )));
             }
         };
-        let mut lower_aggr_exprs = vec![];
+        // (unaliased state expression, output column name)
+        let mut lower_states: Vec<(Expr, String)> = vec![];
+        let mut lower_output_names: HashSet<String> = aggr
+            .group_expr
+            .iter()
+            .map(|e| e.qualified_name().1)
+            .collect();
         let mut upper_aggr_exprs = vec![];
 
         // group exprs for upper plan should refer to the output group expr as column from lower plan
@@ -218,9 +225,28 @@ impl StateMergeHelper {
                 params: aggr_func.params.clone(),
             };
             let expr = Expr::AggregateFunction(expr);
-            let lower_state_output_col_name = expr.schema_name().to_string();
 
-            lower_aggr_exprs.push(expr);
+            // The state column is named after the unaliased state expression, which can
+            // repeat even though the original output names are unique: a name-preserving
+            // rewrite such as `count(*)` -> `count(ts) AS count(*)` can make two aggregates
+            // share one state expression, and schema names hide casts, so
+            // `count(CAST(ts AS Int64))` is named `count(t.ts)` too. Identical states are
+            // computed once; a different state with a taken name gets a numeric suffix.
+            let lower_state_output_col_name =
+                if let Some((_, name)) = lower_states.iter().find(|(e, _)| *e == expr) {
+                    name.clone()
+                } else {
+                    let base = expr.schema_name().to_string();
+                    let mut name = base.clone();
+                    let mut suffix = 0;
+                    while lower_output_names.contains(&name) {
+                        suffix += 1;
+                        name = format!("{base}_{suffix}");
+                    }
+                    lower_output_names.insert(name.clone());
+                    lower_states.push((expr, name.clone()));
+                    name
+                };
 
             // then create the merge function using the physical expression of the original aggregate function
             let (name, human_display) = match aggr_expr {
@@ -270,7 +296,16 @@ impl StateMergeHelper {
         }
 
         let mut lower = aggr.clone();
-        lower.aggr_expr = lower_aggr_exprs;
+        lower.aggr_expr = lower_states
+            .into_iter()
+            .map(|(expr, name)| {
+                if expr.schema_name().to_string() == name {
+                    expr
+                } else {
+                    expr.alias(name)
+                }
+            })
+            .collect();
         let lower_plan = LogicalPlan::Aggregate(lower);
 
         // update aggregate's output schema
diff --git a/src/common/function/src/aggrs/extremum.rs b/src/common/function/src/aggrs/extremum.rs
new file mode 100644
index 00000000000..668c307ff36
--- /dev/null
+++ b/src/common/function/src/aggrs/extremum.rs
@@ -0,0 +1,259 @@
+// 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.
+
+//! PromQL `min` and `max` aggregation operators.
+//!
+//! PromQL ignores NaN samples unless every sample of a group is NaN. DataFusion's
+//! `min`/`max` order NaN differently depending on the code path (its grouped
+//! accumulator lets NaN replace the current value and be replaced by the next one),
+//! so the result depends on the order of the input.
+
+use std::sync::Arc;
+
+use datafusion::arrow::array::{ArrayRef, AsArray};
+use datafusion::arrow::datatypes::{DataType, Field, FieldRef, Float64Type};
+use datafusion::error::Result as DfResult;
+use datafusion::logical_expr::function::{AccumulatorArgs, StateFieldsArgs};
+use datafusion::logical_expr::{
+    Accumulator, AggregateUDF, AggregateUDFImpl, GroupsAccumulator, Signature, Volatility,
+};
+use datafusion_common::ScalarValue;
+use datafusion_functions_aggregate_common::aggregate::groups_accumulator::prim_op::PrimitiveGroupsAccumulator;
+
+use crate::function_registry::FunctionRegistry;
+
+/// `max` or `min` with PromQL NaN semantics.
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct Extremum {
+    name: &'static str,
+    is_max: bool,
+    signature: Signature,
+}
+
+impl Extremum {
+    pub const MAX_NAME: &'static str = "prom_max";
+    pub const MIN_NAME: &'static str = "prom_min";
+
+    /// Registers both functions; the registry also derives their state functions, which
+    /// distributed plans need to split the aggregation between datanodes and the frontend.
+    pub fn register(registry: &FunctionRegistry) {
+        registry.register_aggr(Self::max_udaf());
+        registry.register_aggr(Self::min_udaf());
+    }
+
+    pub fn max_udaf() -> AggregateUDF {
+        AggregateUDF::from(Self::new(Self::MAX_NAME, true))
+    }
+
+    pub fn min_udaf() -> AggregateUDF {
+        AggregateUDF::from(Self::new(Self::MIN_NAME, false))
+    }
+
+    fn new(name: &'static str, is_max: bool) -> Self {
+        Self {
+            name,
+            is_max,
+            signature: Signature::exact(vec![DataType::Float64], Volatility::Immutable),
+        }
+    }
+}
+
+/// Folds `value` into `current` like Prometheus' aggregation: a NaN is replaced by any
+/// sample, and a NaN sample never replaces a number.
+fn fold(is_max: bool, current: &mut f64, value: f64) {
+    let better = if is_max {
+        value > *current
+    } else {
+        value < *current
+    };
+    if current.is_nan() || better {
+        *current = value;
+    }
+}
+
+impl AggregateUDFImpl for Extremum {
+    fn name(&self) -> &str {
+        self.name
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> DfResult<DataType> {
+        Ok(DataType::Float64)
+    }
+
+    fn accumulator(&self, _acc_args: AccumulatorArgs) -> DfResult<Box<dyn Accumulator>> {
+        Ok(Box::new(ExtremumAccumulator {
+            is_max: self.is_max,
+            value: None,
+        }))
+    }
+
+    fn state_fields(&self, args: StateFieldsArgs) -> DfResult<Vec<FieldRef>> {
+        Ok(vec![Arc::new(Field::new(
+            format!("{}[{}]", args.name, self.name),
+            DataType::Float64,
+            true,
+        ))])
+    }
+
+    fn groups_accumulator_supported(&self, _args: AccumulatorArgs) -> bool {
+        true
+    }
+
+    fn create_groups_accumulator(
+        &self,
+        _args: AccumulatorArgs,
+    ) -> DfResult<Box<dyn GroupsAccumulator>> {
+        Ok(groups_accumulator(self.is_max))
+    }
+}
+
+fn groups_accumulator(is_max: bool) -> Box<dyn GroupsAccumulator> {
+    Box::new(
+        PrimitiveGroupsAccumulator::<Float64Type, _>::new(&DataType::Float64, move |cur, v| {
+            fold(is_max, cur, v)
+        })
+        .with_starting_value(f64::NAN),
+    )
+}
+
+#[derive(Debug)]
+struct ExtremumAccumulator {
+    is_max: bool,
+    value: Option<f64>,
+}
+
+impl ExtremumAccumulator {
+    fn update(&mut self, values: &ArrayRef) {
+        for v in values.as_primitive::<Float64Type>().iter().flatten() {
+            match &mut self.value {
+                Some(current) => fold(self.is_max, current, v),
+                None => self.value = Some(v),
+            }
+        }
+    }
+}
+
+impl Accumulator for ExtremumAccumulator {
+    fn update_batch(&mut self, values: &[ArrayRef]) -> DfResult<()> {
+        self.update(&values[0]);
+        Ok(())
+    }
+
+    fn merge_batch(&mut self, states: &[ArrayRef]) -> DfResult<()> {
+        self.update(&states[0]);
+        Ok(())
+    }
+
+    fn state(&mut self) -> DfResult<Vec<ScalarValue>> {
+        Ok(vec![ScalarValue::Float64(self.value)])
+    }
+
+    fn evaluate(&mut self) -> DfResult<ScalarValue> {
+        Ok(ScalarValue::Float64(self.value))
+    }
+
+    fn size(&self) -> usize {
+        size_of_val(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use datafusion::arrow::array::Float64Array;
+    use datafusion::logical_expr::EmitTo;
+
+    use super::*;
+
+    fn groups_result(
+        is_max: bool,
+        values: Vec<Option<f64>>,
+        groups: Vec<usize>,
+    ) -> Vec<Option<f64>> {
+        let num_groups = groups.iter().max().map_or(0, |g| g + 1);
+        let mut acc = groups_accumulator(is_max);
+        let values: ArrayRef = Arc::new(Float64Array::from(values));
+        acc.update_batch(&[values], &groups, None, num_groups)
+            .unwrap();
+        let out = acc.evaluate(EmitTo::All).unwrap();
+        out.as_primitive::<Float64Type>().iter().collect()
+    }
+
+    fn is_nan(v: Option<f64>) -> bool {
+        v.is_some_and(f64::is_nan)
+    }
+
+    #[test]
+    fn nan_is_ignored_unless_the_group_is_all_nan() {
+        // Group 0 has NaN on both sides of a number; group 1 is all NaN; group 2 has only NULL.
+        let values = vec![
+            Some(f64::NAN),
+            Some(3.0),
+            Some(f64::NAN),
+            Some(f64::NAN),
+            None,
+        ];
+        let groups = vec![0, 0, 0, 1, 2];
+        for is_max in [true, false] {
+            let out = groups_result(is_max, values.clone(), groups.clone());
+            assert_eq!(out[0], Some(3.0));
+            assert!(is_nan(out[1]));
+            assert_eq!(out[2], None);
+        }
+    }
+
+    #[test]
+    fn result_does_not_depend_on_input_order() {
+        let forward = vec![Some(1.0), Some(f64::NAN), Some(4.0), Some(2.0)];
+        let mut backward = forward.clone();
+        backward.reverse();
+        assert_eq!(
+            groups_result(true, forward.clone(), vec![0; 4]),
+            vec![Some(4.0)]
+        );
+        assert_eq!(
+            groups_result(true, backward.clone(), vec![0; 4]),
+            vec![Some(4.0)]
+        );
+        assert_eq!(groups_result(false, forward, vec![0; 4]), vec![Some(1.0)]);
+        assert_eq!(groups_result(false, backward, vec![0; 4]), vec![Some(1.0)]);
+    }
+
+    #[test]
+    fn merged_partial_states_keep_nan_semantics() {
+        let mut partial_nan = ExtremumAccumulator {
+            is_max: true,
+            value: None,
+        };
+        partial_nan.update(&(Arc::new(Float64Array::from(vec![f64::NAN])) as ArrayRef));
+        let mut partial_num = ExtremumAccumulator {
+            is_max: true,
+            value: None,
+        };
+        partial_num.update(&(Arc::new(Float64Array::from(vec![2.0, 5.0])) as ArrayRef));
+
+        let mut merged = ExtremumAccumulator {
+            is_max: true,
+            value: None,
+        };
+        for partial in [&mut partial_nan, &mut partial_num] {
+            let state = partial.state().unwrap()[0].to_array().unwrap();
+            merged.merge_batch(&[state]).unwrap();
+        }
+        assert_eq!(merged.evaluate().unwrap(), ScalarValue::Float64(Some(5.0)));
+    }
+}
diff --git a/src/common/function/src/function_registry.rs b/src/common/function/src/function_registry.rs
index 6583f7ba607..8657636fe6b 100644
--- a/src/common/function/src/function_registry.rs
+++ b/src/common/function/src/function_registry.rs
@@ -25,6 +25,7 @@ use crate::admin::AdminFunction;
 use crate::aggrs::aggr_wrapper::StateMergeHelper;
 use crate::aggrs::approximate::ApproximateFunction;
 use crate::aggrs::count_hash::CountHash;
+use crate::aggrs::extremum::Extremum;
 use crate::aggrs::vector::VectorFunction as VectorAggrFunction;
 use crate::function::{Function, FunctionRef};
 use crate::function_factory::ScalarFunctionFactory;
@@ -260,6 +261,9 @@ pub static FUNCTION_REGISTRY: LazyLock<Arc<FunctionRegistry>> = LazyLock::new(||
     // CountHash function
     CountHash::register(&function_registry);
 
+    // PromQL min/max; registered before the state functions are derived.
+    Extremum::register(&function_registry);
+
     // state function of supported aggregate functions
     StateMergeHelper::register(&function_registry);
 
diff --git a/src/common/function/src/scalars/matches_term.rs b/src/common/function/src/scalars/matches_term.rs
index ec1b34d408e..5775307922e 100644
--- a/src/common/function/src/scalars/matches_term.rs
+++ b/src/common/function/src/scalars/matches_term.rs
@@ -15,13 +15,12 @@
 use std::fmt;
 use std::sync::Arc;
 
+use common_base::term_token::{CharClass, classify_char};
 use datafusion_common::arrow::array::{Array, AsArray, BooleanArray, BooleanBuilder};
 use datafusion_common::arrow::compute;
 use datafusion_common::arrow::datatypes::DataType;
 use datafusion_common::{DataFusionError, ScalarValue};
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, Signature, Volatility};
-use icu_properties::props::Script;
-use icu_properties::{CodePointMapData, CodePointMapDataBorrowed};
 use memchr::memmem;
 
 use crate::function::Function;
@@ -231,14 +230,6 @@ pub struct MatchesTermFinder {
     ends_with_other: bool,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum CharClass {
-    AsciiWord,
-    Han,
-    UnicodeWord,
-    Other,
-}
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum TermKind {
     AsciiLike,
@@ -246,25 +237,6 @@ enum TermKind {
     HanContaining,
 }
 
-fn classify_char(c: char) -> CharClass {
-    if c.is_ascii_alphanumeric() {
-        CharClass::AsciiWord
-    } else if is_han(c) {
-        CharClass::Han
-    } else if c.is_alphanumeric() {
-        CharClass::UnicodeWord
-    } else {
-        CharClass::Other
-    }
-}
-
-static HAN_SCRIPT_DATA: CodePointMapDataBorrowed<'static, Script> =
-    CodePointMapData::<Script>::new();
-
-fn is_han(c: char) -> bool {
-    HAN_SCRIPT_DATA.get(c) == Script::Han
-}
-
 fn classify_term(term: &str) -> TermKind {
     let mut has_han = false;
     let mut has_unicode_word = false;
@@ -508,12 +480,4 @@ mod tests {
         assert!(MatchesTermFinder::new("行账号").find("中国农业银行账号"));
         assert!(MatchesTermFinder::new("登录").find("登录手机号18888888888的动态key"));
     }
-
-    #[test]
-    fn han_detection_uses_script_not_all_cjk() {
-        assert!(is_han('汉'));
-        assert!(is_han('\u{30000}'));
-        assert!(!is_han('あ'));
-        assert!(!is_han('한'));
-    }
 }
diff --git a/src/common/function/src/scalars/vector/impl_conv.rs b/src/common/function/src/scalars/vector/impl_conv.rs
index 219361a302c..00d23cedf7f 100644
--- a/src/common/function/src/scalars/vector/impl_conv.rs
+++ b/src/common/function/src/scalars/vector/impl_conv.rs
@@ -53,8 +53,10 @@ pub fn binlit_as_veclit(bytes: &[u8]) -> Result<Cow<'_, [f32]>> {
         })
     } else {
         let v = bytes
-            .chunks_exact(std::mem::size_of::<f32>())
-            .map(|chunk| f32::from_le_bytes(chunk.try_into().unwrap()))
+            .as_chunks::<{ std::mem::size_of::<f32>() }>()
+            .0
+            .iter()
+            .map(|chunk| f32::from_le_bytes(*chunk))
             .collect::<Vec<f32>>();
         Ok(Cow::Owned(v))
     }
diff --git a/src/common/meta/AGENTS.md b/src/common/meta/AGENTS.md
index 3684f8f9db3..6c9710b9e45 100644
--- a/src/common/meta/AGENTS.md
+++ b/src/common/meta/AGENTS.md
@@ -41,3 +41,12 @@ cargo nextest run -p common-meta
 ```
 
 Backend-specific coverage may also need `pg_kvbackend` or `mysql_kvbackend`.
+
+`test_util::etcd_certs_dir` and `test_util::test_certs_dir` resolve fixture
+certificates using `CARGO_MANIFEST_DIR` at **run time** (`std::env::var`, not `env!`).
+`cargo nextest run` sets it; direct test-binary execution requires setting the
+variable to the crate directory. Run this example from the repository root:
+
+```bash
+CARGO_MANIFEST_DIR="$PWD/src/common/meta" ./target/debug/deps/<test_binary>
+```
diff --git a/src/common/meta/src/ddl/create_flow.rs b/src/common/meta/src/ddl/create_flow.rs
index e36c89fbb34..89ade1b5cbe 100644
--- a/src/common/meta/src/ddl/create_flow.rs
+++ b/src/common/meta/src/ddl/create_flow.rs
@@ -42,7 +42,7 @@ use crate::cache_invalidator::Context;
 use crate::ddl::DdlContext;
 use crate::ddl::event::flow::{CREATE_FLOW_EVENT_TYPE, CreateFlowEventIntent, FlowDdlEvent};
 use crate::ddl::utils::{add_peer_context_if_needed, map_to_procedure_error};
-use crate::error::{self, Result, UnexpectedSnafu};
+use crate::error::{self, InvalidFlowOptionSnafu, Result, UnexpectedSnafu};
 use crate::instruction::{CacheIdent, CreateFlow, DropFlow};
 use crate::key::flow::flow_info::{FlowInfoValue, FlowScheduleConfig, FlowStatus};
 use crate::key::flow::flow_route::FlowRouteValue;
@@ -558,9 +558,9 @@ pub fn validate_flow_options(flow_task: &CreateFlowTask) -> Result<()> {
             | FLOW_EXPERIMENTAL_ENABLE_INCREMENTAL_READ_KEY
             | FlowType::FLOW_TYPE_KEY => {}
             unknown => {
-                return UnexpectedSnafu {
+                return InvalidFlowOptionSnafu {
                     err_msg: format!(
-                        "Unknown flow option '{unknown}', supported user options: {DEFER_ON_MISSING_SOURCE_KEY}, {FLOW_EXPERIMENTAL_ENABLE_INCREMENTAL_READ_KEY}"
+                        "unknown flow option '{unknown}', supported options: {DEFER_ON_MISSING_SOURCE_KEY}, {FLOW_EXPERIMENTAL_ENABLE_INCREMENTAL_READ_KEY}"
                     ),
                 }
                 .fail();
diff --git a/src/common/meta/src/ddl/drop_table.rs b/src/common/meta/src/ddl/drop_table.rs
index b73bd95e1bc..622a27d804b 100644
--- a/src/common/meta/src/ddl/drop_table.rs
+++ b/src/common/meta/src/ddl/drop_table.rs
@@ -19,6 +19,8 @@ use std::collections::HashMap;
 
 use async_trait::async_trait;
 use common_error::ext::BoxedError;
+#[cfg(feature = "enterprise")]
+use common_error::ext::ErrorExt;
 use common_event_recorder::Event;
 use common_procedure::error::{ExternalSnafu, FromJsonSnafu, ToJsonSnafu};
 use common_procedure::{
@@ -53,7 +55,7 @@ use crate::rpc::router::{RegionRoute, operating_leader_region_roles};
 
 #[cfg(feature = "enterprise")]
 fn ensure_retry_later(err: error::Error) -> error::Error {
-    if err.is_retry_later() {
+    if err.retry_hint().is_retryable() {
         err
     } else {
         error::Error::retry_later(err)
diff --git a/src/common/meta/src/ddl/tests/create_flow.rs b/src/common/meta/src/ddl/tests/create_flow.rs
index e7004656fe9..ad334e29863 100644
--- a/src/common/meta/src/ddl/tests/create_flow.rs
+++ b/src/common/meta/src/ddl/tests/create_flow.rs
@@ -18,6 +18,8 @@ use std::sync::Arc;
 
 use api::v1::flow::CreateRequest;
 use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
+use common_error::ext::ErrorExt;
+use common_error::status_code::StatusCode;
 use common_procedure::{Procedure, Status};
 use common_procedure_test::execute_procedure_until_done;
 use table::table_name::TableName;
@@ -326,6 +328,26 @@ fn test_validate_flow_options_allows_incremental_read_option() {
     validate_flow_options(&task).unwrap();
 }
 
+#[test]
+fn test_validate_flow_options_unknown_option_matches_invalid_sql_error() {
+    let mut task = test_create_flow_task(
+        "my_flow",
+        vec![],
+        TableName::new(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, "my_sink_table"),
+        false,
+    );
+    task.flow_options
+        .insert("foo".to_string(), "sensitive-value".to_string());
+
+    let err = validate_flow_options(&task).unwrap_err();
+    assert_eq!(StatusCode::InvalidArguments, err.status_code());
+    assert_eq!(
+        "Invalid SQL, error: unknown flow option 'foo', supported options: defer_on_missing_source, experimental_enable_incremental_read",
+        err.output_msg()
+    );
+    assert!(!err.output_msg().contains("sensitive-value"));
+}
+
 #[test]
 fn test_validate_flow_options_rejects_schedule_and_internal_keys_as_unknown() {
     for key in [
@@ -346,9 +368,10 @@ fn test_validate_flow_options_rejects_schedule_and_internal_keys_as_unknown() {
             .insert(key.to_string(), "value".to_string());
 
         let err = validate_flow_options(&task).unwrap_err();
+        assert_eq!(StatusCode::InvalidArguments, err.status_code());
         assert!(
             err.to_string()
-                .contains(&format!("Unknown flow option '{key}'")),
+                .contains(&format!("unknown flow option '{key}'")),
             "unexpected error for {key}: {err}"
         );
     }
@@ -884,10 +907,10 @@ async fn test_create_flow_rejects_unknown_option_in_meta_task() {
     let mut procedure = CreateFlowProcedure::new(task, query_ctx, ddl_context);
 
     let err = procedure.on_prepare().await.unwrap_err();
-    assert_matches!(err, error::Error::Unexpected { .. });
+    assert_eq!(StatusCode::InvalidArguments, err.status_code());
     assert!(
         err.to_string()
-            .contains("Unknown flow option 'unknown_option'")
+            .contains("unknown flow option 'unknown_option'")
     );
 }
 
diff --git a/src/common/meta/src/ddl/undrop_table.rs b/src/common/meta/src/ddl/undrop_table.rs
index 73a361ffd0e..efb1d4824d7 100644
--- a/src/common/meta/src/ddl/undrop_table.rs
+++ b/src/common/meta/src/ddl/undrop_table.rs
@@ -17,8 +17,8 @@ use api::v1::region::{
 use async_trait::async_trait;
 use common_procedure::error::{FromJsonSnafu, ToJsonSnafu};
 use common_procedure::{
-    Context as ProcedureContext, EventContext, EventTrigger, LockKey, Procedure,
-    Result as ProcedureResult, Status,
+    Context as ProcedureContext, Error as ProcedureError, EventContext, EventTrigger, LockKey,
+    Procedure, Result as ProcedureResult, Status,
 };
 use common_telemetry::tracing_context::TracingContext;
 use common_telemetry::warn;
@@ -156,6 +156,7 @@ impl UndropTableProcedure {
         }
         .await;
         if let Err(err) = restore_result {
+            // Keep this classification aligned with map_restore_error().
             let should_cleanup_opened_regions = !err.is_retry_later();
             let err = self.map_restore_metadata_error(err);
             if should_cleanup_opened_regions
@@ -274,6 +275,19 @@ impl UndropTableProcedure {
         Ok(())
     }
 
+    fn map_restore_error(err: error::Error) -> ProcedureError {
+        // Restore retries keep opened regions, while other failures close them. Preserve
+        // this policy even when the underlying metadata error carries a retry hint:
+        // retrying after cleanup would restore metadata without reopening the regions.
+        if err.is_retry_later() {
+            map_to_procedure_error(err)
+        } else if err.need_clean_poisons() {
+            ProcedureError::external_and_clean_poisons(err)
+        } else {
+            ProcedureError::external(err)
+        }
+    }
+
     fn map_restore_metadata_error(&self, err: error::Error) -> error::Error {
         match err {
             error::Error::TombstoneTargetAlreadyExists { .. } => {
@@ -413,7 +427,12 @@ impl Procedure for UndropTableProcedure {
     async fn execute(&mut self, _: &ProcedureContext) -> ProcedureResult<Status> {
         match self.data.state {
             UndropTableState::Prepare => self.on_prepare().await,
-            UndropTableState::RestoreMetadata => self.on_restore_metadata().await,
+            UndropTableState::RestoreMetadata => {
+                return self
+                    .on_restore_metadata()
+                    .await
+                    .map_err(Self::map_restore_error);
+            }
             UndropTableState::OpenRegions => self.on_open_regions().await,
             UndropTableState::InvalidateTableCache => self.on_broadcast().await,
         }
@@ -606,7 +625,8 @@ mod tests {
     use api::v1::region::region_request;
     use async_trait::async_trait;
     use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
-    use common_error::ext::ErrorExt;
+    use common_error::ext::{BoxedError, ErrorExt};
+    use common_error::mock::MockError;
     use common_error::status_code::StatusCode;
     use store_api::storage::RegionId;
     use table::table_name::TableName;
@@ -635,6 +655,38 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_restore_metadata_retry_policy() {
+        let source = error::Error::retry_later(MockError::new(StatusCode::Internal));
+        let err = Err::<(), _>(BoxedError::new(source))
+            .context(error::ExternalSnafu)
+            .unwrap_err();
+        assert!(err.retry_hint().is_retryable());
+        assert!(!err.is_retry_later());
+        let err = UndropTableProcedure::map_restore_error(err);
+        assert!(!err.is_retry_later());
+        assert!(!err.need_clean_poisons());
+
+        for retryable in [false, true] {
+            for clean_poisons in [false, true] {
+                let source = BoxedError::new(MockError::new(StatusCode::Internal));
+                let err = if retryable {
+                    error::Error::RetryLater {
+                        source,
+                        clean_poisons,
+                    }
+                } else {
+                    Err::<(), _>(source)
+                        .context(error::AbortProcedureSnafu { clean_poisons })
+                        .unwrap_err()
+                };
+                let err = UndropTableProcedure::map_restore_error(err);
+                assert_eq!(err.is_retry_later(), retryable);
+                assert_eq!(err.need_clean_poisons(), clean_poisons);
+            }
+        }
+    }
+
     #[test]
     fn test_map_restore_metadata_error_without_table_name() {
         let context = new_ddl_context(Arc::new(MockDatanodeManager::new(())));
diff --git a/src/common/meta/src/ddl/utils.rs b/src/common/meta/src/ddl/utils.rs
index ebfbd6fd522..a8058d89b94 100644
--- a/src/common/meta/src/ddl/utils.rs
+++ b/src/common/meta/src/ddl/utils.rs
@@ -28,7 +28,7 @@ use api::v1::region::{
     region_request,
 };
 use common_catalog::consts::{METRIC_ENGINE, MITO_ENGINE};
-use common_error::ext::BoxedError;
+use common_error::ext::{BoxedError, ErrorExt};
 use common_procedure::error::Error as ProcedureError;
 use common_telemetry::tracing_context::TracingContext;
 use common_telemetry::{error, info, warn};
@@ -61,7 +61,7 @@ use crate::wal_provider::RegionWalOptions;
 pub fn add_peer_context_if_needed(datanode: Peer) -> impl FnOnce(Error) -> Error {
     move |err| {
         error!(err; "Failed to operate datanode, peer: {}", datanode);
-        if !err.is_retry_later() {
+        if !err.retry_hint().is_retryable() {
             return Err::<(), BoxedError>(BoxedError::new(err))
                 .context(OperateDatanodeSnafu { peer: datanode })
                 .unwrap_err();
@@ -84,7 +84,7 @@ pub(crate) fn is_metric_engine_logical_table(
 /// This function determines whether the error should be retried and if poison cleanup is needed,
 /// then maps it to the appropriate procedure error variant.
 pub fn map_to_procedure_error(e: Error) -> ProcedureError {
-    match (e.is_retry_later(), e.need_clean_poisons()) {
+    match (e.retry_hint().is_retryable(), e.need_clean_poisons()) {
         (true, true) => ProcedureError::retry_later_and_clean_poisons(e),
         (true, false) => ProcedureError::retry_later(e),
         (false, true) => ProcedureError::external_and_clean_poisons(e),
@@ -256,7 +256,7 @@ pub fn handle_multiple_results<T: Debug>(results: Vec<Result<T>>) -> MultipleRes
         match result {
             Ok(value) => ok_results.push(value),
             Err(err) => {
-                if err.is_retry_later() {
+                if err.retry_hint().is_retryable() {
                     retryable_results.push(err);
                 } else {
                     non_retryable_results.push(err);
@@ -475,8 +475,74 @@ pub fn extract_column_metadatas(
 
 #[cfg(test)]
 mod tests {
+    use common_error::mock::MockError;
+    use common_error::status_code::StatusCode;
+
     use super::*;
 
+    fn external_error(retryable: bool) -> Error {
+        let source = MockError::new(StatusCode::Internal);
+        let source = if retryable {
+            BoxedError::new(Error::retry_later(source))
+        } else {
+            BoxedError::new(source)
+        };
+        Err::<(), _>(source)
+            .context(error::ExternalSnafu)
+            .unwrap_err()
+    }
+
+    #[test]
+    fn test_map_to_procedure_error() {
+        for retryable in [false, true] {
+            for clean_poisons in [false, true] {
+                let err = if retryable {
+                    Error::RetryLater {
+                        source: BoxedError::new(external_error(false)),
+                        clean_poisons,
+                    }
+                } else {
+                    Err::<(), _>(BoxedError::new(external_error(true)))
+                        .context(error::AbortProcedureSnafu { clean_poisons })
+                        .unwrap_err()
+                };
+                let err = map_to_procedure_error(err);
+                assert_eq!(err.is_retry_later(), retryable);
+                assert_eq!(err.need_clean_poisons(), clean_poisons);
+            }
+            let err = map_to_procedure_error(external_error(retryable));
+            assert_eq!(err.is_retry_later(), retryable);
+            assert!(!err.need_clean_poisons());
+        }
+    }
+
+    #[test]
+    fn test_handle_multiple_results_retry_hint() {
+        assert!(matches!(
+            handle_multiple_results(vec![Ok(()), Err(external_error(true))]),
+            MultipleResults::PartialRetryable(_)
+        ));
+        assert!(matches!(
+            handle_multiple_results::<()>(vec![
+                Err(external_error(true)),
+                Err(external_error(true))
+            ]),
+            MultipleResults::AllRetryable(_)
+        ));
+        assert!(matches!(
+            handle_multiple_results(vec![
+                Ok(()),
+                Err(external_error(true)),
+                Err(external_error(false))
+            ]),
+            MultipleResults::PartialNonRetryable(_)
+        ));
+        assert!(matches!(
+            handle_multiple_results::<()>(vec![Err(external_error(false))]),
+            MultipleResults::AllNonRetryable(_)
+        ));
+    }
+
     #[test]
     fn test_get_catalog_and_schema() {
         let test_catalog = "my_catalog";
diff --git a/src/common/meta/src/error.rs b/src/common/meta/src/error.rs
index 62559fd6f1b..adfa158adf0 100644
--- a/src/common/meta/src/error.rs
+++ b/src/common/meta/src/error.rs
@@ -515,6 +515,13 @@ pub enum Error {
         location: Location,
     },
 
+    #[snafu(display("Invalid SQL, error: {err_msg}"))]
+    InvalidFlowOption {
+        err_msg: String,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
     #[snafu(display("Invalid flow request body: {:?}", body))]
     InvalidFlowRequestBody {
         body: Box<Option<api::v1::flow::flow_request::Body>>,
@@ -1247,6 +1254,7 @@ impl ErrorExt for Error {
 
             ProcedureNotFound { .. }
             | InvalidViewInfo { .. }
+            | InvalidFlowOption { .. }
             | PrimaryKeyNotFound { .. }
             | EmptyKey { .. }
             | AlterLogicalTablesInvalidArguments { .. }
@@ -1338,8 +1346,11 @@ impl ErrorExt for Error {
         use Error::*;
 
         match self {
-            RetryLater { .. }
-            | GetLatestCacheRetryExceeded { .. }
+            RetryLater { source, .. } => match source.retry_hint() {
+                RetryHint::RetryAfterRouteRefresh => RetryHint::RetryAfterRouteRefresh,
+                RetryHint::Retryable | RetryHint::NonRetryable => RetryHint::Retryable,
+            },
+            GetLatestCacheRetryExceeded { .. }
             | NoLeader { .. }
             | ElectionNoLeader { .. }
             | ElectionLeaderLeaseExpired { .. }
@@ -1362,15 +1373,15 @@ impl ErrorExt for Error {
             | StartProcedureManager { source, .. }
             | StopProcedureManager { source, .. }
             | RegisterProcedureLoader { source, .. }
-            | PutPoison { source, .. }
-            | ProcedureStateReceiver { source, .. } => source.retry_hint(),
+            | PutPoison { source, .. } => source.retry_hint(),
             External { source, .. }
             | ResponseExceededSizeLimit { source, .. }
             | OperateDatanode { source, .. }
-            | AbortProcedure { source, .. }
             | RegisterRepartitionProcedureLoader { source, .. }
             | CreateRepartitionProcedure { source, .. }
             | PersistRepartitionGcRequirement { source, .. } => source.retry_hint(),
+            // These errors end an operation; their sources cannot make it retryable.
+            AbortProcedure { .. } | ProcedureStateReceiver { .. } => RetryHint::NonRetryable,
             Table { source, .. } => source.retry_hint(),
             ConvertAlterTableRequest { source, .. } => source.retry_hint(),
             ConvertColumnDef { source, .. } => source.retry_hint(),
@@ -1455,6 +1466,7 @@ mod retry_hint_tests {
     use std::sync::Arc;
 
     use common_error::mock::MockError;
+    use snafu::ResultExt;
 
     use super::*;
 
@@ -1472,6 +1484,42 @@ mod retry_hint_tests {
         assert_eq!(err.retry_hint(), RetryHint::Retryable);
     }
 
+    #[test]
+    fn test_leader_retry_hints() {
+        for (error, expected) in [
+            (
+                NoLeaderSnafu { table_id: 1_u32 }.build(),
+                RetryHint::Retryable,
+            ),
+            (ElectionNoLeaderSnafu.build(), RetryHint::Retryable),
+            (
+                ElectionLeaderLeaseExpiredSnafu.build(),
+                RetryHint::Retryable,
+            ),
+            (
+                ElectionLeaderLeaseChangedSnafu.build(),
+                RetryHint::Retryable,
+            ),
+        ] {
+            assert_eq!(error.retry_hint(), expected, "{error:?}");
+        }
+    }
+
+    #[test]
+    fn test_procedure_error_retry_hints() {
+        let source = common_procedure::Error::retry_later(MockError::new(StatusCode::Internal));
+        let err = Err::<(), _>(source).context(PutPoisonSnafu).unwrap_err();
+        assert_eq!(err.retry_hint(), RetryHint::Retryable);
+
+        let source = common_procedure::Error::retry_later(MockError::new(StatusCode::Internal));
+        let err = Err::<(), _>(source)
+            .context(ProcedureStateReceiverSnafu {
+                procedure_id: ProcedureId::random(),
+            })
+            .unwrap_err();
+        assert_eq!(err.retry_hint(), RetryHint::NonRetryable);
+    }
+
     #[test]
     fn test_get_cache_forwards_retry_hint() {
         let source = Arc::new(Error::retry_later(MockError::new(StatusCode::Internal)));
diff --git a/src/common/meta/src/instruction.rs b/src/common/meta/src/instruction.rs
index 60ebe14e37c..827f06e944d 100644
--- a/src/common/meta/src/instruction.rs
+++ b/src/common/meta/src/instruction.rs
@@ -49,7 +49,7 @@ pub struct InstructionError {
     pub message: String,
     /// Retry hint serialized as a string.
     #[serde(
-        serialize_with = "RetryHint::serialize_as_str",
+        serialize_with = "InstructionError::serialize_retry_hint",
         deserialize_with = "RetryHint::deserialize_from_str"
     )]
     pub retry_hint: RetryHint,
@@ -108,6 +108,18 @@ impl InstructionError {
             retry_hint: error.retry_hint(),
         }
     }
+
+    /// Keeps instruction replies readable by peers that only know the legacy hints.
+    fn serialize_retry_hint<S>(hint: &RetryHint, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let hint = match hint {
+            RetryHint::RetryAfterRouteRefresh => RetryHint::Retryable,
+            hint => *hint,
+        };
+        RetryHint::serialize_as_str(&hint, serializer)
+    }
 }
 
 impl Display for InstructionError {
@@ -732,12 +744,12 @@ impl PackedRegionFileRefs {
         }
 
         let mut refs = HashSet::new();
-        for bytes in files.chunks_exact(16) {
+        for bytes in files.as_chunks::<16>().0 {
             let mut id = [0; 16];
             id.copy_from_slice(bytes);
             refs.insert(FileRef::new(region, FileId::from_bytes(id), None));
         }
-        for bytes in indexed.chunks_exact(24) {
+        for bytes in indexed.as_chunks::<24>().0 {
             let mut id = [0; 16];
             id.copy_from_slice(&bytes[..16]);
             let mut version = [0; 8];
@@ -1450,6 +1462,26 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_instruction_error_route_refresh_compatibility() {
+        let error = InstructionError::new(
+            StatusCode::RegionNotFound,
+            "region not found",
+            RetryHint::RetryAfterRouteRefresh,
+        );
+        let serialized = serde_json::to_string(&error).unwrap();
+        assert_eq!(
+            r#"{"code":4005,"message":"region not found","retry_hint":"retryable"}"#,
+            serialized
+        );
+        let decoded: InstructionError = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(decoded.code, error.code);
+        assert_eq!(decoded.message, error.message);
+        assert_eq!(decoded.retry_hint, RetryHint::Retryable);
+        assert_eq!(error.retry_hint, RetryHint::RetryAfterRouteRefresh);
+        assert_eq!(error.retry_hint.as_str(), "retry_after_route_refresh");
+    }
+
     #[test]
     fn test_instruction_error_from_error() {
         let error = MockError::new(StatusCode::RegionNotFound);
diff --git a/src/common/meta/src/kv_backend/chroot.rs b/src/common/meta/src/kv_backend/chroot.rs
index 1a7e7c615ac..4d2d16d0f2f 100644
--- a/src/common/meta/src/kv_backend/chroot.rs
+++ b/src/common/meta/src/kv_backend/chroot.rs
@@ -82,7 +82,7 @@ impl KvBackend for ChrootKvBackend {
 
     async fn batch_put(&self, mut req: BatchPutRequest) -> Result<BatchPutResponse, Self::Error> {
         for kv in req.kvs.iter_mut() {
-            kv.key = self.key_prepend_root(kv.key.drain(..).collect());
+            kv.key = self.key_prepend_root(std::mem::take(&mut kv.key));
         }
         let mut res = self.inner.batch_put(req).await?;
         res.prev_kvs = res
diff --git a/src/common/meta/src/node_manager.rs b/src/common/meta/src/node_manager.rs
index 6cc6c3e1539..d18e2cc8471 100644
--- a/src/common/meta/src/node_manager.rs
+++ b/src/common/meta/src/node_manager.rs
@@ -28,12 +28,22 @@ use crate::peer::Peer;
 #[async_trait::async_trait]
 pub trait Datanode: Send + Sync {
     /// Handles DML, and DDL requests.
-    async fn handle(&self, request: RegionRequest) -> Result<RegionResponse>;
+    async fn handle_request(&self, request: Arc<RegionRequest>) -> Result<RegionResponse>;
 
     /// Handles query requests
     async fn handle_query(&self, request: QueryRequest) -> Result<SendableRecordBatchStream>;
 }
 
+impl dyn Datanode + '_ {
+    /// Handles an owned or shared request without cloning its payload.
+    pub async fn handle<R>(&self, request: R) -> Result<RegionResponse>
+    where
+        R: Into<Arc<RegionRequest>> + Send,
+    {
+        self.handle_request(request.into()).await
+    }
+}
+
 pub type DatanodeRef = Arc<dyn Datanode>;
 
 /// The trait for handling requests to flownode
diff --git a/src/common/meta/src/peer.rs b/src/common/meta/src/peer.rs
index 924c293bbe0..18ffd92f8bb 100644
--- a/src/common/meta/src/peer.rs
+++ b/src/common/meta/src/peer.rs
@@ -22,6 +22,9 @@ use crate::cluster::NodeInfo;
 use crate::error::Error;
 use crate::{DatanodeId, FlownodeId};
 
+/// Shared reference to a [`Peer`].
+pub type PeerRef = Arc<Peer>;
+
 /// [`PeerResolver`] provides methods to look up peer information by node ID.
 ///
 /// This trait allows resolving both datanode and flownode peers, regardless of their current activity status.
diff --git a/src/common/meta/src/reconciliation/reconcile_catalog.rs b/src/common/meta/src/reconciliation/reconcile_catalog.rs
index e28e81d323d..f015a483b6e 100644
--- a/src/common/meta/src/reconciliation/reconcile_catalog.rs
+++ b/src/common/meta/src/reconciliation/reconcile_catalog.rs
@@ -16,6 +16,7 @@ use std::any::Any;
 use std::fmt::Debug;
 use std::time::Instant;
 
+use common_error::ext::ErrorExt;
 use common_procedure::error::FromJsonSnafu;
 use common_procedure::{
     Context as ProcedureContext, Error as ProcedureError, EventContext, EventTrigger, LockKey,
@@ -191,7 +192,7 @@ impl Procedure for ReconcileCatalogProcedure {
                 Ok(status)
             }
             Err(e) => {
-                if e.is_retry_later() {
+                if e.retry_hint().is_retryable() {
                     metrics::METRIC_META_RECONCILIATION_PROCEDURE_ERROR
                         .with_label_values(&[procedure_name, step, metrics::ERROR_TYPE_RETRYABLE])
                         .inc();
diff --git a/src/common/meta/src/reconciliation/reconcile_database.rs b/src/common/meta/src/reconciliation/reconcile_database.rs
index f5e2fe9f9a0..49443aca9db 100644
--- a/src/common/meta/src/reconciliation/reconcile_database.rs
+++ b/src/common/meta/src/reconciliation/reconcile_database.rs
@@ -23,6 +23,7 @@ use std::fmt::Debug;
 use std::time::Instant;
 
 use async_trait::async_trait;
+use common_error::ext::ErrorExt;
 use common_procedure::error::{FromJsonSnafu, ToJsonSnafu};
 use common_procedure::{
     Context as ProcedureContext, Error as ProcedureError, EventContext, EventTrigger, LockKey,
@@ -231,7 +232,7 @@ impl Procedure for ReconcileDatabaseProcedure {
                 Ok(status)
             }
             Err(e) => {
-                if e.is_retry_later() {
+                if e.retry_hint().is_retryable() {
                     metrics::METRIC_META_RECONCILIATION_PROCEDURE_ERROR
                         .with_label_values(&[procedure_name, step, metrics::ERROR_TYPE_RETRYABLE])
                         .inc();
diff --git a/src/common/meta/src/reconciliation/reconcile_logical_tables.rs b/src/common/meta/src/reconciliation/reconcile_logical_tables.rs
index 8c16e5a450f..5c5c654f6df 100644
--- a/src/common/meta/src/reconciliation/reconcile_logical_tables.rs
+++ b/src/common/meta/src/reconciliation/reconcile_logical_tables.rs
@@ -22,6 +22,7 @@ use std::any::Any;
 use std::fmt::Debug;
 
 use async_trait::async_trait;
+use common_error::ext::ErrorExt;
 use common_procedure::error::{FromJsonSnafu, ToJsonSnafu};
 use common_procedure::{
     Context as ProcedureContext, Error as ProcedureError, EventContext, EventTrigger, LockKey,
@@ -207,7 +208,7 @@ impl Procedure for ReconcileLogicalTablesProcedure {
                 Ok(status)
             }
             Err(e) => {
-                if e.is_retry_later() {
+                if e.retry_hint().is_retryable() {
                     metrics::METRIC_META_RECONCILIATION_PROCEDURE_ERROR
                         .with_label_values(&[procedure_name, step, metrics::ERROR_TYPE_RETRYABLE])
                         .inc();
diff --git a/src/common/meta/src/reconciliation/reconcile_table.rs b/src/common/meta/src/reconciliation/reconcile_table.rs
index d48999b895f..a14fe13a3db 100644
--- a/src/common/meta/src/reconciliation/reconcile_table.rs
+++ b/src/common/meta/src/reconciliation/reconcile_table.rs
@@ -20,6 +20,7 @@ pub(crate) mod update_table_info;
 
 use std::fmt::Debug;
 
+use common_error::ext::ErrorExt;
 use common_procedure::error::{FromJsonSnafu, ToJsonSnafu};
 use common_procedure::{
     Context as ProcedureContext, Error as ProcedureError, EventContext, EventTrigger, LockKey,
@@ -318,7 +319,7 @@ impl Procedure for ReconcileTableProcedure {
                 Ok(status)
             }
             Err(e) => {
-                if e.is_retry_later() {
+                if e.retry_hint().is_retryable() {
                     metrics::METRIC_META_RECONCILIATION_PROCEDURE_ERROR
                         .with_label_values(&[procedure_name, step, metrics::ERROR_TYPE_RETRYABLE])
                         .inc();
diff --git a/src/common/meta/src/rpc/router.rs b/src/common/meta/src/rpc/router.rs
index 929f57515ed..e089318b272 100644
--- a/src/common/meta/src/rpc/router.rs
+++ b/src/common/meta/src/rpc/router.rs
@@ -48,7 +48,7 @@ pub fn region_distribution(region_routes: &[RegionRoute]) -> RegionDistribution
                 .add_follower_region(region_number);
         }
     }
-    for (_, region_role_set) in regions_id_map.iter_mut() {
+    for region_role_set in regions_id_map.values_mut() {
         // Sort the regions in ascending order.
         region_role_set.sort()
     }
@@ -114,15 +114,25 @@ pub fn convert_to_region_leader_map(region_routes: &[RegionRoute]) -> HashMap<Re
         .collect::<HashMap<_, _>>()
 }
 
+/// Returns the leader of the first route matching the region number.
 pub fn find_region_leader(
     region_routes: &[RegionRoute],
     region_number: RegionNumber,
 ) -> Option<Peer> {
+    find_region_leader_ref(region_routes, region_number).cloned()
+}
+
+/// Borrows the leader of the first route matching the region number.
+///
+/// Returns `None` if no route matches or the first matching route has no leader.
+pub fn find_region_leader_ref(
+    region_routes: &[RegionRoute],
+    region_number: RegionNumber,
+) -> Option<&Peer> {
     region_routes
         .iter()
         .find(|x| x.region.id.region_number() == region_number)
         .and_then(|r| r.leader_peer.as_ref())
-        .cloned()
 }
 
 /// Returns the region numbers of the leader regions on the target datanode.
@@ -442,6 +452,27 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_find_region_leader() {
+        let mut routes = vec![
+            new_test_region_route(RegionId::new(1, 1)),
+            new_test_region_route(RegionId::new(1, 1)),
+        ];
+        routes[1].leader_peer = Some(Peer::new(2, "a2"));
+
+        assert_eq!(
+            find_region_leader_ref(&routes, 1),
+            routes[0].leader_peer.as_ref()
+        );
+        assert_eq!(find_region_leader(&routes, 1), routes[0].leader_peer);
+        assert_eq!(find_region_leader_ref(&routes, 2), None);
+        assert_eq!(find_region_leader(&routes, 2), None);
+
+        routes[0].leader_peer = None;
+        assert_eq!(find_region_leader_ref(&routes, 1), None);
+        assert_eq!(find_region_leader(&routes, 1), None);
+    }
+
     #[test]
     fn test_leader_is_downgraded() {
         let mut region_route = RegionRoute {
diff --git a/src/common/meta/src/rpc/store.rs b/src/common/meta/src/rpc/store.rs
index 25536993972..a9c36199761 100644
--- a/src/common/meta/src/rpc/store.rs
+++ b/src/common/meta/src/rpc/store.rs
@@ -199,7 +199,7 @@ impl RangeResponse {
     }
 
     pub fn take_kvs(&mut self) -> Vec<KeyValue> {
-        self.kvs.drain(..).collect()
+        std::mem::take(&mut self.kvs)
     }
 }
 
@@ -451,7 +451,7 @@ impl BatchPutResponse {
     }
 
     pub fn take_prev_kvs(&mut self) -> Vec<KeyValue> {
-        self.prev_kvs.drain(..).collect()
+        std::mem::take(&mut self.prev_kvs)
     }
 }
 
@@ -780,7 +780,7 @@ impl DeleteRangeResponse {
     }
 
     pub fn take_prev_kvs(&mut self) -> Vec<KeyValue> {
-        self.prev_kvs.drain(..).collect()
+        std::mem::take(&mut self.prev_kvs)
     }
 }
 
diff --git a/src/common/meta/src/sequence.rs b/src/common/meta/src/sequence.rs
index cd0a8ebf881..9d56170833c 100644
--- a/src/common/meta/src/sequence.rs
+++ b/src/common/meta/src/sequence.rs
@@ -188,7 +188,7 @@ impl Inner {
         }
 
         error::NextSequenceSnafu {
-            err_msg: format!("{}.next()", &self.name),
+            err_msg: format!("{}.next()", self.name),
         }
         .fail()
     }
@@ -264,7 +264,7 @@ impl Inner {
         }
 
         error::NextSequenceSnafu {
-            err_msg: format!("{}.next_range()", &self.name),
+            err_msg: format!("{}.next_range()", self.name),
         }
         .fail()
     }
diff --git a/src/common/meta/src/test_util.rs b/src/common/meta/src/test_util.rs
index 1009bc1c99a..618603c13e5 100644
--- a/src/common/meta/src/test_util.rs
+++ b/src/common/meta/src/test_util.rs
@@ -111,7 +111,8 @@ struct MockNode<T> {
 
 #[async_trait::async_trait]
 impl<T: MockDatanodeHandler> Datanode for MockNode<T> {
-    async fn handle(&self, request: RegionRequest) -> Result<RegionResponse> {
+    async fn handle_request(&self, request: Arc<RegionRequest>) -> Result<RegionResponse> {
+        let request = Arc::try_unwrap(request).expect("mock request must be exclusively owned");
         self.handler.handle(&self.peer, request).await
     }
 
@@ -322,8 +323,8 @@ macro_rules! maybe_skip_etcd_tls_integration_test {
 
 /// Returns the directory of the etcd TLS certs.
 pub fn etcd_certs_dir() -> PathBuf {
-    let project_path = env!("CARGO_MANIFEST_DIR");
-    let project_path = PathBuf::from(project_path);
+    let project_path =
+        PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set"));
     let base = project_path.ancestors().nth(3).unwrap();
     base.join("tests-integration")
         .join("fixtures")
@@ -332,8 +333,8 @@ pub fn etcd_certs_dir() -> PathBuf {
 
 /// Returns the directory of the test certs.
 pub fn test_certs_dir() -> PathBuf {
-    let project_path = env!("CARGO_MANIFEST_DIR");
-    let project_path = PathBuf::from(project_path);
+    let project_path =
+        PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set"));
     let base = project_path.ancestors().nth(3).unwrap();
     base.join("tests-integration")
         .join("fixtures")
diff --git a/src/common/procedure/src/error.rs b/src/common/procedure/src/error.rs
index 67fab54b156..b3f4a83d5f4 100644
--- a/src/common/procedure/src/error.rs
+++ b/src/common/procedure/src/error.rs
@@ -306,7 +306,8 @@ impl ErrorExt for Error {
             | Error::DeletePoison { source, .. }
             | Error::GetPoison { source, .. }
             | Error::CheckStatus { source, .. } => source.retry_hint(),
-            Error::ProcedureExec { source, .. } => source.retry_hint(),
+            // The watcher reports this only after the child has failed or been poisoned.
+            Error::ProcedureExec { .. } => RetryHint::NonRetryable,
             Error::StartRemoveOutdatedMetaTask { source, .. }
             | Error::StopRemoveOutdatedMetaTask { source, .. } => source.retry_hint(),
             Error::DeleteState { error, .. } => retry_hint_from_opendal_error(error),
@@ -379,8 +380,11 @@ mod tests {
     use std::sync::Arc;
 
     use common_error::mock::MockError;
+    use tokio::sync::watch;
 
     use super::*;
+    use crate::procedure::ProcedureState;
+    use crate::watcher;
 
     #[test]
     fn test_retry_later_hint_is_retryable() {
@@ -397,6 +401,21 @@ mod tests {
         assert_eq!(err.retry_hint(), RetryHint::Retryable);
     }
 
+    #[tokio::test]
+    async fn test_finished_procedure_hint_is_non_retryable() {
+        let source = Arc::new(Error::retry_later(MockError::new(StatusCode::Internal)));
+        for state in [
+            ProcedureState::failed(source.clone()),
+            ProcedureState::poisoned(Default::default(), source),
+        ] {
+            let (sender, mut receiver) = watch::channel(ProcedureState::Running);
+            sender.send(state).unwrap();
+            let err = watcher::wait(&mut receiver).await.unwrap_err();
+
+            assert_eq!(err.retry_hint(), RetryHint::NonRetryable);
+        }
+    }
+
     #[test]
     fn test_retry_exceeded_hint_is_non_retryable() {
         let source = Arc::new(Error::retry_later(MockError::new(StatusCode::Internal)));
diff --git a/src/common/query/src/stream.rs b/src/common/query/src/stream.rs
index 0a46164d9b4..d6f1735e06c 100644
--- a/src/common/query/src/stream.rs
+++ b/src/common/query/src/stream.rs
@@ -95,7 +95,7 @@ impl DisplayAs for StreamScanAdapter {
             f,
             "StreamScanAdapter: [<SendableRecordBatchStream>], schema: ["
         )?;
-        write!(f, "{:?}", &self.arrow_schema)?;
+        write!(f, "{:?}", self.arrow_schema)?;
         write!(f, "]")
     }
 }
diff --git a/src/common/recordbatch/src/filter.rs b/src/common/recordbatch/src/filter.rs
index 26c28aa3fa0..60ff399601f 100644
--- a/src/common/recordbatch/src/filter.rs
+++ b/src/common/recordbatch/src/filter.rs
@@ -12,215 +12,174 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! Util record batch stream wrapper that can perform precise filter.
+//! Precise single-column predicates and record batch filtering.
+
+mod predicate;
+#[cfg(test)]
+mod tests;
+mod timestamp;
 
 use std::sync::Arc;
 
-use common_time::timestamp::div_mod_units;
 use datafusion::error::Result as DfResult;
 use datafusion::logical_expr::{Expr, Literal, Operator};
 use datafusion::physical_plan::PhysicalExpr;
-use datafusion_common::arrow::array::{ArrayRef, Datum, Scalar};
+use datafusion_common::arrow::array::{ArrayRef, Datum};
 use datafusion_common::arrow::buffer::BooleanBuffer;
-use datafusion_common::arrow::compute::kernels::cmp;
-use datafusion_common::cast::{as_boolean_array, as_null_array, as_string_array};
+use datafusion_common::cast::{as_boolean_array, as_null_array};
 use datafusion_common::{DataFusionError, ScalarValue, internal_err};
-use datatypes::arrow::array::{
-    Array, ArrayAccessor, ArrayData, BooleanArray, BooleanBufferBuilder, DictionaryArray,
-    RecordBatch, StringArrayType,
-};
+use datatypes::arrow::array::{Array, BooleanArray, BooleanBufferBuilder, RecordBatch};
 use datatypes::arrow::compute::filter_record_batch;
-use datatypes::arrow::datatypes::{DataType, TimeUnit, UInt32Type};
-use datatypes::arrow::error::ArrowError;
-use datatypes::compute::or_kleene;
+use datatypes::arrow::datatypes::DataType;
 use datatypes::data_type::{ConcreteDataType, DataType as _};
 use datatypes::value::Value;
 use datatypes::vectors::VectorRef;
-use regex::Regex;
 use snafu::ResultExt;
 
-use crate::error::{ArrowComputeSnafu, Result, ToArrowScalarSnafu, UnsupportedOperationSnafu};
+pub use self::predicate::{regexp_is_match_dictionary, regexp_is_match_scalar};
+pub use self::timestamp::timestamp_scalar_value;
+use crate::error::{Result, ToArrowScalarSnafu};
+use crate::filter::predicate::SimplePredicate;
 
-/// An inplace expr evaluator for simple filter. Only support
-/// - `col` `op` `literal`
-/// - `literal` `op` `col`
-///
-/// And the `op` is one of `=`, `!=`, `>`, `>=`, `<`, `<=`,
-/// or regex operators: `~`, `~*`, `!~`, `!~*`.
-///
-/// This struct contains normalized predicate expr. In the form of
-/// `col` `op` `literal` where the `col` is provided from input.
+/// Evaluates supported single-column predicates with precompiled regular expressions.
+/// Compound predicates preserve SQL null semantics until conversion to a scan mask.
 #[derive(Debug, Clone)]
 pub struct SimpleFilterEvaluator {
-    /// Name of the referenced column.
     column_name: String,
-    /// The literal value.
-    literal: Scalar<ArrayRef>,
-    /// The operator.
-    op: Operator,
-    /// Only used when the operator is `Or`-chain.
-    literal_list: Vec<Scalar<ArrayRef>>,
-    /// Pre-compiled regex.
-    /// Only used when the operator is regex operators.
-    /// If the regex is empty, it is also `None`.
-    regex: Option<Regex>,
-    /// Whether the regex is negative.
-    regex_negative: bool,
+    predicate: SimplePredicate,
 }
 
 impl SimpleFilterEvaluator {
     pub fn new<T: Literal>(column_name: String, lit: T, op: Operator) -> Option<Self> {
-        match op {
+        if !matches!(
+            op,
             Operator::Eq
-            | Operator::NotEq
-            | Operator::Lt
-            | Operator::LtEq
-            | Operator::Gt
-            | Operator::GtEq => {}
-            _ => return None,
+                | Operator::NotEq
+                | Operator::Lt
+                | Operator::LtEq
+                | Operator::Gt
+                | Operator::GtEq
+        ) {
+            return None;
         }
-
-        let Expr::Literal(val, _) = lit.lit() else {
+        let Expr::Literal(value, _) = lit.lit() else {
             return None;
         };
-
         Some(Self {
             column_name,
-            literal: val.to_scalar().ok()?,
-            op,
-            literal_list: vec![],
-            regex: None,
-            regex_negative: false,
+            predicate: SimplePredicate::Comparison {
+                literal: value.to_scalar().ok()?,
+                op,
+                regex: None,
+                regex_negative: false,
+            },
         })
     }
 
     pub fn try_new(predicate: &Expr) -> Option<Self> {
-        match predicate {
-            Expr::BinaryExpr(binary) => {
-                // check if the expr is in the supported form
-                match binary.op {
-                    Operator::Eq
-                    | Operator::NotEq
-                    | Operator::Lt
-                    | Operator::LtEq
-                    | Operator::Gt
-                    | Operator::GtEq
-                    | Operator::RegexMatch
-                    | Operator::RegexIMatch
-                    | Operator::RegexNotMatch
-                    | Operator::RegexNotIMatch => {}
-                    Operator::Or => {
-                        let lhs = Self::try_new(&binary.left)?;
-                        let rhs = Self::try_new(&binary.right)?;
-                        if lhs.column_name != rhs.column_name
-                            || !matches!(lhs.op, Operator::Eq | Operator::Or)
-                            || !matches!(rhs.op, Operator::Eq | Operator::Or)
-                        {
-                            return None;
-                        }
-                        let mut list = vec![];
-                        let placeholder_literal = lhs.literal.clone();
-                        // above check guarantees the op is either `Eq` or `Or`
-                        if matches!(lhs.op, Operator::Or) {
-                            list.extend(lhs.literal_list);
-                        } else {
-                            list.push(lhs.literal);
-                        }
-                        if matches!(rhs.op, Operator::Or) {
-                            list.extend(rhs.literal_list);
-                        } else {
-                            list.push(rhs.literal);
-                        }
-                        return Some(Self {
-                            column_name: lhs.column_name,
-                            literal: placeholder_literal,
-                            op: Operator::Or,
-                            literal_list: list,
-                            regex: None,
-                            regex_negative: false,
-                        });
-                    }
-                    _ => return None,
-                }
-
-                // swap the expr if it is in the form of `literal` `op` `col`
-                let mut op = binary.op;
-                let (lhs, rhs) = match (&*binary.left, &*binary.right) {
-                    (Expr::Column(col), Expr::Literal(lit, _)) => (col, lit),
-                    (Expr::Literal(lit, _), Expr::Column(col)) => {
-                        // safety: The previous check ensures the operator is able to swap.
-                        op = op.swap().unwrap();
-                        (col, lit)
-                    }
-                    _ => return None,
-                };
-
-                let (regex, regex_negative) = Self::maybe_build_regex(op, rhs).ok()?;
-                let literal = rhs.to_scalar().ok()?;
-                Some(Self {
-                    column_name: lhs.name.clone(),
-                    literal,
-                    op,
-                    literal_list: vec![],
-                    regex,
-                    regex_negative,
-                })
-            }
-            _ => None,
-        }
+        Self::try_new_with_column_type(predicate, &|_| None)
     }
 
-    /// Get the name of the referenced column.
+    /// Recognizes single-column filters, including lossless string dictionary casts
+    /// when the caller can resolve the column's type.
+    pub fn try_new_with_column_type(
+        predicate: &Expr,
+        column_type: &impl Fn(&str) -> Option<DataType>,
+    ) -> Option<Self> {
+        let columns = predicate.column_refs();
+        if columns.len() != 1 {
+            return None;
+        }
+        let column_name = columns.into_iter().next()?.name.clone();
+        let column_type = column_type(&column_name);
+        Some(Self {
+            column_name,
+            predicate: SimplePredicate::try_new(predicate, column_type.as_ref())?,
+        })
+    }
+
+    /// Returns the referenced column name.
     pub fn column_name(&self) -> &str {
         &self.column_name
     }
 
     pub fn is_eq(&self) -> bool {
-        matches!(self.op, Operator::Eq)
+        matches!(
+            self.predicate,
+            SimplePredicate::Comparison {
+                op: Operator::Eq,
+                ..
+            }
+        )
     }
-
     pub fn is_not_eq(&self) -> bool {
-        matches!(self.op, Operator::NotEq)
+        matches!(
+            self.predicate,
+            SimplePredicate::Comparison {
+                op: Operator::NotEq,
+                ..
+            }
+        )
     }
-
     pub fn is_lt(&self) -> bool {
-        matches!(self.op, Operator::Lt)
+        matches!(
+            self.predicate,
+            SimplePredicate::Comparison {
+                op: Operator::Lt,
+                ..
+            }
+        )
     }
-
     pub fn is_lt_eq(&self) -> bool {
-        matches!(self.op, Operator::LtEq)
+        matches!(
+            self.predicate,
+            SimplePredicate::Comparison {
+                op: Operator::LtEq,
+                ..
+            }
+        )
     }
-
     pub fn is_gt(&self) -> bool {
-        matches!(self.op, Operator::Gt)
+        matches!(
+            self.predicate,
+            SimplePredicate::Comparison {
+                op: Operator::Gt,
+                ..
+            }
+        )
     }
-
     pub fn is_gt_eq(&self) -> bool {
-        matches!(self.op, Operator::GtEq)
+        matches!(
+            self.predicate,
+            SimplePredicate::Comparison {
+                op: Operator::GtEq,
+                ..
+            }
+        )
     }
 
-    /// Returns true if this filter represents an `OR` chain of equality comparisons, e.g.
-    /// `col = lit1 OR col = lit2 ...`.
+    /// Returns true for an OR chain of equality comparisons.
     pub fn is_or_eq_chain(&self) -> bool {
-        matches!(self.op, Operator::Or)
+        matches!(self.predicate, SimplePredicate::OrEqChain { .. })
     }
 
-    /// Returns the literal as a [`Value`]. It returns `None` if the literal can't be converted.
+    /// Returns the literal of a bare comparison, without discarding compound conditions.
     pub fn literal_value(&self) -> Option<Value> {
-        let array = self.literal.get().0;
-        let scalar = ScalarValue::try_from_array(array, 0).ok()?;
-        Value::try_from(scalar).ok()
+        let SimplePredicate::Comparison { literal, .. } = &self.predicate else {
+            return None;
+        };
+        Value::try_from(ScalarValue::try_from_array(literal.get().0, 0).ok()?).ok()
     }
 
-    /// Returns the literal list as a list of [`Value`]s. It returns `None` if any literal can't be
-    /// converted.
+    /// Returns equality-OR literals, or None for other predicates or unsupported values.
     pub fn literal_list_values(&self) -> Option<Vec<Value>> {
-        self.literal_list
+        let SimplePredicate::OrEqChain { literals } = &self.predicate else {
+            return None;
+        };
+        literals
             .iter()
-            .map(|scalar| {
-                let array = scalar.get().0;
-                let scalar = ScalarValue::try_from_array(array, 0).ok()?;
-                Value::try_from(scalar).ok()
+            .map(|literal| {
+                Value::try_from(ScalarValue::try_from_array(literal.get().0, 0).ok()?).ok()
             })
             .collect()
     }
@@ -229,8 +188,7 @@ impl SimpleFilterEvaluator {
         let input = input
             .to_scalar()
             .with_context(|_| ToArrowScalarSnafu { v: input.clone() })?;
-        let result = self.evaluate_datum(&input, 1)?;
-        Ok(result.value(0))
+        Ok(self.evaluate_datum(&input, 1)?.value(0))
     }
 
     pub fn evaluate_array(&self, input: &ArrayRef) -> Result<BooleanBuffer> {
@@ -238,200 +196,27 @@ impl SimpleFilterEvaluator {
     }
 
     pub fn evaluate_vector(&self, input: &VectorRef) -> Result<BooleanBuffer> {
-        self.evaluate_datum(&input.to_arrow_array(), input.len())
+        self.evaluate_array(&input.to_arrow_array())
     }
 
-    fn evaluate_datum(&self, input: &impl Datum, input_len: usize) -> Result<BooleanBuffer> {
-        let result = match self.op {
-            Operator::Eq => cmp::eq(input, &self.literal),
-            Operator::NotEq => cmp::neq(input, &self.literal),
-            Operator::Lt => cmp::lt(input, &self.literal),
-            Operator::LtEq => cmp::lt_eq(input, &self.literal),
-            Operator::Gt => cmp::gt(input, &self.literal),
-            Operator::GtEq => cmp::gt_eq(input, &self.literal),
-            Operator::RegexMatch => self.regex_match(input),
-            Operator::RegexIMatch => self.regex_match(input),
-            Operator::RegexNotMatch => self.regex_match(input),
-            Operator::RegexNotIMatch => self.regex_match(input),
-            Operator::Or => {
-                // OR operator stands for OR-chained EQs (or INLIST in other words)
-                let mut result: BooleanArray = vec![false; input_len].into();
-                for literal in &self.literal_list {
-                    let rhs = cmp::eq(input, literal).context(ArrowComputeSnafu)?;
-                    result = or_kleene(&result, &rhs).context(ArrowComputeSnafu)?;
-                }
-                Ok(result)
-            }
-            _ => {
-                return UnsupportedOperationSnafu {
-                    reason: format!("{:?}", self.op),
-                }
-                .fail();
-            }
-        };
-        result
-            .context(ArrowComputeSnafu)
-            .map(|array| boolean_array_to_scan_mask(&array).values().clone())
+    fn evaluate_datum(&self, input: &impl Datum, len: usize) -> Result<BooleanBuffer> {
+        let result = self.predicate.evaluate(input, len)?;
+        Ok(boolean_array_to_scan_mask(&result).values().clone())
     }
 
-    /// Builds a regex pattern from a scalar value and operator.
-    /// Returns the `(regex, negative)` and if successful.
-    ///
-    /// Returns `Err` if
-    /// - the value is not a string
-    /// - the regex pattern is invalid
-    ///
-    /// The regex is `None` if
-    /// - the operator is not a regex operator
-    /// - the pattern is empty
-    fn maybe_build_regex(
-        operator: Operator,
-        value: &ScalarValue,
-    ) -> Result<(Option<Regex>, bool), ArrowError> {
-        let (ignore_case, negative) = match operator {
-            Operator::RegexMatch => (false, false),
-            Operator::RegexIMatch => (true, false),
-            Operator::RegexNotMatch => (false, true),
-            Operator::RegexNotIMatch => (true, true),
-            _ => return Ok((None, false)),
-        };
-        let flag = if ignore_case { Some("i") } else { None };
-        let regex = value
-            .try_as_str()
-            .ok_or_else(|| ArrowError::CastError(format!("Cannot cast {:?} to str", value)))?
-            .ok_or_else(|| ArrowError::CastError("Regex should not be null".to_string()))?;
-        let pattern = match flag {
-            Some(flag) => format!("(?{flag}){regex}"),
-            None => regex.to_string(),
-        };
-        if pattern.is_empty() {
-            Ok((None, negative))
-        } else {
-            Regex::new(pattern.as_str())
-                .map_err(|e| {
-                    ArrowError::ComputeError(format!("Regular expression did not compile: {e:?}"))
-                })
-                .map(|regex| (Some(regex), negative))
-        }
-    }
-
-    fn regex_match(&self, input: &impl Datum) -> std::result::Result<BooleanArray, ArrowError> {
-        let array = input.get().0;
-
-        // Try to cast to StringArray first
-        if let Ok(string_array) = as_string_array(array) {
-            let mut result = regexp_is_match_scalar(string_array, self.regex.as_ref())?;
-            if self.regex_negative {
-                result = datatypes::compute::not(&result)?;
-            }
-            return Ok(result);
-        }
-
-        // Try to cast to StringDictionaryArray
-        if let Some(dict_array) = array.as_any().downcast_ref::<DictionaryArray<UInt32Type>>() {
-            let mut result = regexp_is_match_dictionary(dict_array, self.regex.as_ref())?;
-            if self.regex_negative {
-                result = datatypes::compute::not(&result)?;
-            }
-            return Ok(result);
-        }
-
-        Err(ArrowError::CastError(format!(
-            "Cannot cast {:?} to StringArray or StringDictionaryArray",
-            array.data_type()
-        )))
-    }
-
-    /// Casts the filter's timestamp literal into the unit of the `target`
-    /// timestamp type, so it can be evaluated against a column stored in that
-    /// unit (e.g. an old-unit SST after the time index unit was widened).
-    ///
-    /// When the literal is not representable in `target`'s unit (e.g.
-    /// `ts = 7_000_500us` against a millisecond column), the outcome keeps the
-    /// row set instead of rounding the literal: `=` prunes / `!=` matches, and
-    /// inequalities strengthen the operator (e.g. `>= 2_500_500us` becomes
-    /// `> 2500ms`) so the excluded boundary row stays excluded.
-    ///
-    /// Returns `None` when the filter doesn't compare against a tz-naive
-    /// timestamp literal, or `target` is not a timestamp type.
+    /// Adapts timestamp predicates to an older SST's timestamp unit without rounding
+    /// away boundary rows. Nonrepresentable equality literals cannot match a row.
     pub fn cast_timestamp_unit(&self, target: &ConcreteDataType) -> Option<TimestampUnitCast> {
-        let target_unit = match target.as_arrow_type() {
-            DataType::Timestamp(unit, _) => unit,
-            _ => return None,
+        let DataType::Timestamp(target_unit, _) = target.as_arrow_type() else {
+            return None;
         };
-
-        // An `OR` chain of equalities (an IN list): convert each literal
-        // with `=` semantics; literals not representable in the target unit
-        // cannot match any row and simply drop out of the chain.
-        if self.op == Operator::Or {
-            let mut literal_list = Vec::with_capacity(self.literal_list.len());
-            for literal in &self.literal_list {
-                let scalar = ScalarValue::try_from_array(literal.get().0, 0).ok()?;
-                let Some((value, unit)) = timestamp_scalar_parts(&scalar) else {
-                    continue;
-                };
-                let Some(value) = value else {
-                    continue;
-                };
-                let cast = div_mod_units(value, unit.into(), target_unit.into())?;
-                if cast.remainder == 0 {
-                    literal_list.push(timestamp_scalar(cast.quotient, target_unit)?);
-                }
-            }
-            if literal_list.is_empty() {
-                return Some(TimestampUnitCast::Pruned);
-            }
-            let literal = literal_list[0].clone();
-            return Some(TimestampUnitCast::Filter(Self {
+        Some(match self.predicate.cast_timestamp_unit(target_unit)? {
+            SimplePredicate::Constant(Some(true)) => TimestampUnitCast::Matched,
+            SimplePredicate::Constant(_) => TimestampUnitCast::Pruned,
+            predicate => TimestampUnitCast::Filter(Self {
                 column_name: self.column_name.clone(),
-                literal,
-                op: Operator::Or,
-                literal_list,
-                regex: None,
-                regex_negative: false,
-            }));
-        }
-
-        let scalar = ScalarValue::try_from_array(self.literal.get().0, 0).ok()?;
-        let (value, unit) = timestamp_scalar_parts(&scalar)?;
-        let Some(value) = value else {
-            // A NULL literal never compares true (arrow comparison
-            // semantics: null results are filtered out).
-            return Some(TimestampUnitCast::Pruned);
-        };
-        if unit == target_unit {
-            return Some(TimestampUnitCast::Filter(self.clone()));
-        }
-        let cast = div_mod_units(value, unit.into(), target_unit.into())?;
-        let divisible = cast.remainder == 0;
-        let literal = timestamp_scalar(cast.quotient, target_unit)?;
-        let filter = |op: Operator| Self {
-            column_name: self.column_name.clone(),
-            literal: literal.clone(),
-            op,
-            literal_list: vec![],
-            regex: None,
-            regex_negative: false,
-        };
-
-        Some(match self.op {
-            Operator::Eq if divisible => TimestampUnitCast::Filter(filter(Operator::Eq)),
-            Operator::Eq => TimestampUnitCast::Pruned,
-            Operator::NotEq if divisible => TimestampUnitCast::Filter(filter(Operator::NotEq)),
-            Operator::NotEq => TimestampUnitCast::Matched,
-            // v > L holds exactly for v > quotient, whether or not L is
-            // representable in the target unit.
-            Operator::Gt => TimestampUnitCast::Filter(filter(Operator::Gt)),
-            Operator::GtEq if divisible => TimestampUnitCast::Filter(filter(Operator::GtEq)),
-            // L strictly between two target values: v >= L is v > quotient.
-            Operator::GtEq => TimestampUnitCast::Filter(filter(Operator::Gt)),
-            Operator::Lt if divisible => TimestampUnitCast::Filter(filter(Operator::Lt)),
-            // L strictly between two target values: v < L is v <= quotient.
-            Operator::Lt => TimestampUnitCast::Filter(filter(Operator::LtEq)),
-            // v <= L holds exactly for v <= quotient.
-            Operator::LtEq => TimestampUnitCast::Filter(filter(Operator::LtEq)),
-            // Regex predicates don't apply to timestamps.
-            _ => return None,
+                predicate,
+            }),
         })
     }
 }
@@ -449,35 +234,6 @@ pub enum TimestampUnitCast {
     Matched,
 }
 
-/// Extracts the value and unit from a tz-naive timestamp scalar.
-fn timestamp_scalar_parts(scalar: &ScalarValue) -> Option<(Option<i64>, TimeUnit)> {
-    let (value, unit, timezone) = match scalar {
-        ScalarValue::TimestampSecond(v, tz) => (*v, TimeUnit::Second, tz),
-        ScalarValue::TimestampMillisecond(v, tz) => (*v, TimeUnit::Millisecond, tz),
-        ScalarValue::TimestampMicrosecond(v, tz) => (*v, TimeUnit::Microsecond, tz),
-        ScalarValue::TimestampNanosecond(v, tz) => (*v, TimeUnit::Nanosecond, tz),
-        _ => return None,
-    };
-    // A timezone-aware literal doesn't compare against a tz-naive column;
-    // leave it to the caller instead of guessing the intended semantics.
-    (timezone.is_none()).then_some((value, unit))
-}
-
-/// Builds a tz-naive timestamp literal for `value` in `unit`.
-pub fn timestamp_scalar_value(value: i64, unit: TimeUnit) -> ScalarValue {
-    match unit {
-        TimeUnit::Second => ScalarValue::TimestampSecond(Some(value), None),
-        TimeUnit::Millisecond => ScalarValue::TimestampMillisecond(Some(value), None),
-        TimeUnit::Microsecond => ScalarValue::TimestampMicrosecond(Some(value), None),
-        TimeUnit::Nanosecond => ScalarValue::TimestampNanosecond(Some(value), None),
-    }
-}
-
-/// Builds a one-element scalar array holding `value` in `unit`.
-fn timestamp_scalar(value: i64, unit: TimeUnit) -> Option<Scalar<ArrayRef>> {
-    timestamp_scalar_value(value, unit).to_scalar().ok()
-}
-
 /// Evaluate the predicate on the input [RecordBatch], and return a new [RecordBatch].
 /// Copy from datafusion::physical_plan::src::filter.rs
 pub fn batch_filter(
@@ -520,726 +276,3 @@ fn boolean_array_to_scan_mask(array: &BooleanArray) -> BooleanArray {
     }
     BooleanArray::new(values.into(), None)
 }
-
-/// The same as arrow [regexp_is_match_scalar()](datatypes::compute::kernels::regexp::regexp_is_match_scalar())
-/// with pre-compiled regex.
-/// See <https://github.com/apache/arrow-rs/blob/54.2.0/arrow-string/src/regexp.rs#L204-L246> for the implementation details.
-pub fn regexp_is_match_scalar<'a, S>(
-    array: &'a S,
-    regex: Option<&Regex>,
-) -> Result<BooleanArray, ArrowError>
-where
-    &'a S: StringArrayType<'a>,
-{
-    let null_bit_buffer = array.nulls().map(|x| x.inner().sliced());
-    let mut result = BooleanBufferBuilder::new(array.len());
-
-    if let Some(re) = regex {
-        for i in 0..array.len() {
-            let value = array.value(i);
-            result.append(re.is_match(value));
-        }
-    } else {
-        result.append_n(array.len(), true);
-    }
-
-    let buffer = result.into();
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            array.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![buffer],
-            vec![],
-        )
-    };
-
-    Ok(BooleanArray::from(data))
-}
-
-/// Similar to [regexp_is_match_scalar] but for StringDictionaryArray.
-/// Iterates through dictionary keys to get string values and applies regex matching.
-pub fn regexp_is_match_dictionary(
-    dict_array: &DictionaryArray<UInt32Type>,
-    regex: Option<&Regex>,
-) -> Result<BooleanArray, ArrowError> {
-    // Get the string values from the dictionary
-    let string_values = dict_array
-        .values()
-        .as_any()
-        .downcast_ref::<datatypes::arrow::array::StringArray>()
-        .ok_or_else(|| {
-            ArrowError::CastError("Dictionary values must be StringArray".to_string())
-        })?;
-
-    // Dictionary logical nulls include both null keys and keys whose dictionary value is null.
-    let logical_nulls = dict_array.logical_nulls();
-    let null_bit_buffer = logical_nulls.as_ref().map(|x| x.inner().sliced());
-    let mut result = BooleanBufferBuilder::new(dict_array.len());
-
-    if let Some(re) = regex {
-        let keys = dict_array.keys().values();
-        for i in 0..dict_array.len() {
-            if logical_nulls.as_ref().is_some_and(|nulls| nulls.is_null(i)) {
-                result.append(false);
-            } else {
-                let key = keys[i] as usize;
-                let string_value = string_values.value(key);
-                result.append(re.is_match(string_value));
-            }
-        }
-    } else {
-        result.append_n(dict_array.len(), true);
-    }
-
-    let buffer = result.into();
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            dict_array.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![buffer],
-            vec![],
-        )
-    };
-
-    Ok(BooleanArray::from(data))
-}
-
-#[cfg(test)]
-mod test {
-
-    use std::sync::Arc;
-
-    use datafusion::execution::context::ExecutionProps;
-    use datafusion::logical_expr::physical_planning_context::PhysicalPlanningContext;
-    use datafusion::logical_expr::{BinaryExpr, col, lit};
-    use datafusion::physical_expr::create_physical_expr;
-    use datafusion_common::{Column, DFSchema};
-    use datatypes::arrow::array::{TimestampMillisecondArray, TimestampNanosecondArray};
-    use datatypes::arrow::datatypes::{DataType, Field, Schema};
-
-    use super::*;
-
-    #[test]
-    fn unsupported_filter_op() {
-        // `+` is not supported
-        let expr = Expr::BinaryExpr(BinaryExpr {
-            left: Box::new(Expr::Column(Column::from_name("foo"))),
-            op: Operator::Plus,
-            right: Box::new(1.lit()),
-        });
-        assert!(SimpleFilterEvaluator::try_new(&expr).is_none());
-
-        // two literal is not supported
-        let expr = Expr::BinaryExpr(BinaryExpr {
-            left: Box::new(1.lit()),
-            op: Operator::Eq,
-            right: Box::new(1.lit()),
-        });
-        assert!(SimpleFilterEvaluator::try_new(&expr).is_none());
-
-        // two column is not supported
-        let expr = Expr::BinaryExpr(BinaryExpr {
-            left: Box::new(Expr::Column(Column::from_name("foo"))),
-            op: Operator::Eq,
-            right: Box::new(Expr::Column(Column::from_name("bar"))),
-        });
-        assert!(SimpleFilterEvaluator::try_new(&expr).is_none());
-
-        // compound expr is not supported
-        let expr = Expr::BinaryExpr(BinaryExpr {
-            left: Box::new(Expr::BinaryExpr(BinaryExpr {
-                left: Box::new(Expr::Column(Column::from_name("foo"))),
-                op: Operator::Eq,
-                right: Box::new(1.lit()),
-            })),
-            op: Operator::Eq,
-            right: Box::new(1.lit()),
-        });
-        assert!(SimpleFilterEvaluator::try_new(&expr).is_none());
-    }
-
-    #[test]
-    fn supported_filter_op() {
-        // equal
-        let expr = Expr::BinaryExpr(BinaryExpr {
-            left: Box::new(Expr::Column(Column::from_name("foo"))),
-            op: Operator::Eq,
-            right: Box::new(1.lit()),
-        });
-        let _ = SimpleFilterEvaluator::try_new(&expr).unwrap();
-
-        // swap operands
-        let expr = Expr::BinaryExpr(BinaryExpr {
-            left: Box::new(1.lit()),
-            op: Operator::Lt,
-            right: Box::new(Expr::Column(Column::from_name("foo"))),
-        });
-        let evaluator = SimpleFilterEvaluator::try_new(&expr).unwrap();
-        assert_eq!(evaluator.op, Operator::Gt);
-        assert_eq!(evaluator.column_name, "foo".to_string());
-    }
-
-    #[test]
-    fn run_on_array() {
-        let expr = Expr::BinaryExpr(BinaryExpr {
-            left: Box::new(Expr::Column(Column::from_name("foo"))),
-            op: Operator::Eq,
-            right: Box::new(1i64.lit()),
-        });
-        let evaluator = SimpleFilterEvaluator::try_new(&expr).unwrap();
-
-        let input_1 = Arc::new(datatypes::arrow::array::Int64Array::from(vec![1, 2, 3])) as _;
-        let result = evaluator.evaluate_array(&input_1).unwrap();
-        assert_eq!(result, BooleanBuffer::from(vec![true, false, false]));
-
-        let input_2 = Arc::new(datatypes::arrow::array::Int64Array::from(vec![1, 1, 1])) as _;
-        let result = evaluator.evaluate_array(&input_2).unwrap();
-        assert_eq!(result, BooleanBuffer::from(vec![true, true, true]));
-
-        let input_3 = Arc::new(datatypes::arrow::array::Int64Array::new_null(0)) as _;
-        let result = evaluator.evaluate_array(&input_3).unwrap();
-        assert_eq!(result, BooleanBuffer::from(vec![]));
-    }
-
-    #[test]
-    fn run_on_scalar() {
-        let expr = Expr::BinaryExpr(BinaryExpr {
-            left: Box::new(Expr::Column(Column::from_name("foo"))),
-            op: Operator::Lt,
-            right: Box::new(1i64.lit()),
-        });
-        let evaluator = SimpleFilterEvaluator::try_new(&expr).unwrap();
-
-        let input_1 = ScalarValue::Int64(Some(1));
-        let result = evaluator.evaluate_scalar(&input_1).unwrap();
-        assert!(!result);
-
-        let input_2 = ScalarValue::Int64(Some(0));
-        let result = evaluator.evaluate_scalar(&input_2).unwrap();
-        assert!(result);
-
-        let input_3 = ScalarValue::Int64(None);
-        let result = evaluator.evaluate_scalar(&input_3).unwrap();
-        assert!(!result);
-    }
-
-    #[test]
-    fn batch_filter_test() {
-        let expr = col("ts").gt(lit(123456u64));
-        let schema = Schema::new(vec![
-            Field::new("a", DataType::Int32, true),
-            Field::new("ts", DataType::UInt64, false),
-        ]);
-        let df_schema = DFSchema::try_from(schema.clone()).unwrap();
-        let props = ExecutionProps::new();
-        let physical_expr = create_physical_expr(
-            &expr,
-            &df_schema,
-            &props,
-            &PhysicalPlanningContext::default(),
-        )
-        .unwrap();
-        let batch = RecordBatch::try_new(
-            Arc::new(schema),
-            vec![
-                Arc::new(datatypes::arrow::array::Int32Array::from(vec![4, 5, 6])),
-                Arc::new(datatypes::arrow::array::UInt64Array::from(vec![
-                    123456, 123457, 123458,
-                ])),
-            ],
-        )
-        .unwrap();
-        let new_batch = batch_filter(&batch, &physical_expr).unwrap();
-        assert_eq!(new_batch.num_rows(), 2);
-        let first_column_values = new_batch
-            .column(0)
-            .as_any()
-            .downcast_ref::<datatypes::arrow::array::Int32Array>()
-            .unwrap();
-        let expected = datatypes::arrow::array::Int32Array::from(vec![5, 6]);
-        assert_eq!(first_column_values, &expected);
-    }
-
-    #[test]
-    fn test_complex_filter_expression() {
-        // Create an expression tree for: col = 'B' OR col = 'C' OR col = 'D'
-        let col_eq_b = col("col").eq(lit("B"));
-        let col_eq_c = col("col").eq(lit("C"));
-        let col_eq_d = col("col").eq(lit("D"));
-
-        // Build the OR chain
-        let col_or_expr = col_eq_b.or(col_eq_c).or(col_eq_d);
-
-        // Check that SimpleFilterEvaluator can handle OR chain
-        let or_evaluator = SimpleFilterEvaluator::try_new(&col_or_expr).unwrap();
-        assert_eq!(or_evaluator.column_name, "col");
-        assert_eq!(or_evaluator.op, Operator::Or);
-        assert_eq!(or_evaluator.literal_list.len(), 3);
-        assert_eq!(
-            format!("{:?}", or_evaluator.literal_list),
-            "[Scalar(StringArray\n[\n  \"B\",\n]), Scalar(StringArray\n[\n  \"C\",\n]), Scalar(StringArray\n[\n  \"D\",\n])]"
-        );
-
-        // Create a schema and batch for testing
-        let schema = Schema::new(vec![Field::new("col", DataType::Utf8, false)]);
-        let df_schema = DFSchema::try_from(schema.clone()).unwrap();
-        let props = ExecutionProps::new();
-        let physical_expr = create_physical_expr(
-            &col_or_expr,
-            &df_schema,
-            &props,
-            &PhysicalPlanningContext::default(),
-        )
-        .unwrap();
-
-        // Create test data
-        let col_data = Arc::new(datatypes::arrow::array::StringArray::from(vec![
-            "B", "C", "E", "B", "C", "D", "F",
-        ]));
-        let batch = RecordBatch::try_new(Arc::new(schema), vec![col_data]).unwrap();
-        let expected = datatypes::arrow::array::StringArray::from(vec!["B", "C", "B", "C", "D"]);
-
-        // Filter the batch
-        let filtered_batch = batch_filter(&batch, &physical_expr).unwrap();
-
-        // Expected: rows with col in ("B", "C", "D")
-        // That would be rows 0, 1, 3, 4, 5
-        assert_eq!(filtered_batch.num_rows(), 5);
-
-        let col_filtered = filtered_batch
-            .column(0)
-            .as_any()
-            .downcast_ref::<datatypes::arrow::array::StringArray>()
-            .unwrap();
-        assert_eq!(col_filtered, &expected);
-    }
-
-    #[test]
-    fn test_maybe_build_regex() {
-        // Test case for RegexMatch (case sensitive, non-negative)
-        let (regex, negative) = SimpleFilterEvaluator::maybe_build_regex(
-            Operator::RegexMatch,
-            &ScalarValue::Utf8(Some("a.*b".to_string())),
-        )
-        .unwrap();
-        assert!(regex.is_some());
-        assert!(!negative);
-        assert!(regex.unwrap().is_match("axxb"));
-
-        // Test case for RegexIMatch (case insensitive, non-negative)
-        let (regex, negative) = SimpleFilterEvaluator::maybe_build_regex(
-            Operator::RegexIMatch,
-            &ScalarValue::Utf8(Some("a.*b".to_string())),
-        )
-        .unwrap();
-        assert!(regex.is_some());
-        assert!(!negative);
-        assert!(regex.unwrap().is_match("AxxB"));
-
-        // Test case for RegexNotMatch (case sensitive, negative)
-        let (regex, negative) = SimpleFilterEvaluator::maybe_build_regex(
-            Operator::RegexNotMatch,
-            &ScalarValue::Utf8(Some("a.*b".to_string())),
-        )
-        .unwrap();
-        assert!(regex.is_some());
-        assert!(negative);
-
-        // Test case for RegexNotIMatch (case insensitive, negative)
-        let (regex, negative) = SimpleFilterEvaluator::maybe_build_regex(
-            Operator::RegexNotIMatch,
-            &ScalarValue::Utf8(Some("a.*b".to_string())),
-        )
-        .unwrap();
-        assert!(regex.is_some());
-        assert!(negative);
-
-        // Test with empty regex pattern
-        let (regex, negative) = SimpleFilterEvaluator::maybe_build_regex(
-            Operator::RegexMatch,
-            &ScalarValue::Utf8(Some("".to_string())),
-        )
-        .unwrap();
-        assert!(regex.is_none());
-        assert!(!negative);
-
-        // Test with non-regex operator
-        let (regex, negative) = SimpleFilterEvaluator::maybe_build_regex(
-            Operator::Eq,
-            &ScalarValue::Utf8(Some("a.*b".to_string())),
-        )
-        .unwrap();
-        assert!(regex.is_none());
-        assert!(!negative);
-
-        // Test with invalid regex pattern
-        let result = SimpleFilterEvaluator::maybe_build_regex(
-            Operator::RegexMatch,
-            &ScalarValue::Utf8(Some("a(b".to_string())),
-        );
-        assert!(result.is_err());
-
-        // Test with non-string value
-        let result = SimpleFilterEvaluator::maybe_build_regex(
-            Operator::RegexMatch,
-            &ScalarValue::Int64(Some(123)),
-        );
-        assert!(result.is_err());
-
-        // Test with null value
-        let result = SimpleFilterEvaluator::maybe_build_regex(
-            Operator::RegexMatch,
-            &ScalarValue::Utf8(None),
-        );
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_regex_match_dictionary_array() {
-        use datatypes::arrow::array::StringDictionaryBuilder;
-
-        // Create a StringDictionaryArray
-        let mut builder = StringDictionaryBuilder::<UInt32Type>::new();
-        builder.append("apple").unwrap();
-        builder.append("banana").unwrap();
-        builder.append("apple").unwrap();
-        builder.append("cherry").unwrap();
-        let dict_array = builder.finish();
-
-        // Test regex that matches "apple"
-        let regex = regex::Regex::new(r"app.*").unwrap();
-        let result = regexp_is_match_dictionary(&dict_array, Some(&regex)).unwrap();
-
-        // Should match indices 0 and 2 (both "apple")
-        assert_eq!(result.len(), 4);
-        assert!(result.value(0)); // "apple"
-        assert!(!result.value(1)); // "banana"
-        assert!(result.value(2)); // "apple"
-        assert!(!result.value(3)); // "cherry"
-
-        // Test regex that matches "banana"
-        let regex2 = regex::Regex::new(r"ban.*").unwrap();
-        let result2 = regexp_is_match_dictionary(&dict_array, Some(&regex2)).unwrap();
-
-        assert!(!result2.value(0)); // "apple"
-        assert!(result2.value(1)); // "banana"
-        assert!(!result2.value(2)); // "apple"
-        assert!(!result2.value(3)); // "cherry"
-
-        // Test with no regex (should match all)
-        let result3 = regexp_is_match_dictionary(&dict_array, None).unwrap();
-        assert!(result3.value(0));
-        assert!(result3.value(1));
-        assert!(result3.value(2));
-        assert!(result3.value(3));
-    }
-
-    #[test]
-    fn test_regex_scan_masks_preserve_sql_null_semantics() {
-        let plain = Arc::new(datatypes::arrow::array::StringArray::from(vec![
-            Some("api"),
-            Some("API"),
-            Some("db"),
-            None,
-        ])) as ArrayRef;
-        assert_regex_scan_masks(
-            &plain,
-            [
-                vec![true, false, false, false],
-                vec![true, true, false, false],
-                vec![false, true, true, false],
-                vec![false, false, true, false],
-            ],
-        );
-
-        let dictionary = DictionaryArray::new(
-            datatypes::arrow::array::UInt32Array::from(vec![
-                Some(0),
-                Some(1),
-                Some(2),
-                None,
-                Some(3),
-            ]),
-            Arc::new(datatypes::arrow::array::StringArray::from(vec![
-                Some("api"),
-                Some("API"),
-                Some("db"),
-                None,
-            ])),
-        );
-        let raw =
-            regexp_is_match_dictionary(&dictionary, Some(&Regex::new("^api$").unwrap())).unwrap();
-        assert!(raw.is_null(3)); // null dictionary key
-        assert!(raw.is_null(4)); // non-null key referencing a null dictionary value
-
-        let dictionary = Arc::new(dictionary) as ArrayRef;
-        assert_regex_scan_masks(
-            &dictionary,
-            [
-                vec![true, false, false, false, false],
-                vec![true, true, false, false, false],
-                vec![false, true, true, false, false],
-                vec![false, false, true, false, false],
-            ],
-        );
-
-        let negative = regex_evaluator(Operator::RegexNotMatch);
-        assert!(!negative.evaluate_scalar(&ScalarValue::Utf8(None)).unwrap());
-    }
-
-    #[test]
-    fn test_nullable_boolean_predicate_becomes_scan_mask() {
-        let predicate = BooleanArray::from(vec![Some(true), None, Some(false)]);
-        assert_eq!(
-            BooleanArray::from(vec![true, false, false]),
-            boolean_array_to_scan_mask(&predicate)
-        );
-    }
-
-    fn assert_regex_scan_masks(input: &ArrayRef, expected: [Vec<bool>; 4]) {
-        for (op, expected) in [
-            Operator::RegexMatch,
-            Operator::RegexIMatch,
-            Operator::RegexNotMatch,
-            Operator::RegexNotIMatch,
-        ]
-        .into_iter()
-        .zip(expected)
-        {
-            assert_eq!(
-                BooleanBuffer::from(expected),
-                regex_evaluator(op).evaluate_array(input).unwrap(),
-                "{op:?}"
-            );
-        }
-    }
-
-    fn regex_evaluator(op: Operator) -> SimpleFilterEvaluator {
-        let expr = Expr::BinaryExpr(BinaryExpr {
-            left: Box::new(Expr::Column(Column::from_name("host"))),
-            op,
-            right: Box::new("^api$".lit()),
-        });
-        SimpleFilterEvaluator::try_new(&expr).unwrap()
-    }
-
-    fn ts_us(v: i64) -> ScalarValue {
-        ScalarValue::TimestampMicrosecond(Some(v), None)
-    }
-
-    fn cast_to_ms(expr: &Expr) -> Option<TimestampUnitCast> {
-        SimpleFilterEvaluator::try_new(expr)
-            .unwrap()
-            .cast_timestamp_unit(&ConcreteDataType::timestamp_millisecond_datatype())
-    }
-
-    /// Evaluates a cast `Filter` outcome against millisecond values and
-    /// returns the mask.
-    fn eval_ms_mask(cast: Option<TimestampUnitCast>, values: &[i64]) -> Vec<bool> {
-        let filter = match cast.expect("cast must apply") {
-            TimestampUnitCast::Filter(filter) => filter,
-            other => panic!("expected Filter outcome, got {other:?}"),
-        };
-        let array = Arc::new(TimestampMillisecondArray::from(values.to_vec())) as ArrayRef;
-        filter.evaluate_array(&array).unwrap().iter().collect()
-    }
-
-    #[test]
-    fn cast_timestamp_unit_converts_representable_literal() {
-        // ts = 7_000_000us evaluated against a ms column becomes ts = 7000ms.
-        assert_eq!(
-            vec![false, true, false],
-            eval_ms_mask(
-                cast_to_ms(&col("ts").eq(lit(ts_us(7_000_000)))),
-                &[6_999, 7_000, 7_001]
-            )
-        );
-        // != complements =.
-        assert_eq!(
-            vec![true, false, true],
-            eval_ms_mask(
-                cast_to_ms(&col("ts").not_eq(lit(ts_us(7_000_000)))),
-                &[6_999, 7_000, 7_001]
-            )
-        );
-    }
-
-    #[test]
-    fn cast_timestamp_unit_prunes_non_representable_equality() {
-        // 7_000_500us is not a whole millisecond: no ms row can equal it,
-        // and every ms row satisfies `!=`.
-        assert!(matches!(
-            cast_to_ms(&col("ts").eq(lit(ts_us(7_000_500)))),
-            Some(TimestampUnitCast::Pruned)
-        ));
-        assert!(matches!(
-            cast_to_ms(&col("ts").not_eq(lit(ts_us(7_000_500)))),
-            Some(TimestampUnitCast::Matched)
-        ));
-    }
-
-    #[test]
-    fn cast_timestamp_unit_strengthens_inequalities() {
-        // 2_500_500us is strictly between 2500ms and 2501ms: the cast must
-        // not round the literal to a boundary the original predicate
-        // excludes (>= 2500ms would wrongly match 2500ms).
-        let values = vec![2_499, 2_500, 2_501];
-        assert_eq!(
-            vec![false, false, true],
-            eval_ms_mask(cast_to_ms(&col("ts").gt(lit(ts_us(2_500_500)))), &values)
-        );
-        assert_eq!(
-            vec![false, false, true],
-            eval_ms_mask(cast_to_ms(&col("ts").gt_eq(lit(ts_us(2_500_500)))), &values)
-        );
-        assert_eq!(
-            vec![true, true, false],
-            eval_ms_mask(cast_to_ms(&col("ts").lt(lit(ts_us(2_500_500)))), &values)
-        );
-        assert_eq!(
-            vec![true, true, false],
-            eval_ms_mask(cast_to_ms(&col("ts").lt_eq(lit(ts_us(2_500_500)))), &values)
-        );
-
-        // Representable boundary keeps the original operator.
-        let values = vec![2_499, 2_500, 2_501];
-        assert_eq!(
-            vec![false, false, true],
-            eval_ms_mask(cast_to_ms(&col("ts").gt(lit(ts_us(2_500_000)))), &values)
-        );
-        assert_eq!(
-            vec![false, true, true],
-            eval_ms_mask(cast_to_ms(&col("ts").gt_eq(lit(ts_us(2_500_000)))), &values)
-        );
-        assert_eq!(
-            vec![true, false, false],
-            eval_ms_mask(cast_to_ms(&col("ts").lt(lit(ts_us(2_500_000)))), &values)
-        );
-        assert_eq!(
-            vec![true, true, false],
-            eval_ms_mask(cast_to_ms(&col("ts").lt_eq(lit(ts_us(2_500_000)))), &values)
-        );
-    }
-
-    #[test]
-    fn cast_timestamp_unit_handles_negative_instants() {
-        // -2_500_500us floors to -2501ms with remainder 500us: only rows
-        // with instant >= -2.5005ms may match >= / >.
-        let values = vec![-2_502, -2_501, -2_500];
-        assert_eq!(
-            vec![false, false, true],
-            eval_ms_mask(
-                cast_to_ms(&col("ts").gt_eq(lit(ts_us(-2_500_500)))),
-                &values
-            )
-        );
-        assert_eq!(
-            vec![false, false, true],
-            eval_ms_mask(cast_to_ms(&col("ts").gt(lit(ts_us(-2_500_500)))), &values)
-        );
-        assert_eq!(
-            vec![true, true, false],
-            eval_ms_mask(
-                cast_to_ms(&col("ts").lt_eq(lit(ts_us(-2_500_500)))),
-                &values
-            )
-        );
-        // Exactly representable negative literal: -2_500_000us == -2500ms.
-        assert_eq!(
-            vec![false, false, true],
-            eval_ms_mask(cast_to_ms(&col("ts").eq(lit(ts_us(-2_500_000)))), &values)
-        );
-    }
-
-    #[test]
-    fn cast_timestamp_unit_or_chain_drops_unrepresentable_literals() {
-        // Only 7_000_000us is a whole millisecond; 7_000_500us cannot match.
-        let expr = col("ts")
-            .eq(lit(ts_us(7_000_500)))
-            .or(col("ts").eq(lit(ts_us(7_000_000))));
-        assert_eq!(
-            vec![false, true],
-            eval_ms_mask(cast_to_ms(&expr), &[6_999, 7_000])
-        );
-
-        // A chain where no literal is representable matches nothing.
-        let expr = col("ts")
-            .eq(lit(ts_us(7_000_500)))
-            .or(col("ts").eq(lit(ts_us(6_000_500))));
-        assert!(matches!(cast_to_ms(&expr), Some(TimestampUnitCast::Pruned)));
-    }
-
-    #[test]
-    fn cast_timestamp_unit_null_literal_prunes() {
-        // A NULL literal never compares true.
-        assert!(matches!(
-            cast_to_ms(&col("ts").eq(lit(ScalarValue::TimestampMicrosecond(None, None)))),
-            Some(TimestampUnitCast::Pruned)
-        ));
-    }
-
-    #[test]
-    fn cast_timestamp_unit_same_unit_returns_filter_directly() {
-        // A literal already in the target unit is returned unchanged.
-        let expr = col("ts").eq(lit(ts_us(7_000_000)));
-        let filter = SimpleFilterEvaluator::try_new(&expr).unwrap();
-        let cast = filter
-            .cast_timestamp_unit(&ConcreteDataType::timestamp_microsecond_datatype())
-            .unwrap();
-        let TimestampUnitCast::Filter(f) = cast else {
-            panic!("expected Filter, got {cast:?}")
-        };
-        assert_eq!(filter.op, f.op);
-        assert_eq!(filter.column_name(), f.column_name());
-        assert_eq!(
-            ts_us(7_000_000),
-            ScalarValue::try_from_array(f.literal.get().0, 0).unwrap()
-        );
-    }
-
-    #[test]
-    fn cast_timestamp_unit_rejects_non_timestamps() {
-        // Non-timestamp target type.
-        assert!(
-            SimpleFilterEvaluator::try_new(&col("ts").gt(lit(ts_us(1))))
-                .unwrap()
-                .cast_timestamp_unit(&ConcreteDataType::int64_datatype())
-                .is_none()
-        );
-        // Non-timestamp literal against a timestamp target.
-        assert!(cast_to_ms(&col("ts").gt(lit(42_i64))).is_none());
-    }
-
-    #[test]
-    fn cast_timestamp_unit_to_finer_unit() {
-        // 5 seconds against a nanosecond column becomes 5_000_000_000ns.
-        let filter = SimpleFilterEvaluator::try_new(
-            &col("ts").eq(lit(ScalarValue::TimestampSecond(Some(5), None))),
-        )
-        .unwrap()
-        .cast_timestamp_unit(&ConcreteDataType::timestamp_nanosecond_datatype())
-        .and_then(|cast| match cast {
-            TimestampUnitCast::Filter(filter) => Some(filter),
-            _ => None,
-        })
-        .unwrap();
-        let array = Arc::new(TimestampNanosecondArray::from(vec![
-            4_999_999_999,
-            5_000_000_000,
-        ])) as ArrayRef;
-        assert_eq!(
-            vec![false, true],
-            filter
-                .evaluate_array(&array)
-                .unwrap()
-                .iter()
-                .collect::<Vec<_>>()
-        );
-    }
-}
diff --git a/src/common/recordbatch/src/filter/predicate.rs b/src/common/recordbatch/src/filter/predicate.rs
new file mode 100644
index 00000000000..e283633dc02
--- /dev/null
+++ b/src/common/recordbatch/src/filter/predicate.rs
@@ -0,0 +1,944 @@
+// 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.
+
+//! Predicate recognition, execution, and precompiled regular expressions.
+
+use datafusion::logical_expr::{Expr, Operator};
+use datafusion_common::ScalarValue;
+use datafusion_common::arrow::array::{ArrayRef, Datum, Scalar};
+use datafusion_common::arrow::buffer::BooleanBuffer;
+use datafusion_common::arrow::compute::kernels::cmp;
+use datafusion_common::cast::as_string_array;
+use datatypes::arrow::array::{
+    Array, ArrayAccessor, ArrayData, BooleanArray, BooleanBufferBuilder, DictionaryArray,
+    StringArrayType,
+};
+use datatypes::arrow::datatypes::{DataType, UInt32Type};
+use datatypes::arrow::error::ArrowError;
+use datatypes::compute::or_kleene;
+use regex::Regex;
+use snafu::ResultExt;
+
+use crate::error::{ArrowComputeSnafu, Result, UnsupportedOperationSnafu};
+
+#[derive(Debug, Clone)]
+pub(crate) enum SimplePredicate {
+    Comparison {
+        literal: Scalar<ArrayRef>,
+        op: Operator,
+        regex: Option<Regex>,
+        regex_negative: bool,
+    },
+    OrEqChain {
+        literals: Vec<Scalar<ArrayRef>>,
+    },
+    IsNull {
+        negated: bool,
+    },
+    Constant(Option<bool>),
+    And(Box<Self>, Box<Self>),
+    Or(Box<Self>, Box<Self>),
+}
+
+impl SimplePredicate {
+    pub(crate) fn try_new(expr: &Expr, column_type: Option<&DataType>) -> Option<Self> {
+        match expr {
+            Expr::BinaryExpr(binary) if matches!(binary.op, Operator::And | Operator::Or) => {
+                let left = Self::try_new(&binary.left, column_type)?;
+                let right = Self::try_new(&binary.right, column_type)?;
+                if binary.op == Operator::And {
+                    return Some(Self::And(Box::new(left), Box::new(right)));
+                }
+                // Preserve the encoded-key IN-list fast path for pure equality disjunctions.
+                if let (Some(mut lhs), Some(rhs)) =
+                    (left.equality_literals(), right.equality_literals())
+                {
+                    lhs.extend(rhs);
+                    return Some(Self::OrEqChain { literals: lhs });
+                }
+                Some(Self::Or(Box::new(left), Box::new(right)))
+            }
+            Expr::BinaryExpr(binary) => {
+                let mut op = binary.op;
+                if !matches!(
+                    op,
+                    Operator::Eq
+                        | Operator::NotEq
+                        | Operator::Lt
+                        | Operator::LtEq
+                        | Operator::Gt
+                        | Operator::GtEq
+                        | Operator::RegexMatch
+                        | Operator::RegexIMatch
+                        | Operator::RegexNotMatch
+                        | Operator::RegexNotIMatch
+                ) {
+                    return None;
+                }
+                let literal = if let Expr::Literal(literal, _) = &*binary.right {
+                    Self::check_column(&binary.left, column_type)?;
+                    literal
+                } else if let Expr::Literal(literal, _) = &*binary.left {
+                    Self::check_column(&binary.right, column_type)?;
+                    op = op.swap()?;
+                    literal
+                } else {
+                    return None;
+                };
+                let (regex, regex_negative) = Self::maybe_build_regex(op, literal).ok()?;
+                Some(Self::Comparison {
+                    literal: literal.to_scalar().ok()?,
+                    op,
+                    regex,
+                    regex_negative,
+                })
+            }
+            Expr::IsNull(column) | Expr::IsNotNull(column) => {
+                Self::check_column(column, column_type)?;
+                Some(Self::IsNull {
+                    negated: matches!(expr, Expr::IsNotNull(_)),
+                })
+            }
+            Expr::Literal(ScalarValue::Boolean(value), _) => Some(Self::Constant(*value)),
+            _ => None,
+        }
+    }
+
+    fn check_column(expr: &Expr, column_type: Option<&DataType>) -> Option<()> {
+        match expr {
+            Expr::Column(_) => Some(()),
+            Expr::Cast(cast) if cast.field.data_type() == &DataType::Utf8 => {
+                let Expr::Column(_) = &*cast.expr else {
+                    return None;
+                };
+                match column_type? {
+                    DataType::Utf8 => Some(()),
+                    DataType::Dictionary(key, value)
+                        if **key == DataType::UInt32 && **value == DataType::Utf8 =>
+                    {
+                        Some(())
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+
+    fn equality_literals(&self) -> Option<Vec<Scalar<ArrayRef>>> {
+        match self {
+            Self::Comparison {
+                literal,
+                op: Operator::Eq,
+                ..
+            } => Some(vec![literal.clone()]),
+            Self::OrEqChain { literals } => Some(literals.clone()),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn evaluate(&self, input: &impl Datum, len: usize) -> Result<BooleanArray> {
+        match self {
+            Self::Comparison {
+                literal,
+                op,
+                regex,
+                regex_negative,
+            } => match op {
+                Operator::Eq => cmp::eq(input, literal),
+                Operator::NotEq => cmp::neq(input, literal),
+                Operator::Lt => cmp::lt(input, literal),
+                Operator::LtEq => cmp::lt_eq(input, literal),
+                Operator::Gt => cmp::gt(input, literal),
+                Operator::GtEq => cmp::gt_eq(input, literal),
+                Operator::RegexMatch
+                | Operator::RegexIMatch
+                | Operator::RegexNotMatch
+                | Operator::RegexNotIMatch => {
+                    Self::regex_match(input, regex.as_ref(), *regex_negative)
+                }
+                _ => {
+                    return UnsupportedOperationSnafu {
+                        reason: format!("{op:?}"),
+                    }
+                    .fail();
+                }
+            }
+            .context(ArrowComputeSnafu),
+            Self::OrEqChain { literals } => {
+                let mut result = BooleanArray::from(vec![false; len]);
+                for literal in literals {
+                    let rhs = cmp::eq(input, literal).context(ArrowComputeSnafu)?;
+                    result = or_kleene(&result, &rhs).context(ArrowComputeSnafu)?;
+                }
+                Ok(result)
+            }
+            Self::IsNull { negated } => {
+                let values = match input.get().0.logical_nulls() {
+                    Some(nulls) if *negated => nulls.inner().clone(),
+                    Some(nulls) => !nulls.inner(),
+                    None if *negated => BooleanBuffer::new_set(len),
+                    None => BooleanBuffer::new_unset(len),
+                };
+                Ok(BooleanArray::new(values, None))
+            }
+            Self::Constant(value) => Ok(BooleanArray::from(vec![*value; len])),
+            Self::And(left, right) => datatypes::compute::and_kleene(
+                &left.evaluate(input, len)?,
+                &right.evaluate(input, len)?,
+            )
+            .context(ArrowComputeSnafu),
+            Self::Or(left, right) => {
+                or_kleene(&left.evaluate(input, len)?, &right.evaluate(input, len)?)
+                    .context(ArrowComputeSnafu)
+            }
+        }
+    }
+
+    /// Builds a regex pattern from a scalar value and operator.
+    /// Returns the `(regex, negative)` and if successful.
+    ///
+    /// Returns `Err` if
+    /// - the value is not a string
+    /// - the regex pattern is invalid
+    ///
+    /// The regex is `None` if
+    /// - the operator is not a regex operator
+    /// - the pattern is empty
+    fn maybe_build_regex(
+        operator: Operator,
+        value: &ScalarValue,
+    ) -> Result<(Option<Regex>, bool), ArrowError> {
+        let (ignore_case, negative) = match operator {
+            Operator::RegexMatch => (false, false),
+            Operator::RegexIMatch => (true, false),
+            Operator::RegexNotMatch => (false, true),
+            Operator::RegexNotIMatch => (true, true),
+            _ => return Ok((None, false)),
+        };
+        let flag = if ignore_case { Some("i") } else { None };
+        let regex = value
+            .try_as_str()
+            .ok_or_else(|| ArrowError::CastError(format!("Cannot cast {:?} to str", value)))?
+            .ok_or_else(|| ArrowError::CastError("Regex should not be null".to_string()))?;
+        let pattern = match flag {
+            Some(flag) => format!("(?{flag}){regex}"),
+            None => regex.to_string(),
+        };
+        if pattern.is_empty() {
+            Ok((None, negative))
+        } else {
+            Regex::new(pattern.as_str())
+                .map_err(|e| {
+                    ArrowError::ComputeError(format!("Regular expression did not compile: {e:?}"))
+                })
+                .map(|regex| (Some(regex), negative))
+        }
+    }
+
+    fn regex_match(
+        input: &impl Datum,
+        regex: Option<&Regex>,
+        negative: bool,
+    ) -> std::result::Result<BooleanArray, ArrowError> {
+        let array = input.get().0;
+
+        // Try to cast to StringArray first
+        if let Ok(string_array) = as_string_array(array) {
+            let mut result = regexp_is_match_scalar(string_array, regex)?;
+            if negative {
+                result = datatypes::compute::not(&result)?;
+            }
+            return Ok(result);
+        }
+
+        // Try to cast to StringDictionaryArray
+        if let Some(dict_array) = array.as_any().downcast_ref::<DictionaryArray<UInt32Type>>() {
+            let mut result = regexp_is_match_dictionary(dict_array, regex)?;
+            if negative {
+                result = datatypes::compute::not(&result)?;
+            }
+            return Ok(result);
+        }
+
+        Err(ArrowError::CastError(format!(
+            "Cannot cast {:?} to StringArray or StringDictionaryArray",
+            array.data_type()
+        )))
+    }
+}
+
+/// The same as arrow [regexp_is_match_scalar()](datatypes::compute::kernels::regexp::regexp_is_match_scalar())
+/// with pre-compiled regex.
+/// See <https://github.com/apache/arrow-rs/blob/54.2.0/arrow-string/src/regexp.rs#L204-L246> for the implementation details.
+pub fn regexp_is_match_scalar<'a, S>(
+    array: &'a S,
+    regex: Option<&Regex>,
+) -> Result<BooleanArray, ArrowError>
+where
+    &'a S: StringArrayType<'a>,
+{
+    let null_bit_buffer = array.nulls().map(|x| x.inner().sliced());
+    let mut result = BooleanBufferBuilder::new(array.len());
+
+    if let Some(re) = regex {
+        for i in 0..array.len() {
+            let value = array.value(i);
+            result.append(re.is_match(value));
+        }
+    } else {
+        result.append_n(array.len(), true);
+    }
+
+    let buffer = result.into();
+    let data = unsafe {
+        ArrayData::new_unchecked(
+            DataType::Boolean,
+            array.len(),
+            None,
+            null_bit_buffer,
+            0,
+            vec![buffer],
+            vec![],
+        )
+    };
+
+    Ok(BooleanArray::from(data))
+}
+
+/// Similar to [regexp_is_match_scalar] but for StringDictionaryArray.
+/// Iterates through dictionary keys to get string values and applies regex matching.
+pub fn regexp_is_match_dictionary(
+    dict_array: &DictionaryArray<UInt32Type>,
+    regex: Option<&Regex>,
+) -> Result<BooleanArray, ArrowError> {
+    // Get the string values from the dictionary
+    let string_values = dict_array
+        .values()
+        .as_any()
+        .downcast_ref::<datatypes::arrow::array::StringArray>()
+        .ok_or_else(|| {
+            ArrowError::CastError("Dictionary values must be StringArray".to_string())
+        })?;
+
+    // Dictionary logical nulls include both null keys and keys whose dictionary value is null.
+    let logical_nulls = dict_array.logical_nulls();
+    let null_bit_buffer = logical_nulls.as_ref().map(|x| x.inner().sliced());
+    let mut result = BooleanBufferBuilder::new(dict_array.len());
+
+    if let Some(re) = regex {
+        let keys = dict_array.keys().values();
+        for i in 0..dict_array.len() {
+            if logical_nulls.as_ref().is_some_and(|nulls| nulls.is_null(i)) {
+                result.append(false);
+            } else {
+                let key = keys[i] as usize;
+                let string_value = string_values.value(key);
+                result.append(re.is_match(string_value));
+            }
+        }
+    } else {
+        result.append_n(dict_array.len(), true);
+    }
+
+    let buffer = result.into();
+    let data = unsafe {
+        ArrayData::new_unchecked(
+            DataType::Boolean,
+            dict_array.len(),
+            None,
+            null_bit_buffer,
+            0,
+            vec![buffer],
+            vec![],
+        )
+    };
+
+    Ok(BooleanArray::from(data))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use datafusion::execution::context::ExecutionProps;
+    use datafusion::logical_expr::physical_planning_context::PhysicalPlanningContext;
+    use datafusion::logical_expr::{BinaryExpr, Expr, Literal, Operator, col, lit};
+    use datafusion::physical_expr::create_physical_expr;
+    use datafusion_common::arrow::array::ArrayRef;
+    use datafusion_common::arrow::buffer::BooleanBuffer;
+    use datafusion_common::{Column, DFSchema, ScalarValue};
+    use datatypes::arrow::array::{Array, DictionaryArray, RecordBatch};
+    use datatypes::arrow::datatypes::{DataType, Field, Schema, TimeUnit, UInt32Type};
+    use datatypes::value::Value;
+    use regex::Regex;
+
+    use crate::filter::predicate::{SimplePredicate, regexp_is_match_dictionary};
+    use crate::filter::{SimpleFilterEvaluator, batch_filter};
+
+    #[test]
+    fn unsupported_filter_op() {
+        // `+` is not supported
+        let expr = Expr::BinaryExpr(BinaryExpr {
+            left: Box::new(Expr::Column(Column::from_name("foo"))),
+            op: Operator::Plus,
+            right: Box::new(1.lit()),
+        });
+        assert!(SimpleFilterEvaluator::try_new(&expr).is_none());
+
+        // two literal is not supported
+        let expr = Expr::BinaryExpr(BinaryExpr {
+            left: Box::new(1.lit()),
+            op: Operator::Eq,
+            right: Box::new(1.lit()),
+        });
+        assert!(SimpleFilterEvaluator::try_new(&expr).is_none());
+
+        // two column is not supported
+        let expr = Expr::BinaryExpr(BinaryExpr {
+            left: Box::new(Expr::Column(Column::from_name("foo"))),
+            op: Operator::Eq,
+            right: Box::new(Expr::Column(Column::from_name("bar"))),
+        });
+        assert!(SimpleFilterEvaluator::try_new(&expr).is_none());
+
+        // compound expr is not supported
+        let expr = Expr::BinaryExpr(BinaryExpr {
+            left: Box::new(Expr::BinaryExpr(BinaryExpr {
+                left: Box::new(Expr::Column(Column::from_name("foo"))),
+                op: Operator::Eq,
+                right: Box::new(1.lit()),
+            })),
+            op: Operator::Eq,
+            right: Box::new(1.lit()),
+        });
+        assert!(SimpleFilterEvaluator::try_new(&expr).is_none());
+        for negated in [false, true] {
+            let membership = col("label").in_list(vec![lit(""), lit("lo")], negated);
+            assert!(SimpleFilterEvaluator::try_new(&membership).is_none());
+            assert!(
+                SimpleFilterEvaluator::try_new(&col("label").is_null().or(membership)).is_none()
+            );
+        }
+        for expr in [
+            col("other").is_null().or(col("label").not_eq(lit("lo"))),
+            col("a.label")
+                .is_null()
+                .or(col("b.label").not_eq(lit("lo"))),
+            col("label").is_null().or(col("label").eq(col("other"))),
+            col("label")
+                .is_null()
+                .or(Expr::Cast(datafusion::logical_expr::Cast::new(
+                    Box::new(col("label")),
+                    DataType::Int64,
+                ))
+                .eq(lit("lo"))),
+        ] {
+            assert!(SimpleFilterEvaluator::try_new(&expr).is_none(), "{expr}");
+        }
+    }
+
+    #[test]
+    fn string_cast_requires_matching_column_type() {
+        let cast = Expr::Cast(datafusion::logical_expr::Cast::new(
+            Box::new(col("label")),
+            DataType::Utf8,
+        ));
+        let expr = col("label").is_null().or(cast.not_eq(lit("lo")));
+        for data_type in [
+            DataType::Int64,
+            DataType::Timestamp(TimeUnit::Millisecond, None),
+            DataType::Binary,
+        ] {
+            assert!(
+                SimpleFilterEvaluator::try_new_with_column_type(&expr, &|_| Some(
+                    data_type.clone()
+                ))
+                .is_none()
+            );
+        }
+        assert!(SimpleFilterEvaluator::try_new(&expr).is_none());
+    }
+
+    #[tokio::test]
+    async fn single_column_predicates_match_datafusion() {
+        use datafusion::prelude::SessionContext;
+        use datafusion_common::tree_node::{TreeNode, TreeNodeRecursion};
+        use datatypes::arrow::array::{Int32Array, StringArray, UInt32Array};
+
+        let values = vec![
+            None,
+            Some(""),
+            Some("lo"),
+            Some("eth0"),
+            Some("a\nb"),
+            Some("服务"),
+            None,
+        ];
+        let strings: ArrayRef = Arc::new(StringArray::from(values));
+        let dictionary: ArrayRef = Arc::new(DictionaryArray::<UInt32Type>::new(
+            UInt32Array::from(vec![
+                None,
+                Some(0),
+                Some(1),
+                Some(2),
+                Some(3),
+                Some(4),
+                Some(5),
+            ]),
+            Arc::new(StringArray::from(vec![
+                Some(""),
+                Some("lo"),
+                Some("eth0"),
+                Some("a\nb"),
+                Some("服务"),
+                None,
+            ])),
+        ));
+        let null = || lit(ScalarValue::Utf8(None));
+        let mut predicates = vec![
+            col("label").is_null(),
+            col("label").is_not_null(),
+            col("label")
+                .is_null()
+                .or(col("label").eq(lit("")))
+                .and(col("label").is_not_null()),
+            col("label")
+                .not_eq(lit("lo"))
+                .and(col("label").not_eq(lit("eth0"))),
+            col("label")
+                .eq(lit("lo"))
+                .or(col("label").eq(lit("eth0")))
+                .or(col("label").eq(lit(""))),
+            col("label").eq(null()).or(col("label").eq(lit("eth0"))),
+            col("label").gt(lit("a")).and(col("label").lt(lit("z"))),
+            lit("lo").not_eq(col("label")),
+        ];
+        for (op, literal) in [
+            (Operator::Eq, ""),
+            (Operator::NotEq, "lo"),
+            (Operator::RegexNotMatch, "^(?:lo|vfat)$"),
+            (Operator::RegexMatch, "^(?:|eth0)$"),
+        ] {
+            let comparison = Expr::BinaryExpr(BinaryExpr::new(
+                Box::new(col("label")),
+                op,
+                Box::new(lit(literal)),
+            ));
+            predicates.extend([
+                col("label").is_null().or(comparison.clone()),
+                comparison.or(col("label").is_null()),
+            ]);
+        }
+        for input in [strings, dictionary] {
+            let ctx = SessionContext::new();
+            let schema = Arc::new(Schema::new(vec![
+                Field::new("label", input.data_type().clone(), true),
+                Field::new("id", DataType::Int32, false),
+            ]));
+            ctx.register_batch(
+                "labels",
+                RecordBatch::try_new(
+                    schema,
+                    vec![
+                        input.clone(),
+                        Arc::new(Int32Array::from_iter_values(0..input.len() as i32)),
+                    ],
+                )
+                .unwrap(),
+            )
+            .unwrap();
+            for expr in &predicates {
+                let df = ctx
+                    .table("labels")
+                    .await
+                    .unwrap()
+                    .filter(expr.clone())
+                    .unwrap();
+                let plan = df.clone().into_optimized_plan().unwrap();
+                let expected = df
+                    .collect()
+                    .await
+                    .unwrap()
+                    .iter()
+                    .flat_map(|batch| {
+                        batch
+                            .column_by_name("id")
+                            .unwrap()
+                            .as_any()
+                            .downcast_ref::<Int32Array>()
+                            .unwrap()
+                            .values()
+                            .to_vec()
+                    })
+                    .collect::<Vec<_>>();
+                let evaluate = |expr: &Expr| {
+                    let evaluator =
+                        SimpleFilterEvaluator::try_new_with_column_type(expr, &|name| {
+                            (name == "label").then(|| input.data_type().clone())
+                        })
+                        .unwrap_or_else(|| panic!("unsupported: {expr}"));
+                    let mask = evaluator.evaluate_array(&input).unwrap();
+                    for (i, matched) in mask.iter().enumerate() {
+                        let scalar = ScalarValue::try_from_array(&input, i).unwrap();
+                        assert_eq!(
+                            evaluator.evaluate_scalar(&scalar).unwrap(),
+                            matched,
+                            "{expr}, row={i}"
+                        );
+                    }
+                    mask
+                };
+                let selected = |mask: BooleanBuffer| {
+                    mask.iter()
+                        .enumerate()
+                        .filter_map(|(i, matched)| matched.then_some(i as i32))
+                        .collect::<Vec<_>>()
+                };
+                assert_eq!(selected(evaluate(expr)), expected, "{expr}");
+                let mut filters = Vec::new();
+                plan.apply(|plan| {
+                    if let datafusion::logical_expr::LogicalPlan::Filter(filter) = plan {
+                        filters.push(filter.predicate.clone());
+                    }
+                    Ok(TreeNodeRecursion::Continue)
+                })
+                .unwrap();
+                if !filters.is_empty() {
+                    let mut mask = BooleanBuffer::new_set(input.len());
+                    for filter in filters {
+                        mask = &mask & &evaluate(&filter);
+                    }
+                    assert_eq!(selected(mask), expected, "optimized: {plan}");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn supported_filter_op() {
+        // equal
+        let expr = Expr::BinaryExpr(BinaryExpr {
+            left: Box::new(Expr::Column(Column::from_name("foo"))),
+            op: Operator::Eq,
+            right: Box::new(1.lit()),
+        });
+        let _ = SimpleFilterEvaluator::try_new(&expr).unwrap();
+
+        // swap operands
+        let expr = Expr::BinaryExpr(BinaryExpr {
+            left: Box::new(1.lit()),
+            op: Operator::Lt,
+            right: Box::new(Expr::Column(Column::from_name("foo"))),
+        });
+        let evaluator = SimpleFilterEvaluator::try_new(&expr).unwrap();
+        assert!(evaluator.is_gt());
+        assert_eq!(evaluator.column_name, "foo".to_string());
+    }
+
+    #[test]
+    fn run_on_array() {
+        let expr = Expr::BinaryExpr(BinaryExpr {
+            left: Box::new(Expr::Column(Column::from_name("foo"))),
+            op: Operator::Eq,
+            right: Box::new(1i64.lit()),
+        });
+        let evaluator = SimpleFilterEvaluator::try_new(&expr).unwrap();
+
+        let input_1 = Arc::new(datatypes::arrow::array::Int64Array::from(vec![1, 2, 3])) as _;
+        let result = evaluator.evaluate_array(&input_1).unwrap();
+        assert_eq!(result, BooleanBuffer::from(vec![true, false, false]));
+
+        let input_2 = Arc::new(datatypes::arrow::array::Int64Array::from(vec![1, 1, 1])) as _;
+        let result = evaluator.evaluate_array(&input_2).unwrap();
+        assert_eq!(result, BooleanBuffer::from(vec![true, true, true]));
+
+        let input_3 = Arc::new(datatypes::arrow::array::Int64Array::new_null(0)) as _;
+        let result = evaluator.evaluate_array(&input_3).unwrap();
+        assert_eq!(result, BooleanBuffer::from(vec![]));
+    }
+
+    #[test]
+    fn run_on_scalar() {
+        let expr = Expr::BinaryExpr(BinaryExpr {
+            left: Box::new(Expr::Column(Column::from_name("foo"))),
+            op: Operator::Lt,
+            right: Box::new(1i64.lit()),
+        });
+        let evaluator = SimpleFilterEvaluator::try_new(&expr).unwrap();
+
+        let input_1 = ScalarValue::Int64(Some(1));
+        let result = evaluator.evaluate_scalar(&input_1).unwrap();
+        assert!(!result);
+
+        let input_2 = ScalarValue::Int64(Some(0));
+        let result = evaluator.evaluate_scalar(&input_2).unwrap();
+        assert!(result);
+
+        let input_3 = ScalarValue::Int64(None);
+        let result = evaluator.evaluate_scalar(&input_3).unwrap();
+        assert!(!result);
+    }
+
+    #[test]
+    fn test_complex_filter_expression() {
+        // Create an expression tree for: col = 'B' OR col = 'C' OR col = 'D'
+        let col_eq_b = col("col").eq(lit("B"));
+        let col_eq_c = col("col").eq(lit("C"));
+        let col_eq_d = col("col").eq(lit("D"));
+
+        // Build the OR chain
+        let col_or_expr = col_eq_b.or(col_eq_c).or(col_eq_d);
+
+        // Check that SimpleFilterEvaluator can handle OR chain
+        let or_evaluator = SimpleFilterEvaluator::try_new(&col_or_expr).unwrap();
+        assert_eq!(or_evaluator.column_name, "col");
+        assert!(or_evaluator.is_or_eq_chain());
+        assert_eq!(
+            or_evaluator.literal_list_values().unwrap(),
+            vec![Value::from("B"), Value::from("C"), Value::from("D")]
+        );
+
+        // Create a schema and batch for testing
+        let schema = Schema::new(vec![Field::new("col", DataType::Utf8, false)]);
+        let df_schema = DFSchema::try_from(schema.clone()).unwrap();
+        let props = ExecutionProps::new();
+        let physical_expr = create_physical_expr(
+            &col_or_expr,
+            &df_schema,
+            &props,
+            &PhysicalPlanningContext::default(),
+        )
+        .unwrap();
+
+        // Create test data
+        let col_data = Arc::new(datatypes::arrow::array::StringArray::from(vec![
+            "B", "C", "E", "B", "C", "D", "F",
+        ]));
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![col_data]).unwrap();
+        let expected = datatypes::arrow::array::StringArray::from(vec!["B", "C", "B", "C", "D"]);
+
+        // Filter the batch
+        let filtered_batch = batch_filter(&batch, &physical_expr).unwrap();
+
+        // Expected: rows with col in ("B", "C", "D")
+        // That would be rows 0, 1, 3, 4, 5
+        assert_eq!(filtered_batch.num_rows(), 5);
+
+        let col_filtered = filtered_batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<datatypes::arrow::array::StringArray>()
+            .unwrap();
+        assert_eq!(col_filtered, &expected);
+    }
+
+    #[test]
+    fn test_maybe_build_regex() {
+        // Test case for RegexMatch (case sensitive, non-negative)
+        let (regex, negative) = SimplePredicate::maybe_build_regex(
+            Operator::RegexMatch,
+            &ScalarValue::Utf8(Some("a.*b".to_string())),
+        )
+        .unwrap();
+        assert!(regex.is_some());
+        assert!(!negative);
+        assert!(regex.unwrap().is_match("axxb"));
+
+        // Test case for RegexIMatch (case insensitive, non-negative)
+        let (regex, negative) = SimplePredicate::maybe_build_regex(
+            Operator::RegexIMatch,
+            &ScalarValue::Utf8(Some("a.*b".to_string())),
+        )
+        .unwrap();
+        assert!(regex.is_some());
+        assert!(!negative);
+        assert!(regex.unwrap().is_match("AxxB"));
+
+        // Test case for RegexNotMatch (case sensitive, negative)
+        let (regex, negative) = SimplePredicate::maybe_build_regex(
+            Operator::RegexNotMatch,
+            &ScalarValue::Utf8(Some("a.*b".to_string())),
+        )
+        .unwrap();
+        assert!(regex.is_some());
+        assert!(negative);
+
+        // Test case for RegexNotIMatch (case insensitive, negative)
+        let (regex, negative) = SimplePredicate::maybe_build_regex(
+            Operator::RegexNotIMatch,
+            &ScalarValue::Utf8(Some("a.*b".to_string())),
+        )
+        .unwrap();
+        assert!(regex.is_some());
+        assert!(negative);
+
+        // Test with empty regex pattern
+        let (regex, negative) = SimplePredicate::maybe_build_regex(
+            Operator::RegexMatch,
+            &ScalarValue::Utf8(Some("".to_string())),
+        )
+        .unwrap();
+        assert!(regex.is_none());
+        assert!(!negative);
+
+        // Test with non-regex operator
+        let (regex, negative) = SimplePredicate::maybe_build_regex(
+            Operator::Eq,
+            &ScalarValue::Utf8(Some("a.*b".to_string())),
+        )
+        .unwrap();
+        assert!(regex.is_none());
+        assert!(!negative);
+
+        // Test with invalid regex pattern
+        let result = SimplePredicate::maybe_build_regex(
+            Operator::RegexMatch,
+            &ScalarValue::Utf8(Some("a(b".to_string())),
+        );
+        assert!(result.is_err());
+
+        // Test with non-string value
+        let result = SimplePredicate::maybe_build_regex(
+            Operator::RegexMatch,
+            &ScalarValue::Int64(Some(123)),
+        );
+        assert!(result.is_err());
+
+        // Test with null value
+        let result =
+            SimplePredicate::maybe_build_regex(Operator::RegexMatch, &ScalarValue::Utf8(None));
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_regex_match_dictionary_array() {
+        use datatypes::arrow::array::StringDictionaryBuilder;
+
+        // Create a StringDictionaryArray
+        let mut builder = StringDictionaryBuilder::<UInt32Type>::new();
+        builder.append("apple").unwrap();
+        builder.append("banana").unwrap();
+        builder.append("apple").unwrap();
+        builder.append("cherry").unwrap();
+        let dict_array = builder.finish();
+
+        // Test regex that matches "apple"
+        let regex = regex::Regex::new(r"app.*").unwrap();
+        let result = regexp_is_match_dictionary(&dict_array, Some(&regex)).unwrap();
+
+        // Should match indices 0 and 2 (both "apple")
+        assert_eq!(result.len(), 4);
+        assert!(result.value(0)); // "apple"
+        assert!(!result.value(1)); // "banana"
+        assert!(result.value(2)); // "apple"
+        assert!(!result.value(3)); // "cherry"
+
+        // Test regex that matches "banana"
+        let regex2 = regex::Regex::new(r"ban.*").unwrap();
+        let result2 = regexp_is_match_dictionary(&dict_array, Some(&regex2)).unwrap();
+
+        assert!(!result2.value(0)); // "apple"
+        assert!(result2.value(1)); // "banana"
+        assert!(!result2.value(2)); // "apple"
+        assert!(!result2.value(3)); // "cherry"
+
+        // Test with no regex (should match all)
+        let result3 = regexp_is_match_dictionary(&dict_array, None).unwrap();
+        assert!(result3.value(0));
+        assert!(result3.value(1));
+        assert!(result3.value(2));
+        assert!(result3.value(3));
+    }
+
+    #[test]
+    fn test_regex_scan_masks_preserve_sql_null_semantics() {
+        let plain = Arc::new(datatypes::arrow::array::StringArray::from(vec![
+            Some("api"),
+            Some("API"),
+            Some("db"),
+            None,
+        ])) as ArrayRef;
+        assert_regex_scan_masks(
+            &plain,
+            [
+                vec![true, false, false, false],
+                vec![true, true, false, false],
+                vec![false, true, true, false],
+                vec![false, false, true, false],
+            ],
+        );
+
+        let dictionary = DictionaryArray::new(
+            datatypes::arrow::array::UInt32Array::from(vec![
+                Some(0),
+                Some(1),
+                Some(2),
+                None,
+                Some(3),
+            ]),
+            Arc::new(datatypes::arrow::array::StringArray::from(vec![
+                Some("api"),
+                Some("API"),
+                Some("db"),
+                None,
+            ])),
+        );
+        let raw =
+            regexp_is_match_dictionary(&dictionary, Some(&Regex::new("^api$").unwrap())).unwrap();
+        assert!(raw.is_null(3)); // null dictionary key
+        assert!(raw.is_null(4)); // non-null key referencing a null dictionary value
+
+        let dictionary = Arc::new(dictionary) as ArrayRef;
+        assert_regex_scan_masks(
+            &dictionary,
+            [
+                vec![true, false, false, false, false],
+                vec![true, true, false, false, false],
+                vec![false, true, true, false, false],
+                vec![false, false, true, false, false],
+            ],
+        );
+
+        let negative = regex_evaluator(Operator::RegexNotMatch);
+        assert!(!negative.evaluate_scalar(&ScalarValue::Utf8(None)).unwrap());
+    }
+
+    fn assert_regex_scan_masks(input: &ArrayRef, expected: [Vec<bool>; 4]) {
+        for (op, expected) in [
+            Operator::RegexMatch,
+            Operator::RegexIMatch,
+            Operator::RegexNotMatch,
+            Operator::RegexNotIMatch,
+        ]
+        .into_iter()
+        .zip(expected)
+        {
+            assert_eq!(
+                BooleanBuffer::from(expected),
+                regex_evaluator(op).evaluate_array(input).unwrap(),
+                "{op:?}"
+            );
+        }
+    }
+
+    fn regex_evaluator(op: Operator) -> SimpleFilterEvaluator {
+        let expr = Expr::BinaryExpr(BinaryExpr {
+            left: Box::new(Expr::Column(Column::from_name("host"))),
+            op,
+            right: Box::new("^api$".lit()),
+        });
+        SimpleFilterEvaluator::try_new(&expr).unwrap()
+    }
+}
diff --git a/src/common/recordbatch/src/filter/tests.rs b/src/common/recordbatch/src/filter/tests.rs
new file mode 100644
index 00000000000..77abf59b404
--- /dev/null
+++ b/src/common/recordbatch/src/filter/tests.rs
@@ -0,0 +1,72 @@
+// 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::execution::context::ExecutionProps;
+use datafusion::logical_expr::physical_planning_context::PhysicalPlanningContext;
+use datafusion::logical_expr::{col, lit};
+use datafusion::physical_expr::create_physical_expr;
+use datafusion_common::DFSchema;
+use datatypes::arrow::datatypes::{DataType, Field, Schema};
+
+use datatypes::arrow::array::{BooleanArray, RecordBatch};
+
+use crate::filter::{batch_filter, boolean_array_to_scan_mask};
+
+#[test]
+fn batch_filter_test() {
+    let expr = col("ts").gt(lit(123456u64));
+    let schema = Schema::new(vec![
+        Field::new("a", DataType::Int32, true),
+        Field::new("ts", DataType::UInt64, false),
+    ]);
+    let df_schema = DFSchema::try_from(schema.clone()).unwrap();
+    let props = ExecutionProps::new();
+    let physical_expr = create_physical_expr(
+        &expr,
+        &df_schema,
+        &props,
+        &PhysicalPlanningContext::default(),
+    )
+    .unwrap();
+    let batch = RecordBatch::try_new(
+        Arc::new(schema),
+        vec![
+            Arc::new(datatypes::arrow::array::Int32Array::from(vec![4, 5, 6])),
+            Arc::new(datatypes::arrow::array::UInt64Array::from(vec![
+                123456, 123457, 123458,
+            ])),
+        ],
+    )
+    .unwrap();
+    let new_batch = batch_filter(&batch, &physical_expr).unwrap();
+    assert_eq!(new_batch.num_rows(), 2);
+    let first_column_values = new_batch
+        .column(0)
+        .as_any()
+        .downcast_ref::<datatypes::arrow::array::Int32Array>()
+        .unwrap();
+    let expected = datatypes::arrow::array::Int32Array::from(vec![5, 6]);
+    assert_eq!(first_column_values, &expected);
+}
+
+#[test]
+fn test_nullable_boolean_predicate_becomes_scan_mask() {
+    let predicate = BooleanArray::from(vec![Some(true), None, Some(false)]);
+    assert_eq!(
+        BooleanArray::from(vec![true, false, false]),
+        boolean_array_to_scan_mask(&predicate)
+    );
+}
diff --git a/src/common/recordbatch/src/filter/timestamp.rs b/src/common/recordbatch/src/filter/timestamp.rs
new file mode 100644
index 00000000000..4c19aad546b
--- /dev/null
+++ b/src/common/recordbatch/src/filter/timestamp.rs
@@ -0,0 +1,439 @@
+// 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.
+
+//! Timestamp-unit adaptation for predicates evaluated against historical SSTs.
+
+use common_time::timestamp::div_mod_units;
+use datafusion::logical_expr::Operator;
+use datafusion_common::ScalarValue;
+use datafusion_common::arrow::array::{ArrayRef, Datum, Scalar};
+use datatypes::arrow::datatypes::TimeUnit;
+
+use crate::filter::predicate::SimplePredicate;
+
+/// Builds a tz-naive timestamp literal for `value` in `unit`.
+pub fn timestamp_scalar_value(value: i64, unit: TimeUnit) -> ScalarValue {
+    match unit {
+        TimeUnit::Second => ScalarValue::TimestampSecond(Some(value), None),
+        TimeUnit::Millisecond => ScalarValue::TimestampMillisecond(Some(value), None),
+        TimeUnit::Microsecond => ScalarValue::TimestampMicrosecond(Some(value), None),
+        TimeUnit::Nanosecond => ScalarValue::TimestampNanosecond(Some(value), None),
+    }
+}
+
+impl SimplePredicate {
+    pub(crate) fn cast_timestamp_unit(&self, target_unit: TimeUnit) -> Option<Self> {
+        // Constants represent scan outcomes here. As in the public Matched/Pruned
+        // result, UNKNOWN can be collapsed to false under these AND/OR-only trees.
+        match self {
+            Self::And(left, right) | Self::Or(left, right) => {
+                let left = left.cast_timestamp_unit(target_unit)?;
+                let right = right.cast_timestamp_unit(target_unit)?;
+                let and = matches!(self, Self::And(..));
+                Some(match (left, right) {
+                    (Self::Constant(Some(false)), _) | (_, Self::Constant(Some(false))) if and => {
+                        Self::Constant(Some(false))
+                    }
+                    (Self::Constant(Some(true)), _) | (_, Self::Constant(Some(true))) if !and => {
+                        Self::Constant(Some(true))
+                    }
+                    (Self::Constant(Some(true)), other) | (other, Self::Constant(Some(true)))
+                        if and =>
+                    {
+                        other
+                    }
+                    (Self::Constant(Some(false)), other) | (other, Self::Constant(Some(false)))
+                        if !and =>
+                    {
+                        other
+                    }
+                    (left, right) => {
+                        if and {
+                            Self::And(Box::new(left), Box::new(right))
+                        } else {
+                            Self::Or(Box::new(left), Box::new(right))
+                        }
+                    }
+                })
+            }
+            Self::IsNull { .. } => Some(self.clone()),
+            Self::Constant(value) => Some(Self::Constant(Some(value.unwrap_or(false)))),
+            Self::OrEqChain { literals } => {
+                let mut converted = Vec::with_capacity(literals.len());
+                for literal in literals {
+                    let scalar = ScalarValue::try_from_array(literal.get().0, 0).ok()?;
+                    let (value, unit) = timestamp_scalar_parts(&scalar)?;
+                    let Some(value) = value else {
+                        continue;
+                    };
+                    let cast = div_mod_units(value, unit.into(), target_unit.into())?;
+                    if cast.remainder == 0 {
+                        converted.push(timestamp_scalar(cast.quotient, target_unit)?);
+                    }
+                }
+                if converted.is_empty() {
+                    return Some(Self::Constant(Some(false)));
+                }
+                Some(Self::OrEqChain {
+                    literals: converted,
+                })
+            }
+            Self::Comparison { literal, op, .. } => {
+                let scalar = ScalarValue::try_from_array(literal.get().0, 0).ok()?;
+                let (value, unit) = timestamp_scalar_parts(&scalar)?;
+                let Some(value) = value else {
+                    return Some(Self::Constant(Some(false)));
+                };
+                if unit == target_unit {
+                    return Some(self.clone());
+                }
+                let cast = div_mod_units(value, unit.into(), target_unit.into())?;
+                let divisible = cast.remainder == 0;
+                let literal = timestamp_scalar(cast.quotient, target_unit)?;
+                let filter = |op| Self::Comparison {
+                    literal: literal.clone(),
+                    op,
+                    regex: None,
+                    regex_negative: false,
+                };
+                Some(match op {
+                    Operator::Eq if divisible => filter(Operator::Eq),
+                    Operator::Eq => Self::Constant(Some(false)),
+                    Operator::NotEq if divisible => filter(Operator::NotEq),
+                    Operator::NotEq => Self::Constant(Some(true)),
+                    // The quotient is floor(L), including negative timestamps.
+                    // v > L is v > quotient whether or not L is representable.
+                    Operator::Gt => filter(Operator::Gt),
+                    Operator::GtEq if divisible => filter(Operator::GtEq),
+                    // Between target values, v >= L is v > quotient.
+                    Operator::GtEq => filter(Operator::Gt),
+                    Operator::Lt if divisible => filter(Operator::Lt),
+                    // Between target values, v < L is v <= quotient.
+                    Operator::Lt => filter(Operator::LtEq),
+                    Operator::LtEq => filter(Operator::LtEq),
+                    _ => return None,
+                })
+            }
+        }
+    }
+}
+
+/// Extracts the value and unit from a tz-naive timestamp scalar.
+fn timestamp_scalar_parts(scalar: &ScalarValue) -> Option<(Option<i64>, TimeUnit)> {
+    let (value, unit, timezone) = match scalar {
+        ScalarValue::TimestampSecond(v, tz) => (*v, TimeUnit::Second, tz),
+        ScalarValue::TimestampMillisecond(v, tz) => (*v, TimeUnit::Millisecond, tz),
+        ScalarValue::TimestampMicrosecond(v, tz) => (*v, TimeUnit::Microsecond, tz),
+        ScalarValue::TimestampNanosecond(v, tz) => (*v, TimeUnit::Nanosecond, tz),
+        _ => return None,
+    };
+    // A timezone-aware literal doesn't compare against a tz-naive column;
+    // leave it to the caller instead of guessing the intended semantics.
+    (timezone.is_none()).then_some((value, unit))
+}
+
+/// Builds a one-element scalar array holding `value` in `unit`.
+fn timestamp_scalar(value: i64, unit: TimeUnit) -> Option<Scalar<ArrayRef>> {
+    timestamp_scalar_value(value, unit).to_scalar().ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use datafusion::execution::context::ExecutionProps;
+    use datafusion::logical_expr::physical_planning_context::PhysicalPlanningContext;
+    use datafusion::logical_expr::{Expr, col, lit};
+    use datafusion::physical_expr::create_physical_expr;
+    use datafusion_common::arrow::array::ArrayRef;
+    use datafusion_common::arrow::buffer::BooleanBuffer;
+    use datafusion_common::cast::as_boolean_array;
+    use datafusion_common::{DFSchema, ScalarValue};
+    use datatypes::arrow::array::{
+        RecordBatch, TimestampMillisecondArray, TimestampNanosecondArray,
+    };
+    use datatypes::arrow::datatypes::{Field, Schema};
+    use datatypes::data_type::ConcreteDataType;
+
+    use crate::filter::{SimpleFilterEvaluator, TimestampUnitCast, boolean_array_to_scan_mask};
+
+    #[test]
+    fn compound_timestamp_filters_preserve_unit_conversion() {
+        use datatypes::arrow::array::TimestampMicrosecondArray;
+
+        let null = || lit(ScalarValue::TimestampMicrosecond(None, None));
+        let predicates = [
+            col("ts")
+                .gt(lit(ts_us(-1500)))
+                .and(col("ts").lt(lit(ts_us(500)))),
+            col("ts")
+                .eq(lit(ts_us(500)))
+                .or(col("ts").gt_eq(lit(ts_us(1500)))),
+            col("ts")
+                .is_not_null()
+                .and(col("ts").not_eq(lit(ts_us(500)))),
+            col("ts").eq(null()).or(col("ts").eq(lit(ts_us(-1000)))),
+            col("ts")
+                .eq(lit(ts_us(500)))
+                .and(col("ts").gt(lit(ts_us(0)))),
+            col("ts")
+                .not_eq(lit(ts_us(500)))
+                .or(col("ts").lt(lit(ts_us(0)))),
+        ];
+        let native: ArrayRef = Arc::new(TimestampMicrosecondArray::from(vec![
+            -2000, -1000, 0, 1000, 2000,
+        ]));
+        let old: ArrayRef = Arc::new(TimestampMillisecondArray::from(vec![-2, -1, 0, 1, 2]));
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "ts",
+            native.data_type().clone(),
+            false,
+        )]));
+        let batch = RecordBatch::try_new(schema.clone(), vec![native]).unwrap();
+        for expr in predicates {
+            let physical = create_physical_expr(
+                &expr,
+                &DFSchema::try_from(schema.as_ref().clone()).unwrap(),
+                &ExecutionProps::new(),
+                &PhysicalPlanningContext::default(),
+            )
+            .unwrap();
+            let result = physical
+                .evaluate(&batch)
+                .unwrap()
+                .into_array(batch.num_rows())
+                .unwrap();
+            let expected = boolean_array_to_scan_mask(as_boolean_array(&result).unwrap())
+                .values()
+                .clone();
+            let actual = match cast_to_ms(&expr).unwrap() {
+                TimestampUnitCast::Matched => BooleanBuffer::new_set(old.len()),
+                TimestampUnitCast::Pruned => BooleanBuffer::new_unset(old.len()),
+                TimestampUnitCast::Filter(filter) => filter.evaluate_array(&old).unwrap(),
+            };
+            assert_eq!(actual, expected, "{expr}");
+        }
+    }
+
+    fn ts_us(v: i64) -> ScalarValue {
+        ScalarValue::TimestampMicrosecond(Some(v), None)
+    }
+
+    fn cast_to_ms(expr: &Expr) -> Option<TimestampUnitCast> {
+        SimpleFilterEvaluator::try_new(expr)
+            .unwrap()
+            .cast_timestamp_unit(&ConcreteDataType::timestamp_millisecond_datatype())
+    }
+
+    /// Evaluates a cast `Filter` outcome against millisecond values and
+    /// returns the mask.
+    fn eval_ms_mask(cast: Option<TimestampUnitCast>, values: &[i64]) -> Vec<bool> {
+        let filter = match cast.expect("cast must apply") {
+            TimestampUnitCast::Filter(filter) => filter,
+            other => panic!("expected Filter outcome, got {other:?}"),
+        };
+        let array = Arc::new(TimestampMillisecondArray::from(values.to_vec())) as ArrayRef;
+        filter.evaluate_array(&array).unwrap().iter().collect()
+    }
+
+    #[test]
+    fn cast_timestamp_unit_converts_representable_literal() {
+        // ts = 7_000_000us evaluated against a ms column becomes ts = 7000ms.
+        assert_eq!(
+            vec![false, true, false],
+            eval_ms_mask(
+                cast_to_ms(&col("ts").eq(lit(ts_us(7_000_000)))),
+                &[6_999, 7_000, 7_001]
+            )
+        );
+        // != complements =.
+        assert_eq!(
+            vec![true, false, true],
+            eval_ms_mask(
+                cast_to_ms(&col("ts").not_eq(lit(ts_us(7_000_000)))),
+                &[6_999, 7_000, 7_001]
+            )
+        );
+    }
+
+    #[test]
+    fn cast_timestamp_unit_prunes_non_representable_equality() {
+        // 7_000_500us is not a whole millisecond: no ms row can equal it,
+        // and every ms row satisfies `!=`.
+        assert!(matches!(
+            cast_to_ms(&col("ts").eq(lit(ts_us(7_000_500)))),
+            Some(TimestampUnitCast::Pruned)
+        ));
+        assert!(matches!(
+            cast_to_ms(&col("ts").not_eq(lit(ts_us(7_000_500)))),
+            Some(TimestampUnitCast::Matched)
+        ));
+    }
+
+    #[test]
+    fn cast_timestamp_unit_strengthens_inequalities() {
+        // 2_500_500us is strictly between 2500ms and 2501ms: the cast must
+        // not round the literal to a boundary the original predicate
+        // excludes (>= 2500ms would wrongly match 2500ms).
+        let values = vec![2_499, 2_500, 2_501];
+        assert_eq!(
+            vec![false, false, true],
+            eval_ms_mask(cast_to_ms(&col("ts").gt(lit(ts_us(2_500_500)))), &values)
+        );
+        assert_eq!(
+            vec![false, false, true],
+            eval_ms_mask(cast_to_ms(&col("ts").gt_eq(lit(ts_us(2_500_500)))), &values)
+        );
+        assert_eq!(
+            vec![true, true, false],
+            eval_ms_mask(cast_to_ms(&col("ts").lt(lit(ts_us(2_500_500)))), &values)
+        );
+        assert_eq!(
+            vec![true, true, false],
+            eval_ms_mask(cast_to_ms(&col("ts").lt_eq(lit(ts_us(2_500_500)))), &values)
+        );
+
+        // Representable boundary keeps the original operator.
+        let values = vec![2_499, 2_500, 2_501];
+        assert_eq!(
+            vec![false, false, true],
+            eval_ms_mask(cast_to_ms(&col("ts").gt(lit(ts_us(2_500_000)))), &values)
+        );
+        assert_eq!(
+            vec![false, true, true],
+            eval_ms_mask(cast_to_ms(&col("ts").gt_eq(lit(ts_us(2_500_000)))), &values)
+        );
+        assert_eq!(
+            vec![true, false, false],
+            eval_ms_mask(cast_to_ms(&col("ts").lt(lit(ts_us(2_500_000)))), &values)
+        );
+        assert_eq!(
+            vec![true, true, false],
+            eval_ms_mask(cast_to_ms(&col("ts").lt_eq(lit(ts_us(2_500_000)))), &values)
+        );
+    }
+
+    #[test]
+    fn cast_timestamp_unit_handles_negative_instants() {
+        // -2_500_500us floors to -2501ms with remainder 500us: only rows
+        // with instant >= -2.5005ms may match >= / >.
+        let values = vec![-2_502, -2_501, -2_500];
+        assert_eq!(
+            vec![false, false, true],
+            eval_ms_mask(
+                cast_to_ms(&col("ts").gt_eq(lit(ts_us(-2_500_500)))),
+                &values
+            )
+        );
+        assert_eq!(
+            vec![false, false, true],
+            eval_ms_mask(cast_to_ms(&col("ts").gt(lit(ts_us(-2_500_500)))), &values)
+        );
+        assert_eq!(
+            vec![true, true, false],
+            eval_ms_mask(
+                cast_to_ms(&col("ts").lt_eq(lit(ts_us(-2_500_500)))),
+                &values
+            )
+        );
+        // Exactly representable negative literal: -2_500_000us == -2500ms.
+        assert_eq!(
+            vec![false, false, true],
+            eval_ms_mask(cast_to_ms(&col("ts").eq(lit(ts_us(-2_500_000)))), &values)
+        );
+    }
+
+    #[test]
+    fn cast_timestamp_unit_or_chain_drops_unrepresentable_literals() {
+        // Only 7_000_000us is a whole millisecond; 7_000_500us cannot match.
+        let expr = col("ts")
+            .eq(lit(ts_us(7_000_500)))
+            .or(col("ts").eq(lit(ts_us(7_000_000))));
+        assert_eq!(
+            vec![false, true],
+            eval_ms_mask(cast_to_ms(&expr), &[6_999, 7_000])
+        );
+
+        // A chain where no literal is representable matches nothing.
+        let expr = col("ts")
+            .eq(lit(ts_us(7_000_500)))
+            .or(col("ts").eq(lit(ts_us(6_000_500))));
+        assert!(matches!(cast_to_ms(&expr), Some(TimestampUnitCast::Pruned)));
+    }
+
+    #[test]
+    fn cast_timestamp_unit_null_literal_prunes() {
+        // A NULL literal never compares true.
+        assert!(matches!(
+            cast_to_ms(&col("ts").eq(lit(ScalarValue::TimestampMicrosecond(None, None)))),
+            Some(TimestampUnitCast::Pruned)
+        ));
+    }
+
+    #[test]
+    fn cast_timestamp_unit_same_unit_returns_filter_directly() {
+        // A literal already in the target unit is returned unchanged.
+        let expr = col("ts").eq(lit(ts_us(7_000_000)));
+        let filter = SimpleFilterEvaluator::try_new(&expr).unwrap();
+        let cast = filter
+            .cast_timestamp_unit(&ConcreteDataType::timestamp_microsecond_datatype())
+            .unwrap();
+        let TimestampUnitCast::Filter(f) = cast else {
+            panic!("expected Filter, got {cast:?}")
+        };
+        assert!(filter.is_eq() && f.is_eq());
+        assert_eq!(filter.column_name(), f.column_name());
+        assert_eq!(filter.literal_value(), f.literal_value());
+    }
+
+    #[test]
+    fn cast_timestamp_unit_rejects_non_timestamps() {
+        // Non-timestamp target type.
+        assert!(
+            SimpleFilterEvaluator::try_new(&col("ts").gt(lit(ts_us(1))))
+                .unwrap()
+                .cast_timestamp_unit(&ConcreteDataType::int64_datatype())
+                .is_none()
+        );
+        // Non-timestamp literal against a timestamp target.
+        assert!(cast_to_ms(&col("ts").gt(lit(42_i64))).is_none());
+    }
+
+    #[test]
+    fn cast_timestamp_unit_to_finer_unit() {
+        // 5 seconds against a nanosecond column becomes 5_000_000_000ns.
+        let filter = SimpleFilterEvaluator::try_new(
+            &col("ts").eq(lit(ScalarValue::TimestampSecond(Some(5), None))),
+        )
+        .unwrap()
+        .cast_timestamp_unit(&ConcreteDataType::timestamp_nanosecond_datatype())
+        .and_then(|cast| match cast {
+            TimestampUnitCast::Filter(filter) => Some(filter),
+            _ => None,
+        })
+        .unwrap();
+        let array = Arc::new(TimestampNanosecondArray::from(vec![
+            4_999_999_999,
+            5_000_000_000,
+        ])) as ArrayRef;
+        assert_eq!(
+            vec![false, true],
+            filter
+                .evaluate_array(&array)
+                .unwrap()
+                .iter()
+                .collect::<Vec<_>>()
+        );
+    }
+}
diff --git a/src/common/version/build.rs b/src/common/version/build.rs
index 81c805484b4..2037f826616 100644
--- a/src/common/version/build.rs
+++ b/src/common/version/build.rs
@@ -30,12 +30,21 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     println!("cargo:rerun-if-env-changed=RUSTC");
     println!("cargo:rerun-if-env-changed=GREPTIME_PRODUCT_NAME");
+    println!("cargo:rerun-if-env-changed=CARGO_WORKSPACE_DIR");
 
-    // The "CARGO_WORKSPACE_DIR" is set manually (not by Rust itself) in Cargo config file, to
-    // solve the problem where the "CARGO_MANIFEST_DIR" is not what we want when this repo is
-    // made as a submodule in another repo.
-    let workspace_dir =
-        env::var("CARGO_WORKSPACE_DIR").or_else(|_| env::var("CARGO_MANIFEST_DIR"))?;
+    // Resolve the workspace root from CARGO_MANIFEST_DIR (this crate is
+    // src/common/version, three levels below the root). The path remains absolute
+    // and is used at build time. CARGO_WORKSPACE_DIR remains an explicit override
+    // for submodule builds; see https://github.com/rust-lang/cargo/issues/3946.
+    let workspace_dir = match env::var("CARGO_WORKSPACE_DIR") {
+        Ok(dir) if !dir.is_empty() => dir,
+        _ => env::var("CARGO_MANIFEST_DIR").map(|dir| {
+            PathBuf::from(dir)
+                .join("../../..")
+                .to_string_lossy()
+                .into_owned()
+        })?,
+    };
     let workspace_root = PathBuf::from(&workspace_dir);
     println!(
         "cargo:rerun-if-changed={}",
diff --git a/src/datanode/src/error.rs b/src/datanode/src/error.rs
index b62708aa343..7ea7b2a7c59 100644
--- a/src/datanode/src/error.rs
+++ b/src/datanode/src/error.rs
@@ -554,8 +554,8 @@ impl ErrorExt for Error {
         use Error::*;
 
         match self {
+            RegionNotReady { .. } | RegionNotFound { .. } => RetryHint::RetryAfterRouteRefresh,
             RegionBusy { .. }
-            | RegionNotReady { .. }
             | ConcurrentQueryLimiterClosed { .. }
             | ConcurrentQueryLimiterTimeout { .. } => RetryHint::Retryable,
             NewPlanDecoder { source, .. } | ExecuteLogicalPlan { source, .. } => {
@@ -595,14 +595,28 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_region_state_hints_are_retryable() {
+    fn test_region_state_retry_hints() {
         let region_id = RegionId::new(1024, 1);
-
-        let err = RegionBusySnafu { region_id }.build();
-        assert_eq!(err.retry_hint(), RetryHint::Retryable);
-
-        let err = RegionNotReadySnafu { region_id }.build();
-        assert_eq!(err.retry_hint(), RetryHint::Retryable);
+        for (error, status, hint) in [
+            (
+                RegionBusySnafu { region_id }.build(),
+                StatusCode::RegionBusy,
+                RetryHint::Retryable,
+            ),
+            (
+                RegionNotReadySnafu { region_id }.build(),
+                StatusCode::RegionNotReady,
+                RetryHint::RetryAfterRouteRefresh,
+            ),
+            (
+                RegionNotFoundSnafu { region_id }.build(),
+                StatusCode::RegionNotFound,
+                RetryHint::RetryAfterRouteRefresh,
+            ),
+        ] {
+            assert_eq!(error.status_code(), status);
+            assert_eq!(error.retry_hint(), hint);
+        }
     }
 
     #[test]
diff --git a/src/datanode/src/region_server.rs b/src/datanode/src/region_server.rs
index aba09de8797..0d106a7d915 100644
--- a/src/datanode/src/region_server.rs
+++ b/src/datanode/src/region_server.rs
@@ -2566,7 +2566,7 @@ mod tests {
             .unwrap_err();
         assert_matches!(&err, error::Error::HandleBatchOpenRequest { .. });
         assert_eq!(err.status_code(), StatusCode::RegionNotFound);
-        assert_eq!(err.retry_hint(), RetryHint::NonRetryable);
+        assert_eq!(err.retry_hint(), RetryHint::RetryAfterRouteRefresh);
     }
 
     struct CurrentEngineTest {
diff --git a/src/datatypes/src/types/vector_type.rs b/src/datatypes/src/types/vector_type.rs
index d01949c4737..ab756be90eb 100644
--- a/src/datatypes/src/types/vector_type.rs
+++ b/src/datatypes/src/types/vector_type.rs
@@ -86,8 +86,10 @@ pub fn vector_type_value_to_string(val: &[u8], dim: u32) -> Result<String> {
     }
 
     let elements = val
-        .chunks_exact(std::mem::size_of::<f32>())
-        .map(|e| f32::from_le_bytes(e.try_into().unwrap()));
+        .as_chunks::<{ std::mem::size_of::<f32>() }>()
+        .0
+        .iter()
+        .map(|e| f32::from_le_bytes(*e));
 
     let mut s = String::from("[");
     for (i, e) in elements.enumerate() {
diff --git a/src/flow/src/adapter.rs b/src/flow/src/adapter.rs
index c98510bd7d5..5b15ad0a93c 100644
--- a/src/flow/src/adapter.rs
+++ b/src/flow/src/adapter.rs
@@ -141,8 +141,9 @@ fn relation_desc_from_output(
     columns: &[ColumnSchema],
     lineage: &[Option<usize>],
     source_primary_key_indices: &[usize],
+    plan: &LogicalPlan,
 ) -> RelationDesc {
-    let keys = source_primary_key_indices
+    let mut keys = source_primary_key_indices
         .iter()
         .filter_map(|source_index| {
             lineage
@@ -150,6 +151,14 @@ fn relation_desc_from_output(
                 .position(|index| index == &Some(*source_index))
         })
         .collect_vec();
+    // DISTINCT defines identity from every output tuple; the source timestamp participates
+    // separately as the relation time index, so it is excluded from the tag key.
+    if matches!(plan, LogicalPlan::Distinct(Distinct::All(_))) {
+        keys = columns
+            .iter()
+            .positions(|column| !column.is_time_index())
+            .collect();
+    }
     let time_index = columns.iter().position(ColumnSchema::is_time_index);
     RelationDesc {
         typ: crate::repr::RelationType {
@@ -849,8 +858,12 @@ impl StreamingEngine {
         let source_primary_key_indices = source_meta.primary_key_indices;
         stateless::validate_source_scan(&flow_plan, source_table_id, &source_schema)?;
         let (inferred_schema, lineage) = output_column_schemas(&flow_plan, &source_schema)?;
-        let inferred_relation =
-            relation_desc_from_output(&inferred_schema, &lineage, &source_primary_key_indices);
+        let inferred_relation = relation_desc_from_output(
+            &inferred_schema,
+            &lineage,
+            &source_primary_key_indices,
+            &flow_plan,
+        );
         let sink_exists = self.fetch_table_pk_schema(sink_table_name).await?.is_some();
         if !sink_exists {
             validate_auto_column_names(&inferred_schema)?;
diff --git a/src/flow/src/adapter/tests.rs b/src/flow/src/adapter/tests.rs
index 6bc02f60786..6a2bf5ed816 100644
--- a/src/flow/src/adapter/tests.rs
+++ b/src/flow/src/adapter/tests.rs
@@ -20,7 +20,7 @@ use datafusion::arrow::datatypes::{DataType as ArrowDataType, Field, TimeUnit as
 use datafusion::catalog::MemTable;
 use datafusion::datasource::provider_as_source;
 use datafusion_common::TableReference;
-use datafusion_expr::LogicalPlanBuilder;
+use datafusion_expr::{LogicalPlan, LogicalPlanBuilder};
 use datatypes::schema::{ColumnDefaultConstraint, ColumnSchema, Schema, SchemaBuilder};
 use store_api::storage::{ConcreteDataType, TableId};
 use table::metadata::{TableInfo, TableInfoBuilder, TableMetaBuilder};
@@ -194,10 +194,133 @@ fn stateless_distinct_preserves_direct_column_lineage() {
     let (output, lineage) = super::output_column_schemas(&plan, &source).unwrap();
     assert_eq!(output[0].name, "dis");
     assert_eq!(lineage, vec![Some(0)]);
-    let relation = super::relation_desc_from_output(&output, &lineage, &[0]);
+    let relation = super::relation_desc_from_output(&output, &lineage, &[0], &plan);
     assert_eq!(relation.typ.keys[0].column_indices, vec![0]);
 }
 
+#[test]
+fn stateless_distinct_output_is_always_the_sink_key() {
+    let source = Arc::new(Schema::new(vec![
+        ColumnSchema::new("v", ConcreteDataType::int32_datatype(), true),
+        ColumnSchema::new("k", ConcreteDataType::int32_datatype(), true),
+        ColumnSchema::new("other", ConcreteDataType::int32_datatype(), true),
+        ColumnSchema::new(
+            "ts",
+            ConcreteDataType::timestamp_millisecond_datatype(),
+            false,
+        )
+        .with_time_index(true),
+    ]));
+    // All cases share one provider so the key assertions exercise only plan/output metadata.
+    let provider = Arc::new(
+        MemTable::try_new(
+            Arc::new(datafusion::arrow::datatypes::Schema::new(vec![
+                Field::new("v", ArrowDataType::Int32, true),
+                Field::new("k", ArrowDataType::Int32, true),
+                Field::new("other", ArrowDataType::Int32, true),
+                Field::new(
+                    "ts",
+                    ArrowDataType::Timestamp(ArrowTimeUnit::Millisecond, None),
+                    false,
+                ),
+            ])),
+            vec![vec![]],
+        )
+        .unwrap(),
+    );
+    let make_plan = |expressions: Vec<datafusion_expr::Expr>, distinct: bool| {
+        let builder = LogicalPlanBuilder::scan(
+            TableReference::bare("source"),
+            provider_as_source(provider.clone()),
+            None,
+        )
+        .unwrap()
+        .project(expressions)
+        .unwrap();
+        if distinct {
+            builder.distinct().unwrap().build().unwrap()
+        } else {
+            builder.build().unwrap()
+        }
+    };
+    let assert_key = |plan: &LogicalPlan, source_keys: &[usize], expected: &[usize]| {
+        let (output, lineage) = super::output_column_schemas(plan, &source).unwrap();
+        let relation = super::relation_desc_from_output(&output, &lineage, source_keys, plan);
+        assert_eq!(
+            relation
+                .typ
+                .keys
+                .iter()
+                .map(|key| key.column_indices.clone())
+                .collect::<Vec<_>>(),
+            if expected.is_empty() {
+                vec![]
+            } else {
+                vec![expected.to_vec()]
+            }
+        );
+        relation
+    };
+
+    // No source PK: all distinct output fields form the key.
+    assert_key(&make_plan(vec![datafusion_expr::col("v")], true), &[], &[0]);
+    // A surviving subset of a composite source PK cannot identify projected DISTINCT tuples.
+    assert_key(
+        &make_plan(
+            vec![datafusion_expr::col("v"), datafusion_expr::col("other")],
+            true,
+        ),
+        &[0, 1],
+        &[0, 1],
+    );
+    // Even a retained source PK needs the additional selected fields in the DISTINCT key.
+    assert_key(
+        &make_plan(
+            vec![datafusion_expr::col("v"), datafusion_expr::col("other")],
+            true,
+        ),
+        &[0],
+        &[0, 1],
+    );
+    // Aliases and computed output expressions are included by output position.
+    let alias_plan = make_plan(
+        vec![
+            datafusion_expr::col("v").alias("renamed"),
+            (datafusion_expr::col("v") + datafusion_expr::col("other")).alias("computed"),
+        ],
+        true,
+    );
+    let (output, lineage) = super::output_column_schemas(&alias_plan, &source).unwrap();
+    let relation = super::relation_desc_from_output(&output, &lineage, &[0], &alias_plan);
+    assert_eq!(
+        output
+            .iter()
+            .map(|column| column.name.as_str())
+            .collect_vec(),
+        ["renamed", "computed"]
+    );
+    assert_eq!(relation.typ.keys[0].column_indices, vec![0, 1]);
+
+    // A selected time index remains the relation time index, not part of the tag key.
+    let relation = assert_key(
+        &make_plan(
+            vec![datafusion_expr::col("v"), datafusion_expr::col("ts")],
+            true,
+        ),
+        &[0],
+        &[0],
+    );
+    assert_eq!(relation.typ.time_index, Some(1));
+
+    // Non-DISTINCT plans retain only inherited source-key lineage (or no key if none survives).
+    let ordinary = make_plan(
+        vec![datafusion_expr::col("v"), datafusion_expr::col("other")],
+        false,
+    );
+    assert_key(&ordinary, &[0, 1], &[0]);
+    assert_key(&ordinary, &[], &[]);
+}
+
 #[test]
 fn stateless_normalizes_dictionary_output_type() {
     let field = Field::new_dictionary("host", ArrowDataType::UInt32, ArrowDataType::Utf8, true);
@@ -220,7 +343,7 @@ fn stateless_normalizes_dictionary_output_type() {
     assert_eq!(output[0].data_type, ConcreteDataType::string_datatype());
     assert_eq!(lineage, vec![Some(0)]);
 
-    let relation = super::relation_desc_from_output(&output, &lineage, &[0]);
+    let relation = super::relation_desc_from_output(&output, &lineage, &[0], &plan);
     assert_eq!(relation.typ.keys[0].column_indices, vec![0]);
 }
 
diff --git a/src/flow/src/batching_mode/task.rs b/src/flow/src/batching_mode/task.rs
index 40020f639c1..c2c3082995a 100644
--- a/src/flow/src/batching_mode/task.rs
+++ b/src/flow/src/batching_mode/task.rs
@@ -1400,6 +1400,12 @@ impl BatchingTask {
         match res {
             Ok(res) => {
                 let (affected_rows, _) = res.output.extract_rows_and_cost();
+                if matches!(&res.output.data, common_query::OutputData::AffectedRows(_)) {
+                    res.metrics.wait_ready().await;
+                }
+                if let Some(error) = res.metrics.completion_error() {
+                    warn!("Flow {flow_id} completed with terminal metrics error: {error}");
+                }
                 debug!(
                     "Flow {flow_id} executed, affected_rows: {affected_rows:?}, elapsed: {:?}, watermark: {:?}",
                     elapsed,
diff --git a/src/flow/src/batching_mode/utils/test.rs b/src/flow/src/batching_mode/utils/test.rs
index 1f390d1594c..1af8880a7d4 100644
--- a/src/flow/src/batching_mode/utils/test.rs
+++ b/src/flow/src/batching_mode/utils/test.rs
@@ -22,7 +22,6 @@ use common_recordbatch::recordbatch::merge_record_batches;
 use common_recordbatch::{RecordBatch, util};
 use common_time::Timestamp;
 use datafusion_common::ScalarValue;
-use datafusion_common::tree_node::TreeNode as _;
 use datafusion_expr::{GroupingSet, TableScanBuilder};
 use datatypes::arrow::array::{Array, AsArray};
 use datatypes::arrow::datatypes::{Float64Type, Int64Type, UInt64Type};
diff --git a/src/frontend/AGENTS.md b/src/frontend/AGENTS.md
index e16cbfc9872..bf8703d81e6 100644
--- a/src/frontend/AGENTS.md
+++ b/src/frontend/AGENTS.md
@@ -42,7 +42,9 @@ remote datanodes via `operator`/`client`.
 - **Insert** (`instance/grpc.rs`): `handle_inserts` / `handle_row_inserts` →
   `check_permission` → `operator`'s `Inserter` (schema validation, optional
   auto-create, partition routing, meter admission) → local `RegionServer`
-  (standalone) or RPC to datanodes (distributed). Arrow bulk inserts pass the
+  (standalone) or RPC to datanodes (distributed). `FrontendBuilder` configures
+  the operator write dispatcher with frontend retry options for distributed
+  inserts, deletes, and bulk writes. Arrow bulk inserts pass the
   request channel to `Inserter` and check meter admission for each nonempty batch.
 - Finite ingestion requests split internally admit their total rows per database
   before dispatch (`operator::insert::admit_write` / `admit_row_insert_batches`).
@@ -96,7 +98,8 @@ cargo nextest run -p frontend
   `servers`; permissions, planning, and routing live here.
 - Standalone vs distributed diverge in datanode access (the `standalone` crate's
   local `RegionServer` adapter vs `NodeClients` RPC), MetaClient usage, and
-  whether heartbeat matters. In standalone, the cache invalidator is a no-op.
+  whether heartbeat matters. The builder defaults local invalidation to its
+  layered cache registry; callers may supply a custom invalidator.
 
 ## Maintenance contract
 
diff --git a/src/frontend/src/error.rs b/src/frontend/src/error.rs
index 9fd2312e736..451040c884a 100644
--- a/src/frontend/src/error.rs
+++ b/src/frontend/src/error.rs
@@ -323,6 +323,13 @@ pub enum Error {
         name: String,
     },
 
+    #[snafu(display("Invalid write retry config: {}", reason))]
+    InvalidWriteRetryConfig {
+        reason: &'static str,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
     #[snafu(display("Invalid tls config"))]
     InvalidTlsConfig {
         #[snafu(source)]
@@ -391,7 +398,8 @@ impl ErrorExt for Error {
             | Error::IllegalAuthConfig { .. }
             | Error::ColumnNoneDefaultValue { .. }
             | Error::IncompleteGrpcRequest { .. }
-            | Error::InvalidTlsConfig { .. } => StatusCode::InvalidArguments,
+            | Error::InvalidTlsConfig { .. }
+            | Error::InvalidWriteRetryConfig { .. } => StatusCode::InvalidArguments,
 
             Error::NotSupported { .. } => StatusCode::Unsupported,
 
diff --git a/src/frontend/src/frontend.rs b/src/frontend/src/frontend.rs
index 71e5888b8fa..4608f70c093 100644
--- a/src/frontend/src/frontend.rs
+++ b/src/frontend/src/frontend.rs
@@ -36,9 +36,10 @@ use crate::heartbeat::HeartbeatTask;
 use crate::instance::Instance;
 use crate::service_config::{
     InfluxdbOptions, JaegerOptions, MysqlOptions, OpentsdbOptions, OtlpOptions,
-    PendingRowsBatcherOptions, PostgresOptions, PromStoreOptions,
+    PendingRowsBatcherOptions, PostgresOptions, PromStoreOptions, WriteRetryOptions,
 };
 
+/// Configures frontend protocols, query execution, and distributed write retries.
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(default)]
 pub struct FrontendOptions {
@@ -75,6 +76,8 @@ pub struct FrontendOptions {
     pub meta_client: Option<MetaClientOptions>,
     pub logging: LoggingOptions,
     pub datanode: DatanodeClientOptions,
+    /// Retry policy for retryable distributed write failures.
+    pub write_retry: WriteRetryOptions,
     pub user_provider: Option<String>,
     pub tracing: TracingOptions,
     pub query: QueryOptions,
@@ -112,6 +115,7 @@ impl Default for FrontendOptions {
             meta_client: None,
             logging: LoggingOptions::default(),
             datanode: DatanodeClientOptions::default(),
+            write_retry: WriteRetryOptions::default(),
             user_provider: None,
             tracing: TracingOptions::default(),
             query: QueryOptions::default(),
@@ -227,6 +231,72 @@ mod tests {
     type GrpcStream<T> =
         Pin<Box<dyn Stream<Item = std::result::Result<T, Status>> + Send + Sync + 'static>>;
 
+    #[test]
+    fn test_write_retry_config() {
+        let defaults: FrontendOptions = toml::from_str("").unwrap();
+        assert_eq!(defaults.write_retry, WriteRetryOptions::default());
+        let options: FrontendOptions = toml::from_str(
+            r#"
+[write_retry]
+max_retries = 5
+initial_backoff = "250ms"
+max_backoff = "5s"
+backoff_multiplier = 3.0
+"#,
+        )
+        .unwrap();
+        assert_eq!(
+            options.write_retry,
+            WriteRetryOptions {
+                max_retries: 5,
+                initial_backoff: Duration::from_millis(250),
+                max_backoff: Duration::from_secs(5),
+                backoff_multiplier: 3.0,
+            }
+        );
+        options.write_retry.validate().unwrap();
+        let serialized = toml::to_string(&options).unwrap();
+        let parsed: FrontendOptions = toml::from_str(&serialized).unwrap();
+        assert_eq!(options.write_retry, parsed.write_retry);
+        let disabled: FrontendOptions = toml::from_str("[write_retry]\nmax_retries = 0").unwrap();
+        assert_eq!(disabled.write_retry.max_retries, 0);
+        assert_eq!(
+            disabled.write_retry.initial_backoff,
+            defaults.write_retry.initial_backoff
+        );
+    }
+
+    #[test]
+    fn test_write_retry_config_from_env() {
+        temp_env::with_vars(
+            [
+                ("FRONTEND_RETRY_TEST__WRITE_RETRY__MAX_RETRIES", Some("4")),
+                (
+                    "FRONTEND_RETRY_TEST__WRITE_RETRY__INITIAL_BACKOFF",
+                    Some("500ms"),
+                ),
+                ("FRONTEND_RETRY_TEST__WRITE_RETRY__MAX_BACKOFF", Some("8s")),
+                (
+                    "FRONTEND_RETRY_TEST__WRITE_RETRY__BACKOFF_MULTIPLIER",
+                    Some("1.5"),
+                ),
+            ],
+            || {
+                let options =
+                    FrontendOptions::load_layered_options(None, "FRONTEND_RETRY_TEST").unwrap();
+                assert_eq!(
+                    options.write_retry,
+                    WriteRetryOptions {
+                        max_retries: 4,
+                        initial_backoff: Duration::from_millis(500),
+                        max_backoff: Duration::from_secs(8),
+                        backoff_multiplier: 1.5,
+                    }
+                );
+            },
+        );
+    }
+
     #[test]
     fn test_logical_batcher_protocols_from_env() {
         temp_env::with_vars(
diff --git a/src/frontend/src/instance/builder.rs b/src/frontend/src/instance/builder.rs
index d261daed48e..144520ea11f 100644
--- a/src/frontend/src/instance/builder.rs
+++ b/src/frontend/src/instance/builder.rs
@@ -25,7 +25,7 @@ use common_base::Plugins;
 use common_datasource::object_store::LocalFileAccess;
 use common_event_recorder::{EventRecorderImpl, EventRecorderRef};
 use common_meta::cache::{LayeredCacheRegistryRef, TableFlownodeSetCacheRef, TableRouteCacheRef};
-use common_meta::cache_invalidator::{CacheInvalidatorRef, DummyCacheInvalidator};
+use common_meta::cache_invalidator::CacheInvalidatorRef;
 use common_meta::key::TableMetadataManager;
 use common_meta::key::flow::FlowMetadataManager;
 use common_meta::kv_backend::KvBackendRef;
@@ -45,6 +45,7 @@ use operator::statement::{
     StatementExecutor, StatementExecutorConfiguratorRef, StatementExecutorRef,
 };
 use operator::table::TableMutationOperator;
+use operator::write_dispatcher::WriteDispatcher;
 use partition::cache::PartitionInfoCacheRef;
 use partition::manager::PartitionRuleManager;
 use pipeline::pipeline_operator::PipelineOperator;
@@ -68,7 +69,7 @@ pub struct FrontendBuilder {
     options: FrontendOptions,
     kv_backend: KvBackendRef,
     layered_cache_registry: LayeredCacheRegistryRef,
-    local_cache_invalidator: Option<CacheInvalidatorRef>,
+    local_cache_invalidator: CacheInvalidatorRef,
     catalog_manager: CatalogManagerRef,
     node_manager: NodeManagerRef,
     plugins: Option<Plugins>,
@@ -78,6 +79,9 @@ pub struct FrontendBuilder {
 }
 
 impl FrontendBuilder {
+    /// Creates a frontend builder from its configuration and shared services.
+    ///
+    /// Uses the layered cache registry for local invalidation unless overridden.
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         options: FrontendOptions,
@@ -91,8 +95,8 @@ impl FrontendBuilder {
         Self {
             options,
             kv_backend,
+            local_cache_invalidator: layered_cache_registry.clone(),
             layered_cache_registry,
-            local_cache_invalidator: None,
             catalog_manager,
             node_manager,
             plugins: None,
@@ -138,9 +142,10 @@ impl FrontendBuilder {
         )
     }
 
+    /// Overrides the default local cache invalidator.
     pub fn with_local_cache_invalidator(self, cache_invalidator: CacheInvalidatorRef) -> Self {
         Self {
-            local_cache_invalidator: Some(cache_invalidator),
+            local_cache_invalidator: cache_invalidator,
             ..self
         }
     }
@@ -185,7 +190,11 @@ impl FrontendBuilder {
         }
     }
 
+    /// Validates configuration and assembles the frontend [`Instance`].
     pub async fn try_build(self) -> Result<Instance> {
+        if let Err(reason) = self.options.write_retry.validate() {
+            return error::InvalidWriteRetryConfigSnafu { reason }.fail();
+        }
         let kv_backend = self.kv_backend;
         let node_manager = self.node_manager;
         let plugins = self.plugins.unwrap_or_default();
@@ -208,9 +217,18 @@ impl FrontendBuilder {
             partition_info_cache.clone(),
         ));
 
-        let local_cache_invalidator = self
-            .local_cache_invalidator
-            .unwrap_or_else(|| Arc::new(DummyCacheInvalidator));
+        let local_cache_invalidator = self.local_cache_invalidator;
+
+        let mut write_dispatcher =
+            WriteDispatcher::new(node_manager.clone(), partition_manager.clone());
+        if self.options.write_retry.max_retries > 0 {
+            write_dispatcher = write_dispatcher.with_retry(
+                self.options.write_retry.clone(),
+                self.catalog_manager.clone(),
+                local_cache_invalidator.clone(),
+            );
+        }
+        let write_dispatcher = Arc::new(write_dispatcher);
 
         let region_query_handler =
             if let Some(factory) = plugins.get::<RegionQueryHandlerFactoryRef>() {
@@ -234,6 +252,7 @@ impl FrontendBuilder {
                 table_flownode_cache.clone(),
                 self.options.auto_create_table,
             )
+            .with_write_dispatcher(write_dispatcher.clone())
         };
         // The execution-only inserter owns no batchers, avoiding an Arc cycle.
         let bulk_inserter = Arc::new(create_inserter());
@@ -262,11 +281,14 @@ impl FrontendBuilder {
             create_inserter()
                 .with_pending_rows_batcher(build_batcher(self.options.table_batcher_options())),
         );
-        let deleter = Arc::new(Deleter::new(
-            self.catalog_manager.clone(),
-            partition_manager.clone(),
-            node_manager.clone(),
-        ));
+        let deleter = Arc::new(
+            Deleter::new(
+                self.catalog_manager.clone(),
+                partition_manager.clone(),
+                node_manager.clone(),
+            )
+            .with_write_dispatcher(write_dispatcher),
+        );
         let requester = Arc::new(Requester::new(
             self.catalog_manager.clone(),
             partition_manager.clone(),
@@ -409,3 +431,76 @@ impl FrontendBuilder {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use api::v1::meta::Role;
+    use common_meta::cache_invalidator::{Context, DummyCacheInvalidator};
+    use common_meta::instruction::CacheIdent;
+    use common_meta::key::table_route::{TableRouteKey, TableRouteValue};
+    use common_meta::key::{MetadataKey, MetadataValue};
+    use common_meta::rpc::router::{Region, RegionRoute};
+    use common_meta::rpc::store::PutRequest;
+    use meta_client::client::MetaClientBuilder;
+    use store_api::storage::RegionId;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test_local_cache_invalidator() {
+        for custom_invalidator in [false, true] {
+            let mut builder = FrontendBuilder::new_test(
+                &FrontendOptions::default(),
+                Arc::new(MetaClientBuilder::new(0, Role::Frontend).build()),
+            );
+            if custom_invalidator {
+                builder = builder.with_local_cache_invalidator(Arc::new(DummyCacheInvalidator));
+            }
+            let backend = builder.kv_backend.clone();
+            let routes: TableRouteCacheRef = builder.layered_cache_registry.get().unwrap();
+            let partitions: PartitionInfoCacheRef = builder.layered_cache_registry.get().unwrap();
+            let instance = builder.try_build().await.unwrap();
+            let table_id = 1024;
+            for region_number in [1, 2] {
+                let route = TableRouteValue::physical(vec![RegionRoute {
+                    region: Region {
+                        id: RegionId::new(table_id, region_number),
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                }]);
+                backend
+                    .put(
+                        PutRequest::new()
+                            .with_key(TableRouteKey::new(table_id).to_bytes())
+                            .with_value(route.try_as_raw_value().unwrap()),
+                    )
+                    .await
+                    .unwrap();
+                if region_number == 1 {
+                    routes.get(table_id).await.unwrap().unwrap();
+                    partitions.get(table_id).await.unwrap().unwrap();
+                }
+            }
+            assert!(routes.contains_key(&table_id));
+            assert!(partitions.contains_key(&table_id));
+
+            instance
+                .cache_invalidator()
+                .invalidate(&Context::default(), &[CacheIdent::TableId(table_id)])
+                .await
+                .unwrap();
+
+            assert_eq!(custom_invalidator, routes.contains_key(&table_id));
+            assert_eq!(custom_invalidator, partitions.contains_key(&table_id));
+            let route = routes.get(table_id).await.unwrap().unwrap();
+            let region = route.as_physical_table_route_ref().unwrap().region_routes[0]
+                .region
+                .id;
+            assert_eq!(
+                if custom_invalidator { 1 } else { 2 },
+                region.region_number()
+            );
+        }
+    }
+}
diff --git a/src/frontend/src/instance/logical_batcher.rs b/src/frontend/src/instance/logical_batcher.rs
index 255766ac14d..423f2996cae 100644
--- a/src/frontend/src/instance/logical_batcher.rs
+++ b/src/frontend/src/instance/logical_batcher.rs
@@ -48,6 +48,7 @@ impl Instance {
             LogicalTablePendingRowsBatcher::try_new(
                 self.partition_manager().clone(),
                 self.node_manager().clone(),
+                self.inserter.write_dispatcher().clone(),
                 self.catalog_manager().clone(),
                 self.table_flownode_set_cache().clone(),
                 true,
diff --git a/src/frontend/src/instance/otlp/trace_types.rs b/src/frontend/src/instance/otlp/trace_types.rs
index 0295d12e685..6f37f14e34a 100644
--- a/src/frontend/src/instance/otlp/trace_types.rs
+++ b/src/frontend/src/instance/otlp/trace_types.rs
@@ -519,31 +519,34 @@ mod tests {
         );
     }
 
-    /// The PHP instrumentation case: an empty string must be distinguishable
-    /// from any other unparsable value in the reported diagnostics.
+    /// The PHP instrumentation case: `getHeaderLine('Content-Length')` sends ""
+    /// when the header is absent. The span must be kept with a null attribute.
     #[test]
-    fn test_prepare_trace_column_rewrites_reports_empty_string_value() {
-        let rows = vec![Row {
-            values: vec![Value {
-                value_data: Some(ValueData::StringValue(String::new())),
+    fn test_prepare_trace_column_rewrites_nulls_empty_string_value() {
+        let mut rows = Rows {
+            schema: vec![ColumnSchema {
+                column_name: "span_attributes.http.response.body.size".to_string(),
+                datatype: ColumnDataType::String as i32,
+                ..Default::default()
             }],
-        }];
+            rows: vec![Row {
+                values: vec![Value {
+                    value_data: Some(ValueData::StringValue(String::new())),
+                }],
+            }],
+        };
         let pending_rewrites = vec![PendingTraceColumnRewrite {
             col_idx: 0,
             target_type: ColumnDataType::Int64,
             column_name: "span_attributes.http.response.body.size".to_string(),
         }];
 
-        let err = prepare_trace_column_rewrites(&rows, pending_rewrites, "opentelemetry_traces")
-            .unwrap_err();
-        assert!(
-            err.error.to_string().contains(
-                "'span_attributes.http.response.body.size' in table 'opentelemetry_traces' \
-                 from String(\"\") to Int64"
-            ),
-            "unexpected error message: {}",
-            err.error
-        );
+        prepare_trace_column_rewrites(&rows.rows, pending_rewrites, "opentelemetry_traces")
+            .unwrap()
+            .apply(&mut rows);
+
+        assert_eq!(rows.schema[0].datatype, ColumnDataType::Int64 as i32);
+        assert_eq!(rows.rows[0].values[0].value_data, None);
     }
 
     #[test]
diff --git a/src/frontend/src/service_config.rs b/src/frontend/src/service_config.rs
index 2c761c4242a..535ae9b655b 100644
--- a/src/frontend/src/service_config.rs
+++ b/src/frontend/src/service_config.rs
@@ -25,6 +25,7 @@ pub use influxdb::{InfluxdbMergeMode, InfluxdbOptions};
 pub use jaeger::JaegerOptions;
 pub use mysql::MysqlOptions;
 pub use opentsdb::OpentsdbOptions;
+pub use operator::write_dispatcher::WriteRetryOptions;
 pub use otlp::OtlpOptions;
 pub use pending_rows_batcher::{BatcherOptions, PendingRowsBatcherOptions};
 pub use postgres::PostgresOptions;
diff --git a/src/index/Cargo.toml b/src/index/Cargo.toml
index 078f9e42c56..3a62c016311 100644
--- a/src/index/Cargo.toml
+++ b/src/index/Cargo.toml
@@ -23,8 +23,6 @@ fst.workspace = true
 futures.workspace = true
 greptime-proto.workspace = true
 itertools.workspace = true
-jieba-rs = "0.10"
-lazy_static.workspace = true
 mockall.workspace = true
 pin-project.workspace = true
 prost.workspace = true
diff --git a/src/index/benches/index_build_bench.rs b/src/index/benches/index_build_bench.rs
index 4c6c3fac020..e5994400926 100644
--- a/src/index/benches/index_build_bench.rs
+++ b/src/index/benches/index_build_bench.rs
@@ -31,7 +31,7 @@ use index::bloom_filter::reader::BloomFilterReaderImpl;
 use index::external_provider::{ExternalTempFileProvider, Reader, Writer};
 use index::fulltext_index::Config;
 use index::fulltext_index::create::{BloomFilterFulltextIndexCreator, FulltextIndexCreator};
-use index::fulltext_index::tokenizer::{Analyzer, EnglishTokenizer};
+use index::fulltext_index::tokenizer::{Analyzer, ScriptTokenizer};
 use index::inverted_index::create::InvertedIndexCreator;
 use index::inverted_index::create::sort::external_sort::ExternalSorter;
 use index::inverted_index::create::sort_create::SortIndexCreator;
@@ -365,7 +365,7 @@ fn bench_bloom_search(c: &mut Criterion) {
     let mut group = c.benchmark_group("bloom_search");
 
     let lines = service_logs(ROWS * 10);
-    let analyzer = Analyzer::new(Box::new(EnglishTokenizer), false);
+    let analyzer = Analyzer::new(Box::new(ScriptTokenizer), false);
     let blob = rt.block_on(async {
         let mut creator = bloom_creator();
         for line in &lines {
diff --git a/src/index/benches/tokenizer_bench.rs b/src/index/benches/tokenizer_bench.rs
index f376fe57d78..12054906f37 100644
--- a/src/index/benches/tokenizer_bench.rs
+++ b/src/index/benches/tokenizer_bench.rs
@@ -21,7 +21,7 @@ use async_trait::async_trait;
 use criterion::{BatchSize, BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
 use futures::AsyncRead;
 use index::fulltext_index::create::{FulltextIndexCreator, TantivyFulltextIndexCreator};
-use index::fulltext_index::tokenizer::{ChineseTokenizer, EnglishTokenizer, Tokenizer};
+use index::fulltext_index::tokenizer::{ScriptTokenizer, Tokenizer};
 use index::fulltext_index::{Analyzer, Config};
 use puffin::puffin_manager::{PuffinWriter, PutOptions};
 
@@ -86,8 +86,8 @@ impl PuffinWriter for NoopPuffinWriter {
     }
 }
 
-fn bench_english_tokenizer(c: &mut Criterion) {
-    let tokenizer = EnglishTokenizer;
+fn bench_tokenizer_english_text(c: &mut Criterion) {
+    let tokenizer = ScriptTokenizer;
 
     let texts = vec![
         ("short", "Hello, world! This is a test."),
@@ -125,7 +125,7 @@ fn bench_english_tokenizer(c: &mut Criterion) {
         ),
     ];
 
-    let mut group = c.benchmark_group("english_tokenizer");
+    let mut group = c.benchmark_group("tokenizer_english_text");
 
     for (size, text) in texts {
         group.bench_with_input(BenchmarkId::new("tokenize", size), &text, |b, text| {
@@ -136,7 +136,7 @@ fn bench_english_tokenizer(c: &mut Criterion) {
     group.finish();
 
     // Benchmark with repeated tokenization to simulate real-world usage
-    let mut repeat_group = c.benchmark_group("english_tokenizer_repeated");
+    let mut repeat_group = c.benchmark_group("tokenizer_english_text_repeated");
 
     let sample_text = "The quick brown fox jumps over the lazy dog. This sentence contains most letters of the alphabet.";
 
@@ -157,9 +157,9 @@ fn bench_english_tokenizer(c: &mut Criterion) {
     repeat_group.finish();
 }
 
-fn bench_chinese_tokenizer(c: &mut Criterion) {
-    let tokenizer = ChineseTokenizer;
-    let mut group = c.benchmark_group("chinese_tokenizer");
+fn bench_tokenizer_chinese_text(c: &mut Criterion) {
+    let tokenizer = ScriptTokenizer;
+    let mut group = c.benchmark_group("tokenizer_chinese_text");
 
     for (name, text) in CHINESE_TOKENIZER_TEXTS {
         group.throughput(Throughput::Bytes(text.len() as u64));
@@ -170,7 +170,7 @@ fn bench_chinese_tokenizer(c: &mut Criterion) {
 
     group.finish();
 
-    let mut repeat_group = c.benchmark_group("chinese_tokenizer_repeated");
+    let mut repeat_group = c.benchmark_group("tokenizer_chinese_text_repeated");
     let sample_text = CHINESE_TOKENIZER_TEXTS
         .iter()
         .find(|(name, _)| *name == "mixed_log")
@@ -253,8 +253,8 @@ fn bench_tantivy_chinese_fulltext_index(c: &mut Criterion) {
 
 criterion_group!(
     benches,
-    bench_english_tokenizer,
-    bench_chinese_tokenizer,
+    bench_tokenizer_english_text,
+    bench_tokenizer_chinese_text,
     bench_tantivy_chinese_fulltext_index
 );
 criterion_main!(benches);
diff --git a/src/index/src/bloom_filter/creator.rs b/src/index/src/bloom_filter/creator.rs
index 83c0ae0c697..dc1dc54d289 100644
--- a/src/index/src/bloom_filter/creator.rs
+++ b/src/index/src/bloom_filter/creator.rs
@@ -270,8 +270,10 @@ mod tests {
     /// Converts a slice of bytes to a vector of `u64`.
     pub fn u64_vec_from_bytes(bytes: &[u8]) -> Vec<u64> {
         bytes
-            .chunks_exact(std::mem::size_of::<u64>())
-            .map(|chunk| u64::from_le_bytes(chunk.try_into().unwrap()))
+            .as_chunks::<{ std::mem::size_of::<u64>() }>()
+            .0
+            .iter()
+            .map(|chunk| u64::from_le_bytes(*chunk))
             .collect()
     }
 
diff --git a/src/index/src/fulltext_index/create/bloom_filter.rs b/src/index/src/fulltext_index/create/bloom_filter.rs
index a2db31418eb..a57fee93f84 100644
--- a/src/index/src/fulltext_index/create/bloom_filter.rs
+++ b/src/index/src/fulltext_index/create/bloom_filter.rs
@@ -29,7 +29,7 @@ use crate::fulltext_index::error::{
     AbortedSnafu, BiErrorsSnafu, BloomFilterFinishSnafu, ExternalSnafu, PuffinAddBlobSnafu, Result,
     SerializeToJsonSnafu,
 };
-use crate::fulltext_index::tokenizer::{Analyzer, ChineseTokenizer, EnglishTokenizer};
+use crate::fulltext_index::tokenizer::{Analyzer, ScriptTokenizer};
 use crate::fulltext_index::{Config, KEY_FULLTEXT_CONFIG};
 
 const PIPE_BUFFER_SIZE_FOR_SENDING_BLOB: usize = 8192;
@@ -50,11 +50,9 @@ impl BloomFilterFulltextIndexCreator {
         global_memory_usage: Arc<AtomicUsize>,
         global_memory_usage_threshold: Option<usize>,
     ) -> Self {
-        let tokenizer = match config.analyzer {
-            crate::fulltext_index::Analyzer::English => Box::new(EnglishTokenizer) as _,
-            crate::fulltext_index::Analyzer::Chinese => Box::new(ChineseTokenizer) as _,
-        };
-        let analyzer = Analyzer::new(tokenizer, config.case_sensitive);
+        // Both analyzers tokenize the same way: query probes must be derivable from the
+        // term alone, which a context-dependent segmenter like jieba can't provide.
+        let analyzer = Analyzer::new(Box::new(ScriptTokenizer), config.case_sensitive);
 
         let inner = BloomFilterCreator::new(
             rows_per_segment,
diff --git a/src/index/src/fulltext_index/tokenizer.rs b/src/index/src/fulltext_index/tokenizer.rs
index e6752a40420..c656fd181dc 100644
--- a/src/index/src/fulltext_index/tokenizer.rs
+++ b/src/index/src/fulltext_index/tokenizer.rs
@@ -12,121 +12,32 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use common_base::term_token::{self, has_irregular_lowercase};
+
 use crate::Bytes;
 use crate::bloom_filter::element_hash;
 use crate::fulltext_index::error::Result;
 
-lazy_static::lazy_static! {
-    static ref JIEBA: jieba_rs::Jieba = jieba_rs::Jieba::new();
-}
-
-/// A-Z, a-z, 0-9, and '_' are true
-const VALID_ASCII_TOKEN: [bool; 256] = [
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, true, true, true, true, true,
-    true, true, true, true, true, false, false, false, false, false, false, false, true, true,
-    true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true,
-    true, true, true, true, true, true, true, true, false, false, false, false, true, false, true,
-    true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true,
-    true, true, true, true, true, true, true, true, true, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false, false, false, false,
-    false, false, false, false, false, false, false, false, false, false,
-];
-
 /// `Tokenizer` tokenizes a text into a list of tokens.
 pub trait Tokenizer: Send {
     fn tokenize<'a>(&self, text: &'a str) -> Vec<&'a str>;
 }
 
-/// `EnglishTokenizer` tokenizes an English text.
-///
-/// It splits the text by non-alphabetic characters.
+/// `ScriptTokenizer` produces the tokens described in [`term_token::tokenize`].
 #[derive(Debug, Default)]
-pub struct EnglishTokenizer;
+pub struct ScriptTokenizer;
 
-impl Tokenizer for EnglishTokenizer {
+impl Tokenizer for ScriptTokenizer {
     fn tokenize<'a>(&self, text: &'a str) -> Vec<&'a str> {
-        if text.is_ascii() {
-            let mut tokens = Vec::new();
-            let mut start = 0;
-            for (i, &byte) in text.as_bytes().iter().enumerate() {
-                if !VALID_ASCII_TOKEN[byte as usize] {
-                    if start < i {
-                        tokens.push(&text[start..i]);
-                    }
-                    start = i + 1;
-                }
-            }
-
-            if start < text.len() {
-                tokens.push(&text[start..]);
-            }
-
-            tokens
-        } else {
-            text.split(|c: char| !c.is_alphanumeric() && c != '_')
-                .filter(|s| !s.is_empty())
-                .collect()
-        }
+        term_token::tokenize(text)
     }
 }
 
-/// `ChineseTokenizer` tokenizes a Chinese text.
-///
-/// It uses Jieba search-mode tokenization to improve recall for Chinese fulltext search.
-/// Enabling HMM also helps merge some unknown fragments into larger tokens, which can reduce
-/// token cardinality versus a fully fragmented output.
-#[derive(Debug, Default)]
-pub struct ChineseTokenizer;
-
-impl Tokenizer for ChineseTokenizer {
-    fn tokenize<'a>(&self, text: &'a str) -> Vec<&'a str> {
-        if text.is_ascii() {
-            EnglishTokenizer {}.tokenize(text)
-        } else {
-            // Search-mode tokenization emits finer-grained searchable terms, while HMM helps
-            // merge some unknown fragments and avoid excessive token fragmentation.
-            let mut tokens = JIEBA
-                .cut_for_search(text, true)
-                .into_iter()
-                .map(|token| token.word)
-                .filter(|token| is_indexable_token(token))
-                .collect::<Vec<_>>();
-
-            let english = EnglishTokenizer {};
-            tokens.extend(
-                english
-                    .tokenize(text)
-                    .into_iter()
-                    .filter(|token| is_ascii_underscore_token(token)),
-            );
-
-            tokens
-        }
-    }
-}
-
-fn is_indexable_token(token: &str) -> bool {
-    token.chars().any(|c| c.is_alphanumeric() || c == '_')
-}
-
-fn is_ascii_underscore_token(token: &str) -> bool {
-    token.is_ascii() && token.chars().any(|c| c == '_')
-}
-
 /// `Analyzer` analyzes a text into a list of tokens.
 ///
 /// It uses a `Tokenizer` to tokenize the text and optionally lowercases the tokens.
+/// When case-insensitive, it also emits the tokens of the whole lowercased text if
+/// they can differ, so that predicates on `lower(col)` can probe the index.
 pub struct Analyzer {
     tokenizer: Box<dyn Tokenizer>,
     case_sensitive: bool,
@@ -152,22 +63,36 @@ impl Analyzer {
         buf: &'a mut Vec<u8>,
     ) -> impl Iterator<Item = u64> + use<'a> {
         let case_sensitive = self.case_sensitive;
-        self.tokenizer.tokenize(text).into_iter().map(move |token| {
-            if case_sensitive {
-                element_hash(token.as_bytes())
-            } else if token.is_ascii() {
-                buf.clear();
-                buf.extend(token.bytes().map(|b| b.to_ascii_lowercase()));
-                element_hash(buf)
-            } else {
-                element_hash(token.to_lowercase().as_bytes())
-            }
-        })
+        let lowercased_text_hashes = self
+            .irregular_lowercased_text(text)
+            .map(|lowered| {
+                self.tokenizer
+                    .tokenize(&lowered)
+                    .into_iter()
+                    .map(|token| element_hash(token.as_bytes()))
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+        self.tokenizer
+            .tokenize(text)
+            .into_iter()
+            .map(move |token| {
+                if case_sensitive {
+                    element_hash(token.as_bytes())
+                } else if token.is_ascii() {
+                    buf.clear();
+                    buf.extend(token.bytes().map(|b| b.to_ascii_lowercase()));
+                    element_hash(buf)
+                } else {
+                    element_hash(token.to_lowercase().as_bytes())
+                }
+            })
+            .chain(lowercased_text_hashes)
     }
 
     /// Analyzes the given text into a list of tokens.
     pub fn analyze_text(&self, text: &str) -> Result<Vec<Bytes>> {
-        let res = self
+        let mut res = self
             .tokenizer
             .tokenize(text)
             .iter()
@@ -178,9 +103,22 @@ impl Analyzer {
                     s.to_lowercase().as_bytes().to_vec()
                 }
             })
-            .collect();
+            .collect::<Vec<_>>();
+        if let Some(lowered) = self.irregular_lowercased_text(text) {
+            res.extend(
+                self.tokenizer
+                    .tokenize(&lowered)
+                    .into_iter()
+                    .map(|token| token.as_bytes().to_vec()),
+            );
+        }
         Ok(res)
     }
+
+    /// Returns the lowercased text whose tokens must be indexed too, if any.
+    fn irregular_lowercased_text(&self, text: &str) -> Option<String> {
+        (!self.case_sensitive && has_irregular_lowercase(text)).then(|| text.to_lowercase())
+    }
 }
 
 #[cfg(test)]
@@ -190,12 +128,8 @@ mod tests {
     #[test]
     fn test_analyze_text_hashes_matches_analyze_text() {
         let text = "Hello, WORLD ship_Ship 清洁表面 ÄÖÜ straße İstanbul x";
-        for (tokenizer, case_sensitive) in [
-            (Box::new(EnglishTokenizer) as Box<dyn Tokenizer>, false),
-            (Box::new(EnglishTokenizer), true),
-            (Box::new(ChineseTokenizer), false),
-        ] {
-            let analyzer = Analyzer::new(tokenizer, case_sensitive);
+        for case_sensitive in [false, true] {
+            let analyzer = Analyzer::new(Box::new(ScriptTokenizer), case_sensitive);
             let expected = analyzer
                 .analyze_text(text)
                 .unwrap()
@@ -209,433 +143,13 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_english_tokenizer() {
-        let tokenizer = EnglishTokenizer;
-        let text = "Hello, world!!! This is a----++   test012_345+67890 ship_ship ship__ship _ __ __IDENTIFIER__ _ship ship_";
-        let tokens = tokenizer.tokenize(text);
-        assert_eq!(
-            tokens,
-            vec![
-                "Hello",
-                "world",
-                "This",
-                "is",
-                "a",
-                "test012_345",
-                "67890",
-                "ship_ship",
-                "ship__ship",
-                "_",
-                "__",
-                "__IDENTIFIER__",
-                "_ship",
-                "ship_"
-            ]
-        );
-    }
-
-    #[test]
-    fn test_english_tokenizer_with_utf8() {
-        let tokenizer = EnglishTokenizer;
-        let text = "💸unfold the 纸巾😣and gently 清洁表😭面";
-        let tokens = tokenizer.tokenize(text);
-        assert_eq!(
-            tokens,
-            // Don't care what happens to non-ASCII characters.
-            // It's kind of a misconfiguration to use EnglishTokenizer on non-ASCII text.
-            vec!["unfold", "the", "纸巾", "and", "gently", "清洁表", "面"]
-        );
-    }
-
-    #[test]
-    fn test_chinese_tokenizer() {
-        let tokenizer = ChineseTokenizer;
-        let text = "我喜欢苹果";
-        let tokens = tokenizer.tokenize(text);
-        assert_eq!(tokens, vec!["我", "喜欢", "苹果"]);
-    }
-
-    #[test]
-    fn test_chinese_tokenizer_issue_7943_sample() {
-        let tokenizer = ChineseTokenizer;
-        let text = "[2026/04/09/ 13:56:11.031]2026-04-09 13:56:11.031 - [ trace_id=340a6a44b0bd8e37bb7697ss7da61ff0 span_id=085ff5ttf1e0a23b trace_flags=01] - [http-nio-8081-exec-16] INFO c.h.p.xx.web.service.impl.CCCXForwardKKKServiceImpl.pushout(188) - 登录手机号18888888888的动态key：829889AC8 ship_ship ship__ship _ __ __IDENTIFIER__ _ship ship_ EOF";
-        let tokens = tokenizer.tokenize(text);
-
-        assert_eq!(
-            tokens,
-            vec![
-                "2026",
-                "04",
-                "09",
-                "13",
-                "56",
-                "11.031",
-                "2026-04",
-                "09",
-                "13",
-                "56",
-                "11.031",
-                "trace",
-                "_",
-                "id",
-                "340a6a44b0bd8e37bb7697ss7da61ff0",
-                "span",
-                "_",
-                "id",
-                "085ff5ttf1e0a23b",
-                "trace",
-                "_",
-                "flags",
-                "01",
-                "http",
-                "nio-8081",
-                "exec-16",
-                "INFO",
-                "c",
-                "h",
-                "p",
-                "xx",
-                "web",
-                "service",
-                "impl",
-                "CCCXForwardKKKServiceImpl",
-                "pushout",
-                "188",
-                "登录",
-                "手机",
-                "手机号",
-                "18888888888",
-                "的",
-                "动态",
-                "key",
-                "829889AC8",
-                "ship",
-                "_",
-                "ship",
-                "ship",
-                "__",
-                "ship",
-                "_",
-                "__",
-                "__",
-                "IDENTIFIER",
-                "__",
-                "_",
-                "ship",
-                "ship",
-                "_",
-                "EOF",
-                "trace_id",
-                "span_id",
-                "trace_flags",
-                "ship_ship",
-                "ship__ship",
-                "_",
-                "__",
-                "__IDENTIFIER__",
-                "_ship",
-                "ship_"
-            ]
-        );
-    }
-
-    #[test]
-    fn test_chinese_tokenizer_keeps_ascii_underscore_compounds() {
-        let tokenizer = ChineseTokenizer;
-        let text = "trace_id=abc 登录手机号 dynamic_key=xyz";
-
-        let tokens = tokenizer.tokenize(text);
-
-        assert!(tokens.contains(&"trace_id"));
-        assert!(tokens.contains(&"dynamic_key"));
-        assert!(tokens.contains(&"登录"));
-        assert!(tokens.contains(&"手机号"));
-    }
-
-    #[test]
-    fn test_chinese_tokenizer_skips_non_ascii_underscore_tokens() {
-        let tokenizer = ChineseTokenizer;
-        let text = "登录_id trace_id 手机号_trace";
-
-        let tokens = tokenizer.tokenize(text);
-
-        assert_eq!(
-            tokens,
-            [
-                "登录",
-                "_",
-                "id",
-                "trace",
-                "_",
-                "id",
-                "手机",
-                "手机号",
-                "_",
-                "trace",
-                "trace_id"
-            ]
-        );
-    }
-
-    #[test]
-    fn test_chinese_tokenizer_aggressive_tokenization_probe() {
-        let tokenizer = ChineseTokenizer;
-        let text = "哈基米哦南北绿豆，噢马自立曼波。登录手机号。中国农业银行。装电视台，中国中央广播电视台。压不缩，笑不活。";
-
-        let default_tokens = tokenizer.tokenize(text);
-        let cut_hmm_false = JIEBA
-            .cut(text, false)
-            .into_iter()
-            .map(|token| token.word)
-            .collect::<Vec<_>>();
-        let cut_hmm_true = JIEBA
-            .cut(text, true)
-            .into_iter()
-            .map(|token| token.word)
-            .collect::<Vec<_>>();
-        let cut_for_search_hmm_false = JIEBA
-            .cut_for_search(text, false)
-            .into_iter()
-            .map(|token| token.word)
-            .collect::<Vec<_>>();
-        let cut_for_search_hmm_true = JIEBA
-            .cut_for_search(text, true)
-            .into_iter()
-            .map(|token| token.word)
-            .collect::<Vec<_>>();
-
-        assert_eq!(
-            default_tokens,
-            [
-                "哈基米",
-                "哦",
-                "南北",
-                "绿豆",
-                "噢",
-                "马",
-                "自立",
-                "曼波",
-                "登录",
-                "手机",
-                "手机号",
-                "中国",
-                "农业",
-                "银行",
-                "中国农业银行",
-                "装",
-                "电视",
-                "电视台",
-                "中国",
-                "中央",
-                "广播",
-                "电视",
-                "电视台",
-                "不缩",
-                "压不缩",
-                "笑",
-                "不活",
-            ]
-        );
-        assert_eq!(
-            cut_hmm_false,
-            [
-                "哈",
-                "基",
-                "米",
-                "哦",
-                "南北",
-                "绿豆",
-                "，",
-                "噢",
-                "马",
-                "自立",
-                "曼",
-                "波",
-                "。",
-                "登录",
-                "手机号",
-                "。",
-                "中国农业银行",
-                "。",
-                "装",
-                "电视台",
-                "，",
-                "中国",
-                "中央",
-                "广播",
-                "电视台",
-                "。",
-                "压",
-                "不",
-                "缩",
-                "，",
-                "笑",
-                "不",
-                "活",
-                "。"
-            ]
-        );
-        assert_eq!(
-            cut_hmm_true,
-            [
-                "哈基米",
-                "哦",
-                "南北",
-                "绿豆",
-                "，",
-                "噢",
-                "马",
-                "自立",
-                "曼波",
-                "。",
-                "登录",
-                "手机号",
-                "。",
-                "中国农业银行",
-                "。",
-                "装",
-                "电视台",
-                "，",
-                "中国",
-                "中央",
-                "广播",
-                "电视台",
-                "。",
-                "压不缩",
-                "，",
-                "笑",
-                "不活",
-                "。"
-            ]
-        );
-        assert_eq!(
-            cut_for_search_hmm_false,
-            [
-                "哈",
-                "基",
-                "米",
-                "哦",
-                "南北",
-                "绿豆",
-                "，",
-                "噢",
-                "马",
-                "自立",
-                "曼",
-                "波",
-                "。",
-                "登录",
-                "手机",
-                "手机号",
-                "。",
-                "中国",
-                "农业",
-                "银行",
-                "中国农业银行",
-                "。",
-                "装",
-                "电视",
-                "电视台",
-                "，",
-                "中国",
-                "中央",
-                "广播",
-                "电视",
-                "电视台",
-                "。",
-                "压",
-                "不",
-                "缩",
-                "，",
-                "笑",
-                "不",
-                "活",
-                "。"
-            ]
-        );
-
-        assert_eq!(
-            cut_for_search_hmm_true,
-            [
-                "哈基米",
-                "哦",
-                "南北",
-                "绿豆",
-                "，",
-                "噢",
-                "马",
-                "自立",
-                "曼波",
-                "。",
-                "登录",
-                "手机",
-                "手机号",
-                "。",
-                "中国",
-                "农业",
-                "银行",
-                "中国农业银行",
-                "。",
-                "装",
-                "电视",
-                "电视台",
-                "，",
-                "中国",
-                "中央",
-                "广播",
-                "电视",
-                "电视台",
-                "。",
-                "不缩",
-                "压不缩",
-                "，",
-                "笑",
-                "不活",
-                "。"
-            ]
-        );
-    }
-
-    #[test]
-    fn test_valid_ascii_token_lookup_table() {
-        // Test all ASCII values in a single loop
-        for c in 0u8..=255u8 {
-            let is_valid = VALID_ASCII_TOKEN[c as usize];
-            let should_be_valid = (c as char).is_ascii_alphanumeric() || c == b'_';
-
-            assert_eq!(
-                is_valid,
-                should_be_valid,
-                "Character '{}' (byte {}) validity mismatch: expected {}, got {}",
-                if c.is_ascii() && !c.is_ascii_control() {
-                    c as char
-                } else {
-                    '?'
-                },
-                c,
-                should_be_valid,
-                is_valid
-            );
-        }
-    }
-
     #[test]
     fn test_analyzer() {
-        let tokenizer = EnglishTokenizer;
-        let analyzer = Analyzer::new(Box::new(tokenizer), false);
-        let text = "Hello, world! This is a test.";
-        let tokens = analyzer.analyze_text(text).unwrap();
+        let analyzer = Analyzer::new(Box::new(ScriptTokenizer), false);
+        let tokens = analyzer.analyze_text("Hello, World_Two").unwrap();
         assert_eq!(
             tokens,
-            vec![
-                b"hello".to_vec(),
-                b"world".to_vec(),
-                b"this".to_vec(),
-                b"is".to_vec(),
-                b"a".to_vec(),
-                b"test".to_vec()
-            ]
+            vec![b"hello".to_vec(), b"world".to_vec(), b"two".to_vec()]
         );
     }
 }
diff --git a/src/log-store/src/kafka/consumer.rs b/src/log-store/src/kafka/consumer.rs
index 8a7cba5a4b6..d064a9bc9ac 100644
--- a/src/log-store/src/kafka/consumer.rs
+++ b/src/log-store/src/kafka/consumer.rs
@@ -158,13 +158,10 @@ impl RecordsBuffer {
 impl RecordsBuffer {
     fn pop_front(&mut self) -> Option<RecordAndOffset> {
         while let Some(index) = self.index.peek() {
-            if let Some(record_and_offset) = self.buffer.pop_front() {
-                if index == record_and_offset.offset as u64 {
-                    self.index.next();
-                    return Some(record_and_offset);
-                }
-            } else {
-                return None;
+            let record_and_offset = self.buffer.pop_front()?;
+            if index == record_and_offset.offset as u64 {
+                self.index.next();
+                return Some(record_and_offset);
             }
         }
 
diff --git a/src/meta-client/src/client/heartbeat.rs b/src/meta-client/src/client/heartbeat.rs
index 96fc398556d..6dcc14c13f2 100644
--- a/src/meta-client/src/client/heartbeat.rs
+++ b/src/meta-client/src/client/heartbeat.rs
@@ -19,7 +19,7 @@ use std::time::Duration;
 use api::v1::meta::heartbeat_client::HeartbeatClient;
 use api::v1::meta::{HeartbeatRequest, HeartbeatResponse, RequestHeader, Role};
 use common_grpc::channel_manager::ChannelManager;
-use common_meta::distributed_time_constants::BASE_HEARTBEAT_INTERVAL;
+use common_meta::distributed_time_constants::{BASE_HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT};
 use common_meta::util;
 use common_telemetry::tracing_context::TracingContext;
 use common_telemetry::{info, warn};
@@ -249,17 +249,26 @@ impl Inner {
         })?;
         let receiver = ReceiverStream::new(receiver);
 
-        let mut stream = leader
-            .heartbeat(receiver)
-            .await
-            .map_err(error::Error::from)?
-            .into_inner();
+        let handshake = async {
+            let mut stream = leader
+                .heartbeat(receiver)
+                .await
+                .map_err(error::Error::from)?
+                .into_inner();
 
-        let res = stream
-            .message()
+            let res = stream
+                .message()
+                .await
+                .map_err(error::Error::from)?
+                .context(error::CreateHeartbeatStreamSnafu)?;
+            Ok::<_, error::Error>((stream, res))
+        };
+
+        let (stream, res) = tokio::time::timeout(HEARTBEAT_TIMEOUT, handshake)
             .await
-            .map_err(error::Error::from)?
-            .context(error::CreateHeartbeatStreamSnafu)?;
+            .with_context(|_| error::HeartbeatHandshakeTimeoutSnafu {
+                timeout: HEARTBEAT_TIMEOUT,
+            })??;
 
         let config = HeartbeatConfig::from_response(&res);
 
diff --git a/src/meta-client/src/error.rs b/src/meta-client/src/error.rs
index 4623cfee33b..e15c83be1d9 100644
--- a/src/meta-client/src/error.rs
+++ b/src/meta-client/src/error.rs
@@ -86,6 +86,15 @@ pub enum Error {
         location: Location,
     },
 
+    #[snafu(display("Heartbeat handshake timeout after {timeout:?}"))]
+    HeartbeatHandshakeTimeout {
+        timeout: std::time::Duration,
+        #[snafu(implicit)]
+        location: Location,
+        #[snafu(source)]
+        error: tokio::time::error::Elapsed,
+    },
+
     #[snafu(display("Invalid response header"))]
     InvalidResponseHeader {
         #[snafu(implicit)]
@@ -150,6 +159,7 @@ impl ErrorExt for Error {
             | Error::MissingQueryContext { .. }
             | Error::SendHeartbeat { .. }
             | Error::CreateHeartbeatStream { .. }
+            | Error::HeartbeatHandshakeTimeout { .. }
             | Error::CreateChannel { .. }
             | Error::RetryTimesExceeded { .. }
             | Error::ConvertMetaConfig { .. } => StatusCode::Internal,
@@ -168,6 +178,7 @@ impl ErrorExt for Error {
     fn retry_hint(&self) -> RetryHint {
         match self {
             Error::MetaServer { retry_hint, .. } => *retry_hint,
+            Error::HeartbeatHandshakeTimeout { .. } => RetryHint::Retryable,
             Error::InvalidResponseHeader { source, .. }
             | Error::ConvertMetaRequest { source, .. }
             | Error::ConvertMetaResponse { source, .. }
diff --git a/src/meta-client/tests/heartbeat_handshake_timeout.rs b/src/meta-client/tests/heartbeat_handshake_timeout.rs
new file mode 100644
index 00000000000..2ee43fa74d3
--- /dev/null
+++ b/src/meta-client/tests/heartbeat_handshake_timeout.rs
@@ -0,0 +1,140 @@
+// 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::pin::Pin;
+use std::time::Duration;
+
+use api::v1::meta::heartbeat_server::{Heartbeat, HeartbeatServer};
+use api::v1::meta::{
+    AskLeaderRequest, AskLeaderResponse, HeartbeatRequest, HeartbeatResponse, Peer, ResponseHeader,
+};
+use common_error::ext::{ErrorExt, RetryHint};
+use common_meta::distributed_time_constants::HEARTBEAT_TIMEOUT;
+use futures::Stream;
+use meta_client::error::Error;
+use meta_client::{MetaClientOptions, MetaClientRef, MetaClientType, create_meta_client};
+use tokio_stream::wrappers::TcpListenerStream;
+use tonic::codec::CompressionEncoding;
+use tonic::{Request, Response, Status, Streaming};
+
+type HeartbeatStream =
+    Pin<Box<dyn Stream<Item = Result<HeartbeatResponse, Status>> + Send + 'static>>;
+
+struct MockMetasrv {
+    addr: String,
+    send_first_heartbeat_response: bool,
+}
+
+#[async_trait::async_trait]
+impl Heartbeat for MockMetasrv {
+    type HeartbeatStream = HeartbeatStream;
+
+    async fn heartbeat(
+        &self,
+        request: Request<Streaming<HeartbeatRequest>>,
+    ) -> Result<Response<Self::HeartbeatStream>, Status> {
+        let send_first_heartbeat_response = self.send_first_heartbeat_response;
+        let stream = futures::stream::once(async move {
+            let mut request = request.into_inner();
+            request
+                .message()
+                .await?
+                .ok_or_else(|| Status::invalid_argument("missing heartbeat request"))?;
+
+            if send_first_heartbeat_response {
+                Ok(HeartbeatResponse::default())
+            } else {
+                futures::future::pending::<Result<HeartbeatResponse, Status>>().await
+            }
+        });
+        Ok(Response::new(Box::pin(stream)))
+    }
+
+    async fn ask_leader(
+        &self,
+        _request: Request<AskLeaderRequest>,
+    ) -> Result<Response<AskLeaderResponse>, Status> {
+        Ok(Response::new(AskLeaderResponse {
+            header: Some(ResponseHeader::default()),
+            leader: Some(Peer {
+                id: 1,
+                addr: self.addr.clone(),
+            }),
+        }))
+    }
+}
+
+async fn create_client(send_first_heartbeat_response: bool) -> MetaClientRef {
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let addr = listener.local_addr().unwrap();
+    let mock = MockMetasrv {
+        addr: addr.to_string(),
+        send_first_heartbeat_response,
+    };
+
+    tokio::spawn(async move {
+        let service = HeartbeatServer::new(mock)
+            .accept_compressed(CompressionEncoding::Gzip)
+            .accept_compressed(CompressionEncoding::Zstd)
+            .send_compressed(CompressionEncoding::Gzip)
+            .send_compressed(CompressionEncoding::Zstd);
+        tonic::transport::Server::builder()
+            .add_service(service)
+            .serve_with_incoming(TcpListenerStream::new(listener))
+            .await
+            .unwrap();
+    });
+
+    let options = MetaClientOptions {
+        metasrv_addrs: vec![addr.to_string()],
+        connect_timeout: Duration::from_millis(500),
+        ..Default::default()
+    };
+    create_meta_client(
+        MetaClientType::Datanode { member_id: 1 },
+        &options,
+        None,
+        None,
+    )
+    .await
+    .expect("the mock answers leader discovery")
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_heartbeat_handshake_succeeds_when_the_server_responds() {
+    let client = create_client(true).await;
+
+    tokio::time::timeout(HEARTBEAT_TIMEOUT, client.heartbeat())
+        .await
+        .expect("heartbeat handshake must complete before its deadline")
+        .expect("heartbeat handshake must succeed");
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_heartbeat_handshake_times_out_when_the_stream_stays_silent() {
+    let client = create_client(false).await;
+
+    let result = tokio::time::timeout(2 * HEARTBEAT_TIMEOUT, client.heartbeat())
+        .await
+        .expect("heartbeat handshake must be bounded");
+    let error = match result {
+        Ok(_) => panic!("a silent heartbeat stream must fail the handshake"),
+        Err(error) => error,
+    };
+    assert!(matches!(
+        &error,
+        Error::HeartbeatHandshakeTimeout { timeout, .. } if *timeout == HEARTBEAT_TIMEOUT
+    ));
+    assert_eq!(error.retry_hint(), RetryHint::Retryable);
+}
diff --git a/src/meta-srv/AGENTS.md b/src/meta-srv/AGENTS.md
index e1e23581525..5f9f573978c 100644
--- a/src/meta-srv/AGENTS.md
+++ b/src/meta-srv/AGENTS.md
@@ -38,7 +38,11 @@ abstraction, election, key encoding, and the DDL manager live in `common-meta`;
 
 - **Heartbeat**: `service/heartbeat.rs` receives datanode/frontend heartbeats and
   runs the handler chain in `handler/`; responses carry mailbox messages (DDL
-  results, cache invalidation).
+  results, cache invalidation). Node information is refreshed in memory on each
+  heartbeat. Datanode statistics collection and flownode remapping share
+  `handler/utils.rs` for per-node address persistence. Datanode address
+  updates retain the statistics handler's per-node ordering. Address epochs are
+  confirmed only after a successful save; cache invalidation remains best effort.
 - **DDL**: `service/procedure.rs` (`ddl`) is leader-only and hands off to
   `common-meta`'s `DdlManager`, executed via `common-procedure`.
 - **Region migration**: `procedure/region_migration/manager.rs` plus per-step
diff --git a/src/meta-srv/src/handler.rs b/src/meta-srv/src/handler.rs
index 320f26fae7c..24c1764db2a 100644
--- a/src/meta-srv/src/handler.rs
+++ b/src/meta-srv/src/handler.rs
@@ -81,6 +81,7 @@ pub mod publish_heartbeat_handler;
 pub mod region_lease_handler;
 pub mod remap_flow_peer_handler;
 pub mod response_header_handler;
+mod utils;
 
 #[cfg(test)]
 pub mod test_utils;
@@ -223,18 +224,50 @@ impl Pusher {
     }
 
     #[inline]
-    pub async fn push(&self, res: HeartbeatResponse) -> Result<()> {
-        self.sender.send(Ok(res)).await.map_err(|e| {
-            error::PushMessageSnafu {
-                err_msg: e.to_string(),
-            }
-            .build()
-        })
+    pub fn header(&self) -> ResponseHeader {
+        self.res_header.clone()
+    }
+}
+
+/// An owned snapshot of the [`Pusher`] fields the push paths need, so a caller can drop
+/// the [`Pushers`] read guard before awaiting the send. It must not hold a [`Pusher`]:
+/// dropping one fires the deregister signal, which reads as a closed channel.
+struct PusherHandle {
+    sender: Sender<std::result::Result<HeartbeatResponse, tonic::Status>>,
+    res_header: ResponseHeader,
+    deregister_signal_receiver: DeregisterSignalReceiver,
+}
+
+impl PusherHandle {
+    /// Snapshots `pusher`, which callers read under the [`Pushers`] guard.
+    fn from_pusher(pusher: &Pusher) -> Self {
+        Self {
+            sender: pusher.sender.clone(),
+            res_header: pusher.header(),
+            deregister_signal_receiver: pusher.deregister_signal_receiver.clone(),
+        }
+    }
+
+    /// Sends one mailbox message, consuming the handle.
+    async fn push(self, mailbox_message: MailboxMessage) -> Result<()> {
+        self.sender
+            .send(Ok(HeartbeatResponse {
+                header: Some(self.res_header),
+                mailbox_message: Some(mailbox_message),
+                ..Default::default()
+            }))
+            .await
+            .map_err(|e| {
+                error::PushMessageSnafu {
+                    err_msg: e.to_string(),
+                }
+                .build()
+            })
     }
 
     #[inline]
-    pub fn header(&self) -> ResponseHeader {
-        self.res_header.clone()
+    fn deregister_signal_receiver(&self) -> DeregisterSignalReceiver {
+        self.deregister_signal_receiver.clone()
     }
 }
 
@@ -248,41 +281,41 @@ impl Pushers {
         pusher_id: PusherId,
         mailbox_message: MailboxMessage,
     ) -> Result<DeregisterSignalReceiver> {
-        let pushers = self.0.read().await;
-        let pusher = pushers
-            .get(&pusher_id)
-            .with_context(|| error::PusherNotFoundSnafu {
-                pusher_id: pusher_id.to_string(),
-            })?;
+        // Releases the guard before the send below, which parks while the target's
+        // channel is full. `PusherNotFound` is still reported from inside the guard.
+        let handle = {
+            let pushers = self.0.read().await;
+            let pusher = pushers
+                .get(&pusher_id)
+                .with_context(|| error::PusherNotFoundSnafu {
+                    pusher_id: pusher_id.to_string(),
+                })?;
+            PusherHandle::from_pusher(pusher)
+        };
 
-        pusher
-            .push(HeartbeatResponse {
-                header: Some(pusher.header()),
-                mailbox_message: Some(mailbox_message),
-                ..Default::default()
-            })
-            .await?;
+        let deregister_signal_receiver = handle.deregister_signal_receiver();
+        handle.push(mailbox_message).await?;
 
-        Ok(pusher.deregister_signal_receiver.clone())
+        Ok(deregister_signal_receiver)
     }
 
     async fn broadcast(&self, role: Role, mailbox_message: &MailboxMessage) -> Result<()> {
-        let pushers = self.0.read().await;
-        let pushers = pushers
-            .range(PusherId::role_range(role))
-            .map(|(_, value)| value)
-            .collect::<Vec<_>>();
-        let mut results = Vec::with_capacity(pushers.len());
+        // Collects owned handles, releasing the guard before the sends below. Collecting
+        // `&Pusher` would hold it for the whole `join_all`.
+        let targets = {
+            let pushers = self.0.read().await;
+            pushers
+                .range(PusherId::role_range(role))
+                .map(|(_, pusher)| PusherHandle::from_pusher(pusher))
+                .collect::<Vec<_>>()
+        };
 
-        for pusher in pushers {
+        let mut results = Vec::with_capacity(targets.len());
+        for handle in targets {
             let mut mailbox_message = mailbox_message.clone();
             mailbox_message.id = 0; // one-way message
 
-            results.push(pusher.push(HeartbeatResponse {
-                header: Some(pusher.header()),
-                mailbox_message: Some(mailbox_message),
-                ..Default::default()
-            }))
+            results.push(handle.push(mailbox_message));
         }
 
         // Checks the error out of the loop.
@@ -923,14 +956,15 @@ mod tests {
     use std::sync::Arc;
     use std::time::Duration;
 
-    use api::v1::meta::{HeartbeatRequest, MailboxMessage, RequestHeader, Role};
+    use api::v1::meta::{HeartbeatRequest, HeartbeatResponse, MailboxMessage, RequestHeader, Role};
     use common_meta::kv_backend::memory::MemoryKvBackend;
     use common_meta::sequence::SequenceBuilder;
+    use futures::future::poll_immediate;
     use tokio::sync::mpsc;
 
     use super::{
         HandleControl, HeartbeatAccumulator, HeartbeatHandler, HeartbeatHandlerGroupBuilder,
-        PusherId, Pushers,
+        PusherHandle, PusherId, Pushers,
     };
     use crate::error;
     use crate::handler::collect_stats_handler::CollectStatsHandler;
@@ -1396,4 +1430,90 @@ mod tests {
         let extensions = res.extensions;
         assert_eq!(extensions.get("custom.key").unwrap(), b"custom-value");
     }
+
+    async fn full_pusher(
+        pushers: &Pushers,
+        id: PusherId,
+    ) -> mpsc::Receiver<std::result::Result<HeartbeatResponse, tonic::Status>> {
+        let (tx, rx) = mpsc::channel(1);
+        tx.try_send(Ok(HeartbeatResponse::default())).unwrap();
+        pushers.insert(id, Pusher::new(tx)).await;
+        // Callers keep `rx` alive: dropping it would make the send fail instead of park.
+        rx
+    }
+
+    fn test_mailbox_message(subject: &str) -> MailboxMessage {
+        MailboxMessage {
+            id: 0,
+            subject: subject.to_string(),
+            timestamp_millis: 123,
+            ..Default::default()
+        }
+    }
+
+    #[tokio::test]
+    async fn test_pushers_push_does_not_fence_the_registry() {
+        let pushers = Pushers::default();
+
+        let full_id = PusherId::new(Role::Datanode, 1);
+        let _full_rx = full_pusher(&pushers, full_id).await;
+
+        let (healthy_tx, mut healthy_rx) = mpsc::channel(1);
+        let healthy_id = PusherId::new(Role::Datanode, 2);
+        pushers.insert(healthy_id, Pusher::new(healthy_tx)).await;
+
+        let msg = test_mailbox_message("fence-test");
+
+        let mut parked = Box::pin(pushers.push(full_id, msg.clone()));
+        assert!(poll_immediate(parked.as_mut()).await.is_none());
+
+        let (writer_tx, _writer_rx) = mpsc::channel(1);
+        let mut writer =
+            Box::pin(pushers.insert(PusherId::new(Role::Datanode, 3), Pusher::new(writer_tx)));
+        assert!(poll_immediate(writer.as_mut()).await.is_some());
+
+        let mut healthy = Box::pin(pushers.push(healthy_id, msg));
+        assert!(poll_immediate(healthy.as_mut()).await.is_some());
+        assert!(healthy_rx.try_recv().is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_pushers_broadcast_does_not_fence_the_registry() {
+        let pushers = Pushers::default();
+
+        let _full_rx = full_pusher(&pushers, PusherId::new(Role::Datanode, 1)).await;
+        let (healthy_tx, _healthy_rx) = mpsc::channel(1);
+        pushers
+            .insert(PusherId::new(Role::Datanode, 2), Pusher::new(healthy_tx))
+            .await;
+
+        let msg = test_mailbox_message("broadcast-fence-test");
+        let mut parked = Box::pin(pushers.broadcast(Role::Datanode, &msg));
+        assert!(poll_immediate(parked.as_mut()).await.is_none());
+
+        let (writer_tx, _writer_rx) = mpsc::channel(1);
+        let mut writer =
+            Box::pin(pushers.insert(PusherId::new(Role::Flownode, 1), Pusher::new(writer_tx)));
+        assert!(poll_immediate(writer.as_mut()).await.is_some());
+    }
+
+    #[tokio::test]
+    async fn test_pusher_handle_does_not_fire_the_deregister_signal() {
+        let (tx, _rx) = mpsc::channel(1);
+        let pusher = Pusher::new(tx);
+        let mut signal = pusher.deregister_signal_receiver.clone();
+
+        let handle = PusherHandle::from_pusher(&pusher);
+        drop(handle);
+
+        assert!(
+            tokio::time::timeout(Duration::from_millis(100), signal.changed())
+                .await
+                .is_err()
+        );
+
+        // The real `Pusher` still owns the signal.
+        drop(pusher);
+        assert!(signal.changed().await.is_ok());
+    }
 }
diff --git a/src/meta-srv/src/handler/collect_cluster_info_handler.rs b/src/meta-srv/src/handler/collect_cluster_info_handler.rs
index 6bee86ad711..12fee395136 100644
--- a/src/meta-srv/src/handler/collect_cluster_info_handler.rs
+++ b/src/meta-srv/src/handler/collect_cluster_info_handler.rs
@@ -46,30 +46,21 @@ impl HeartbeatHandler for CollectFrontendClusterInfoHandler {
         ctx: &mut Context,
         _acc: &mut HeartbeatAccumulator,
     ) -> Result<HandleControl> {
-        let Some((key, peer, info, env_vars)) = extract_base_info(req) else {
+        let Some(update) = NodeInfoUpdate::from_request(req) else {
             return Ok(HandleControl::Continue);
         };
 
         let frontend_workloads = get_frontend_workloads(req.node_workloads.as_ref());
 
-        let value = NodeInfo {
-            peer,
-            last_activity_ts: common_time::util::current_time_millis(),
-            status: NodeStatus::Frontend(FrontendStatus {
-                workloads: frontend_workloads,
-            }),
-            version: info.version,
-            git_commit: info.git_commit,
-            start_time_ms: info.start_time_ms,
-            total_cpu_millicores: info.total_cpu_millicores,
-            total_memory_bytes: info.total_memory_bytes,
-            cpu_usage_millicores: info.cpu_usage_millicores,
-            memory_usage_bytes: info.memory_usage_bytes,
-            hostname: info.hostname,
-            env_vars,
-        };
-
-        put_into_memory_store(ctx, key, value).await?;
+        update
+            .save_to_memory(
+                ctx,
+                common_time::util::current_time_millis(),
+                NodeStatus::Frontend(FrontendStatus {
+                    workloads: frontend_workloads,
+                }),
+            )
+            .await?;
 
         Ok(HandleControl::Continue)
     }
@@ -89,29 +80,20 @@ impl HeartbeatHandler for CollectFlownodeClusterInfoHandler {
         ctx: &mut Context,
         _acc: &mut HeartbeatAccumulator,
     ) -> Result<HandleControl> {
-        let Some((key, peer, info, env_vars)) = extract_base_info(req) else {
+        let Some(update) = NodeInfoUpdate::from_request(req) else {
             return Ok(HandleControl::Continue);
         };
         let flownode_workloads = get_flownode_workloads(req.node_workloads.as_ref());
 
-        let value = NodeInfo {
-            peer,
-            last_activity_ts: common_time::util::current_time_millis(),
-            status: NodeStatus::Flownode(FlownodeStatus {
-                workloads: flownode_workloads,
-            }),
-            version: info.version,
-            git_commit: info.git_commit,
-            start_time_ms: info.start_time_ms,
-            total_cpu_millicores: info.total_cpu_millicores,
-            total_memory_bytes: info.total_memory_bytes,
-            cpu_usage_millicores: info.cpu_usage_millicores,
-            memory_usage_bytes: info.memory_usage_bytes,
-            hostname: info.hostname,
-            env_vars,
-        };
-
-        put_into_memory_store(ctx, key, value).await?;
+        update
+            .save_to_memory(
+                ctx,
+                common_time::util::current_time_millis(),
+                NodeStatus::Flownode(FlownodeStatus {
+                    workloads: flownode_workloads,
+                }),
+            )
+            .await?;
 
         Ok(HandleControl::Continue)
     }
@@ -132,7 +114,7 @@ impl HeartbeatHandler for CollectDatanodeClusterInfoHandler {
         ctx: &mut Context,
         acc: &mut HeartbeatAccumulator,
     ) -> Result<HandleControl> {
-        let Some((key, peer, info, env_vars)) = extract_base_info(req) else {
+        let Some(update) = NodeInfoUpdate::from_request(req) else {
             return Ok(HandleControl::Continue);
         };
 
@@ -147,16 +129,64 @@ impl HeartbeatHandler for CollectDatanodeClusterInfoHandler {
             .count();
         let follower_regions = stat.region_stats.len() - leader_regions;
 
-        let value = NodeInfo {
+        update
+            .save_to_memory(
+                ctx,
+                stat.timestamp_millis,
+                NodeStatus::Datanode(DatanodeStatus {
+                    rcus: stat.rcus,
+                    wcus: stat.wcus,
+                    leader_regions,
+                    follower_regions,
+                    workloads: stat.datanode_workloads.clone(),
+                }),
+            )
+            .await?;
+
+        Ok(HandleControl::Continue)
+    }
+}
+
+/// Common fields collected for one heartbeat's in-memory node information
+/// update. Persistent routing addresses have a separate lifecycle.
+struct NodeInfoUpdate {
+    key: NodeInfoKey,
+    peer: Peer,
+    info: PbNodeInfo,
+    env_vars: HashMap<String, String>,
+}
+
+impl NodeInfoUpdate {
+    fn from_request(request: &HeartbeatRequest) -> Option<Self> {
+        let key = NodeInfoKey::new(request)?;
+        let peer = request.peer.clone()?;
+        let info = request.info.clone()?;
+        let env_vars = EnvVars::from_extensions(&request.extensions)
+            .inspect_err(|e| {
+                warn!(e; "Failed to deserialize __env_vars from heartbeat extensions, peer: {}", peer);
+            })
+            .unwrap_or_default()
+            .map(|e| e.vars)
+            .unwrap_or_default();
+        Some(Self {
+            key,
             peer,
-            last_activity_ts: stat.timestamp_millis,
-            status: NodeStatus::Datanode(DatanodeStatus {
-                rcus: stat.rcus,
-                wcus: stat.wcus,
-                leader_regions,
-                follower_regions,
-                workloads: stat.datanode_workloads.clone(),
-            }),
+            info,
+            env_vars,
+        })
+    }
+
+    async fn save_to_memory(
+        self,
+        ctx: &Context,
+        last_activity_ts: i64,
+        status: NodeStatus,
+    ) -> Result<()> {
+        let info = self.info;
+        let value = NodeInfo {
+            peer: self.peer,
+            last_activity_ts,
+            status,
             version: info.version,
             git_commit: info.git_commit,
             start_time_ms: info.start_time_ms,
@@ -165,53 +195,88 @@ impl HeartbeatHandler for CollectDatanodeClusterInfoHandler {
             cpu_usage_millicores: info.cpu_usage_millicores,
             memory_usage_bytes: info.memory_usage_bytes,
             hostname: info.hostname,
-            env_vars,
+            env_vars: self.env_vars,
         };
-
-        put_into_memory_store(ctx, key, value).await?;
-
-        Ok(HandleControl::Continue)
+        let value = value.try_into().context(InvalidClusterInfoFormatSnafu)?;
+        ctx.in_memory
+            .put(PutRequest {
+                key: (&self.key).into(),
+                value,
+                ..Default::default()
+            })
+            .await
+            .context(SaveClusterInfoSnafu)?;
+        Ok(())
     }
 }
 
-fn extract_base_info(
-    request: &HeartbeatRequest,
-) -> Option<(NodeInfoKey, Peer, PbNodeInfo, HashMap<String, String>)> {
-    let HeartbeatRequest { peer, info, .. } = request;
-    let key = NodeInfoKey::new(request)?;
-    let Some(peer) = &peer else {
-        return None;
-    };
-    let Some(info) = &info else {
-        return None;
-    };
+#[cfg(test)]
+mod tests {
+    use api::v1::meta::RequestHeader;
+    use common_meta::datanode::Stat;
 
-    let env_vars = EnvVars::from_extensions(&request.extensions)
-        .inspect_err(|e| {
-            warn!(e;
-                "Failed to deserialize __env_vars from heartbeat extensions, peer: {}", peer
+    use super::*;
+    use crate::handler::test_utils::TestEnv;
+
+    #[tokio::test]
+    async fn test_node_info_refreshes_without_epoch_change() {
+        let mut ctx = TestEnv::new().ctx();
+        let handlers: Vec<(Role, Box<dyn HeartbeatHandler>)> = vec![
+            (Role::Frontend, Box::new(CollectFrontendClusterInfoHandler)),
+            (Role::Datanode, Box::new(CollectDatanodeClusterInfoHandler)),
+            (Role::Flownode, Box::new(CollectFlownodeClusterInfoHandler)),
+        ];
+        for (role, handler) in handlers {
+            let mut req = HeartbeatRequest {
+                header: Some(RequestHeader {
+                    role: role as i32,
+                    ..Default::default()
+                }),
+                peer: Some(Peer {
+                    id: 7,
+                    addr: "node:3001".into(),
+                }),
+                info: Some(PbNodeInfo {
+                    version: "v1".into(),
+                    hostname: "host".into(),
+                    ..Default::default()
+                }),
+                node_epoch: 10,
+                ..Default::default()
+            };
+            let mut acc = HeartbeatAccumulator {
+                stat: Some(Stat {
+                    timestamp_millis: 123,
+                    rcus: 5,
+                    wcus: 6,
+                    ..Default::default()
+                }),
+                ..Default::default()
+            };
+            handler.handle(&req, &mut ctx, &mut acc).await.unwrap();
+            let key: Vec<u8> = (&NodeInfoKey::new(&req).unwrap()).into();
+            let first =
+                NodeInfo::try_from(ctx.in_memory.get(&key).await.unwrap().unwrap().value).unwrap();
+            assert_eq!(first.peer, req.peer.clone().unwrap());
+            assert_eq!(first.version, "v1");
+            assert_eq!(first.hostname, "host");
+            req.info.as_mut().unwrap().version = "v2".into();
+            req.info.as_mut().unwrap().memory_usage_bytes = 42;
+            acc.stat.as_mut().unwrap().timestamp_millis = 456;
+            handler.handle(&req, &mut ctx, &mut acc).await.unwrap();
+            let second =
+                NodeInfo::try_from(ctx.in_memory.get(&key).await.unwrap().unwrap().value).unwrap();
+            assert_eq!(second.version, "v2");
+            assert_eq!(second.memory_usage_bytes, 42);
+            assert_eq!(
+                serde_json::to_value(&second.status).unwrap(),
+                serde_json::to_value(&first.status).unwrap()
             );
-        })
-        .unwrap_or_default()
-        .map(|e| e.vars)
-        .unwrap_or_default();
-
-    Some((key, peer.clone(), info.clone(), env_vars))
-}
-
-async fn put_into_memory_store(ctx: &mut Context, key: NodeInfoKey, value: NodeInfo) -> Result<()> {
-    let key = (&key).into();
-    let value = value.try_into().context(InvalidClusterInfoFormatSnafu)?;
-    let put_req = PutRequest {
-        key,
-        value,
-        ..Default::default()
-    };
-
-    ctx.in_memory
-        .put(put_req)
-        .await
-        .context(SaveClusterInfoSnafu)?;
-
-    Ok(())
+            if role == Role::Datanode {
+                assert_eq!(second.last_activity_ts, 456);
+            }
+            // Node information must not be persisted to the configured backend.
+            assert!(ctx.kv_backend.get(&key).await.unwrap().is_none());
+        }
+    }
 }
diff --git a/src/meta-srv/src/handler/collect_stats_handler.rs b/src/meta-srv/src/handler/collect_stats_handler.rs
index e3ae7ebe915..4b58beaf0fb 100644
--- a/src/meta-srv/src/handler/collect_stats_handler.rs
+++ b/src/meta-srv/src/handler/collect_stats_handler.rs
@@ -15,19 +15,19 @@
 use std::cmp::Ordering;
 use std::sync::Arc;
 
-use api::v1::meta::{HeartbeatRequest, Role};
+use api::v1::meta::{HeartbeatRequest, Peer, Role};
 use common_meta::datanode::{DatanodeStatKey, DatanodeStatValue, Stat};
 use common_meta::instruction::CacheIdent;
-use common_meta::key::node_address::{NodeAddressKey, NodeAddressValue};
-use common_meta::key::{MetadataKey, MetadataValue};
-use common_meta::peer::Peer;
+use common_meta::key::MetadataKey;
+use common_meta::key::node_address::NodeAddressKey;
 use common_meta::rpc::store::PutRequest;
-use common_telemetry::{error, info, warn};
+use common_telemetry::{error, warn};
 use dashmap::DashMap;
 use snafu::ResultExt;
 use tokio::sync::Mutex;
 
 use crate::error::{self, Result};
+use crate::handler::utils::{self, NodeAddressUpdater};
 use crate::handler::{HandleControl, HeartbeatAccumulator, HeartbeatHandler};
 use crate::metasrv::Context;
 
@@ -40,7 +40,7 @@ struct EpochStats {
 impl EpochStats {
     #[inline]
     fn drain_all(&mut self) -> Vec<Stat> {
-        self.stats.drain(..).collect()
+        std::mem::take(&mut self.stats)
     }
 
     #[inline]
@@ -74,6 +74,7 @@ const DEFAULT_FLUSH_STATS_FACTOR: usize = 3;
 pub struct CollectStatsHandler {
     stats_cache: DashMap<DatanodeStatKey, Arc<Mutex<EpochStats>>>,
     flush_stats_factor: usize,
+    address_updater: NodeAddressUpdater,
 }
 
 impl Default for CollectStatsHandler {
@@ -87,6 +88,7 @@ impl CollectStatsHandler {
         Self {
             flush_stats_factor: flush_stats_factor.unwrap_or(DEFAULT_FLUSH_STATS_FACTOR),
             stats_cache: DashMap::default(),
+            address_updater: NodeAddressUpdater::default(),
         }
     }
 }
@@ -119,6 +121,7 @@ impl HeartbeatHandler for CollectStatsHandler {
 
         let key: Vec<u8> = key.into();
 
+        let current_epoch = current_stat.node_epoch;
         let refresh = if let Some(epoch) = epoch_stats.epoch() {
             match current_stat.node_epoch.cmp(&epoch) {
                 Ordering::Greater => {
@@ -146,11 +149,13 @@ impl HeartbeatHandler for CollectStatsHandler {
             true
         };
 
-        // Need to refresh the [datanode -> address] mapping
-        if refresh {
-            // Safety: `epoch_stats.stats` is not empty
-            let last = epoch_stats.stats.last().unwrap();
-            rewrite_node_address(ctx, last).await;
+        // Keep address updates and statistics in the original per-node order.
+        // Address acknowledgement is independent of the statistics epoch so a
+        // failed save can be retried by the next heartbeat of the same epoch.
+        if epoch_stats.epoch() == Some(current_epoch)
+            && let Some(stat) = epoch_stats.stats.last()
+        {
+            update_datanode_address(&self.address_updater, ctx, stat).await;
         }
 
         if !refresh && epoch_stats.len() < self.flush_stats_factor {
@@ -178,48 +183,26 @@ impl HeartbeatHandler for CollectStatsHandler {
     }
 }
 
-async fn rewrite_node_address(ctx: &Context, stat: &Stat) {
-    let peer = Peer {
-        id: stat.id,
-        addr: stat.addr.clone(),
-    };
-    let key = NodeAddressKey::with_datanode(peer.id).to_bytes();
-    if let Ok(value) = NodeAddressValue::new(peer.clone()).try_as_raw_value() {
-        let put = PutRequest {
-            key,
-            value,
-            prev_kv: false,
-        };
-
-        match ctx.leader_cached_kv_backend.put(put).await {
-            Ok(_) => {
-                info!(
-                    "Successfully updated datanode `NodeAddressValue`: {:?}",
-                    peer
-                );
-                // broadcast invalidating cache
-                let cache_idents = stat
-                    .table_ids()
-                    .into_iter()
-                    .map(CacheIdent::TableId)
-                    .collect::<Vec<_>>();
-                if let Err(e) = ctx
-                    .cache_invalidator
-                    .invalidate(&Default::default(), &cache_idents)
-                    .await
-                {
-                    error!(e; "Failed to invalidate {} `NodeAddressKey` cache, peer: {:?}", cache_idents.len(), peer);
-                }
-            }
-            Err(e) => {
-                error!(e; "Failed to update datanode `NodeAddressValue`: {:?}", peer);
-            }
-        }
-    } else {
-        warn!(
-            "Failed to serialize datanode `NodeAddressValue`: {:?}",
-            peer
-        );
+/// Applies datanode-specific address and table-cache updates. The caller keeps
+/// its statistics lock so notifications and statistics retain their ordering.
+async fn update_datanode_address(updater: &NodeAddressUpdater, ctx: &Context, stat: &Stat) {
+    let updated = updater
+        .update_if_needed((Role::Datanode, stat.id), stat.node_epoch, || async {
+            let peer = Peer { id: stat.id, addr: stat.addr.clone() };
+            let key = NodeAddressKey::with_datanode(stat.id).to_bytes();
+            utils::save_node_address(ctx, key, peer).await
+        })
+        .await
+        .inspect_err(|e| {
+            error!(e; "Failed to update datanode address, node: {}, address: {}", stat.id, stat.addr);
+        });
+    if let Ok(true) = updated {
+        let cache_idents = stat
+            .table_ids()
+            .into_iter()
+            .map(CacheIdent::TableId)
+            .collect::<Vec<_>>();
+        utils::invalidate_address_caches(ctx, stat.id, &cache_idents).await;
     }
 }
 
@@ -553,4 +536,126 @@ mod tests {
             handler.handle(&req, &mut ctx, &mut acc).await.unwrap();
         }
     }
+
+    #[tokio::test]
+    async fn test_persistence_failure_retries_but_notification_failure_does_not() {
+        use crate::handler::collect_stats_handler::CollectStatsHandler;
+        use crate::handler::test_utils::FailingCacheInvalidator;
+        use crate::handler::{HandleControl, HeartbeatAccumulator, HeartbeatHandler};
+        use crate::service::store::cached_kv::LeaderCachedKvBackend;
+        use api::v1::meta::HeartbeatRequest;
+        use common_meta::key::MetadataValue;
+        use common_meta::key::node_address::NodeAddressValue;
+        use common_meta::kv_backend::test_util::MockKvBackendBuilder;
+        use common_meta::rpc::store::PutResponse;
+        let mut ctx = TestEnv::new().ctx();
+        let puts = Arc::new(std::sync::Mutex::new(Vec::<PutRequest>::new()));
+        let backend = MockKvBackendBuilder::default()
+            .put_fn(Arc::new({
+                let puts = puts.clone();
+                move |req: PutRequest| {
+                    let mut puts = puts.lock().unwrap();
+                    puts.push(req);
+                    if puts.len() == 1 {
+                        return common_meta::error::UnexpectedSnafu {
+                            err_msg: "injected persistence failure",
+                        }
+                        .fail();
+                    }
+                    Ok(PutResponse::default())
+                }
+            }) as _)
+            .build()
+            .unwrap();
+        ctx.leader_cached_kv_backend =
+            Arc::new(LeaderCachedKvBackend::with_always_leader(Arc::new(backend)));
+        let invalidator = Arc::new(FailingCacheInvalidator::default());
+        ctx.cache_invalidator = invalidator.clone();
+        let handler = CollectStatsHandler::default();
+        let mut stat = Stat {
+            id: 101,
+            addr: "dn-original".into(),
+            node_epoch: 7,
+            ..Default::default()
+        };
+        let req = HeartbeatRequest::default();
+
+        // A backend error must not interrupt subsequent heartbeat handlers.
+        assert!(matches!(
+            handler
+                .handle(
+                    &req,
+                    &mut ctx,
+                    &mut HeartbeatAccumulator {
+                        stat: Some(stat.clone()),
+                        ..Default::default()
+                    }
+                )
+                .await
+                .unwrap(),
+            HandleControl::Continue
+        ));
+        assert_eq!(puts.lock().unwrap().len(), 1);
+        assert_eq!(invalidator.attempts(), 0);
+
+        let stats_key: Vec<u8> = common_meta::datanode::DatanodeStatKey { node_id: 101 }.into();
+        assert!(ctx.in_memory.get(&stats_key).await.unwrap().is_some());
+
+        // Same epoch retries persistence using the current heartbeat's address.
+        stat.addr = "dn-retry".into();
+        handler
+            .handle(
+                &req,
+                &mut ctx,
+                &mut HeartbeatAccumulator {
+                    stat: Some(stat.clone()),
+                    ..Default::default()
+                },
+            )
+            .await
+            .unwrap();
+        {
+            let puts = puts.lock().unwrap();
+            assert_eq!(puts.len(), 2);
+            assert_eq!(puts[1].key, NodeAddressKey::with_datanode(101).to_bytes());
+            assert_eq!(
+                NodeAddressValue::try_from_raw_value(&puts[1].value)
+                    .unwrap()
+                    .peer
+                    .addr,
+                "dn-retry"
+            );
+        }
+        assert_eq!(invalidator.attempts(), 1);
+
+        // Notification remains best-effort: its failure neither rewrites nor retries.
+        handler
+            .handle(
+                &req,
+                &mut ctx,
+                &mut HeartbeatAccumulator {
+                    stat: Some(stat.clone()),
+                    ..Default::default()
+                },
+            )
+            .await
+            .unwrap();
+        assert_eq!(puts.lock().unwrap().len(), 2);
+        assert_eq!(invalidator.attempts(), 1);
+
+        stat.node_epoch = 8;
+        handler
+            .handle(
+                &req,
+                &mut ctx,
+                &mut HeartbeatAccumulator {
+                    stat: Some(stat.clone()),
+                    ..Default::default()
+                },
+            )
+            .await
+            .unwrap();
+        assert_eq!(puts.lock().unwrap().len(), 3);
+        assert_eq!(invalidator.attempts(), 2);
+    }
 }
diff --git a/src/meta-srv/src/handler/failure_handler.rs b/src/meta-srv/src/handler/failure_handler.rs
index 5f1448d3ab6..d1d287d13ff 100644
--- a/src/meta-srv/src/handler/failure_handler.rs
+++ b/src/meta-srv/src/handler/failure_handler.rs
@@ -52,9 +52,10 @@ impl HeartbeatHandler for RegionFailureHandler {
             return Ok(HandleControl::Continue);
         };
 
+        // Never blocks: the region lease has already been decided earlier in the
+        // chain, so a busy supervisor must not withhold the heartbeat response.
         self.heartbeat_acceptor
-            .accept(DatanodeHeartbeat::from(stat))
-            .await;
+            .accept(DatanodeHeartbeat::from(stat));
 
         Ok(HandleControl::Continue)
     }
@@ -62,6 +63,8 @@ impl HeartbeatHandler for RegionFailureHandler {
 
 #[cfg(test)]
 mod tests {
+    use std::time::Duration;
+
     use api::v1::meta::HeartbeatRequest;
     use common_catalog::consts::default_engine;
     use common_meta::datanode::{RegionManifestInfo, RegionStat, Stat};
@@ -73,7 +76,45 @@ mod tests {
     use crate::handler::{HeartbeatAccumulator, HeartbeatHandler};
     use crate::metasrv::builder::MetasrvBuilder;
     use crate::region::supervisor::tests::new_test_supervisor;
-    use crate::region::supervisor::{Event, HeartbeatAcceptor};
+    use crate::region::supervisor::{DatanodeHeartbeat, Event, HeartbeatAcceptor};
+
+    fn new_region_stat(region_id: u64) -> RegionStat {
+        RegionStat {
+            id: RegionId::from_u64(region_id),
+            rcus: 0,
+            wcus: 0,
+            approximate_bytes: 0,
+            engine: default_engine().to_string(),
+            role: RegionRole::Follower,
+            num_rows: 0,
+            memtable_size: 0,
+            manifest_size: 0,
+            sst_size: 0,
+            sst_num: 0,
+            index_size: 0,
+            region_manifest: RegionManifestInfo::Mito {
+                manifest_version: 0,
+                flushed_entry_id: 0,
+                file_removed_cnt: 0,
+            },
+            data_topic_latest_entry_id: 0,
+            metadata_topic_latest_entry_id: 0,
+            written_bytes: 0,
+            query_cpu_time: 0,
+            query_scanned_bytes: 0,
+            min_timestamp: None,
+            max_timestamp: None,
+        }
+    }
+
+    fn new_stat() -> Stat {
+        Stat {
+            id: 42,
+            region_stats: vec![new_region_stat(1), new_region_stat(2), new_region_stat(3)],
+            timestamp_millis: 1000,
+            ..Default::default()
+        }
+    }
 
     #[tokio::test]
     async fn test_handle_heartbeat() {
@@ -85,40 +126,7 @@ mod tests {
         let metasrv = builder.build().await.unwrap();
         let mut ctx = metasrv.new_ctx();
         let acc = &mut HeartbeatAccumulator::default();
-        fn new_region_stat(region_id: u64) -> RegionStat {
-            RegionStat {
-                id: RegionId::from_u64(region_id),
-                rcus: 0,
-                wcus: 0,
-                approximate_bytes: 0,
-                engine: default_engine().to_string(),
-                role: RegionRole::Follower,
-                num_rows: 0,
-                memtable_size: 0,
-                manifest_size: 0,
-                sst_size: 0,
-                sst_num: 0,
-                index_size: 0,
-                region_manifest: RegionManifestInfo::Mito {
-                    manifest_version: 0,
-                    flushed_entry_id: 0,
-                    file_removed_cnt: 0,
-                },
-                data_topic_latest_entry_id: 0,
-                metadata_topic_latest_entry_id: 0,
-                written_bytes: 0,
-                query_cpu_time: 0,
-                query_scanned_bytes: 0,
-                min_timestamp: None,
-                max_timestamp: None,
-            }
-        }
-        acc.stat = Some(Stat {
-            id: 42,
-            region_stats: vec![new_region_stat(1), new_region_stat(2), new_region_stat(3)],
-            timestamp_millis: 1000,
-            ..Default::default()
-        });
+        acc.stat = Some(new_stat());
 
         handler.handle(req, &mut ctx, acc).await.unwrap();
         let (tx, rx) = oneshot::channel();
@@ -126,4 +134,39 @@ mod tests {
         let detector = rx.await.unwrap();
         assert_eq!(detector.iter().collect::<Vec<_>>().len(), 3);
     }
+
+    #[tokio::test]
+    async fn test_handle_heartbeat_does_not_block_on_full_supervisor_queue() {
+        // Regression test for #9419: a full queue used to park the handler.
+        // Keep the supervisor alive, or the queue reports Closed.
+        let (_supervisor, sender) = new_test_supervisor();
+        // Built directly, so the supervisor stays undrained.
+        let handler = RegionFailureHandler {
+            heartbeat_acceptor: HeartbeatAcceptor::new(sender.clone()),
+        };
+
+        let stat = new_stat();
+        let mut queued = 0;
+        while sender
+            .try_send(Event::HeartbeatArrived(DatanodeHeartbeat::from(&stat)))
+            .is_ok()
+        {
+            queued += 1;
+        }
+        assert_eq!(queued, sender.max_capacity());
+
+        let builder = MetasrvBuilder::new();
+        let metasrv = builder.build().await.unwrap();
+        let mut ctx = metasrv.new_ctx();
+        let acc = &mut HeartbeatAccumulator::default();
+        // Without a stat the handler returns before the acceptor.
+        acc.stat = Some(stat);
+
+        let result = tokio::time::timeout(
+            Duration::from_secs(5),
+            handler.handle(&HeartbeatRequest::default(), &mut ctx, acc),
+        )
+        .await;
+        assert!(result.is_ok());
+    }
 }
diff --git a/src/meta-srv/src/handler/remap_flow_peer_handler.rs b/src/meta-srv/src/handler/remap_flow_peer_handler.rs
index f6b3c67a9e5..186cefa19e8 100644
--- a/src/meta-srv/src/handler/remap_flow_peer_handler.rs
+++ b/src/meta-srv/src/handler/remap_flow_peer_handler.rs
@@ -12,22 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use api::v1::meta::{HeartbeatRequest, Peer, Role};
+use api::v1::meta::{HeartbeatRequest, Role};
 use common_meta::instruction::CacheIdent;
-use common_meta::key::node_address::{NodeAddressKey, NodeAddressValue};
-use common_meta::key::{MetadataKey, MetadataValue};
-use common_meta::rpc::store::PutRequest;
-use common_telemetry::{error, info, warn};
-use dashmap::DashMap;
+use common_meta::key::MetadataKey;
+use common_meta::key::node_address::NodeAddressKey;
+use common_telemetry::error;
 
 use crate::Result;
+use crate::handler::utils::{self, NodeAddressUpdater};
 use crate::handler::{HandleControl, HeartbeatAccumulator, HeartbeatHandler};
 use crate::metasrv::Context;
 
 #[derive(Debug, Default)]
 pub struct RemapFlowPeerHandler {
-    /// flow_node_id -> epoch
-    epoch_cache: DashMap<u64, u64>,
+    address_updater: NodeAddressUpdater,
 }
 
 #[async_trait::async_trait]
@@ -45,61 +43,83 @@ impl HeartbeatHandler for RemapFlowPeerHandler {
         let Some(peer) = req.peer.as_ref() else {
             return Ok(HandleControl::Continue);
         };
-
-        let current_epoch = req.node_epoch;
-        let flow_node_id = peer.id;
-
-        let refresh = if let Some(mut epoch) = self.epoch_cache.get_mut(&flow_node_id) {
-            if current_epoch > *epoch.value() {
-                *epoch.value_mut() = current_epoch;
-                true
-            } else {
-                false
-            }
-        } else {
-            self.epoch_cache.insert(flow_node_id, current_epoch);
-            true
-        };
-
-        if refresh {
-            rewrite_node_address(ctx, peer).await;
+        let updated = self
+            .address_updater
+            .update_if_needed((Role::Flownode, peer.id), req.node_epoch, || {
+                let key = NodeAddressKey::with_flownode(peer.id).to_bytes();
+                utils::save_node_address(ctx, key, peer.clone())
+            })
+            .await
+            .inspect_err(|e| {
+                // Address errors must not prevent later heartbeat handlers from running.
+                error!(e; "Failed to update flownode address, peer: {:?}", peer);
+            });
+        if let Ok(true) = updated {
+            let cache_idents = [CacheIdent::FlowNodeAddressChange(peer.id)];
+            utils::invalidate_address_caches(ctx, peer.id, &cache_idents).await;
         }
-
         Ok(HandleControl::Continue)
     }
 }
 
-async fn rewrite_node_address(ctx: &mut Context, peer: &Peer) {
-    let key = NodeAddressKey::with_flownode(peer.id).to_bytes();
-    if let Ok(value) = NodeAddressValue::new(peer.clone()).try_as_raw_value() {
-        let put = PutRequest {
-            key,
-            value,
-            prev_kv: false,
-        };
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::handler::test_utils::TestEnv;
+    use api::v1::meta::Peer;
+    use std::sync::Arc;
+    #[tokio::test]
+    async fn test_notification_failure_keeps_persisted_epoch() {
+        use crate::handler::{HeartbeatAccumulator, HeartbeatHandler};
+        use api::v1::meta::HeartbeatRequest;
 
-        match ctx.leader_cached_kv_backend.put(put).await {
-            Ok(_) => {
-                info!("Successfully updated flow `NodeAddressValue`: {:?}", peer);
-                // broadcast invalidating cache to all frontends
-                let cache_idents = vec![CacheIdent::FlowNodeAddressChange(peer.id)];
-                info!(
-                    "Invalidate flow node cache for new address with cache idents: {:?}",
-                    cache_idents
-                );
-                if let Err(e) = ctx
-                    .cache_invalidator
-                    .invalidate(&Default::default(), &cache_idents)
-                    .await
-                {
-                    error!(e; "Failed to invalidate {} `NodeAddressKey` cache, peer: {:?}", cache_idents.len(), peer);
-                }
-            }
-            Err(e) => {
-                error!(e; "Failed to update flow `NodeAddressValue`: {:?}", peer);
-            }
-        }
-    } else {
-        warn!("Failed to serialize flow `NodeAddressValue`: {:?}", peer);
+        use crate::handler::test_utils::FailingCacheInvalidator;
+        use common_meta::key::MetadataValue;
+        use common_meta::key::node_address::NodeAddressValue;
+        let mut ctx = TestEnv::new().ctx();
+        let invalidator = Arc::new(FailingCacheInvalidator::default());
+        ctx.cache_invalidator = invalidator.clone();
+        let handler = RemapFlowPeerHandler::default();
+        let mut req = HeartbeatRequest {
+            peer: Some(Peer {
+                id: 1,
+                addr: "first".into(),
+            }),
+            node_epoch: 1,
+            ..Default::default()
+        };
+        let key = NodeAddressKey::with_flownode(1).to_bytes();
+        handler
+            .handle(&req, &mut ctx, &mut HeartbeatAccumulator::default())
+            .await
+            .unwrap();
+        req.peer.as_mut().unwrap().addr = "same-epoch".into();
+        handler
+            .handle(&req, &mut ctx, &mut HeartbeatAccumulator::default())
+            .await
+            .unwrap();
+        assert_eq!(invalidator.attempts(), 1);
+        let kv = ctx.kv_backend.get(&key).await.unwrap().unwrap();
+        assert_eq!(
+            NodeAddressValue::try_from_raw_value(&kv.value)
+                .unwrap()
+                .peer
+                .addr,
+            "first"
+        );
+        req.node_epoch = 2;
+        handler
+            .handle(&req, &mut ctx, &mut HeartbeatAccumulator::default())
+            .await
+            .unwrap();
+        assert_eq!(invalidator.attempts(), 2);
+        let kv = ctx.kv_backend.get(&key).await.unwrap().unwrap();
+        assert_eq!(
+            NodeAddressValue::try_from_raw_value(&kv.value)
+                .unwrap()
+                .peer
+                .addr,
+            "same-epoch"
+        );
     }
 }
diff --git a/src/meta-srv/src/handler/test_utils.rs b/src/meta-srv/src/handler/test_utils.rs
index d8241c785ea..c2afb3cb14a 100644
--- a/src/meta-srv/src/handler/test_utils.rs
+++ b/src/meta-srv/src/handler/test_utils.rs
@@ -13,9 +13,13 @@
 // limitations under the License.
 
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
-use common_meta::cache_invalidator::{CacheInvalidatorRef, DummyCacheInvalidator};
+use common_meta::cache_invalidator::{
+    CacheInvalidator, CacheInvalidatorRef, Context as InvalidationContext, DummyCacheInvalidator,
+};
 use common_meta::distributed_time_constants::BASE_HEARTBEAT_INTERVAL;
+use common_meta::instruction::CacheIdent;
 use common_meta::key::{TableMetadataManager, TableMetadataManagerRef};
 use common_meta::kv_backend::memory::MemoryKvBackend;
 use common_meta::kv_backend::{KvBackendRef, ResettableKvBackendRef};
@@ -97,3 +101,34 @@ impl TestEnv {
         }
     }
 }
+
+/// Counts failed notification attempts without requiring heartbeat connections.
+#[derive(Default)]
+pub(crate) struct FailingCacheInvalidator {
+    attempts: AtomicUsize,
+}
+
+impl FailingCacheInvalidator {
+    pub(crate) fn attempts(&self) -> usize {
+        self.attempts.load(Ordering::Relaxed)
+    }
+}
+
+#[async_trait::async_trait]
+impl CacheInvalidator for FailingCacheInvalidator {
+    async fn invalidate(
+        &self,
+        _: &InvalidationContext,
+        _: &[CacheIdent],
+    ) -> common_meta::error::Result<()> {
+        self.attempts.fetch_add(1, Ordering::Relaxed);
+        common_meta::error::UnexpectedSnafu {
+            err_msg: "injected notification failure",
+        }
+        .fail()
+    }
+
+    fn invalidate_all(&self) -> common_meta::error::Result<()> {
+        Ok(())
+    }
+}
diff --git a/src/meta-srv/src/handler/utils.rs b/src/meta-srv/src/handler/utils.rs
new file mode 100644
index 00000000000..96624d87306
--- /dev/null
+++ b/src/meta-srv/src/handler/utils.rs
@@ -0,0 +1,281 @@
+// 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::future::Future;
+use std::sync::Arc;
+
+use api::v1::meta::{Peer, Role};
+use common_meta::instruction::CacheIdent;
+use common_meta::key::MetadataValue;
+use common_meta::key::node_address::NodeAddressValue;
+use common_meta::rpc::store::PutRequest;
+use common_telemetry::{error, info};
+use dashmap::DashMap;
+use snafu::ResultExt;
+use tokio::sync::Mutex;
+
+use crate::Result;
+use crate::error::{InvalidNodeInfoFormatSnafu, KvBackendSnafu};
+use crate::metasrv::Context;
+
+/// Serializes address changes per node and acknowledges only successful updates.
+/// Node information refreshed on every heartbeat has a separate lifecycle.
+#[derive(Debug, Default)]
+pub(crate) struct NodeAddressUpdater {
+    states: DashMap<(Role, u64), Arc<Mutex<NodeAddressEpochs>>>,
+}
+
+#[derive(Debug, Default)]
+struct NodeAddressEpochs {
+    /// Rejects stale heartbeats even after a newer epoch failed to save.
+    seen_epoch: Option<u64>,
+    /// Suppresses retries only after persistence succeeds.
+    saved_epoch: Option<u64>,
+}
+
+impl NodeAddressUpdater {
+    /// Saves a new or previously failed epoch. Returns true only when this call
+    /// saved the address, or false when the heartbeat is stale or already saved.
+    /// Cache invalidation is separate and does not affect acknowledgement.
+    pub(crate) async fn update_if_needed<F, Fut>(
+        &self,
+        node: (Role, u64),
+        epoch: u64,
+        save: F,
+    ) -> Result<bool>
+    where
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = Result<()>>,
+    {
+        // Never retain a DashMap guard across await, even while waiting for a
+        // different node: its entry may live in the same shard.
+        let state = {
+            let entry = self.states.entry(node).or_default();
+            Arc::clone(entry.value())
+        };
+        let mut state = state.lock().await;
+        if state.seen_epoch.is_some_and(|seen| epoch < seen) || state.saved_epoch == Some(epoch) {
+            return Ok(false);
+        }
+
+        // Seeing an epoch rejects stale heartbeats, but only a successful save
+        // suppresses retries of that same epoch. Cancellation also leaves it retryable.
+        state.seen_epoch = Some(epoch);
+        save().await?;
+        state.saved_epoch = Some(epoch);
+        Ok(true)
+    }
+}
+
+/// Persists an address through the leader cache.
+pub(crate) async fn save_node_address(ctx: &Context, key: Vec<u8>, peer: Peer) -> Result<()> {
+    let address = NodeAddressValue::new(peer);
+    let value = address
+        .try_as_raw_value()
+        .context(InvalidNodeInfoFormatSnafu)?;
+    ctx.leader_cached_kv_backend
+        .put(PutRequest {
+            key,
+            value,
+            prev_kv: false,
+        })
+        .await
+        .context(KvBackendSnafu)?;
+    info!("Successfully updated node address: {:?}", address.peer);
+    Ok(())
+}
+
+/// Preserves the existing best-effort notification behavior. Notification
+/// failures do not undo a persisted address or cause same-epoch rewrites.
+pub(crate) async fn invalidate_address_caches(
+    ctx: &Context,
+    node_id: u64,
+    cache_idents: &[CacheIdent],
+) {
+    if let Err(e) = ctx
+        .cache_invalidator
+        .invalidate(&Default::default(), cache_idents)
+        .await
+    {
+        error!(e; "Failed to invalidate address caches for node {}: {:?}", node_id, cache_idents);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use tokio::sync::Notify;
+    use tokio::time::timeout;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test_failed_save_retries_same_epoch_and_rejects_stale_heartbeats() {
+        let updater = NodeAddressUpdater::default();
+        let key = (Role::Datanode, 1);
+        assert!(
+            updater
+                .update_if_needed(key, 2, || async {
+                    crate::error::UnexpectedSnafu {
+                        violated: "injected save failure",
+                    }
+                    .fail()
+                })
+                .await
+                .is_err()
+        );
+        assert!(
+            !updater
+                .update_if_needed(key, 1, || async {
+                    panic!("stale heartbeat must not save");
+                })
+                .await
+                .unwrap()
+        );
+        assert!(
+            updater
+                .update_if_needed(key, 2, || async { Ok(()) })
+                .await
+                .unwrap()
+        );
+        assert!(
+            !updater
+                .update_if_needed(key, 2, || async {
+                    panic!("successful epoch must not save again");
+                })
+                .await
+                .unwrap()
+        );
+        assert!(
+            updater
+                .update_if_needed(key, 3, || async { Ok(()) })
+                .await
+                .unwrap()
+        );
+    }
+
+    #[tokio::test]
+    async fn test_cancelled_save_can_be_retried() {
+        let updater = NodeAddressUpdater::default();
+        let key = (Role::Datanode, 1);
+        let entered = Notify::new();
+        {
+            let first = updater.update_if_needed(key, 0, || async {
+                entered.notify_one();
+                std::future::pending::<Result<()>>().await
+            });
+            tokio::pin!(first);
+            tokio::select! {
+                _ = entered.notified() => {},
+                _ = &mut first => panic!("save must remain pending"),
+            }
+        }
+        assert!(
+            timeout(
+                Duration::from_secs(2),
+                updater.update_if_needed(key, 0, || async { Ok(()) })
+            )
+            .await
+            .unwrap()
+            .unwrap()
+        );
+    }
+
+    #[test]
+    fn test_same_node_serialized_other_nodes_progress() {
+        // A watchdog outside the runtime detects synchronous DashMap deadlocks;
+        // a Tokio timeout alone cannot fire if the only worker is blocked.
+        let (progress_tx, progress_rx) = std::sync::mpsc::sync_channel(1);
+        let release = Arc::new(Notify::new());
+        let finish = Arc::new(Notify::new());
+        let worker = std::thread::spawn({
+            let release = release.clone();
+            let finish = finish.clone();
+            move || {
+                tokio::runtime::Builder::new_current_thread()
+                    .enable_time()
+                    .build()
+                    .unwrap()
+                    .block_on(async move {
+                        let updater = Arc::new(NodeAddressUpdater::default());
+                        let entered = Arc::new(Notify::new());
+
+                        let first = tokio::spawn({
+                            let updater = updater.clone();
+                            let entered = entered.clone();
+                            let release = release.clone();
+                            async move {
+                                updater
+                                    .update_if_needed((Role::Datanode, 1), 1, || async {
+                                        entered.notify_one();
+                                        release.notified().await;
+                                        Ok(())
+                                    })
+                                    .await
+                            }
+                        });
+                        entered.notified().await;
+                        let second = tokio::spawn({
+                            let updater = updater.clone();
+                            async move {
+                                updater
+                                    .update_if_needed((Role::Datanode, 1), 2, || async { Ok(()) })
+                                    .await
+                            }
+                        });
+                        tokio::task::yield_now().await;
+                        assert!(!second.is_finished());
+                        // Exercise shared DashMap shards on a single-thread runtime while the
+                        // first node is suspended in external I/O.
+                        timeout(Duration::from_secs(2), async {
+                            for id in 0_u64..128 {
+                                assert!(
+                                    updater
+                                        .update_if_needed((Role::Datanode, id + 2), 1, || async {
+                                            Ok(())
+                                        })
+                                        .await
+                                        .unwrap()
+                                );
+                            }
+                        })
+                        .await
+                        .unwrap();
+                        progress_tx.send(()).unwrap();
+                        finish.notified().await;
+                        timeout(Duration::from_secs(2), async {
+                            assert!(first.await.unwrap().unwrap());
+                            assert!(second.await.unwrap().unwrap());
+                        })
+                        .await
+                        .unwrap();
+                        assert!(
+                            !updater
+                                .update_if_needed((Role::Datanode, 1), 1, || async {
+                                    panic!("old epoch must not overwrite a newer one");
+                                })
+                                .await
+                                .unwrap()
+                        );
+                    });
+            }
+        });
+        let progress = progress_rx.recv_timeout(Duration::from_secs(5));
+        release.notify_one();
+        finish.notify_one();
+        progress.expect("other node updates must progress while one node save is blocked");
+        worker.join().unwrap();
+    }
+}
diff --git a/src/meta-srv/src/metrics.rs b/src/meta-srv/src/metrics.rs
index 1cf32194302..c92e6f31fff 100644
--- a/src/meta-srv/src/metrics.rs
+++ b/src/meta-srv/src/metrics.rs
@@ -48,6 +48,9 @@ lazy_static! {
     ///  Heartbeat received by metasrv.
     pub static ref METRIC_META_HEARTBEAT_RECV: IntCounterVec =
         register_int_counter_vec!("greptime_meta_heartbeat_recv", "heartbeats received by metasrv", &["pusher_key"]).unwrap();
+    /// Heartbeats dropped by metasrv.
+    pub static ref METRIC_META_HEARTBEAT_DROPPED: IntCounterVec =
+        register_int_counter_vec!("greptime_meta_heartbeat_dropped", "heartbeats dropped by metasrv", &["reason"]).unwrap();
     /// The migration execute histogram.
     pub static ref METRIC_META_REGION_MIGRATION_EXECUTE: HistogramVec =
         register_histogram_vec!("greptime_meta_region_migration_execute", "meta region migration execute", &["state"]).unwrap();
diff --git a/src/meta-srv/src/procedure/repartition/utils.rs b/src/meta-srv/src/procedure/repartition/utils.rs
index 50dbc57f9a8..cf6ea726f34 100644
--- a/src/meta-srv/src/procedure/repartition/utils.rs
+++ b/src/meta-srv/src/procedure/repartition/utils.rs
@@ -82,7 +82,7 @@ pub fn merge_and_validate_region_wal_options(
     table_id: TableId,
 ) -> Result<RegionWalOptions> {
     // Doesn't allow overwriting existing WAL options.
-    for (region_number, _) in new_region_wal_options.iter() {
+    for region_number in new_region_wal_options.keys() {
         if region_wal_options.contains_key(region_number) {
             return error::UnexpectedSnafu {
                 violated: format!(
diff --git a/src/meta-srv/src/region/supervisor.rs b/src/meta-srv/src/region/supervisor.rs
index 56a9fe4ee57..99c68ac23c8 100644
--- a/src/meta-srv/src/region/supervisor.rs
+++ b/src/meta-srv/src/region/supervisor.rs
@@ -35,6 +35,7 @@ use common_time::util::current_time_millis;
 use futures::{StreamExt, TryStreamExt};
 use snafu::{ResultExt, ensure};
 use store_api::storage::RegionId;
+use tokio::sync::mpsc::error::TrySendError;
 use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::sync::oneshot;
 use tokio::time::{MissedTickBehavior, interval, interval_at};
@@ -43,6 +44,7 @@ use crate::discovery::utils::accept_ingest_workload;
 use crate::error::{self, Result};
 use crate::failure_detector::PhiAccrualFailureDetectorOptions;
 use crate::metasrv::{RegionStatAwareSelectorRef, SelectTarget, SelectorContext, SelectorRef};
+use crate::metrics::METRIC_META_HEARTBEAT_DROPPED;
 use crate::procedure::region_migration::manager::{
     RegionMigrationManagerRef, RegionMigrationTriggerReason, SubmitRegionMigrationTaskResult,
 };
@@ -356,10 +358,29 @@ impl HeartbeatAcceptor {
         Self { sender }
     }
 
-    /// Accepts heartbeats from datanodes.
-    pub(crate) async fn accept(&self, heartbeat: DatanodeHeartbeat) {
-        if let Err(err) = self.sender.send(Event::HeartbeatArrived(heartbeat)).await {
-            error!(err; "RegionSupervisor has stop receiving heartbeat.");
+    /// Accepts heartbeats from datanodes without waiting for queue capacity: a full queue
+    /// drops the heartbeat, counted in [`METRIC_META_HEARTBEAT_DROPPED`]. A dropped
+    /// heartbeat costs the failure detector one sample.
+    pub(crate) fn accept(&self, heartbeat: DatanodeHeartbeat) {
+        let datanode_id = heartbeat.datanode_id;
+        match self.sender.try_send(Event::HeartbeatArrived(heartbeat)) {
+            Ok(()) => {}
+            Err(TrySendError::Full(_)) => {
+                METRIC_META_HEARTBEAT_DROPPED
+                    .with_label_values(&["full"])
+                    .inc();
+                warn!(
+                    "Dropping heartbeat because the region supervisor event queue is full, datanode_id: {}, queue_capacity: {}",
+                    datanode_id,
+                    self.sender.max_capacity()
+                );
+            }
+            Err(TrySendError::Closed(err)) => {
+                METRIC_META_HEARTBEAT_DROPPED
+                    .with_label_values(&["closed"])
+                    .inc();
+                error!(err; "RegionSupervisor has stop receiving heartbeat.");
+            }
         }
     }
 }
@@ -899,14 +920,15 @@ pub(crate) mod tests {
     use tokio::time::sleep;
 
     use super::RegionSupervisorSelector;
+    use crate::metrics::METRIC_META_HEARTBEAT_DROPPED;
     use crate::procedure::region_migration::RegionMigrationTriggerReason;
     use crate::procedure::region_migration::manager::{
         RegionMigrationManager, SubmitRegionMigrationTaskResult,
     };
     use crate::procedure::region_migration::test_util::TestingEnv;
     use crate::region::supervisor::{
-        DatanodeHeartbeat, Event, RegionFailureDetectorControl, RegionSupervisor,
-        RegionSupervisorTicker,
+        DatanodeHeartbeat, Event, HeartbeatAcceptor, RegionFailureDetectorControl,
+        RegionSupervisor, RegionSupervisorTicker,
     };
     use crate::selector::test_utils::{RandomNodeSelector, new_test_selector_context};
 
@@ -940,6 +962,14 @@ pub(crate) mod tests {
         )
     }
 
+    fn filler_heartbeat() -> DatanodeHeartbeat {
+        DatanodeHeartbeat {
+            datanode_id: 1,
+            regions: vec![],
+            timestamp: 0,
+        }
+    }
+
     #[tokio::test]
     async fn test_heartbeat() {
         let (mut supervisor, sender) = new_test_supervisor();
@@ -1372,4 +1402,39 @@ pub(crate) mod tests {
         assert!(supervisor.failure_detector.contains(&detecting_region));
         assert!(supervisor.failover_counts.contains_key(&detecting_region));
     }
+
+    #[tokio::test]
+    async fn test_heartbeat_accept_does_not_block_on_full_queue() {
+        // Regression test for #9419: a full queue used to park the caller.
+        // The supervisor is never run, so the queue stays full.
+        let (mut supervisor, sender) = new_test_supervisor();
+
+        let mut queued = 0;
+        while sender
+            .try_send(Event::HeartbeatArrived(filler_heartbeat()))
+            .is_ok()
+        {
+            queued += 1;
+        }
+        assert_eq!(queued, sender.max_capacity());
+        assert_eq!(sender.capacity(), 0);
+
+        let acceptor = HeartbeatAcceptor::new(sender.clone());
+        let dropped = || {
+            METRIC_META_HEARTBEAT_DROPPED
+                .with_label_values(&["full"])
+                .get()
+        };
+        let dropped_before = dropped();
+        // The full queue drops the heartbeat and counts it.
+        acceptor.accept(filler_heartbeat());
+        assert_eq!(dropped(), dropped_before + 1);
+        assert_eq!(sender.capacity(), 0);
+
+        // Free one slot: the next heartbeat is accepted.
+        supervisor.receiver.try_recv().unwrap();
+        acceptor.accept(filler_heartbeat());
+        assert_eq!(dropped(), dropped_before + 1);
+        assert_eq!(sender.capacity(), 0);
+    }
 }
diff --git a/src/meta-srv/src/service/heartbeat.rs b/src/meta-srv/src/service/heartbeat.rs
index 5cdc5b57894..782daa289de 100644
--- a/src/meta-srv/src/service/heartbeat.rs
+++ b/src/meta-srv/src/service/heartbeat.rs
@@ -419,7 +419,6 @@ mod tests {
     use std::sync::Arc;
 
     use api::v1::meta::heartbeat_server::Heartbeat;
-    use api::v1::meta::*;
     use common_meta::kv_backend::memory::MemoryKvBackend;
     use common_telemetry::tracing_context::W3cTrace;
     use servers::grpc::GrpcOptions;
diff --git a/src/meta-srv/src/service/store/cached_kv.rs b/src/meta-srv/src/service/store/cached_kv.rs
index 6526ebcd41e..1c2990f5446 100644
--- a/src/meta-srv/src/service/store/cached_kv.rs
+++ b/src/meta-srv/src/service/store/cached_kv.rs
@@ -69,6 +69,9 @@ pub struct LeaderCachedKvBackend {
     check_leader: CheckLeaderRef,
     store: KvBackendRef,
     cache: ResettableKvBackendRef,
+    /// Incremented before and after each store mutation. The first increment
+    /// detects overlapping writers; the second invalidates cache fills that
+    /// read the old value while the store mutation was in flight.
     version: AtomicUsize,
     name: String,
 }
@@ -214,9 +217,11 @@ impl KvBackend for LeaderCachedKvBackend {
         let ver = self.create_new_version();
 
         let res = self.store.put(req.clone()).await?;
+        self.create_new_version();
         let _ = self.cache.put(req.clone()).await?;
 
-        if !self.validate_version(ver) {
+        // Only our own completion increment may follow the starting version.
+        if !self.validate_version(ver + 1) {
             self.invalid_key(req.key).await?;
         }
 
@@ -231,9 +236,11 @@ impl KvBackend for LeaderCachedKvBackend {
         let ver = self.create_new_version();
 
         let res = self.store.batch_put(req.clone()).await?;
+        self.create_new_version();
         let _ = self.cache.batch_put(req.clone()).await?;
 
-        if !self.validate_version(ver) {
+        // Only our own completion increment may follow the starting version.
+        if !self.validate_version(ver + 1) {
             let keys = req.kvs.into_iter().map(|kv| kv.key).collect::<Vec<_>>();
             self.invalid_keys(keys).await?;
         }
@@ -306,6 +313,7 @@ impl KvBackend for LeaderCachedKvBackend {
 
         let key = req.key.clone();
         let res = self.store.compare_and_put(req).await?;
+        self.create_new_version();
         // Delete key in the cache.
         //
         // Cache can not deal with the CAS operation, because it does
@@ -322,6 +330,7 @@ impl KvBackend for LeaderCachedKvBackend {
         let _ = self.create_new_version();
 
         let res = self.store.delete_range(req.clone()).await?;
+        self.create_new_version();
         let _ = self.cache.delete_range(req).await?;
         Ok(res)
     }
@@ -334,6 +343,7 @@ impl KvBackend for LeaderCachedKvBackend {
         let _ = self.create_new_version();
 
         let res = self.store.batch_delete(req.clone()).await?;
+        self.create_new_version();
         let _ = self.cache.batch_delete(req).await?;
         Ok(res)
     }
@@ -351,6 +361,7 @@ impl TxnService for LeaderCachedKvBackend {
         let _ = self.create_new_version();
 
         let res = self.store.txn(txn.clone()).await?;
+        self.create_new_version();
         let TxnRequest {
             success, failure, ..
         } = txn.into();
@@ -384,6 +395,7 @@ impl TxnService for LeaderCachedKvBackend {
 
 impl ResettableKvBackend for LeaderCachedKvBackend {
     fn reset(&self) {
+        self.create_new_version();
         self.cache.reset()
     }
 
@@ -394,10 +406,355 @@ impl ResettableKvBackend for LeaderCachedKvBackend {
 
 #[cfg(test)]
 mod tests {
+    use std::sync::Mutex;
+
+    use common_meta::kv_backend::txn::{Compare, CompareOp};
     use common_meta::rpc::KeyValue;
+    use futures::poll;
+    use tokio::sync::oneshot;
 
     use super::*;
 
+    /// Pauses one backend call at a known point, without relying on task scheduling.
+    #[derive(Default)]
+    struct Pause {
+        receiver: Mutex<Option<oneshot::Receiver<()>>>,
+    }
+
+    impl Pause {
+        fn arm(&self) -> oneshot::Sender<()> {
+            let (sender, receiver) = oneshot::channel();
+            assert!(self.receiver.lock().unwrap().replace(receiver).is_none());
+            sender
+        }
+
+        async fn wait(&self) {
+            let receiver = self.receiver.lock().unwrap().take();
+            if let Some(receiver) = receiver {
+                receiver.await.unwrap();
+            }
+        }
+    }
+
+    #[derive(Default)]
+    struct ControlledBackend {
+        inner: MemoryKvBackend<Error>,
+        before_write: Pause,
+        after_write: Pause,
+        after_read: Pause,
+    }
+
+    #[async_trait::async_trait]
+    impl TxnService for ControlledBackend {
+        type Error = Error;
+
+        async fn txn(&self, txn: Txn) -> Result<TxnResponse> {
+            self.before_write.wait().await;
+            let res = self.inner.txn(txn).await;
+            self.after_write.wait().await;
+            res
+        }
+
+        fn max_txn_ops(&self) -> usize {
+            self.inner.max_txn_ops()
+        }
+    }
+
+    #[async_trait::async_trait]
+    impl KvBackend for ControlledBackend {
+        fn name(&self) -> &str {
+            "ControlledBackend"
+        }
+
+        fn as_any(&self) -> &dyn Any {
+            self
+        }
+
+        async fn range(&self, req: RangeRequest) -> Result<RangeResponse> {
+            let res = self.inner.range(req).await;
+            self.after_read.wait().await;
+            res
+        }
+
+        async fn batch_get(&self, req: BatchGetRequest) -> Result<BatchGetResponse> {
+            let res = self.inner.batch_get(req).await;
+            self.after_read.wait().await;
+            res
+        }
+
+        async fn put(&self, req: PutRequest) -> Result<PutResponse> {
+            self.before_write.wait().await;
+            let res = self.inner.put(req).await;
+            self.after_write.wait().await;
+            res
+        }
+
+        async fn batch_put(&self, req: BatchPutRequest) -> Result<BatchPutResponse> {
+            self.before_write.wait().await;
+            let res = self.inner.batch_put(req).await;
+            self.after_write.wait().await;
+            res
+        }
+
+        async fn delete_range(&self, req: DeleteRangeRequest) -> Result<DeleteRangeResponse> {
+            self.before_write.wait().await;
+            let res = self.inner.delete_range(req).await;
+            self.after_write.wait().await;
+            res
+        }
+
+        async fn batch_delete(&self, req: BatchDeleteRequest) -> Result<BatchDeleteResponse> {
+            self.before_write.wait().await;
+            let res = self.inner.batch_delete(req).await;
+            self.after_write.wait().await;
+            res
+        }
+    }
+
+    #[derive(Clone, Copy, Debug)]
+    enum Write {
+        Txn,
+        TxnFailure,
+        Put,
+        BatchPut,
+        CompareAndPut,
+        DeleteRange,
+        BatchDelete,
+    }
+
+    const WRITES: [Write; 7] = [
+        Write::Txn,
+        Write::TxnFailure,
+        Write::Put,
+        Write::BatchPut,
+        Write::CompareAndPut,
+        Write::DeleteRange,
+        Write::BatchDelete,
+    ];
+    const KEY: &[u8] = b"route";
+
+    impl Write {
+        async fn execute(self, store: &LeaderCachedKvBackend, value: &[u8]) {
+            match self {
+                Self::Txn => {
+                    store
+                        .txn(Txn::new().and_then(vec![TxnOp::Put(KEY.to_vec(), value.to_vec())]))
+                        .await
+                        .unwrap();
+                }
+                Self::TxnFailure => {
+                    let res = store
+                        .txn(
+                            Txn::new()
+                                .when(vec![Compare::with_value_not_exists(
+                                    KEY.to_vec(),
+                                    CompareOp::Equal,
+                                )])
+                                .or_else(vec![TxnOp::Put(KEY.to_vec(), value.to_vec())]),
+                        )
+                        .await
+                        .unwrap();
+                    assert!(!res.succeeded);
+                }
+                Self::Put => {
+                    store
+                        .put(PutRequest::new().with_key(KEY).with_value(value))
+                        .await
+                        .unwrap();
+                }
+                Self::BatchPut => {
+                    store
+                        .batch_put(BatchPutRequest {
+                            kvs: vec![KeyValue {
+                                key: KEY.to_vec(),
+                                value: value.to_vec(),
+                            }],
+                            ..Default::default()
+                        })
+                        .await
+                        .unwrap();
+                }
+                Self::CompareAndPut => {
+                    let res = store
+                        .compare_and_put(
+                            CompareAndPutRequest::new()
+                                .with_key(KEY)
+                                .with_expect(b"old")
+                                .with_value(value),
+                        )
+                        .await
+                        .unwrap();
+                    assert!(res.success);
+                }
+                Self::DeleteRange => {
+                    store
+                        .delete_range(DeleteRangeRequest::new().with_key(KEY))
+                        .await
+                        .unwrap();
+                }
+                Self::BatchDelete => {
+                    store
+                        .batch_delete(BatchDeleteRequest {
+                            keys: vec![KEY.to_vec()],
+                            prev_kv: false,
+                        })
+                        .await
+                        .unwrap();
+                }
+            }
+        }
+    }
+
+    async fn read(store: &LeaderCachedKvBackend, batch: bool) -> Option<KeyValue> {
+        if batch {
+            store
+                .batch_get(BatchGetRequest {
+                    keys: vec![KEY.to_vec()],
+                })
+                .await
+                .unwrap()
+                .kvs
+                .pop()
+        } else {
+            store.get(KEY).await.unwrap()
+        }
+    }
+
+    /// A cache miss reads the old value after a writer starts, then returns after
+    /// the writer has committed and updated/invalidated the cache (#9548).
+    #[tokio::test]
+    async fn test_cache_miss_overlaps_write() {
+        for write in WRITES {
+            for batch in [true, false] {
+                let backing = Arc::new(ControlledBackend::default());
+                backing
+                    .inner
+                    .put(PutRequest::new().with_key(KEY).with_value(b"old"))
+                    .await
+                    .unwrap();
+                let store = LeaderCachedKvBackend::with_always_leader(backing.clone());
+
+                let commit = backing.before_write.arm();
+                let writer = write.execute(&store, b"new");
+                tokio::pin!(writer);
+                assert!(poll!(writer.as_mut()).is_pending());
+
+                let return_read = backing.after_read.arm();
+                let reader = read(&store, batch);
+                tokio::pin!(reader);
+                assert!(poll!(reader.as_mut()).is_pending());
+
+                commit.send(()).unwrap();
+                writer.await;
+                return_read.send(()).unwrap();
+                assert_eq!(reader.await.unwrap().value(), b"old");
+
+                let durable = backing.inner.get(KEY).await.unwrap();
+                assert_eq!(
+                    read(&store, batch).await,
+                    durable,
+                    "{write:?}, batch={batch}"
+                );
+            }
+        }
+    }
+
+    /// Start order, commit order and response order can all differ. An older
+    /// put response must not overwrite the cache after a newer mutation.
+    #[tokio::test]
+    async fn test_overlapping_writes() {
+        for first in [Write::Put, Write::BatchPut] {
+            for second in WRITES {
+                for reverse_commit in [false, true] {
+                    let backing = Arc::new(ControlledBackend::default());
+                    backing
+                        .inner
+                        .put(PutRequest::new().with_key(KEY).with_value(b"old"))
+                        .await
+                        .unwrap();
+                    let store = LeaderCachedKvBackend::with_always_leader(backing.clone());
+
+                    let resume = if reverse_commit {
+                        backing.before_write.arm()
+                    } else {
+                        backing.after_write.arm()
+                    };
+                    // Keep the initial value so the second CAS succeeds.
+                    let writer = first.execute(&store, b"old");
+                    tokio::pin!(writer);
+                    assert!(poll!(writer.as_mut()).is_pending());
+                    second.execute(&store, b"new").await;
+                    resume.send(()).unwrap();
+                    writer.await;
+
+                    let durable = backing.inner.get(KEY).await.unwrap();
+                    assert_eq!(
+                        read(&store, true).await,
+                        durable,
+                        "{first:?}, {second:?}, reverse_commit={reverse_commit}"
+                    );
+                }
+            }
+        }
+    }
+
+    /// The later-started put commits first but returns last, after its stored
+    /// value has already been replaced by the first writer.
+    #[tokio::test]
+    async fn test_write_response_reordering() {
+        for first in WRITES {
+            for second in [Write::Put, Write::BatchPut] {
+                let backing = Arc::new(ControlledBackend::default());
+                backing
+                    .inner
+                    .put(PutRequest::new().with_key(KEY).with_value(b"old"))
+                    .await
+                    .unwrap();
+                let store = LeaderCachedKvBackend::with_always_leader(backing.clone());
+
+                let commit_first = backing.before_write.arm();
+                let first_writer = first.execute(&store, b"new");
+                tokio::pin!(first_writer);
+                assert!(poll!(first_writer.as_mut()).is_pending());
+
+                let return_second = backing.after_write.arm();
+                let second_writer = second.execute(&store, b"old");
+                tokio::pin!(second_writer);
+                assert!(poll!(second_writer.as_mut()).is_pending());
+
+                commit_first.send(()).unwrap();
+                first_writer.await;
+                return_second.send(()).unwrap();
+                second_writer.await;
+
+                let durable = backing.inner.get(KEY).await.unwrap();
+                assert_eq!(read(&store, true).await, durable, "{first:?}, {second:?}");
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn test_cache_miss_overlaps_reset() {
+        for batch in [true, false] {
+            let backing = Arc::new(ControlledBackend::default());
+            backing
+                .inner
+                .put(PutRequest::new().with_key(KEY).with_value(b"old"))
+                .await
+                .unwrap();
+            let store = LeaderCachedKvBackend::with_always_leader(backing.clone());
+
+            let return_read = backing.after_read.arm();
+            let reader = read(&store, batch);
+            tokio::pin!(reader);
+            assert!(poll!(reader.as_mut()).is_pending());
+            store.reset();
+            return_read.send(()).unwrap();
+            reader.await;
+            assert!(store.cache.get(KEY).await.unwrap().is_none());
+        }
+    }
+
     fn create_leader_cached_kv_backend() -> LeaderCachedKvBackend {
         let store = Arc::new(MemoryKvBackend::new());
         LeaderCachedKvBackend::with_always_leader(store)
diff --git a/src/metric-engine/src/engine/bulk_insert.rs b/src/metric-engine/src/engine/bulk_insert.rs
index fa47ce48008..b7ad7646e3c 100644
--- a/src/metric-engine/src/engine/bulk_insert.rs
+++ b/src/metric-engine/src/engine/bulk_insert.rs
@@ -354,17 +354,38 @@ mod tests {
 
     #[tokio::test]
     async fn test_bulk_insert_physical_region_passthrough() {
-        check_bulk_insert_physical_region_passthrough(false).await;
-        check_bulk_insert_physical_region_passthrough(true).await;
+        check_bulk_insert_physical_region_passthrough(false, false, false).await;
+        check_bulk_insert_physical_region_passthrough(true, false, false).await;
     }
 
-    async fn check_bulk_insert_physical_region_passthrough(skip_wal: bool) {
+    #[tokio::test]
+    async fn test_bulk_insert_physical_region_close_recovery() {
+        check_bulk_insert_physical_region_passthrough(false, true, false).await;
+        check_bulk_insert_physical_region_passthrough(true, true, false).await;
+    }
+
+    #[tokio::test]
+    async fn test_physical_bulk_partition_columns_preserve_stored_rows() {
+        for skip_wal in [false, true] {
+            let stripped =
+                check_bulk_insert_physical_region_passthrough(skip_wal, true, false).await;
+            let retained =
+                check_bulk_insert_physical_region_passthrough(skip_wal, true, true).await;
+            assert_eq!(retained, stripped, "skip_wal={skip_wal}");
+        }
+    }
+
+    async fn check_bulk_insert_physical_region_passthrough(
+        skip_wal: bool,
+        close: bool,
+        retain_partition_columns: bool,
+    ) -> String {
         // Use flat format so that BulkMemtable is used (supports write_bulk).
         let mito_config = MitoConfig {
             default_flat_format: true,
             ..Default::default()
         };
-        let env = TestEnv::with_mito_config("", mito_config, Default::default()).await;
+        let mut env = TestEnv::with_mito_config("", mito_config, Default::default()).await;
         env.init_metric_region().await;
         env.metric().inner.flush_task.stop().await.unwrap();
         let physical_region_id = env.default_physical_region_id();
@@ -388,7 +409,11 @@ mod tests {
             index: 2,
             column_id: 2, // column_id for "job" in the physical table
         }];
-        let non_tag_indices = vec![0, 1]; // timestamp, value
+        let non_tag_indices = if retain_partition_columns {
+            vec![0, 1, 2] // timestamp, value, and the job partition column
+        } else {
+            vec![0, 1] // timestamp, value
+        };
         let second_batch = build_logical_batch(3, 3);
         let physical_batch = modify_batch_sparse(
             second_batch,
@@ -397,6 +422,10 @@ mod tests {
             &non_tag_indices,
         )
         .unwrap();
+        assert_eq!(
+            physical_batch.column_by_name("job").is_some(),
+            retain_partition_columns
+        );
         let request = build_bulk_request(physical_region_id, physical_batch, skip_wal);
         let response = env
             .metric()
@@ -414,20 +443,23 @@ mod tests {
         let batches = RecordBatches::try_collect(stream).await.unwrap();
         assert_eq!(batches.iter().map(|b| b.num_rows()).sum::<usize>(), 6);
 
-        // Closing without a flush must recover only WAL-backed data. Recreate
-        // the wrapper too, so its metadata cache cannot hide missing metadata.
         let stat = env.mito().region_statistic(physical_region_id).unwrap();
         assert_eq!(stat.sst_num, 0);
-        env.metric()
-            .handle_request(
-                physical_region_id,
-                RegionRequest::Close(RegionCloseRequest {
-                    flush_on_close: false,
-                }),
-            )
-            .await
-            .unwrap();
-        let reopened = MetricEngine::try_new(env.mito(), Default::default()).unwrap();
+        let reopened = if close {
+            env.metric()
+                .handle_request(
+                    physical_region_id,
+                    RegionRequest::Close(RegionCloseRequest::default()),
+                )
+                .await
+                .unwrap();
+            // Recreating the wrapper prevents its metadata cache from hiding data loss.
+            MetricEngine::try_new(env.mito(), Default::default()).unwrap()
+        } else {
+            // Stopping workers without Close exercises recovery from WAL alone.
+            env.reopen_engine(Default::default()).await;
+            env.metric()
+        };
         reopened.inner.flush_task.stop().await.unwrap();
         reopened
             .handle_request(
@@ -446,6 +478,11 @@ mod tests {
             )
             .await
             .unwrap();
+        let stat = env
+            .mito()
+            .region_statistic(crate::utils::to_data_region_id(physical_region_id))
+            .unwrap();
+        assert_eq!(stat.sst_num > 0, skip_wal && close);
         let stream = reopened
             .scan_to_stream(logical_region_id, ScanRequest::default())
             .await
@@ -453,8 +490,9 @@ mod tests {
         let batches = RecordBatches::try_collect(stream).await.unwrap();
         assert_eq!(
             batches.iter().map(|b| b.num_rows()).sum::<usize>(),
-            if skip_wal { 0 } else { 6 },
+            if skip_wal && !close { 0 } else { 6 },
         );
+        batches.pretty_print().unwrap()
     }
 
     #[tokio::test]
diff --git a/src/metric-engine/src/engine/put.rs b/src/metric-engine/src/engine/put.rs
index fdf9b02a5ff..b709d99d847 100644
--- a/src/metric-engine/src/engine/put.rs
+++ b/src/metric-engine/src/engine/put.rs
@@ -934,14 +934,22 @@ mod tests {
 
     #[tokio::test]
     async fn test_put_skip_wal_batch_recovery() {
-        check_put_skip_wal_batch_recovery("sparse", false).await;
-        check_put_skip_wal_batch_recovery("sparse", true).await;
-        check_put_skip_wal_batch_recovery("dense", false).await;
-        check_put_skip_wal_batch_recovery("dense", true).await;
+        check_put_skip_wal_batch_recovery("sparse", false, false).await;
+        check_put_skip_wal_batch_recovery("sparse", true, false).await;
+        check_put_skip_wal_batch_recovery("dense", false, false).await;
+        check_put_skip_wal_batch_recovery("dense", true, false).await;
     }
 
-    async fn check_put_skip_wal_batch_recovery(encoding: &str, skip_wal: bool) {
-        let env = TestEnv::new().await;
+    #[tokio::test]
+    async fn test_put_skip_wal_batch_close_recovery() {
+        check_put_skip_wal_batch_recovery("sparse", false, true).await;
+        check_put_skip_wal_batch_recovery("sparse", true, true).await;
+        check_put_skip_wal_batch_recovery("dense", false, true).await;
+        check_put_skip_wal_batch_recovery("dense", true, true).await;
+    }
+
+    async fn check_put_skip_wal_batch_recovery(encoding: &str, skip_wal: bool, close: bool) {
+        let mut env = TestEnv::new().await;
         let engine = env.metric();
         engine.inner.flush_task.stop().await.unwrap();
         let physical_region_id = env.default_physical_region_id();
@@ -1009,18 +1017,21 @@ mod tests {
             assert!(stat.memtable_size > 0);
             assert_eq!(stat.sst_num, 0);
         }
-        engine
-            .handle_request(
-                physical_region_id,
-                RegionRequest::Close(RegionCloseRequest {
-                    flush_on_close: false,
-                }),
-            )
-            .await
-            .unwrap();
-
-        // Recreate the wrapper as well, discarding its metadata cache.
-        let reopened = MetricEngine::try_new(env.mito(), Default::default()).unwrap();
+        let reopened = if close {
+            engine
+                .handle_request(
+                    physical_region_id,
+                    RegionRequest::Close(RegionCloseRequest::default()),
+                )
+                .await
+                .unwrap();
+            // Recreate the wrapper as well, discarding its metadata cache.
+            MetricEngine::try_new(env.mito(), Default::default()).unwrap()
+        } else {
+            // Bypass Close to retain coverage of rows lost without WAL protection.
+            env.reopen_engine(Default::default()).await;
+            env.metric()
+        };
         reopened.inner.flush_task.stop().await.unwrap();
         reopened
             .handle_request(
@@ -1042,12 +1053,17 @@ mod tests {
             )
             .await
             .unwrap();
+        let stat = env
+            .mito()
+            .region_statistic(crate::utils::to_data_region_id(physical_region_id))
+            .unwrap();
+        assert_eq!(stat.sst_num > 0, skip_wal && close);
         let recovered_metadata = reopened.get_metadata(logical_region_id).await.unwrap();
         assert_eq!(
             metadata_before.column_metadatas,
             recovered_metadata.column_metadatas
         );
-        let expected = if skip_wal {
+        let expected = if skip_wal && !close {
             vec![]
         } else {
             vec![(0, 30.0), (1, 10.0), (2, 20.0), (3, 30.0)]
@@ -1055,7 +1071,7 @@ mod tests {
         assert_eq!(
             scan_timestamp_values(&reopened, logical_region_id).await,
             expected,
-            "encoding={encoding}, skip_wal={skip_wal}"
+            "encoding={encoding}, skip_wal={skip_wal}, close={close}"
         );
     }
 
diff --git a/src/metric-engine/src/error.rs b/src/metric-engine/src/error.rs
index 0803223ba33..f9d61d6af31 100644
--- a/src/metric-engine/src/error.rs
+++ b/src/metric-engine/src/error.rs
@@ -486,6 +486,9 @@ impl ErrorExt for Error {
         use Error::*;
 
         match self {
+            PhysicalRegionNotFound { .. } | LogicalRegionNotFound { .. } => {
+                RetryHint::RetryAfterRouteRefresh
+            }
             CreateMitoRegion { source, .. }
             | OpenMitoRegion { source, .. }
             | CleanUpMitoRegion { source, .. }
@@ -510,3 +513,20 @@ impl ErrorExt for Error {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_missing_region_retry_hints() {
+        let region_id = RegionId::new(1024, 1);
+        for error in [
+            PhysicalRegionNotFoundSnafu { region_id }.build(),
+            LogicalRegionNotFoundSnafu { region_id }.build(),
+        ] {
+            assert_eq!(error.status_code(), StatusCode::RegionNotFound);
+            assert_eq!(error.retry_hint(), RetryHint::RetryAfterRouteRefresh);
+        }
+    }
+}
diff --git a/src/metric-engine/src/test_util.rs b/src/metric-engine/src/test_util.rs
index 0671351ddb3..cf64d968182 100644
--- a/src/metric-engine/src/test_util.rs
+++ b/src/metric-engine/src/test_util.rs
@@ -121,6 +121,17 @@ impl TestEnv {
         self.metric.clone()
     }
 
+    /// Restarts Mito without closing regions and recreates the metric metadata cache.
+    /// Callers stop the old metric engine's metadata flush task before restarting.
+    pub async fn reopen_engine(&mut self, config: EngineConfig) {
+        let mito_config = self.mito.mito_config().clone();
+        self.mito = self
+            .mito_env
+            .reopen_engine(self.mito.clone(), mito_config)
+            .await;
+        self.metric = MetricEngine::try_new(self.mito.clone(), config).unwrap();
+    }
+
     /// Creates a new follower engine with the same config as the leader engine.
     pub async fn create_follower_engine(&mut self) -> (MitoEngine, MetricEngine) {
         let mito = self
diff --git a/src/mito-codec/src/row_converter/sparse/checked.rs b/src/mito-codec/src/row_converter/sparse/checked.rs
index 0cc9ed8211a..fec89b74e0d 100644
--- a/src/mito-codec/src/row_converter/sparse/checked.rs
+++ b/src/mito-codec/src/row_converter/sparse/checked.rs
@@ -116,7 +116,7 @@ impl<'a, 'b> SparsePrimaryKeyView<'a, 'b> {
         // encoded_value checked the markers and every chunk length. Reserve once
         // before unchunking so the buffer does not grow for each 8-byte chunk.
         buffer.reserve(encoded.len() - 2);
-        for chunk in encoded[2..].chunks_exact(9) {
+        for chunk in encoded[2..].as_chunks::<9>().0 {
             let len = usize::from(chunk[8]).min(8);
             buffer.extend_from_slice(&chunk[..len]);
         }
diff --git a/src/mito2/benches/memtable_bench.rs b/src/mito2/benches/memtable_bench.rs
index 80331941865..e4d71c9883c 100644
--- a/src/mito2/benches/memtable_bench.rs
+++ b/src/mito2/benches/memtable_bench.rs
@@ -268,7 +268,7 @@ fn filter_1_host(c: &mut Criterion) {
                 )
                 .unwrap();
 
-            for (_range_id, range) in ranges.ranges.iter() {
+            for range in ranges.ranges.values() {
                 let iter = range.build_record_batch_iter(None, None).unwrap();
                 for batch in iter {
                     let _batch = batch.unwrap();
diff --git a/src/mito2/src/access_layer.rs b/src/mito2/src/access_layer.rs
index 3959e0c26a4..b1457935c16 100644
--- a/src/mito2/src/access_layer.rs
+++ b/src/mito2/src/access_layer.rs
@@ -579,7 +579,7 @@ pub struct SstWriteRequest {
     pub source: FlatSource,
     pub cache_manager: CacheManagerRef,
     /// Optional uniform row sequence for writes that do not preserve sequences.
-    /// Compaction passes `None` to retain the reader's effective input sequences.
+    /// Compaction and LastNonNull flushes pass `None` to retain input sequences.
     pub max_sequence: Option<SequenceNumber>,
     pub sst_write_format: FormatType,
 
diff --git a/src/mito2/src/cache/index/result_cache.rs b/src/mito2/src/cache/index/result_cache.rs
index dfed662a142..5d22c739831 100644
--- a/src/mito2/src/cache/index/result_cache.rs
+++ b/src/mito2/src/cache/index/result_cache.rs
@@ -23,7 +23,7 @@ use store_api::storage::{ColumnId, FileId};
 
 use crate::metrics::{CACHE_BYTES, CACHE_EVICTION, CACHE_HIT, CACHE_MISS};
 use crate::sst::index::fulltext_index::applier::builder::{
-    FulltextQuery, FulltextRequest, FulltextTerm,
+    FulltextLike, FulltextQuery, FulltextRequest, FulltextTerm,
 };
 use crate::sst::parquet::row_selection::RowGroupSelection;
 
@@ -176,7 +176,12 @@ impl FulltextIndexKey {
                     .iter()
                     .map(|term| term.term.len() + size_of::<FulltextTerm>())
                     .sum::<usize>();
-                query_size + term_size
+                let like_size = request
+                    .likes
+                    .iter()
+                    .map(|like| like.pattern.len() + size_of::<FulltextLike>())
+                    .sum::<usize>();
+                query_size + term_size + like_size
             })
             .sum();
         Self {
@@ -343,6 +348,7 @@ mod tests {
                 FulltextQuery("another long query string".to_string()),
             ],
             terms: vec![],
+            likes: vec![],
         };
         predicates1.insert(1, request1);
         let key1 = PredicateKey::new_fulltext(Arc::new(predicates1));
@@ -357,6 +363,7 @@ mod tests {
                 FulltextQuery("another long query string".to_string()),
             ],
             terms: vec![],
+            likes: vec![],
         };
         predicates2.insert(1, request2);
         let key2 = PredicateKey::new_fulltext(Arc::new(predicates2));
@@ -427,6 +434,7 @@ mod tests {
                 col_lowered: false,
                 term: "test term".to_string(),
             }],
+            likes: vec![],
         };
         predicates1.insert(1, request1);
         let key1 = PredicateKey::new_fulltext(Arc::new(predicates1));
diff --git a/src/mito2/src/compaction/scheduler_test.rs b/src/mito2/src/compaction/scheduler_test.rs
index 5afcc9c37fd..42c1df23f07 100644
--- a/src/mito2/src/compaction/scheduler_test.rs
+++ b/src/mito2/src/compaction/scheduler_test.rs
@@ -546,7 +546,7 @@ async fn test_planning_panic_notifies_and_clears_status() {
 
     let finished = recv_compaction_pick_finished(&mut rx).await;
     let CompactionPlanningResult::Error(err) = &finished.result else {
-        panic!("expected planning error, got {:?}", &finished.result);
+        panic!("expected planning error, got {:?}", finished.result);
     };
     assert!(err.to_string().contains("planning boom"));
     let pending_ddls = scheduler
diff --git a/src/mito2/src/engine/basic_test.rs b/src/mito2/src/engine/basic_test.rs
index 776e1f78abe..c11ec4324d6 100644
--- a/src/mito2/src/engine/basic_test.rs
+++ b/src/mito2/src/engine/basic_test.rs
@@ -1262,13 +1262,13 @@ async fn test_all_region_infos() {
 async fn test_all_index_metas_list_all_types() {
     test_all_index_metas_list_all_types_with_format(false, r#"
 PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "bloom_filter", target_type: "column", target_key: "1", target_json: "{\"column\":1}", blob_size: 751, meta_json: Some("{\"bloom\":{\"bloom_filter_size\":640,\"row_count\":20,\"rows_per_segment\":2,\"segment_count\":10}}"), node_id: None }
-PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "fulltext_bloom", target_type: "column", target_key: "4", target_json: "{\"column\":4}", blob_size: 89, meta_json: Some("{\"bloom\":{\"bloom_filter_size\":64,\"row_count\":20,\"rows_per_segment\":4,\"segment_count\":5},\"fulltext\":{\"analyzer\":\"English\",\"case_sensitive\":false}}"), node_id: None }
+PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "fulltext_bloom", target_type: "column", target_key: "4", target_json: "{\"column\":4}", blob_size: 89, meta_json: Some("{\"bloom\":{\"bloom_filter_size\":64,\"row_count\":20,\"rows_per_segment\":4,\"segment_count\":5},\"fulltext\":{\"analyzer\":\"English\",\"bloom_version\":2,\"case_sensitive\":false}}"), node_id: None }
 PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "fulltext_tantivy", target_type: "column", target_key: "5", target_json: "{\"column\":5}", blob_size: 1000, meta_json: Some("{\"fulltext\":{\"analyzer\":\"Chinese\",\"case_sensitive\":true}}"), node_id: None }
 PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "inverted", target_type: "column", target_key: "1", target_json: "{\"column\":1}", blob_size: 518, meta_json: Some("{\"inverted\":{\"base_offset\":0,\"bitmap_type\":\"Roaring\",\"fst_size\":150,\"inverted_index_size\":518,\"null_bitmap_size\":8,\"relative_fst_offset\":368,\"relative_null_bitmap_offset\":0,\"segment_row_count\":1024,\"total_row_count\":20}}"), node_id: None }
 PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "inverted", target_type: "column", target_key: "2", target_json: "{\"column\":2}", blob_size: 515, meta_json: Some("{\"inverted\":{\"base_offset\":0,\"bitmap_type\":\"Roaring\",\"fst_size\":147,\"inverted_index_size\":515,\"null_bitmap_size\":8,\"relative_fst_offset\":368,\"relative_null_bitmap_offset\":0,\"segment_row_count\":1024,\"total_row_count\":20}}"), node_id: None }"#).await;
     test_all_index_metas_list_all_types_with_format(true, r#"
 PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "bloom_filter", target_type: "column", target_key: "1", target_json: "{\"column\":1}", blob_size: 751, meta_json: Some("{\"bloom\":{\"bloom_filter_size\":640,\"row_count\":20,\"rows_per_segment\":2,\"segment_count\":10}}"), node_id: None }
-PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "fulltext_bloom", target_type: "column", target_key: "4", target_json: "{\"column\":4}", blob_size: 89, meta_json: Some("{\"bloom\":{\"bloom_filter_size\":64,\"row_count\":20,\"rows_per_segment\":4,\"segment_count\":5},\"fulltext\":{\"analyzer\":\"English\",\"case_sensitive\":false}}"), node_id: None }
+PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "fulltext_bloom", target_type: "column", target_key: "4", target_json: "{\"column\":4}", blob_size: 89, meta_json: Some("{\"bloom\":{\"bloom_filter_size\":64,\"row_count\":20,\"rows_per_segment\":4,\"segment_count\":5},\"fulltext\":{\"analyzer\":\"English\",\"bloom_version\":2,\"case_sensitive\":false}}"), node_id: None }
 PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "fulltext_tantivy", target_type: "column", target_key: "5", target_json: "{\"column\":5}", blob_size: 1000, meta_json: Some("{\"fulltext\":{\"analyzer\":\"Chinese\",\"case_sensitive\":true}}"), node_id: None }
 PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "inverted", target_type: "column", target_key: "1", target_json: "{\"column\":1}", blob_size: 518, meta_json: Some("{\"inverted\":{\"base_offset\":0,\"bitmap_type\":\"Roaring\",\"fst_size\":150,\"inverted_index_size\":518,\"null_bitmap_size\":8,\"relative_fst_offset\":368,\"relative_null_bitmap_offset\":0,\"segment_row_count\":1024,\"total_row_count\":20}}"), node_id: None }
 PuffinIndexMetaEntry { table_dir: "test/", index_file_path: "test/11_0000000001/index/<file_id>.puffin", region_id: 47244640257(11, 1), table_id: 11, region_number: 1, region_group: 0, region_sequence: 1, file_id: "<file_id>", index_file_size: Some(6000), index_type: "inverted", target_type: "column", target_key: "2", target_json: "{\"column\":2}", blob_size: 515, meta_json: Some("{\"inverted\":{\"base_offset\":0,\"bitmap_type\":\"Roaring\",\"fst_size\":147,\"inverted_index_size\":515,\"null_bitmap_size\":8,\"relative_fst_offset\":368,\"relative_null_bitmap_offset\":0,\"segment_row_count\":1024,\"total_row_count\":20}}"), node_id: None }"#).await;
@@ -1500,7 +1500,10 @@ async fn check_request_skip_wal_recovery(flat_format: bool, skip_wal: bool) {
     let before = RecordBatches::try_collect(stream).await.unwrap();
     assert_eq!(before.iter().map(|b| b.num_rows()).sum::<usize>(), 4);
 
-    reopen_region(&engine, region_id, table_dir, false, HashMap::new()).await;
+    // Stop the engine directly, without region close, to exercise WAL-only recovery.
+    let engine =
+        restart_without_region_close(&mut env, engine, flat_format, region_id, table_dir).await;
+
     let stream = engine
         .scan_to_stream(region_id, ScanRequest::default())
         .await
@@ -1625,7 +1628,7 @@ async fn check_request_skip_wal_mixed_batch_recovery(
     skip_wal: bool,
     flush_before_reopen: bool,
 ) {
-    use crate::region_write_ctx::RegionWriteCtx;
+    use crate::region_write_ctx::{RegionWriteCtx, WriteSource};
     use crate::request::OptionOutputTx;
     use crate::test_util::LogStoreImpl;
     use crate::wal::Wal;
@@ -1657,6 +1660,7 @@ async fn check_request_skip_wal_mixed_batch_recovery(
         &region.version_control,
         region.provider.clone(),
         None,
+        WriteSource::Request,
     );
     let mut receivers = Vec::with_capacity(4);
     for (index, (skip, timestamp)) in [(false, 0), (skip_wal, 0), (false, 0), (skip_wal, 1)]
@@ -1692,8 +1696,7 @@ async fn check_request_skip_wal_mixed_batch_recovery(
     ctx.add_wal_entry(&mut writer).unwrap();
     let response = writer.write_to_wal().await.unwrap();
     assert_eq!(response.last_entry_ids.get(&region_id), Some(&1));
-    ctx.write_memtable().await;
-    ctx.publish_sequence_and_entry_id();
+    ctx.write_memtables().await;
     drop(ctx);
     for rx in receivers {
         assert_eq!(rx.await.unwrap().unwrap(), 2);
@@ -1751,9 +1754,13 @@ async fn check_request_skip_wal_mixed_batch_recovery(
         );
     }
 
-    // A no-flush close discards memtables. Only WAL-backed rows recover
-    // unless an explicit flush has already persisted all requests.
-    reopen_region(&engine, region_id, table_dir, true, HashMap::new()).await;
+    // Bypass region close so only WAL-backed rows recover unless the explicit
+    // flush above persisted all requests.
+    let engine =
+        restart_without_region_close(&mut env, engine, flat_format, region_id, table_dir).await;
+    engine
+        .set_region_role(region_id, RegionRole::Leader)
+        .unwrap();
     let loses_skipped_rows = skip_wal && !flush_before_reopen;
     let mut expected_values = if loses_skipped_rows {
         vec![(0, 20.0), (1000, 1.0), (3000, 21.0)]
@@ -1830,3 +1837,38 @@ async fn request_skip_wal_values(engine: &MitoEngine, region_id: RegionId) -> Ve
     values.sort_unstable_by_key(|(timestamp, _)| *timestamp);
     values
 }
+
+/// Restarts workers without closing regions, preserving WAL-only recovery coverage.
+async fn restart_without_region_close(
+    env: &mut TestEnv,
+    engine: MitoEngine,
+    flat_format: bool,
+    region_id: RegionId,
+    table_dir: String,
+) -> MitoEngine {
+    let engine = env
+        .reopen_engine(
+            engine,
+            MitoConfig {
+                default_flat_format: flat_format,
+                ..Default::default()
+            },
+        )
+        .await;
+    engine
+        .handle_request(
+            region_id,
+            RegionRequest::Open(RegionOpenRequest {
+                engine: String::new(),
+                table_dir,
+                options: HashMap::new(),
+                skip_wal_replay: false,
+                path_type: PathType::Bare,
+                checkpoint: None,
+                requirements: Default::default(),
+            }),
+        )
+        .await
+        .unwrap();
+    engine
+}
diff --git a/src/mito2/src/engine/flush_test.rs b/src/mito2/src/engine/flush_test.rs
index b040ae5ec54..c7b4be14587 100644
--- a/src/mito2/src/engine/flush_test.rs
+++ b/src/mito2/src/engine/flush_test.rs
@@ -24,9 +24,11 @@ use api::v1::Rows;
 use async_trait::async_trait;
 use common_base::Plugins;
 use common_base::readable_size::ReadableSize;
+use common_error::ext::{ErrorExt, RetryHint};
 use common_recordbatch::RecordBatches;
 use common_time::util::current_time_millis;
 use common_wal::options::{KafkaWalOptions, WAL_OPTIONS_KEY, WalOptions};
+use datafusion_expr::{col, lit};
 use parquet::basic::{Encoding, Type as PhysicalType};
 use rstest::rstest;
 use rstest_reuse::{self, apply};
@@ -35,9 +37,9 @@ use store_api::metadata::RegionMetadataRef;
 use store_api::mito_engine_options::WRITE_BUFFER_SIZE_KEY;
 use store_api::region_engine::{RegionEngine, RegionRole};
 use store_api::region_request::{
-    AlterKind, PathType, RegionAlterRequest, RegionCloseRequest, RegionFlushRequest,
-    RegionOpenRequest, RegionPutRequest, RegionRequest, ReplayCheckpoint, SetRegionOption,
-    UnsetRegionOption,
+    AlterKind, PathType, RegionAlterRequest, RegionCloseRequest, RegionCompactRequest,
+    RegionFlushRequest, RegionOpenRequest, RegionPutRequest, RegionRequest, ReplayCheckpoint,
+    SetRegionOption, UnsetRegionOption,
 };
 use store_api::storage::{RegionId, ScanRequest};
 use tokio::sync::Notify;
@@ -49,9 +51,11 @@ use crate::engine::listener::{EventListener, FlushListener, StallListener};
 use crate::engine::region_hook::{RegionGcInfo, RegionHook, RegionHookRef, SstFileInfo};
 use crate::error::Error;
 use crate::manifest::action::RegionMetaActionList;
+use crate::memtable::RangesOptions;
 use crate::test_util::{
-    CreateRequestBuilder, LogStoreFactory, MockWriteBufferManager, TestEnv, build_rows,
-    build_rows_for_key, flush_region, kafka_log_store_factory, multiple_log_store_factories,
+    CreateRequestBuilder, LogStoreFactory, MockWriteBufferManager, TestEnv,
+    build_delete_rows_for_key, build_rows, build_rows_for_key, build_rows_with_fields, delete_rows,
+    delete_rows_schema, flush_region, kafka_log_store_factory, multiple_log_store_factories,
     prepare_test_for_kafka_log_store, put_rows, raft_engine_log_store_factory, reopen_region,
     rows_schema, single_kafka_log_store_factory,
 };
@@ -1003,6 +1007,7 @@ async fn test_region_write_buffer_rejects_only_full_region_queue() {
         .expect("the stalled queue should be rejected at the region hard limit")
         .unwrap()
         .unwrap_err();
+    assert_eq!(err.retry_hint(), RetryHint::Retryable);
     assert_matches!(
         err.into_inner().as_any().downcast_ref::<Error>().unwrap(),
         Error::RejectWrite { .. }
@@ -1818,3 +1823,303 @@ async fn test_region_hook() {
         manifest_count,
     );
 }
+
+/// Explicitly finish a merge instead of sleeping for the background dispatcher.
+fn compact_bulk_memtables(engine: &MitoEngine, region_id: RegionId) {
+    let version = engine.get_region(region_id).unwrap().version();
+    for memtable in version.memtables.list_memtables() {
+        memtable.compact(false).unwrap();
+    }
+}
+
+async fn scan_bulk_test_keys(engine: &MitoEngine, region_id: RegionId) -> String {
+    let mut schema = None;
+    let mut batches = Vec::new();
+    for key in ["deleted", "k"] {
+        let request = ScanRequest {
+            filters: vec![col("tag_0").eq(lit(key))],
+            ..Default::default()
+        };
+        let stream = engine.scan_to_stream(region_id, request).await.unwrap();
+        schema = Some(stream.schema());
+        batches.extend(RecordBatches::try_collect(stream).await.unwrap().take());
+    }
+    RecordBatches::try_new(schema.unwrap(), batches)
+        .unwrap()
+        .pretty_print()
+        .unwrap()
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_bulk_flush_keeps_newer_version(#[values(false, true)] delete_newer: bool) {
+    let mut env = TestEnv::new().await;
+    let config = MitoConfig {
+        default_flat_format: true,
+        min_compaction_interval: Duration::from_secs(3600),
+        ..Default::default()
+    };
+    let engine = env.create_engine(config.clone()).await;
+    let region_id = RegionId::new(1, 1);
+    let request = CreateRequestBuilder::new()
+        .insert_option("memtable.type", "bulk")
+        .insert_option("memtable.bulk.merge_threshold", "2")
+        .insert_option("memtable.bulk.encode_row_threshold", "1")
+        .build();
+    let schema = rows_schema(&request);
+    let delete_schema = delete_rows_schema(&request);
+    engine
+        .handle_request(region_id, RegionRequest::Create(request.clone()))
+        .await
+        .unwrap();
+    put_rows(
+        &engine,
+        region_id,
+        Rows {
+            schema: schema.clone(),
+            rows: build_rows_for_key("k", 1, 2, 1),
+        },
+    )
+    .await;
+    put_rows(
+        &engine,
+        region_id,
+        Rows {
+            schema: schema.clone(),
+            rows: build_rows_for_key("a", 0, 1024, 0),
+        },
+    )
+    .await;
+    if delete_newer {
+        let mut rows = build_delete_rows_for_key("b", 0, 1023);
+        rows.extend(build_delete_rows_for_key("k", 1, 2));
+        delete_rows(
+            &engine,
+            region_id,
+            Rows {
+                schema: delete_schema,
+                rows,
+            },
+        )
+        .await;
+    } else {
+        let mut rows = build_rows_for_key("b", 0, 1023, 0);
+        rows.extend(build_rows_for_key("k", 1, 2, 2));
+        put_rows(
+            &engine,
+            region_id,
+            Rows {
+                schema: schema.clone(),
+                rows,
+            },
+        )
+        .await;
+    }
+    compact_bulk_memtables(&engine, region_id);
+    // Previously this advanced the old unordered row above the newer encoded row.
+    put_rows(
+        &engine,
+        region_id,
+        Rows {
+            schema,
+            rows: build_rows_for_key("c", 0, 1, 0),
+        },
+    )
+    .await;
+    let expected = if delete_newer {
+        "\
++-------+---------+----+
+| tag_0 | field_0 | ts |
++-------+---------+----+
++-------+---------+----+"
+    } else {
+        "\
++-------+---------+---------------------+
+| tag_0 | field_0 | ts                  |
++-------+---------+---------------------+
+| k     | 2.0     | 1970-01-01T00:00:01 |
++-------+---------+---------------------+"
+    };
+    assert_eq!(expected, scan_bulk_test_keys(&engine, region_id).await);
+    flush_region(&engine, region_id, None).await;
+    assert_eq!(expected, scan_bulk_test_keys(&engine, region_id).await);
+    let engine = env.reopen_engine(engine, config).await;
+    reopen_region(
+        &engine,
+        region_id,
+        request.table_dir,
+        false,
+        request.options,
+    )
+    .await;
+    assert_eq!(expected, scan_bulk_test_keys(&engine, region_id).await);
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_bulk_last_non_null_merge_and_flush(#[values(false, true)] encoded: bool) {
+    let mut env = TestEnv::new().await;
+    let config = MitoConfig {
+        default_flat_format: true,
+        min_compaction_interval: Duration::from_secs(3600),
+        ..Default::default()
+    };
+    let engine = env.create_engine(config.clone()).await;
+    let region_id = RegionId::new(1, 1);
+    env.get_schema_metadata_manager()
+        .register_region_table_info(
+            region_id.table_id(),
+            "test_table",
+            "test_catalog",
+            "test_schema",
+            None,
+            env.get_kv_backend(),
+        )
+        .await;
+    let request = CreateRequestBuilder::new()
+        .field_num(2)
+        .insert_option("memtable.type", "bulk")
+        .insert_option("merge_mode", "last_non_null")
+        .insert_option("memtable.bulk.merge_threshold", "4")
+        .insert_option(
+            "memtable.bulk.encode_row_threshold",
+            if encoded { "1" } else { "1000000" },
+        )
+        .insert_option("compaction.type", "twcs")
+        .insert_option("compaction.twcs.trigger_file_num", "2")
+        .build();
+    let schema = rows_schema(&request);
+    engine
+        .handle_request(region_id, RegionRequest::Create(request.clone()))
+        .await
+        .unwrap();
+    // An older SST must remain hidden behind a delete retained in the memtable.
+    put_rows(
+        &engine,
+        region_id,
+        Rows {
+            schema: schema.clone(),
+            rows: build_rows_with_fields("deleted", &[1], &[(Some(1), Some(1))]),
+        },
+    )
+    .await;
+    flush_region(&engine, region_id, None).await;
+
+    let mut a = build_rows_with_fields(
+        "a",
+        &(0..1023).collect::<Vec<_>>(),
+        &[(Some(0), None); 1023],
+    );
+    a.extend(build_rows_with_fields("k", &[1], &[(Some(1), None)]));
+    put_rows(
+        &engine,
+        region_id,
+        Rows {
+            schema: schema.clone(),
+            rows: a,
+        },
+    )
+    .await;
+    // Intermediate writes must be bulk parts, not an unordered merge barrier.
+    let mut b = build_rows_with_fields(
+        "b",
+        &(0..1023).collect::<Vec<_>>(),
+        &[(Some(0), None); 1023],
+    );
+    b.extend(build_rows_with_fields("k", &[1], &[(Some(2), None)]));
+    put_rows(
+        &engine,
+        region_id,
+        Rows {
+            schema: schema.clone(),
+            rows: b,
+        },
+    )
+    .await;
+    let mut deletes = build_delete_rows_for_key("d", 0, 1023);
+    deletes.extend(build_delete_rows_for_key("deleted", 1, 2));
+    delete_rows(
+        &engine,
+        region_id,
+        Rows {
+            schema: delete_rows_schema(&request),
+            rows: deletes,
+        },
+    )
+    .await;
+    let before = scan_bulk_test_keys(&engine, region_id).await;
+    assert!(before.contains("| k     | 2.0"));
+    assert!(!before.contains("| deleted"));
+
+    let mut c = build_rows_with_fields(
+        "c",
+        &(0..1022).collect::<Vec<_>>(),
+        &[(Some(0), None); 1022],
+    );
+    c.extend(build_rows_with_fields("k", &[1], &[(None, Some(3))]));
+    c.extend(build_rows_with_fields("deleted", &[1], &[(None, Some(3))]));
+    put_rows(
+        &engine,
+        region_id,
+        Rows {
+            schema: schema.clone(),
+            rows: c,
+        },
+    )
+    .await;
+    compact_bulk_memtables(&engine, region_id);
+    // All four sources must have merged, with the requested output format.
+    let version = engine.get_region(region_id).unwrap().version();
+    let mut ranges = Vec::new();
+    for memtable in version.memtables.list_memtables() {
+        ranges.extend(
+            memtable
+                .ranges(None, RangesOptions::default())
+                .unwrap()
+                .ranges
+                .into_values(),
+        );
+    }
+    assert_eq!(1, ranges.len());
+    assert_eq!(encoded, ranges[0].encoded().is_some());
+    drop(ranges);
+    drop(version);
+    let expected = "\
++---------+---------+---------+---------------------+
+| tag_0   | field_0 | field_1 | ts                  |
++---------+---------+---------+---------------------+
+| deleted |         | 3.0     | 1970-01-01T00:00:01 |
+| k       | 2.0     | 3.0     | 1970-01-01T00:00:01 |
++---------+---------+---------+---------------------+";
+    assert_eq!(expected, scan_bulk_test_keys(&engine, region_id).await);
+    // Leave a raw source beside merged parts so flush also exercises grouping.
+    put_rows(
+        &engine,
+        region_id,
+        Rows {
+            schema,
+            rows: build_rows_with_fields("z", &[0], &[(Some(0), None)]),
+        },
+    )
+    .await;
+    flush_region(&engine, region_id, None).await;
+    assert_eq!(expected, scan_bulk_test_keys(&engine, region_id).await);
+    engine
+        .handle_request(
+            region_id,
+            RegionRequest::Compact(RegionCompactRequest::default()),
+        )
+        .await
+        .unwrap();
+    assert_eq!(expected, scan_bulk_test_keys(&engine, region_id).await);
+    let engine = env.reopen_engine(engine, config).await;
+    reopen_region(
+        &engine,
+        region_id,
+        request.table_dir,
+        false,
+        request.options,
+    )
+    .await;
+    assert_eq!(expected, scan_bulk_test_keys(&engine, region_id).await);
+}
diff --git a/src/mito2/src/engine/prune_test.rs b/src/mito2/src/engine/prune_test.rs
index f2171510345..71e6845e96f 100644
--- a/src/mito2/src/engine/prune_test.rs
+++ b/src/mito2/src/engine/prune_test.rs
@@ -288,7 +288,7 @@ async fn test_prune_memtable_complex_expr_with_format(flat_format: bool) {
     )
     .await;
 
-    // ts filter will be ignored when pruning time series in memtable.
+    // Both the compound time range and the tag predicate are evaluated during the scan.
     let filters = vec![time_range_expr(4, 7), col("tag_0").lt(lit("6"))];
 
     let stream = engine
@@ -306,10 +306,6 @@ async fn test_prune_memtable_complex_expr_with_format(flat_format: bool) {
 +-------+---------+---------------------+
 | tag_0 | field_0 | ts                  |
 +-------+---------+---------------------+
-| 0     | 0.0     | 1970-01-01T00:00:00 |
-| 1     | 1.0     | 1970-01-01T00:00:01 |
-| 2     | 2.0     | 1970-01-01T00:00:02 |
-| 3     | 3.0     | 1970-01-01T00:00:03 |
 | 4     | 4.0     | 1970-01-01T00:00:04 |
 | 5     | 5.0     | 1970-01-01T00:00:05 |
 +-------+---------+---------------------+";
diff --git a/src/mito2/src/engine/puffin_index.rs b/src/mito2/src/engine/puffin_index.rs
index 278d9017e7f..48833f237d1 100644
--- a/src/mito2/src/engine/puffin_index.rs
+++ b/src/mito2/src/engine/puffin_index.rs
@@ -39,7 +39,8 @@ use crate::cache::index::inverted_index::{CachedInvertedIndexBlobReader, Inverte
 use crate::sst::file::RegionIndexId;
 use crate::sst::index::bloom_filter::INDEX_BLOB_TYPE as BLOOM_BLOB_TYPE;
 use crate::sst::index::fulltext_index::{
-    INDEX_BLOB_TYPE_BLOOM as FULLTEXT_BLOOM_BLOB_TYPE,
+    FULLTEXT_BLOOM_VERSION, INDEX_BLOB_TYPE_BLOOM as FULLTEXT_BLOOM_BLOB_TYPE,
+    INDEX_BLOB_TYPE_BLOOM_V1 as FULLTEXT_BLOOM_V1_BLOB_TYPE,
     INDEX_BLOB_TYPE_TANTIVY as FULLTEXT_TANTIVY_BLOB_TYPE,
 };
 use crate::sst::index::inverted_index::INDEX_BLOB_TYPE as INVERTED_BLOB_TYPE;
@@ -126,7 +127,7 @@ pub(crate) async fn collect_index_entries_from_puffin(
                 );
                 entries.push(entry);
             }
-            Some(BlobIndexTypeTargetKey::FulltextBloom(target_key)) => {
+            Some(BlobIndexTypeTargetKey::FulltextBloom(target_key, bloom_version)) => {
                 let bloom_meta = try_read_bloom_meta(
                     &reader,
                     region_index_id,
@@ -139,7 +140,7 @@ pub(crate) async fn collect_index_entries_from_puffin(
                 .await;
 
                 let bloom_value = bloom_meta.as_deref().map(bloom_meta_value);
-                let fulltext_value = Some(fulltext_meta_value(blob));
+                let fulltext_value = Some(fulltext_meta_value(blob, Some(bloom_version)));
                 let (target_type, target_json) = decode_target_info(target_key);
                 let meta_json = build_meta_json(bloom_value, fulltext_value, None);
                 let entry = build_index_entry(
@@ -154,7 +155,7 @@ pub(crate) async fn collect_index_entries_from_puffin(
                 entries.push(entry);
             }
             Some(BlobIndexTypeTargetKey::FulltextTantivy(target_key)) => {
-                let fulltext_value = Some(fulltext_meta_value(blob));
+                let fulltext_value = Some(fulltext_meta_value(blob, None));
                 let (target_type, target_json) = decode_target_info(target_key);
                 let meta_json = build_meta_json(None, fulltext_value, None);
                 let entry = build_index_entry(
@@ -392,12 +393,16 @@ fn bloom_meta_value(meta: &BloomFilterMeta) -> Value {
     })
 }
 
-fn fulltext_meta_value(blob: &BlobMetadata) -> Value {
+fn fulltext_meta_value(blob: &BlobMetadata, bloom_version: Option<u8>) -> Value {
     let config = FulltextConfig::from_blob_metadata(blob).unwrap_or_default();
-    json!({
+    let mut value = json!({
         "analyzer": config.analyzer.to_str(),
         "case_sensitive": config.case_sensitive,
-    })
+    });
+    if let Some(version) = bloom_version {
+        value["bloom_version"] = json!(version);
+    }
+    value
 }
 
 fn inverted_meta_value(meta: &InvertedIndexMeta, metas: &InvertedIndexMetas) -> Value {
@@ -441,7 +446,8 @@ fn build_meta_json(
 
 enum BlobIndexTypeTargetKey<'a> {
     BloomFilter(&'a str),
-    FulltextBloom(&'a str),
+    /// Target key and version of a fulltext bloom blob.
+    FulltextBloom(&'a str, u8),
     FulltextTantivy(&'a str),
     Inverted,
 }
@@ -451,9 +457,17 @@ impl<'a> BlobIndexTypeTargetKey<'a> {
         if let Some(target_key) = Self::target_key_from_blob(blob_type, BLOOM_BLOB_TYPE) {
             Some(BlobIndexTypeTargetKey::BloomFilter(target_key))
         } else if let Some(target_key) =
+            // v2 goes first: the v1 type is a prefix of it.
             Self::target_key_from_blob(blob_type, FULLTEXT_BLOOM_BLOB_TYPE)
         {
-            Some(BlobIndexTypeTargetKey::FulltextBloom(target_key))
+            Some(BlobIndexTypeTargetKey::FulltextBloom(
+                target_key,
+                FULLTEXT_BLOOM_VERSION,
+            ))
+        } else if let Some(target_key) =
+            Self::target_key_from_blob(blob_type, FULLTEXT_BLOOM_V1_BLOB_TYPE)
+        {
+            Some(BlobIndexTypeTargetKey::FulltextBloom(target_key, 1))
         } else if let Some(target_key) =
             Self::target_key_from_blob(blob_type, FULLTEXT_TANTIVY_BLOB_TYPE)
         {
diff --git a/src/mito2/src/engine/scan_test.rs b/src/mito2/src/engine/scan_test.rs
index e10968d3a32..f86b327735d 100644
--- a/src/mito2/src/engine/scan_test.rs
+++ b/src/mito2/src/engine/scan_test.rs
@@ -56,7 +56,7 @@ use store_api::metric_engine_consts::PRIMARY_KEY_ENCODING;
 use store_api::region_engine::{PrepareRequest, RegionEngine, RegionScanner};
 use store_api::region_request::{
     AlterKind, RegionAlterRequest, RegionBulkInsertsRequest, RegionCompactRequest,
-    RegionPutRequest, RegionRequest, SetRegionOption,
+    RegionOpenRequest, RegionPutRequest, RegionRequest, SetRegionOption,
 };
 use store_api::storage::consts::PRIMARY_KEY_COLUMN_NAME;
 use store_api::storage::{
@@ -73,6 +73,215 @@ use crate::test_util;
 use crate::test_util::sst_util::{new_sparse_primary_key, sst_region_metadata_with_encoding};
 use crate::test_util::{CreateRequestBuilder, TestEnv, reopen_region};
 
+#[tokio::test]
+async fn test_nullable_label_filters_in_memtables_and_ssts() {
+    use datafusion_expr::{BinaryExpr as LogicalBinaryExpr, Cast, Expr};
+
+    for (flat, memtable) in [(false, "time_series"), (true, "bulk")] {
+        let mut env = TestEnv::new().await;
+        let engine = env
+            .create_engine(MitoConfig {
+                default_flat_format: flat,
+                ..Default::default()
+            })
+            .await;
+        let region_id = RegionId::new(1, 1);
+        let request = CreateRequestBuilder::new()
+            .insert_option("memtable.type", memtable)
+            .build();
+        let schema = test_util::rows_schema(&request);
+        engine
+            .handle_request(region_id, RegionRequest::Create(request))
+            .await
+            .unwrap();
+        let rows = [None, Some(""), Some("tmpfs"), Some("ext4")]
+            .into_iter()
+            .enumerate()
+            .map(|(i, label)| {
+                let mut row = row(vec![
+                    ValueData::StringValue(String::new()),
+                    ValueData::F64Value(i as f64),
+                    ValueData::TimestampMillisecondValue(i as i64),
+                ]);
+                row.values[0].value_data = label.map(|v| ValueData::StringValue(v.into()));
+                row
+            })
+            .collect();
+        test_util::put_rows(&engine, region_id, Rows { schema, rows }).await;
+        for flushed in [false, true] {
+            if flushed {
+                test_util::flush_region(&engine, region_id, None).await;
+            }
+            let mut cases = Vec::new();
+            for (op, literal, include_null, expected) in [
+                (Operator::NotEq, "tmpfs", true, vec![0, 1, 3]),
+                (
+                    Operator::RegexNotMatch,
+                    "^(?:tmpfs|vfat)$",
+                    true,
+                    vec![0, 1, 3],
+                ),
+                (Operator::Eq, "", true, vec![0, 1]),
+                (Operator::NotEq, "", false, vec![2, 3]),
+                (Operator::RegexMatch, "^(?:ext4)$", false, vec![3]),
+            ] {
+                for cast in [false, true] {
+                    let column = if cast {
+                        Expr::Cast(Cast::new(Box::new(col("tag_0")), DataType::Utf8))
+                    } else {
+                        col("tag_0")
+                    };
+                    let comparison = Expr::BinaryExpr(LogicalBinaryExpr::new(
+                        Box::new(column),
+                        op,
+                        Box::new(lit(literal)),
+                    ));
+                    let filter = if include_null {
+                        col("tag_0").is_null().or(comparison)
+                    } else {
+                        comparison
+                    };
+                    cases.push((filter, expected.clone()));
+                }
+            }
+            let column = col("tag_0");
+            cases.extend([
+                (column.clone().is_null(), vec![0]),
+                (column.clone().is_not_null(), vec![1, 2, 3]),
+                (
+                    column
+                        .clone()
+                        .is_null()
+                        .or(column.clone().not_eq(lit("tmpfs")))
+                        .and(column.clone().is_null().or(column.clone().not_eq(lit("")))),
+                    vec![0, 3],
+                ),
+                (
+                    column.clone().eq(lit("ext4")).or(column.eq(lit("tmpfs"))),
+                    vec![2, 3],
+                ),
+            ]);
+            for (filter, expected) in cases {
+                let stream = engine
+                    .scan_to_stream(
+                        region_id,
+                        ScanRequest {
+                            filters: vec![filter.clone()],
+                            distribution: flat.then_some(TimeSeriesDistribution::PerSeries),
+                            ..Default::default()
+                        },
+                    )
+                    .await
+                    .unwrap();
+                let batches = RecordBatches::try_collect(stream).await.unwrap();
+                let mut actual = Vec::new();
+                for batch in batches.iter() {
+                    let ts = batch
+                        .column_by_name("ts")
+                        .unwrap()
+                        .as_primitive::<TimestampMillisecondType>();
+                    actual.extend(ts.values().iter().copied());
+                }
+                actual.sort_unstable();
+                assert_eq!(actual, expected, "flat={flat}, flushed={flushed}, {filter}");
+            }
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_compound_time_filters_before_last_row() {
+    for (flat, memtable) in [
+        (false, "time_series"),
+        (true, "time_series"),
+        (true, "bulk"),
+    ] {
+        let mut env = TestEnv::new().await;
+        let engine = env
+            .create_engine(MitoConfig {
+                default_flat_format: flat,
+                ..Default::default()
+            })
+            .await;
+        let region_id = RegionId::new(1, 1);
+        let request = CreateRequestBuilder::new()
+            .insert_option("memtable.type", memtable)
+            .build();
+        let schema = test_util::rows_schema(&request);
+        engine
+            .handle_request(region_id, RegionRequest::Create(request))
+            .await
+            .unwrap();
+        let rows = (0..5)
+            .map(|i| {
+                row(vec![
+                    ValueData::StringValue("series".into()),
+                    ValueData::F64Value(i as f64),
+                    ValueData::TimestampMillisecondValue(i),
+                ])
+            })
+            .collect();
+        test_util::put_rows(&engine, region_id, Rows { schema, rows }).await;
+        let ts = |value| lit(ScalarValue::TimestampMillisecond(Some(value), None));
+        let cases = [
+            (col("ts").eq(ts(1)).or(col("ts").eq(ts(3))), vec![1, 3]),
+            (col("ts").gt_eq(ts(1)).and(col("ts").lt(ts(3))), vec![1, 2]),
+            (col("ts").is_null().or(col("ts").lt(ts(2))), vec![0, 1]),
+        ];
+        for flushed in [false, true] {
+            if flushed {
+                test_util::flush_region(&engine, region_id, None).await;
+            }
+            for (filter, expected) in &cases {
+                for selector in [
+                    None,
+                    Some(TimeSeriesRowSelector::LastRow { after_merge: false }),
+                    Some(TimeSeriesRowSelector::LastRow { after_merge: true }),
+                ] {
+                    let stream = engine
+                        .scan_to_stream(
+                            region_id,
+                            ScanRequest {
+                                filters: vec![
+                                    col("tag_0").is_null().or(col("tag_0").eq(lit("series"))),
+                                    filter.clone(),
+                                ],
+                                distribution: flat.then_some(TimeSeriesDistribution::PerSeries),
+                                series_row_selector: selector,
+                                ..Default::default()
+                            },
+                        )
+                        .await
+                        .unwrap();
+                    let batches = RecordBatches::try_collect(stream).await.unwrap();
+                    let mut actual = Vec::new();
+                    for batch in batches.iter() {
+                        actual.extend(
+                            batch
+                                .column_by_name("ts")
+                                .unwrap()
+                                .as_primitive::<TimestampMillisecondType>()
+                                .values()
+                                .iter()
+                                .copied(),
+                        );
+                    }
+                    actual.sort_unstable();
+                    let expected = if selector.is_some() {
+                        expected.last().copied().into_iter().collect::<Vec<_>>()
+                    } else {
+                        expected.clone()
+                    };
+                    assert_eq!(
+                        actual, expected,
+                        "flat={flat}, memtable={memtable}, flushed={flushed}, selector={selector:?}, {filter}"
+                    );
+                }
+            }
+        }
+    }
+}
+
 #[tokio::test]
 async fn test_json_type_hint_pushdown_scanner_returns_batches() -> WhateverResult<()> {
     // Create a region with a JSON2 field whose physical Parquet representation is a nested struct.
@@ -2782,13 +2991,21 @@ fn build_bulk_insert_request(
 
 #[tokio::test]
 async fn test_bulk_skip_wal_recovery() {
-    check_bulk_skip_wal_recovery(false, false).await;
-    check_bulk_skip_wal_recovery(false, true).await;
-    check_bulk_skip_wal_recovery(true, false).await;
-    check_bulk_skip_wal_recovery(true, true).await;
+    check_bulk_skip_wal_recovery(false, false, false).await;
+    check_bulk_skip_wal_recovery(false, true, false).await;
+    check_bulk_skip_wal_recovery(true, false, false).await;
+    check_bulk_skip_wal_recovery(true, true, false).await;
 }
 
-async fn check_bulk_skip_wal_recovery(skip_wal: bool, flush: bool) {
+#[tokio::test]
+async fn test_bulk_skip_wal_close_recovery() {
+    check_bulk_skip_wal_recovery(false, false, true).await;
+    check_bulk_skip_wal_recovery(false, true, true).await;
+    check_bulk_skip_wal_recovery(true, false, true).await;
+    check_bulk_skip_wal_recovery(true, true, true).await;
+}
+
+async fn check_bulk_skip_wal_recovery(skip_wal: bool, flush: bool, close: bool) {
     let mut env = TestEnv::new().await;
     let engine = env.create_engine(MitoConfig::default()).await;
     let region_id = RegionId::new(1, 1);
@@ -2839,7 +3056,41 @@ async fn check_bulk_skip_wal_recovery(skip_wal: bool, flush: bool) {
             u64::from(!skip_wal)
         );
     }
-    reopen_region(&engine, region_id, table_dir, false, HashMap::new()).await;
+    let engine = if close {
+        reopen_region(&engine, region_id, table_dir, false, HashMap::new()).await;
+        assert_eq!(
+            region.version().flushed_sequence,
+            if flush || skip_wal { 4 } else { 0 }
+        );
+        engine
+    } else {
+        // Stopping the engine directly exercises recovery without close-time flush.
+        let engine = env.reopen_engine(engine, MitoConfig::default()).await;
+        engine
+            .handle_request(
+                region_id,
+                RegionRequest::Open(RegionOpenRequest {
+                    engine: String::new(),
+                    table_dir,
+                    path_type: store_api::region_request::PathType::Bare,
+                    options: HashMap::new(),
+                    skip_wal_replay: false,
+                    checkpoint: None,
+                    requirements: Default::default(),
+                }),
+            )
+            .await
+            .unwrap();
+        engine
+    };
+    assert!(
+        !engine
+            .get_region(region_id)
+            .unwrap()
+            .version()
+            .memtables
+            .has_skip_wal_writes()
+    );
     let stream = engine
         .scan_to_stream(region_id, ScanRequest::default())
         .await
@@ -2851,7 +3102,7 @@ async fn check_bulk_skip_wal_recovery(skip_wal: bool, flush: bool) {
             .iter()
             .map(|b| b.num_rows())
             .sum::<usize>(),
-        if skip_wal && !flush { 0 } else { 4 }
+        if skip_wal && !flush && !close { 0 } else { 4 }
     );
 }
 
diff --git a/src/mito2/src/engine/skip_wal_test.rs b/src/mito2/src/engine/skip_wal_test.rs
index 363318d1cf5..915099e7228 100644
--- a/src/mito2/src/engine/skip_wal_test.rs
+++ b/src/mito2/src/engine/skip_wal_test.rs
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -34,7 +35,7 @@ use crate::engine::listener::AlterFlushListener;
 use crate::test_util::{
     CreateRequestBuilder, LogStoreFactory, TestEnv, build_rows, flush_region,
     kafka_log_store_factory, multiple_log_store_factories, prepare_test_for_kafka_log_store,
-    put_rows, raft_engine_log_store_factory, rows_schema,
+    put_rows, raft_engine_log_store_factory, reopen_region, rows_schema,
 };
 
 fn set_skip_wal_request(skip_wal: bool) -> RegionRequest {
@@ -920,3 +921,192 @@ async fn test_close_region_after_truncate_skip_wal() {
     let total_rows: usize = batches.iter().map(|b| b.num_rows()).sum();
     assert_eq!(3, total_rows);
 }
+
+#[rstest]
+#[case(false)]
+#[case(true)]
+#[tokio::test]
+async fn test_close_request_skip_wal(
+    #[case] skip_wal: bool,
+    #[values(false, true)] flat_format: bool,
+) {
+    let mut env = TestEnv::with_prefix("close-request-skip-wal").await;
+    let engine = env
+        .create_engine(MitoConfig {
+            default_flat_format: flat_format,
+            ..Default::default()
+        })
+        .await;
+    let region_id = RegionId::new(1, 1);
+    let request = CreateRequestBuilder::new().build();
+    engine
+        .handle_request(region_id, RegionRequest::Create(request.clone()))
+        .await
+        .unwrap();
+    engine
+        .handle_request(
+            region_id,
+            RegionRequest::Put(RegionPutRequest {
+                skip_wal,
+                rows: Rows {
+                    schema: rows_schema(&request),
+                    rows: build_rows(0, 3),
+                },
+                hint: None,
+                partition_expr_version: None,
+            }),
+        )
+        .await
+        .unwrap();
+    let region = engine.get_region(region_id).unwrap();
+    assert!(!region.skip_wal());
+    assert_eq!(region.version().memtables.has_skip_wal_writes(), skip_wal);
+    let expected = common_recordbatch::RecordBatches::try_collect(
+        engine
+            .scan_to_stream(region_id, ScanRequest::default())
+            .await
+            .unwrap(),
+    )
+    .await
+    .unwrap()
+    .pretty_print()
+    .unwrap();
+
+    reopen_region(&engine, region_id, request.table_dir, false, HashMap::new()).await;
+    // Logged writes are recovered without a close-time flush.
+    assert_eq!(
+        region.version().flushed_sequence,
+        if skip_wal { 3 } else { 0 }
+    );
+    let reopened = engine.get_region(region_id).unwrap();
+    assert!(!reopened.version().memtables.has_skip_wal_writes());
+    let actual = common_recordbatch::RecordBatches::try_collect(
+        engine
+            .scan_to_stream(region_id, ScanRequest::default())
+            .await
+            .unwrap(),
+    )
+    .await
+    .unwrap()
+    .pretty_print()
+    .unwrap();
+    assert_eq!(actual, expected);
+}
+
+#[rstest]
+#[case(false)]
+#[case(true)]
+#[tokio::test]
+async fn test_close_request_skip_wal_during_flush(#[case] new_skip_wal: bool) {
+    let mut env = TestEnv::with_prefix("close-request-skip-wal-during-flush").await;
+    let listener = Arc::new(AlterFlushListener::default());
+    let engine = env
+        .create_engine_with(MitoConfig::default(), None, Some(listener.clone()), None)
+        .await;
+    let region_id = RegionId::new(1, 1);
+    let request = CreateRequestBuilder::new().build();
+    engine
+        .handle_request(region_id, RegionRequest::Create(request.clone()))
+        .await
+        .unwrap();
+    engine
+        .handle_request(
+            region_id,
+            RegionRequest::Put(RegionPutRequest {
+                skip_wal: true,
+                rows: Rows {
+                    schema: rows_schema(&request),
+                    rows: build_rows(0, 3),
+                },
+                hint: None,
+                partition_expr_version: None,
+            }),
+        )
+        .await
+        .unwrap();
+    let region = engine.get_region(region_id).unwrap();
+    let engine_cloned = engine.clone();
+    let flush_job = tokio::spawn(async move {
+        flush_region(&engine_cloned, region_id, None).await;
+    });
+    tokio::time::timeout(Duration::from_secs(5), listener.wait_flush_begin())
+        .await
+        .unwrap();
+
+    // These rows belong to the next mutable, while the skipped rows are frozen.
+    engine
+        .handle_request(
+            region_id,
+            RegionRequest::Put(RegionPutRequest {
+                skip_wal: new_skip_wal,
+                rows: Rows {
+                    schema: rows_schema(&request),
+                    rows: build_rows(3, 6),
+                },
+                hint: None,
+                partition_expr_version: None,
+            }),
+        )
+        .await
+        .unwrap();
+    let expected = common_recordbatch::RecordBatches::try_collect(
+        engine
+            .scan_to_stream(region_id, ScanRequest::default())
+            .await
+            .unwrap(),
+    )
+    .await
+    .unwrap()
+    .pretty_print()
+    .unwrap();
+    let request_count = listener.request_count();
+    let engine_cloned = engine.clone();
+    let close_job = tokio::spawn(async move {
+        engine_cloned
+            .handle_request(
+                region_id,
+                RegionRequest::Close(RegionCloseRequest::default()),
+            )
+            .await
+            .unwrap();
+    });
+    tokio::time::timeout(
+        Duration::from_secs(5),
+        listener.wait_request_count(request_count + 1),
+    )
+    .await
+    .unwrap();
+    listener.wake_flush();
+    tokio::time::timeout(Duration::from_secs(5), flush_job)
+        .await
+        .unwrap()
+        .unwrap();
+    if new_skip_wal {
+        tokio::time::timeout(Duration::from_secs(5), listener.wait_flush_begin())
+            .await
+            .unwrap();
+        listener.wake_flush();
+    }
+    tokio::time::timeout(Duration::from_secs(5), close_job)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        region.version().flushed_sequence,
+        if new_skip_wal { 6 } else { 3 }
+    );
+    assert!(!region.version().memtables.has_skip_wal_writes());
+
+    reopen_region(&engine, region_id, request.table_dir, false, HashMap::new()).await;
+    let actual = common_recordbatch::RecordBatches::try_collect(
+        engine
+            .scan_to_stream(region_id, ScanRequest::default())
+            .await
+            .unwrap(),
+    )
+    .await
+    .unwrap()
+    .pretty_print()
+    .unwrap();
+    assert_eq!(actual, expected);
+}
diff --git a/src/mito2/src/engine/staging_test.rs b/src/mito2/src/engine/staging_test.rs
index bd823708509..1b2a7ffee13 100644
--- a/src/mito2/src/engine/staging_test.rs
+++ b/src/mito2/src/engine/staging_test.rs
@@ -18,11 +18,14 @@ use std::sync::Arc;
 use std::time::Duration;
 use std::{assert_matches, fs};
 
-use api::v1::Rows;
-use common_error::ext::ErrorExt;
+use api::v1::{ArrowIpc, Rows};
+use common_error::ext::{ErrorExt, RetryHint};
 use common_error::status_code::StatusCode;
 use common_function::utils::partition_expr_version;
+use common_grpc::flight;
 use common_recordbatch::RecordBatches;
+use datatypes::arrow::array::{ArrayRef, Float64Array, StringArray, TimestampMillisecondArray};
+use datatypes::arrow::record_batch::RecordBatch;
 use datatypes::value::Value;
 use object_store::Buffer;
 use object_store::layers::mock::{
@@ -34,8 +37,9 @@ use store_api::region_engine::{
     RegionEngine, RemapManifestsRequest, SetRegionRoleStateResponse, SettableRegionRoleState,
 };
 use store_api::region_request::{
-    ApplyStagingManifestRequest, EnterStagingRequest, RegionAlterRequest, RegionFlushRequest,
-    RegionPutRequest, RegionRequest, RegionTruncateRequest, StagingPartitionDirective,
+    ApplyStagingManifestRequest, EnterStagingRequest, RegionAlterRequest, RegionBulkInsertsRequest,
+    RegionFlushRequest, RegionPutRequest, RegionRequest, RegionTruncateRequest,
+    StagingPartitionDirective,
 };
 use store_api::storage::{RegionId, ScanRequest};
 
@@ -254,7 +258,7 @@ fn default_partition_expr() -> String {
 }
 
 #[tokio::test]
-async fn test_staging_reject_all_writes_rejects_put() {
+async fn test_staging_reject_all_writes_rejects_put_and_bulk() {
     let mut env = TestEnv::new().await;
     let engine = env.create_engine(MitoConfig::default()).await;
 
@@ -281,23 +285,50 @@ async fn test_staging_reject_all_writes_rejects_put() {
         schema: column_schemas,
         rows: build_rows(0, 2),
     };
-    let err = engine
-        .handle_request(
+    let payload = RecordBatch::try_from_iter([
+        (
+            "tag_0",
+            Arc::new(StringArray::from(vec!["0", "1"])) as ArrayRef,
+        ),
+        (
+            "field_0",
+            Arc::new(Float64Array::from(vec![0.0, 1.0])) as ArrayRef,
+        ),
+        (
+            "ts",
+            Arc::new(TimestampMillisecondArray::from(vec![0, 1000])) as ArrayRef,
+        ),
+    ])
+    .unwrap();
+    let (schema, data_header, data) = flight::record_batch_to_ipc(payload.clone()).unwrap();
+    for request in [
+        RegionRequest::Put(RegionPutRequest {
+            skip_wal: false,
+            rows,
+            hint: None,
+            partition_expr_version: None,
+        }),
+        RegionRequest::BulkInserts(RegionBulkInsertsRequest {
+            skip_wal: false,
             region_id,
-            RegionRequest::Put(RegionPutRequest {
-                skip_wal: false,
-                rows,
-                hint: None,
-                partition_expr_version: None,
-            }),
-        )
-        .await
-        .unwrap_err();
-    assert_eq!(err.status_code(), StatusCode::StorageUnavailable);
-    assert_matches!(
-        err.into_inner().as_any().downcast_ref::<Error>().unwrap(),
-        Error::RejectWrite { .. }
-    );
+            payload,
+            raw_data: ArrowIpc {
+                schema,
+                data_header,
+                payload: data,
+            },
+            partition_expr_version: None,
+            aligned_schema_version: None,
+        }),
+    ] {
+        let err = engine.handle_request(region_id, request).await.unwrap_err();
+        assert_eq!(err.status_code(), StatusCode::StorageUnavailable);
+        assert_eq!(err.retry_hint(), RetryHint::RetryAfterRouteRefresh);
+        assert_matches!(
+            err.into_inner().as_any().downcast_ref::<Error>().unwrap(),
+            Error::RejectWriteInStaging { .. }
+        );
+    }
 }
 
 #[tokio::test]
diff --git a/src/mito2/src/error.rs b/src/mito2/src/error.rs
index 7d43548dd2b..91566bc2949 100644
--- a/src/mito2/src/error.rs
+++ b/src/mito2/src/error.rs
@@ -633,6 +633,13 @@ pub enum Error {
         location: Location,
     },
 
+    #[snafu(display("Region {} rejects writes while in staging", region_id))]
+    RejectWriteInStaging {
+        region_id: RegionId,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
     #[snafu(display("Failed to compact region {}", region_id))]
     CompactRegion {
         region_id: RegionId,
@@ -1532,7 +1539,7 @@ impl ErrorExt for Error {
             RegionClosed { .. } => StatusCode::Cancelled,
             StaleCompactionExecution { .. } => StatusCode::Cancelled,
             RegionTruncated { .. } => StatusCode::Cancelled,
-            RejectWrite { .. } => StatusCode::StorageUnavailable,
+            RejectWrite { .. } | RejectWriteInStaging { .. } => StatusCode::StorageUnavailable,
             CompactRegion { source, .. } => source.status_code(),
             EditRegion { source, .. } => source.status_code(),
             CompatReader { .. } => StatusCode::Unexpected,
@@ -1630,6 +1637,13 @@ impl ErrorExt for Error {
         use Error::*;
 
         match self {
+            PartitionExprVersionMismatch { .. }
+            | RegionNotFound { .. }
+            | RejectWriteInStaging { .. }
+            | RegionState {
+                state: RegionRoleState::Follower,
+                ..
+            } => RetryHint::RetryAfterRouteRefresh,
             ReadParquet { .. }
             | WriteParquet { .. }
             | RejectWrite { .. }
@@ -1710,6 +1724,63 @@ mod tests {
     use snafu::IntoError;
 
     use super::*;
+    use crate::region::RegionLeaderState;
+
+    #[test]
+    fn test_partition_version_mismatch_retry_hint() {
+        let error = PartitionExprVersionMismatchSnafu {
+            region_id: RegionId::new(1, 1),
+            request_version: 1u64,
+            expected_version: 2u64,
+        }
+        .build();
+        assert_eq!(error.status_code(), StatusCode::InvalidArguments);
+        assert_eq!(error.retry_hint(), RetryHint::RetryAfterRouteRefresh);
+    }
+
+    #[test]
+    fn test_region_state_retry_hint() {
+        let region_id = RegionId::new(1, 1);
+        let writable = RegionRoleState::Leader(RegionLeaderState::Writable);
+        let follower_error = RegionStateSnafu {
+            region_id,
+            state: RegionRoleState::Follower,
+            expect: writable,
+        }
+        .build();
+        assert_eq!(
+            follower_error.retry_hint(),
+            RetryHint::RetryAfterRouteRefresh
+        );
+        assert_eq!(follower_error.status_code(), StatusCode::RegionNotReady);
+        let leader_error = RegionStateSnafu {
+            region_id,
+            state: writable,
+            expect: RegionRoleState::Follower,
+        }
+        .build();
+        assert_eq!(leader_error.retry_hint(), RetryHint::Retryable);
+        for (error, status, hint) in [
+            (
+                RejectWriteSnafu { region_id }.build(),
+                StatusCode::StorageUnavailable,
+                RetryHint::Retryable,
+            ),
+            (
+                RejectWriteInStagingSnafu { region_id }.build(),
+                StatusCode::StorageUnavailable,
+                RetryHint::RetryAfterRouteRefresh,
+            ),
+            (
+                RegionNotFoundSnafu { region_id }.build(),
+                StatusCode::RegionNotFound,
+                RetryHint::RetryAfterRouteRefresh,
+            ),
+        ] {
+            assert_eq!(error.status_code(), status);
+            assert_eq!(error.retry_hint(), hint);
+        }
+    }
 
     #[test]
     fn test_manifest_update_persistence() {
diff --git a/src/mito2/src/flush.rs b/src/mito2/src/flush.rs
index a5d9a7d0a73..758fe716eab 100644
--- a/src/mito2/src/flush.rs
+++ b/src/mito2/src/flush.rs
@@ -46,7 +46,10 @@ use crate::error::{
 };
 use crate::manifest::action::{RegionEdit, RegionMetaAction, RegionMetaActionList};
 use crate::memtable::bulk::ENCODE_ROW_THRESHOLD;
-use crate::memtable::{BoxedRecordBatchIterator, EncodedRange, MemtableRanges, RangesOptions};
+use crate::memtable::{
+    BoxedRecordBatchIterator, EncodedRange, MemtableRange, MemtableRanges, RangesOptions,
+    group_by_sequence,
+};
 use crate::metrics::{
     FLUSH_BYTES_TOTAL, FLUSH_ELAPSED, FLUSH_FAILURE_TOTAL, FLUSH_FILE_TOTAL, FLUSH_REQUESTS_TOTAL,
     INFLIGHT_FLUSH_COUNT,
@@ -231,7 +234,7 @@ pub enum FlushReason {
     Repartition,
     /// Flush triggered by remote WAL pruning.
     RemoteWalPrune,
-    /// Flush before closing a Noop WAL region.
+    /// Flush before closing a region.
     Closing,
 }
 
@@ -836,7 +839,10 @@ impl RegionFlushTask {
             metadata: version.metadata.clone(),
             source,
             cache_manager: self.cache_manager.clone(),
-            max_sequence: Some(max_sequence),
+            // Sources have disjoint sequence intervals. LastNonNull can still
+            // contain Puts and retained delete barriers for the same row.
+            max_sequence: (version.options.merge_mode() != MergeMode::LastNonNull)
+                .then_some(max_sequence),
             sst_write_format: if flat_format {
                 FormatType::Flat
             } else {
@@ -906,7 +912,7 @@ struct FlatSources {
     encoded: SmallVec<[(EncodedRange, SequenceNumber); 4]>,
 }
 
-/// Returns the max sequence and [FlatSource] for the given memtable.
+/// Builds sequence-disjoint sources and their maximum input sequences.
 fn memtable_flat_sources(
     schema: SchemaRef,
     mem_ranges: MemtableRanges,
@@ -914,190 +920,158 @@ fn memtable_flat_sources(
     options: &RegionOptions,
     field_column_start: usize,
 ) -> Result<FlatSources> {
-    let MemtableRanges { ranges } = mem_ranges;
+    let components = group_by_sequence(
+        mem_ranges.ranges.into_values().collect(),
+        |range: &MemtableRange| {
+            let stats = range.stats();
+            (stats.min_sequence, stats.max_sequence())
+        },
+    );
     let mut flat_sources = FlatSources {
         sources: SmallVec::new(),
         encoded: SmallVec::new(),
     };
-
-    if ranges.len() == 1 {
-        debug!("Flushing single flat range");
-
-        let only_range = ranges.into_values().next().unwrap();
-        let max_sequence = only_range.stats().max_sequence();
-        if let Some(encoded) = only_range.encoded() {
-            flat_sources.encoded.push((encoded, max_sequence));
-        } else {
-            let schema = only_range.record_batch_schema_hint().unwrap_or(schema);
-            let iter = only_range.build_record_batch_iter(None, None)?;
-            // Dedup according to append mode and merge mode.
-            // Even single range may have duplicate rows.
-            let iter = maybe_dedup_one(
-                options.append_mode,
-                options.merge_mode(),
-                field_column_start,
-                iter,
-            );
-            flat_sources
-                .sources
-                .push((FlatSource::new_iter(schema, iter), max_sequence));
-        };
-    } else {
-        let min_flush_rows = *ENCODE_ROW_THRESHOLD;
-        // Calculate total rows from non-encoded ranges.
-        let total_rows: usize = ranges
-            .values()
-            .filter(|r| r.encoded().is_none())
-            .map(|r| r.num_rows())
-            .sum();
-        debug!(
-            "Flushing multiple flat ranges, total_rows: {}, min_flush_rows: {}, num_ranges: {}",
-            total_rows,
-            min_flush_rows,
-            ranges.len()
-        );
-        let mut rows_remaining = total_rows;
-        let mut last_iter_rows = 0;
-        let num_ranges = ranges.len();
-        let mut input_iters = Vec::with_capacity(num_ranges);
-        let mut current_ranges = Vec::new();
-
-        let schemas = ranges
-            .values()
-            .filter(|range| range.encoded().is_none())
-            .map(|range| {
-                (
-                    range
-                        .record_batch_schema_hint()
-                        .unwrap_or_else(|| schema.clone()),
-                    range.num_rows() as u64,
-                )
-            })
-            .collect::<Vec<_>>();
-        let plans = Arc::new(collect_json2_rewrite_plans(metadata, &schemas)?);
-        let schema = rewrite_json2_schema(
-            schemas.first().map(|(schema, _)| schema).unwrap_or(&schema),
-            &plans,
-        );
-
-        for (_range_id, range) in ranges {
-            if let Some(encoded) = range.encoded() {
-                let max_sequence = range.stats().max_sequence();
-                flat_sources.encoded.push((encoded, max_sequence));
-                continue;
-            }
-
-            if let Some(actual) = range.record_batch_schema_hint() {
-                let actual = rewrite_json2_schema(&actual, &plans);
-                ensure!(
-                    actual == schema,
-                    UnexpectedSnafu {
-                        reason: format!(
-                            "Different schemas found in a MemtableRanges, expected: {}, actual: {}",
-                            schema, actual,
-                        ),
-                    }
-                )
-            }
-
-            let iter = range.build_record_batch_iter(None, None)?;
-            let iter: BoxedRecordBatchIterator = if plans.is_empty() {
-                iter
-            } else {
-                let plans = plans.clone();
-                Box::new(iter.map(move |batch| rewrite_json2_batch(batch?, &plans)))
-            };
-            input_iters.push(iter);
-            let range_rows = range.num_rows();
-            last_iter_rows += range_rows;
-            rows_remaining -= range_rows;
-            current_ranges.push(range);
-
-            // Flush if we have enough rows, but don't flush if the remaining rows
-            // would be less than DEFAULT_ROW_GROUP_SIZE (to avoid small last files).
-            if last_iter_rows >= min_flush_rows
-                && (rows_remaining == 0 || rows_remaining >= DEFAULT_ROW_GROUP_SIZE)
-            {
-                debug!(
-                    "Flush batch ready, rows: {}, min_rows: {}, num_iters: {}, remaining: {}",
-                    last_iter_rows,
-                    min_flush_rows,
-                    input_iters.len(),
-                    rows_remaining
-                );
-
-                // Calculate max_sequence from all merged ranges
-                let max_sequence = current_ranges
-                    .iter()
-                    .map(|r| r.stats().max_sequence())
-                    .max()
-                    .unwrap_or(0);
-                let batch_size =
-                    crate::batch_size::estimate_batch_size(current_ranges.iter().map(|range| {
-                        let stats = range.stats();
-                        (stats.num_rows() as u64, stats.bytes_allocated() as u64)
-                    }));
-
-                let input_iters =
-                    std::mem::replace(&mut input_iters, Vec::with_capacity(num_ranges));
-
-                let maybe_dedup = merge_and_dedup_with_batch_size(
+    let mut rows_remaining = components
+        .iter()
+        .filter(|component| component.len() != 1 || component[0].encoded().is_none())
+        .flatten()
+        .map(MemtableRange::num_rows)
+        .sum::<usize>();
+    let mut pending = Vec::new();
+    let mut pending_rows = 0;
+    for component in components {
+        // A standalone encoded component is an ordering barrier. Do not merge
+        // raw ranges on either side while uploading the intervening rows as-is.
+        if component.len() == 1
+            && let Some(encoded) = component[0].encoded()
+        {
+            if !pending.is_empty() {
+                flat_sources.sources.push(build_flush_source(
                     &schema,
-                    options.append_mode,
-                    options.merge_mode(),
+                    std::mem::take(&mut pending),
+                    metadata,
+                    options,
                     field_column_start,
-                    input_iters,
-                    batch_size,
-                )?;
-
-                flat_sources.sources.push((
-                    FlatSource::new_iter(schema.clone(), maybe_dedup),
-                    max_sequence,
-                ));
-                last_iter_rows = 0;
-                current_ranges.clear();
+                )?);
+                pending_rows = 0;
             }
-        }
-
-        // Handle remaining iters.
-        if !input_iters.is_empty() {
-            debug!(
-                "Flush remaining batch, rows: {}, min_rows: {}, num_iters: {}, remaining: {}",
-                last_iter_rows,
-                min_flush_rows,
-                input_iters.len(),
-                rows_remaining
-            );
-
-            let max_sequence = current_ranges
-                .iter()
-                .map(|r| r.stats().max_sequence())
-                .max()
-                .unwrap_or(0);
-            let batch_size =
-                crate::batch_size::estimate_batch_size(current_ranges.iter().map(|range| {
-                    let stats = range.stats();
-                    (stats.num_rows() as u64, stats.bytes_allocated() as u64)
-                }));
-
-            let maybe_dedup = merge_and_dedup_with_batch_size(
-                &schema,
-                options.append_mode,
-                options.merge_mode(),
-                field_column_start,
-                input_iters,
-                batch_size,
-            )?;
-
             flat_sources
-                .sources
-                .push((FlatSource::new_iter(schema, maybe_dedup), max_sequence));
+                .encoded
+                .push((encoded, component[0].stats().max_sequence()));
+            continue;
+        }
+        let component_rows = component.iter().map(MemtableRange::num_rows).sum::<usize>();
+        pending_rows += component_rows;
+        rows_remaining -= component_rows;
+        pending.extend(component);
+        // Only split between disjoint components, retaining the existing
+        // minimum-size rule for the final source.
+        if pending_rows >= *ENCODE_ROW_THRESHOLD
+            && (rows_remaining == 0 || rows_remaining >= DEFAULT_ROW_GROUP_SIZE)
+        {
+            flat_sources.sources.push(build_flush_source(
+                &schema,
+                std::mem::take(&mut pending),
+                metadata,
+                options,
+                field_column_start,
+            )?);
+            pending_rows = 0;
         }
     }
-
+    if !pending.is_empty() {
+        flat_sources.sources.push(build_flush_source(
+            &schema,
+            pending,
+            metadata,
+            options,
+            field_column_start,
+        )?);
+    }
     Ok(flat_sources)
 }
 
+/// Builds one sequence-contiguous source, decoding encoded ranges if their
+/// intervals overlap other ranges. JSON2 layouts are reconciled for this group.
+fn build_flush_source(
+    schema: &SchemaRef,
+    ranges: Vec<MemtableRange>,
+    metadata: &RegionMetadataRef,
+    options: &RegionOptions,
+    field_column_start: usize,
+) -> Result<(FlatSource, SequenceNumber)> {
+    let max_sequence = ranges
+        .iter()
+        .map(|range| range.stats().max_sequence())
+        .max()
+        .unwrap_or(0);
+    if let [range] = ranges.as_slice() {
+        // A single range needs no layout reconciliation, including legacy JSON2.
+        let schema = range
+            .record_batch_schema_hint()
+            .unwrap_or_else(|| schema.clone());
+        let iter = maybe_dedup_one(
+            options.append_mode,
+            options.merge_mode(),
+            field_column_start,
+            range.build_record_batch_iter(None, None)?,
+        );
+        return Ok((FlatSource::new_iter(schema, iter), max_sequence));
+    }
+    let batch_size = crate::batch_size::estimate_batch_size(ranges.iter().map(|range| {
+        let stats = range.stats();
+        (stats.num_rows() as u64, stats.bytes_allocated() as u64)
+    }));
+    let schemas = ranges
+        .iter()
+        .map(|range| {
+            (
+                range
+                    .record_batch_schema_hint()
+                    .unwrap_or_else(|| schema.clone()),
+                range.num_rows() as u64,
+            )
+        })
+        .collect::<Vec<_>>();
+    let plans = Arc::new(collect_json2_rewrite_plans(metadata, &schemas)?);
+    let schema = rewrite_json2_schema(
+        schemas.first().map(|(schema, _)| schema).unwrap_or(schema),
+        &plans,
+    );
+    let mut iters = Vec::with_capacity(ranges.len());
+    for range in ranges {
+        if let Some(actual) = range.record_batch_schema_hint() {
+            let actual = rewrite_json2_schema(&actual, &plans);
+            ensure!(
+                actual == schema,
+                UnexpectedSnafu {
+                    reason: format!(
+                        "Different schemas found in a MemtableRanges, expected: {}, actual: {}",
+                        schema, actual
+                    ),
+                }
+            );
+        }
+        let iter = range.build_record_batch_iter(None, None)?;
+        let iter: BoxedRecordBatchIterator = if plans.is_empty() {
+            iter
+        } else {
+            let plans = plans.clone();
+            Box::new(iter.map(move |batch| rewrite_json2_batch(batch?, &plans)))
+        };
+        iters.push(iter);
+    }
+    let iter = merge_and_dedup_with_batch_size(
+        &schema,
+        options.append_mode,
+        options.merge_mode(),
+        field_column_start,
+        iters,
+        batch_size,
+    )?;
+    Ok((FlatSource::new_iter(schema, iter), max_sequence))
+}
+
 /// Merges multiple record batch iterators and applies deduplication based on the specified mode.
 ///
 /// This function is used during the flush process to combine data from multiple memtable ranges
@@ -1129,7 +1103,7 @@ fn memtable_flat_sources(
 /// 3. If `append_mode` is false, wraps the merge iterator with a `FlatDedupIterator` that
 ///    applies the specified merge mode:
 ///    - `LastRow`: Removes duplicate rows, keeping only the last one
-///    - `LastNonNull`: Removes duplicates but preserves the last non-null value for each field
+///    - `LastNonNull`: Folds fields between delete markers, retaining every marker
 ///
 /// # Examples
 ///
@@ -2356,7 +2330,7 @@ mod tests {
             1,
             std::iter::once(1000),
             std::iter::once(Some(1.0)),
-            1,
+            2,
         );
         converter.append_key_values(&kvs)?;
         let batch = converter.convert()?.batch;
@@ -2371,6 +2345,8 @@ mod tests {
                 )),
                 MemtableStats {
                     num_rows: 1,
+                    min_sequence: id as u64 + 1,
+                    max_sequence: id as u64 + 1,
                     ..Default::default()
                 },
             )
@@ -2389,7 +2365,7 @@ mod tests {
         ranges.insert(
             1,
             new_range(
-                0,
+                1,
                 TestIterBuilder {
                     schema: schema.clone(),
                     batch: Some(batch),
diff --git a/src/mito2/src/gc/worker_test.rs b/src/mito2/src/gc/worker_test.rs
index 7bcf511f1a0..2a66294f59b 100644
--- a/src/mito2/src/gc/worker_test.rs
+++ b/src/mito2/src/gc/worker_test.rs
@@ -518,13 +518,9 @@ async fn write_and_list_entry(store: &ObjectStore, path: &str) -> Entry {
         .await
         .unwrap();
     // List the parent directory to get the entry.
-    let parent = std::path::Path::new(path).parent().and_then(|p| {
-        if p.as_os_str().is_empty() {
-            None
-        } else {
-            Some(p)
-        }
-    });
+    let parent = std::path::Path::new(path)
+        .parent()
+        .filter(|p| !p.as_os_str().is_empty());
     let prefix = match parent {
         Some(p) => format!("{}/", p.to_str().unwrap()),
         None => String::new(), // root
diff --git a/src/mito2/src/memtable.rs b/src/mito2/src/memtable.rs
index 0f0a50875cc..afb546340b1 100644
--- a/src/mito2/src/memtable.rs
+++ b/src/mito2/src/memtable.rs
@@ -64,6 +64,32 @@ pub use bulk::part::{
 #[cfg(any(test, feature = "test"))]
 pub use time_partition::filter_record_batch;
 
+/// Groups sequence intervals into ordered, disjoint components. A component must
+/// not be split during a partial merge: an excluded interval could contain an
+/// intermediate row version. Bounds may conservatively include removed rows.
+pub(crate) fn group_by_sequence<T>(
+    mut parts: Vec<T>,
+    bounds: impl Fn(&T) -> (SequenceNumber, SequenceNumber),
+) -> Vec<Vec<T>> {
+    parts.sort_by_key(&bounds);
+    let mut groups: Vec<Vec<T>> = Vec::new();
+    let mut group_max = 0;
+    for part in parts {
+        let (min, max) = bounds(&part);
+        match groups.last_mut() {
+            Some(group) if min <= group_max => {
+                group.push(part);
+                group_max = group_max.max(max);
+            }
+            _ => {
+                groups.push(vec![part]);
+                group_max = max;
+            }
+        }
+    }
+    groups
+}
+
 /// Id for memtables.
 ///
 /// Should be unique under the same region.
diff --git a/src/mito2/src/memtable/bulk.rs b/src/mito2/src/memtable/bulk.rs
index 94ccac472df..7402eeb0582 100644
--- a/src/mito2/src/memtable/bulk.rs
+++ b/src/mito2/src/memtable/bulk.rs
@@ -21,7 +21,7 @@ pub mod part_reader;
 mod row_group_reader;
 
 use std::collections::{BTreeMap, HashSet};
-use std::sync::atomic::{AtomicI64, AtomicU64, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, AtomicUsize, Ordering};
 use std::sync::{Arc, LazyLock, Mutex, RwLock};
 use std::time::Instant;
 
@@ -60,6 +60,7 @@ use crate::memtable::{
     AllocTracker, BoxedBatchIterator, BoxedRecordBatchIterator, EncodedBulkPart, EncodedRange,
     IterBuilder, KeyValues, MemScanMetrics, Memtable, MemtableBuilder, MemtableId, MemtableRange,
     MemtableRangeContext, MemtableRanges, MemtableRef, MemtableStats, RangesOptions,
+    group_by_sequence,
 };
 use crate::read::flat_dedup::{FlatDedupIterator, FlatLastNonNull, FlatLastRow};
 use crate::read::flat_merge::FlatMergeIterator;
@@ -177,7 +178,7 @@ enum MergedPart {
 
 /// Result of collecting parts to merge
 struct CollectedParts {
-    /// Groups of parts ready for merging (each group has up to 16 parts)
+    /// Consecutive groups of parts ready for merging.
     groups: Vec<Vec<PartToMerge>>,
 }
 
@@ -202,38 +203,18 @@ impl BulkParts {
         self.unordered_part.is_empty() && self.parts.is_empty()
     }
 
-    /// Returns true if enough parts of the same type are available to merge.
-    fn should_merge_parts(&self, merge_threshold: usize, encode_bytes_threshold: usize) -> bool {
-        let mut bulk_count = 0;
-        let mut encoded_count = 0;
-
-        for wrapper in &self.parts {
-            if !Self::is_merge_candidate(wrapper, encode_bytes_threshold) {
-                continue;
-            }
-
-            if wrapper.part.is_encoded() {
-                encoded_count += 1;
-            } else {
-                bulk_count += 1;
-            }
-
-            if bulk_count >= merge_threshold || encoded_count >= merge_threshold {
-                return true;
-            }
-        }
-
-        false
-    }
-
-    /// Returns whether a part is small enough to benefit from merging.
-    fn is_merge_candidate(wrapper: &BulkPartWrapper, encode_bytes_threshold: usize) -> bool {
-        !wrapper.merging
-            && Self::is_merge_candidate_by_size(
-                wrapper.part.is_encoded(),
-                wrapper.part.estimated_size(),
-                encode_bytes_threshold,
-            )
+    /// Returns a conservative scheduling hint without sorting or allocating.
+    /// The picker checks sequence barriers and sizes when compaction runs.
+    fn may_merge_parts(&self, merge_threshold: usize) -> bool {
+        let merge_threshold = merge_threshold.max(2);
+        self.parts.len() >= merge_threshold
+            && self
+                .parts
+                .iter()
+                .filter(|wrapper| !wrapper.merging)
+                .take(merge_threshold)
+                .count()
+                == merge_threshold
     }
 
     fn is_merge_candidate_by_size(
@@ -250,79 +231,105 @@ impl BulkParts {
             || self.unordered_part.estimated_bytes() > encode_bytes_threshold
     }
 
-    /// Collects unmerged parts and marks them as being merged.
-    /// Only collects parts of types that meet the threshold.
-    /// Parts are grouped by row count for parallel processing.
+    /// Converts buffered small writes into a sorted part once a threshold is reached.
+    fn seal_unordered(&mut self, metadata: &RegionMetadataRef) -> Result<()> {
+        if let Some(part) = self.unordered_part.to_bulk_part(metadata)? {
+            self.parts.push(BulkPartWrapper {
+                part: PartToMerge::Bulk {
+                    part,
+                    file_id: FileId::random(),
+                },
+                merging: false,
+            });
+            self.unordered_part.clear();
+        }
+        Ok(())
+    }
+
+    /// Selects consecutive sequence components without crossing unordered, busy,
+    /// or oversized parts. Overlapping components are indivisible, even above the size limit.
+    fn pick_merge_groups(
+        &self,
+        merge_threshold: usize,
+        max_merge_groups: usize,
+        encode_bytes_threshold: usize,
+    ) -> Vec<Vec<usize>> {
+        if self.parts.len() < merge_threshold.max(2) || max_merge_groups == 0 {
+            return Vec::new();
+        }
+        // The unordered interval participates in overlap grouping as a barrier,
+        // so neither overlapping parts nor parts on opposite sides can be merged.
+        let intervals = self
+            .parts
+            .iter()
+            .enumerate()
+            .map(|(index, wrapper)| {
+                let part = &wrapper.part;
+                (Some(index), (part.min_sequence(), part.max_sequence()))
+            })
+            .chain(
+                self.unordered_part
+                    .sequence_bounds()
+                    .map(|bounds| (None, bounds)),
+            )
+            .collect();
+        let components = group_by_sequence(intervals, |(_, bounds)| *bounds);
+        let mut groups = Vec::new();
+        let mut pending = Vec::new();
+        for component in components {
+            if groups.len() >= max_merge_groups {
+                break;
+            }
+            let Some(component) = component
+                .into_iter()
+                .map(|(index, _)| index)
+                .collect::<Option<Vec<_>>>()
+            else {
+                pending.clear();
+                continue;
+            };
+            let busy = component.iter().any(|&i| self.parts[i].merging);
+            let oversized = component.len() == 1 && {
+                let part = &self.parts[component[0]].part;
+                !Self::is_merge_candidate_by_size(
+                    part.is_encoded(),
+                    part.estimated_size(),
+                    encode_bytes_threshold,
+                )
+            };
+            if busy || oversized {
+                pending.clear();
+                continue;
+            }
+            pending.extend(component);
+            if pending.len() >= merge_threshold.max(2) {
+                groups.push(std::mem::take(&mut pending));
+            }
+        }
+        groups
+    }
+
     fn collect_parts_to_merge(
         &mut self,
         merge_threshold: usize,
         max_merge_groups: usize,
         encode_bytes_threshold: usize,
     ) -> CollectedParts {
-        let mut bulk_indices = Vec::new();
-        let mut encoded_indices = Vec::new();
-
-        for (idx, wrapper) in self.parts.iter().enumerate() {
-            if !Self::is_merge_candidate(wrapper, encode_bytes_threshold) {
-                continue;
-            }
-            let num_rows = wrapper.part.num_rows();
-            if wrapper.part.is_encoded() {
-                encoded_indices.push((idx, num_rows));
-            } else {
-                bulk_indices.push((idx, num_rows));
-            }
-        }
-
-        let mut groups = Vec::new();
-
-        // Process bulk parts if threshold met
-        if bulk_indices.len() >= merge_threshold {
-            groups.extend(self.collect_and_group_parts(
-                bulk_indices,
-                merge_threshold,
-                max_merge_groups,
-            ));
-        }
-
-        // Process encoded parts if threshold met
-        if encoded_indices.len() >= merge_threshold {
-            groups.extend(self.collect_and_group_parts(
-                encoded_indices,
-                merge_threshold,
-                max_merge_groups,
-            ));
-        }
-
-        CollectedParts { groups }
-    }
-
-    /// Sorts indices by row count, groups into chunks, marks as merging, and returns groups.
-    fn collect_and_group_parts(
-        &mut self,
-        mut indices: Vec<(usize, usize)>,
-        merge_threshold: usize,
-        max_merge_groups: usize,
-    ) -> Vec<Vec<PartToMerge>> {
-        if indices.is_empty() {
-            return Vec::new();
-        }
-
-        indices.sort_unstable_by_key(|(_, num_rows)| *num_rows);
-        indices
-            .chunks(merge_threshold)
-            .take(max_merge_groups)
-            .map(|chunk| {
-                chunk
-                    .iter()
-                    .map(|(idx, _)| {
-                        let wrapper = &mut self.parts[*idx];
+        let groups = self
+            .pick_merge_groups(merge_threshold, max_merge_groups, encode_bytes_threshold)
+            .into_iter()
+            .map(|group| {
+                group
+                    .into_iter()
+                    .map(|i| {
+                        let wrapper = &mut self.parts[i];
                         wrapper.merging = true;
                         wrapper.part.clone()
                     })
                     .collect()
             })
-            .collect()
+            .collect();
+        CollectedParts { groups }
     }
 
     /// Installs merged parts and removes the original parts by file ids.
@@ -431,6 +438,8 @@ pub struct BulkMemtable {
     compactor: Arc<Mutex<MemtableCompactor>>,
     /// Dispatcher for scheduling compaction tasks
     compact_dispatcher: Option<Arc<CompactDispatcher>>,
+    /// Whether a write-triggered compaction is queued or running.
+    compacting: Arc<AtomicBool>,
     /// Whether the append mode is enabled
     append_mode: bool,
     /// Mode to handle duplicate rows while merging
@@ -493,18 +502,8 @@ impl Memtable for BulkMemtable {
                 bulk_parts.unordered_part.push(fragment);
 
                 // Compacts unordered_part if the row or byte threshold is exceeded.
-                if bulk_parts.should_compact_unordered_part(self.config.encode_bytes_threshold)
-                    && let Some(bulk_part) =
-                        bulk_parts.unordered_part.to_bulk_part(&self.metadata)?
-                {
-                    bulk_parts.parts.push(BulkPartWrapper {
-                        part: PartToMerge::Bulk {
-                            part: bulk_part,
-                            file_id: FileId::random(),
-                        },
-                        merging: false,
-                    });
-                    bulk_parts.unordered_part.clear();
+                if bulk_parts.should_compact_unordered_part(self.config.encode_bytes_threshold) {
+                    bulk_parts.seal_unordered(&self.metadata)?;
                 }
             } else {
                 bulk_parts.parts.push(BulkPartWrapper {
@@ -523,9 +522,7 @@ impl Memtable for BulkMemtable {
             self.update_stats(local_metrics);
         }
 
-        if self.should_compact() {
-            self.schedule_compact();
-        }
+        self.schedule_compact();
 
         Ok(())
     }
@@ -688,21 +685,12 @@ impl Memtable for BulkMemtable {
             return Ok(());
         }
 
-        // Unified merge for all parts
-        let should_merge = self.parts.read().unwrap().should_merge_parts(
-            self.config.merge_threshold,
-            self.config.encode_bytes_threshold,
-        );
-        if should_merge {
-            compactor.merge_parts(
-                &self.parts,
-                &self.metadata,
-                !self.append_mode,
-                self.merge_mode,
-            )?;
-        }
-
-        Ok(())
+        compactor.merge_parts(
+            &self.parts,
+            &self.metadata,
+            !self.append_mode,
+            self.merge_mode,
+        )
     }
 }
 
@@ -727,6 +715,7 @@ impl BulkMemtable {
                 self.float_field_encoding,
             ))),
             compact_dispatcher: self.compact_dispatcher.clone(),
+            compacting: Arc::new(AtomicBool::new(false)),
             append_mode: self.append_mode,
             merge_mode: self.merge_mode,
             row_group_size: self.row_group_size,
@@ -815,6 +804,7 @@ impl BulkMemtable {
                 float_field_encoding,
             ))),
             compact_dispatcher,
+            compacting: Arc::new(AtomicBool::new(false)),
             append_mode,
             merge_mode,
             row_group_size,
@@ -870,22 +860,27 @@ impl BulkMemtable {
             .sum()
     }
 
-    /// Returns whether the memtable should be compacted.
-    fn should_compact(&self) -> bool {
-        let parts = self.parts.read().unwrap();
-        parts.should_merge_parts(
-            self.config.merge_threshold,
-            self.config.encode_bytes_threshold,
-        )
-    }
-
-    /// Schedules a compaction task using the CompactDispatcher.
+    /// Schedules at most one write-triggered compaction at a time.
     fn schedule_compact(&self) {
+        if self.config.max_merge_groups == 0 || self.compacting.load(Ordering::Relaxed) {
+            return;
+        }
+        if !self
+            .parts
+            .read()
+            .unwrap()
+            .may_merge_parts(self.config.merge_threshold)
+        {
+            return;
+        }
+        let Some(guard) = CompactTaskGuard::try_new(self.compacting.clone()) else {
+            return;
+        };
         if let Some(dispatcher) = &self.compact_dispatcher {
             let task = MemCompactTask {
                 metadata: self.metadata.clone(),
                 parts: self.parts.clone(),
-                config: self.config.clone(),
+                _guard: guard,
                 compactor: self.compactor.clone(),
                 append_mode: self.append_mode,
                 merge_mode: self.merge_mode,
@@ -1110,6 +1105,15 @@ impl PartToMerge {
         }
     }
 
+    /// Returns the lower bound of input sequences.
+    fn min_sequence(&self) -> SequenceNumber {
+        match self {
+            PartToMerge::Bulk { part, .. } => part.min_sequence,
+            PartToMerge::Multi { part, .. } => part.min_sequence(),
+            PartToMerge::Encoded { part, .. } => part.metadata().min_sequence,
+        }
+    }
+
     /// Gets the maximum sequence number of this part.
     fn max_sequence(&self) -> u64 {
         match self {
@@ -1261,12 +1265,14 @@ impl MemtableCompactor {
     ) -> Result<()> {
         let start = Instant::now();
 
-        // Collect pre-grouped parts
-        let collected = bulk_parts.write().unwrap().collect_parts_to_merge(
-            self.config.merge_threshold,
-            self.config.max_merge_groups,
-            self.config.encode_bytes_threshold,
-        );
+        let collected = {
+            let mut parts = bulk_parts.write().unwrap();
+            parts.collect_parts_to_merge(
+                self.config.merge_threshold,
+                self.config.max_merge_groups,
+                self.config.encode_bytes_threshold,
+            )
+        };
 
         if collected.groups.is_empty() {
             return Ok(());
@@ -1355,6 +1361,11 @@ impl MemtableCompactor {
             .map(|p| p.max_timestamp())
             .max()
             .unwrap_or(i64::MIN);
+        let min_sequence = parts_to_merge
+            .iter()
+            .map(PartToMerge::min_sequence)
+            .min()
+            .unwrap_or(0);
         let max_sequence = parts_to_merge
             .iter()
             .map(|p| p.max_sequence())
@@ -1450,7 +1461,7 @@ impl MemtableCompactor {
                 schema,
                 min_timestamp,
                 max_timestamp,
-                max_sequence,
+                min_sequence..=max_sequence,
                 &mut metrics,
             )?;
 
@@ -1476,6 +1487,7 @@ impl MemtableCompactor {
                 batches,
                 min_timestamp,
                 max_timestamp,
+                min_sequence,
                 max_sequence,
                 estimated_series_count,
                 metadata,
@@ -1492,12 +1504,31 @@ impl MemtableCompactor {
     }
 }
 
+/// Keeps the compaction flag set while queued or running and clears it on drop,
+/// including failures and cancellation while waiting for a dispatcher permit.
+struct CompactTaskGuard(Arc<AtomicBool>);
+
+impl CompactTaskGuard {
+    fn try_new(compacting: Arc<AtomicBool>) -> Option<Self> {
+        // The compactor mutex protects merging; this flag only avoids duplicate tasks.
+        compacting
+            .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
+            .ok()
+            .map(|_| Self(compacting))
+    }
+}
+
+impl Drop for CompactTaskGuard {
+    fn drop(&mut self) {
+        self.0.store(false, Ordering::Relaxed);
+    }
+}
+
 /// A memtable compact task to run in background.
 struct MemCompactTask {
     metadata: RegionMetadataRef,
     parts: Arc<RwLock<BulkParts>>,
-    /// Configuration for the bulk memtable.
-    config: BulkMemtableConfig,
+    _guard: CompactTaskGuard,
     /// Compactor for merging bulk parts
     compactor: Arc<Mutex<MemtableCompactor>>,
     /// Whether the append mode is enabled
@@ -1508,22 +1539,12 @@ struct MemCompactTask {
 
 impl MemCompactTask {
     fn compact(&self) -> Result<()> {
-        let mut compactor = self.compactor.lock().unwrap();
-
-        let should_merge = self.parts.read().unwrap().should_merge_parts(
-            self.config.merge_threshold,
-            self.config.encode_bytes_threshold,
-        );
-        if should_merge {
-            compactor.merge_parts(
-                &self.parts,
-                &self.metadata,
-                !self.append_mode,
-                self.merge_mode,
-            )?;
-        }
-
-        Ok(())
+        self.compactor.lock().unwrap().merge_parts(
+            &self.parts,
+            &self.metadata,
+            !self.append_mode,
+            self.merge_mode,
+        )
     }
 }
 
@@ -1794,11 +1815,16 @@ mod tests {
             assert_eq!(expected_min, memtable.stats().min_sequence);
             assert_eq!(expected_min, memtable.min_sequence());
             assert_eq!(expected_ranges, memtable.stats().num_ranges);
+            assert!(!memtable.compacting.load(Ordering::Relaxed));
         }
         // The third write synchronously merges all parts without a dispatcher.
         // Dedup can remove the oldest rows, but their lower bound remains safe.
         assert_eq!(10, memtable.stats().min_sequence);
         assert_eq!(201, memtable.stats().max_sequence);
+        let ranges = memtable.ranges(None, RangesOptions::default()).unwrap();
+        let merged = ranges.ranges.values().next().unwrap();
+        assert!(merged.encoded().is_some());
+        assert_eq!(10, merged.stats().min_sequence);
         let fork = memtable.fork(2, &metadata);
         assert!(fork.is_empty());
         assert_eq!(0, fork.min_sequence());
@@ -1872,7 +1898,7 @@ mod tests {
         let total_rows: usize = ranges.ranges.values().map(|r| r.stats().num_rows()).sum();
         assert_eq!(5, total_rows);
 
-        for (_range_id, range) in ranges.ranges.iter() {
+        for range in ranges.ranges.values() {
             assert!(range.num_rows() > 0);
             assert!(range.is_record_batch());
 
@@ -2468,7 +2494,7 @@ mod tests {
         let total_rows: usize = ranges.ranges.values().map(|r| r.stats().num_rows()).sum();
         assert_eq!(10, total_rows);
 
-        for (_range_id, range) in ranges.ranges.iter() {
+        for range in ranges.ranges.values() {
             assert!(range.num_rows() > 0);
             assert!(range.is_record_batch());
 
@@ -2554,7 +2580,7 @@ mod tests {
 
         // Read all data and verify
         let mut total_rows_read = 0;
-        for (_range_id, range) in ranges.ranges.iter() {
+        for range in ranges.ranges.values() {
             assert!(range.is_record_batch());
             let record_batch_iter = range.build_record_batch_iter(None, None).unwrap();
 
@@ -2615,7 +2641,7 @@ mod tests {
         assert_eq!(5, large_part.num_rows());
         memtable.write_bulk(large_part).unwrap();
 
-        // Write another small part (2 rows) - should trigger compaction of unordered_part
+        // A later small write fills the unordered part to its compact threshold.
         let part = create_bulk_part_with_converter(
             "small_2",
             2,
@@ -2642,7 +2668,7 @@ mod tests {
         assert_eq!(13, total_rows);
 
         let mut total_rows_read = 0;
-        for (_range_id, range) in ranges.ranges.iter() {
+        for range in ranges.ranges.values() {
             let record_batch_iter = range.build_record_batch_iter(None, None).unwrap();
             for batch_result in record_batch_iter {
                 let batch = batch_result.unwrap();
@@ -2780,10 +2806,10 @@ mod tests {
     }
 
     #[test]
-    fn test_should_merge_parts_below_threshold() {
+    fn test_may_merge_parts_below_threshold() {
         let mut bulk_parts = BulkParts::default();
 
-        // Add 7 bulk parts (below DEFAULT_MERGE_THRESHOLD of 8)
+        // Add one fewer part than the merge threshold.
         for i in 0..DEFAULT_MERGE_THRESHOLD - 1 {
             let part = create_bulk_part_with_converter(
                 &format!("key_{}", i),
@@ -2794,14 +2820,18 @@ mod tests {
             )
             .unwrap();
             bulk_parts.parts.push(create_bulk_part_wrapper(part));
+            if i == 0 {
+                assert!(!bulk_parts.may_merge_parts(0));
+                assert!(!bulk_parts.may_merge_parts(1));
+            }
         }
 
-        // Should not trigger merge since we have only 7 parts
-        assert!(!bulk_parts.should_merge_parts(DEFAULT_MERGE_THRESHOLD, usize::MAX));
+        // There are not enough parts to merge.
+        assert!(!bulk_parts.may_merge_parts(DEFAULT_MERGE_THRESHOLD));
     }
 
     #[test]
-    fn test_should_merge_parts_at_threshold() {
+    fn test_may_merge_parts_at_threshold() {
         let mut bulk_parts = BulkParts::default();
         let merge_threshold = 8;
 
@@ -2819,7 +2849,7 @@ mod tests {
         }
 
         // Should trigger merge since we have 8 parts
-        assert!(bulk_parts.should_merge_parts(merge_threshold, usize::MAX));
+        assert!(bulk_parts.may_merge_parts(merge_threshold));
     }
 
     #[test]
@@ -2839,7 +2869,7 @@ mod tests {
         }
 
         let max_size = bulk_parts.parts[0].part.estimated_size();
-        assert!(bulk_parts.should_merge_parts(merge_threshold, max_size));
+        assert!(bulk_parts.may_merge_parts(merge_threshold));
         assert_eq!(
             1,
             bulk_parts
@@ -2850,7 +2880,7 @@ mod tests {
     }
 
     #[test]
-    fn test_should_merge_parts_with_merging_flag() {
+    fn test_may_merge_parts_with_merging_flag() {
         let mut bulk_parts = BulkParts::default();
         let merge_threshold = 8;
 
@@ -2868,7 +2898,7 @@ mod tests {
         }
 
         // Should trigger merge since we have 10 parts
-        assert!(bulk_parts.should_merge_parts(merge_threshold, usize::MAX));
+        assert!(bulk_parts.may_merge_parts(merge_threshold));
 
         // Mark first 3 parts as merging
         for wrapper in bulk_parts.parts.iter_mut().take(3) {
@@ -2876,53 +2906,115 @@ mod tests {
         }
 
         // Now only 7 parts are available for merging, should not trigger
-        assert!(!bulk_parts.should_merge_parts(merge_threshold, usize::MAX));
+        assert!(!bulk_parts.may_merge_parts(merge_threshold));
     }
 
     #[test]
-    fn test_collect_parts_to_merge_grouping() {
-        let mut bulk_parts = BulkParts::default();
+    fn test_compact_task_guard() {
+        let compacting = Arc::new(AtomicBool::new(false));
+        let guard = CompactTaskGuard::try_new(compacting.clone()).unwrap();
+        assert!(compacting.load(Ordering::Relaxed));
+        assert!(CompactTaskGuard::try_new(compacting.clone()).is_none());
+        drop(guard);
+        assert!(!compacting.load(Ordering::Relaxed));
+        assert!(CompactTaskGuard::try_new(compacting.clone()).is_some());
+        assert!(!compacting.load(Ordering::Relaxed));
+    }
 
-        // Add 16 bulk parts with different row counts
-        for i in 0..16 {
-            let num_rows = (i % 4) + 1; // 1 to 4 rows
-            let timestamps: Vec<i64> = (0..num_rows)
-                .map(|j| 1000 + i as i64 * 100 + j as i64)
-                .collect();
-            let values: Vec<Option<f64>> =
-                (0..num_rows).map(|j| Some((i * 10 + j) as f64)).collect();
-            let part = create_bulk_part_with_converter(
-                &format!("key_{}", i),
-                i as u32,
-                timestamps,
-                values,
-                100 + i as u64,
-            )
-            .unwrap();
-            bulk_parts.parts.push(create_bulk_part_wrapper(part));
-        }
-
-        // Should trigger merge since we have 16 parts
-        assert!(bulk_parts.should_merge_parts(DEFAULT_MERGE_THRESHOLD, usize::MAX));
-
-        // Collect parts to merge
-        let collected = bulk_parts.collect_parts_to_merge(
-            DEFAULT_MERGE_THRESHOLD,
-            DEFAULT_MAX_MERGE_GROUPS,
-            usize::MAX,
+    #[test]
+    fn test_compact_scheduling_disabled() {
+        let memtable = BulkMemtable::new(
+            0,
+            BulkMemtableConfig {
+                merge_threshold: 2,
+                max_merge_groups: 0,
+                ..Default::default()
+            },
+            metadata_for_test(),
+            None,
+            Some(Arc::new(CompactDispatcher::new(0))),
+            false,
+            MergeMode::LastRow,
         );
+        let part =
+            create_bulk_part_with_converter("key", 0, vec![1000], vec![Some(1.0)], 0).unwrap();
+        memtable.parts.write().unwrap().parts = vec![
+            create_bulk_part_wrapper(part.clone()),
+            create_bulk_part_wrapper(part),
+        ];
+        memtable.schedule_compact();
+        assert!(!memtable.compacting.load(Ordering::Relaxed));
+    }
 
-        // Should have groups
-        assert!(!collected.groups.is_empty());
+    #[test]
+    fn test_collect_parts_to_merge_sequence_components() {
+        let make_part = |min, max| {
+            let mut part =
+                create_bulk_part_with_converter("key", 0, vec![1000], vec![Some(1.0)], max)
+                    .unwrap();
+            part.min_sequence = min;
+            part
+        };
+        let metadata = metadata_for_test();
+        let encoder = BulkPartEncoder::new(metadata.clone(), DEFAULT_ROW_GROUP_SIZE).unwrap();
+        // Deliberately use installation order rather than sequence order.
+        let mut parts = BulkParts {
+            parts: vec![
+                create_bulk_part_wrapper(make_part(70, 70)),
+                create_bulk_part_wrapper(make_part(10, 30)),
+                BulkPartWrapper {
+                    part: PartToMerge::Multi {
+                        part: MultiBulkPart::from_bulk_part(make_part(35, 50), &metadata),
+                        file_id: FileId::random(),
+                    },
+                    merging: false,
+                },
+                create_bulk_part_wrapper(make_part(60, 60)),
+                BulkPartWrapper {
+                    part: PartToMerge::Encoded {
+                        part: encoder.encode_part(&make_part(20, 40)).unwrap().unwrap(),
+                        file_id: FileId::random(),
+                    },
+                    merging: false,
+                },
+            ],
+            ..Default::default()
+        };
+        // The oversized encoded part connects three intervals transitively;
+        // neither the merge threshold nor its size may split that component.
+        assert!(parts.may_merge_parts(parts.parts.len()));
+        assert_eq!(
+            vec![vec![1, 4, 2], vec![3, 0]],
+            parts.pick_merge_groups(2, 2, 1)
+        );
+        // The hint may schedule a merge even when unordered writes block all parts.
+        parts.unordered_part.push(make_part(0, 100));
+        assert!(parts.may_merge_parts(2));
+        assert!(parts.pick_merge_groups(2, 2, 1).is_empty());
+        parts.unordered_part.clear();
 
-        // All groups should have parts
-        for group in &collected.groups {
-            assert!(!group.is_empty());
-        }
+        // Touching the unordered interval blocks the entire transitive component.
+        parts.unordered_part.push(make_part(50, 55));
+        assert_eq!(vec![vec![3, 0]], parts.pick_merge_groups(2, 2, 1));
+        parts.unordered_part.clear();
 
-        // Total parts collected should be 16
-        let total_parts: usize = collected.groups.iter().map(|g| g.len()).sum();
-        assert_eq!(16, total_parts);
+        // Even without overlap, a group cannot straddle pending small writes.
+        parts.unordered_part.push(make_part(65, 65));
+        assert_eq!(vec![vec![1, 4, 2]], parts.pick_merge_groups(2, 2, 1));
+        parts.unordered_part.clear();
+
+        parts.parts[4].merging = true;
+        let selected = parts.collect_parts_to_merge(2, 2, 1);
+        assert_eq!(1, selected.groups.len());
+        assert_eq!(
+            vec![60, 70],
+            selected.groups[0]
+                .iter()
+                .map(PartToMerge::max_sequence)
+                .collect::<Vec<_>>()
+        );
+        assert!(!parts.parts[1].merging);
+        assert!(!parts.parts[2].merging);
     }
 
     #[test]
@@ -3063,7 +3155,7 @@ mod tests {
 
         // Read all data
         let mut total_rows_read = 0;
-        for (_range_id, range) in ranges.ranges.iter() {
+        for range in ranges.ranges.values() {
             assert!(range.is_record_batch());
             let record_batch_iter = range.build_record_batch_iter(None, None).unwrap();
 
@@ -3120,7 +3212,7 @@ mod tests {
 
         // Should return ranges but each range should produce an empty iterator
         // instead of an error.
-        for (_range_id, range) in ranges.ranges.iter() {
+        for range in ranges.ranges.values() {
             assert!(range.is_record_batch());
             let record_batch_iter = range.build_record_batch_iter(None, None).unwrap();
             let total_rows: usize = record_batch_iter.map(|r| r.unwrap().num_rows()).sum();
diff --git a/src/mito2/src/memtable/bulk/part.rs b/src/mito2/src/memtable/bulk/part.rs
index 7e50fbbd4cb..fecfceafeee 100644
--- a/src/mito2/src/memtable/bulk/part.rs
+++ b/src/mito2/src/memtable/bulk/part.rs
@@ -15,6 +15,7 @@
 //! Bulk part encoder/decoder.
 
 use std::collections::{HashMap, HashSet};
+use std::ops::RangeInclusive;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
@@ -71,7 +72,9 @@ use crate::sst::SeriesEstimator;
 use crate::sst::index::IndexOutput;
 use crate::sst::parquet::flat_format::primary_key_column_index;
 use crate::sst::parquet::format::{PrimaryKeyArray, PrimaryKeyArrayBuilder};
-use crate::sst::parquet::{PARQUET_METADATA_KEY, SstInfo, apply_float_field_encoding};
+use crate::sst::parquet::{
+    COLUMN_INDEX_TRUNCATE_LENGTH, PARQUET_METADATA_KEY, SstInfo, apply_float_field_encoding,
+};
 
 const INIT_DICT_VALUE_CAPACITY: usize = 8;
 
@@ -434,6 +437,11 @@ impl UnorderedPart {
         self.total_bytes
     }
 
+    /// Returns the sequence interval occupied by pending small writes.
+    pub(super) fn sequence_bounds(&self) -> Option<(SequenceNumber, SequenceNumber)> {
+        (!self.is_empty()).then_some((self.min_sequence, self.max_sequence))
+    }
+
     /// Adds a BulkPart to this unordered collection.
     pub fn push(&mut self, part: BulkPart) {
         self.total_rows += part.num_rows();
@@ -1202,7 +1210,7 @@ impl EncodedBulkPart {
             num_rows: meta.num_rows,
             num_ranges: 1,
             max_sequence: meta.max_sequence,
-            min_sequence: 0,
+            min_sequence: meta.min_sequence,
             series_count: meta.num_series as usize,
         }
     }
@@ -1289,6 +1297,8 @@ pub struct BulkPartMeta {
     pub region_metadata: RegionMetadataRef,
     /// Number of series.
     pub num_series: u64,
+    /// Lower bound of input sequences, including rows removed by deduplication.
+    pub min_sequence: SequenceNumber,
     /// Maximum sequence number in part.
     pub max_sequence: u64,
 }
@@ -1334,7 +1344,7 @@ impl BulkPartEncoder {
             .set_write_batch_size(row_group_size)
             .set_max_row_group_row_count(Some(row_group_size))
             .set_compression(Compression::ZSTD(ZstdLevel::default()))
-            .set_column_index_truncate_length(None)
+            .set_column_index_truncate_length(COLUMN_INDEX_TRUNCATE_LENGTH)
             .set_statistics_truncate_length(None);
         props = apply_float_field_encoding(props, &metadata, float_field_encoding);
         let writer_props = Some(props.build());
@@ -1354,7 +1364,7 @@ impl BulkPartEncoder {
         arrow_schema: SchemaRef,
         min_timestamp: i64,
         max_timestamp: i64,
-        max_sequence: u64,
+        sequence_bounds: RangeInclusive<SequenceNumber>,
         metrics: &mut BulkPartEncodeMetrics,
     ) -> Result<Option<EncodedBulkPart>> {
         let mut buf = Vec::with_capacity(4096);
@@ -1406,7 +1416,8 @@ impl BulkPartEncoder {
                 parquet_metadata,
                 region_metadata: self.metadata.clone(),
                 num_series,
-                max_sequence,
+                min_sequence: *sequence_bounds.start(),
+                max_sequence: *sequence_bounds.end(),
             },
             schema: arrow_schema,
         }))
@@ -1442,6 +1453,7 @@ impl BulkPartEncoder {
                 region_metadata: self.metadata.clone(),
                 num_series: part.estimated_series_count() as u64,
                 max_sequence: part.sequence,
+                min_sequence: part.min_sequence,
             },
             schema: arrow_schema,
         }))
@@ -1651,6 +1663,8 @@ pub struct MultiBulkPart {
     max_timestamp: i64,
     /// Min timestamp in part.
     min_timestamp: i64,
+    /// Lower bound of input sequences, including rows removed by deduplication.
+    min_sequence: SequenceNumber,
     /// Max sequence number in part.
     max_sequence: SequenceNumber,
     /// Number of series.
@@ -1674,6 +1688,7 @@ impl MultiBulkPart {
             total_rows: num_rows,
             max_timestamp: part.max_timestamp,
             min_timestamp: part.min_timestamp,
+            min_sequence: part.min_sequence,
             max_sequence: part.sequence,
             series_count,
             batch_stats,
@@ -1686,6 +1701,7 @@ impl MultiBulkPart {
     /// * `batches` - Ordered record batches
     /// * `min_timestamp` - Minimum timestamp across all batches
     /// * `max_timestamp` - Maximum timestamp across all batches
+    /// * `min_sequence` - Lower bound of input sequences
     /// * `max_sequence` - Maximum sequence number across all batches
     /// * `series_count` - Number of series in the batches
     /// * `metadata` - Region metadata for computing batch statistics
@@ -1696,6 +1712,7 @@ impl MultiBulkPart {
         batches: Vec<RecordBatch>,
         min_timestamp: i64,
         max_timestamp: i64,
+        min_sequence: SequenceNumber,
         max_sequence: SequenceNumber,
         series_count: usize,
         metadata: &RegionMetadata,
@@ -1710,6 +1727,7 @@ impl MultiBulkPart {
             total_rows,
             max_timestamp,
             min_timestamp,
+            min_sequence,
             max_sequence,
             series_count,
             batch_stats,
@@ -1735,6 +1753,11 @@ impl MultiBulkPart {
         self.max_timestamp
     }
 
+    /// Returns the lower bound of input sequences.
+    pub fn min_sequence(&self) -> SequenceNumber {
+        self.min_sequence
+    }
+
     /// Returns the maximum sequence number.
     pub fn max_sequence(&self) -> SequenceNumber {
         self.max_sequence
@@ -1825,7 +1848,7 @@ impl MultiBulkPart {
             num_rows: self.num_rows(),
             num_ranges: 1,
             max_sequence: self.max_sequence,
-            min_sequence: 0,
+            min_sequence: self.min_sequence,
             series_count: self.series_count,
         }
     }
@@ -3145,12 +3168,14 @@ mod tests {
         let mut all_batches = Vec::new();
         let mut min_ts = i64::MAX;
         let mut max_ts = i64::MIN;
+        let mut min_seq = u64::MAX;
         let mut max_seq = 0u64;
 
         for inputs in groups {
             let part = build_converted_bulk_part(inputs);
             min_ts = min_ts.min(part.min_timestamp);
             max_ts = max_ts.max(part.max_timestamp);
+            min_seq = min_seq.min(part.min_sequence);
             max_seq = max_seq.max(part.sequence);
             all_batches.push(part.batch);
         }
@@ -3159,6 +3184,7 @@ mod tests {
             all_batches,
             min_ts,
             max_ts,
+            min_seq,
             max_seq,
             groups.len(),
             &metadata,
diff --git a/src/mito2/src/memtable/time_series.rs b/src/mito2/src/memtable/time_series.rs
index 4e720df88df..fad746927d4 100644
--- a/src/mito2/src/memtable/time_series.rs
+++ b/src/mito2/src/memtable/time_series.rs
@@ -641,7 +641,13 @@ impl Iter {
                 predicate
                     .exprs()
                     .iter()
-                    .filter_map(SimpleFilterEvaluator::try_new)
+                    .filter_map(|expr| {
+                        SimpleFilterEvaluator::try_new_with_column_type(expr, &|name| {
+                            metadata
+                                .column_by_name(name)
+                                .map(|column| column.column_schema.data_type.as_arrow_type())
+                        })
+                    })
                     .collect::<Vec<_>>()
             })
             .unwrap_or_default();
diff --git a/src/mito2/src/memtable/version.rs b/src/mito2/src/memtable/version.rs
index d707128c93a..cd5dae10315 100644
--- a/src/mito2/src/memtable/version.rs
+++ b/src/mito2/src/memtable/version.rs
@@ -15,6 +15,7 @@
 //! Memtable version.
 
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
 
 use common_time::Timestamp;
@@ -23,8 +24,9 @@ use store_api::metadata::RegionMetadataRef;
 use store_api::storage::SequenceNumber;
 
 use crate::error::Result;
-use crate::memtable::time_partition::TimePartitionsRef;
-use crate::memtable::{MemtableId, MemtableRef};
+use crate::memtable::bulk::part::BulkPart;
+use crate::memtable::time_partition::TimePartitions;
+use crate::memtable::{KeyValues, MemtableBuilderRef, MemtableId, MemtableRef};
 
 pub(crate) type SmallMemtableVec = SmallVec<[MemtableRef; 2]>;
 
@@ -32,26 +34,35 @@ pub(crate) type SmallMemtableVec = SmallVec<[MemtableRef; 2]>;
 #[derive(Debug, Clone)]
 pub(crate) struct MemtableVersion {
     /// Mutable memtable.
-    pub(crate) mutable: TimePartitionsRef,
+    pub(crate) mutable: MutableMemtablesRef,
     /// Immutable memtables.
     ///
     /// We only allow one flush job per region but if a flush job failed, then we
     /// might need to store more than one immutable memtable on the next time we
     /// flush the region.
     immutables: SmallMemtableVec,
+    /// Whether immutable memtables may contain skip-WAL writes.
+    /// Flushes are serialized per region and cover all immutable memtables.
+    immutable_has_skip_wal_writes: bool,
 }
 
 pub(crate) type MemtableVersionRef = Arc<MemtableVersion>;
 
 impl MemtableVersion {
     /// Returns a new [MemtableVersion] with specific mutable memtable.
-    pub(crate) fn new(mutable: TimePartitionsRef) -> MemtableVersion {
+    pub(crate) fn new(mutable: TimePartitions) -> MemtableVersion {
         MemtableVersion {
-            mutable,
+            mutable: Arc::new(MutableMemtables::new(mutable)),
             immutables: SmallVec::new(),
+            immutable_has_skip_wal_writes: false,
         }
     }
 
+    /// Returns whether current memtables may contain skip-WAL writes.
+    pub(crate) fn has_skip_wal_writes(&self) -> bool {
+        self.mutable.has_skip_wal_writes() || self.immutable_has_skip_wal_writes
+    }
+
     /// Immutable memtables.
     pub(crate) fn immutables(&self) -> &[MemtableRef] {
         &self.immutables
@@ -94,21 +105,25 @@ impl MemtableVersion {
             }
 
             // Update the time window.
-            let mutable = self.mutable.new_with_part_duration(time_window, None);
+            let mutable = self
+                .mutable
+                .partitions
+                .new_with_part_duration(time_window, None);
             common_telemetry::debug!(
                 "Freeze empty memtable, update partition duration from {:?} to {:?}",
                 self.mutable.part_duration(),
                 time_window
             );
             return Ok(Some(MemtableVersion {
-                mutable: Arc::new(mutable),
+                mutable: Arc::new(MutableMemtables::new(mutable)),
                 immutables: self.immutables.clone(),
+                immutable_has_skip_wal_writes: self.immutable_has_skip_wal_writes,
             }));
         }
 
         // Marks the mutable memtable as immutable so it can free the memory usage from our
         // soft limit.
-        self.mutable.freeze()?;
+        self.mutable.partitions.freeze()?;
         // Fork the memtable.
         if Some(self.mutable.part_duration()) != time_window {
             common_telemetry::debug!(
@@ -117,17 +132,23 @@ impl MemtableVersion {
                 time_window
             );
         }
-        let mutable = Arc::new(self.mutable.fork(metadata, time_window));
+        let mutable = Arc::new(MutableMemtables::new(
+            self.mutable.partitions.fork(metadata, time_window),
+        ));
 
         let mut immutables =
             SmallVec::with_capacity(self.immutables.len() + self.mutable.num_partitions());
         immutables.extend(self.immutables.iter().cloned());
         // Pushes the mutable memtable to immutable list.
-        self.mutable.list_memtables_to_small_vec(&mut immutables);
+        self.mutable
+            .partitions
+            .list_memtables_to_small_vec(&mut immutables);
 
         Ok(Some(MemtableVersion {
             mutable,
             immutables,
+            immutable_has_skip_wal_writes: self.immutable_has_skip_wal_writes
+                || self.mutable.has_skip_wal_writes(),
         }))
     }
 
@@ -139,6 +160,9 @@ impl MemtableVersion {
             .filter(|mem| !ids.contains(&mem.id()))
             .cloned()
             .collect();
+        if self.immutables.is_empty() {
+            self.immutable_has_skip_wal_writes = false;
+        }
     }
 
     /// Returns the memory usage of the mutable memtable.
@@ -182,3 +206,213 @@ impl MemtableVersion {
         self.mutable.is_empty() && self.immutables.is_empty()
     }
 }
+
+/// Mutable time partitions and their shared write state.
+///
+/// Version clones share this object. Freezing creates a new object so writes to
+/// the new mutable memtables cannot change the old version's state.
+#[derive(Debug)]
+pub(crate) struct MutableMemtables {
+    partitions: TimePartitions,
+    /// Set before installation because failed writes may install some rows.
+    has_skip_wal_writes: AtomicBool,
+}
+
+pub(crate) type MutableMemtablesRef = Arc<MutableMemtables>;
+
+impl MutableMemtables {
+    fn new(partitions: TimePartitions) -> Self {
+        Self {
+            partitions,
+            has_skip_wal_writes: AtomicBool::new(false),
+        }
+    }
+
+    /// Marks that these memtables may contain skip-WAL writes.
+    pub(crate) fn mark_skip_wal_writes(&self) {
+        self.has_skip_wal_writes.store(true, Ordering::Relaxed);
+    }
+
+    fn has_skip_wal_writes(&self) -> bool {
+        self.has_skip_wal_writes.load(Ordering::Relaxed)
+    }
+
+    /// Writes key values to the mutable time partitions.
+    pub(crate) fn write(&self, kvs: &KeyValues) -> Result<()> {
+        self.partitions.write(kvs)
+    }
+
+    /// Writes a bulk part to the mutable time partitions.
+    pub(crate) fn write_bulk(&self, part: BulkPart) -> Result<()> {
+        self.partitions.write_bulk(part)
+    }
+
+    /// Returns whether all mutable time partitions are empty.
+    pub(crate) fn is_empty(&self) -> bool {
+        self.partitions.is_empty()
+    }
+
+    /// Returns the memtable builder.
+    pub(crate) fn memtable_builder(&self) -> &MemtableBuilderRef {
+        self.partitions.memtable_builder()
+    }
+
+    /// Returns the next memtable ID.
+    pub(crate) fn next_memtable_id(&self) -> MemtableId {
+        self.partitions.next_memtable_id()
+    }
+
+    /// Returns the time partition duration.
+    pub(crate) fn part_duration(&self) -> Duration {
+        self.partitions.part_duration()
+    }
+
+    /// Creates empty time partitions with an optional new duration and builder.
+    /// The returned partitions do not share data or write state with this object.
+    pub(crate) fn new_with_part_duration(
+        &self,
+        part_duration: Option<Duration>,
+        memtable_builder: Option<MemtableBuilderRef>,
+    ) -> TimePartitions {
+        self.partitions
+            .new_with_part_duration(part_duration, memtable_builder)
+    }
+
+    /// Returns the mutable memory usage.
+    pub(crate) fn memory_usage(&self) -> usize {
+        self.partitions.memory_usage()
+    }
+
+    /// Returns the number of time series in mutable time partitions.
+    pub(crate) fn series_count(&self) -> usize {
+        self.partitions.series_count()
+    }
+
+    fn num_rows(&self) -> u64 {
+        self.partitions.num_rows()
+    }
+
+    fn num_partitions(&self) -> usize {
+        self.partitions.num_partitions()
+    }
+
+    fn list_memtables(&self, memtables: &mut Vec<MemtableRef>) {
+        self.partitions.list_memtables(memtables);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::memtable::time_series::TimeSeriesMemtableBuilder;
+    use crate::test_util::memtable_util;
+
+    #[test]
+    fn test_skip_wal_writes_follow_memtable_lifecycle() {
+        for new_skip_wal_writes in [false, true] {
+            let metadata = memtable_util::metadata_for_test();
+            let partitions = TimePartitions::new(
+                metadata.clone(),
+                Arc::new(TimeSeriesMemtableBuilder::default()),
+                0,
+                Some(Duration::from_secs(5)),
+            );
+            let version = MemtableVersion::new(partitions);
+            let snapshot = version.clone();
+            assert!(!version.has_skip_wal_writes());
+
+            let kvs = memtable_util::build_key_values(
+                &metadata,
+                "hello".to_string(),
+                0,
+                &[1000, 7000],
+                1,
+            );
+            version.mutable.mark_skip_wal_writes();
+            version.mutable.write(&kvs).unwrap();
+            assert!(snapshot.has_skip_wal_writes());
+
+            let mut frozen = version
+                .freeze_mutable(&metadata, Some(Duration::from_secs(5)))
+                .unwrap()
+                .unwrap();
+            assert_eq!(2, frozen.immutables().len());
+            assert!(frozen.has_skip_wal_writes());
+            assert!(!frozen.mutable.has_skip_wal_writes());
+            assert!(!Arc::ptr_eq(&version.mutable, &frozen.mutable));
+
+            let during_flush = frozen.clone();
+            if new_skip_wal_writes {
+                frozen.mutable.mark_skip_wal_writes();
+            }
+            frozen.mutable.write(&kvs).unwrap();
+            let ids: Vec<_> = frozen.immutables().iter().map(|mem| mem.id()).collect();
+            frozen.remove_memtables(&ids);
+            assert_eq!(new_skip_wal_writes, frozen.has_skip_wal_writes());
+            assert_eq!(
+                new_skip_wal_writes,
+                during_flush.mutable.has_skip_wal_writes()
+            );
+            // Removing flushed memtables does not mutate the old flush snapshot.
+            assert_eq!(2, during_flush.immutables().len());
+            assert!(during_flush.has_skip_wal_writes());
+
+            let mut next_flush = frozen
+                .freeze_mutable(&metadata, Some(Duration::from_secs(5)))
+                .unwrap()
+                .unwrap();
+            let ids: Vec<_> = next_flush.immutables().iter().map(|mem| mem.id()).collect();
+            next_flush.remove_memtables(&ids);
+            assert!(!next_flush.has_skip_wal_writes());
+        }
+    }
+
+    #[test]
+    fn test_skip_wal_writes_survive_flush_retry() {
+        let metadata = memtable_util::metadata_for_test();
+        let partitions = TimePartitions::new(
+            metadata.clone(),
+            Arc::new(TimeSeriesMemtableBuilder::default()),
+            0,
+            Some(Duration::from_secs(5)),
+        );
+        let version = MemtableVersion::new(partitions);
+        let kvs = memtable_util::build_key_values(&metadata, "hello".to_string(), 0, &[1000], 1);
+        version.mutable.mark_skip_wal_writes();
+        version.mutable.write(&kvs).unwrap();
+        let frozen = version
+            .freeze_mutable(&metadata, Some(Duration::from_secs(5)))
+            .unwrap()
+            .unwrap();
+
+        // A failed flush leaves immutable memtables installed. Changing the
+        // empty mutable's partition duration must retain their write state.
+        let frozen = frozen
+            .freeze_mutable(&metadata, Some(Duration::from_secs(10)))
+            .unwrap()
+            .unwrap();
+        assert!(frozen.has_skip_wal_writes());
+        assert!(!frozen.mutable.has_skip_wal_writes());
+
+        // A retry includes the old immutable memtables and new logged writes.
+        frozen.mutable.write(&kvs).unwrap();
+        let mut retried = frozen
+            .freeze_mutable(&metadata, Some(Duration::from_secs(10)))
+            .unwrap()
+            .unwrap();
+        assert_eq!(2, retried.immutables().len());
+        assert!(retried.has_skip_wal_writes());
+        let ids: Vec<_> = retried.immutables().iter().map(|mem| mem.id()).collect();
+        retried.remove_memtables(&ids);
+        assert!(!retried.has_skip_wal_writes());
+
+        let replacement = MemtableVersion::new(TimePartitions::new(
+            metadata,
+            frozen.mutable.memtable_builder().clone(),
+            frozen.mutable.next_memtable_id(),
+            None,
+        ));
+        assert!(!replacement.has_skip_wal_writes());
+        assert!(frozen.has_skip_wal_writes());
+    }
+}
diff --git a/src/mito2/src/read/flat_dedup.rs b/src/mito2/src/read/flat_dedup.rs
index 64c78895a99..b166d4c7f32 100644
--- a/src/mito2/src/read/flat_dedup.rs
+++ b/src/mito2/src/read/flat_dedup.rs
@@ -160,8 +160,8 @@ impl<I, S> Drop for FlatDedupReader<I, S> {
 /// Strategy to remove duplicate rows from sorted record batches.
 pub trait RecordBatchDedupStrategy: Send {
     /// Pushes a batch to the dedup strategy.
-    /// Returns a batch if the strategy ensures there is no duplications based on
-    /// the input batch.
+    /// Returns rows that no longer need to be updated by subsequent input.
+    /// A strategy for partial merges may retain duplicates separated by Deletes.
     fn push_batch(
         &mut self,
         batch: RecordBatch,
@@ -297,11 +297,11 @@ impl RecordBatchDedupStrategy for FlatLastRow {
 pub struct FlatLastNonNull {
     /// The start index of field columns:
     field_column_start: usize,
-    /// Filter deleted rows.
+    /// Filter deleted rows; otherwise preserve every delete barrier.
     filter_deleted: bool,
     /// Buffered batch to check whether the next batch have duplicated rows with this batch.
     /// Fields in the last row of this batch may be updated by the next batch.
-    /// The buffered batch should contain no duplication.
+    /// In preserve mode, duplicate keys may be separated by delete markers.
     buffer: Option<BatchLastRow>,
     /// Whether the last row range contains a delete operation.
     /// If so, we don't need to update null fields.
@@ -326,7 +326,7 @@ impl RecordBatchDedupStrategy for FlatLastNonNull {
             // If the buffer is None, dedup the batch, put the batch into the buffer and return.
             // There is no previous batch with the same key, we can pass contains_delete as false.
             let (record_batch, contains_delete) =
-                Self::dedup_one_batch(batch, self.field_column_start, false)?;
+                Self::dedup_one_batch(batch, self.field_column_start, false, self.filter_deleted)?;
             metrics.num_unselected_rows += row_before_dedup - record_batch.num_rows();
             self.buffer = BatchLastRow::try_new(record_batch);
             self.contains_delete = contains_delete;
@@ -341,7 +341,7 @@ impl RecordBatchDedupStrategy for FlatLastNonNull {
             // Dedup the batch.
             // There is no previous batch with the same key, we can pass contains_delete as false.
             let (record_batch, contains_delete) =
-                Self::dedup_one_batch(batch, self.field_column_start, false)?;
+                Self::dedup_one_batch(batch, self.field_column_start, false, self.filter_deleted)?;
             metrics.num_unselected_rows += row_before_dedup - record_batch.num_rows();
             debug_assert!(record_batch.num_rows() > 0);
             self.buffer = BatchLastRow::try_new(record_batch);
@@ -369,8 +369,12 @@ impl RecordBatchDedupStrategy for FlatLastNonNull {
         let merged = concat_batches(&schema, &[last_row, batch]).context(ComputeArrowSnafu)?;
         let merged_row_count = merged.num_rows();
         // Dedup the merged batch and update the buffer.
-        let (record_batch, contains_delete) =
-            Self::dedup_one_batch(merged, self.field_column_start, self.contains_delete)?;
+        let (record_batch, contains_delete) = Self::dedup_one_batch(
+            merged,
+            self.field_column_start,
+            self.contains_delete,
+            self.filter_deleted,
+        )?;
         metrics.num_unselected_rows += merged_row_count - record_batch.num_rows();
         debug_assert!(record_batch.num_rows() > 0);
         self.buffer = BatchLastRow::try_new(record_batch);
@@ -397,7 +401,11 @@ impl RecordBatchDedupStrategy for FlatLastNonNull {
 }
 
 impl FlatLastNonNull {
-    /// Creates a new strategy with the given `filter_deleted` flag.
+    /// Creates a strategy with the given `filter_deleted` flag. When false,
+    /// every delete barrier is preserved and Puts are folded only between
+    /// barriers so later reads cannot fill fields from a deleted row.
+    /// Inputs for partial merges must form a sequence-contiguous group to avoid
+    /// folding fields across an intermediate version left outside the merge.
     pub fn new(field_column_start: usize, filter_deleted: bool) -> Self {
         Self {
             field_column_start,
@@ -413,6 +421,7 @@ impl FlatLastNonNull {
         batch: RecordBatch,
         field_column_start: usize,
         prev_batch_contains_delete: bool,
+        filter_deleted: bool,
     ) -> Result<(RecordBatch, bool)> {
         // Get op type array for checking delete operations
         let op_type_column = batch
@@ -460,6 +469,7 @@ impl FlatLastNonNull {
             field_column_start,
             op_types,
             prev_batch_contains_delete,
+            filter_deleted,
         )
     }
 
@@ -471,9 +481,29 @@ impl FlatLastNonNull {
         field_column_start: usize,
         op_types: &UInt8Array,
         first_range_contains_delete: bool,
+        filter_deleted: bool,
     ) -> Result<(RecordBatch, bool)> {
-        let ranges = partitions.ranges();
-        let contains_delete = Self::last_range_has_delete(&ranges, op_types);
+        let mut ranges = partitions.ranges();
+        let contains_delete = filter_deleted && Self::last_range_has_delete(&ranges, op_types);
+        if !filter_deleted && op_types.values().contains(&(OpType::Delete as u8)) {
+            let mut segments = Vec::with_capacity(ranges.len());
+            for range in ranges {
+                let mut start = range.start;
+                for i in range.clone() {
+                    if op_types.value(i) == OpType::Delete as u8 {
+                        if start < i {
+                            segments.push(start..i);
+                        }
+                        segments.push(i..i + 1);
+                        start = i + 1;
+                    }
+                }
+                if start < range.end {
+                    segments.push(start..range.end);
+                }
+            }
+            ranges = segments;
+        }
 
         // Each range at least has 1 row.
         let num_duplications: usize = ranges.iter().map(|r| r.end - r.start - 1).sum();
@@ -498,7 +528,7 @@ impl FlatLastNonNull {
                         &ranges,
                         column,
                         op_types,
-                        first_range_contains_delete,
+                        first_range_contains_delete && filter_deleted,
                     );
                     take(column, &field_indices, take_options.clone()).context(ComputeArrowSnafu)
                 } else {
@@ -1239,52 +1269,6 @@ mod tests {
         check_record_batches_equal(&expected_filter_deleted, &result);
         assert_eq!(6, dedup_iter.metrics.num_unselected_rows);
         assert_eq!(2, dedup_iter.metrics.num_deleted_rows);
-
-        // Test with filter_deleted = false
-        let expected_no_filter = vec![
-            new_record_batch_multi_fields(
-                &[b"k1"],
-                &[1],
-                &[13],
-                &[OpType::Put],
-                &[(Some(11), Some(11))],
-            ),
-            new_record_batch_multi_fields(
-                &[b"k1", b"k1", b"k1"],
-                &[2, 3, 4],
-                &[11, 13, 13],
-                &[OpType::Put, OpType::Put, OpType::Delete],
-                &[(Some(12), Some(22)), (Some(13), None), (None, Some(14))],
-            ),
-            new_record_batch_multi_fields(
-                &[b"k2"],
-                &[1],
-                &[20],
-                &[OpType::Put],
-                &[(Some(101), Some(101))],
-            ),
-            new_record_batch_multi_fields(
-                &[b"k2"],
-                &[2],
-                &[20],
-                &[OpType::Delete],
-                &[(None, None)],
-            ),
-            new_record_batch_multi_fields(
-                &[b"k3"],
-                &[2],
-                &[20],
-                &[OpType::Put],
-                &[(Some(202), Some(202))],
-            ),
-        ];
-
-        let iter = input.clone().into_iter().map(Ok);
-        let mut dedup_iter = FlatDedupIterator::new(iter, FlatLastNonNull::new(1, false));
-        let result = collect_iterator_results(&mut dedup_iter);
-        check_record_batches_equal(&expected_no_filter, &result);
-        assert_eq!(4, dedup_iter.metrics.num_unselected_rows);
-        assert_eq!(0, dedup_iter.metrics.num_deleted_rows);
     }
 
     #[test]
@@ -1588,6 +1572,69 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_last_non_null_preserves_delete_barriers() {
+        let input = new_record_batch_multi_fields(
+            &[b"k1".as_slice(); 9],
+            &[1; 9],
+            &[9, 8, 7, 6, 5, 4, 3, 2, 1],
+            &[
+                OpType::Put,
+                OpType::Put,
+                OpType::Delete,
+                OpType::Delete,
+                OpType::Put,
+                OpType::Put,
+                OpType::Delete,
+                OpType::Put,
+                OpType::Put,
+            ],
+            &[
+                (None, Some(9)),
+                (Some(8), None),
+                (None, None),
+                (None, None),
+                (None, Some(5)),
+                (Some(4), None),
+                (None, None),
+                (None, None),
+                (Some(1), Some(1)),
+            ],
+        );
+        let expected = new_record_batch_multi_fields(
+            &[b"k1".as_slice(); 6],
+            &[1; 6],
+            &[9, 7, 6, 5, 3, 2],
+            &[
+                OpType::Put,
+                OpType::Delete,
+                OpType::Delete,
+                OpType::Put,
+                OpType::Delete,
+                OpType::Put,
+            ],
+            &[
+                (Some(8), Some(9)),
+                (None, None),
+                (None, None),
+                (Some(4), Some(5)),
+                (None, None),
+                (Some(1), Some(1)),
+            ],
+        );
+        // Check both intra-batch partitioning and barriers split across batches.
+        for batch_size in [1, input.num_rows()] {
+            let batches = (0..input.num_rows())
+                .step_by(batch_size)
+                .map(|start| Ok(input.slice(start, batch_size.min(input.num_rows() - start))));
+            let output = FlatDedupIterator::new(batches, FlatLastNonNull::new(1, false))
+                .collect::<Result<Vec<_>>>()
+                .unwrap();
+            let actual = concat_batches(&input.schema(), &output).unwrap();
+            assert_eq!(expected, actual);
+        }
+    }
+
     #[test]
     fn test_flat_last_non_null_strategy_delete_middle() {
         let input = vec![
diff --git a/src/mito2/src/read/scan_region.rs b/src/mito2/src/read/scan_region.rs
index dc68835a11f..0f9cea941b3 100644
--- a/src/mito2/src/read/scan_region.rs
+++ b/src/mito2/src/read/scan_region.rs
@@ -29,10 +29,12 @@ use common_telemetry::tracing::Instrument;
 use common_telemetry::{debug, error, tracing, warn};
 use common_time::range::TimestampRange;
 use datafusion::execution::memory_pool::{MemoryPool, UnboundedMemoryPool};
+use datafusion::optimizer::simplify_expressions::ExprSimplifier;
 use datafusion::physical_plan::expressions::DynamicFilterPhysicalExpr;
 use datafusion_common::pruning::PruningStatistics;
-use datafusion_common::{Column, ScalarValue};
+use datafusion_common::{Column, ScalarValue, ToDFSchema};
 use datafusion_expr::Expr;
+use datafusion_expr::simplify::SimplifyContext;
 use datafusion_expr::utils::expr_to_columns;
 use datatypes::arrow::array::{ArrayRef, BooleanArray, UInt64Array};
 use datatypes::extension::json::is_json2_extension_type;
@@ -57,8 +59,8 @@ use crate::access_layer::AccessLayerRef;
 use crate::cache::CacheStrategy;
 use crate::config::DEFAULT_MAX_CONCURRENT_SCAN_FILES;
 use crate::error::{
-    InvalidPartitionExprSnafu, InvalidRequestSnafu, RegionSequenceDomainBrokenSnafu, Result,
-    SequenceRangeUnsupportedSnafu,
+    EvalPartitionFilterSnafu, InvalidPartitionExprSnafu, InvalidRequestSnafu,
+    RegionSequenceDomainBrokenSnafu, Result, SequenceRangeUnsupportedSnafu,
 };
 #[cfg(feature = "enterprise")]
 use crate::extension::{BoxedExtensionRange, BoxedExtensionRangeProvider};
@@ -2197,6 +2199,22 @@ impl PredicateGroup {
                     expr: expr_json.clone(),
                 })?;
 
+            // Persisted partition bounds retain their original types after schema changes.
+            let schema = metadata
+                .schema
+                .arrow_schema()
+                .clone()
+                .to_dfschema_ref()
+                .context(EvalPartitionFilterSnafu)?;
+            let simplifier = ExprSimplifier::new(
+                SimplifyContext::builder()
+                    .with_schema(schema.clone())
+                    .build(),
+            );
+            let logical_expr = simplifier
+                .coerce(logical_expr, &schema)
+                .and_then(|expr| simplifier.simplify(expr))
+                .context(EvalPartitionFilterSnafu)?;
             combined_exprs.push(logical_expr);
             region_partition_expr = Some(expr);
         }
@@ -2339,6 +2357,75 @@ mod tests {
             .with_files(vec![file])
     }
 
+    #[test]
+    fn test_partition_time_filter_after_unit_widening() {
+        use datatypes::arrow::array::TimestampMicrosecondArray;
+
+        let bound = Value::Timestamp(Timestamp::new_millisecond(1));
+        for (expr, expected) in [
+            (
+                partition_col("ts").lt(bound.clone()),
+                vec![true, false, false],
+            ),
+            (partition_col("ts").gt_eq(bound), vec![false, true, true]),
+        ] {
+            let mut builder = RegionMetadataBuilder::new(RegionId::new(1, 1));
+            builder.push_column_metadata(ColumnMetadata {
+                column_schema: ColumnSchema::new(
+                    "ts",
+                    ConcreteDataType::timestamp_microsecond_datatype(),
+                    false,
+                ),
+                semantic_type: SemanticType::Timestamp,
+                column_id: 0,
+            });
+            builder.primary_key(vec![]);
+            builder.partition_expr_json(Some(expr.as_json_str().unwrap()));
+            let metadata = builder.build().unwrap();
+            let group = PredicateGroup::new(&metadata, &[]).unwrap();
+            let filters = group.time_filters().unwrap();
+            let input: ArrayRef = Arc::new(TimestampMicrosecondArray::from(vec![999, 1000, 1001]));
+            assert_eq!(filters.len(), 1);
+            assert_eq!(
+                filters[0].evaluate_array(&input).unwrap(),
+                datafusion_common::arrow::buffer::BooleanBuffer::from(expected),
+            );
+        }
+    }
+
+    #[test]
+    fn test_partition_time_filter_overflow_after_unit_widening() {
+        // Year 3000 fits milliseconds but overflows nanoseconds.
+        let bound = Value::Timestamp(Timestamp::new_millisecond(32_503_680_000_000));
+        let expr = partition_col("ts").lt(bound);
+        let mut builder = RegionMetadataBuilder::new(RegionId::new(1, 1));
+        builder.push_column_metadata(ColumnMetadata {
+            column_schema: ColumnSchema::new(
+                "ts",
+                ConcreteDataType::timestamp_nanosecond_datatype(),
+                false,
+            ),
+            semantic_type: SemanticType::Timestamp,
+            column_id: 0,
+        });
+        builder.primary_key(vec![]);
+        builder.partition_expr_json(Some(expr.as_json_str().unwrap()));
+        let metadata = builder.build().unwrap();
+
+        let error = PredicateGroup::new(&metadata, &[])
+            .err()
+            .expect("an overflowing partition bound must fail scan construction");
+        let crate::error::Error::EvalPartitionFilter { error, .. } = error else {
+            panic!("unexpected error: {error:?}");
+        };
+        assert!(
+            error
+                .to_string()
+                .contains("converted value exceeds the representable i64 range"),
+            "{error}"
+        );
+    }
+
     #[tokio::test]
     async fn test_total_rows_is_exact_after_partition_filter() {
         let expr = partition_col("k0").gt_eq(Value::String("foo".into()));
@@ -2801,12 +2888,12 @@ mod tests {
             })
             .primary_key(vec![0]);
         let metadata = Arc::new(builder.build().unwrap());
-        let mutable = Arc::new(crate::memtable::time_partition::TimePartitions::new(
+        let mutable = crate::memtable::time_partition::TimePartitions::new(
             metadata.clone(),
             Arc::new(crate::test_util::memtable_util::EmptyMemtableBuilder::default()),
             0,
             None,
-        ));
+        );
         let version = Arc::new(
             crate::region::version::VersionBuilder::new(metadata.clone(), mutable).build(),
         );
@@ -3080,12 +3167,12 @@ mod tests {
             ..Default::default()
         };
         let metadata = Arc::new(metadata_with_primary_key(vec![0, 1], false));
-        let mutable = Arc::new(crate::memtable::time_partition::TimePartitions::new(
+        let mutable = crate::memtable::time_partition::TimePartitions::new(
             metadata.clone(),
             Arc::new(crate::test_util::memtable_util::EmptyMemtableBuilder::default()),
             0,
             None,
-        ));
+        );
         let version = Arc::new(
             crate::region::version::VersionBuilder::new(metadata, mutable)
                 .options(crate::region::options::RegionOptions {
@@ -3120,12 +3207,12 @@ mod tests {
             ..Default::default()
         };
         let metadata = Arc::new(metadata_with_primary_key(vec![0, 1], false));
-        let mutable = Arc::new(crate::memtable::time_partition::TimePartitions::new(
+        let mutable = crate::memtable::time_partition::TimePartitions::new(
             metadata.clone(),
             Arc::new(crate::test_util::memtable_util::EmptyMemtableBuilder::default()),
             0,
             None,
-        ));
+        );
         let target_region_id = metadata.region_id;
 
         // Files at or below the cursor are excluded. Among the remaining files,
@@ -3137,23 +3224,25 @@ mod tests {
             (None, false, true, false),
             (None, true, true, true),
         ] {
-            let version =
-                crate::region::version::VersionBuilder::new(metadata.clone(), mutable.clone())
-                    .options(crate::region::options::RegionOptions {
-                        preserve_row_sequence: true,
-                        ..Default::default()
-                    })
-                    .add_files(
-                        new_noop_file_purger(),
-                        [FileMeta {
-                            region_id: target_region_id,
-                            sequence,
-                            preserve_row_sequence: marked,
-                            ..Default::default()
-                        }]
-                        .into_iter(),
-                    )
-                    .build();
+            let version = crate::region::version::VersionBuilder::new(
+                metadata.clone(),
+                mutable.new_with_part_duration(None, None),
+            )
+            .options(crate::region::options::RegionOptions {
+                preserve_row_sequence: true,
+                ..Default::default()
+            })
+            .add_files(
+                new_noop_file_purger(),
+                [FileMeta {
+                    region_id: target_region_id,
+                    sequence,
+                    preserve_row_sequence: marked,
+                    ..Default::default()
+                }]
+                .into_iter(),
+            )
+            .build();
             let (files, range) = exact_sequence_range(&request, &version).unwrap();
             assert_eq!(expected_files, !files.is_empty());
             assert_eq!(expected_range, range.is_some());
@@ -3168,24 +3257,26 @@ mod tests {
             (None, true, 1, true),
         ] {
             let file_id = store_api::storage::FileId::random();
-            let version =
-                crate::region::version::VersionBuilder::new(metadata.clone(), mutable.clone())
-                    .options(crate::region::options::RegionOptions {
-                        preserve_row_sequence: true,
-                        ..Default::default()
-                    })
-                    .add_files(
-                        new_noop_file_purger(),
-                        [FileMeta {
-                            region_id: RegionId::new(1, 2),
-                            file_id,
-                            sequence,
-                            preserve_row_sequence: marked,
-                            ..Default::default()
-                        }]
-                        .into_iter(),
-                    )
-                    .build();
+            let version = crate::region::version::VersionBuilder::new(
+                metadata.clone(),
+                mutable.new_with_part_duration(None, None),
+            )
+            .options(crate::region::options::RegionOptions {
+                preserve_row_sequence: true,
+                ..Default::default()
+            })
+            .add_files(
+                new_noop_file_purger(),
+                [FileMeta {
+                    region_id: RegionId::new(1, 2),
+                    file_id,
+                    sequence,
+                    preserve_row_sequence: marked,
+                    ..Default::default()
+                }]
+                .into_iter(),
+            )
+            .build();
             let result = exact_sequence_range(&request, &version);
             if expected_error {
                 assert!(result.is_err());
diff --git a/src/mito2/src/region/opener.rs b/src/mito2/src/region/opener.rs
index 84a0e13833f..71c1192cbf2 100644
--- a/src/mito2/src/region/opener.rs
+++ b/src/mito2/src/region/opener.rs
@@ -58,7 +58,7 @@ use crate::error::{
 use crate::manifest::action::RegionManifest;
 use crate::manifest::manager::{RegionManifestManager, RegionManifestOptions};
 use crate::memtable::bulk::part::BulkPart;
-use crate::memtable::time_partition::{TimePartitions, TimePartitionsRef};
+use crate::memtable::time_partition::TimePartitions;
 use crate::memtable::{MemtableBuilderProvider, ensure_json2_not_use_time_series_memtable};
 use crate::metrics::{CACHE_FILL_DOWNLOADED_FILES, CACHE_FILL_PENDING_FILES};
 use crate::read::series_candidate::is_sparse_metric_metadata;
@@ -68,7 +68,7 @@ use crate::region::{
     ManifestContext, ManifestStats, MitoRegion, MitoRegionRef, RegionLeaderState, RegionRoleState,
     RegionStats,
 };
-use crate::region_write_ctx::RegionWriteCtx;
+use crate::region_write_ctx::{RegionWriteCtx, WriteSource};
 use crate::request::OptionOutputTx;
 use crate::schedule::scheduler::SchedulerRef;
 use crate::series_index::{IndexFilePurger, load_version_control};
@@ -410,12 +410,8 @@ impl RegionOpener {
         let memtable_builder = self.memtable_builder_provider.builder_for_options(&options);
         let part_duration = options.compaction.time_window();
         // Initial memtable id is 0.
-        let mutable = Arc::new(TimePartitions::new(
-            metadata.clone(),
-            memtable_builder.clone(),
-            0,
-            part_duration,
-        ));
+        let mutable =
+            TimePartitions::new(metadata.clone(), memtable_builder.clone(), 0, part_duration);
 
         debug!(
             "Create region {} with options: {:?}, default_flat_format: {}",
@@ -587,12 +583,8 @@ impl RegionOpener {
             .time_window()
             .or(manifest.compaction_time_window);
         // Initial memtable id is 0.
-        let mutable = Arc::new(TimePartitions::new(
-            metadata.clone(),
-            memtable_builder.clone(),
-            0,
-            part_duration,
-        ));
+        let mutable =
+            TimePartitions::new(metadata.clone(), memtable_builder.clone(), 0, part_duration);
 
         // Updates region options by manifest before creating version.
         let version_builder = version_builder_from_manifest(
@@ -785,7 +777,7 @@ pub(crate) fn version_builder_from_manifest(
     manifest: &RegionManifest,
     metadata: RegionMetadataRef,
     file_purger: FilePurgerRef,
-    mutable: TimePartitionsRef,
+    mutable: TimePartitions,
     region_options: RegionOptions,
 ) -> VersionBuilder {
     VersionBuilder::new(metadata, mutable)
@@ -961,6 +953,7 @@ where
             provider.clone(),
             // For WAL replay, we don't need to track the write bytes rate.
             None,
+            WriteSource::WalReplay,
         );
         for mutation in entry.mutations {
             rows_replayed += mutation
@@ -1009,11 +1002,9 @@ where
 
         // set next_entry_id and write to memtable.
         region_write_ctx.set_next_entry_id(last_entry_id + 1);
-        region_write_ctx.write_memtable().await;
-        region_write_ctx.write_bulk().await;
         // Publish the replayed sequences only after all rows (including bulk
         // parts) are installed, matching the write path ordering.
-        region_write_ctx.publish_sequence_and_entry_id();
+        region_write_ctx.write_memtables().await;
     }
 
     // TODO(weny): We need to update `flushed_entry_id` in the region manifest
diff --git a/src/mito2/src/region/version.rs b/src/mito2/src/region/version.rs
index a56cef1f544..1c595fb0b9f 100644
--- a/src/mito2/src/region/version.rs
+++ b/src/mito2/src/region/version.rs
@@ -32,7 +32,7 @@ use store_api::storage::{RegionId, SequenceNumber};
 
 use crate::error::Result;
 use crate::manifest::action::{RegionEdit, TruncateKind};
-use crate::memtable::time_partition::{TimePartitions, TimePartitionsRef};
+use crate::memtable::time_partition::TimePartitions;
 use crate::memtable::version::{MemtableVersion, MemtableVersionRef};
 use crate::memtable::{MemtableBuilderRef, MemtableId};
 use crate::region::options::RegionOptions;
@@ -319,13 +319,13 @@ impl VersionControl {
         version: &Version,
         metadata: RegionMetadataRef,
         memtable_builder: MemtableBuilderRef,
-    ) -> TimePartitionsRef {
-        Arc::new(TimePartitions::new(
+    ) -> TimePartitions {
+        TimePartitions::new(
             metadata,
             memtable_builder,
             version.memtables.mutable.next_memtable_id(),
             Some(version.memtables.mutable.part_duration()),
-        ))
+        )
     }
 }
 
@@ -402,7 +402,7 @@ pub(crate) struct VersionBuilder {
 
 impl VersionBuilder {
     /// Returns a new builder.
-    pub(crate) fn new(metadata: RegionMetadataRef, mutable: TimePartitionsRef) -> Self {
+    pub(crate) fn new(metadata: RegionMetadataRef, mutable: TimePartitions) -> Self {
         VersionBuilder {
             metadata: metadata.clone(),
             memtables: Arc::new(MemtableVersion::new(mutable)),
diff --git a/src/mito2/src/region_write_ctx.rs b/src/mito2/src/region_write_ctx.rs
index a64c37dac7f..f8d7eb9c840 100644
--- a/src/mito2/src/region_write_ctx.rs
+++ b/src/mito2/src/region_write_ctx.rs
@@ -70,8 +70,19 @@ impl Drop for WriteNotify {
     }
 }
 
+/// Source of writes installed into memtables.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum WriteSource {
+    Request,
+    WalReplay,
+}
+
 /// Context to keep region metadata and buffer write requests.
 pub(crate) struct RegionWriteCtx {
+    /// Source of the buffered writes.
+    source: WriteSource,
+    /// Whether accepted non-empty writes bypass WAL. WAL replay never sets this flag.
+    has_skip_wal_writes: bool,
     /// Id of region to write.
     region_id: RegionId,
     /// Version of the region while creating the context.
@@ -120,6 +131,7 @@ impl RegionWriteCtx {
         version_control: &VersionControlRef,
         provider: Provider,
         written_bytes: Option<Arc<AtomicU64>>,
+        source: WriteSource,
     ) -> RegionWriteCtx {
         let VersionControlData {
             version,
@@ -129,6 +141,8 @@ impl RegionWriteCtx {
         } = version_control.current();
 
         RegionWriteCtx {
+            source,
+            has_skip_wal_writes: false,
             region_id,
             version,
             version_control: version_control.clone(),
@@ -162,6 +176,7 @@ impl RegionWriteCtx {
             self.next_sequence = sequence;
         }
         let num_rows = rows.as_ref().map(|rows| rows.rows.len()).unwrap_or(0);
+        self.has_skip_wal_writes |= num_rows > 0 && self.is_skip_wal_write(skip_wal);
         let mutation = Mutation {
             op_type,
             sequence: self.next_sequence,
@@ -255,8 +270,29 @@ impl RegionWriteCtx {
         self.next_entry_id
     }
 
-    /// Consumes mutations and writes them into mutable memtable.
-    pub(crate) async fn write_memtable(&mut self) {
+    /// Installs ordinary and bulk writes, then publishes their sequence and entry ID.
+    pub(crate) async fn write_memtables(&mut self) {
+        if self.failed {
+            return;
+        }
+        // A failed installation may leave some rows in memory.
+        if self.has_skip_wal_writes {
+            self.version.memtables.mutable.mark_skip_wal_writes();
+        }
+        self.write_mutations().await;
+        self.write_bulk().await;
+        self.publish_sequence_and_entry_id();
+    }
+
+    fn is_skip_wal_write(&self, request_skip_wal: bool) -> bool {
+        self.source == WriteSource::Request
+            && (request_skip_wal
+                || self.provider == Provider::Noop
+                || self.version.options.skip_wal)
+    }
+
+    /// Consumes mutations and writes them into mutable memtables.
+    async fn write_mutations(&mut self) {
         debug_assert_eq!(self.wal_notifiers.len(), self.wal_entry.mutations.len());
 
         if self.failed {
@@ -336,6 +372,7 @@ impl RegionWriteCtx {
             self.wal_entry.bulk_entries.push(entry);
         }
 
+        self.has_skip_wal_writes |= bulk.num_rows() > 0 && self.is_skip_wal_write(skip_wal);
         self.bulk_notifiers
             .push(WriteNotify::new(sender, bulk.num_rows()));
 
@@ -344,7 +381,7 @@ impl RegionWriteCtx {
         true
     }
 
-    pub(crate) async fn write_bulk(&mut self) {
+    async fn write_bulk(&mut self) {
         if self.failed || self.bulk_parts.is_empty() {
             return;
         }
@@ -398,10 +435,10 @@ impl RegionWriteCtx {
     }
 
     /// Publishes the assigned sequences and entry id to the region's committed
-    /// watermark. Only call after both [`write_memtable`](Self::write_memtable)
+    /// watermark. Only call after both [`write_mutations`](Self::write_mutations)
     /// and [`write_bulk`](Self::write_bulk) have completed; a failed context
     /// must not publish.
-    pub(crate) fn publish_sequence_and_entry_id(&self) {
+    fn publish_sequence_and_entry_id(&self) {
         if self.failed {
             return;
         }
@@ -576,6 +613,7 @@ mod tests {
             &version_control,
             Provider::raft_engine_provider(region_id.as_u64()),
             None,
+            WriteSource::Request,
         );
         for (op_type, skip, num_rows) in [
             (OpType::Put, skip_wal, 2),
@@ -657,6 +695,7 @@ mod tests {
             &version_control,
             Provider::raft_engine_provider(region_id.as_u64()),
             None,
+            WriteSource::Request,
         );
         ctx.push_mutation(
             OpType::Delete as i32,
@@ -693,6 +732,7 @@ mod tests {
             &version_control,
             Provider::raft_engine_provider(region_id.as_u64()),
             None,
+            WriteSource::Request,
         );
         let (tx, rx) = oneshot::channel();
         ctx.push_mutation(
@@ -736,6 +776,7 @@ mod tests {
             &version_control,
             Provider::raft_engine_provider(region_id.as_u64()),
             None,
+            WriteSource::Request,
         );
         // Alternate policies in one context, retaining all parts for the memtable.
         for skip in [skip_wal, false, skip_wal] {
@@ -772,8 +813,13 @@ mod tests {
         let builder = VersionControlBuilder::new();
         let region_id = builder.region_id();
         let version_control = Arc::new(builder.build());
-        let mut ctx =
-            RegionWriteCtx::new(region_id, &version_control, Provider::noop_provider(), None);
+        let mut ctx = RegionWriteCtx::new(
+            region_id,
+            &version_control,
+            Provider::noop_provider(),
+            None,
+            WriteSource::Request,
+        );
         let (tx, rx) = oneshot::channel();
 
         assert!(ctx.push_bulk(OptionOutputTx::from(tx), new_bulk_part(), None, skip_wal));
@@ -791,6 +837,142 @@ mod tests {
         assert!(result.is_err(), "bulk notifier should report WAL error");
     }
 
+    #[tokio::test]
+    async fn test_skip_wal_writes_source_and_policy() {
+        use api::v1::helper::{tag_column_schema, time_index_column_schema};
+        use api::v1::value::ValueData;
+        use api::v1::{ColumnDataType, Row, Value};
+
+        for source in [WriteSource::Request, WriteSource::WalReplay] {
+            for skip_wal in [false, true] {
+                for bulk in [false, true] {
+                    for fail_before_install in [false, true] {
+                        let builder = VersionControlBuilder::new();
+                        let region_id = builder.region_id();
+                        let version_control = Arc::new(builder.build());
+                        let mut ctx = RegionWriteCtx::new(
+                            region_id,
+                            &version_control,
+                            Provider::raft_engine_provider(region_id.as_u64()),
+                            None,
+                            source,
+                        );
+                        let (tx, rx) = oneshot::channel();
+                        if bulk {
+                            let mut part = new_bulk_part();
+                            part.fill_missing_columns(&ctx.version.metadata).unwrap();
+                            assert!(ctx.push_bulk(OptionOutputTx::from(tx), part, None, skip_wal));
+                        } else {
+                            ctx.push_mutation(
+                                OpType::Put as i32,
+                                Some(Rows {
+                                    schema: vec![
+                                        time_index_column_schema(
+                                            "ts",
+                                            ColumnDataType::TimestampMillisecond,
+                                        ),
+                                        tag_column_schema("tag_0", ColumnDataType::String),
+                                    ],
+                                    rows: vec![Row {
+                                        values: vec![
+                                            crate::test_util::ts_ms_value(0),
+                                            Value {
+                                                value_data: Some(ValueData::StringValue(
+                                                    "a".to_string(),
+                                                )),
+                                            },
+                                        ],
+                                    }],
+                                }),
+                                None,
+                                OptionOutputTx::from(tx),
+                                None,
+                                skip_wal,
+                            );
+                        }
+                        if fail_before_install {
+                            ctx.set_error(Arc::new(
+                                UnexpectedSnafu {
+                                    reason: "WAL append failed".to_string(),
+                                }
+                                .build(),
+                            ));
+                        }
+                        ctx.write_memtables().await;
+                        assert_eq!(
+                            version_control
+                                .current()
+                                .version
+                                .memtables
+                                .has_skip_wal_writes(),
+                            source == WriteSource::Request && skip_wal && !fail_before_install,
+                            "source={source:?}, skip_wal={skip_wal}, bulk={bulk}, failed={fail_before_install}",
+                        );
+                        assert_eq!(
+                            version_control.committed_sequence(),
+                            if fail_before_install {
+                                0
+                            } else if bulk {
+                                2
+                            } else {
+                                1
+                            }
+                        );
+                        drop(ctx);
+                        assert_eq!(rx.await.unwrap().is_err(), fail_before_install);
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_skip_wal_writes_region_policy_and_empty_requests() {
+        for source in [WriteSource::Request, WriteSource::WalReplay] {
+            for noop in [false, true] {
+                for region_skip_wal in [false, true] {
+                    let builder = VersionControlBuilder::new();
+                    let region_id = builder.region_id();
+                    let mut version = builder.build_version();
+                    version.options.skip_wal = region_skip_wal;
+                    let version_control =
+                        Arc::new(crate::region::version::VersionControl::new(version));
+                    let provider = if noop {
+                        Provider::Noop
+                    } else {
+                        Provider::raft_engine_provider(region_id.as_u64())
+                    };
+                    let mut ctx =
+                        RegionWriteCtx::new(region_id, &version_control, provider, None, source);
+                    ctx.push_mutation(
+                        OpType::Put as i32,
+                        None,
+                        None,
+                        OptionOutputTx::none(),
+                        None,
+                        true,
+                    );
+                    assert!(!ctx.has_skip_wal_writes);
+                    ctx.push_mutation(
+                        OpType::Put as i32,
+                        Some(Rows {
+                            schema: vec![],
+                            rows: vec![api::v1::Row::default()],
+                        }),
+                        None,
+                        OptionOutputTx::none(),
+                        None,
+                        false,
+                    );
+                    assert_eq!(
+                        ctx.has_skip_wal_writes,
+                        source == WriteSource::Request && (noop || region_skip_wal)
+                    );
+                }
+            }
+        }
+    }
+
     fn new_bulk_part() -> BulkPart {
         let schema = Arc::new(Schema::new(vec![Field::new(
             "ts",
diff --git a/src/mito2/src/series_index/builder.rs b/src/mito2/src/series_index/builder.rs
index 63a51badaeb..447f3d409e0 100644
--- a/src/mito2/src/series_index/builder.rs
+++ b/src/mito2/src/series_index/builder.rs
@@ -21,6 +21,7 @@ use common_telemetry::warn;
 use futures::TryStreamExt;
 use object_store::ObjectStore;
 use snafu::{OptionExt, ensure};
+use store_api::metadata::RegionMetadataRef;
 
 use crate::error::{Result, UnexpectedSnafu};
 use crate::read::BoxedRecordBatchStream;
@@ -30,7 +31,6 @@ use crate::read::flat_projection::FlatProjectionMapper;
 use crate::read::prune::FlatPruneReader;
 use crate::read::read_columns::ReadColumns;
 use crate::region::MitoRegionRef;
-use crate::region::version::VersionRef;
 use crate::series_index::bucket::SeriesBucket;
 use crate::series_index::catalog::{
     RangeIndexEntry, SeriesIndexEntry, range_index_path, series_index_path, series_metadata,
@@ -65,18 +65,18 @@ async fn reader_input(
 pub(crate) async fn build_range_index(
     store: &ObjectStore,
     region: &MitoRegionRef,
-    version: &VersionRef,
+    metadata: &RegionMetadataRef,
     file: FileHandle,
 ) -> Result<Option<RangeIndexEntry>> {
     let file_id = file.file_id().file_id();
     let Some((context, mut selection)) = reader_input(region, file).await? else {
         return Ok(None);
     };
-    let mapper = FlatProjectionMapper::new(&version.metadata, [])?;
+    let mapper = FlatProjectionMapper::new(metadata, [])?;
     let compat = FlatCompatBatch::try_new(&mapper, context.read_format(), false)?;
     let path = range_index_path(region.region_id, file_id);
     let mut writer = SstRangeIndexWriter::try_new(
-        version.metadata.clone(),
+        metadata.clone(),
         store.clone(),
         &path,
         SstRangeIndexWriterOptions::default(),
@@ -127,13 +127,13 @@ pub(crate) async fn build_range_index(
 pub(crate) async fn build_series_index(
     store: &ObjectStore,
     region: &MitoRegionRef,
-    version: &VersionRef,
+    metadata: &RegionMetadataRef,
     bucket: &SeriesBucket,
     entry: &SeriesIndexEntry,
     purger: &IndexFilePurger,
 ) -> Result<SeriesIndexFileHandle> {
     let mut sources = Vec::<BoxedRecordBatchStream>::new();
-    let mapper = FlatProjectionMapper::new(&version.metadata, [])?;
+    let mapper = FlatProjectionMapper::new(metadata, [])?;
     let schema = mapper.input_arrow_schema(false);
     for file in &bucket.files {
         let Some((context, mut selection)) = reader_input(region, file.clone()).await? else {
@@ -182,7 +182,7 @@ pub(crate) async fn build_series_index(
     // TODO(yingwen): Deduplicate update-mode rows before series indexes are used by queries.
     let path = series_index_path(region.region_id, entry.index_uuid);
     let mut writer = SeriesIndexWriter::try_new(
-        version.metadata.clone(),
+        metadata.clone(),
         store.clone(),
         &path,
         SeriesIndexWriterOptions::default(),
@@ -226,6 +226,7 @@ mod tests {
     use store_api::region_engine::RegionEngine;
 
     use super::*;
+    use crate::region::version::VersionRef;
     use crate::series_index::bucket::{group_files_into_series_buckets, plan_series_indexes};
     use crate::series_index::catalog::{
         SeriesIndexCatalog, load_version_control, series_catalog_path, store_catalog,
@@ -280,7 +281,7 @@ mod tests {
         let mut range_bytes = HashMap::new();
         if build_ranges {
             for file in files {
-                let completed = build_range_index(&store, &region, &version, file.clone())
+                let completed = build_range_index(&store, &region, &version.metadata, file.clone())
                     .await
                     .unwrap()
                     .unwrap();
@@ -318,7 +319,7 @@ mod tests {
         let result = build_series_index(
             &store.clone().layer(layer),
             &region,
-            &version,
+            &version.metadata,
             &bucket,
             &entry,
             &purger,
@@ -466,14 +467,15 @@ mod tests {
         let store = ObjectStore::new(Memory::default()).unwrap();
         let (purger, _receiver) = series_index_channel(store.clone());
         for file in &bucket.files {
-            build_range_index(&store, &region, &version, file.clone())
+            build_range_index(&store, &region, &version.metadata, file.clone())
                 .await
                 .unwrap()
                 .unwrap();
         }
-        let _handle = build_series_index(&store, &region, &version, &bucket, &entry, &purger)
-            .await
-            .unwrap();
+        let _handle =
+            build_series_index(&store, &region, &version.metadata, &bucket, &entry, &purger)
+                .await
+                .unwrap();
         let bytes = store
             .read(&series_index_path(region.region_id, entry.index_uuid))
             .await
@@ -533,14 +535,14 @@ mod tests {
         let result: Result<Option<SeriesIndexFileHandle>> = async {
             for file in files {
                 let Some(entry) =
-                    build_range_index(&store, &region, &version, file.clone()).await?
+                    build_range_index(&store, &region, &version.metadata, file.clone()).await?
                 else {
                     // Defer series construction if a needed range is not ready.
                     return Ok(None);
                 };
                 completed.push(entry.file_id);
             }
-            build_series_index(&store, &region, &version, &bucket, &entry, &purger)
+            build_series_index(&store, &region, &version.metadata, &bucket, &entry, &purger)
                 .await
                 .map(Some)
         }
@@ -741,12 +743,12 @@ mod tests {
             .layer(write_layer);
         fail.store(fail_before_open, Ordering::Relaxed);
         let result = if !series {
-            build_range_index(&store, &region, &version, bucket.files[0].clone())
+            build_range_index(&store, &region, &version.metadata, bucket.files[0].clone())
                 .await
                 .map(|_| ())
         } else {
             let (purger, _receiver) = series_index_channel(store.clone());
-            build_series_index(&store, &region, &version, &bucket, &entry, &purger)
+            build_series_index(&store, &region, &version.metadata, &bucket, &entry, &purger)
                 .await
                 .map(|_| ())
         };
diff --git a/src/mito2/src/series_index/maintenance.rs b/src/mito2/src/series_index/maintenance.rs
index f5221bb1ebe..2520e32422e 100644
--- a/src/mito2/src/series_index/maintenance.rs
+++ b/src/mito2/src/series_index/maintenance.rs
@@ -19,13 +19,14 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use common_telemetry::{debug, info};
+use common_time::TimeToLive;
 use object_store::ObjectStore;
+use store_api::metadata::RegionMetadataRef;
 use store_api::storage::{FileId, RegionId};
 
 use crate::error::Result;
 use crate::metrics::{SERIES_INDEX_RECONCILE_ELAPSED, SERIES_INDEX_RECONCILE_TOTAL};
 use crate::read::series_candidate::is_sparse_metric_metadata;
-use crate::region::version::VersionRef;
 use crate::region::{MitoRegionRef, RegionLeaderState, RegionRoleState};
 use crate::series_index::bucket::{
     group_files_into_series_buckets, plan_series_indexes, rounded_bucket_width,
@@ -37,6 +38,15 @@ use crate::series_index::catalog::{
 };
 use crate::series_index::purger::IndexFilePurger;
 use crate::series_index::version::{SeriesIndexFileHandle, SeriesIndexVersion};
+use crate::sst::file::FileHandle;
+
+/// Captured index-build inputs that retain SSTs without retaining memtables.
+struct ReconcileSnapshot {
+    metadata: RegionMetadataRef,
+    files: Vec<FileHandle>,
+    compaction_time_window: Option<Duration>,
+    ttl: Option<TimeToLive>,
+}
 
 /// Retires newly completed series files unless their snapshot is published.
 #[derive(Default)]
@@ -86,21 +96,36 @@ pub(crate) async fn reconcile_series_indexes(
     allow_builds: bool,
 ) -> Result<ReconcileStats> {
     let total_start = Instant::now();
-    // Use this snapshot throughout reconciliation, even if the region version advances.
-    let version = region.version_control.current().version;
-    if !is_sparse_metric_metadata(&version.metadata) {
-        SERIES_INDEX_RECONCILE_TOTAL
-            .with_label_values(&["noop"])
-            .inc();
-        return Ok(ReconcileStats::default());
-    }
+    // Retaining the full version during I/O would pin flushed memtables and delay
+    // write-buffer reclamation. Capture consistent build inputs without the memtables.
+    let snapshot = {
+        let version = region.version_control.current().version;
+        if !is_sparse_metric_metadata(&version.metadata) {
+            SERIES_INDEX_RECONCILE_TOTAL
+                .with_label_values(&["noop"])
+                .inc();
+            return Ok(ReconcileStats::default());
+        }
+        ReconcileSnapshot {
+            metadata: version.metadata.clone(),
+            files: version
+                .ssts
+                .levels()
+                .iter()
+                .flat_map(|level| level.files())
+                .cloned()
+                .collect(),
+            compaction_time_window: version.compaction_time_window,
+            ttl: version.options.ttl,
+        }
+    };
     let build_start = Instant::now();
     let mut unpublished = UnpublishedSeriesFiles::default();
     let (next, mut stats) = build_index_version(
         worker_id,
         &store,
         &region,
-        &version,
+        &snapshot,
         requested_bucket_width,
         now_ms,
         &purger,
@@ -161,7 +186,7 @@ async fn build_index_version(
     worker_id: u32,
     store: &ObjectStore,
     region: &MitoRegionRef,
-    version: &VersionRef,
+    snapshot: &ReconcileSnapshot,
     requested_bucket_width: Duration,
     now_ms: i64,
     purger: &IndexFilePurger,
@@ -170,13 +195,12 @@ async fn build_index_version(
     allow_builds: bool,
 ) -> Result<(Option<SeriesIndexVersion>, ReconcileStats)> {
     let mut stats = ReconcileStats::default();
-    let files = version
-        .ssts
-        .levels()
-        .iter()
-        .flat_map(|level| level.files())
-        .cloned()
-        .collect::<Vec<_>>();
+    let ReconcileSnapshot {
+        metadata,
+        files,
+        compaction_time_window,
+        ttl,
+    } = snapshot;
     stats.source_files = files.len();
     let visible = files
         .iter()
@@ -184,12 +208,12 @@ async fn build_index_version(
         .collect::<HashSet<_>>();
     let current = region.series_index_version();
     // Empty build inputs still let the planner expire established bucket coverage.
-    let buckets = match (allow_builds, version.compaction_time_window) {
+    let buckets = match (allow_builds, *compaction_time_window) {
         (true, Some(window)) => rounded_bucket_width(requested_bucket_width, window)
             // Successful rounding guarantees the window fits in i64; subsecond windows
             // use the same one-second minimum as rounded_bucket_width.
             .map(|width| {
-                group_files_into_series_buckets(&files, width, (window.as_secs() as i64).max(1))
+                group_files_into_series_buckets(files, width, (window.as_secs() as i64).max(1))
             })
             .unwrap_or_default(),
         (true, None) => {
@@ -201,12 +225,7 @@ async fn build_index_version(
         }
         (false, _) => Vec::new(),
     };
-    let plan = plan_series_indexes(
-        buckets,
-        current.index_buckets.clone(),
-        version.options.ttl,
-        now_ms,
-    );
+    let plan = plan_series_indexes(buckets, current.index_buckets.clone(), *ttl, now_ms);
     stats.computed_buckets = plan.computed_buckets;
     stats.skipped_buckets = plan.skipped_buckets;
     let mut next = prune_index_version(&current, &visible, &plan.expired_index_ids, &mut stats);
@@ -240,14 +259,15 @@ async fn build_index_version(
         for file in &bucket.files {
             if enable_range_index
                 && !range_indexes.contains_key(&file.file_id().file_id())
-                && let Some(entry) = build_range_index(store, region, version, file.clone()).await?
+                && let Some(entry) =
+                    build_range_index(store, region, metadata, file.clone()).await?
             {
                 stats.built_range += 1;
                 range_indexes.insert(entry.file_id, entry);
             }
         }
         let series_handle =
-            build_series_index(store, region, version, &bucket, &expected, purger).await?;
+            build_series_index(store, region, metadata, &bucket, &expected, purger).await?;
         unpublished.0.push(series_handle.clone());
         stats.built_series += 1;
         series_indexes.insert(expected.index_uuid, series_handle);
@@ -259,7 +279,7 @@ async fn build_index_version(
             if range_indexes.contains_key(&file_id) {
                 continue;
             }
-            if let Some(entry) = build_range_index(store, region, version, file).await? {
+            if let Some(entry) = build_range_index(store, region, metadata, file.clone()).await? {
                 stats.built_range += 1;
                 range_indexes.insert(entry.file_id, entry);
             }
diff --git a/src/mito2/src/series_index/tests.rs b/src/mito2/src/series_index/tests.rs
index 631bdc75b87..5f13d0b4b2d 100644
--- a/src/mito2/src/series_index/tests.rs
+++ b/src/mito2/src/series_index/tests.rs
@@ -720,13 +720,13 @@ async fn test_failed_reconcile_retires_only_unpublished_series() {
         let (bucket, entry) = &plan.builds[0];
         let mut ranges = HashMap::new();
         for file in &bucket.files {
-            let entry = build_range_index(store, &region, &version, file.clone())
+            let entry = build_range_index(store, &region, &version.metadata, file.clone())
                 .await
                 .unwrap()
                 .unwrap();
             ranges.insert(entry.file_id, entry);
         }
-        let handle = build_series_index(store, &region, &version, bucket, entry, purger)
+        let handle = build_series_index(store, &region, &version.metadata, bucket, entry, purger)
             .await
             .unwrap();
         let reused_path = series_index_path(region.region_id, entry.index_uuid);
diff --git a/src/mito2/src/sst/file.rs b/src/mito2/src/sst/file.rs
index 87684586fbf..5f4dcb28752 100644
--- a/src/mito2/src/sst/file.rs
+++ b/src/mito2/src/sst/file.rs
@@ -26,6 +26,7 @@ use bytes::Bytes;
 use common_base::readable_size::ReadableSize;
 use common_telemetry::{debug, error, warn};
 use common_time::Timestamp;
+use datatypes::schema::FulltextBackend;
 use partition::expr::PartitionExpr;
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
@@ -37,6 +38,7 @@ use crate::access_layer::AccessLayerRef;
 use crate::cache::CacheManagerRef;
 use crate::cache::file_cache::{FileType, IndexKey};
 use crate::sst::file_purger::FilePurgerRef;
+use crate::sst::index::fulltext_index::FULLTEXT_BLOOM_VERSION;
 use crate::sst::location;
 use crate::sst::parquet::SstInfo;
 use crate::sst::primary_key::PrimaryKeyRangeMapper;
@@ -397,6 +399,15 @@ pub struct ColumnIndexMetadata {
     pub column_id: ColumnId,
     /// List of index types that have been successfully created for this column.
     pub created_indexes: IndexTypes,
+    /// Version of the column's fulltext bloom index. `0` means not recorded: the column
+    /// has no bloom index, or its index is the legacy format, which `ssts_index_meta`
+    /// reports as version 1.
+    #[serde(skip_serializing_if = "is_zero")]
+    pub fulltext_bloom_version: u8,
+}
+
+fn is_zero(version: &u8) -> bool {
+    *version == 0
 }
 
 impl FileMeta {
@@ -450,13 +461,14 @@ impl FileMeta {
         let id_to_indexes = self
             .indexes
             .iter()
-            .map(|index| (index.column_id, index.created_indexes.clone()))
+            .map(|index| (index.column_id, index))
             .collect::<std::collections::HashMap<_, _>>();
         for column in metadata {
             if !column.column_schema.is_indexed() {
                 continue;
             }
-            if let Some(indexes) = id_to_indexes.get(&column.column_id) {
+            if let Some(index) = id_to_indexes.get(&column.column_id) {
+                let indexes = &index.created_indexes;
                 if column.column_schema.is_inverted_indexed()
                     && !indexes.contains(&IndexType::InvertedIndex)
                 {
@@ -467,6 +479,26 @@ impl FileMeta {
                 {
                     return false;
                 }
+                if column
+                    .column_schema
+                    .fulltext_options()
+                    .ok()
+                    .flatten()
+                    .is_some_and(|options| {
+                        options.enable && options.backend == FulltextBackend::Bloom
+                    })
+                    && index.fulltext_bloom_version < FULLTEXT_BLOOM_VERSION
+                {
+                    debug!(
+                        "Fulltext bloom index is outdated, region_id: {}, file_id: {}, column_id: {}, version: {}, current: {}",
+                        self.region_id,
+                        self.file_id,
+                        column.column_id,
+                        index.fulltext_bloom_version,
+                        FULLTEXT_BLOOM_VERSION
+                    );
+                    return false;
+                }
                 if column.column_schema.is_skipping_indexed()
                     && !indexes.contains(&IndexType::BloomFilterIndex)
                 {
@@ -1038,6 +1070,7 @@ mod tests {
             indexes: vec![ColumnIndexMetadata {
                 column_id: 0,
                 created_indexes: SmallVec::from_iter([IndexType::InvertedIndex]),
+                ..Default::default()
             }],
             index_file_size: 0,
             index_version: 0,
@@ -1116,6 +1149,7 @@ mod tests {
             indexes: vec![ColumnIndexMetadata {
                 column_id: 0,
                 created_indexes: SmallVec::from_iter([IndexType::InvertedIndex]),
+                ..Default::default()
             }],
             index_file_size: 0,
             index_version: 0,
@@ -1340,6 +1374,7 @@ mod tests {
             indexes: vec![ColumnIndexMetadata {
                 column_id: 1,
                 created_indexes: SmallVec::from_iter([IndexType::InvertedIndex]),
+                ..Default::default()
             }],
             ..Default::default()
         };
@@ -1353,6 +1388,7 @@ mod tests {
                 IndexType::InvertedIndex,
                 IndexType::BloomFilterIndex,
             ]),
+            ..Default::default()
         }];
         let region_meta = vec![new_column_meta(1, "tag1", true, false, false)];
         assert!(file_meta.is_index_consistent_with_region(&region_meta));
@@ -1361,6 +1397,7 @@ mod tests {
         file_meta.indexes = vec![ColumnIndexMetadata {
             column_id: 1,
             created_indexes: SmallVec::from_iter([IndexType::InvertedIndex]),
+            ..Default::default()
         }];
         let region_meta = vec![new_column_meta(1, "tag1", true, true, false)]; // Requires fulltext too
         assert!(!file_meta.is_index_consistent_with_region(&region_meta));
@@ -1369,6 +1406,7 @@ mod tests {
         file_meta.indexes = vec![ColumnIndexMetadata {
             column_id: 2, // File only has index for column 2
             created_indexes: SmallVec::from_iter([IndexType::InvertedIndex]),
+            ..Default::default()
         }];
         let region_meta = vec![new_column_meta(1, "tag1", true, false, false)]; // Requires index on column 1
         assert!(!file_meta.is_index_consistent_with_region(&region_meta));
@@ -1377,6 +1415,7 @@ mod tests {
         file_meta.indexes = vec![ColumnIndexMetadata {
             column_id: 1,
             created_indexes: SmallVec::from_iter([IndexType::InvertedIndex]),
+            ..Default::default()
         }];
         let region_meta = vec![new_column_meta(1, "tag1", false, false, false)]; // No index required
         assert!(file_meta.is_index_consistent_with_region(&region_meta));
@@ -1391,10 +1430,12 @@ mod tests {
             ColumnIndexMetadata {
                 column_id: 1,
                 created_indexes: SmallVec::from_iter([IndexType::InvertedIndex]),
+                ..Default::default()
             },
             ColumnIndexMetadata {
                 column_id: 2, // Column 2 is missing the required BloomFilterIndex
                 created_indexes: SmallVec::from_iter([IndexType::FulltextIndex]),
+                ..Default::default()
             },
         ];
         let region_meta = vec![
@@ -1403,4 +1444,41 @@ mod tests {
         ];
         assert!(!file_meta.is_index_consistent_with_region(&region_meta));
     }
+
+    #[test]
+    fn test_index_consistency_requires_current_fulltext_bloom_version() {
+        let fulltext_column = |backend| {
+            let column_schema = ColumnSchema::new("msg", ConcreteDataType::string_datatype(), true)
+                .with_fulltext_options(FulltextOptions::new_unchecked(
+                    true,
+                    FulltextAnalyzer::English,
+                    false,
+                    backend,
+                    1000,
+                    0.01,
+                ))
+                .unwrap();
+            vec![ColumnMetadata {
+                column_schema,
+                semantic_type: api::v1::SemanticType::Field,
+                column_id: 1,
+            }]
+        };
+        let file_meta = |fulltext_bloom_version| FileMeta {
+            indexes: vec![ColumnIndexMetadata {
+                column_id: 1,
+                created_indexes: SmallVec::from_iter([IndexType::FulltextIndex]),
+                fulltext_bloom_version,
+            }],
+            ..Default::default()
+        };
+
+        let bloom = fulltext_column(FulltextBackend::Bloom);
+        // Written before the version was recorded, i.e. with the old bloom blob.
+        assert!(!file_meta(0).is_index_consistent_with_region(&bloom));
+        assert!(file_meta(FULLTEXT_BLOOM_VERSION).is_index_consistent_with_region(&bloom));
+        // Tantivy indexes carry no bloom version.
+        let tantivy = fulltext_column(FulltextBackend::Tantivy);
+        assert!(file_meta(0).is_index_consistent_with_region(&tantivy));
+    }
 }
diff --git a/src/mito2/src/sst/file_purger.rs b/src/mito2/src/sst/file_purger.rs
index 1b3b6239897..2660a19d4af 100644
--- a/src/mito2/src/sst/file_purger.rs
+++ b/src/mito2/src/sst/file_purger.rs
@@ -434,6 +434,7 @@ mod tests {
                     indexes: vec![ColumnIndexMetadata {
                         column_id: 0,
                         created_indexes: SmallVec::from_iter([IndexType::InvertedIndex]),
+                        ..Default::default()
                     }],
                     index_file_size: 4096,
                     index_version: 0,
diff --git a/src/mito2/src/sst/file_ref.rs b/src/mito2/src/sst/file_ref.rs
index 2f067cf3c19..4dee84ca1fa 100644
--- a/src/mito2/src/sst/file_ref.rs
+++ b/src/mito2/src/sst/file_ref.rs
@@ -77,12 +77,8 @@ impl FileReferenceManager {
     }
 
     fn ref_file_set(&self, region_id: RegionId) -> Option<HashSet<FileRef>> {
-        let file_refs = if let Some(file_refs) = self.files_per_region.get(&region_id) {
-            file_refs.clone()
-        } else {
-            // region id not found.
-            return None;
-        };
+        // region id not found.
+        let file_refs = self.files_per_region.get(&region_id)?.clone();
 
         if file_refs.files.is_empty() {
             // still return an empty manifest to indicate no files are referenced.
@@ -277,6 +273,7 @@ mod tests {
             indexes: vec![ColumnIndexMetadata {
                 column_id: 0,
                 created_indexes: SmallVec::from_iter([IndexType::InvertedIndex]),
+                ..Default::default()
             }],
             index_file_size: 4096,
             index_version: 0,
diff --git a/src/mito2/src/sst/index.rs b/src/mito2/src/sst/index.rs
index 502f6bcdc05..8cc332f8d29 100644
--- a/src/mito2/src/sst/index.rs
+++ b/src/mito2/src/sst/index.rs
@@ -74,6 +74,7 @@ use crate::sst::file::{
     ColumnIndexMetadata, FileHandle, IndexType, IndexTypes, RegionFileId, RegionIndexId,
 };
 use crate::sst::file_purger::FilePurgerRef;
+use crate::sst::index::fulltext_index::FULLTEXT_BLOOM_VERSION;
 use crate::sst::index::fulltext_index::creator::FulltextIndexer;
 use crate::sst::index::intermediate::IntermediateManager;
 use crate::sst::index::inverted_index::creator::InvertedIndexer;
@@ -160,6 +161,8 @@ pub struct IndexOutput {
     pub inverted_index: InvertedIndexOutput,
     /// Fulltext index output.
     pub fulltext_index: FulltextIndexOutput,
+    /// Columns of `fulltext_index` that use the bloom backend.
+    pub fulltext_bloom_columns: Vec<ColumnId>,
     /// Bloom filter output.
     pub bloom_filter: BloomFilterOutput,
 }
@@ -203,6 +206,13 @@ impl IndexOutput {
         map.into_iter()
             .map(|(column_id, created_indexes)| ColumnIndexMetadata {
                 column_id,
+                fulltext_bloom_version: if self.fulltext_index.is_available()
+                    && self.fulltext_bloom_columns.contains(&column_id)
+                {
+                    FULLTEXT_BLOOM_VERSION
+                } else {
+                    0
+                },
                 created_indexes,
             })
             .collect::<Vec<_>>()
@@ -1611,12 +1621,12 @@ mod tests {
         file_purger: FilePurgerRef,
         files: HashMap<FileId, FileMeta>,
     ) -> VersionControlRef {
-        let mutable = Arc::new(TimePartitions::new(
+        let mutable = TimePartitions::new(
             metadata.clone(),
             Arc::new(EmptyMemtableBuilder::default()),
             0,
             None,
-        ));
+        );
         let version_builder = VersionBuilder::new(metadata, mutable)
             .add_files(file_purger, files.values().cloned())
             .build();
diff --git a/src/mito2/src/sst/index/fulltext_index.rs b/src/mito2/src/sst/index/fulltext_index.rs
index 542a372bb01..ee166f817b5 100644
--- a/src/mito2/src/sst/index/fulltext_index.rs
+++ b/src/mito2/src/sst/index/fulltext_index.rs
@@ -16,4 +16,13 @@ pub(crate) mod applier;
 pub(crate) mod creator;
 
 pub(crate) const INDEX_BLOB_TYPE_TANTIVY: &str = "greptime-fulltext-index-v1";
-pub(crate) const INDEX_BLOB_TYPE_BLOOM: &str = "greptime-fulltext-index-bloom";
+/// Bloom blobs tokenized by `ScriptTokenizer`. A new key instead of a config field so that
+/// older versions, which would probe these tokens with their own rules and drop rows,
+/// don't find the blob and scan without pruning.
+pub(crate) const INDEX_BLOB_TYPE_BLOOM: &str = "greptime-fulltext-index-bloom-v2";
+/// Version of the bloom blobs stored under [`INDEX_BLOB_TYPE_BLOOM`], recorded in the
+/// manifest so that `ADMIN BUILD_INDEX` can find SSTs with older blobs.
+pub(crate) const FULLTEXT_BLOOM_VERSION: u8 = 2;
+/// Bloom blobs from older versions. Their tokens don't follow `matches_term` boundaries,
+/// so queries never probe them; they are kept only for index metadata listing.
+pub(crate) const INDEX_BLOB_TYPE_BLOOM_V1: &str = "greptime-fulltext-index-bloom";
diff --git a/src/mito2/src/sst/index/fulltext_index/applier.rs b/src/mito2/src/sst/index/fulltext_index/applier.rs
index 4efb2a5ccb9..55df0dd1a06 100644
--- a/src/mito2/src/sst/index/fulltext_index/applier.rs
+++ b/src/mito2/src/sst/index/fulltext_index/applier.rs
@@ -19,12 +19,12 @@ use std::sync::Arc;
 use std::time::Instant;
 
 use common_base::range_read::RangeReader;
+use common_base::term_token::{extract_like_probes, extract_term_probes};
 use common_telemetry::{tracing, warn};
 use index::bloom_filter::applier::{BloomFilterApplier, InListPredicate};
 use index::bloom_filter::reader::{BloomFilterReadMetrics, BloomFilterReaderImpl};
+use index::fulltext_index::Config;
 use index::fulltext_index::search::{FulltextIndexSearcher, RowId, TantivyFulltextIndexSearcher};
-use index::fulltext_index::tokenizer::{ChineseTokenizer, EnglishTokenizer, Tokenizer};
-use index::fulltext_index::{Analyzer, Config};
 use index::target::IndexTarget;
 use object_store::ObjectStore;
 use puffin::puffin_manager::cache::PuffinMetadataCacheRef;
@@ -45,7 +45,7 @@ use crate::error::{
 };
 use crate::metrics::INDEX_APPLY_ELAPSED;
 use crate::sst::file::RegionIndexId;
-use crate::sst::index::fulltext_index::applier::builder::{FulltextRequest, FulltextTerm};
+use crate::sst::index::fulltext_index::applier::builder::FulltextRequest;
 use crate::sst::index::fulltext_index::{INDEX_BLOB_TYPE_BLOOM, INDEX_BLOB_TYPE_TANTIVY};
 use crate::sst::index::puffin_manager::{
     PuffinManagerFactory, SstPuffinBlob, SstPuffinDir, SstPuffinReader,
@@ -233,7 +233,10 @@ impl FulltextIndexApplier {
 
         let mut row_ids: Option<BTreeSet<RowId>> = None;
         for (column_id, request) in self.requests.iter() {
-            if request.queries.is_empty() && request.terms.is_empty() {
+            // Tantivy tokens don't follow `matches_term` boundaries, e.g. `SimpleTokenizer`
+            // keeps "错误error日志" as one token, so terms and patterns are left to the
+            // bloom backend.
+            if request.queries.is_empty() {
                 continue;
             }
 
@@ -307,7 +310,6 @@ impl FulltextIndexApplier {
             TantivyFulltextIndexSearcher::new(path, config).context(ApplyFulltextIndexSnafu)?;
         let mut row_ids: Option<BTreeSet<RowId>> = None;
 
-        // 1. Apply queries
         for query in &request.queries {
             let result = searcher
                 .search(&query.0)
@@ -327,21 +329,6 @@ impl FulltextIndexApplier {
             }
         }
 
-        // 2. Apply terms
-        let query = request.terms_as_query(config.case_sensitive);
-        if !query.0.is_empty() {
-            let result = searcher
-                .search(&query.0)
-                .await
-                .context(ApplyFulltextIndexSnafu)?;
-
-            if let Some(ids) = row_ids.as_mut() {
-                ids.retain(|id| result.contains(id));
-            } else {
-                row_ids = Some(result);
-            }
-        }
-
         Ok(row_ids)
     }
 }
@@ -376,8 +363,7 @@ impl FulltextIndexApplier {
         let mut applied = false;
 
         for (column_id, request) in self.requests.iter() {
-            if request.terms.is_empty() {
-                // only apply terms
+            if request.terms.is_empty() && request.likes.is_empty() {
                 continue;
             }
 
@@ -386,7 +372,7 @@ impl FulltextIndexApplier {
                     file_id,
                     file_size_hint,
                     *column_id,
-                    &request.terms,
+                    request,
                     &mut output,
                     metrics.as_deref_mut(),
                 )
@@ -417,7 +403,7 @@ impl FulltextIndexApplier {
         file_id: RegionIndexId,
         file_size_hint: Option<u64>,
         column_id: ColumnId,
-        terms: &[FulltextTerm],
+        request: &FulltextRequest,
         output: &mut [(usize, Vec<Range<usize>>)],
         mut metrics: Option<&mut FulltextIndexApplyMetrics>,
     ) -> Result<bool> {
@@ -435,7 +421,7 @@ impl FulltextIndexApplier {
         let config =
             Config::from_blob_metadata(reader.metadata()).context(ApplyFulltextIndexSnafu)?;
 
-        let predicates = Self::terms_to_predicates(terms, &config);
+        let predicates = Self::request_to_predicates(request, &config);
         if predicates.is_empty() {
             return Ok(false);
         }
@@ -524,43 +510,39 @@ impl FulltextIndexApplier {
         }
     }
 
-    /// Converts terms to predicates.
-    ///
-    /// Split terms by non-alphanumeric characters and convert them to lowercase if case-insensitive.
-    /// Multiple terms are combined with AND semantics.
-    fn terms_to_predicates(terms: &[FulltextTerm], config: &Config) -> Vec<InListPredicate> {
-        let mut probes = HashSet::new();
-        for term in terms {
-            if config.case_sensitive && term.col_lowered {
-                // lowercased terms are not indexed
-                continue;
+    /// Converts terms and `LIKE` patterns to predicates, one per token that a matching
+    /// row must contain. Multiple predicates are combined with AND semantics.
+    fn request_to_predicates(request: &FulltextRequest, config: &Config) -> Vec<InListPredicate> {
+        // Probes of a lowercased column come from lowercased text and are indexed as is;
+        // a case-sensitive index has no tokens of the lowercased text.
+        let probes = |col_lowered: bool, probes: Vec<String>| -> Vec<Vec<u8>> {
+            match (col_lowered, config.case_sensitive) {
+                (true, true) => vec![],
+                (false, false) => probes
+                    .iter()
+                    .map(|p| p.to_lowercase().into_bytes())
+                    .collect(),
+                _ => probes.into_iter().map(String::into_bytes).collect(),
             }
-            probes.extend(Self::term_to_probes(&term.term, config));
-        }
+        };
+        let term_probes = request
+            .terms
+            .iter()
+            .flat_map(|term| probes(term.col_lowered, extract_term_probes(&term.term)));
+        let like_probes = request
+            .likes
+            .iter()
+            .flat_map(|like| probes(like.col_lowered, extract_like_probes(&like.pattern)));
 
-        probes
+        term_probes
+            .chain(like_probes)
+            .collect::<HashSet<_>>()
             .into_iter()
             .map(|p| InListPredicate {
                 list: iter::once(p).collect(),
             })
             .collect::<Vec<_>>()
     }
-
-    fn term_to_probes<'a>(term: &'a str, config: &'a Config) -> impl Iterator<Item = Vec<u8>> + 'a {
-        let tokens = match config.analyzer {
-            Analyzer::English => EnglishTokenizer {}.tokenize(term),
-            Analyzer::Chinese => ChineseTokenizer {}.tokenize(term),
-        };
-
-        tokens.into_iter().map(|t| {
-            if !config.case_sensitive {
-                t.to_lowercase()
-            } else {
-                t.to_string()
-            }
-            .into_bytes()
-        })
-    }
 }
 
 /// The source of the index.
@@ -774,3 +756,247 @@ impl IndexSource {
         Ok(reader)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use common_function::scalars::matches_term::MatchesTermFinder;
+    use datatypes::arrow::array::{Scalar, StringArray};
+    use datatypes::arrow::compute::kernels::comparison::like;
+    use index::fulltext_index::Analyzer;
+    use index::fulltext_index::tokenizer::{self, ScriptTokenizer};
+    use rand::rngs::StdRng;
+    use rand::{Rng, SeedableRng};
+
+    use super::*;
+    use crate::sst::index::fulltext_index::applier::builder::{FulltextLike, FulltextTerm};
+
+    /// A `matches_term` or `LIKE` predicate on `col`, or on `lower(col)` when `lowered`.
+    enum Predicate<'a> {
+        Term(&'a str),
+        Like(&'a str),
+        LowerTerm(&'a str),
+        LowerLike(&'a str),
+    }
+
+    impl Predicate<'_> {
+        fn eval(&self, text: &str) -> bool {
+            let like_matches = |text: &str, pattern: &str| {
+                like(
+                    &StringArray::from(vec![text]),
+                    &Scalar::new(StringArray::from(vec![pattern])),
+                )
+                .unwrap()
+                .value(0)
+            };
+            match self {
+                Predicate::Term(term) => MatchesTermFinder::new(term).find(text),
+                Predicate::Like(pattern) => like_matches(text, pattern),
+                Predicate::LowerTerm(term) => {
+                    MatchesTermFinder::new(term).find(&text.to_lowercase())
+                }
+                Predicate::LowerLike(pattern) => like_matches(&text.to_lowercase(), pattern),
+            }
+        }
+
+        fn request(&self) -> FulltextRequest {
+            let mut request = FulltextRequest::default();
+            let (term, like, col_lowered) = match *self {
+                Predicate::Term(term) => (Some(term), None, false),
+                Predicate::Like(pattern) => (None, Some(pattern), false),
+                Predicate::LowerTerm(term) => (Some(term), None, true),
+                Predicate::LowerLike(pattern) => (None, Some(pattern), true),
+            };
+            request.terms.extend(term.map(|term| FulltextTerm {
+                col_lowered,
+                term: term.to_string(),
+            }));
+            request.likes.extend(like.map(|pattern| FulltextLike {
+                col_lowered,
+                pattern: pattern.to_string(),
+            }));
+            request
+        }
+
+        /// Asserts that every probe is among `text`'s indexed tokens, i.e. the bloom
+        /// filter keeps the row, and returns the number of probes.
+        fn assert_probes_indexed(&self, text: &str) -> usize {
+            let mut num_probes = 0;
+            for case_sensitive in [true, false] {
+                let config = Config {
+                    analyzer: Analyzer::English,
+                    case_sensitive,
+                };
+                let tokens = tokenizer::Analyzer::new(Box::new(ScriptTokenizer), case_sensitive)
+                    .analyze_text(text)
+                    .unwrap()
+                    .into_iter()
+                    .collect::<HashSet<_>>();
+                let predicates =
+                    FulltextIndexApplier::request_to_predicates(&self.request(), &config);
+                for predicate in &predicates {
+                    assert!(
+                        predicate.list.iter().any(|probe| tokens.contains(probe)),
+                        "probe {:?} not indexed, text: {text:?}, case_sensitive: {case_sensitive}",
+                        predicate
+                            .list
+                            .iter()
+                            .map(|p| String::from_utf8_lossy(p))
+                            .collect::<Vec<_>>(),
+                    );
+                }
+                num_probes = predicates.len();
+            }
+            num_probes
+        }
+    }
+
+    #[test]
+    fn test_probes_keep_matching_rows() {
+        // (text, predicate, whether the predicate yields probes)
+        let cases = [
+            ("hello_world", Predicate::Term("world"), true),
+            ("trace_id=abc", Predicate::Term("id"), true),
+            ("错误error日志", Predicate::Term("error"), true),
+            (
+                "登录手机号18888888888的动态key",
+                Predicate::Term("手机号"),
+                true,
+            ),
+            (
+                "登录手机号18888888888的动态key",
+                Predicate::Term("机号"),
+                true,
+            ),
+            (
+                "登录手机号18888888888的动态key",
+                Predicate::Term("18888888888"),
+                true,
+            ),
+            // The ASCII edge of a Han term may continue in the text.
+            (
+                "登录手机号18888888888的动态key",
+                Predicate::Term("机号1888"),
+                true,
+            ),
+            ("中国农业银行", Predicate::Term("农业"), true),
+            ("中国农业银行", Predicate::Term("农"), false),
+            ("连接timeout.5次", Predicate::Term("timeout"), true),
+            ("用户user-123登录", Predicate::Term("user"), true),
+            (
+                "CRITICAL error: disk",
+                Predicate::Term("CRITICAL error"),
+                true,
+            ),
+            ("café>", Predicate::Term("café"), true),
+            (
+                "connection timeout after 5s",
+                Predicate::Like("%timeout%"),
+                false,
+            ),
+            (
+                "connection timeout after 5s",
+                Predicate::Like("% timeout %"),
+                true,
+            ),
+            (
+                "connection timeout after 5s",
+                Predicate::Like("connection%"),
+                false,
+            ),
+            (
+                "connection timeout after 5s",
+                Predicate::Like("connection %"),
+                true,
+            ),
+            (
+                "connection timeout after 5s",
+                Predicate::Like("%after 5s"),
+                true,
+            ),
+            ("trace_id=abc", Predicate::Like(r"trace\_id=%"), true),
+            ("trace_id=abc", Predicate::Like("trace_id=%"), false),
+            ("100% done", Predicate::Like(r"100\% done"), true),
+            ("错误error日志", Predicate::Like("%错误error日%"), true),
+            ("错误error日志", Predicate::Like("%r日志"), true),
+        ];
+        let lowered_cases = [
+            (
+                "Connection TIMEOUT after 5s",
+                Predicate::LowerTerm("timeout"),
+                true,
+            ),
+            (
+                "Connection TIMEOUT after 5s",
+                Predicate::LowerLike("% timeout %"),
+                true,
+            ),
+            // Lowercasing changes the class of U+212A KELVIN SIGN, splits U+0130 into
+            // two characters, and lowercases `Σ` depending on what follows it.
+            ("a\u{212A}b", Predicate::LowerTerm("akb"), true),
+            ("\u{130}stanbul", Predicate::LowerTerm("stanbul"), true),
+            ("ΟΔΟΣ.x", Predicate::LowerTerm("οδοσ"), true),
+        ];
+        for (text, predicate, has_probes) in cases.into_iter().chain(lowered_cases) {
+            assert!(predicate.eval(text), "case doesn't match: {text:?}");
+            assert_eq!(
+                predicate.assert_probes_indexed(text) > 0,
+                has_probes,
+                "text: {text:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_probes_keep_matching_rows_random() {
+        // Word characters of every class, separators, LIKE metacharacters, and
+        // characters whose lowercase changes length or class.
+        const ALPHABET: &[char] = &[
+            'a', 'b', 'A', '1', '_', '-', ' ', '.', '%', '\\', '错', '误', 'é', 'Д', '\u{212A}',
+            '\u{130}', 'Σ',
+        ];
+        let mut rng = StdRng::seed_from_u64(42);
+        let random_char = |rng: &mut StdRng| ALPHABET[rng.random_range(0..ALPHABET.len())];
+
+        for _ in 0..20000 {
+            let text = (0..rng.random_range(0..12))
+                .map(|_| random_char(&mut rng))
+                .collect::<String>();
+            let chars = text.chars().collect::<Vec<_>>();
+            let start = rng.random_range(0..=chars.len());
+            let end = rng.random_range(start..=chars.len());
+
+            let term = chars[start..end].iter().collect::<String>();
+            let lowered = term.to_lowercase();
+            for predicate in [Predicate::Term(&term), Predicate::LowerTerm(&lowered)] {
+                if predicate.eval(&text) {
+                    predicate.assert_probes_indexed(&text);
+                }
+            }
+
+            let mut pattern = String::new();
+            if start > 0 && rng.random_bool(0.5) {
+                pattern.push('%');
+            }
+            for &c in &chars[start..end] {
+                match rng.random_range(0..10) {
+                    0 => pattern.push('%'),
+                    1 => pattern.push('_'),
+                    _ if matches!(c, '%' | '_' | '\\') => {
+                        pattern.push('\\');
+                        pattern.push(c);
+                    }
+                    _ => pattern.push(c),
+                }
+            }
+            if end < chars.len() && rng.random_bool(0.5) {
+                pattern.push('%');
+            }
+            let lowered = pattern.to_lowercase();
+            for predicate in [Predicate::Like(&pattern), Predicate::LowerLike(&lowered)] {
+                if predicate.eval(&text) {
+                    predicate.assert_probes_indexed(&text);
+                }
+            }
+        }
+    }
+}
diff --git a/src/mito2/src/sst/index/fulltext_index/applier/builder.rs b/src/mito2/src/sst/index/fulltext_index/applier/builder.rs
index ea4d0063f9f..23122bc5416 100644
--- a/src/mito2/src/sst/index/fulltext_index/applier/builder.rs
+++ b/src/mito2/src/sst/index/fulltext_index/applier/builder.rs
@@ -14,9 +14,11 @@
 
 use std::collections::BTreeMap;
 
+use common_base::term_token::extract_like_probes;
 use datafusion_common::ScalarValue;
-use datafusion_expr::expr::ScalarFunction;
+use datafusion_expr::expr::{Like, ScalarFunction};
 use datafusion_expr::{BinaryExpr, Expr, Operator};
+use datatypes::schema::FulltextBackend;
 use object_store::ObjectStore;
 use puffin::puffin_manager::cache::PuffinMetadataCacheRef;
 use store_api::metadata::RegionMetadata;
@@ -36,31 +38,7 @@ use crate::sst::index::puffin_manager::PuffinManagerFactory;
 pub struct FulltextRequest {
     pub queries: Vec<FulltextQuery>,
     pub terms: Vec<FulltextTerm>,
-}
-
-impl FulltextRequest {
-    /// Convert terms to a query string.
-    ///
-    /// For example, if the terms are ["foo", "bar"], the query string will be `r#"+"foo" +"bar""#`.
-    /// Need to escape the `"` in the term.
-    ///
-    /// `skip_lowercased` is used for the situation that lowercased terms are not indexed.
-    pub fn terms_as_query(&self, skip_lowercased: bool) -> FulltextQuery {
-        let mut query = String::new();
-        for term in &self.terms {
-            if skip_lowercased && term.col_lowered {
-                continue;
-            }
-            // Escape the `"` in the term.
-            let escaped_term = term.term.replace("\"", "\\\"");
-            if query.is_empty() {
-                query = format!("+\"{escaped_term}\"");
-            } else {
-                query.push_str(&format!(" +\"{escaped_term}\""));
-            }
-        }
-        FulltextQuery(query)
-    }
+    pub likes: Vec<FulltextLike>,
 }
 
 /// A query to be matched in fulltext index.
@@ -79,6 +57,16 @@ pub struct FulltextTerm {
     pub term: String,
 }
 
+/// A case-sensitive `LIKE` pattern to be matched in fulltext index.
+///
+/// `pattern` is e.g. "%foo bar%" in `SELECT * FROM t WHERE text LIKE '%foo bar%'`.
+/// `col_lowered` indicates whether the column is lowercased, e.g. `lower(text) LIKE '%foo bar%'`.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FulltextLike {
+    pub col_lowered: bool,
+    pub pattern: String,
+}
+
 /// `FulltextIndexApplierBuilder` is a builder for `FulltextIndexApplier`.
 pub struct FulltextIndexApplierBuilder<'a> {
     table_dir: String,
@@ -144,9 +132,9 @@ impl<'a> FulltextIndexApplierBuilder<'a> {
         }
 
         // Check if any requests have queries or terms
-        let has_requests = requests
-            .iter()
-            .any(|(_, request)| !request.queries.is_empty() || !request.terms.is_empty());
+        let has_requests = requests.iter().any(|(_, request)| {
+            !request.queries.is_empty() || !request.terms.is_empty() || !request.likes.is_empty()
+        });
 
         Ok(has_requests.then(|| {
             FulltextIndexApplier::new(
@@ -176,6 +164,11 @@ impl<'a> FulltextIndexApplierBuilder<'a> {
                 Self::extract_requests(left, metadata, requests);
                 Self::extract_requests(right, metadata, requests);
             }
+            Expr::Like(like) => {
+                if let Some((column_id, like)) = Self::expr_to_like(metadata, like) {
+                    requests.entry(column_id).or_default().likes.push(like);
+                }
+            }
             Expr::ScalarFunction(func) => {
                 if let Some((column_id, query)) = Self::expr_to_query(metadata, func) {
                     requests.entry(column_id).or_default().queries.push(query);
@@ -261,6 +254,58 @@ impl<'a> FulltextIndexApplierBuilder<'a> {
         ))
     }
 
+    fn expr_to_like(metadata: &RegionMetadata, like: &Like) -> Option<(ColumnId, FulltextLike)> {
+        // `ILIKE` uses Unicode case folding, which disagrees with the index's
+        // `to_lowercase` on characters like 'ſ', so its probes could miss rows.
+        if like.negated || like.case_insensitive {
+            return None;
+        }
+        // Probes assume arrow's default `\` escape.
+        if !matches!(like.escape_char, None | Some('\\')) {
+            return None;
+        }
+
+        let (c, col_lowered) = match like.expr.as_ref() {
+            Expr::Column(c) => (c, false),
+            Expr::ScalarFunction(f) => match Self::extract_lower_arg(f)? {
+                Expr::Column(c) => (c, true),
+                _ => return None,
+            },
+            _ => return None,
+        };
+        let column = metadata.column_by_name(&c.name)?;
+        if column.column_schema.data_type != ConcreteDataType::string_datatype() {
+            return None;
+        }
+        // `LIKE` is common on unindexed columns and with patterns like '%word%' that have
+        // no probe; skip them instead of opening every SST's index for nothing.
+        let options = column.column_schema.fulltext_options().ok()??;
+        if !options.enable || options.backend != FulltextBackend::Bloom {
+            return None;
+        }
+
+        let Expr::Literal(
+            ScalarValue::Utf8(Some(pattern))
+            | ScalarValue::LargeUtf8(Some(pattern))
+            | ScalarValue::Utf8View(Some(pattern)),
+            _,
+        ) = like.pattern.as_ref()
+        else {
+            return None;
+        };
+        if extract_like_probes(pattern).is_empty() {
+            return None;
+        }
+
+        Some((
+            column.column_id,
+            FulltextLike {
+                col_lowered,
+                pattern: pattern.clone(),
+            },
+        ))
+    }
+
     fn extract_lower_arg(lower_func: &ScalarFunction) -> Option<&Expr> {
         if lower_func.args.len() != 1 {
             return None;
@@ -289,9 +334,9 @@ mod tests {
     use common_function::scalars::matches_term::MatchesTermFunction;
     use datafusion::functions::string::lower;
     use datafusion_common::Column;
-    use datafusion_expr::expr::ScalarFunction;
+    use datafusion_expr::expr::{Like, ScalarFunction};
     use datafusion_expr::{Literal, ScalarUDF};
-    use datatypes::schema::ColumnSchema;
+    use datatypes::schema::{ColumnSchema, FulltextAnalyzer, FulltextOptions};
     use store_api::metadata::{ColumnMetadata, RegionMetadataBuilder};
     use store_api::storage::RegionId;
 
@@ -512,6 +557,107 @@ mod tests {
         assert_eq!(request.queries[0], FulltextQuery("foo".to_string()));
     }
 
+    fn mock_metadata_with_fulltext(backend: FulltextBackend) -> RegionMetadata {
+        let mut builder = RegionMetadataBuilder::new(RegionId::new(1, 2));
+        builder
+            .push_column_metadata(ColumnMetadata {
+                column_schema: ColumnSchema::new("text", ConcreteDataType::string_datatype(), true)
+                    .with_fulltext_options(FulltextOptions::new_unchecked(
+                        true,
+                        FulltextAnalyzer::English,
+                        false,
+                        backend,
+                        10240,
+                        0.01,
+                    ))
+                    .unwrap(),
+                semantic_type: SemanticType::Field,
+                column_id: 1,
+            })
+            .push_column_metadata(ColumnMetadata {
+                column_schema: ColumnSchema::new(
+                    "ts",
+                    ConcreteDataType::timestamp_millisecond_datatype(),
+                    false,
+                ),
+                semantic_type: SemanticType::Timestamp,
+                column_id: 2,
+            });
+
+        builder.build().unwrap()
+    }
+
+    #[test]
+    fn test_expr_to_like() {
+        let like = |negated, case_insensitive, escape_char, pattern: &str| Like {
+            negated,
+            expr: Box::new(Expr::Column(Column::from_name("text"))),
+            pattern: Box::new(pattern.lit()),
+            escape_char,
+            case_insensitive,
+        };
+        let bloom = mock_metadata_with_fulltext(FulltextBackend::Bloom);
+
+        for escape_char in [None, Some('\\')] {
+            assert_eq!(
+                FulltextIndexApplierBuilder::expr_to_like(
+                    &bloom,
+                    &like(false, false, escape_char, "%foo bar baz%")
+                ),
+                Some((
+                    1,
+                    FulltextLike {
+                        col_lowered: false,
+                        pattern: "%foo bar baz%".to_string(),
+                    }
+                ))
+            );
+        }
+        let lowered = Like {
+            expr: Box::new(Expr::ScalarFunction(ScalarFunction {
+                args: vec![Expr::Column(Column::from_name("text"))],
+                func: lower(),
+            })),
+            ..like(false, false, None, "%foo bar baz%")
+        };
+        assert_eq!(
+            FulltextIndexApplierBuilder::expr_to_like(&bloom, &lowered),
+            Some((
+                1,
+                FulltextLike {
+                    col_lowered: true,
+                    pattern: "%foo bar baz%".to_string(),
+                }
+            ))
+        );
+        // NOT LIKE, ILIKE and other escape characters can't use the probes, and
+        // '%foo%' has none.
+        for like in [
+            like(true, false, None, "%foo bar baz%"),
+            like(false, true, None, "%foo bar baz%"),
+            like(false, false, Some('!'), "%foo bar baz%"),
+            like(false, false, None, "%foo%"),
+        ] {
+            assert_eq!(
+                FulltextIndexApplierBuilder::expr_to_like(&bloom, &like),
+                None
+            );
+        }
+        // Only columns with a bloom fulltext index.
+        for metadata in [
+            mock_metadata(),
+            mock_metadata_with_fulltext(FulltextBackend::Tantivy),
+        ] {
+            assert_eq!(
+                FulltextIndexApplierBuilder::expr_to_like(
+                    &metadata,
+                    &like(false, false, None, "%foo bar baz%")
+                ),
+                None
+            );
+        }
+    }
+
     #[test]
     fn test_extract_multiple_requests() {
         let metadata = mock_metadata();
@@ -551,92 +697,4 @@ mod tests {
             }
         );
     }
-
-    #[test]
-    fn test_terms_as_query() {
-        // Test with empty terms
-        let request = FulltextRequest::default();
-        assert_eq!(request.terms_as_query(false), FulltextQuery(String::new()));
-        assert_eq!(request.terms_as_query(true), FulltextQuery(String::new()));
-
-        // Test with a single term (not lowercased)
-        let mut request = FulltextRequest::default();
-        request.terms.push(FulltextTerm {
-            col_lowered: false,
-            term: "foo".to_string(),
-        });
-        assert_eq!(
-            request.terms_as_query(false),
-            FulltextQuery("+\"foo\"".to_string())
-        );
-        assert_eq!(
-            request.terms_as_query(true),
-            FulltextQuery("+\"foo\"".to_string())
-        );
-
-        // Test with a single lowercased term and skip_lowercased=true
-        let mut request = FulltextRequest::default();
-        request.terms.push(FulltextTerm {
-            col_lowered: true,
-            term: "foo".to_string(),
-        });
-        assert_eq!(
-            request.terms_as_query(false),
-            FulltextQuery("+\"foo\"".to_string())
-        );
-        assert_eq!(request.terms_as_query(true), FulltextQuery(String::new())); // Should skip lowercased term
-
-        // Test with multiple terms, mix of lowercased and not
-        let mut request = FulltextRequest::default();
-        request.terms.push(FulltextTerm {
-            col_lowered: false,
-            term: "foo".to_string(),
-        });
-        request.terms.push(FulltextTerm {
-            col_lowered: true,
-            term: "bar".to_string(),
-        });
-        assert_eq!(
-            request.terms_as_query(false),
-            FulltextQuery("+\"foo\" +\"bar\"".to_string())
-        );
-        assert_eq!(
-            request.terms_as_query(true),
-            FulltextQuery("+\"foo\"".to_string()) // Only the non-lowercased term
-        );
-
-        // Test with term containing quotes that need escaping
-        let mut request = FulltextRequest::default();
-        request.terms.push(FulltextTerm {
-            col_lowered: false,
-            term: "foo\"bar".to_string(),
-        });
-        assert_eq!(
-            request.terms_as_query(false),
-            FulltextQuery("+\"foo\\\"bar\"".to_string())
-        );
-
-        // Test with a complex mix of terms
-        let mut request = FulltextRequest::default();
-        request.terms.push(FulltextTerm {
-            col_lowered: false,
-            term: "foo".to_string(),
-        });
-        request.terms.push(FulltextTerm {
-            col_lowered: true,
-            term: "bar\"quoted\"".to_string(),
-        });
-        request.terms.push(FulltextTerm {
-            col_lowered: false,
-            term: "baz\\escape".to_string(),
-        });
-        assert_eq!(
-            request.terms_as_query(false),
-            FulltextQuery("+\"foo\" +\"bar\\\"quoted\\\"\" +\"baz\\escape\"".to_string())
-        );
-        assert_eq!(
-            request.terms_as_query(true),
-            FulltextQuery("+\"foo\" +\"baz\\escape\"".to_string()) // Skips the lowercased term
-        );
-    }
 }
diff --git a/src/mito2/src/sst/index/fulltext_index/creator.rs b/src/mito2/src/sst/index/fulltext_index/creator.rs
index 800e0b77a09..7348d81b7f3 100644
--- a/src/mito2/src/sst/index/fulltext_index/creator.rs
+++ b/src/mito2/src/sst/index/fulltext_index/creator.rs
@@ -229,6 +229,14 @@ impl FulltextIndexer {
     pub fn column_ids(&self) -> impl Iterator<Item = ColumnId> + '_ {
         self.creators.keys().copied()
     }
+
+    /// Returns IDs of columns indexed with the bloom backend.
+    pub fn bloom_column_ids(&self) -> impl Iterator<Item = ColumnId> + '_ {
+        self.creators
+            .values()
+            .filter(|c| matches!(c.inner, AltFulltextCreator::Bloom(_)))
+            .map(|c| c.column_id)
+    }
 }
 
 impl FulltextIndexer {
@@ -778,28 +786,8 @@ mod tests {
         let row_ids = applier_factory(vec![(1, "World")], vec![], None).await;
         assert_eq!(row_ids, Some(rows([3])));
 
+        // Terms are left to the bloom backend.
         let row_ids = applier_factory(vec![], vec![(1, vec![(false, "hello")])], None).await;
-        assert_eq!(row_ids, Some(rows([0])));
-
-        let row_ids = applier_factory(vec![], vec![(1, vec![(true, "hello")])], None).await;
-        assert_eq!(row_ids, None);
-
-        let row_ids = applier_factory(vec![], vec![(1, vec![(false, "world")])], None).await;
-        assert_eq!(row_ids, Some(rows([1])));
-
-        let row_ids = applier_factory(vec![], vec![(1, vec![(true, "world")])], None).await;
-        assert_eq!(row_ids, None);
-
-        let row_ids = applier_factory(vec![], vec![(1, vec![(false, "Hello")])], None).await;
-        assert_eq!(row_ids, Some(rows([3])));
-
-        let row_ids = applier_factory(vec![], vec![(1, vec![(true, "Hello")])], None).await;
-        assert_eq!(row_ids, None);
-
-        let row_ids = applier_factory(vec![], vec![(1, vec![(false, "Hello, World")])], None).await;
-        assert_eq!(row_ids, Some(rows([3])));
-
-        let row_ids = applier_factory(vec![], vec![(1, vec![(true, "Hello, World")])], None).await;
         assert_eq!(row_ids, None);
     }
 
@@ -939,30 +927,6 @@ mod tests {
 
         let row_ids = applier_factory(vec![(2, "World")], vec![], None).await;
         assert_eq!(row_ids, Some(rows([2, 3])));
-
-        let row_ids = applier_factory(vec![], vec![(2, vec![(false, "hello")])], None).await;
-        assert_eq!(row_ids, Some(rows([0, 3])));
-
-        let row_ids = applier_factory(vec![], vec![(2, vec![(true, "hello")])], None).await;
-        assert_eq!(row_ids, Some(rows([0, 3])));
-
-        let row_ids = applier_factory(vec![], vec![(2, vec![(false, "world")])], None).await;
-        assert_eq!(row_ids, Some(rows([2, 3])));
-
-        let row_ids = applier_factory(vec![], vec![(2, vec![(true, "world")])], None).await;
-        assert_eq!(row_ids, Some(rows([2, 3])));
-
-        let row_ids = applier_factory(vec![], vec![(2, vec![(false, "Hello")])], None).await;
-        assert_eq!(row_ids, Some(rows([0, 3])));
-
-        let row_ids = applier_factory(vec![], vec![(2, vec![(true, "Hello")])], None).await;
-        assert_eq!(row_ids, Some(rows([0, 3])));
-
-        let row_ids = applier_factory(vec![], vec![(2, vec![(false, "World")])], None).await;
-        assert_eq!(row_ids, Some(rows([2, 3])));
-
-        let row_ids = applier_factory(vec![], vec![(2, vec![(true, "World")])], None).await;
-        assert_eq!(row_ids, Some(rows([2, 3])));
     }
 
     #[tokio::test]
@@ -995,22 +959,6 @@ mod tests {
         .await;
         assert_eq!(row_ids, Some(rows([3])));
 
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(true, "hello")])],
-            Some(BitVec::from_slice(&[0b1111])),
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([0, 3])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(true, "hello")])],
-            Some(BitVec::from_slice(&[0b1110])), // row 0 is filtered out
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([3])));
-
         let row_ids = applier_factory(
             vec![],
             vec![(2, vec![(false, "world")])],
@@ -1027,22 +975,6 @@ mod tests {
         .await;
         assert_eq!(row_ids, Some(rows([3])));
 
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(true, "world")])],
-            Some(BitVec::from_slice(&[0b1111])),
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([2, 3])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(true, "world")])],
-            Some(BitVec::from_slice(&[0b1011])), // row 2 is filtered out
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([3])));
-
         let row_ids = applier_factory(
             vec![],
             vec![(2, vec![(false, "Hello")])],
@@ -1059,22 +991,6 @@ mod tests {
         .await;
         assert_eq!(row_ids, Some(rows([0])));
 
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(true, "Hello")])],
-            Some(BitVec::from_slice(&[0b1111])),
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([0, 3])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(true, "Hello")])],
-            Some(BitVec::from_slice(&[0b1110])), // row 0 is filtered out
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([3])));
-
         let row_ids = applier_factory(
             vec![],
             vec![(2, vec![(false, "World")])],
@@ -1093,19 +1009,11 @@ mod tests {
 
         let row_ids = applier_factory(
             vec![],
-            vec![(2, vec![(true, "World")])],
+            vec![(2, vec![(true, "hello")])],
             Some(BitVec::from_slice(&[0b1111])),
         )
         .await;
-        assert_eq!(row_ids, Some(rows([2, 3])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(true, "World")])],
-            Some(BitVec::from_slice(&[0b1011])), // row 2 is filtered out
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([3])));
+        assert_eq!(row_ids, Some(rows([0, 3])));
     }
 
     #[tokio::test]
@@ -1127,12 +1035,6 @@ mod tests {
 
         let row_ids = applier_factory(vec![(3, "世界")], vec![], None).await;
         assert_eq!(row_ids, Some(rows([2, 3])));
-
-        let row_ids = applier_factory(vec![], vec![(3, vec![(false, "你好")])], None).await;
-        assert_eq!(row_ids, Some(rows([0, 3])));
-
-        let row_ids = applier_factory(vec![], vec![(3, vec![(false, "世界")])], None).await;
-        assert_eq!(row_ids, Some(rows([2, 3])));
     }
 
     #[tokio::test]
@@ -1182,61 +1084,6 @@ mod tests {
         assert_eq!(row_ids, Some(rows([3])));
     }
 
-    #[tokio::test]
-    async fn test_fulltext_index_multi_terms_case_sensitive_tantivy() {
-        let applier_factory = build_fulltext_applier_factory(
-            "test_fulltext_index_multi_terms_case_sensitive_tantivy_",
-            FulltextBackend::Tantivy,
-            &[
-                (Some("Hello"), None, None),
-                (Some("World"), None, None),
-                (None, None, None),
-                (Some("Hello, World"), None, None),
-            ],
-        )
-        .await;
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(1, vec![(false, "hello"), (false, "world")])],
-            None,
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(1, vec![(false, "Hello"), (false, "World")])],
-            None,
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([3])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(1, vec![(true, "Hello"), (false, "World")])],
-            None,
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([1, 3])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(1, vec![(false, "Hello"), (true, "World")])],
-            None,
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([0, 3])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(1, vec![(true, "Hello"), (true, "World")])],
-            None,
-        )
-        .await;
-        assert_eq!(row_ids, None);
-    }
-
     #[tokio::test]
     async fn test_fulltext_index_multi_terms_case_sensitive_bloom() {
         let applier_factory = build_fulltext_applier_factory(
@@ -1292,53 +1139,6 @@ mod tests {
         assert_eq!(row_ids, None);
     }
 
-    #[tokio::test]
-    async fn test_fulltext_index_multi_terms_case_insensitive_tantivy() {
-        let applier_factory = build_fulltext_applier_factory(
-            "test_fulltext_index_multi_terms_case_insensitive_tantivy_",
-            FulltextBackend::Tantivy,
-            &[
-                (None, Some("hello"), None),
-                (None, None, None),
-                (None, Some("world"), None),
-                (None, Some("Hello, World"), None),
-            ],
-        )
-        .await;
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(false, "hello"), (false, "world")])],
-            None,
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([3])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(true, "hello"), (false, "world")])],
-            None,
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([3])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(false, "hello"), (true, "world")])],
-            None,
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([3])));
-
-        let row_ids = applier_factory(
-            vec![],
-            vec![(2, vec![(true, "hello"), (true, "world")])],
-            None,
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([3])));
-    }
-
     #[tokio::test]
     async fn test_fulltext_index_multi_terms_case_insensitive_bloom() {
         let applier_factory = build_fulltext_applier_factory(
@@ -1404,16 +1204,10 @@ mod tests {
         )
         .await;
 
-        let row_ids = applier_factory(
-            vec![(1, "Hello"), (3, "你好")],
-            vec![(2, vec![(false, "world")])],
-            None,
-        )
-        .await;
-        assert_eq!(row_ids, Some(rows([3])));
+        let row_ids = applier_factory(vec![(1, "Hello"), (3, "你好")], vec![], None).await;
+        assert_eq!(row_ids, Some(rows([0, 3])));
 
-        let row_ids =
-            applier_factory(vec![(2, "World")], vec![(1, vec![(false, "World")])], None).await;
+        let row_ids = applier_factory(vec![(1, "World"), (2, "World")], vec![], None).await;
         assert_eq!(row_ids, Some(rows([1, 3])));
     }
 
diff --git a/src/mito2/src/sst/index/indexer/finish.rs b/src/mito2/src/sst/index/indexer/finish.rs
index 6a6c3f34d0b..0c1f200d599 100644
--- a/src/mito2/src/sst/index/indexer/finish.rs
+++ b/src/mito2/src/sst/index/indexer/finish.rs
@@ -160,6 +160,7 @@ impl Indexer {
         };
 
         let column_ids = indexer.column_ids().collect();
+        index_output.fulltext_bloom_columns = indexer.bloom_column_ids().collect();
         let err = match indexer.finish(puffin_writer).await {
             Ok((row_count, byte_count)) => {
                 self.fill_fulltext_index_output(
diff --git a/src/mito2/src/sst/index/inverted_index/applier.rs b/src/mito2/src/sst/index/inverted_index/applier.rs
index 0f665eec549..8f0c309a003 100644
--- a/src/mito2/src/sst/index/inverted_index/applier.rs
+++ b/src/mito2/src/sst/index/inverted_index/applier.rs
@@ -221,8 +221,9 @@ impl InvertedIndexApplier {
         let start = Instant::now();
 
         let context = SearchContext {
-            // Encountering a non-existing column indicates that it doesn't match predicates.
-            index_not_found_strategy: IndexNotFoundStrategy::ReturnEmpty,
+            // Older SSTs may lack an index enabled by ALTER, or a column with a default value.
+            // Missing indexes cannot rule out matching rows.
+            index_not_found_strategy: IndexNotFoundStrategy::Ignore,
         };
 
         let mut cache_miss = 0;
diff --git a/src/mito2/src/sst/index/inverted_index/creator.rs b/src/mito2/src/sst/index/inverted_index/creator.rs
index d1dee226515..9c1ba5cbca0 100644
--- a/src/mito2/src/sst/index/inverted_index/creator.rs
+++ b/src/mito2/src/sst/index/inverted_index/creator.rs
@@ -556,6 +556,7 @@ mod tests {
     async fn build_applier_factory(
         prefix: &str,
         rows: BTreeSet<(&'static str, i32, [u64; 2])>,
+        sst_indexed_column_ids: HashSet<ColumnId>,
     ) -> impl Fn(DfExpr) -> BoxFuture<'static, Vec<usize>> {
         let (d, factory) = PuffinManagerFactory::new_for_test_async(prefix).await;
         let table_dir = "table0".to_string();
@@ -573,7 +574,7 @@ mod tests {
             intm_mgr,
             memory_threshold,
             NonZeroUsize::new(segment_row_count).unwrap(),
-            indexed_column_ids.clone(),
+            sst_indexed_column_ids,
         );
 
         for (str_tag, i32_tag, u64_field) in &rows {
@@ -624,6 +625,42 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn test_create_and_query_missing_index() {
+        let rows = BTreeSet::from_iter([("aaa", 1, [1, 2]), ("bbb", 2, [3, 4])]);
+        // The SST predates enabling indexes on tag_i32 and field_u64.
+        let applier_factory = build_applier_factory(
+            "test_create_and_query_missing_index_",
+            rows,
+            HashSet::from([1]),
+        )
+        .await;
+
+        let cases = [
+            (col("tag_i32").eq(lit(1)), vec![0, 1]),
+            (
+                col("tag_i32")
+                    .eq(lit(1))
+                    .and(col("field_u64").eq(lit(1u64))),
+                vec![0, 1],
+            ),
+            (
+                col("tag_str").eq(lit("aaa")).and(col("tag_i32").eq(lit(1))),
+                vec![0],
+            ),
+            (
+                col("tag_str")
+                    .eq(lit("missing"))
+                    .and(col("tag_i32").eq(lit(1))),
+                vec![],
+            ),
+        ];
+        for (expr, expected) in cases {
+            let actual = applier_factory(expr.clone()).await;
+            assert_eq!(actual, expected, "{expr}");
+        }
+    }
+
     #[tokio::test]
     async fn test_create_and_query_get_key() {
         let rows = BTreeSet::from_iter([
@@ -638,7 +675,12 @@ mod tests {
             ("abc", 3, [9, 10]),
         ]);
 
-        let applier_factory = build_applier_factory("test_create_and_query_get_key_", rows).await;
+        let applier_factory = build_applier_factory(
+            "test_create_and_query_get_key_",
+            rows,
+            HashSet::from([1, 2, 4]),
+        )
+        .await;
 
         let expr = col("tag_str").eq(lit("aaa"));
         let res = applier_factory(expr).await;
@@ -681,7 +723,12 @@ mod tests {
             ("abc", 3, [9, 10]),
         ]);
 
-        let applier_factory = build_applier_factory("test_create_and_query_range_", rows).await;
+        let applier_factory = build_applier_factory(
+            "test_create_and_query_range_",
+            rows,
+            HashSet::from([1, 2, 4]),
+        )
+        .await;
 
         let expr = col("tag_str").between(lit("aaa"), lit("aab"));
         let res = applier_factory(expr).await;
@@ -718,8 +765,12 @@ mod tests {
             ("abc", 3, [9, 10]),
         ]);
 
-        let applier_factory =
-            build_applier_factory("test_create_and_query_comparison_", rows).await;
+        let applier_factory = build_applier_factory(
+            "test_create_and_query_comparison_",
+            rows,
+            HashSet::from([1, 2, 4]),
+        )
+        .await;
 
         let expr = col("tag_str").lt(lit("aab"));
         let res = applier_factory(expr).await;
@@ -800,7 +851,12 @@ mod tests {
             ("abc", 3, [9, 10]),
         ]);
 
-        let applier_factory = build_applier_factory("test_create_and_query_regex_", rows).await;
+        let applier_factory = build_applier_factory(
+            "test_create_and_query_regex_",
+            rows,
+            HashSet::from([1, 2, 4]),
+        )
+        .await;
 
         let expr = binary_expr(col("tag_str"), Operator::RegexMatch, lit(".*"));
         let res = applier_factory(expr).await;
diff --git a/src/mito2/src/sst/parquet.rs b/src/mito2/src/sst/parquet.rs
index 301842bde72..9404d4484fc 100644
--- a/src/mito2/src/sst/parquet.rs
+++ b/src/mito2/src/sst/parquet.rs
@@ -77,6 +77,18 @@ pub(crate) struct Json2TargetLayout {
 /// batching without changing the row group layout of newly written SSTs.
 pub const DEFAULT_ROW_GROUP_SIZE: usize = 100 * 1024;
 
+/// Truncation length of min/max values in the parquet column index.
+///
+/// Mito never reads the column index (it is skipped or stripped on load), so truncating
+/// it is safe. Chunk statistics stay untruncated because pruning decodes primary keys
+/// from them. Without truncation every page of a large string column stores its whole
+/// min and max values, uncompressed.
+///
+/// Truncated values are only bounds: code that starts reading the column index must not
+/// decode primary keys from it.
+pub(crate) const COLUMN_INDEX_TRUNCATE_LENGTH: Option<usize> =
+    parquet::file::properties::DEFAULT_COLUMN_INDEX_TRUNCATE_LENGTH;
+
 /// Applies the configured encoding to direct floating-point field columns.
 pub(crate) fn apply_float_field_encoding(
     mut builder: WriterPropertiesBuilder,
@@ -901,6 +913,82 @@ mod tests {
         .await;
     }
 
+    #[tokio::test]
+    async fn test_column_index_truncates_large_field_values() {
+        let mut env = TestEnv::new().await;
+        let object_store = env.init_object_store_manager();
+        let handle = sst_file_handle(0, 1000);
+        let file_path = FixedPathProvider {
+            region_file_id: handle.file_id(),
+        };
+        let metadata = build_test_binary_test_region_metadata();
+        // A tag long enough that the encoded primary key exceeds the 64-byte truncation length.
+        let tag = "t".repeat(100);
+        let values: Vec<Vec<u8>> = (0..64)
+            .map(|i| format!("{i:08}").into_bytes().repeat(4 * 1024))
+            .collect();
+        let batch = new_record_batch_with_binary_values(&tag, &values);
+        let mut metrics = Metrics::new(WriteType::Flush);
+        let mut writer = ParquetWriter::new_with_object_store(
+            object_store.clone(),
+            metadata.clone(),
+            IndexConfig::default(),
+            NoopIndexBuilder,
+            file_path,
+            &mut metrics,
+        )
+        .await;
+        writer
+            .write_all_flat_as_primary_key(
+                new_flat_source_from_record_batches(vec![batch]),
+                None,
+                &WriteOptions::default(),
+            )
+            .await
+            .unwrap();
+
+        let path = handle.file_path(FILE_DIR, PathType::Bare);
+        let bytes = object_store.read(&path).await.unwrap().to_bytes();
+        let options = parquet::arrow::arrow_reader::ArrowReaderOptions::new()
+            .with_page_index_policy(PageIndexPolicy::Required);
+        let builder =
+            ParquetRecordBatchReaderBuilder::try_new_with_options(bytes, options).unwrap();
+        let parquet_meta = builder.metadata().clone();
+        let schema = parquet_meta.file_metadata().schema_descr();
+        let column = |name: &str| {
+            (0..schema.num_columns())
+                .find(|i| schema.column(*i).name() == name)
+                .unwrap()
+        };
+
+        let field_index = &parquet_meta.column_index().unwrap()[0][column("field_0")];
+        let parquet::file::page_index::column_index::ColumnIndexMetaData::BYTE_ARRAY(field_index) =
+            field_index
+        else {
+            panic!("unexpected column index: {field_index:?}");
+        };
+        let mut pages = 0;
+        for (min, max) in field_index
+            .min_values_iter()
+            .zip(field_index.max_values_iter())
+        {
+            assert!(min.unwrap().len() <= 64);
+            assert!(max.unwrap().len() <= 64);
+            pages += 1;
+        }
+        assert!(pages > 1, "values should span several pages");
+
+        // Chunk statistics keep exact primary keys; pruning decodes them.
+        let pk_stats = parquet_meta
+            .row_group(0)
+            .column(column(store_api::storage::consts::PRIMARY_KEY_COLUMN_NAME))
+            .statistics()
+            .unwrap();
+        let pk = new_primary_key(&[&tag]);
+        assert!(pk.len() > 64);
+        assert_eq!(pk_stats.max_bytes_opt().unwrap(), pk.as_slice());
+    }
+
     #[rstest::rstest]
     #[tokio::test]
     async fn test_write_multiple_files(#[values(1024, 4096)] write_buffer_size: usize) {
@@ -1475,6 +1563,32 @@ mod tests {
         assert!(cached.contains_row_group(3));
     }
 
+    fn new_record_batch_with_binary_values(tag: &str, values: &[Vec<u8>]) -> RecordBatch {
+        let metadata = build_test_binary_test_region_metadata();
+        let flat_schema = to_flat_sst_arrow_schema(&metadata, &FlatSchemaOptions::default());
+        let num_rows = values.len();
+        let mut tag_0_builder = StringDictionaryBuilder::<UInt32Type>::new();
+        let mut pk_builder = BinaryDictionaryBuilder::<UInt32Type>::new();
+        let pk = new_primary_key(&[tag]);
+        for _ in 0..num_rows {
+            tag_0_builder.append_value(tag);
+            pk_builder.append(&pk).unwrap();
+        }
+        let columns: Vec<ArrayRef> = vec![
+            Arc::new(tag_0_builder.finish()),
+            Arc::new(datatypes::arrow::array::BinaryArray::from_iter_values(
+                values.iter().map(|v| v.as_slice()),
+            )),
+            Arc::new(TimestampMillisecondArray::from_iter_values(
+                0..num_rows as i64,
+            )),
+            Arc::new(pk_builder.finish()),
+            Arc::new(UInt64Array::from_value(1000, num_rows)),
+            Arc::new(UInt8Array::from_value(OpType::Put as u8, num_rows)),
+        ];
+        RecordBatch::try_new(flat_schema, columns).unwrap()
+    }
+
     fn new_record_batch_with_binary(tags: &[&str], start: usize, end: usize) -> RecordBatch {
         assert!(end >= start);
         let metadata = build_test_binary_test_region_metadata();
diff --git a/src/mito2/src/sst/parquet/prefilter.rs b/src/mito2/src/sst/parquet/prefilter.rs
index 4362440e415..d5401f4a6de 100644
--- a/src/mito2/src/sst/parquet/prefilter.rs
+++ b/src/mito2/src/sst/parquet/prefilter.rs
@@ -341,8 +341,7 @@ pub(crate) fn build_bulk_filter_plan(
     predicate: Option<&Predicate>,
 ) -> BulkFilterPlan {
     let metadata = read_format.metadata();
-    // Bulk memtable only needs simple binary filters here. Any filter that
-    // cannot be reduced to a SimpleFilterContext stays out of this fast path.
+    // Filters not recognized by SimpleFilterContext stay out of this fast path.
     let simple_filters: Vec<SimpleFilterContext> = predicate
         .into_iter()
         .flat_map(|predicate| {
diff --git a/src/mito2/src/sst/parquet/reader.rs b/src/mito2/src/sst/parquet/reader.rs
index 90c2728e35d..a3cbdef90f1 100644
--- a/src/mito2/src/sst/parquet/reader.rs
+++ b/src/mito2/src/sst/parquet/reader.rs
@@ -2014,7 +2014,12 @@ impl SimpleFilterContext {
         expected_meta: Option<&RegionMetadata>,
         expr: &Expr,
     ) -> Option<Self> {
-        let filter = SimpleFilterEvaluator::try_new(expr)?;
+        let filter = SimpleFilterEvaluator::try_new_with_column_type(expr, &|name| {
+            expected_meta
+                .unwrap_or(sst_meta)
+                .column_by_name(name)
+                .map(|column| column.column_schema.data_type.as_arrow_type())
+        })?;
         let expr_str = format!("{expr:?}");
         let (column_metadata, maybe_filter) = match expected_meta {
             Some(meta) => {
@@ -3159,6 +3164,15 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn test_nullable_label_filter_uses_missing_sst_column_default() {
+        let metadata = Arc::new(sst_region_metadata());
+        let expected = expected_metadata_with_reused_tag_name(&metadata);
+        let expr = col("tag_0").is_null().or(col("tag_0").not_eq(lit("lo")));
+        let ctx = SimpleFilterContext::new_opt(&metadata, Some(&expected), &expr).unwrap();
+        assert!(matches!(ctx.filter(), MaybeFilter::Matched));
+    }
+
     #[test]
     fn test_simple_filter_context_drops_mismatched_field_filter() {
         let (sst_metadata, latest_metadata) = mock_metadata();
diff --git a/src/mito2/src/sst/parquet/writer.rs b/src/mito2/src/sst/parquet/writer.rs
index b9ef15add34..932654dfdd8 100644
--- a/src/mito2/src/sst/parquet/writer.rs
+++ b/src/mito2/src/sst/parquet/writer.rs
@@ -62,7 +62,8 @@ use crate::sst::parquet::flat_format::{
 };
 use crate::sst::parquet::format::{PrimaryKeyArray, PrimaryKeyWriteFormat};
 use crate::sst::parquet::{
-    PARQUET_METADATA_KEY, SstInfo, WriteOptions, apply_float_field_encoding,
+    COLUMN_INDEX_TRUNCATE_LENGTH, PARQUET_METADATA_KEY, SstInfo, WriteOptions,
+    apply_float_field_encoding,
 };
 use crate::sst::{
     DEFAULT_WRITE_CONCURRENCY, FlatSchemaOptions, SeriesEstimator, maybe_wrap_schema,
@@ -544,7 +545,7 @@ where
                 .set_compression(Compression::ZSTD(ZstdLevel::default()))
                 .set_encoding(Encoding::PLAIN)
                 .set_max_row_group_row_count(Some(opts.row_group_size))
-                .set_column_index_truncate_length(None)
+                .set_column_index_truncate_length(COLUMN_INDEX_TRUNCATE_LENGTH)
                 .set_statistics_truncate_length(None);
             let ts_col = ColumnPath::new(vec![
                 self.metadata.time_index_column().column_schema.name.clone(),
diff --git a/src/mito2/src/sst/primary_key.rs b/src/mito2/src/sst/primary_key.rs
index 5fb258052c7..7752a652f80 100644
--- a/src/mito2/src/sst/primary_key.rs
+++ b/src/mito2/src/sst/primary_key.rs
@@ -270,12 +270,12 @@ mod tests {
     }
 
     fn version_with_files(metadata: RegionMetadataRef, files: Vec<FileMeta>) -> VersionRef {
-        let mutable = Arc::new(TimePartitions::new(
+        let mutable = TimePartitions::new(
             metadata.clone(),
             Arc::new(TimeSeriesMemtableBuilder::default()),
             0,
             None,
-        ));
+        );
         Arc::new(
             VersionBuilder::new(metadata, mutable)
                 .add_files(new_noop_file_purger(), files.into_iter())
diff --git a/src/mito2/src/test_util/version_util.rs b/src/mito2/src/test_util/version_util.rs
index 1c0d7bfebc8..44827b35cc1 100644
--- a/src/mito2/src/test_util/version_util.rs
+++ b/src/mito2/src/test_util/version_util.rs
@@ -132,12 +132,7 @@ impl VersionControlBuilder {
 
     pub(crate) fn build_version(&self) -> Version {
         let metadata = Arc::new(self.metadata.clone());
-        let mutable = Arc::new(TimePartitions::new(
-            metadata.clone(),
-            self.memtable_builder.clone(),
-            0,
-            None,
-        ));
+        let mutable = TimePartitions::new(metadata.clone(), self.memtable_builder.clone(), 0, None);
         VersionBuilder::new(metadata, mutable)
             .add_files(self.file_purger.clone(), self.files.values().cloned())
             .build()
diff --git a/src/mito2/src/worker/handle_close.rs b/src/mito2/src/worker/handle_close.rs
index 5a0406c655f..ede17511ad7 100644
--- a/src/mito2/src/worker/handle_close.rs
+++ b/src/mito2/src/worker/handle_close.rs
@@ -36,16 +36,12 @@ impl<S: LogStore> RegionWorkerLoop<S> {
 
         info!("Try to close region {}, worker: {}", region_id, self.id);
 
-        // If the close request asks for a flush, or the region skips WAL,
-        // and has data in memtable and region is flushable (like, not in follower state),
-        // we should flush it before closing to ensure durability.
-        if (request.flush_on_close || region.skip_wal())
-            && !region
-                .version_control
-                .current()
-                .version
-                .memtables
-                .is_empty()
+        // Memtables containing skip-WAL writes must be flushed before closing.
+        // Followers cannot flush; explicit flush-on-close and region WAL options
+        // retain their existing behavior.
+        let version = region.version();
+        if (request.flush_on_close || region.skip_wal() || version.memtables.has_skip_wal_writes())
+            && !version.memtables.is_empty()
             && region.is_flushable()
         {
             info!("Region {} has pending data, waiting for flush", region_id);
@@ -69,7 +65,7 @@ impl<S: LogStore> RegionWorkerLoop<S> {
             return;
         }
 
-        // WAL configured or memtable is empty, flush is not necessary.
+        // No close-time flush is required, or the region cannot flush.
         self.remove_region(region_id).await;
         info!("Region {} closed, worker: {}", region_id, self.id);
         sender.send(Ok(0))
diff --git a/src/mito2/src/worker/handle_manifest.rs b/src/mito2/src/worker/handle_manifest.rs
index aa8475a49f1..a5761434e91 100644
--- a/src/mito2/src/worker/handle_manifest.rs
+++ b/src/mito2/src/worker/handle_manifest.rs
@@ -257,13 +257,10 @@ impl<S: LogStore> RegionWorkerLoop<S> {
         } else {
             None
         };
-        let new_mutable = Arc::new(
-            region
-                .version()
-                .memtables
-                .mutable
-                .new_with_part_duration(version.compaction_time_window, memtable_builder),
-        );
+        let new_mutable = version
+            .memtables
+            .mutable
+            .new_with_part_duration(version.compaction_time_window, memtable_builder);
         // Here it assumes the leader has backfilled the partition_expr of the metadata.
         let metadata = manifest.metadata.clone();
 
diff --git a/src/mito2/src/worker/handle_write.rs b/src/mito2/src/worker/handle_write.rs
index 323d73c60ec..1383a3e9a5d 100644
--- a/src/mito2/src/worker/handle_write.rs
+++ b/src/mito2/src/worker/handle_write.rs
@@ -26,14 +26,14 @@ use store_api::storage::RegionId;
 
 use crate::error::{
     InvalidRequestSnafu, PartitionExprVersionMismatchSnafu, RegionNotFoundSnafu, RegionStateSnafu,
-    RejectWriteSnafu, Result,
+    RejectWriteInStagingSnafu, RejectWriteSnafu, Result,
 };
 use crate::metrics;
 use crate::metrics::{
     WRITE_REJECT_TOTAL, WRITE_ROWS_TOTAL, WRITE_STAGE_ELAPSED, WRITE_STALL_TOTAL,
 };
 use crate::region::{RegionLeaderState, RegionRoleState};
-use crate::region_write_ctx::RegionWriteCtx;
+use crate::region_write_ctx::{RegionWriteCtx, WriteSource};
 use crate::request::{SenderBulkRequest, SenderWriteRequest, WriteRequest};
 use crate::wal::Wal;
 use crate::worker::RegionWorkerLoop;
@@ -126,9 +126,7 @@ impl<S: LogStore> RegionWorkerLoop<S> {
             if region_ctxs.len() == 1 {
                 // fast path for single region.
                 let mut region_ctx = region_ctxs.into_values().next().unwrap();
-                region_ctx.write_memtable().await;
-                region_ctx.write_bulk().await;
-                region_ctx.publish_sequence_and_entry_id();
+                region_ctx.write_memtables().await;
                 put_rows += region_ctx.put_num;
                 delete_rows += region_ctx.delete_num;
             } else {
@@ -137,9 +135,7 @@ impl<S: LogStore> RegionWorkerLoop<S> {
                     .map(|mut region_ctx| {
                         // use tokio runtime to schedule tasks.
                         common_runtime::spawn_global(async move {
-                            region_ctx.write_memtable().await;
-                            region_ctx.write_bulk().await;
-                            region_ctx.publish_sequence_and_entry_id();
+                            region_ctx.write_memtables().await;
                             (region_ctx.put_num, region_ctx.delete_num)
                         })
                     })
@@ -339,7 +335,7 @@ impl<S> RegionWorkerLoop<S> {
                         if region.reject_all_writes_in_staging() {
                             sender_req
                                 .sender
-                                .send(RejectWriteSnafu { region_id }.fail());
+                                .send(RejectWriteInStagingSnafu { region_id }.fail());
                             continue;
                         }
 
@@ -348,6 +344,7 @@ impl<S> RegionWorkerLoop<S> {
                             &region.version_control,
                             region.provider.clone(),
                             Some(region.region_stats.written_bytes.clone()),
+                            WriteSource::Request,
                         );
 
                         e.insert(region_ctx);
@@ -402,7 +399,7 @@ impl<S> RegionWorkerLoop<S> {
             if region.reject_all_writes_in_staging() {
                 sender_req
                     .sender
-                    .send(RejectWriteSnafu { region_id }.fail());
+                    .send(RejectWriteInStagingSnafu { region_id }.fail());
                 continue;
             }
             let expected_version = region.expected_partition_expr_version();
@@ -484,7 +481,9 @@ impl<S> RegionWorkerLoop<S> {
                     RegionRoleState::Leader(RegionLeaderState::Writable)
                     | RegionRoleState::Leader(RegionLeaderState::Staging) => {
                         if region.reject_all_writes_in_staging() {
-                            bulk_req.sender.send(RejectWriteSnafu { region_id }.fail());
+                            bulk_req
+                                .sender
+                                .send(RejectWriteInStagingSnafu { region_id }.fail());
                             continue;
                         }
                         let region_ctx = RegionWriteCtx::new(
@@ -492,6 +491,7 @@ impl<S> RegionWorkerLoop<S> {
                             &region.version_control,
                             region.provider.clone(),
                             Some(region.region_stats.written_bytes.clone()),
+                            WriteSource::Request,
                         );
 
                         e.insert(region_ctx);
@@ -531,7 +531,9 @@ impl<S> RegionWorkerLoop<S> {
                 continue;
             };
             if region.reject_all_writes_in_staging() {
-                bulk_req.sender.send(RejectWriteSnafu { region_id }.fail());
+                bulk_req
+                    .sender
+                    .send(RejectWriteInStagingSnafu { region_id }.fail());
                 continue;
             }
             let expected_version = region.expected_partition_expr_version();
@@ -897,6 +899,7 @@ mod tests {
             &version_control,
             Provider::raft_engine_provider(region_id.as_u64()),
             None,
+            WriteSource::Request,
         );
         let (tx, rx) = oneshot::channel();
         ctx.push_mutation(
@@ -946,6 +949,7 @@ mod tests {
                 &version_control,
                 Provider::raft_engine_provider(region_id.as_u64()),
                 None,
+                WriteSource::Request,
             );
             let (tx, rx) = oneshot::channel();
             assert!(ctx.push_bulk(OptionOutputTx::from(tx), new_bulk_part(1), None, skip_wal));
@@ -959,9 +963,7 @@ mod tests {
         if skip_wal {
             let ctx = contexts.get_mut(&region_id).unwrap();
             assert_eq!(ctx.next_entry_id(), 1);
-            ctx.write_memtable().await;
-            ctx.write_bulk().await;
-            ctx.publish_sequence_and_entry_id();
+            ctx.write_memtables().await;
             assert_eq!(version_control.committed_sequence(), 1);
             assert_eq!(version_control.current().last_entry_id, 0);
         }
@@ -995,9 +997,7 @@ mod tests {
         assert_eq!(entry_id + 1, region_ctxs[&ok_region].next_entry_id());
 
         for region_ctx in region_ctxs.values_mut() {
-            region_ctx.write_memtable().await;
-            region_ctx.write_bulk().await;
-            region_ctx.publish_sequence_and_entry_id();
+            region_ctx.write_memtables().await;
         }
 
         assert_eq!(
@@ -1034,6 +1034,7 @@ mod tests {
             &version_control,
             Provider::raft_engine_provider(region_id.as_u64()),
             None,
+            WriteSource::Request,
         );
         let (tx, rx) = oneshot::channel();
         assert!(ctx.push_bulk(OptionOutputTx::from(tx), new_bulk_part(3), None, skip_wal));
@@ -1050,9 +1051,7 @@ mod tests {
 
         let write_handle = tokio::spawn(async move {
             let mut region_ctx = region_ctxs.remove(&region_id).unwrap();
-            region_ctx.write_memtable().await;
-            region_ctx.write_bulk().await;
-            region_ctx.publish_sequence_and_entry_id();
+            region_ctx.write_memtables().await;
         });
 
         tokio::time::timeout(
diff --git a/src/object-store/Cargo.toml b/src/object-store/Cargo.toml
index 15e2069e3bd..96785fbf243 100644
--- a/src/object-store/Cargo.toml
+++ b/src/object-store/Cargo.toml
@@ -24,7 +24,7 @@ common-telemetry.workspace = true
 derive_builder = { workspace = true, optional = true }
 hdfs-native = { workspace = true, optional = true }
 humantime-serde.workspace = true
-opendal = { version = "0.59.2", features = [
+opendal = { version = "0.59.4", features = [
     "layers-tracing",
     "layers-prometheus",
     "services-azblob",
@@ -34,7 +34,7 @@ opendal = { version = "0.59.2", features = [
     "services-oss",
     "services-s3",
 ] }
-opendal-http-transport-reqwest = "0.59.2"
+opendal-http-transport-reqwest = "0.59.4"
 prometheus.workspace = true
 reqwest.workspace = true
 serde.workspace = true
diff --git a/src/operator/AGENTS.md b/src/operator/AGENTS.md
index 62853a18f61..3a368c23068 100644
--- a/src/operator/AGENTS.md
+++ b/src/operator/AGENTS.md
@@ -14,6 +14,7 @@ insert/delete routing.
 | Statements | `src/operator/src/statement.rs`, `src/operator/src/statement/` | `StatementExecutor` and per-statement handlers |
 | Inserts | `src/operator/src/insert.rs`, `src/operator/src/bulk_insert.rs` | Insert, auto-create/alter, routing, dispatch |
 | Deletes | `src/operator/src/delete.rs` | Delete conversion and dispatch |
+| Write dispatch | `src/operator/src/write_dispatcher.rs` | Shared insert/delete/bulk dispatch, bounded retries, route refresh and write request rebuilding |
 | Request conversion | `src/operator/src/req_convert.rs`, `src/operator/src/req_convert/` | Table/row/column requests to region requests |
 | Region requests | `src/operator/src/region_req_factory.rs` | Region-level DDL/DML request construction |
 | Procedures | `src/operator/src/procedure.rs` | Metasrv procedure administration |
@@ -38,6 +39,8 @@ cargo sqlness bare -t <case>
 ```
 
 Check standalone and distributed routing when changing region dispatch.
+Write retries operate on prepared region requests in `write_dispatcher`; keep
+admission and Flow side effects outside retries, and preserve successful regions.
 
 Write admission uses fallible `write_meter!` calls in `Inserter::do_request`
 and `handle_bulk_insert`, before flow side effects and datanode dispatch. Bulk
diff --git a/src/operator/Cargo.toml b/src/operator/Cargo.toml
index 72f953e0f89..b89bf4b13d3 100644
--- a/src/operator/Cargo.toml
+++ b/src/operator/Cargo.toml
@@ -24,6 +24,7 @@ api.workspace = true
 arrow.workspace = true
 async-stream.workspace = true
 async-trait.workspace = true
+backon.workspace = true
 bytes.workspace = true
 catalog.workspace = true
 chrono.workspace = true
@@ -54,12 +55,14 @@ file-engine.workspace = true
 futures.workspace = true
 futures-util.workspace = true
 humantime.workspace = true
+humantime-serde.workspace = true
 itertools.workspace = true
 jsonb.workspace = true
 lazy_static.workspace = true
 meta-client.workspace = true
 meter-core.workspace = true
 meter-macros.workspace = true
+mito-codec.workspace = true
 moka = { workspace = true, features = ["future"] }
 object-store.workspace = true
 partition.workspace = true
@@ -86,8 +89,10 @@ url.workspace = true
 
 [dev-dependencies]
 axum.workspace = true
+cache.workspace = true
 catalog = { workspace = true, features = ["testing"] }
 common-meta = { workspace = true, features = ["testing"] }
 common-test-util.workspace = true
 object-store = { workspace = true, features = ["testing"] }
 path-slash = "0.2"
+tokio-stream = { workspace = true, features = ["net"] }
diff --git a/src/operator/src/bulk_insert.rs b/src/operator/src/bulk_insert.rs
index f8d58f5d173..d4a1ed0497c 100644
--- a/src/operator/src/bulk_insert.rs
+++ b/src/operator/src/bulk_insert.rs
@@ -14,33 +14,34 @@
 
 use std::collections::HashSet;
 
-use ahash::{HashMap, HashMapExt};
 use api::v1::flow::{DirtyWindowRequest, DirtyWindowRequests};
 use api::v1::region::{
     BulkInsertRequest, RegionRequest, RegionRequestHeader, bulk_insert_request, region_request,
 };
 use api::v1::{ArrowIpc, PartitionExprVersion};
-use arrow::compute::filter_record_batch;
+use arrow::compute;
 use arrow::record_batch::RecordBatch;
 use bytes::Bytes;
 use common_base::AffectedRows;
-use common_error::ext::BoxedError;
 use common_grpc::FlightData;
-use common_grpc::flight::{FlightEncoder, FlightMessage, record_batch_to_ipc};
+use common_grpc::flight::{FlightEncoder, FlightMessage};
 use common_telemetry::error;
 use common_telemetry::tracing_context::TracingContext;
-use futures::future::{join_all, try_join_all};
+use futures::future;
 use meter_core::data::MeterRecord;
 use meter_macros::write_meter;
 use session::context::{Channel, QueryContextRef};
-use snafu::{ResultExt, ensure};
+use snafu::{OptionExt, ResultExt, ensure};
 use store_api::storage::RegionId;
 use table::TableRef;
 use table::metadata::TableInfoRef;
+use tokio_util::sync::CancellationToken;
 
 use crate::error::Result;
 use crate::insert::Inserter;
-use crate::req_convert::insert::extract_timestamps;
+use crate::req_convert::TablePartitioner;
+use crate::req_convert::insert;
+use crate::write_dispatcher::WriteAttempt;
 use crate::{error, metrics};
 
 impl Inserter {
@@ -54,72 +55,28 @@ impl Inserter {
         batch: RecordBatch,
         ctx: QueryContextRef,
     ) -> Result<AffectedRows> {
-        let (rule, versions) = self
-            .partition_manager
-            .find_table_partition_rule(&table_info)
+        let requests = TablePartitioner::try_new(&self.partition_manager, &table_info)
             .await
-            .context(error::InvalidPartitionSnafu)?;
-        let masks = rule
-            .split_record_batch(&batch)
-            .context(error::SplitInsertSnafu)?;
-        let mut writes = Vec::with_capacity(masks.len());
-        for (region_number, mask) in masks {
-            if mask.select_none() {
-                continue;
-            }
-            let region_id = RegionId::new(table_info.table_id(), region_number);
-            let selected = if mask.select_all() {
-                batch.clone()
-            } else {
-                filter_record_batch(&batch, mask.array()).context(error::ComputeArrowSnafu)?
-            };
-            let (schema, data_header, payload) = record_batch_to_ipc(selected)
-                .map_err(BoxedError::new)
-                .context(error::ExternalSnafu)?;
-            let peer = self
-                .partition_manager
-                .find_region_leader(region_id)
-                .await
-                .context(error::FindRegionLeaderSnafu)?;
-            let request = RegionRequest {
+            .context(error::InvalidPartitionSnafu)?
+            .partition_bulk_insert_requests(batch, None, ctx.skip_wal())?;
+        let writes = requests
+            .into_iter()
+            .map(|request| RegionRequest {
                 header: Some(RegionRequestHeader {
                     dbname: ctx.get_db_string(),
                     tracing_context: TracingContext::from_current_span().to_w3c(),
                     ..Default::default()
                 }),
-                body: Some(region_request::Body::BulkInsert(BulkInsertRequest {
-                    skip_wal: ctx.skip_wal(),
-                    region_id: region_id.as_u64(),
-                    partition_expr_version: versions
-                        .get(&region_number)
-                        .copied()
-                        .flatten()
-                        .map(|value| PartitionExprVersion { value }),
-                    // Let the datanode revalidate against its current schema.
-                    aligned_schema_version: None,
-                    body: Some(bulk_insert_request::Body::ArrowIpc(ArrowIpc {
-                        schema,
-                        data_header,
-                        payload,
-                    })),
-                })),
-            };
-            writes.push((peer, request));
-        }
-        let results = join_all(writes.into_iter().map(|(peer, request)| async move {
-            self.node_manager
-                .datanode(&peer)
-                .await
-                .handle(request)
-                .await
-                .context(error::RequestInsertsSnafu)
-        }))
-        .await;
-        let affected_rows = results
-            .into_iter()
-            .map(|result| result.map(|response| response.affected_rows))
-            .sum::<Result<usize>>()?;
-        Ok(affected_rows)
+                body: Some(region_request::Body::BulkInsert(request)),
+            })
+            .collect();
+        let writes = self.write_dispatcher.prepare(writes).await?;
+        Ok(self
+            .write_dispatcher
+            .execute(writes, None, None)
+            .await
+            .context(error::RequestInsertsSnafu)?
+            .affected_rows)
     }
 
     /// Handle bulk insert request.
@@ -208,12 +165,6 @@ impl Inserter {
                 .get(&region_number)
                 .copied()
                 .unwrap_or_default();
-            let datanode = self
-                .partition_manager
-                .find_region_leader(region_id)
-                .await
-                .context(error::FindRegionLeaderSnafu)?;
-
             let request = RegionRequest {
                 header: Some(RegionRequestHeader {
                     tracing_context: TracingContext::from_current_span().to_w3c(),
@@ -233,12 +184,16 @@ impl Inserter {
                 })),
             };
 
-            let _datanode_handle_timer = metrics::HANDLE_BULK_INSERT_ELAPSED
-                .with_label_values(&["datanode_handle"])
-                .start_timer();
-            let datanode = self.node_manager.datanode(&datanode).await;
-            let result = datanode
-                .handle(request)
+            let writes = self.write_dispatcher.prepare(vec![request]).await?;
+            let result = self
+                .write_dispatcher
+                .execute(
+                    writes,
+                    Some(
+                        metrics::HANDLE_BULK_INSERT_ELAPSED.with_label_values(&["datanode_handle"]),
+                    ),
+                    None,
+                )
                 .await
                 .context(error::RequestRegionSnafu)
                 .map(|r| r.affected_rows);
@@ -250,121 +205,143 @@ impl Inserter {
             return result;
         }
 
-        let mut mask_per_datanode = HashMap::with_capacity(region_masks.len());
-        for (region_number, mask) in region_masks {
-            let region_id = RegionId::new(table_id, region_number);
-            let datanode = self
-                .partition_manager
-                .find_region_leader(region_id)
-                .await
-                .context(error::FindRegionLeaderSnafu)?;
-            mask_per_datanode
-                .entry(datanode)
-                .or_insert_with(Vec::new)
-                .push((region_id, mask));
-        }
+        let regions = region_masks
+            .keys()
+            .map(|region| RegionId::new(table_id, *region))
+            .collect::<Vec<_>>();
+        let mut peers = self
+            .write_dispatcher
+            .resolve_peers(&regions)
+            .await
+            .context(error::FindRegionLeaderSnafu)?;
 
         let wait_all_datanode_timer = metrics::HANDLE_BULK_INSERT_ELAPSED
             .with_label_values(&["wait_all_datanode"])
             .start_timer();
 
-        let mut handles = Vec::with_capacity(mask_per_datanode.len());
+        // Dropping the caller stops retries without abandoning in-flight writes.
+        let cancellation = CancellationToken::new();
+        let _guard = cancellation.clone().drop_guard();
+        let mut handles = Vec::with_capacity(region_masks.len());
 
-        for (peer, masks) in mask_per_datanode {
-            for (region_id, mask) in masks {
-                if mask.select_none() {
-                    continue;
-                }
-                let partition_expr_version = partition_versions
-                    .get(&region_id.region_number())
-                    .copied()
-                    .unwrap_or_default();
-                let rb = record_batch.clone();
-                let schema_bytes = schema_bytes.clone();
-                let node_manager = self.node_manager.clone();
-                let peer = peer.clone();
-                let raw_header_and_data = if mask.select_all() {
-                    Some((
-                        raw_flight_data.data_header.clone(),
-                        raw_flight_data.data_body.clone(),
-                    ))
-                } else {
-                    None
-                };
-                let handle: common_runtime::JoinHandle<Result<api::region::RegionResponse>> =
-                    common_runtime::spawn_global(async move {
-                        let (header, payload) = if mask.select_all() {
-                            // SAFETY: raw data must be present, we can avoid re-encoding.
-                            raw_header_and_data.unwrap()
-                        } else {
-                            let filter_timer = metrics::HANDLE_BULK_INSERT_ELAPSED
-                                .with_label_values(&["filter"])
-                                .start_timer();
-                            let batch = filter_record_batch(&rb, mask.array())
-                                .context(error::ComputeArrowSnafu)?;
-                            filter_timer.observe_duration();
-                            metrics::BULK_REQUEST_ROWS
-                                .with_label_values(&["rows_per_region"])
-                                .observe(batch.num_rows() as f64);
-
-                            let encode_timer = metrics::HANDLE_BULK_INSERT_ELAPSED
-                                .with_label_values(&["encode"])
-                                .start_timer();
-                            let mut iter = FlightEncoder::default()
-                                .encode(FlightMessage::RecordBatch(batch))
-                                .into_iter();
-                            let Some(flight_data) = iter.next() else {
-                                // Safety: `iter` on a type of `Vec1`, which is guaranteed to have
-                                // at least one element.
-                                unreachable!()
-                            };
-                            ensure!(
-                                iter.next().is_none(),
-                                error::NotSupportedSnafu {
-                                    feat: "bulk insert RecordBatch with dictionary arrays",
-                                }
-                            );
-                            encode_timer.observe_duration();
-                            (flight_data.data_header, flight_data.data_body)
-                        };
-                        let _datanode_handle_timer = metrics::HANDLE_BULK_INSERT_ELAPSED
-                            .with_label_values(&["datanode_handle"])
-                            .start_timer();
-                        let request = RegionRequest {
-                            header: Some(RegionRequestHeader {
-                                tracing_context: TracingContext::from_current_span().to_w3c(),
-                                ..Default::default()
-                            }),
-                            body: Some(region_request::Body::BulkInsert(BulkInsertRequest {
-                                skip_wal,
-                                region_id: region_id.as_u64(),
-                                partition_expr_version: partition_expr_version
-                                    .map(|value| PartitionExprVersion { value }),
-                                aligned_schema_version: None,
-                                body: Some(bulk_insert_request::Body::ArrowIpc(ArrowIpc {
-                                    schema: schema_bytes,
-                                    data_header: header,
-                                    payload,
-                                })),
-                            })),
-                        };
-
-                        let datanode = node_manager.datanode(&peer).await;
-                        datanode
-                            .handle(request)
-                            .await
-                            .context(error::RequestRegionSnafu)
-                    });
-                handles.push(handle);
+        for (region_number, mask) in region_masks {
+            let region_id = RegionId::new(table_id, region_number);
+            if mask.select_none() {
+                continue;
             }
+            let partition_expr_version = partition_versions
+                .get(&region_id.region_number())
+                .copied()
+                .unwrap_or_default();
+            let peer = peers
+                .remove(&region_id)
+                .context(partition::error::FindLeaderSnafu {
+                    region_id,
+                    table_id,
+                })
+                .context(error::FindRegionLeaderSnafu)?;
+            let dispatcher = self.write_dispatcher.clone();
+            let rb = record_batch.clone();
+            let schema_bytes = schema_bytes.clone();
+            let raw_header_and_data = if mask.select_all() {
+                Some((
+                    raw_flight_data.data_header.clone(),
+                    raw_flight_data.data_body.clone(),
+                ))
+            } else {
+                None
+            };
+            let handle: common_runtime::JoinHandle<Result<WriteAttempt>> =
+                common_runtime::spawn_global(async move {
+                    let (header, payload) = if mask.select_all() {
+                        // SAFETY: raw data must be present, we can avoid re-encoding.
+                        raw_header_and_data.unwrap()
+                    } else {
+                        let filter_timer = metrics::HANDLE_BULK_INSERT_ELAPSED
+                            .with_label_values(&["filter"])
+                            .start_timer();
+                        let batch = compute::filter_record_batch(&rb, mask.array())
+                            .context(error::ComputeArrowSnafu)?;
+                        filter_timer.observe_duration();
+                        metrics::BULK_REQUEST_ROWS
+                            .with_label_values(&["rows_per_region"])
+                            .observe(batch.num_rows() as f64);
+
+                        let encode_timer = metrics::HANDLE_BULK_INSERT_ELAPSED
+                            .with_label_values(&["encode"])
+                            .start_timer();
+                        let mut iter = FlightEncoder::default()
+                            .encode(FlightMessage::RecordBatch(batch))
+                            .into_iter();
+                        let Some(flight_data) = iter.next() else {
+                            // Safety: `iter` on a type of `Vec1`, which is guaranteed to have
+                            // at least one element.
+                            unreachable!()
+                        };
+                        ensure!(
+                            iter.next().is_none(),
+                            error::NotSupportedSnafu {
+                                feat: "bulk insert RecordBatch with dictionary arrays",
+                            }
+                        );
+                        encode_timer.observe_duration();
+                        (flight_data.data_header, flight_data.data_body)
+                    };
+                    let request = RegionRequest {
+                        header: Some(RegionRequestHeader {
+                            tracing_context: TracingContext::from_current_span().to_w3c(),
+                            ..Default::default()
+                        }),
+                        body: Some(region_request::Body::BulkInsert(BulkInsertRequest {
+                            skip_wal,
+                            region_id: region_id.as_u64(),
+                            partition_expr_version: partition_expr_version
+                                .map(|value| PartitionExprVersion { value }),
+                            aligned_schema_version: None,
+                            body: Some(bulk_insert_request::Body::ArrowIpc(ArrowIpc {
+                                schema: schema_bytes,
+                                data_header: header,
+                                payload,
+                            })),
+                        })),
+                    };
+
+                    Ok(dispatcher
+                        .send(
+                            peer,
+                            request,
+                            Some(
+                                &metrics::HANDLE_BULK_INSERT_ELAPSED
+                                    .with_label_values(&["datanode_handle"]),
+                            ),
+                        )
+                        .await)
+                });
+            handles.push(handle);
         }
 
-        let region_responses = try_join_all(handles).await.context(error::JoinTaskSnafu)?;
+        let dispatcher = self.write_dispatcher.clone();
+        let rows_inserted = common_runtime::spawn_global(async move {
+            let results = future::try_join_all(handles)
+                .await
+                .context(error::JoinTaskSnafu)?;
+            let attempts = results.into_iter().collect::<Result<Vec<_>>>()?;
+            dispatcher
+                .finish(
+                    attempts,
+                    Some(
+                        &metrics::HANDLE_BULK_INSERT_ELAPSED
+                            .with_label_values(&["datanode_handle"]),
+                    ),
+                    Some(&cancellation),
+                )
+                .await
+                .context(error::RequestRegionSnafu)
+                .map(|response| response.affected_rows)
+        })
+        .await
+        .context(error::JoinTaskSnafu)??;
         wait_all_datanode_timer.observe_duration();
-        let mut rows_inserted: usize = 0;
-        for res in region_responses {
-            rows_inserted += res?.affected_rows;
-        }
         crate::metrics::DIST_INGEST_ROW_COUNT
             .with_label_values(&[db_name.as_str()])
             .inc_by(rows_inserted as u64);
@@ -393,7 +370,7 @@ impl Inserter {
                 return;
             }
 
-            let Ok(timestamps) = extract_timestamps(
+            let Ok(timestamps) = insert::extract_timestamps(
                 &record_batch,
                 &table_info
                     .meta
diff --git a/src/operator/src/delete.rs b/src/operator/src/delete.rs
index 9641e0e27d4..9bf14471696 100644
--- a/src/operator/src/delete.rs
+++ b/src/operator/src/delete.rs
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;
 use std::sync::Arc;
 use std::{iter, mem};
 
@@ -20,45 +20,55 @@ use api::v1::region::{DeleteRequests as RegionDeleteRequests, RegionRequestHeade
 use api::v1::{DeleteRequests, RowDeleteRequests};
 use catalog::CatalogManagerRef;
 use common_meta::node_manager::{AffectedRows, NodeManagerRef};
-use common_meta::peer::Peer;
 use common_query::Output;
 use common_telemetry::tracing_context::TracingContext;
-use futures_util::future;
 use partition::manager::PartitionRuleManagerRef;
 use session::context::QueryContextRef;
 use snafu::{OptionExt, ResultExt, ensure};
 use table::TableRef;
 use table::requests::DeleteRequest as TableDeleteRequest;
+use tokio_util::sync::CancellationToken;
 
 use crate::error::{
-    CatalogSnafu, FindRegionLeaderSnafu, InvalidDeleteRequestSnafu, JoinTaskSnafu,
-    MissingTimeIndexColumnSnafu, RequestDeletesSnafu, Result, TableNotFoundSnafu,
+    CatalogSnafu, InvalidDeleteRequestSnafu, JoinTaskSnafu, MissingTimeIndexColumnSnafu,
+    RequestDeletesSnafu, Result, TableNotFoundSnafu,
 };
 use crate::region_req_factory::RegionRequestFactory;
 use crate::req_convert::common::preprocess_row_delete_requests;
 use crate::req_convert::delete::{ColumnToRow, RowToRegion, TableToRegion};
+use crate::write_dispatcher::{WriteDispatcher, WriteDispatcherRef};
 
 pub struct Deleter {
     catalog_manager: CatalogManagerRef,
     partition_manager: PartitionRuleManagerRef,
-    node_manager: NodeManagerRef,
+    write_dispatcher: WriteDispatcherRef,
 }
 
 pub type DeleterRef = Arc<Deleter>;
 
 impl Deleter {
+    /// Creates a row deleter with the default write dispatcher.
     pub fn new(
         catalog_manager: CatalogManagerRef,
         partition_manager: PartitionRuleManagerRef,
         node_manager: NodeManagerRef,
     ) -> Self {
         Self {
+            write_dispatcher: Arc::new(WriteDispatcher::new(
+                node_manager,
+                partition_manager.clone(),
+            )),
             catalog_manager,
             partition_manager,
-            node_manager,
         }
     }
 
+    /// Installs the dispatcher shared with the other write paths.
+    pub fn with_write_dispatcher(mut self, dispatcher: WriteDispatcherRef) -> Self {
+        self.write_dispatcher = dispatcher;
+        self
+    }
+
     pub async fn handle_column_deletes(
         &self,
         requests: DeleteRequests,
@@ -129,52 +139,25 @@ impl Deleter {
             ..Default::default()
         });
 
-        let tasks = self
-            .group_requests_by_peer(requests)
-            .await?
-            .into_iter()
-            .map(|(peer, deletes)| {
-                let request = request_factory.build_delete(deletes);
-                let node_manager = self.node_manager.clone();
-                common_runtime::spawn_global(async move {
-                    node_manager
-                        .datanode(&peer)
-                        .await
-                        .handle(request)
-                        .await
-                        .context(RequestDeletesSnafu)
-                })
-            });
-        let results = future::try_join_all(tasks).await.context(JoinTaskSnafu)?;
-
-        let affected_rows = results
-            .into_iter()
-            .map(|resp| resp.map(|r| r.affected_rows))
-            .sum::<Result<AffectedRows>>()?;
+        let dispatcher = self.write_dispatcher.clone();
+        let request = request_factory.build_delete(requests);
+        let writes = dispatcher.prepare(vec![request]).await?;
+        // Dropping the caller stops retries without abandoning in-flight writes.
+        let cancellation = CancellationToken::new();
+        let _guard = cancellation.clone().drop_guard();
+        let affected_rows = common_runtime::spawn_global(async move {
+            dispatcher.execute(writes, None, Some(&cancellation)).await
+        })
+        .await
+        .context(JoinTaskSnafu)?
+        .context(RequestDeletesSnafu)?
+        .affected_rows;
         crate::metrics::DIST_DELETE_ROW_COUNT
             .with_label_values(&[ctx.get_db_string().as_str()])
             .inc_by(affected_rows as u64);
         Ok(affected_rows)
     }
 
-    async fn group_requests_by_peer(
-        &self,
-        requests: RegionDeleteRequests,
-    ) -> Result<HashMap<Peer, RegionDeleteRequests>> {
-        let mut deletes: HashMap<Peer, RegionDeleteRequests> = HashMap::new();
-
-        for req in requests.requests {
-            let peer = self
-                .partition_manager
-                .find_region_leader(req.region_id.into())
-                .await
-                .context(FindRegionLeaderSnafu)?;
-            deletes.entry(peer).or_default().requests.push(req);
-        }
-
-        Ok(deletes)
-    }
-
     async fn trim_columns(
         &self,
         mut requests: RowDeleteRequests,
diff --git a/src/operator/src/insert.rs b/src/operator/src/insert.rs
index e1fbe39a9f4..f727fee0cc2 100644
--- a/src/operator/src/insert.rs
+++ b/src/operator/src/insert.rs
@@ -13,7 +13,9 @@
 // limitations under the License.
 
 use std::collections::BTreeMap;
-use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, LazyLock};
+use std::time::{Duration, Instant};
 
 use ahash::{HashMap, HashMapExt, HashSet, HashSetExt};
 use api::v1::alter_table_expr::Kind;
@@ -40,7 +42,7 @@ use common_frontend::slow_query_event::SLOW_QUERY_TABLE_NAME;
 use common_grpc_expr::util::ColumnExpr;
 use common_meta::cache::TableFlownodeSetCacheRef;
 use common_meta::datanode::REGION_STATS_HISTORY_TABLE_NAME;
-use common_meta::node_manager::{AffectedRows, NodeManagerRef};
+use common_meta::node_manager::NodeManagerRef;
 use common_meta::peer::Peer;
 use common_meta::rpc::ddl::TriggerReason;
 use common_query::Output;
@@ -78,12 +80,12 @@ use table::requests::{
     validate_semantic_option,
 };
 use table::table_reference::TableReference;
+use tokio_util::sync::CancellationToken;
 
 use crate::batcher::PendingRowsBatcher;
 use crate::error::{
-    CatalogSnafu, ColumnOptionsSnafu, CreatePartitionRulesSnafu, FindRegionLeaderSnafu,
-    InvalidInsertRequestSnafu, JoinTaskSnafu, RequestInsertsSnafu, Result, TableNotFoundSnafu,
-    WriteRejectedSnafu,
+    CatalogSnafu, ColumnOptionsSnafu, CreatePartitionRulesSnafu, InvalidInsertRequestSnafu,
+    JoinTaskSnafu, RequestInsertsSnafu, Result, TableNotFoundSnafu, WriteRejectedSnafu,
 };
 use crate::expr_helper;
 use crate::region_req_factory::RegionRequestFactory;
@@ -93,17 +95,23 @@ use crate::req_convert::insert::{
     fill_reqs_with_impure_default, rows_to_record_batch,
 };
 use crate::statement::StatementExecutor;
+use crate::write_dispatcher::{WriteDispatcher, WriteDispatcherRef};
 
 pub struct Inserter {
     catalog_manager: CatalogManagerRef,
     pub(crate) partition_manager: PartitionRuleManagerRef,
     pub(crate) node_manager: NodeManagerRef,
+    pub(crate) write_dispatcher: WriteDispatcherRef,
     pub(crate) table_flownode_set_cache: TableFlownodeSetCacheRef,
     /// Server-side upper bound for auto table creation on write.
     /// When `false`, missing tables are never auto-created regardless of the
     /// per-request `auto_create_table` hint. When `true`, the hint still applies.
     auto_create_table: bool,
     pending_rows_batcher: Option<Arc<dyn PendingRowsBatcher>>,
+    /// Rows handed to detached flow mirror tasks that have not finished yet.
+    /// Bounds how much row data in-flight mirror writes may keep alive, see
+    /// [`MAX_MIRROR_PENDING_ROWS`].
+    mirror_pending_rows: Arc<AtomicU64>,
 }
 
 pub type InserterRef = Arc<Inserter>;
@@ -286,6 +294,7 @@ impl Inserter {
         cost
     }
 
+    /// Creates a row inserter with the default write dispatcher.
     pub fn new(
         catalog_manager: CatalogManagerRef,
         partition_manager: PartitionRuleManagerRef,
@@ -294,15 +303,26 @@ impl Inserter {
         auto_create_table: bool,
     ) -> Self {
         Self {
+            write_dispatcher: Arc::new(WriteDispatcher::new(
+                node_manager.clone(),
+                partition_manager.clone(),
+            )),
             catalog_manager,
             partition_manager,
             node_manager,
             table_flownode_set_cache,
             auto_create_table,
             pending_rows_batcher: None,
+            mirror_pending_rows: Arc::new(AtomicU64::new(0)),
         }
     }
 
+    /// Installs the shared dispatcher used by direct writes and batch flushes.
+    pub fn with_write_dispatcher(mut self, dispatcher: WriteDispatcherRef) -> Self {
+        self.write_dispatcher = dispatcher;
+        self
+    }
+
     /// Installs the shared batcher; callers explicitly select its ingestion entry point.
     pub fn with_pending_rows_batcher(
         mut self,
@@ -804,32 +824,31 @@ impl Inserter {
                 .chain(instant_requests.requests.iter()),
         )
         .await?;
-        flow_mirror_task.detach(self.node_manager.clone())?;
+        let has_instant_rows = instant_requests.requests.iter().any(|request| {
+            request
+                .rows
+                .as_ref()
+                .is_some_and(|rows| !rows.rows.is_empty())
+        });
+        flow_mirror_task.detach(
+            self.node_manager.clone(),
+            self.mirror_pending_rows.clone(),
+            has_instant_rows,
+        )?;
 
-        // Write requests to datanode and wait for response
-        let write_tasks = self
-            .group_requests_by_peer(normal_requests)
-            .await?
-            .into_iter()
-            .map(|(peer, inserts)| {
-                let node_manager = self.node_manager.clone();
-                let request = request_factory.build_insert(inserts);
-                common_runtime::spawn_global(async move {
-                    node_manager
-                        .datanode(&peer)
-                        .await
-                        .handle(request)
-                        .await
-                        .context(RequestInsertsSnafu)
-                })
-            });
-        let results = future::try_join_all(write_tasks)
-            .await
-            .context(JoinTaskSnafu)?;
-        let affected_rows = results
-            .into_iter()
-            .map(|resp| resp.map(|r| r.affected_rows))
-            .sum::<Result<AffectedRows>>()?;
+        let dispatcher = self.write_dispatcher.clone();
+        let request = request_factory.build_insert(normal_requests);
+        let writes = dispatcher.prepare(vec![request]).await?;
+        // Dropping the caller stops retries without abandoning in-flight writes.
+        let cancellation = CancellationToken::new();
+        let _guard = cancellation.clone().drop_guard();
+        let affected_rows = common_runtime::spawn_global(async move {
+            dispatcher.execute(writes, None, Some(&cancellation)).await
+        })
+        .await
+        .context(JoinTaskSnafu)?
+        .context(RequestInsertsSnafu)?
+        .affected_rows;
         crate::metrics::DIST_INGEST_ROW_COUNT
             .with_label_values(&[ctx.get_db_string().as_str()])
             .inc_by(affected_rows as u64);
@@ -839,40 +858,6 @@ impl Inserter {
         ))
     }
 
-    async fn group_requests_by_peer(
-        &self,
-        requests: RegionInsertRequests,
-    ) -> Result<HashMap<Peer, RegionInsertRequests>> {
-        // group by region ids first to reduce repeatedly call `find_region_leader`
-        // TODO(discord9): determine if a addition clone is worth it
-        let mut requests_per_region: HashMap<RegionId, RegionInsertRequests> = HashMap::new();
-        for req in requests.requests {
-            let region_id = RegionId::from_u64(req.region_id);
-            requests_per_region
-                .entry(region_id)
-                .or_default()
-                .requests
-                .push(req);
-        }
-
-        let mut inserts: HashMap<Peer, RegionInsertRequests> = HashMap::new();
-
-        for (region_id, reqs) in requests_per_region {
-            let peer = self
-                .partition_manager
-                .find_region_leader(region_id)
-                .await
-                .context(FindRegionLeaderSnafu)?;
-            inserts
-                .entry(peer)
-                .or_default()
-                .requests
-                .extend(reqs.requests);
-        }
-
-        Ok(inserts)
-    }
-
     /// Returns `Some(reason)` if the config or request hint disables automatic
     /// table creation. Exempt private system tables are handled by
     /// [`Self::is_auto_create_exempt_private_table`].
@@ -1697,6 +1682,11 @@ impl Inserter {
         }
     }
 
+    /// Returns the dispatcher shared with batching execution paths.
+    pub fn write_dispatcher(&self) -> &WriteDispatcherRef {
+        &self.write_dispatcher
+    }
+
     pub fn node_manager(&self) -> &NodeManagerRef {
         &self.node_manager
     }
@@ -2004,9 +1994,65 @@ struct CreateAlterTableResult {
     table_infos: HashMap<TableId, Arc<TableInfo>>,
 }
 
+/// Upper bound of rows buffered by detached flow mirror tasks on this frontend.
+///
+/// Rows retained by in-flight mirror RPCs count against this bound. If ordinary
+/// persisted source-table mirroring exceeds it, that mirror batch is best-effort
+/// dropped while its datanode write continues. Instant-TTL batches fail retryably
+/// on temporary saturation; oversized batches fail non-retryably so the client
+/// can reduce the batch size.
+const MAX_MIRROR_PENDING_ROWS: usize = 1_000_000;
+
+/// How often at most each mirror event is reported.
+const MIRROR_LOG_INTERVAL: Duration = Duration::from_secs(10);
+const MIRROR_LOG_NEVER_REPORTED: u64 = u64::MAX;
+
+struct MirrorLog {
+    last_log_millis: AtomicU64,
+    events: AtomicU64,
+}
+
+impl MirrorLog {
+    const fn new() -> Self {
+        Self {
+            last_log_millis: AtomicU64::new(MIRROR_LOG_NEVER_REPORTED),
+            events: AtomicU64::new(0),
+        }
+    }
+
+    /// Returns the count since the previous report, including this event, to
+    /// the single caller that claims the interval.
+    fn claim_report(&self, now_millis: u64) -> Option<u64> {
+        self.events.fetch_add(1, Ordering::Relaxed);
+        let last = self.last_log_millis.load(Ordering::Relaxed);
+        if last != MIRROR_LOG_NEVER_REPORTED
+            && now_millis.saturating_sub(last) < MIRROR_LOG_INTERVAL.as_millis() as u64
+        {
+            return None;
+        }
+        if self
+            .last_log_millis
+            .compare_exchange(last, now_millis, Ordering::Relaxed, Ordering::Relaxed)
+            .is_err()
+        {
+            return None;
+        }
+        Some(self.events.swap(0, Ordering::Relaxed))
+    }
+}
+
+static MIRROR_DROP_LOG: MirrorLog = MirrorLog::new();
+static MIRROR_FAILURE_LOG: MirrorLog = MirrorLog::new();
+
+/// Milliseconds since the first call, so the drop log is rate limited on a
+/// monotonic clock instead of the wall clock, which can jump.
+fn mirror_drop_log_millis() -> u64 {
+    static START: LazyLock<Instant> = LazyLock::new(Instant::now);
+    START.elapsed().as_millis() as u64
+}
+
 struct FlowMirrorTask {
     requests: HashMap<Peer, RegionInsertRequests>,
-    num_rows: usize,
 }
 
 impl FlowMirrorTask {
@@ -2016,7 +2062,6 @@ impl FlowMirrorTask {
     ) -> Result<Self> {
         let mut src_table_reqs: HashMap<TableId, Option<(Vec<Peer>, RegionInsertRequests)>> =
             HashMap::new();
-        let mut num_rows = 0;
 
         for req in requests {
             let table_id = RegionId::from_u64(req.region_id).table_id();
@@ -2040,11 +2085,6 @@ impl FlowMirrorTask {
                     if !peers.is_empty() {
                         let mut reqs = RegionInsertRequests::default();
                         reqs.requests.push(req.clone());
-                        num_rows += reqs
-                            .requests
-                            .iter()
-                            .map(|r| r.rows.as_ref().unwrap().rows.len())
-                            .sum::<usize>();
                         src_table_reqs.insert(table_id, Some((peers, reqs)));
                     } else {
                         // insert a empty entry to avoid repeat query
@@ -2080,16 +2120,69 @@ impl FlowMirrorTask {
             }
         }
 
-        Ok(Self {
-            requests: inserts,
-            num_rows,
-        })
+        Ok(Self { requests: inserts })
     }
 
-    fn detach(self, node_manager: NodeManagerRef) -> Result<()> {
-        crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.add(self.num_rows as i64);
+    /// Rows of row data this task keeps alive once detached: the payload it
+    /// spawns per peer, not the source requests it was built from.
+    ///
+    /// A source table mapped to several flownodes clones its requests per peer
+    /// and every clone owns its own copy of the rows, so reserving from
+    /// `self.requests` is what the per-peer shares released by [`Self::detach`]
+    /// sum to. Counting the source requests instead under-reserves whenever a
+    /// batch holds several requests for the same source table.
+    fn pending_rows(&self) -> u64 {
+        self.requests.values().map(region_inserts_rows).sum()
+    }
+
+    fn detach(
+        self,
+        node_manager: NodeManagerRef,
+        mirror_pending_rows: Arc<AtomicU64>,
+        has_instant_rows: bool,
+    ) -> Result<()> {
+        // Reserve the cloned per-peer payload before spawning. A full budget
+        // drops normal mirrors or rejects instant writes before datanode dispatch.
+        let num_rows = self.pending_rows();
+        if num_rows == 0 {
+            return Ok(());
+        }
+        if has_instant_rows && num_rows > MAX_MIRROR_PENDING_ROWS as u64 {
+            return InvalidInsertRequestSnafu {
+                reason: format!(
+                    "flow mirror batch has {num_rows} peer-fan-out rows, exceeding the limit of {}; reduce the batch size",
+                    MAX_MIRROR_PENDING_ROWS
+                ),
+            }
+            .fail();
+        }
+
+        let pending = reserve_mirror_pending_rows(&mirror_pending_rows, num_rows);
+        if pending > MAX_MIRROR_PENDING_ROWS as u64 {
+            release_mirror_pending_rows(&mirror_pending_rows, num_rows);
+            if has_instant_rows {
+                return Err(meter_core::collect::WriteRejected::new(
+                    "flow mirror pending rows limit exceeded for instant-TTL insert",
+                ))
+                .context(WriteRejectedSnafu);
+            }
+            crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.inc_by(num_rows);
+            if let Some(events) = MIRROR_DROP_LOG.claim_report(mirror_drop_log_millis()) {
+                warn!(
+                    "Flow mirror write dropped: {} pending rows exceeds limit {}, {} drop events since last report",
+                    pending, MAX_MIRROR_PENDING_ROWS, events
+                );
+            }
+            return Ok(());
+        }
+
         for (peer, inserts) in self.requests {
+            // Each spawned task releases exactly its own share of the
+            // reservation. The shares are computed over the same per-peer
+            // payload as `pending_rows`, so they sum to the reservation.
+            let peer_rows = region_inserts_rows(&inserts);
             let node_manager = node_manager.clone();
+            let mirror_pending_rows = mirror_pending_rows.clone();
             common_runtime::spawn_global(async move {
                 let result = node_manager
                     .flownode(&peer)
@@ -2102,12 +2195,18 @@ impl FlowMirrorTask {
                     Ok(resp) => {
                         let affected_rows = resp.affected_rows;
                         crate::metrics::DIST_MIRROR_ROW_COUNT.inc_by(affected_rows);
-                        crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.sub(affected_rows as _);
                     }
                     Err(err) => {
-                        error!(err; "Failed to insert data into flownode {}", peer);
+                        if let Some(events) =
+                            MIRROR_FAILURE_LOG.claim_report(mirror_drop_log_millis())
+                        {
+                            error!(err; flownode_id = peer.id, flownode_addr = %peer.addr, "Failed to insert data into flownode ({} total mirror failures across peers since last report)", events);
+                        }
                     }
                 }
+                // Release the reservation on both the success and the failure
+                // path, otherwise a broken flownode would fill the budget forever.
+                release_mirror_pending_rows(&mirror_pending_rows, peer_rows);
             });
         }
 
@@ -2115,17 +2214,62 @@ impl FlowMirrorTask {
     }
 }
 
+/// Rows of row data carried by `inserts`. A request without a `rows` payload
+/// carries nothing to keep buffered and contributes zero.
+fn region_inserts_rows(inserts: &RegionInsertRequests) -> u64 {
+    inserts
+        .requests
+        .iter()
+        .filter_map(|req| req.rows.as_ref())
+        .map(|rows| rows.rows.len() as u64)
+        .sum()
+}
+
+/// Reserves `rows` of the pending mirror budget and returns the resulting
+/// pending row count. The caller must [`release_mirror_pending_rows`] exactly
+/// these rows once they are no longer buffered, whether it spawns the batch or
+/// drops it.
+fn reserve_mirror_pending_rows(mirror_pending_rows: &AtomicU64, rows: u64) -> u64 {
+    let pending = mirror_pending_rows.fetch_add(rows, Ordering::Relaxed) + rows;
+    // Keep the gauge in step by applying the same increment, never by setting an
+    // absolute value: another task may move the budget in between.
+    crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.add(rows as i64);
+    pending
+}
+
+/// Releases `rows` of the pending mirror budget.
+///
+/// Every release mirrors the reservation it hands back, so a well-behaved
+/// release never subtracts more than is pending; the saturating update only
+/// keeps a duplicated release from wrapping the shared budget around.
+fn release_mirror_pending_rows(mirror_pending_rows: &AtomicU64, rows: u64) {
+    let prev = mirror_pending_rows
+        .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |pending| {
+            Some(pending.saturating_sub(rows))
+        })
+        .unwrap_or_else(|prev| prev);
+    // Subtract from the gauge with the opposite sign of
+    // [`reserve_mirror_pending_rows`]; reading the budget here and `set`-ting it
+    // would publish a stale value whenever another task releases concurrently.
+    let released = rows.min(prev);
+    if released > 0 {
+        crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.sub(released as i64);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
+    use std::sync::atomic::{AtomicU64, Ordering};
 
     use api::helper::ColumnDataTypeWrapper;
+    use api::v1::flow::FlowResponse;
     use api::v1::helper::{field_column_schema, time_index_column_schema};
     use api::v1::{Row, RowInsertRequest, Rows, Value};
     use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
     use common_meta::cache::new_table_flownode_set_cache;
     use common_meta::ddl::test_util::datanode_handler::NaiveDatanodeHandler;
-    use common_meta::test_util::MockDatanodeManager;
+    use common_meta::test_util::{MockDatanodeManager, MockFlownodeHandler, MockFlownodeManager};
     use common_query::native_histogram::NATIVE_HISTOGRAM_FIELD;
     use common_query::prelude::{greptime_native_histogram, set_default_prefix};
     use datatypes::data_type::ConcreteDataType;
@@ -3340,4 +3484,695 @@ mod tests {
             .unwrap();
         assert!(matches!(output.data, OutputData::AffectedRows(0)));
     }
+
+    /// Flownode handler that keeps mirror inserts in flight until the test
+    /// releases the gate, so the pending mirror budget can be observed
+    /// deterministically.
+    #[derive(Clone)]
+    struct GatedFlownodeHandler {
+        gate: Arc<tokio::sync::Semaphore>,
+        affected_rows: u64,
+    }
+
+    #[async_trait::async_trait]
+    impl MockFlownodeHandler for GatedFlownodeHandler {
+        async fn handle_inserts(
+            &self,
+            _peer: &Peer,
+            _requests: api::v1::region::InsertRequests,
+        ) -> common_meta::error::Result<FlowResponse> {
+            let _permit = self.gate.acquire().await.unwrap();
+            Ok(FlowResponse {
+                affected_rows: self.affected_rows,
+                ..Default::default()
+            })
+        }
+    }
+
+    fn flownode_peer() -> Peer {
+        Peer {
+            id: 1,
+            addr: "127.0.0.1:4001".to_string(),
+        }
+    }
+
+    #[derive(Clone)]
+    struct RecordingNodeManager {
+        datanode_dispatch: tokio::sync::mpsc::UnboundedSender<usize>,
+        flownode_dispatch: tokio::sync::mpsc::UnboundedSender<Peer>,
+        gates: Arc<std::sync::Mutex<HashMap<u64, Arc<tokio::sync::Semaphore>>>>,
+        fail_flownode: bool,
+    }
+
+    #[async_trait::async_trait]
+    impl common_meta::node_manager::DatanodeManager for RecordingNodeManager {
+        async fn datanode(&self, peer: &Peer) -> common_meta::node_manager::DatanodeRef {
+            Arc::new(RecordingNode {
+                peer: peer.clone(),
+                manager: self.clone(),
+            })
+        }
+    }
+
+    #[async_trait::async_trait]
+    impl common_meta::node_manager::FlownodeManager for RecordingNodeManager {
+        async fn flownode(&self, peer: &Peer) -> common_meta::node_manager::FlownodeRef {
+            Arc::new(RecordingNode {
+                peer: peer.clone(),
+                manager: self.clone(),
+            })
+        }
+    }
+
+    struct RecordingNode {
+        peer: Peer,
+        manager: RecordingNodeManager,
+    }
+
+    #[async_trait::async_trait]
+    impl common_meta::node_manager::Datanode for RecordingNode {
+        async fn handle_request(
+            &self,
+            _request: Arc<api::v1::region::RegionRequest>,
+        ) -> common_meta::error::Result<api::region::RegionResponse> {
+            let rows = match _request.body.as_ref() {
+                Some(api::v1::region::region_request::Body::Inserts(requests)) => requests
+                    .requests
+                    .iter()
+                    .filter_map(|request| request.rows.as_ref())
+                    .map(|rows| rows.rows.len())
+                    .sum(),
+                _ => 0,
+            };
+            let _ = self.manager.datanode_dispatch.send(rows);
+            Ok(api::region::RegionResponse::new(rows))
+        }
+
+        async fn handle_query(
+            &self,
+            _request: common_query::request::QueryRequest,
+        ) -> common_meta::error::Result<common_recordbatch::SendableRecordBatchStream> {
+            unreachable!()
+        }
+    }
+
+    #[async_trait::async_trait]
+    impl common_meta::node_manager::Flownode for RecordingNode {
+        async fn handle(
+            &self,
+            _request: api::v1::flow::FlowRequest,
+        ) -> common_meta::error::Result<FlowResponse> {
+            unreachable!()
+        }
+
+        async fn handle_inserts(
+            &self,
+            _request: api::v1::region::InsertRequests,
+        ) -> common_meta::error::Result<FlowResponse> {
+            let _ = self.manager.flownode_dispatch.send(self.peer.clone());
+            if self.manager.fail_flownode {
+                return Err(common_meta::error::UnexpectedSnafu {
+                    err_msg: "test flownode failure".to_string(),
+                }
+                .build());
+            }
+            let gate = self
+                .manager
+                .gates
+                .lock()
+                .unwrap()
+                .get(&self.peer.id)
+                .cloned();
+            if let Some(gate) = gate {
+                let _permit = gate.acquire().await.unwrap();
+            }
+            Ok(FlowResponse::default())
+        }
+
+        async fn handle_mark_window_dirty(
+            &self,
+            _request: api::v1::flow::DirtyWindowRequests,
+        ) -> common_meta::error::Result<FlowResponse> {
+            unreachable!()
+        }
+    }
+
+    fn mirror_requests(peer: &Peer, num_rows: usize) -> HashMap<Peer, RegionInsertRequests> {
+        HashMap::from_iter([(
+            peer.clone(),
+            RegionInsertRequests {
+                requests: vec![RegionInsertRequest {
+                    region_id: RegionId::new(1, 1).as_u64(),
+                    rows: Some(Rows {
+                        schema: vec![],
+                        rows: vec![api::v1::Row { values: vec![] }; num_rows],
+                    }),
+                    ..Default::default()
+                }],
+            },
+        )])
+    }
+
+    /// Serializes the mirror metric tests below: the metrics are process-wide
+    /// singletons, so these tests would otherwise observe each other's updates
+    /// when the test binary runs tests in parallel (they are isolated per
+    /// process only under nextest).
+    static MIRROR_METRIC_TEST_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
+
+    async fn lock_mirror_metrics() -> tokio::sync::MutexGuard<'static, ()> {
+        MIRROR_METRIC_TEST_LOCK.lock().await
+    }
+
+    // The tests below share the process-wide mirror metrics, so they take
+    // `MIRROR_METRIC_TEST_LOCK` and assert on the difference their own budget
+    // publishes instead of on absolute values.
+    #[tokio::test]
+    async fn flow_mirror_saturation_preserves_instant_and_normal_contracts() {
+        use common_error::ext::{ErrorExt, RetryHint};
+        use common_error::status_code::StatusCode;
+
+        let _guard = lock_mirror_metrics().await;
+        let kv_backend = prepare_mocked_backend().await;
+        let partition_manager = create_partition_rule_manager(kv_backend.clone()).await;
+        let (datanode_tx, mut datanode_rx) = tokio::sync::mpsc::unbounded_channel();
+        let (flownode_tx, mut flownode_rx) = tokio::sync::mpsc::unbounded_channel();
+        let node_manager = Arc::new(RecordingNodeManager {
+            datanode_dispatch: datanode_tx,
+            flownode_dispatch: flownode_tx,
+            gates: Arc::new(std::sync::Mutex::new(HashMap::new())),
+            fail_flownode: false,
+        });
+        let flow_cache = Cache::new(10);
+        let flow_cache_backend = prepare_mocked_backend().await;
+        let inserter = Inserter::new(
+            catalog::memory::MemoryCatalogManager::new(),
+            partition_manager,
+            node_manager,
+            Arc::new(new_table_flownode_set_cache(
+                String::new(),
+                flow_cache.clone(),
+                flow_cache_backend,
+            )),
+            true,
+        );
+        let peer = flownode_peer();
+        inserter
+            .table_flownode_set_cache
+            .invalidate(&[common_meta::instruction::CacheIdent::CreateFlow(
+                common_meta::instruction::CreateFlow {
+                    flow_id: 1,
+                    source_table_ids: vec![1, 2],
+                    partition_to_peer_mapping: vec![(0, peer)],
+                },
+            )])
+            .await
+            .unwrap();
+        let mut normal_info = new_test_table_info(1, "normal_table", [1].into_iter());
+        normal_info.catalog_name = DEFAULT_CATALOG_NAME.to_string();
+        normal_info.schema_name = DEFAULT_SCHEMA_NAME.to_string();
+        let mut instant_info = new_test_table_info(2, "instant_table", [1].into_iter());
+        instant_info.meta.options.ttl = Some(common_time::ttl::TimeToLive::Instant);
+        let table_infos =
+            HashMap::from_iter([(1, Arc::new(normal_info)), (2, Arc::new(instant_info))]);
+        let ctx = Arc::new(QueryContext::with(
+            DEFAULT_CATALOG_NAME,
+            DEFAULT_SCHEMA_NAME,
+        ));
+        let insert = |table_id, num_rows| RegionInsertRequests {
+            requests: vec![RegionInsertRequest {
+                region_id: RegionId::new(table_id, 1).as_u64(),
+                rows: Some(Rows {
+                    schema: vec![],
+                    rows: vec![api::v1::Row::default(); num_rows],
+                }),
+                ..Default::default()
+            }],
+        };
+        let make_request = |normal, instant| InstantAndNormalInsertRequests {
+            normal_requests: if normal == 0 {
+                RegionInsertRequests::default()
+            } else {
+                insert(1, normal)
+            },
+            instant_requests: if instant == 0 {
+                RegionInsertRequests::default()
+            } else {
+                insert(2, instant)
+            },
+        };
+
+        let pending = inserter.mirror_pending_rows.clone();
+        let gauge_before = crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get();
+        crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.add(MAX_MIRROR_PENDING_ROWS as i64);
+        pending.store(MAX_MIRROR_PENDING_ROWS as u64, Ordering::Relaxed);
+        let dropped_before = crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get();
+        for request in [make_request(0, 1), make_request(1, 1)] {
+            let error = inserter
+                .do_request(request, &table_infos, &ctx)
+                .await
+                .unwrap_err();
+            assert_eq!(error.status_code(), StatusCode::RateLimited);
+            assert_eq!(error.retry_hint(), RetryHint::Retryable);
+            assert!(datanode_rx.try_recv().is_err());
+            assert!(flownode_rx.try_recv().is_err());
+            assert_eq!(
+                pending.load(Ordering::Relaxed),
+                MAX_MIRROR_PENDING_ROWS as u64
+            );
+        }
+        assert_eq!(
+            crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get(),
+            dropped_before
+        );
+
+        for pending_before in [0, MAX_MIRROR_PENDING_ROWS as u64] {
+            if pending_before == 0 {
+                pending.store(0, Ordering::Relaxed);
+                crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.sub(MAX_MIRROR_PENDING_ROWS as i64);
+            }
+            let gauge_before_rejection = crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get();
+            for (normal, instant) in [
+                (0, MAX_MIRROR_PENDING_ROWS + 1),
+                (MAX_MIRROR_PENDING_ROWS / 2, MAX_MIRROR_PENDING_ROWS / 2 + 1),
+            ] {
+                let error = inserter
+                    .do_request(make_request(normal, instant), &table_infos, &ctx)
+                    .await
+                    .unwrap_err();
+                assert_eq!(error.status_code(), StatusCode::InvalidArguments);
+                assert_eq!(error.retry_hint(), RetryHint::NonRetryable);
+                let message = error.to_string();
+                assert!(message.contains("1000001"), "{message}");
+                assert!(message.contains("1000000"), "{message}");
+                assert!(message.contains("reduce the batch size"), "{message}");
+                assert!(datanode_rx.try_recv().is_err());
+                assert!(flownode_rx.try_recv().is_err());
+                assert_eq!(pending.load(Ordering::Relaxed), pending_before);
+                assert_eq!(
+                    crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get(),
+                    gauge_before_rejection
+                );
+                assert_eq!(
+                    crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get(),
+                    dropped_before
+                );
+            }
+            if pending_before == 0 {
+                crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.add(MAX_MIRROR_PENDING_ROWS as i64);
+                pending.store(MAX_MIRROR_PENDING_ROWS as u64, Ordering::Relaxed);
+            }
+        }
+
+        let result = inserter
+            .do_request(make_request(1, 0), &table_infos, &ctx)
+            .await
+            .unwrap();
+        assert!(matches!(result.data, OutputData::AffectedRows(1)));
+        assert_eq!(1, datanode_rx.try_recv().unwrap());
+        assert!(flownode_rx.try_recv().is_err());
+        assert_eq!(
+            crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get(),
+            dropped_before + 1
+        );
+        pending.store(0, Ordering::Relaxed);
+        crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.sub(MAX_MIRROR_PENDING_ROWS as i64);
+        assert_eq!(
+            crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get(),
+            gauge_before
+        );
+    }
+
+    #[tokio::test]
+    async fn flow_mirror_new_counts_regions_and_peer_clones() {
+        use common_meta::instruction::{CacheIdent, CreateFlow};
+
+        let peer1 = flownode_peer();
+        let peer2 = Peer {
+            id: 2,
+            addr: "127.0.0.1:4002".to_string(),
+        };
+        let cache_backend = prepare_mocked_backend().await;
+        let cache = Arc::new(new_table_flownode_set_cache(
+            String::new(),
+            Cache::new(10),
+            cache_backend,
+        ));
+        cache
+            .invalidate(&[CacheIdent::CreateFlow(CreateFlow {
+                flow_id: 1,
+                source_table_ids: vec![1],
+                partition_to_peer_mapping: vec![(0, peer1), (1, peer2)],
+            })])
+            .await
+            .unwrap();
+        let request = |region_id| RegionInsertRequest {
+            region_id,
+            rows: Some(Rows {
+                schema: vec![],
+                rows: vec![api::v1::Row { values: vec![] }; 3],
+            }),
+            ..Default::default()
+        };
+        let requests = [
+            request(RegionId::new(1, 0).as_u64()),
+            request(RegionId::new(1, 1).as_u64()),
+        ];
+        let task = FlowMirrorTask::new(&cache, requests.iter()).await.unwrap();
+        assert_eq!(12, task.pending_rows());
+        assert_eq!(2, task.requests.len());
+    }
+
+    #[tokio::test]
+    async fn flow_mirror_dropped_when_pending_exceeds_limit() {
+        let _guard = lock_mirror_metrics().await;
+        let pending = Arc::new(AtomicU64::new(MAX_MIRROR_PENDING_ROWS as u64));
+        let dropped_before = crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get();
+        let gauge_before = crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get();
+        let num_rows = 100;
+
+        let task = FlowMirrorTask {
+            requests: mirror_requests(&flownode_peer(), num_rows),
+        };
+        // The budget is already full, so nothing may be spawned for this batch.
+        task.detach(
+            Arc::new(MockDatanodeManager::new(NaiveDatanodeHandler)),
+            pending.clone(),
+            false,
+        )
+        .unwrap();
+
+        assert_eq!(
+            num_rows as u64,
+            crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get() - dropped_before
+        );
+        // The dropped batch must not leak its reservation.
+        assert_eq!(
+            MAX_MIRROR_PENDING_ROWS as u64,
+            pending.load(Ordering::Relaxed)
+        );
+        // The reservation taken before the limit check is released again, so the
+        // gauge nets out and keeps matching the pending budget.
+        assert_eq!(
+            gauge_before,
+            crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get(),
+            "a dropped batch must not change the pending gauge"
+        );
+
+        let task = FlowMirrorTask {
+            requests: mirror_requests(&flownode_peer(), num_rows),
+        };
+        let error = task
+            .detach(
+                Arc::new(MockDatanodeManager::new(NaiveDatanodeHandler)),
+                pending.clone(),
+                true,
+            )
+            .err()
+            .unwrap();
+        use common_error::ext::{ErrorExt, RetryHint};
+        use common_error::status_code::StatusCode;
+        assert_eq!(error.status_code(), StatusCode::RateLimited);
+        assert_eq!(error.retry_hint(), RetryHint::Retryable);
+        assert_eq!(
+            crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get(),
+            dropped_before + num_rows as u64,
+            "rejected instant rows are not successful best-effort drops"
+        );
+        assert_eq!(
+            MAX_MIRROR_PENDING_ROWS as u64,
+            pending.load(Ordering::Relaxed)
+        );
+        assert_eq!(
+            gauge_before,
+            crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get()
+        );
+    }
+
+    /// A source table mapped to several flownodes clones its requests per peer,
+    /// so the reservation must cover every clone and each spawned task must hand
+    /// back exactly its own share; otherwise the shared budget drifts.
+    #[tokio::test]
+    async fn flow_mirror_reserves_and_releases_per_peer_shares() {
+        let _guard = lock_mirror_metrics().await;
+        let per_peer_rows = 10;
+        let total_rows = (2 * per_peer_rows) as u64;
+        // Exactly enough room for the whole batch, cloned rows included.
+        let start = MAX_MIRROR_PENDING_ROWS as u64 - total_rows;
+        let pending = Arc::new(AtomicU64::new(start));
+        let gate = Arc::new(tokio::sync::Semaphore::new(0));
+        let node_manager = Arc::new(MockFlownodeManager::new(GatedFlownodeHandler {
+            gate: gate.clone(),
+            affected_rows: per_peer_rows as u64,
+        }));
+
+        let mut requests = mirror_requests(&flownode_peer(), per_peer_rows);
+        requests.extend(mirror_requests(
+            &Peer {
+                id: 2,
+                addr: "127.0.0.1:4002".to_string(),
+            },
+            per_peer_rows,
+        ));
+
+        let gauge_before = crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get();
+        FlowMirrorTask { requests }
+            .detach(node_manager, pending.clone(), false)
+            .unwrap();
+
+        // Both per-peer payloads are counted, so the budget is exactly full
+        // instead of over-reserved by the duplicated rows.
+        assert_eq!(
+            MAX_MIRROR_PENDING_ROWS as u64,
+            pending.load(Ordering::Relaxed)
+        );
+
+        // Let both tasks finish and check that the budget lands back on its
+        // starting value: over-releasing a shared reservation would saturate it.
+        // The gauge is checked too because `release_mirror_pending_rows` moves
+        // the budget before the gauge; exiting on the budget alone could leak a
+        // pending `gauge.sub` into the next test holding the metrics lock.
+        gate.add_permits(2);
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
+        while pending.load(Ordering::Relaxed) != start
+            || crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get() != gauge_before
+        {
+            assert!(
+                std::time::Instant::now() < deadline,
+                "the mirror tasks must release exactly their own shares"
+            );
+            std::thread::sleep(std::time::Duration::from_millis(1));
+        }
+    }
+
+    #[tokio::test]
+    async fn flow_mirror_fast_peer_releases_only_its_share_before_drop() {
+        let _guard = lock_mirror_metrics().await;
+        let peer1 = flownode_peer();
+        let peer2 = Peer {
+            id: 2,
+            addr: "127.0.0.1:4002".to_string(),
+        };
+        let gate1 = Arc::new(tokio::sync::Semaphore::new(0));
+        let gate2 = Arc::new(tokio::sync::Semaphore::new(0));
+        let gates = Arc::new(std::sync::Mutex::new(HashMap::from_iter([
+            (peer1.id, gate1.clone()),
+            (peer2.id, gate2.clone()),
+        ])));
+        let (datanode_tx, _datanode_rx) = tokio::sync::mpsc::unbounded_channel();
+        let (flownode_tx, mut flownode_rx) = tokio::sync::mpsc::unbounded_channel();
+        let node_manager = Arc::new(RecordingNodeManager {
+            datanode_dispatch: datanode_tx,
+            flownode_dispatch: flownode_tx,
+            gates,
+            fail_flownode: false,
+        });
+        let pending = Arc::new(AtomicU64::new(MAX_MIRROR_PENDING_ROWS as u64 - 20));
+        let gauge_before = crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get();
+        let mut requests = mirror_requests(&peer1, 10);
+        requests.extend(mirror_requests(&peer2, 10));
+        let task = FlowMirrorTask { requests };
+        task.detach(node_manager.clone(), pending.clone(), false)
+            .unwrap();
+        let first = tokio::time::timeout(Duration::from_secs(10), flownode_rx.recv())
+            .await
+            .unwrap()
+            .unwrap();
+        let second = tokio::time::timeout(Duration::from_secs(10), flownode_rx.recv())
+            .await
+            .unwrap()
+            .unwrap();
+        assert_ne!(first.id, second.id);
+        let fast_gate = if first.id == peer1.id {
+            gate1.clone()
+        } else {
+            gate2.clone()
+        };
+        let slow_gate = if first.id == peer1.id {
+            gate2.clone()
+        } else {
+            gate1.clone()
+        };
+        fast_gate.add_permits(1);
+        let deadline = std::time::Instant::now() + Duration::from_secs(10);
+        while pending.load(Ordering::Relaxed) != MAX_MIRROR_PENDING_ROWS as u64 - 10 {
+            assert!(
+                std::time::Instant::now() < deadline,
+                "fast peer did not release"
+            );
+            std::thread::sleep(Duration::from_millis(1));
+        }
+        let dropped_before = crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get();
+        FlowMirrorTask {
+            requests: mirror_requests(&peer1, 11),
+        }
+        .detach(node_manager, pending.clone(), false)
+        .unwrap();
+        assert_eq!(
+            crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get(),
+            dropped_before + 11
+        );
+        assert!(flownode_rx.try_recv().is_err());
+        slow_gate.add_permits(1);
+        while pending.load(Ordering::Relaxed) != MAX_MIRROR_PENDING_ROWS as u64 - 20
+            || crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get() != gauge_before
+        {
+            assert!(
+                std::time::Instant::now() < deadline,
+                "slow peer did not release"
+            );
+            std::thread::sleep(Duration::from_millis(1));
+        }
+    }
+
+    #[tokio::test]
+    async fn flow_mirror_failure_releases_budget_and_gauge() {
+        let _guard = lock_mirror_metrics().await;
+        let (datanode_tx, _datanode_rx) = tokio::sync::mpsc::unbounded_channel();
+        let (flownode_tx, mut flownode_rx) = tokio::sync::mpsc::unbounded_channel();
+        let node_manager = Arc::new(RecordingNodeManager {
+            datanode_dispatch: datanode_tx,
+            flownode_dispatch: flownode_tx,
+            gates: Arc::new(std::sync::Mutex::new(HashMap::new())),
+            fail_flownode: true,
+        });
+        let pending = Arc::new(AtomicU64::new(0));
+        let gauge_before = crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get();
+        FlowMirrorTask {
+            requests: mirror_requests(&flownode_peer(), 5),
+        }
+        .detach(node_manager, pending.clone(), false)
+        .unwrap();
+        assert_eq!(
+            tokio::time::timeout(Duration::from_secs(10), flownode_rx.recv())
+                .await
+                .unwrap()
+                .unwrap()
+                .id,
+            flownode_peer().id
+        );
+        let deadline = std::time::Instant::now() + Duration::from_secs(10);
+        while pending.load(Ordering::Relaxed) != 0
+            || crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get() != gauge_before
+        {
+            assert!(
+                std::time::Instant::now() < deadline,
+                "failed task leaked reservation"
+            );
+            std::thread::sleep(Duration::from_millis(1));
+        }
+    }
+
+    #[tokio::test]
+    async fn flow_mirror_pending_counter_consistent() {
+        let _guard = lock_mirror_metrics().await;
+        let pending = Arc::new(AtomicU64::new(0));
+        let gate = Arc::new(tokio::sync::Semaphore::new(0));
+        let node_manager = Arc::new(MockFlownodeManager::new(GatedFlownodeHandler {
+            gate: gate.clone(),
+            affected_rows: 7,
+        }));
+
+        // A batch without rows short-circuits and leaves the budget untouched.
+        let gauge_before = crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get();
+        FlowMirrorTask {
+            requests: HashMap::new(),
+        }
+        .detach(node_manager.clone(), pending.clone(), false)
+        .unwrap();
+        assert_eq!(0, pending.load(Ordering::Relaxed));
+        assert_eq!(
+            gauge_before,
+            crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get(),
+            "an empty batch must not touch the pending gauge"
+        );
+
+        let dropped_before = crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get();
+        let num_rows = 7;
+
+        FlowMirrorTask {
+            requests: mirror_requests(&flownode_peer(), num_rows),
+        }
+        .detach(node_manager, pending.clone(), false)
+        .unwrap();
+
+        // The spawned task is still waiting on the gated flownode, so the
+        // reservation made by `detach` is the value observable here.
+        assert_eq!(num_rows as u64, pending.load(Ordering::Relaxed));
+        assert_eq!(
+            num_rows as i64,
+            crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get() - gauge_before,
+            "the pending gauge must track the pending rows"
+        );
+        assert_eq!(
+            dropped_before,
+            crate::metrics::DIST_MIRROR_DROPPED_ROW_COUNT.get(),
+            "a batch within the limit must not be counted as dropped"
+        );
+
+        // Release the in-flight task and wait for it to hand its reservation
+        // back, so no task is left holding the shared metrics after this test.
+        gate.add_permits(1);
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
+        while pending.load(Ordering::Relaxed) != 0
+            || crate::metrics::DIST_MIRROR_PENDING_ROW_COUNT.get() != gauge_before
+        {
+            assert!(
+                std::time::Instant::now() < deadline,
+                "the mirror task did not release its pending reservation"
+            );
+            std::thread::sleep(std::time::Duration::from_millis(1));
+        }
+    }
+
+    #[test]
+    fn mirror_logs_are_rate_limited() {
+        let log = Arc::new(MirrorLog::new());
+        assert_eq!(Some(1), log.claim_report(1_000));
+        assert_eq!(None, log.claim_report(1_500));
+        assert_eq!(None, log.claim_report(10_999));
+        assert_eq!(Some(3), log.claim_report(11_000));
+        assert_eq!(None, log.claim_report(11_001));
+        assert_eq!(Some(2), log.claim_report(21_000));
+
+        let concurrent = Arc::new(MirrorLog::new());
+        assert_eq!(Some(1), concurrent.claim_report(50_000));
+        let barrier = Arc::new(std::sync::Barrier::new(8));
+        let threads = (0..8)
+            .map(|_| {
+                let log = concurrent.clone();
+                let barrier = barrier.clone();
+                std::thread::spawn(move || {
+                    barrier.wait();
+                    log.claim_report(60_000)
+                })
+            })
+            .collect::<Vec<_>>();
+        let winners = threads
+            .into_iter()
+            .filter_map(|thread| thread.join().unwrap())
+            .collect::<Vec<_>>();
+        assert_eq!(winners.len(), 1);
+        let residual = concurrent.events.swap(0, Ordering::Relaxed);
+        assert_eq!(winners[0] + residual, 8);
+    }
 }
diff --git a/src/operator/src/lib.rs b/src/operator/src/lib.rs
index a971ca41f70..901f351e22c 100644
--- a/src/operator/src/lib.rs
+++ b/src/operator/src/lib.rs
@@ -29,3 +29,4 @@ pub mod table;
 #[cfg(any(test, feature = "testing"))]
 pub mod test_util;
 pub mod utils;
+pub mod write_dispatcher;
diff --git a/src/operator/src/metrics.rs b/src/operator/src/metrics.rs
index 3e0b2fed2a6..438904ed36c 100644
--- a/src/operator/src/metrics.rs
+++ b/src/operator/src/metrics.rs
@@ -47,6 +47,11 @@ lazy_static! {
         "table operator mirror pending rows"
     )
     .unwrap();
+    pub static ref DIST_MIRROR_DROPPED_ROW_COUNT: IntCounter = register_int_counter!(
+        "greptime_operator_dist_mirror_dropped_rows",
+        "table operator mirror rows dropped because the pending mirror row limit was exceeded"
+    )
+    .unwrap();
     pub static ref DIST_DELETE_ROW_COUNT: IntCounterVec = register_int_counter_vec!(
         "greptime_table_operator_delete_rows",
         "table operator delete rows",
diff --git a/src/operator/src/req_convert.rs b/src/operator/src/req_convert.rs
index 456ff0b328d..82681e09968 100644
--- a/src/operator/src/req_convert.rs
+++ b/src/operator/src/req_convert.rs
@@ -15,3 +15,5 @@
 pub(crate) mod common;
 pub mod delete;
 pub mod insert;
+
+pub(crate) use common::partitioner::TablePartitioner;
diff --git a/src/operator/src/req_convert/common/partitioner.rs b/src/operator/src/req_convert/common/partitioner.rs
index 3353e2fcda7..6df73d7d1b9 100644
--- a/src/operator/src/req_convert/common/partitioner.rs
+++ b/src/operator/src/req_convert/common/partitioner.rs
@@ -12,72 +12,1077 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use api::v1::region::{DeleteRequest, InsertRequest};
-use api::v1::{PartitionExprVersion, Rows};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use api::v1::region::{
+    BulkInsertRequest, DeleteRequest, DeleteRequests, InsertRequest, InsertRequests, RegionRequest,
+    bulk_insert_request, region_request::Body,
+};
+use api::v1::{ArrowIpc, PartitionExprVersion, Rows};
+use common_error::ext::BoxedError;
+use common_grpc::flight::{self, FlightDecoder};
+use datatypes::arrow::array::{Array, BinaryArray, StringBuilder};
+use datatypes::arrow::compute;
+use datatypes::arrow::datatypes::{DataType, Field, Schema};
+use datatypes::arrow::record_batch::RecordBatch;
+use mito_codec::row_converter::sparse::{SparseOffsetsCache, SparsePrimaryKeyView};
+use partition::PartitionRuleRef;
 use partition::manager::PartitionRuleManager;
-use snafu::ResultExt;
-use store_api::storage::RegionId;
+use partition::partition::RegionMask;
+use partition::splitter::RowSplitter;
+use snafu::{OptionExt, ResultExt, ensure};
+use store_api::storage::consts;
+use store_api::storage::{RegionId, RegionNumber, TableId};
 use table::metadata::TableInfo;
 
-use crate::error::{Result, SplitDeleteSnafu, SplitInsertSnafu};
+use crate::error::{self, Result, SplitDeleteSnafu, SplitInsertSnafu};
 
+/// Loads table routing rules and converts rows to region write requests.
 pub struct Partitioner<'a> {
     partition_manager: &'a PartitionRuleManager,
 }
 
+/// A single snapshot of a table's partition rule and expression versions.
+pub(crate) struct TablePartitioner {
+    table_id: TableId,
+    rule: PartitionRuleRef,
+    versions: HashMap<RegionNumber, Option<PartitionExprVersion>>,
+}
+
 impl<'a> Partitioner<'a> {
+    /// Creates a partitioner backed by the shared routing caches.
     pub fn new(partition_manager: &'a PartitionRuleManager) -> Self {
         Self { partition_manager }
     }
 
+    /// Routes insert rows using the current table partitions.
     pub async fn partition_insert_requests(
         &self,
         table_info: &TableInfo,
         rows: Rows,
         skip_wal: bool,
     ) -> Result<Vec<InsertRequest>> {
-        let table_id = table_info.table_id();
-        let requests = self
-            .partition_manager
-            .split_rows(table_info, rows)
+        TablePartitioner::try_new(self.partition_manager, table_info)
             .await
             .context(SplitInsertSnafu)?
-            .into_iter()
-            .map(
-                |(region_number, (rows, partition_expr_version))| InsertRequest {
-                    skip_wal,
-                    region_id: RegionId::new(table_id, region_number).into(),
-                    rows: Some(rows),
-                    partition_expr_version: partition_expr_version
-                        .map(|value| PartitionExprVersion { value }),
-                },
-            )
-            .collect();
-        Ok(requests)
+            .partition_insert_requests(rows, skip_wal)
     }
 
+    /// Routes delete rows using the current table partitions.
     pub async fn partition_delete_requests(
         &self,
         table_info: &TableInfo,
         rows: Rows,
     ) -> Result<Vec<DeleteRequest>> {
-        let table_id = table_info.table_id();
-
-        let requests = self
-            .partition_manager
-            .split_rows(table_info, rows)
+        TablePartitioner::try_new(self.partition_manager, table_info)
             .await
             .context(SplitDeleteSnafu)?
+            .partition_delete_requests(rows)
+    }
+}
+
+impl TablePartitioner {
+    /// Reads a table's partition rule and expression versions into one routing snapshot.
+    pub async fn try_new(
+        partition_manager: &PartitionRuleManager,
+        table_info: &TableInfo,
+    ) -> partition::error::Result<Self> {
+        let (rule, versions) = partition_manager
+            .find_table_partition_rule(table_info)
+            .await?;
+        Ok(Self {
+            table_id: table_info.table_id(),
+            rule,
+            versions: versions
+                .into_iter()
+                .map(|(region, version)| {
+                    (region, version.map(|value| PartitionExprVersion { value }))
+                })
+                .collect(),
+        })
+    }
+
+    /// Rebuilds write requests using this partition snapshot after a route refresh.
+    ///
+    /// Takes ownership so row payloads can move into their new regions. Requests whose
+    /// region and partition version still match retain their original payloads.
+    /// The table metadata comes from the same refresh that created this partitioner.
+    pub(crate) fn rebuild_write_requests(
+        &self,
+        request: RegionRequest,
+        table_info: &TableInfo,
+    ) -> Result<Vec<RegionRequest>> {
+        let RegionRequest { header, body } = request;
+        let bodies = match body.context(error::UnexpectedSnafu {
+            violated: "Cannot rebuild a request without a body",
+        })? {
+            Body::Inserts(inserts) => self.rebuild_insert_requests(inserts)?,
+            Body::Deletes(deletes) => self.rebuild_delete_requests(deletes)?,
+            Body::BulkInsert(bulk) => self.rebuild_bulk_insert_request(bulk, table_info)?,
+            _ => {
+                return error::UnexpectedSnafu {
+                    violated: "Only writes can be rebuilt",
+                }
+                .fail();
+            }
+        };
+        Ok(bodies
             .into_iter()
-            .map(
-                |(region_number, (rows, partition_expr_version))| DeleteRequest {
-                    region_id: RegionId::new(table_id, region_number).into(),
+            .map(|body| RegionRequest {
+                header: header.clone(),
+                body: Some(body),
+            })
+            .collect())
+    }
+
+    /// Moves insert rows into requests for this snapshot's destination regions.
+    pub fn partition_insert_requests(
+        &self,
+        rows: Rows,
+        skip_wal: bool,
+    ) -> Result<Vec<InsertRequest>> {
+        Ok(RowSplitter::new(self.rule.clone())
+            .split(rows)
+            .context(SplitInsertSnafu)?
+            .into_iter()
+            .map(|(region, rows)| InsertRequest {
+                region_id: RegionId::new(self.table_id, region).as_u64(),
+                rows: Some(rows),
+                partition_expr_version: self.version(region),
+                skip_wal,
+            })
+            .collect())
+    }
+
+    /// Moves delete rows into requests for this snapshot's destination regions.
+    pub fn partition_delete_requests(&self, rows: Rows) -> Result<Vec<DeleteRequest>> {
+        Ok(RowSplitter::new(self.rule.clone())
+            .split(rows)
+            .context(SplitDeleteSnafu)?
+            .into_iter()
+            .map(|(region, rows)| DeleteRequest {
+                region_id: RegionId::new(self.table_id, region).as_u64(),
+                rows: Some(rows),
+                partition_expr_version: self.version(region),
+            })
+            .collect())
+    }
+
+    /// Splits an Arrow batch, reusing the original IPC when one region selects all rows.
+    pub fn partition_bulk_insert_requests(
+        &self,
+        batch: RecordBatch,
+        original_ipc: Option<ArrowIpc>,
+        skip_wal: bool,
+    ) -> Result<Vec<BulkInsertRequest>> {
+        let masks = self
+            .rule
+            .split_record_batch(&batch)
+            .context(SplitInsertSnafu)?;
+        self.build_bulk_insert_requests(batch, masks, original_ipc, skip_wal)
+    }
+
+    fn build_bulk_insert_requests(
+        &self,
+        batch: RecordBatch,
+        masks: HashMap<RegionNumber, RegionMask>,
+        mut original_ipc: Option<ArrowIpc>,
+        skip_wal: bool,
+    ) -> Result<Vec<BulkInsertRequest>> {
+        let mut requests = Vec::with_capacity(masks.len());
+        for (region, mask) in masks {
+            if mask.select_none() {
+                continue;
+            }
+            let original = if mask.select_all() {
+                original_ipc.take()
+            } else {
+                None
+            };
+            let ipc = if let Some(ipc) = original {
+                ipc
+            } else {
+                let selected = if mask.select_all() {
+                    batch.clone()
+                } else {
+                    compute::filter_record_batch(&batch, mask.array())
+                        .context(error::ComputeArrowSnafu)?
+                };
+                let (schema, data_header, payload) = flight::record_batch_to_ipc(selected)
+                    .map_err(BoxedError::new)
+                    .context(error::ExternalSnafu)?;
+                ArrowIpc {
+                    schema,
+                    data_header,
+                    payload,
+                }
+            };
+            requests.push(BulkInsertRequest {
+                region_id: RegionId::new(self.table_id, region).as_u64(),
+                partition_expr_version: self.version(region),
+                // The destination datanode validates against its current schema.
+                aligned_schema_version: None,
+                skip_wal,
+                body: Some(bulk_insert_request::Body::ArrowIpc(ipc)),
+            });
+        }
+        Ok(requests)
+    }
+
+    fn rebuild_insert_requests(&self, inserts: InsertRequests) -> Result<Vec<Body>> {
+        let mut bodies = Vec::new();
+        for insert in inserts.requests {
+            let region_id = RegionId::from_u64(insert.region_id);
+            if self.is_partition_expr_unchanged(region_id, insert.partition_expr_version) {
+                bodies.push(Body::Inserts(InsertRequests {
+                    requests: vec![insert],
+                }));
+                continue;
+            }
+            let rows = insert.rows.context(error::UnexpectedSnafu {
+                violated: "Cannot rebuild an insert without rows",
+            })?;
+            for request in self.partition_insert_requests(rows, insert.skip_wal)? {
+                bodies.push(Body::Inserts(InsertRequests {
+                    requests: vec![request],
+                }));
+            }
+        }
+        Ok(bodies)
+    }
+
+    fn rebuild_delete_requests(&self, deletes: DeleteRequests) -> Result<Vec<Body>> {
+        let mut bodies = Vec::new();
+        for delete in deletes.requests {
+            let region_id = RegionId::from_u64(delete.region_id);
+            if self.is_partition_expr_unchanged(region_id, delete.partition_expr_version) {
+                bodies.push(Body::Deletes(DeleteRequests {
+                    requests: vec![delete],
+                }));
+                continue;
+            }
+            let rows = delete.rows.context(error::UnexpectedSnafu {
+                violated: "Cannot rebuild a delete without rows",
+            })?;
+            for request in self.partition_delete_requests(rows)? {
+                bodies.push(Body::Deletes(DeleteRequests {
+                    requests: vec![request],
+                }));
+            }
+        }
+        Ok(bodies)
+    }
+
+    fn rebuild_bulk_insert_request(
+        &self,
+        bulk: BulkInsertRequest,
+        table_info: &TableInfo,
+    ) -> Result<Vec<Body>> {
+        let region_id = RegionId::from_u64(bulk.region_id);
+        if self.is_partition_expr_unchanged(region_id, bulk.partition_expr_version) {
+            return Ok(vec![Body::BulkInsert(bulk)]);
+        }
+        let bulk_insert_request::Body::ArrowIpc(ipc) =
+            bulk.body.context(error::UnexpectedSnafu {
+                violated: "Cannot rebuild a bulk insert without Arrow IPC data",
+            })?;
+        let batch = FlightDecoder::try_from_schema_bytes(&ipc.schema)
+            .and_then(|mut decoder| decoder.try_decode_record_batch(&ipc.data_header, &ipc.payload))
+            .map_err(BoxedError::new)
+            .context(error::ExternalSnafu)?;
+        let routing_batch = self.restore_partition_tags(&batch, table_info)?;
+        let masks = self
+            .rule
+            .split_record_batch(routing_batch.as_ref().unwrap_or(&batch))
+            .context(SplitInsertSnafu)?;
+        Ok(self
+            .build_bulk_insert_requests(batch, masks, Some(ipc), bulk.skip_wal)?
+            .into_iter()
+            .map(Body::BulkInsert)
+            .collect())
+    }
+
+    /// Restores omitted physical-table tags for routing without changing the write payload.
+    fn restore_partition_tags(
+        &self,
+        batch: &RecordBatch,
+        table_info: &TableInfo,
+    ) -> Result<Option<RecordBatch>> {
+        let meta = &table_info.meta;
+        if !table_info.is_physical_table() || meta.column_ids.len() != meta.schema.num_columns() {
+            return Ok(None);
+        }
+        let missing = self
+            .rule
+            .partition_columns()
+            .iter()
+            .filter(|name| batch.column_by_name(name).is_none())
+            .filter_map(|name| {
+                let index = meta.schema.column_index_by_name(name)?;
+                (meta.primary_key_indices.contains(&index)
+                    && meta.schema.column_schemas()[index].data_type.is_string())
+                .then_some((name, meta.column_ids[index]))
+            })
+            .collect::<Vec<_>>();
+        if missing.is_empty() {
+            return Ok(None);
+        }
+        let Some(primary_key) = batch.column_by_name(consts::PRIMARY_KEY_COLUMN_NAME) else {
+            return Ok(None);
+        };
+        let primary_key =
+            primary_key
+                .as_any()
+                .downcast_ref::<BinaryArray>()
+                .context(error::UnexpectedSnafu {
+                    violated: "Sparse primary key column must be Binary",
+                })?;
+        let mut builders = missing
+            .iter()
+            .map(|_| StringBuilder::new())
+            .collect::<Vec<_>>();
+        let mut cache = SparseOffsetsCache::new();
+        let mut buffer = Vec::new();
+        for row in 0..batch.num_rows() {
+            ensure!(
+                !primary_key.is_null(row),
+                error::UnexpectedSnafu {
+                    violated: "Sparse primary key must not be null",
+                }
+            );
+            let mut key = SparsePrimaryKeyView::new(primary_key.value(row), &mut cache)
+                .map_err(BoxedError::new)
+                .context(error::ExternalSnafu)?;
+            for ((_, column_id), builder) in missing.iter().zip(&mut builders) {
+                let label = key
+                    .label(*column_id, &mut buffer)
+                    .map_err(BoxedError::new)
+                    .context(error::ExternalSnafu)?;
+                builder.append_option(label);
+            }
+        }
+        let schema = batch.schema();
+        let mut fields = schema.fields().to_vec();
+        let mut columns = batch.columns().to_vec();
+        for ((name, _), mut builder) in missing.into_iter().zip(builders) {
+            fields.push(Arc::new(Field::new(name, DataType::Utf8, true)));
+            columns.push(Arc::new(builder.finish()));
+        }
+        RecordBatch::try_new(
+            Arc::new(Schema::new_with_metadata(fields, schema.metadata().clone())),
+            columns,
+        )
+        .map(Some)
+        .context(error::ComputeArrowSnafu)
+    }
+
+    /// Whether the request's region still exists with the same partition expression version.
+    ///
+    /// A leader change leaves the partition unchanged, so the original payload can be
+    /// sent to the new peer. A removed region or changed partition expression version
+    /// requires rebuilding the request using this snapshot's partition rule.
+    fn is_partition_expr_unchanged(
+        &self,
+        region_id: RegionId,
+        version: Option<PartitionExprVersion>,
+    ) -> bool {
+        region_id.table_id() == self.table_id
+            && self.versions.get(&region_id.region_number()) == Some(&version)
+    }
+
+    fn version(&self, region: RegionNumber) -> Option<PartitionExprVersion> {
+        self.versions.get(&region).copied().flatten()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use api::v1::region::{
+        AlignedSchemaVersion, BulkInsertRequest, DeleteRequest, InsertRequest, RegionRequestHeader,
+    };
+    use api::v1::value::ValueData;
+    use api::v1::{ArrowIpc, PartitionExprVersion};
+    use api::v1::{ColumnDataType, ColumnSchema, Row, Rows, Value};
+    use common_error::ext::{ErrorExt, RetryHint};
+    use common_error::status_code::StatusCode;
+    use common_grpc::flight;
+    use common_meta::cache::{self, TableInfoCache};
+    use common_meta::key::TableMetadataManager;
+    use common_meta::key::table_route::TableRouteValue;
+    use common_meta::kv_backend::memory::MemoryKvBackend;
+    use common_meta::kv_backend::test_util::MockKvBackendBuilder;
+    use common_meta::rpc::router::{Region, RegionRoute};
+    use common_meta::rpc::store::RangeResponse;
+    use datatypes::arrow::array::{Int32Array, StringArray};
+    use datatypes::arrow::datatypes::{DataType, Field, Schema};
+    use datatypes::arrow::record_batch::RecordBatch;
+    use datatypes::data_type::ConcreteDataType;
+    use datatypes::schema;
+    use datatypes::value::{Value as DataValue, ValueRef};
+    use mito_codec::row_converter::sparse;
+    use mito_codec::row_converter::{PrimaryKeyCodec, SparsePrimaryKeyCodec};
+    use moka::future::Cache;
+    use partition::expr;
+    use partition::manager::{PartitionRuleManager, PartitionRuleManagerRef};
+    use partition::multi_dim::MultiDimPartitionRule;
+    use store_api::metric_engine_consts;
+
+    use super::*;
+    use crate::error::Error;
+    use crate::test_util;
+    use crate::test_util::{test_new_partition_info_cache, test_new_table_route_cache};
+
+    fn build_sparse_partitioner() -> TablePartitioner {
+        TablePartitioner {
+            table_id: 1,
+            rule: Arc::new(
+                MultiDimPartitionRule::try_new(
+                    vec!["zone".to_string()],
+                    vec![1, 2],
+                    vec![
+                        expr::col("zone").lt(DataValue::String("m".into())),
+                        expr::col("zone").gt_eq(DataValue::String("m".into())),
+                    ],
+                    true,
+                )
+                .unwrap(),
+            ),
+            versions: [
+                (1, Some(PartitionExprVersion { value: 2 })),
+                (2, Some(PartitionExprVersion { value: 2 })),
+            ]
+            .into_iter()
+            .collect(),
+        }
+    }
+
+    fn build_sparse_table_info() -> TableInfo {
+        let mut table_info = test_util::new_test_table_info(1, "physical_tags", [1, 2].into_iter());
+        table_info.meta.schema = Arc::new(schema::Schema::new(vec![
+            schema::ColumnSchema::new("host", ConcreteDataType::string_datatype(), true),
+            schema::ColumnSchema::new("zone", ConcreteDataType::string_datatype(), true),
+        ]));
+        table_info.meta.primary_key_indices = vec![0, 1];
+        table_info.meta.partition_key_indices = vec![1];
+        table_info.meta.column_ids = vec![10, 20];
+        table_info.meta.options.extra_options.insert(
+            metric_engine_consts::PHYSICAL_TABLE_METADATA_KEY.to_string(),
+            String::new(),
+        );
+        table_info
+    }
+
+    fn build_sparse_batch() -> RecordBatch {
+        let codec = SparsePrimaryKeyCodec::schemaless();
+        let keys = [Some("east"), Some("west"), Some(""), None, None]
+            .into_iter()
+            .enumerate()
+            .map(|(index, zone)| {
+                let mut key = Vec::new();
+                let values = [
+                    (
+                        sparse::RESERVED_COLUMN_ID_TABLE_ID,
+                        ValueRef::UInt32(42 + index as u32),
+                    ),
+                    (
+                        sparse::RESERVED_COLUMN_ID_TSID,
+                        ValueRef::UInt64(index as u64),
+                    ),
+                    (10, ValueRef::String("node")),
+                ];
+                codec.encode_value_refs(&values, &mut key).unwrap();
+                if let Some(zone) = zone {
+                    codec
+                        .encode_raw_tag_value([(20, zone.as_bytes())].into_iter(), &mut key)
+                        .unwrap();
+                }
+                if index == 4 {
+                    key.extend_from_slice(&20_u32.to_be_bytes());
+                    key.push(0);
+                }
+                key
+            })
+            .collect::<Vec<_>>();
+        RecordBatch::try_new(
+            Arc::new(Schema::new(vec![
+                Field::new("host", DataType::Utf8, false),
+                Field::new(consts::PRIMARY_KEY_COLUMN_NAME, DataType::Binary, false),
+            ])),
+            vec![
+                Arc::new(StringArray::from(vec!["node"; keys.len()])),
+                Arc::new(BinaryArray::from_iter_values(keys.iter())),
+            ],
+        )
+        .unwrap()
+    }
+
+    #[tokio::test]
+    async fn test_partition_tags_use_physical_table_metadata() {
+        let backend = Arc::new(MemoryKvBackend::new());
+        let table_route_cache = test_new_table_route_cache(backend.clone());
+        let partition_info_cache = test_new_partition_info_cache(table_route_cache.clone());
+        let manager =
+            PartitionRuleManager::new(backend.clone(), table_route_cache, partition_info_cache);
+        let table_info = build_sparse_table_info();
+        let routes = [
+            expr::col("zone").lt(DataValue::String("m".into())),
+            expr::col("zone").gt_eq(DataValue::String("m".into())),
+        ]
+        .into_iter()
+        .enumerate()
+        .map(|(index, expr)| RegionRoute {
+            region: Region {
+                id: RegionId::new(1, index as u32 + 1),
+                partition_expr: expr.as_json_str().unwrap(),
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .collect();
+        TableMetadataManager::new(backend)
+            .create_table_metadata(
+                table_info.clone(),
+                TableRouteValue::physical(routes),
+                Default::default(),
+            )
+            .await
+            .unwrap();
+        let batch = build_sparse_batch();
+        let partitioner = TablePartitioner::try_new(&manager, &table_info)
+            .await
+            .unwrap();
+        let restored = partitioner
+            .restore_partition_tags(&batch, &table_info)
+            .unwrap()
+            .unwrap();
+        let zones = restored
+            .column_by_name("zone")
+            .unwrap()
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+        assert_eq!(
+            zones.iter().collect::<Vec<_>>(),
+            vec![Some("east"), Some("west"), Some(""), None, None]
+        );
+
+        for (physical, tag, valid_ids) in [
+            (false, true, true),
+            (true, false, true),
+            (true, true, false),
+        ] {
+            let mut info = table_info.clone();
+            if !physical {
+                info.meta
+                    .options
+                    .extra_options
+                    .remove(metric_engine_consts::PHYSICAL_TABLE_METADATA_KEY);
+            }
+            if !tag {
+                info.meta.primary_key_indices = vec![0];
+            }
+            if !valid_ids {
+                info.meta.column_ids.clear();
+            }
+            let partitioner = TablePartitioner::try_new(&manager, &info).await.unwrap();
+            assert!(
+                partitioner
+                    .restore_partition_tags(&batch, &info)
+                    .unwrap()
+                    .is_none()
+            );
+            assert!(
+                partitioner
+                    .partition_bulk_insert_requests(batch.clone(), None, false)
+                    .is_err()
+            );
+        }
+    }
+
+    #[test]
+    fn test_rebuild_sparse_bulk_with_changed_partition_column() {
+        let partitioner = build_sparse_partitioner();
+        let table_info = build_sparse_table_info();
+        let batch = build_sparse_batch();
+        let restored = partitioner
+            .restore_partition_tags(&batch, &table_info)
+            .unwrap()
+            .unwrap();
+        let zones = restored
+            .column_by_name("zone")
+            .unwrap()
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+        assert_eq!(
+            zones.iter().collect::<Vec<_>>(),
+            vec![Some("east"), Some("west"), Some(""), None, None]
+        );
+        let (schema, data_header, payload) = flight::record_batch_to_ipc(batch.clone()).unwrap();
+        let rebuilt = partitioner
+            .rebuild_write_requests(
+                build_request(Body::BulkInsert(BulkInsertRequest {
+                    region_id: RegionId::new(1, 1).as_u64(),
+                    partition_expr_version: Some(PartitionExprVersion { value: 1 }),
+                    skip_wal: true,
+                    body: Some(bulk_insert_request::Body::ArrowIpc(ArrowIpc {
+                        schema,
+                        data_header,
+                        payload,
+                    })),
+                    ..Default::default()
+                })),
+                &table_info,
+            )
+            .unwrap();
+        assert_eq!(rebuilt.len(), 2);
+        for request in rebuilt {
+            let Some(Body::BulkInsert(bulk)) = request.body else {
+                unreachable!()
+            };
+            assert!(bulk.skip_wal);
+            assert_eq!(
+                bulk.partition_expr_version,
+                Some(PartitionExprVersion { value: 2 })
+            );
+            let Some(bulk_insert_request::Body::ArrowIpc(ipc)) = bulk.body else {
+                unreachable!()
+            };
+            let actual = FlightDecoder::try_from_schema_bytes(&ipc.schema)
+                .unwrap()
+                .try_decode_record_batch(&ipc.data_header, &ipc.payload)
+                .unwrap();
+            let mask = if RegionId::from_u64(bulk.region_id).region_number() == 1 {
+                vec![true, false, true, true, true]
+            } else {
+                vec![false, true, false, false, false]
+            };
+            let expected = compute::filter_record_batch(&batch, &mask.into()).unwrap();
+            assert_eq!(actual, expected);
+        }
+    }
+
+    #[test]
+    fn test_restore_partition_tags_checks_only_missing_tags() {
+        let partitioner = build_sparse_partitioner();
+        let table_info = build_sparse_table_info();
+        let batch = build_sparse_batch();
+        let invalid = RecordBatch::try_new(
+            batch.schema(),
+            vec![
+                batch.column(0).clone(),
+                Arc::new(BinaryArray::from_iter_values([b"invalid"; 5])),
+            ],
+        )
+        .unwrap();
+        assert!(
+            partitioner
+                .restore_partition_tags(&invalid, &table_info)
+                .is_err()
+        );
+        let mut fields = invalid.schema().fields().to_vec();
+        fields.push(Arc::new(Field::new("zone", DataType::Utf8, true)));
+        let mut columns = invalid.columns().to_vec();
+        columns.push(Arc::new(StringArray::from(vec![Some("east"); 5])));
+        let complete = RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).unwrap();
+        assert!(
+            partitioner
+                .restore_partition_tags(&complete, &table_info)
+                .unwrap()
+                .is_none()
+        );
+        let (schema, data_header, payload) = flight::record_batch_to_ipc(invalid).unwrap();
+        let request = build_request(Body::BulkInsert(BulkInsertRequest {
+            region_id: RegionId::new(1, 1).as_u64(),
+            partition_expr_version: Some(PartitionExprVersion { value: 2 }),
+            body: Some(bulk_insert_request::Body::ArrowIpc(ArrowIpc {
+                schema,
+                data_header,
+                payload,
+            })),
+            ..Default::default()
+        }));
+        let expected = request.clone();
+        assert_eq!(
+            partitioner
+                .rebuild_write_requests(request, &table_info)
+                .unwrap(),
+            vec![expected]
+        );
+    }
+
+    #[tokio::test]
+    async fn test_partition_requests_preserve_routing_errors() {
+        let table_info = test_util::new_test_table_info(1, "table_1", [1].into_iter());
+        for (backend_unavailable, expected_status, expected_hint) in [
+            (false, StatusCode::TableNotFound, RetryHint::NonRetryable),
+            (true, StatusCode::Internal, RetryHint::Retryable),
+        ] {
+            let backend = Arc::new(
+                MockKvBackendBuilder::default()
+                    .range_fn(Arc::new(move |_| {
+                        if backend_unavailable {
+                            common_meta::error::NoLeaderSnafu { table_id: 1u32 }.fail()
+                        } else {
+                            Ok(RangeResponse {
+                                kvs: Vec::new(),
+                                more: false,
+                            })
+                        }
+                    }))
+                    .build()
+                    .unwrap(),
+            );
+            let routes = Arc::new(cache::new_table_route_cache(
+                "partitioner_test_routes".to_string(),
+                Cache::new(16),
+                backend.clone(),
+            ));
+            let partitions = Arc::new(partition::cache::new_partition_info_cache(
+                "partitioner_test_partitions".to_string(),
+                Cache::new(16),
+                routes.clone(),
+            ));
+            let manager = PartitionRuleManager::new(backend, routes, partitions);
+            let partitioner = Partitioner::new(&manager);
+            let insert_error = partitioner
+                .partition_insert_requests(&table_info, Rows::default(), false)
+                .await
+                .unwrap_err();
+            let delete_error = partitioner
+                .partition_delete_requests(&table_info, Rows::default())
+                .await
+                .unwrap_err();
+
+            assert!(matches!(insert_error, Error::SplitInsert { .. }));
+            assert!(matches!(delete_error, Error::SplitDelete { .. }));
+            for error in [insert_error, delete_error] {
+                assert_eq!(error.status_code(), expected_status);
+                assert_eq!(error.retry_hint(), expected_hint);
+            }
+        }
+    }
+
+    async fn create_fixture() -> (PartitionRuleManagerRef, TableInfoCache) {
+        let backend = Arc::new(MemoryKvBackend::new());
+        let manager = test_util::create_partition_rule_manager(backend.clone()).await;
+        TableMetadataManager::new(backend.clone())
+            .create_table_metadata(
+                test_util::new_test_table_info(42, "logical_reroute", [1, 2, 3].into_iter()),
+                TableRouteValue::logical(1),
+                Default::default(),
+            )
+            .await
+            .unwrap();
+        let cache = cache::new_table_info_cache(
+            "reroute_test_table_info".to_string(),
+            Cache::new(16),
+            backend,
+        );
+        (manager, cache)
+    }
+
+    fn build_request(body: Body) -> RegionRequest {
+        RegionRequest {
+            header: Some(RegionRequestHeader {
+                dbname: "greptime.public".to_string(),
+                ..Default::default()
+            }),
+            body: Some(body),
+        }
+    }
+
+    fn build_rows(values: &[i32]) -> Rows {
+        Rows {
+            schema: vec![ColumnSchema {
+                column_name: "a".to_string(),
+                datatype: ColumnDataType::Int32 as i32,
+                ..Default::default()
+            }],
+            rows: values
+                .iter()
+                .map(|value| Row {
+                    values: vec![Value {
+                        value_data: Some(ValueData::I32Value(*value)),
+                    }],
+                })
+                .collect(),
+        }
+    }
+
+    fn build_row_request(
+        rows: Rows,
+        insert: bool,
+        region: u32,
+        version: Option<u64>,
+    ) -> RegionRequest {
+        let region_id = RegionId::new(1, region).as_u64();
+        let partition_expr_version = version.map(|value| PartitionExprVersion { value });
+        let body = if insert {
+            Body::Inserts(InsertRequests {
+                requests: vec![InsertRequest {
+                    region_id,
+                    partition_expr_version,
                     rows: Some(rows),
-                    partition_expr_version: partition_expr_version
-                        .map(|value| PartitionExprVersion { value }),
-                },
-            )
-            .collect();
-        Ok(requests)
+                    skip_wal: true,
+                }],
+            })
+        } else {
+            Body::Deletes(DeleteRequests {
+                requests: vec![DeleteRequest {
+                    region_id,
+                    partition_expr_version,
+                    rows: Some(rows),
+                }],
+            })
+        };
+        build_request(body)
+    }
+
+    fn row_request_parts(request: &RegionRequest) -> (u64, Option<u64>, &Rows) {
+        match request.body.as_ref().unwrap() {
+            Body::Inserts(inserts) => {
+                assert_eq!(inserts.requests.len(), 1);
+                let insert = &inserts.requests[0];
+                assert!(insert.skip_wal);
+                (
+                    insert.region_id,
+                    insert.partition_expr_version.map(|v| v.value),
+                    insert.rows.as_ref().unwrap(),
+                )
+            }
+            Body::Deletes(deletes) => {
+                assert_eq!(deletes.requests.len(), 1);
+                let delete = &deletes.requests[0];
+                (
+                    delete.region_id,
+                    delete.partition_expr_version.map(|v| v.value),
+                    delete.rows.as_ref().unwrap(),
+                )
+            }
+            _ => panic!("expected row write"),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_rebuild_rows_updates_partitions_without_losing_rows() {
+        let (manager, cache) = create_fixture().await;
+        let table_info = cache.get(1).await.unwrap().unwrap();
+        let (_, versions) = manager
+            .find_table_partition_rule(&table_info)
+            .await
+            .unwrap();
+        for insert in [true, false] {
+            let request = build_row_request(build_rows(&[1, 20, 70]), insert, 99, Some(0));
+            let header = request.header.clone();
+            let rerouted = rebuild_with_cached_table(&manager, &cache, request)
+                .await
+                .unwrap();
+            assert_eq!(rerouted.len(), 3);
+            let mut actual = Vec::new();
+            for request in rerouted {
+                assert_eq!(request.header, header);
+                let (id, version, rows) = row_request_parts(&request);
+                let region_id = RegionId::from_u64(id);
+                assert_eq!(region_id.table_id(), 1);
+                assert_eq!(version, versions[&region_id.region_number()]);
+                assert_eq!(rows.schema, build_rows(&[]).schema);
+                assert_eq!(rows.rows.len(), 1);
+                actual.push((region_id.region_number(), rows.rows[0].clone()));
+            }
+            actual.sort_by_key(|(region, _)| *region);
+            assert_eq!(
+                actual,
+                vec![
+                    (1, build_rows(&[70]).rows.remove(0)),
+                    (2, build_rows(&[20]).rows.remove(0)),
+                    (3, build_rows(&[1]).rows.remove(0))
+                ]
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn test_unchanged_row_routes_preserve_allocations() {
+        let (manager, cache) = create_fixture().await;
+        let table_info = cache.get(1).await.unwrap().unwrap();
+        let (_, versions) = manager
+            .find_table_partition_rule(&table_info)
+            .await
+            .unwrap();
+        for insert in [true, false] {
+            let request = build_row_request(build_rows(&[1]), insert, 3, versions[&3]);
+            let original_rows = row_request_parts(&request).2;
+            let row_ptr = original_rows.rows.as_ptr();
+            let value_ptr = original_rows.rows[0].values.as_ptr();
+            let rerouted = rebuild_with_cached_table(&manager, &cache, request)
+                .await
+                .unwrap();
+            assert_eq!(rerouted.len(), 1);
+            let rows = row_request_parts(&rerouted[0]).2;
+            assert_eq!(rows.rows.as_ptr(), row_ptr);
+            assert_eq!(rows.rows[0].values.as_ptr(), value_ptr);
+            assert_eq!(rows, &build_rows(&[1]));
+        }
+    }
+
+    fn build_bulk_request(region: u32, version: Option<u64>, values: Vec<i32>) -> RegionRequest {
+        let batch = RecordBatch::try_new(
+            Arc::new(Schema::new(vec![Field::new("a", DataType::Int32, false)])),
+            vec![Arc::new(Int32Array::from(values))],
+        )
+        .unwrap();
+        let (schema, data_header, payload) = flight::record_batch_to_ipc(batch).unwrap();
+        build_request(Body::BulkInsert(BulkInsertRequest {
+            region_id: RegionId::new(1, region).as_u64(),
+            partition_expr_version: version.map(|value| PartitionExprVersion { value }),
+            aligned_schema_version: Some(AlignedSchemaVersion {
+                schema_version: 123,
+            }),
+            skip_wal: true,
+            body: Some(bulk_insert_request::Body::ArrowIpc(ArrowIpc {
+                schema,
+                data_header,
+                payload,
+            })),
+        }))
+    }
+
+    #[tokio::test]
+    async fn test_rebuild_bulk_reencodes_only_changed_partitions() {
+        let (manager, cache) = create_fixture().await;
+        let table_info = cache.get(1).await.unwrap().unwrap();
+        let (_, versions) = manager
+            .find_table_partition_rule(&table_info)
+            .await
+            .unwrap();
+        let request = build_bulk_request(99, Some(0), vec![1, 20, 70]);
+        let header = request.header.clone();
+        let rerouted = rebuild_with_cached_table(&manager, &cache, request)
+            .await
+            .unwrap();
+        assert_eq!(rerouted.len(), 3);
+        let mut actual = Vec::new();
+        for request in rerouted {
+            assert_eq!(request.header, header);
+            let Some(Body::BulkInsert(bulk)) = request.body else {
+                panic!("expected bulk insert")
+            };
+            let region = RegionId::from_u64(bulk.region_id);
+            assert_eq!(region.table_id(), 1);
+            assert!(bulk.skip_wal);
+            assert_eq!(bulk.aligned_schema_version, None);
+            assert_eq!(
+                bulk.partition_expr_version.map(|v| v.value),
+                versions[&region.region_number()]
+            );
+            let Some(bulk_insert_request::Body::ArrowIpc(ipc)) = bulk.body else {
+                panic!("expected Arrow IPC")
+            };
+            let batch = FlightDecoder::try_from_schema_bytes(&ipc.schema)
+                .unwrap()
+                .try_decode_record_batch(&ipc.data_header, &ipc.payload)
+                .unwrap();
+            assert_eq!(batch.num_rows(), 1);
+            let values = batch
+                .column(0)
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .unwrap();
+            actual.push((region.region_number(), values.value(0)));
+        }
+        actual.sort_unstable();
+        assert_eq!(actual, [(1, 70), (2, 20), (3, 1)]);
+
+        // A leader-only change retains the original IPC buffers and schema hint.
+        let request = build_bulk_request(3, versions[&3], vec![1]);
+        let Some(Body::BulkInsert(bulk)) = request.body.as_ref() else {
+            unreachable!()
+        };
+        let Some(bulk_insert_request::Body::ArrowIpc(ipc)) = &bulk.body else {
+            unreachable!()
+        };
+        let pointers = (
+            ipc.schema.as_ptr(),
+            ipc.data_header.as_ptr(),
+            ipc.payload.as_ptr(),
+        );
+        let rerouted = rebuild_with_cached_table(&manager, &cache, request)
+            .await
+            .unwrap();
+        assert_eq!(rerouted.len(), 1);
+        let Some(Body::BulkInsert(bulk)) = rerouted[0].body.as_ref() else {
+            unreachable!()
+        };
+        assert_eq!(
+            bulk.aligned_schema_version,
+            Some(AlignedSchemaVersion {
+                schema_version: 123
+            })
+        );
+        let Some(bulk_insert_request::Body::ArrowIpc(ipc)) = &bulk.body else {
+            unreachable!()
+        };
+        assert_eq!(
+            (
+                ipc.schema.as_ptr(),
+                ipc.data_header.as_ptr(),
+                ipc.payload.as_ptr()
+            ),
+            pointers
+        );
+    }
+
+    #[tokio::test]
+    async fn test_rebuild_logical_table_preserves_logical_region_ids() {
+        let (manager, cache) = create_fixture().await;
+        for insert in [true, false] {
+            let mut request = build_row_request(build_rows(&[1, 20, 70]), insert, 99, Some(0));
+            match request.body.as_mut().unwrap() {
+                Body::Inserts(inserts) => {
+                    inserts.requests[0].region_id = RegionId::new(42, 99).as_u64()
+                }
+                Body::Deletes(deletes) => {
+                    deletes.requests[0].region_id = RegionId::new(42, 99).as_u64()
+                }
+                _ => unreachable!(),
+            }
+            let rerouted = rebuild_with_cached_table(&manager, &cache, request)
+                .await
+                .unwrap();
+            assert_eq!(rerouted.len(), 3);
+            let mut regions = rerouted
+                .iter()
+                .map(|request| {
+                    let region = RegionId::from_u64(row_request_parts(request).0);
+                    assert_eq!(region.table_id(), 42);
+                    region.region_number()
+                })
+                .collect::<Vec<_>>();
+            regions.sort_unstable();
+            assert_eq!(regions, [1, 2, 3]);
+        }
+    }
+
+    async fn rebuild_with_cached_table(
+        manager: &PartitionRuleManager,
+        cache: &TableInfoCache,
+        request: RegionRequest,
+    ) -> Result<Vec<RegionRequest>> {
+        let region_id = match request.body.as_ref().unwrap() {
+            Body::Inserts(inserts) => inserts.requests[0].region_id,
+            Body::Deletes(deletes) => deletes.requests[0].region_id,
+            Body::BulkInsert(bulk) => bulk.region_id,
+            _ => unreachable!(),
+        };
+        let table_id = RegionId::from_u64(region_id).table_id();
+        let table_info = cache.get(table_id).await.unwrap().unwrap();
+        let partitioner = TablePartitioner::try_new(manager, &table_info)
+            .await
+            .context(error::InvalidPartitionSnafu)?;
+        partitioner.rebuild_write_requests(request, &table_info)
     }
 }
diff --git a/src/operator/src/test_util.rs b/src/operator/src/test_util.rs
index aa4a2f30ab8..436c1bbd7b5 100644
--- a/src/operator/src/test_util.rs
+++ b/src/operator/src/test_util.rs
@@ -17,3 +17,8 @@ mod partition_manager;
 
 pub use crate::test_util::kv_backend::prepare_mocked_backend;
 pub use crate::test_util::partition_manager::{create_partition_rule_manager, new_test_table_info};
+
+#[cfg(test)]
+pub(crate) use self::partition_manager::{
+    test_new_partition_info_cache, test_new_table_route_cache,
+};
diff --git a/src/operator/src/test_util/partition_manager.rs b/src/operator/src/test_util/partition_manager.rs
index e51ac49051e..260252d2da5 100644
--- a/src/operator/src/test_util/partition_manager.rs
+++ b/src/operator/src/test_util/partition_manager.rs
@@ -113,7 +113,7 @@ fn new_test_region_wal_options(regions: Vec<RegionNumber>) -> RegionWalOptions {
     HashMap::default()
 }
 
-fn test_new_table_route_cache(kv_backend: KvBackendRef) -> TableRouteCacheRef {
+pub(crate) fn test_new_table_route_cache(kv_backend: KvBackendRef) -> TableRouteCacheRef {
     let cache = CacheBuilder::new(128).build();
     Arc::new(new_table_route_cache(
         "table_route_cache".to_string(),
@@ -122,7 +122,9 @@ fn test_new_table_route_cache(kv_backend: KvBackendRef) -> TableRouteCacheRef {
     ))
 }
 
-fn test_new_partition_info_cache(table_route_cache: TableRouteCacheRef) -> PartitionInfoCacheRef {
+pub(crate) fn test_new_partition_info_cache(
+    table_route_cache: TableRouteCacheRef,
+) -> PartitionInfoCacheRef {
     let cache = CacheBuilder::new(128).build();
     Arc::new(new_partition_info_cache(
         "partition_info_cache".to_string(),
@@ -368,3 +370,127 @@ async fn test_logical_split_rows_rejects_physical_only_partition_column() {
         partition::error::Error::UndefinedColumn { ref column, .. } if column == "b"
     ));
 }
+
+#[tokio::test]
+async fn test_partition_routing_with_empty_default_expression() {
+    use datatypes::arrow::array::{ArrayRef, RecordBatch, StringArray};
+    use datatypes::value::Value;
+    use partition::expr::col;
+    use store_api::storage::RegionId;
+
+    for (transition, target_count) in [(true, 1), (true, 3), (false, 3)] {
+        let backend = Arc::new(common_meta::kv_backend::memory::MemoryKvBackend::new());
+        let route_cache = test_new_table_route_cache(backend.clone());
+        let manager = PartitionRuleManager::new(
+            backend.clone(),
+            route_cache.clone(),
+            test_new_partition_info_cache(route_cache),
+        );
+        let value = |s: &str| Value::String(s.into());
+        let mut exprs = vec![
+            col("host").lt(value("36z0")),
+            col("host")
+                .gt_eq(value("36z0"))
+                .and(col("host").lt(value("7Ez0"))),
+            col("host")
+                .gt_eq(value("7Ez0"))
+                .and(col("host").lt(value("BMz0"))),
+            col("host").gt_eq(value("BMz0")),
+        ];
+        if target_count == 1 {
+            exprs = vec![
+                col("host").lt(value("36z0")),
+                col("host").gt_eq(value("36z0")),
+            ];
+        }
+        let routes = exprs
+            .into_iter()
+            .enumerate()
+            .map(|(i, expr)| RegionRoute {
+                region: Region {
+                    id: RegionId::new(1027, i as u32),
+                    partition_expr: if transition && i == 0 {
+                        String::new()
+                    } else {
+                        expr.as_json_str().unwrap()
+                    },
+                    ..Default::default()
+                },
+                leader_peer: Some(Peer::new(1, "")),
+                ..Default::default()
+            })
+            .collect();
+        let info = new_test_table_info_with_columns(
+            1027,
+            "physical",
+            vec![
+                ColumnSchema::new("host", ConcreteDataType::string_datatype(), true),
+                ColumnSchema::new(
+                    "ts",
+                    ConcreteDataType::timestamp_millisecond_datatype(),
+                    false,
+                )
+                .with_time_index(true),
+            ],
+            vec![0],
+        );
+        let metadata_manager = TableMetadataManager::new(backend);
+        metadata_manager
+            .create_table_metadata(
+                info.clone(),
+                TableRouteValue::physical(routes),
+                new_test_region_wal_options((0..=target_count).collect()),
+            )
+            .await
+            .unwrap();
+        let mut logical_info = info.clone();
+        logical_info.ident.table_id = 1028;
+        logical_info.name = "logical".into();
+        metadata_manager
+            .create_table_metadata(
+                logical_info.clone(),
+                TableRouteValue::logical(1027),
+                HashMap::new(),
+            )
+            .await
+            .unwrap();
+
+        let hosts = [None, Some("1"), Some("5"), Some("8"), Some("animi")];
+        let expected_regions = if target_count == 1 {
+            [0, 0, 1, 1, 1]
+        } else {
+            [0, 0, 1, 2, 3]
+        };
+        let batch = RecordBatch::try_from_iter([(
+            "host",
+            Arc::new(StringArray::from(hosts.to_vec())) as ArrayRef,
+        )])
+        .unwrap();
+        for table_info in [&info, &logical_info] {
+            let (rule, _) = manager.find_table_partition_rule(table_info).await.unwrap();
+            for (host, expected) in hosts.into_iter().zip(expected_regions) {
+                assert_eq!(
+                    rule.find_region(&[host.map(value).unwrap_or(Value::Null)])
+                        .unwrap(),
+                    expected
+                );
+            }
+            let splits = rule.split_record_batch(&batch).unwrap();
+            assert_eq!(splits.len(), target_count as usize + 1);
+            for (region, mask) in splits {
+                let selected = mask
+                    .array()
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(i, selected)| (selected == Some(true)).then_some(i))
+                    .collect::<Vec<_>>();
+                let expected = expected_regions
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(i, expected)| (*expected == region).then_some(i))
+                    .collect::<Vec<_>>();
+                assert_eq!(selected, expected);
+            }
+        }
+    }
+}
diff --git a/src/operator/src/write_dispatcher.rs b/src/operator/src/write_dispatcher.rs
new file mode 100644
index 00000000000..9a042cfb4e7
--- /dev/null
+++ b/src/operator/src/write_dispatcher.rs
@@ -0,0 +1,662 @@
+// 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 options;
+#[cfg(test)]
+mod tests;
+
+use std::collections::{HashMap, HashSet, hash_map::Entry};
+use std::sync::Arc;
+
+use api::region::RegionResponse;
+use api::v1::region::{DeleteRequests, InsertRequests, RegionRequest, region_request::Body};
+use backon::{BackoffBuilder, ExponentialBuilder};
+use catalog::CatalogManagerRef;
+use common_error::ext::{BoxedError, ErrorExt, RetryHint};
+use common_meta::cache_invalidator::{CacheInvalidatorRef, Context};
+use common_meta::error::{Error, ExternalSnafu, Result, TableInfoNotFoundSnafu, UnexpectedSnafu};
+use common_meta::instruction::CacheIdent;
+use common_meta::node_manager::NodeManagerRef;
+use common_meta::peer::{Peer, PeerRef};
+use common_meta::rpc::router;
+use futures::future;
+use partition::manager::{PartitionRuleManager, PartitionRuleManagerRef};
+use prometheus::Histogram;
+use snafu::{OptionExt, ResultExt, ensure};
+use store_api::storage::RegionId;
+use table::table_name::TableName;
+use tokio_util::sync::CancellationToken;
+
+pub use self::options::WriteRetryOptions;
+use crate::error::{self, FindRegionLeaderSnafu, RequestRegionSnafu};
+use crate::req_convert::TablePartitioner;
+
+/// Dispatches already partitioned writes, retaining only failed payloads for retries.
+pub struct WriteDispatcher {
+    node_manager: NodeManagerRef,
+    partition_manager: PartitionRuleManagerRef,
+    retry: Option<WriteRetry>,
+}
+
+/// Shared reference to a [`WriteDispatcher`].
+pub type WriteDispatcherRef = Arc<WriteDispatcher>;
+
+/// The result of one write RPC attempt.
+pub(crate) enum WriteAttempt {
+    Success(RegionResponse),
+    Failed {
+        error: Error,
+        /// Retained when retries are enabled and the original client error allows retry.
+        /// The remaining retry budget is checked separately.
+        request: Option<RoutedWrite>,
+    },
+}
+
+impl WriteDispatcher {
+    /// Creates an owned-request dispatcher without retries, including for standalone.
+    pub fn new(node_manager: NodeManagerRef, partition_manager: PartitionRuleManagerRef) -> Self {
+        Self {
+            node_manager,
+            partition_manager,
+            retry: None,
+        }
+    }
+
+    /// Enables shared remote sends and retries using frontend configuration and caches.
+    pub fn with_retry(
+        mut self,
+        options: WriteRetryOptions,
+        catalog_manager: CatalogManagerRef,
+        cache_invalidator: CacheInvalidatorRef,
+    ) -> Self {
+        if options.max_retries > 0 {
+            self.retry = Some(WriteRetry {
+                node_manager: self.node_manager.clone(),
+                partition_manager: self.partition_manager.clone(),
+                options,
+                catalog_manager,
+                cache_invalidator,
+            });
+        } else {
+            self.retry = None;
+        }
+        self
+    }
+
+    /// Writes planned requests without repeating admission, default values, or Flow side effects.
+    pub async fn dispatch(&self, requests: Vec<RegionRequest>) -> Result<RegionResponse> {
+        self.dispatch_inner(requests, None).await
+    }
+
+    /// Records each datanode send attempt, including retries, in the supplied histogram.
+    pub async fn dispatch_with_metrics(
+        &self,
+        requests: Vec<RegionRequest>,
+        histogram: Histogram,
+    ) -> Result<RegionResponse> {
+        self.dispatch_inner(requests, Some(histogram)).await
+    }
+
+    /// Resolves routes before writes are detached from the caller.
+    pub(crate) async fn prepare(
+        &self,
+        requests: Vec<RegionRequest>,
+    ) -> error::Result<Vec<(PeerRef, RegionRequest)>> {
+        let requests = requests
+            .into_iter()
+            .map(|mut request| {
+                let header = request.header.take();
+                (header, split_request(request))
+            })
+            .collect::<Vec<_>>();
+        let regions = requests
+            .iter()
+            .flat_map(|(_, requests)| requests)
+            .map(write_region_id)
+            .collect::<Result<Vec<_>>>()
+            .context(RequestRegionSnafu)?;
+        let peers = self
+            .resolve_peers(&regions)
+            .await
+            .context(FindRegionLeaderSnafu)?;
+        let mut writes = Vec::new();
+        // Preserve each original envelope and peer batching when retries are disabled.
+        for (header, requests) in requests {
+            let mut by_peer: HashMap<PeerRef, RegionRequest> = HashMap::new();
+            for request in requests {
+                let peer = get_peer(
+                    &peers,
+                    write_region_id(&request).context(RequestRegionSnafu)?,
+                )
+                .context(RequestRegionSnafu)?;
+                match by_peer.entry(peer) {
+                    Entry::Vacant(entry) => {
+                        entry.insert(request);
+                    }
+                    Entry::Occupied(mut entry) => match (&mut entry.get_mut().body, request.body) {
+                        (Some(Body::Inserts(existing)), Some(Body::Inserts(next))) => {
+                            existing.requests.extend(next.requests)
+                        }
+                        (Some(Body::Deletes(existing)), Some(Body::Deletes(next))) => {
+                            existing.requests.extend(next.requests)
+                        }
+                        _ => {
+                            return UnexpectedSnafu {
+                                err_msg: "Cannot combine different write kinds",
+                            }
+                            .fail()
+                            .context(RequestRegionSnafu);
+                        }
+                    },
+                }
+            }
+            for (peer, mut request) in by_peer {
+                request.header = header.clone();
+                writes.push((peer, request));
+            }
+        }
+        Ok(writes)
+    }
+
+    /// Sends requests using routes already resolved by the caller.
+    /// Cancellation stops future retries while allowing in-flight requests to complete.
+    pub(crate) async fn execute(
+        &self,
+        writes: Vec<(PeerRef, RegionRequest)>,
+        histogram: Option<Histogram>,
+        cancellation: Option<&CancellationToken>,
+    ) -> Result<RegionResponse> {
+        let histogram = histogram.as_ref();
+        let writes = if self.retry.is_some() {
+            writes
+                .into_iter()
+                .flat_map(|(peer, request)| {
+                    split_request(request)
+                        .into_iter()
+                        .map(move |request| (Arc::clone(&peer), request))
+                })
+                .collect()
+        } else {
+            writes
+        };
+        let attempts = future::join_all(
+            writes
+                .into_iter()
+                .map(|(peer, request)| self.send(peer, request, histogram)),
+        )
+        .await;
+        self.finish(attempts, histogram, cancellation).await
+    }
+
+    /// Sends the first attempt immediately so bulk encoding can overlap other sends.
+    pub(crate) async fn send(
+        &self,
+        peer: PeerRef,
+        request: RegionRequest,
+        histogram: Option<&Histogram>,
+    ) -> WriteAttempt {
+        if let Some(retry) = &self.retry {
+            return retry
+                .send(
+                    RoutedWrite {
+                        peer,
+                        request: Arc::new(request),
+                    },
+                    histogram,
+                )
+                .await;
+        }
+        let _timer = histogram.map(Histogram::start_timer);
+        let datanode = self.node_manager.datanode(&peer).await;
+        match datanode.handle(request).await {
+            Ok(response) => WriteAttempt::Success(response),
+            Err(error) => WriteAttempt::Failed {
+                error,
+                request: None,
+            },
+        }
+    }
+
+    /// Collects first attempts and retries their failures together, refreshing routes once per round.
+    pub(crate) async fn finish(
+        &self,
+        attempts: Vec<WriteAttempt>,
+        histogram: Option<&Histogram>,
+        cancellation: Option<&CancellationToken>,
+    ) -> Result<RegionResponse> {
+        if let Some(retry) = &self.retry {
+            if retry.should_retry(&attempts, 0) {
+                return retry.retry(attempts, histogram, cancellation).await;
+            }
+            let mut response = RegionResponse::new(0);
+            let failures = merge_attempts(attempts, &mut response)?;
+            return match failures.into_iter().next() {
+                Some((_, error)) => Err(error),
+                None => Ok(response),
+            };
+        }
+        let mut response = RegionResponse::new(0);
+        for attempt in attempts {
+            match attempt {
+                WriteAttempt::Success(result) => merge_response(&mut response, result),
+                WriteAttempt::Failed { error, .. } => return Err(error),
+            }
+        }
+        Ok(response)
+    }
+
+    /// Resolves only the requested peers, loading each table route once.
+    pub(crate) async fn resolve_peers(
+        &self,
+        regions: &[RegionId],
+    ) -> partition::error::Result<HashMap<RegionId, PeerRef>> {
+        resolve_peers(&self.partition_manager, regions).await
+    }
+
+    async fn dispatch_inner(
+        &self,
+        requests: Vec<RegionRequest>,
+        histogram: Option<Histogram>,
+    ) -> Result<RegionResponse> {
+        let writes = self
+            .prepare(requests)
+            .await
+            .map_err(BoxedError::new)
+            .context(ExternalSnafu)?;
+        self.execute(writes, histogram, None).await
+    }
+}
+
+/// Sends shared requests and coordinates retries with refreshed routes.
+struct WriteRetry {
+    node_manager: NodeManagerRef,
+    partition_manager: PartitionRuleManagerRef,
+    options: WriteRetryOptions,
+    catalog_manager: CatalogManagerRef,
+    cache_invalidator: CacheInvalidatorRef,
+}
+
+/// A single-region write request paired with its destination peer.
+pub(crate) struct RoutedWrite {
+    peer: PeerRef,
+    request: Arc<RegionRequest>,
+}
+
+impl WriteRetry {
+    async fn send(&self, write: RoutedWrite, histogram: Option<&Histogram>) -> WriteAttempt {
+        let _timer = histogram.map(Histogram::start_timer);
+        let requester = self.node_manager.datanode(&write.peer).await;
+        match requester.handle(Arc::clone(&write.request)).await {
+            Ok(response) => WriteAttempt::Success(response),
+            Err(error) => {
+                let request = error.retry_hint().is_retryable().then_some(write);
+                WriteAttempt::Failed { error, request }
+            }
+        }
+    }
+
+    fn should_retry(&self, attempts: &[WriteAttempt], retries: usize) -> bool {
+        if retries >= self.options.max_retries {
+            return false;
+        }
+        let mut retryable = false;
+        for attempt in attempts {
+            match attempt {
+                WriteAttempt::Success(_) => {}
+                WriteAttempt::Failed {
+                    request: Some(_), ..
+                } => retryable = true,
+                WriteAttempt::Failed { request: None, .. } => return false,
+            }
+        }
+        retryable
+    }
+
+    async fn retry(
+        &self,
+        mut attempts: Vec<WriteAttempt>,
+        histogram: Option<&Histogram>,
+        cancellation: Option<&CancellationToken>,
+    ) -> Result<RegionResponse> {
+        let mut response = RegionResponse::new(0);
+        let mut backoff = ExponentialBuilder::default()
+            .with_min_delay(self.options.initial_backoff)
+            .with_max_delay(self.options.max_backoff)
+            .with_factor(self.options.backoff_multiplier)
+            .with_max_times(self.options.max_retries)
+            .with_jitter()
+            .build();
+        let mut retries = 0;
+        while self.should_retry(&attempts, retries) {
+            let Some(delay) = backoff.next() else {
+                break;
+            };
+            if let Some(cancellation) = cancellation {
+                tokio::select! {
+                    biased;
+                    _ = cancellation.cancelled() => break,
+                    _ = tokio::time::sleep(delay) => {}
+                }
+            } else {
+                tokio::time::sleep(delay).await;
+            }
+            if cancellation.is_some_and(CancellationToken::is_cancelled) {
+                break;
+            }
+            let failures = merge_attempts(attempts, &mut response)?;
+            let mut first_error = None;
+            let mut refresh = Vec::new();
+            let mut pending = Vec::new();
+            for (write, error) in failures {
+                if error.retry_hint() == RetryHint::RetryAfterRouteRefresh {
+                    refresh.push(write);
+                } else {
+                    pending.push(write);
+                }
+                first_error.get_or_insert(error);
+            }
+            if !refresh.is_empty() {
+                pending.extend(self.reroute_failed_writes(refresh).await?);
+            }
+            if let Some(error) =
+                first_error.filter(|_| cancellation.is_some_and(CancellationToken::is_cancelled))
+            {
+                return Err(error);
+            }
+            attempts =
+                future::join_all(pending.into_iter().map(|write| self.send(write, histogram)))
+                    .await;
+            retries += 1;
+        }
+        match merge_attempts(attempts, &mut response)?.into_iter().next() {
+            Some((_, error)) => Err(error),
+            None => Ok(response),
+        }
+    }
+
+    async fn reroute_failed_writes(&self, writes: Vec<RoutedWrite>) -> Result<Vec<RoutedWrite>> {
+        let regions = writes
+            .iter()
+            .map(|write| write_region_id(&write.request))
+            .collect::<Result<Vec<_>>>()?;
+        self.invalidate_routes(&regions).await?;
+        let mut table_names = HashMap::new();
+        for table_id in regions
+            .iter()
+            .map(|region| region.table_id())
+            .collect::<HashSet<_>>()
+        {
+            // Raw metadata is only used to recover the name of the failed request's table.
+            let table_info = self
+                .catalog_manager
+                .table_info_by_id(table_id)
+                .await
+                .map_err(BoxedError::new)
+                .context(ExternalSnafu)?
+                .with_context(|| TableInfoNotFoundSnafu {
+                    table: table_id.to_string(),
+                })?;
+            table_names.insert(
+                table_id,
+                TableName::new(
+                    &table_info.catalog_name,
+                    &table_info.schema_name,
+                    &table_info.name,
+                ),
+            );
+        }
+        // TableId invalidation refreshes metadata and routes, but TableCache is keyed by name.
+        // Use the refreshed names in case a table was renamed while the write was pending.
+        let caches = table_names
+            .values()
+            .cloned()
+            .map(CacheIdent::TableName)
+            .collect::<Vec<_>>();
+        self.cache_invalidator
+            .invalidate(&Context::default(), &caches)
+            .await?;
+        let mut partitioners = HashMap::new();
+        for (table_id, name) in table_names {
+            let table = self
+                .catalog_manager
+                .table(
+                    &name.catalog_name,
+                    &name.schema_name,
+                    &name.table_name,
+                    None,
+                )
+                .await
+                .map_err(BoxedError::new)
+                .context(ExternalSnafu)?
+                .with_context(|| TableInfoNotFoundSnafu {
+                    table: name.to_string(),
+                })?;
+            let table_info = table.table_info();
+            ensure!(
+                table_info.table_id() == table_id,
+                UnexpectedSnafu {
+                    err_msg: format!(
+                        "Table {name} changed ID from {table_id} to {} while retrying writes",
+                        table_info.table_id()
+                    ),
+                }
+            );
+            let partitioner = TablePartitioner::try_new(&self.partition_manager, &table_info)
+                .await
+                .map_err(BoxedError::new)
+                .context(ExternalSnafu)?;
+            partitioners.insert(table_id, (table_info, partitioner));
+        }
+        let mut rebuilt_requests = Vec::new();
+        for write in writes {
+            let request = Arc::try_unwrap(write.request).map_err(|_| {
+                UnexpectedSnafu {
+                    err_msg: "Write request is still shared after its RPC completed",
+                }
+                .build()
+            })?;
+            let table_id = write_region_id(&request)?.table_id();
+            let (table_info, partitioner) =
+                partitioners.get(&table_id).context(UnexpectedSnafu {
+                    err_msg: "Refreshed write has no partition snapshot",
+                })?;
+            let requests = partitioner
+                .rebuild_write_requests(request, table_info)
+                .map_err(BoxedError::new)
+                .context(ExternalSnafu)?;
+            rebuilt_requests.extend(requests);
+        }
+        self.prepare(rebuilt_requests).await
+    }
+
+    async fn prepare(&self, requests: Vec<RegionRequest>) -> Result<Vec<RoutedWrite>> {
+        let regions = requests
+            .iter()
+            .map(write_region_id)
+            .collect::<Result<Vec<_>>>()?;
+        let peers = resolve_peers(&self.partition_manager, &regions)
+            .await
+            .map_err(BoxedError::new)
+            .context(ExternalSnafu)?;
+        requests
+            .into_iter()
+            .zip(regions)
+            .map(|(request, region)| {
+                Ok(RoutedWrite {
+                    peer: get_peer(&peers, region)?,
+                    request: Arc::new(request),
+                })
+            })
+            .collect()
+    }
+
+    async fn invalidate_routes(&self, regions: &[RegionId]) -> Result<()> {
+        let mut table_ids = regions
+            .iter()
+            .map(|region| region.table_id())
+            .collect::<HashSet<_>>();
+        let mut physical_ids = HashSet::new();
+        for table_id in &table_ids {
+            let (physical_id, _) = self
+                .partition_manager
+                .find_physical_table_route_with_id(*table_id)
+                .await
+                .map_err(BoxedError::new)
+                .context(ExternalSnafu)?;
+            physical_ids.insert(physical_id);
+        }
+        table_ids.extend(physical_ids);
+        let caches = table_ids
+            .into_iter()
+            .map(CacheIdent::TableId)
+            .collect::<Vec<_>>();
+        self.cache_invalidator
+            .invalidate(&Context::default(), &caches)
+            .await
+    }
+}
+
+async fn resolve_peers(
+    partition_manager: &PartitionRuleManager,
+    regions: &[RegionId],
+) -> partition::error::Result<HashMap<RegionId, PeerRef>> {
+    let table_ids = regions
+        .iter()
+        .map(|region| region.table_id())
+        .collect::<HashSet<_>>();
+    let mut physical_tables = HashMap::new();
+    let mut routes = HashMap::new();
+    for table_id in table_ids {
+        let (physical_id, route) = partition_manager
+            .find_physical_table_route_with_id(table_id)
+            .await?;
+        physical_tables.insert(table_id, physical_id);
+        routes.entry(physical_id).or_insert(route);
+    }
+    let mut shared_peers: HashMap<&Peer, PeerRef> = HashMap::new();
+    let mut peers = HashMap::with_capacity(regions.len());
+    for region in regions {
+        if peers.contains_key(region) {
+            continue;
+        }
+        let peer = physical_tables
+            .get(&region.table_id())
+            .and_then(|physical_id| routes.get(physical_id))
+            .and_then(|route| {
+                router::find_region_leader_ref(&route.region_routes, region.region_number())
+            })
+            .context(partition::error::FindLeaderSnafu {
+                region_id: *region,
+                table_id: region.table_id(),
+            })?;
+        let peer = shared_peers
+            .entry(peer)
+            .or_insert_with(|| Arc::new(peer.clone()));
+        peers.insert(*region, Arc::clone(peer));
+    }
+    Ok(peers)
+}
+
+fn get_peer(peers: &HashMap<RegionId, PeerRef>, region: RegionId) -> Result<PeerRef> {
+    peers.get(&region).cloned().context(UnexpectedSnafu {
+        err_msg: "Planned write has no resolved peer",
+    })
+}
+
+fn merge_attempts(
+    attempts: Vec<WriteAttempt>,
+    response: &mut RegionResponse,
+) -> Result<Vec<(RoutedWrite, Error)>> {
+    let mut failures = Vec::new();
+    let mut terminal_error = None;
+    for attempt in attempts {
+        match attempt {
+            WriteAttempt::Success(result) => merge_response(response, result),
+            WriteAttempt::Failed {
+                error,
+                request: Some(write),
+            } => failures.push((write, error)),
+            WriteAttempt::Failed {
+                error,
+                request: None,
+            } => {
+                terminal_error.get_or_insert(error);
+            }
+        }
+    }
+    // A terminal error takes precedence over retained retryable failures.
+    match terminal_error {
+        Some(error) => Err(error),
+        None => Ok(failures),
+    }
+}
+
+fn merge_response(response: &mut RegionResponse, result: RegionResponse) {
+    response.affected_rows += result.affected_rows;
+    response.extensions.extend(result.extensions);
+    response.metadata = result.metadata;
+}
+
+fn split_request(request: RegionRequest) -> Vec<RegionRequest> {
+    let RegionRequest { header, body } = request;
+    let bodies: Vec<Body> = match body {
+        Some(Body::Inserts(inserts)) => inserts
+            .requests
+            .into_iter()
+            .map(|request| {
+                Body::Inserts(InsertRequests {
+                    requests: vec![request],
+                })
+            })
+            .collect(),
+        Some(Body::Deletes(deletes)) => deletes
+            .requests
+            .into_iter()
+            .map(|request| {
+                Body::Deletes(DeleteRequests {
+                    requests: vec![request],
+                })
+            })
+            .collect(),
+        body => return vec![RegionRequest { header, body }],
+    };
+    bodies
+        .into_iter()
+        .map(|body| RegionRequest {
+            header: header.clone(),
+            body: Some(body),
+        })
+        .collect()
+}
+
+fn write_region_id(request: &RegionRequest) -> Result<RegionId> {
+    let region_id = match &request.body {
+        Some(Body::Inserts(inserts)) => match inserts.requests.as_slice() {
+            [request] => Some(request.region_id),
+            _ => None,
+        },
+        Some(Body::Deletes(deletes)) => match deletes.requests.as_slice() {
+            [request] => Some(request.region_id),
+            _ => None,
+        },
+        Some(Body::BulkInsert(bulk)) => Some(bulk.region_id),
+        _ => None,
+    };
+    region_id.map(RegionId::from_u64).ok_or_else(|| {
+        UnexpectedSnafu {
+            err_msg: "Expected a single-region write request",
+        }
+        .build()
+    })
+}
diff --git a/src/operator/src/write_dispatcher/options.rs b/src/operator/src/write_dispatcher/options.rs
new file mode 100644
index 00000000000..20c8ba535f3
--- /dev/null
+++ b/src/operator/src/write_dispatcher/options.rs
@@ -0,0 +1,106 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::time::Duration;
+
+use serde::{Deserialize, Serialize};
+
+/// Exponential backoff for retryable distributed writes.
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct WriteRetryOptions {
+    /// Maximum additional attempts after the original write. Zero disables retries.
+    pub max_retries: usize,
+    /// Initial backoff before jitter is applied.
+    #[serde(with = "humantime_serde")]
+    pub initial_backoff: Duration,
+    /// Maximum backoff before jitter is applied.
+    #[serde(with = "humantime_serde")]
+    pub max_backoff: Duration,
+    /// Multiplier applied to the backoff after each retry.
+    pub backoff_multiplier: f32,
+}
+
+impl Default for WriteRetryOptions {
+    fn default() -> Self {
+        Self {
+            max_retries: 3,
+            initial_backoff: Duration::from_millis(1500),
+            max_backoff: Duration::from_secs(10),
+            backoff_multiplier: 2.0,
+        }
+    }
+}
+
+impl WriteRetryOptions {
+    /// Checks that the configured backoff is positive, bounded, and nondecreasing.
+    pub fn validate(&self) -> Result<(), &'static str> {
+        if self.initial_backoff.is_zero() {
+            return Err("write_retry.initial_backoff must be positive");
+        }
+        if self.max_backoff < self.initial_backoff {
+            return Err("write_retry.max_backoff must be at least initial_backoff");
+        }
+        if !self.backoff_multiplier.is_finite() || self.backoff_multiplier < 1.0 {
+            return Err("write_retry.backoff_multiplier must be finite and at least 1");
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_write_retry_options() {
+        for options in [
+            WriteRetryOptions::default(),
+            WriteRetryOptions {
+                max_retries: 0,
+                ..Default::default()
+            },
+            WriteRetryOptions {
+                backoff_multiplier: 1.0,
+                ..Default::default()
+            },
+        ] {
+            options.validate().unwrap();
+        }
+        for options in [
+            WriteRetryOptions {
+                initial_backoff: Duration::ZERO,
+                ..Default::default()
+            },
+            WriteRetryOptions {
+                max_backoff: Duration::from_secs(1),
+                ..Default::default()
+            },
+            WriteRetryOptions {
+                backoff_multiplier: 0.5,
+                ..Default::default()
+            },
+            WriteRetryOptions {
+                backoff_multiplier: f32::NAN,
+                ..Default::default()
+            },
+            WriteRetryOptions {
+                backoff_multiplier: f32::INFINITY,
+                ..Default::default()
+            },
+        ] {
+            assert!(options.validate().is_err(), "{options:?}");
+        }
+    }
+}
diff --git a/src/operator/src/write_dispatcher/tests.rs b/src/operator/src/write_dispatcher/tests.rs
new file mode 100644
index 00000000000..0f9af3b7190
--- /dev/null
+++ b/src/operator/src/write_dispatcher/tests.rs
@@ -0,0 +1,1798 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::{HashMap, VecDeque};
+use std::future::Future;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::task::Poll;
+use std::time::{Duration, Instant};
+
+use api::v1::region::region_server::{Region, RegionServer};
+use api::v1::region::{
+    AlignedSchemaVersion, BulkInsertRequest, DeleteRequest, InsertRequest, RegionRequestHeader,
+    RegionResponse as PbRegionResponse, bulk_insert_request,
+};
+use api::v1::value::ValueData;
+use api::v1::{
+    ArrowIpc, ColumnDataType, ColumnSchema, PartitionExprVersion, Row, Rows, Value, helper,
+};
+use api::v1::{ResponseHeader, Status as PbStatus};
+use catalog::information_schema::NoopInformationExtension;
+use catalog::kvbackend::KvBackendCatalogManagerBuilder;
+use client::client_manager::NodeClients;
+use common_error::ext::{ErrorExt, RetryHint};
+use common_error::status_code::StatusCode;
+use common_grpc::channel_manager::ChannelConfig;
+use common_grpc::flight::{self, FlightDecoder};
+use common_meta::cache::{
+    self as meta_cache, LayeredCacheRegistryBuilder, LayeredCacheRegistryRef, TableInfoCacheRef,
+    TableRouteCacheRef,
+};
+use common_meta::cache_invalidator::{CacheInvalidator, CacheInvalidatorRef, Context};
+use common_meta::ddl::test_util::datanode_handler::DatanodeWatcher;
+use common_meta::error::{Result, UnexpectedSnafu};
+use common_meta::instruction::CacheIdent;
+use common_meta::key::TableMetadataManager;
+use common_meta::key::table_route::{TableRouteManager, TableRouteValue};
+use common_meta::kv_backend::KvBackendRef;
+use common_meta::kv_backend::memory::MemoryKvBackend;
+use common_meta::peer::Peer;
+use common_meta::rpc::router::{self, RegionRoute};
+use common_meta::test_util::{MockDatanodeHandler, MockDatanodeManager};
+use common_query::request::QueryRequest;
+use common_recordbatch::SendableRecordBatchStream;
+use datatypes::arrow::array::{BinaryArray, Int32Array, StringArray};
+use datatypes::arrow::datatypes::{DataType, Field, Schema};
+use datatypes::arrow::record_batch::RecordBatch;
+use datatypes::data_type::ConcreteDataType;
+use datatypes::schema;
+use datatypes::value::{self, ValueRef};
+use mito_codec::row_converter::sparse;
+use mito_codec::row_converter::{PrimaryKeyCodec, SparsePrimaryKeyCodec};
+use partition::cache::PartitionInfoCacheRef;
+use partition::expr::{self, Operand, PartitionExpr, RestrictedOp};
+use partition::manager::{PartitionRuleManager, PartitionRuleManagerRef};
+use store_api::metric_engine_consts;
+use store_api::storage::{RegionId, consts};
+use tokio::net::TcpListener;
+use tokio::sync::{Barrier, Notify, Semaphore};
+use tokio::task::JoinHandle;
+use tokio_stream::wrappers::TcpListenerStream;
+use tonic::{Code, Request, Response, Status};
+
+use super::*;
+use crate::error::Error;
+use crate::test_util;
+
+#[derive(Clone, Default)]
+struct RecordingRegionService {
+    requests: Arc<Mutex<Vec<RegionRequest>>>,
+    rejections: Arc<Mutex<HashMap<u64, VecDeque<Status>>>>,
+    release: Arc<Mutex<Option<Arc<Semaphore>>>>,
+}
+
+#[async_trait::async_trait]
+impl Region for RecordingRegionService {
+    async fn handle(
+        &self,
+        request: Request<RegionRequest>,
+    ) -> std::result::Result<Response<PbRegionResponse>, Status> {
+        let request = request.into_inner();
+        let region_id = write_region_id(&request).unwrap().as_u64();
+        self.requests.lock().unwrap().push(request);
+        let release = self.release.lock().unwrap().clone();
+        if let Some(release) = release {
+            release.acquire().await.unwrap().forget();
+        }
+        if let Some(status) = self
+            .rejections
+            .lock()
+            .unwrap()
+            .get_mut(&region_id)
+            .and_then(VecDeque::pop_front)
+        {
+            return Err(status);
+        }
+        Ok(Response::new(PbRegionResponse {
+            header: Some(ResponseHeader {
+                status: Some(PbStatus {
+                    status_code: StatusCode::Success as u32,
+                    ..Default::default()
+                }),
+            }),
+            affected_rows: 1,
+            ..Default::default()
+        }))
+    }
+}
+
+#[derive(Default)]
+struct RecordingCacheInvalidator {
+    calls: Mutex<Vec<Vec<CacheIdent>>>,
+    inner: Option<CacheInvalidatorRef>,
+    route_update: Mutex<Option<(KvBackendRef, TableRouteValue)>>,
+    rename_and_recreate: Mutex<Option<KvBackendRef>>,
+}
+
+#[async_trait::async_trait]
+impl CacheInvalidator for RecordingCacheInvalidator {
+    async fn invalidate(&self, ctx: &Context, caches: &[CacheIdent]) -> Result<()> {
+        self.calls.lock().unwrap().push(caches.to_vec());
+        let route_update = self.route_update.lock().unwrap().take();
+        if let Some((backend, updated)) = route_update {
+            let manager = TableRouteManager::new(backend.clone());
+            let storage = manager.table_route_storage();
+            let current = storage.get_with_raw_bytes(1).await?.unwrap();
+            let (txn, _) = storage.build_update_txn(1, &current, &updated)?;
+            assert!(backend.txn(txn).await?.succeeded);
+        }
+        let rename_and_recreate = if caches
+            .iter()
+            .any(|cache| matches!(cache, CacheIdent::TableName(_)))
+        {
+            self.rename_and_recreate.lock().unwrap().take()
+        } else {
+            None
+        };
+        if let Some(backend) = rename_and_recreate {
+            // Reuse the name after the retry has recovered it from the original table ID.
+            let metadata = TableMetadataManager::new(backend);
+            let current = metadata.table_info_manager().get(1).await?.unwrap();
+            metadata
+                .rename_table(&current, "renamed_table".to_string())
+                .await?;
+            let mut replacement = current.table_info.clone();
+            replacement.ident.table_id = 42;
+            let route = metadata
+                .table_route_manager()
+                .table_route_storage()
+                .get_with_raw_bytes(1)
+                .await?
+                .unwrap();
+            let mut routes = route.region_routes().unwrap().clone();
+            for route in &mut routes {
+                route.region.id = RegionId::new(42, route.region.id.region_number());
+            }
+            metadata
+                .create_table_metadata(
+                    replacement,
+                    TableRouteValue::physical(routes),
+                    Default::default(),
+                )
+                .await?;
+        }
+        if let Some(inner) = &self.inner {
+            inner.invalidate(ctx, caches).await
+        } else {
+            UnexpectedSnafu {
+                err_msg: "stop after recording route refresh",
+            }
+            .fail()
+        }
+    }
+
+    fn invalidate_all(&self) -> Result<()> {
+        // This recorder owns no cache entries.
+        Ok(())
+    }
+}
+
+struct RegionTestServer {
+    peer: Peer,
+    service: Arc<RecordingRegionService>,
+    invalidator: Arc<RecordingCacheInvalidator>,
+    task: JoinHandle<()>,
+}
+
+impl RegionTestServer {
+    async fn start() -> Self {
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let peer = Peer::new(1, listener.local_addr().unwrap().to_string());
+        let service = Arc::new(RecordingRegionService::default());
+        let server_service = service.clone();
+        let task = tokio::spawn(async move {
+            tonic::transport::Server::builder()
+                .add_service(RegionServer::new(server_service.as_ref().clone()))
+                .serve_with_incoming(TcpListenerStream::new(listener))
+                .await
+                .unwrap();
+        });
+        Self {
+            peer,
+            service,
+            invalidator: Arc::default(),
+            task,
+        }
+    }
+
+    async fn create_dispatcher(&self, max_retries: usize) -> WriteDispatcher {
+        let backend = test_util::prepare_mocked_backend().await;
+        test_util::create_partition_rule_manager(backend.clone()).await;
+        update_table_leader(&backend, &self.peer).await;
+        let (partition_manager, _, _, catalog_manager) = create_routing_caches(backend);
+        let clients = Arc::new(NodeClients::new(ChannelConfig::default()));
+        WriteDispatcher::new(clients, partition_manager).with_retry(
+            build_retry_options(max_retries),
+            catalog_manager,
+            self.invalidator.clone(),
+        )
+    }
+
+    fn fail_region(&self, region_number: u32, hints: impl IntoIterator<Item = RetryHint>) {
+        let region_id = RegionId::new(1, region_number).as_u64();
+        self.service.rejections.lock().unwrap().insert(
+            region_id,
+            hints
+                .into_iter()
+                .map(|hint| {
+                    let mut status = Status::failed_precondition(format!(
+                        "region {region_id} rejected the write"
+                    ));
+                    status.metadata_mut().insert(
+                        common_error::GREPTIME_DB_HEADER_ERROR_RETRY_HINT,
+                        hint.as_str().parse().unwrap(),
+                    );
+                    status
+                })
+                .collect(),
+        );
+    }
+
+    fn attempt_counts(&self) -> HashMap<u64, usize> {
+        let mut counts = HashMap::new();
+        for request in self.service.requests.lock().unwrap().iter() {
+            *counts
+                .entry(write_region_id(request).unwrap().as_u64())
+                .or_default() += 1;
+        }
+        counts
+    }
+}
+
+impl Drop for RegionTestServer {
+    fn drop(&mut self) {
+        self.task.abort();
+    }
+}
+
+fn build_retry_options(max_retries: usize) -> WriteRetryOptions {
+    WriteRetryOptions {
+        max_retries,
+        initial_backoff: Duration::from_millis(1),
+        max_backoff: Duration::from_millis(2),
+        ..Default::default()
+    }
+}
+
+fn create_routing_caches(
+    backend: KvBackendRef,
+) -> (
+    PartitionRuleManagerRef,
+    TableInfoCacheRef,
+    LayeredCacheRegistryRef,
+    CatalogManagerRef,
+) {
+    let registry = Arc::new(
+        cache::with_default_composite_cache_registry(
+            LayeredCacheRegistryBuilder::default()
+                .add_cache_registry(cache::build_fundamental_cache_registry(backend.clone())),
+        )
+        .unwrap()
+        .build(),
+    );
+    let partition_manager = Arc::new(PartitionRuleManager::new(
+        backend.clone(),
+        registry.get::<TableRouteCacheRef>().unwrap(),
+        registry.get::<PartitionInfoCacheRef>().unwrap(),
+    ));
+    let table_info_cache = registry.get::<TableInfoCacheRef>().unwrap();
+    let catalog_manager = KvBackendCatalogManagerBuilder::new(
+        Arc::new(NoopInformationExtension),
+        backend,
+        registry.clone(),
+    )
+    .build();
+    (
+        partition_manager,
+        table_info_cache,
+        registry,
+        catalog_manager,
+    )
+}
+
+async fn update_table_leader(backend: &KvBackendRef, peer: &Peer) {
+    let manager = TableRouteManager::new(backend.clone());
+    let storage = manager.table_route_storage();
+    let current = storage.get_with_raw_bytes(1).await.unwrap().unwrap();
+    let mut routes = current.region_routes().unwrap().clone();
+    for route in &mut routes {
+        route.leader_peer = Some(peer.clone());
+    }
+    let updated = current.update(routes).unwrap();
+    let (txn, _) = storage.build_update_txn(1, &current, &updated).unwrap();
+    assert!(backend.txn(txn).await.unwrap().succeeded);
+}
+
+fn build_insert_request(regions: &[u32]) -> RegionRequest {
+    RegionRequest {
+        body: Some(Body::Inserts(InsertRequests {
+            requests: regions
+                .iter()
+                .map(|region| InsertRequest {
+                    region_id: RegionId::new(1, *region).as_u64(),
+                    ..Default::default()
+                })
+                .collect(),
+        })),
+        ..Default::default()
+    }
+}
+
+#[tokio::test]
+async fn test_write_retry_disabled_and_enabled_ablation() {
+    common_telemetry::init_default_ut_logging();
+    for run in 0..3 {
+        for max_retries in [0, 1] {
+            let server = RegionTestServer::start().await;
+            server.fail_region(1, [RetryHint::Retryable]);
+            let dispatcher = server.create_dispatcher(max_retries).await;
+            let result = dispatcher.dispatch(vec![build_insert_request(&[1])]).await;
+            let attempts = server.attempt_counts()[&RegionId::new(1, 1).as_u64()];
+            common_telemetry::info!(
+                "write_retry_ablation run={run} max_retries={max_retries} success={} attempts={attempts}",
+                result.is_ok()
+            );
+            assert_eq!(result.is_ok(), max_retries > 0);
+            assert_eq!(attempts, max_retries + 1);
+            assert!(server.invalidator.calls.lock().unwrap().is_empty());
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_write_retry_does_not_replay_successful_regions() {
+    let server = RegionTestServer::start().await;
+    server.fail_region(2, [RetryHint::Retryable]);
+    let dispatcher = server.create_dispatcher(2).await;
+    let response = dispatcher
+        .dispatch(vec![build_insert_request(&[1, 2])])
+        .await
+        .unwrap();
+    assert_eq!(response.affected_rows, 2);
+    assert_eq!(
+        server.attempt_counts(),
+        HashMap::from([
+            (RegionId::new(1, 1).as_u64(), 1),
+            (RegionId::new(1, 2).as_u64(), 2),
+        ])
+    );
+    assert!(server.invalidator.calls.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn test_write_retry_attempt_budget_and_nonretryable_errors() {
+    for (hint, expected_attempts) in [(RetryHint::Retryable, 3), (RetryHint::NonRetryable, 1)] {
+        let server = RegionTestServer::start().await;
+        server.fail_region(1, [hint; 4]);
+        let dispatcher = server.create_dispatcher(2).await;
+        let error = dispatcher
+            .dispatch(vec![build_insert_request(&[1])])
+            .await
+            .unwrap_err();
+        assert_eq!(error.retry_hint(), hint);
+        assert_eq!(
+            server.attempt_counts()[&RegionId::new(1, 1).as_u64()],
+            expected_attempts
+        );
+        assert!(server.invalidator.calls.lock().unwrap().is_empty());
+    }
+}
+
+#[tokio::test]
+async fn test_write_retry_transport_errors() {
+    for code in [Code::Unavailable, Code::Cancelled, Code::DeadlineExceeded] {
+        for hint in [
+            None,
+            Some(RetryHint::NonRetryable),
+            Some(RetryHint::Retryable),
+            Some(RetryHint::RetryAfterRouteRefresh),
+        ] {
+            let server = RegionTestServer::start().await;
+            let region_id = RegionId::new(1, 1).as_u64();
+            let mut status = Status::new(code, "write failed");
+            if let Some(hint) = hint {
+                status.metadata_mut().insert(
+                    common_error::GREPTIME_DB_HEADER_ERROR_RETRY_HINT,
+                    hint.as_str().parse().unwrap(),
+                );
+            }
+            server
+                .service
+                .rejections
+                .lock()
+                .unwrap()
+                .insert(region_id, VecDeque::from([status]));
+            let dispatcher = server.create_dispatcher(2).await;
+            let attempt = dispatcher
+                .send(
+                    Arc::new(server.peer.clone()),
+                    build_insert_request(&[1]),
+                    None,
+                )
+                .await;
+            let WriteAttempt::Failed { error, request } = attempt else {
+                panic!("expected a failed write");
+            };
+            assert!(request.is_some(), "{code:?}, {hint:?}");
+            assert_eq!(
+                error.retry_hint(),
+                hint.filter(|hint| hint.is_retryable())
+                    .unwrap_or(RetryHint::Retryable)
+            );
+            assert_eq!(server.attempt_counts(), HashMap::from([(region_id, 1)]));
+            assert!(server.invalidator.calls.lock().unwrap().is_empty());
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_write_retry_transport_attempt_budget() {
+    for code in [Code::Unavailable, Code::Cancelled, Code::DeadlineExceeded] {
+        for failures in [1, 3] {
+            let server = RegionTestServer::start().await;
+            let region_id = RegionId::new(1, 1).as_u64();
+            server.service.rejections.lock().unwrap().insert(
+                region_id,
+                (0..failures)
+                    .map(|_| Status::new(code, "write failed"))
+                    .collect(),
+            );
+            let dispatcher = server.create_dispatcher(2).await;
+            let response = dispatcher.dispatch(vec![build_insert_request(&[1])]).await;
+            let expected_attempts = if failures == 1 {
+                assert_eq!(response.unwrap().affected_rows, 1);
+                2
+            } else {
+                assert_eq!(response.unwrap_err().retry_hint(), RetryHint::Retryable);
+                3
+            };
+            assert_eq!(
+                server.attempt_counts(),
+                HashMap::from([(region_id, expected_attempts)]),
+                "{code:?}, failures: {failures}"
+            );
+            assert!(server.invalidator.calls.lock().unwrap().is_empty());
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_write_retry_stops_when_a_sibling_is_nonretryable() {
+    for hint in [RetryHint::Retryable, RetryHint::RetryAfterRouteRefresh] {
+        for regions in [[1, 2], [2, 1]] {
+            let server = RegionTestServer::start().await;
+            server.fail_region(1, [hint]);
+            server.fail_region(2, [RetryHint::NonRetryable]);
+            let dispatcher = server.create_dispatcher(2).await;
+            let error = dispatcher
+                .dispatch(vec![build_insert_request(&regions)])
+                .await
+                .unwrap_err();
+            let terminal_region = RegionId::new(1, 2).as_u64();
+            assert!(
+                format!("{error:?}")
+                    .contains(&format!("region {terminal_region} rejected the write")),
+                "{error:?}"
+            );
+            assert_eq!(
+                server.attempt_counts(),
+                HashMap::from([(RegionId::new(1, 1).as_u64(), 1), (terminal_region, 1),])
+            );
+            assert!(server.invalidator.calls.lock().unwrap().is_empty());
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_should_retry_requires_a_retained_request_and_budget() {
+    let backend = test_util::prepare_mocked_backend().await;
+    let (partition_manager, _, cache_invalidator, catalog_manager) = create_routing_caches(backend);
+    let retry = WriteRetry {
+        node_manager: Arc::new(NodeClients::default()),
+        partition_manager,
+        options: build_retry_options(2),
+        catalog_manager,
+        cache_invalidator,
+    };
+    let failure = |request| {
+        let error: client::Error = Status::unavailable("write rejected").into();
+        WriteAttempt::Failed {
+            error: error.into(),
+            request,
+        }
+    };
+    let retryable = || {
+        failure(Some(RoutedWrite {
+            peer: Arc::new(Peer::new(1, "peer")),
+            request: Arc::new(build_insert_request(&[1])),
+        }))
+    };
+    for (name, attempts, retries, expected) in [
+        ("empty", vec![], 0, false),
+        (
+            "all succeeded",
+            vec![WriteAttempt::Success(RegionResponse::new(1))],
+            0,
+            false,
+        ),
+        ("retryable", vec![retryable()], 0, true),
+        ("last retry", vec![retryable()], 1, true),
+        ("budget exhausted", vec![retryable()], 2, false),
+        ("terminal first", vec![failure(None), retryable()], 0, false),
+        ("terminal last", vec![retryable(), failure(None)], 0, false),
+    ] {
+        assert_eq!(retry.should_retry(&attempts, retries), expected, "{name}");
+    }
+}
+
+#[tokio::test]
+async fn test_write_retry_cancellation_stops_backoff() {
+    for hint in [RetryHint::Retryable, RetryHint::RetryAfterRouteRefresh] {
+        let server = RegionTestServer::start().await;
+        server.fail_region(1, [hint]);
+        let mut dispatcher = server.create_dispatcher(2).await;
+        let options = &mut dispatcher.retry.as_mut().unwrap().options;
+        options.initial_backoff = Duration::from_secs(60);
+        options.max_backoff = Duration::from_secs(60);
+        let attempt = dispatcher
+            .send(
+                Arc::new(server.peer.clone()),
+                build_insert_request(&[1]),
+                None,
+            )
+            .await;
+        let cancellation = CancellationToken::new();
+        let guard = cancellation.clone().drop_guard();
+        let finish = dispatcher.finish(vec![attempt], None, Some(&cancellation));
+        tokio::pin!(finish);
+        futures::future::poll_fn(|cx| {
+            assert!(finish.as_mut().poll(cx).is_pending());
+            Poll::Ready(())
+        })
+        .await;
+        drop(guard);
+        let error = tokio::time::timeout(Duration::from_secs(1), finish)
+            .await
+            .unwrap()
+            .unwrap_err();
+        assert_eq!(error.retry_hint(), hint);
+        assert_eq!(
+            server.attempt_counts(),
+            HashMap::from([(RegionId::new(1, 1).as_u64(), 1)])
+        );
+        assert!(server.invalidator.calls.lock().unwrap().is_empty());
+    }
+}
+
+#[tokio::test]
+async fn test_write_retry_cancellation_drains_inflight_requests() {
+    let server = RegionTestServer::start().await;
+    server.fail_region(2, [RetryHint::RetryAfterRouteRefresh]);
+    let release = Arc::new(Semaphore::new(0));
+    *server.service.release.lock().unwrap() = Some(release.clone());
+    let dispatcher = server.create_dispatcher(2).await;
+    let writes = dispatcher
+        .prepare(vec![build_insert_request(&[1, 2])])
+        .await
+        .unwrap();
+    let cancellation = CancellationToken::new();
+    let guard = cancellation.clone().drop_guard();
+    let execute = dispatcher.execute(writes, None, Some(&cancellation));
+    tokio::pin!(execute);
+    tokio::time::timeout(
+        Duration::from_secs(1),
+        futures::future::poll_fn(|cx| {
+            assert!(execute.as_mut().poll(cx).is_pending());
+            if server.service.requests.lock().unwrap().len() == 2 {
+                Poll::Ready(())
+            } else {
+                cx.waker().wake_by_ref();
+                Poll::Pending
+            }
+        }),
+    )
+    .await
+    .unwrap();
+    drop(guard);
+    futures::future::poll_fn(|cx| {
+        assert!(execute.as_mut().poll(cx).is_pending());
+        Poll::Ready(())
+    })
+    .await;
+    release.add_permits(2);
+    let error = tokio::time::timeout(Duration::from_secs(1), execute)
+        .await
+        .unwrap()
+        .unwrap_err();
+    assert_eq!(error.retry_hint(), RetryHint::RetryAfterRouteRefresh);
+    assert_eq!(
+        server.attempt_counts(),
+        HashMap::from([
+            (RegionId::new(1, 1).as_u64(), 1),
+            (RegionId::new(1, 2).as_u64(), 1),
+        ])
+    );
+    assert!(server.invalidator.calls.lock().unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn test_write_retry_refreshes_routes_once_per_failed_round() {
+    let server = RegionTestServer::start().await;
+    for region in [1, 2] {
+        server.fail_region(region, [RetryHint::RetryAfterRouteRefresh]);
+    }
+    let dispatcher = server.create_dispatcher(2).await;
+    let error = dispatcher
+        .dispatch(vec![build_insert_request(&[1, 2])])
+        .await
+        .unwrap_err();
+    assert!(
+        error
+            .to_string()
+            .contains("stop after recording route refresh")
+    );
+    let calls = server.invalidator.calls.lock().unwrap();
+    assert_eq!(calls.len(), 1);
+    assert_eq!(calls[0], vec![CacheIdent::TableId(1)]);
+    assert_eq!(server.service.requests.lock().unwrap().len(), 2);
+}
+
+#[tokio::test]
+async fn test_finish_retries_initial_failures_in_one_round() {
+    let server = RegionTestServer::start().await;
+    for region in [2, 3] {
+        server.fail_region(region, [RetryHint::RetryAfterRouteRefresh]);
+    }
+    let backend = test_util::prepare_mocked_backend().await;
+    test_util::create_partition_rule_manager(backend.clone()).await;
+    update_table_leader(&backend, &server.peer).await;
+    let (partition_manager, table_info_cache, registry, catalog_manager) =
+        create_routing_caches(backend);
+    let table_info = table_info_cache.get(1).await.unwrap().unwrap();
+    let (_, versions) = partition_manager
+        .find_table_partition_rule(&table_info)
+        .await
+        .unwrap();
+    let invalidator = Arc::new(RecordingCacheInvalidator {
+        inner: Some(registry),
+        ..Default::default()
+    });
+    let clients = Arc::new(NodeClients::new(ChannelConfig::default()));
+    let dispatcher = WriteDispatcher::new(clients, partition_manager).with_retry(
+        build_retry_options(2),
+        catalog_manager,
+        invalidator.clone(),
+    );
+    let mut attempts = Vec::new();
+    for (region, value) in [(1, 101), (2, 11), (3, 1)] {
+        let request =
+            build_partitioned_request(WriteKind::BulkInsert, region, versions[&region], &[value]);
+        attempts.push(
+            dispatcher
+                .send(Arc::new(server.peer.clone()), request, None)
+                .await,
+        );
+    }
+    assert!(invalidator.calls.lock().unwrap().is_empty());
+    assert_eq!(
+        server.attempt_counts(),
+        HashMap::from([
+            (RegionId::new(1, 1).as_u64(), 1),
+            (RegionId::new(1, 2).as_u64(), 1),
+            (RegionId::new(1, 3).as_u64(), 1),
+        ])
+    );
+    let response = dispatcher.finish(attempts, None, None).await.unwrap();
+    assert_eq!(response.affected_rows, 3);
+    assert_eq!(
+        server.attempt_counts(),
+        HashMap::from([
+            (RegionId::new(1, 1).as_u64(), 1),
+            (RegionId::new(1, 2).as_u64(), 2),
+            (RegionId::new(1, 3).as_u64(), 2),
+        ])
+    );
+    assert_eq!(
+        *invalidator.calls.lock().unwrap(),
+        vec![
+            vec![CacheIdent::TableId(1)],
+            vec![CacheIdent::TableName(TableName::new(
+                "greptime", "public", "table_1"
+            ))],
+        ]
+    );
+}
+
+#[tokio::test]
+async fn test_write_retry_refreshes_stale_route_and_sends_only_failed_region_to_new_leader() {
+    let old_server = RegionTestServer::start().await;
+    let new_server = RegionTestServer::start().await;
+    old_server.fail_region(2, [RetryHint::RetryAfterRouteRefresh]);
+    let backend = test_util::prepare_mocked_backend().await;
+    // Reuse the operator fixture to populate table metadata and partition rules.
+    test_util::create_partition_rule_manager(backend.clone()).await;
+    update_table_leader(&backend, &old_server.peer).await;
+
+    let (partition_manager, table_info_cache, registry, catalog_manager) =
+        create_routing_caches(backend.clone());
+    let failed_region = RegionId::new(1, 2);
+    assert_eq!(
+        partition_manager
+            .find_region_leader(failed_region)
+            .await
+            .unwrap(),
+        old_server.peer
+    );
+    let table_info = table_info_cache.get(1).await.unwrap().unwrap();
+    let (_, versions) = partition_manager
+        .find_table_partition_rule(&table_info)
+        .await
+        .unwrap();
+
+    // Metadata has migrated while the frontend still holds the old route.
+    update_table_leader(&backend, &new_server.peer).await;
+    assert_eq!(
+        partition_manager
+            .find_region_leader(failed_region)
+            .await
+            .unwrap(),
+        old_server.peer
+    );
+
+    let invalidator = Arc::new(RecordingCacheInvalidator {
+        calls: Mutex::default(),
+        inner: Some(registry),
+        ..Default::default()
+    });
+    let clients = Arc::new(NodeClients::new(ChannelConfig::default()));
+    let dispatcher = WriteDispatcher::new(clients, partition_manager).with_retry(
+        build_retry_options(2),
+        catalog_manager,
+        invalidator.clone(),
+    );
+    let mut request = build_insert_request(&[1, 2]);
+    if let Some(Body::Inserts(inserts)) = &mut request.body {
+        for insert in &mut inserts.requests {
+            insert.partition_expr_version = versions
+                [&RegionId::from_u64(insert.region_id).region_number()]
+                .map(|value| PartitionExprVersion { value });
+        }
+    }
+    let response = dispatcher.dispatch(vec![request]).await.unwrap();
+    assert_eq!(response.affected_rows, 2);
+    assert_eq!(
+        old_server.attempt_counts(),
+        HashMap::from([
+            (RegionId::new(1, 1).as_u64(), 1),
+            (failed_region.as_u64(), 1),
+        ])
+    );
+    assert_eq!(
+        new_server.attempt_counts(),
+        HashMap::from([(failed_region.as_u64(), 1)])
+    );
+    assert_eq!(
+        *invalidator.calls.lock().unwrap(),
+        vec![
+            vec![CacheIdent::TableId(1)],
+            vec![CacheIdent::TableName(TableName::new(
+                "greptime", "public", "table_1"
+            ))],
+        ]
+    );
+}
+
+#[derive(Clone, Copy, Debug)]
+enum WriteKind {
+    Insert,
+    Delete,
+    BulkInsert,
+}
+
+fn build_partitioned_request(
+    kind: WriteKind,
+    region: u32,
+    version: Option<u64>,
+    values: &[i32],
+) -> RegionRequest {
+    let region_id = RegionId::new(1, region).as_u64();
+    let partition_expr_version = version.map(|value| PartitionExprVersion { value });
+    let rows = Rows {
+        schema: vec![ColumnSchema {
+            column_name: "a".to_string(),
+            datatype: ColumnDataType::Int32 as i32,
+            ..Default::default()
+        }],
+        rows: values
+            .iter()
+            .map(|value| Row {
+                values: vec![Value {
+                    value_data: Some(ValueData::I32Value(*value)),
+                }],
+            })
+            .collect(),
+    };
+    let body = match kind {
+        WriteKind::Insert => Body::Inserts(InsertRequests {
+            requests: vec![InsertRequest {
+                region_id,
+                partition_expr_version,
+                rows: Some(rows),
+                skip_wal: true,
+            }],
+        }),
+        WriteKind::Delete => Body::Deletes(DeleteRequests {
+            requests: vec![DeleteRequest {
+                region_id,
+                partition_expr_version,
+                rows: Some(rows),
+            }],
+        }),
+        WriteKind::BulkInsert => {
+            let batch = RecordBatch::try_new(
+                Arc::new(Schema::new(vec![Field::new("a", DataType::Int32, false)])),
+                vec![Arc::new(Int32Array::from(values.to_vec()))],
+            )
+            .unwrap();
+            let (schema, data_header, payload) = flight::record_batch_to_ipc(batch).unwrap();
+            Body::BulkInsert(BulkInsertRequest {
+                region_id,
+                partition_expr_version,
+                skip_wal: true,
+                aligned_schema_version: Some(AlignedSchemaVersion {
+                    schema_version: 123,
+                }),
+                body: Some(bulk_insert_request::Body::ArrowIpc(ArrowIpc {
+                    schema,
+                    data_header,
+                    payload,
+                })),
+            })
+        }
+    };
+    RegionRequest {
+        header: None,
+        body: Some(body),
+    }
+}
+
+fn request_parts(request: &RegionRequest) -> (u32, Option<u64>, Vec<i32>) {
+    let region = write_region_id(request).unwrap().region_number();
+    let (version, rows) = match request.body.as_ref().unwrap() {
+        Body::Inserts(inserts) => {
+            assert!(inserts.requests[0].skip_wal);
+            (
+                inserts.requests[0].partition_expr_version,
+                inserts.requests[0].rows.as_ref().unwrap(),
+            )
+        }
+        Body::Deletes(deletes) => (
+            deletes.requests[0].partition_expr_version,
+            deletes.requests[0].rows.as_ref().unwrap(),
+        ),
+        Body::BulkInsert(bulk) => {
+            assert!(bulk.skip_wal);
+            assert_eq!(bulk.aligned_schema_version, None);
+            let Some(bulk_insert_request::Body::ArrowIpc(ipc)) = &bulk.body else {
+                panic!("expected IPC")
+            };
+            let batch = FlightDecoder::try_from_schema_bytes(&ipc.schema)
+                .unwrap()
+                .try_decode_record_batch(&ipc.data_header, &ipc.payload)
+                .unwrap();
+            let values = batch
+                .column(0)
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .unwrap();
+            return (
+                region,
+                bulk.partition_expr_version.map(|v| v.value),
+                values.values().to_vec(),
+            );
+        }
+        _ => panic!("expected write request"),
+    };
+    (
+        region,
+        version.map(|v| v.value),
+        rows.rows
+            .iter()
+            .map(|row| {
+                let Some(ValueData::I32Value(value)) = row.values[0].value_data else {
+                    panic!("expected int32")
+                };
+                value
+            })
+            .collect(),
+    )
+}
+
+#[tokio::test]
+async fn test_write_retry_rebuilds_only_failed_rows_after_route_refresh() {
+    for kind in [WriteKind::Insert, WriteKind::Delete, WriteKind::BulkInsert] {
+        let old_server = RegionTestServer::start().await;
+        let new_server = RegionTestServer::start().await;
+        old_server.fail_region(2, [RetryHint::RetryAfterRouteRefresh]);
+        let backend = test_util::prepare_mocked_backend().await;
+        test_util::create_partition_rule_manager(backend.clone()).await;
+        update_table_leader(&backend, &old_server.peer).await;
+        let (partition_manager, table_info_cache, registry, catalog_manager) =
+            create_routing_caches(backend.clone());
+        let table_info = table_info_cache.get(1).await.unwrap().unwrap();
+        let (_, old_versions) = partition_manager
+            .find_table_partition_rule(&table_info)
+            .await
+            .unwrap();
+        let manager = TableRouteManager::new(backend.clone());
+        let current = manager
+            .table_route_storage()
+            .get_with_raw_bytes(1)
+            .await
+            .unwrap()
+            .unwrap();
+        let old_routes = current.region_routes().unwrap();
+        let replaced = old_routes
+            .iter()
+            .find(|route| route.region.id.region_number() == 2)
+            .unwrap();
+        let mut routes = old_routes
+            .iter()
+            .filter(|route| route.region.id.region_number() != 2)
+            .cloned()
+            .collect::<Vec<_>>();
+        for (region, lower, upper) in [(4, 10, 30), (5, 30, 50)] {
+            let mut route = replaced.clone();
+            route.region.id = RegionId::new(1, region);
+            route.leader_peer = Some(new_server.peer.clone());
+            route.region.partition_expr = PartitionExpr::new(
+                Operand::Expr(PartitionExpr::new(
+                    Operand::Column("a".to_string()),
+                    RestrictedOp::GtEq,
+                    Operand::Value(datatypes::value::Value::Int32(lower)),
+                )),
+                RestrictedOp::And,
+                Operand::Expr(PartitionExpr::new(
+                    Operand::Column("a".to_string()),
+                    RestrictedOp::Lt,
+                    Operand::Value(datatypes::value::Value::Int32(upper)),
+                )),
+            )
+            .as_json_str()
+            .unwrap();
+            routes.push(route);
+        }
+        let invalidator = Arc::new(RecordingCacheInvalidator {
+            calls: Mutex::default(),
+            inner: Some(registry),
+            route_update: Mutex::new(Some((backend, current.update(routes).unwrap()))),
+            ..Default::default()
+        });
+        let clients = Arc::new(NodeClients::new(ChannelConfig::default()));
+        let dispatcher = WriteDispatcher::new(clients, partition_manager.clone()).with_retry(
+            build_retry_options(2),
+            catalog_manager,
+            invalidator.clone(),
+        );
+        let response = dispatcher
+            .dispatch(vec![
+                build_partitioned_request(kind, 1, old_versions[&1], &[70]),
+                build_partitioned_request(kind, 2, old_versions[&2], &[20, 40]),
+            ])
+            .await
+            .unwrap();
+        assert_eq!(response.affected_rows, 3, "{kind:?}");
+        assert_eq!(
+            old_server.attempt_counts(),
+            HashMap::from([
+                (RegionId::new(1, 1).as_u64(), 1),
+                (RegionId::new(1, 2).as_u64(), 1),
+            ]),
+            "{kind:?}"
+        );
+        let (_, versions) = partition_manager
+            .find_table_partition_rule(&table_info)
+            .await
+            .unwrap();
+        let mut writes = new_server
+            .service
+            .requests
+            .lock()
+            .unwrap()
+            .iter()
+            .map(request_parts)
+            .collect::<Vec<_>>();
+        writes.sort_by_key(|write| write.0);
+        assert_eq!(
+            writes,
+            vec![(4, versions[&4], vec![20]), (5, versions[&5], vec![40])],
+            "{kind:?}"
+        );
+        assert_eq!(
+            *invalidator.calls.lock().unwrap(),
+            vec![
+                vec![CacheIdent::TableId(1)],
+                vec![CacheIdent::TableName(TableName::new(
+                    "greptime", "public", "table_1"
+                ))],
+            ]
+        );
+    }
+}
+
+fn build_sparse_bulk_request(
+    region: u32,
+    version: Option<u64>,
+    tags: &[(&str, &str)],
+) -> (RegionRequest, RecordBatch) {
+    let codec = SparsePrimaryKeyCodec::schemaless();
+    let keys = tags
+        .iter()
+        .enumerate()
+        .map(|(index, (host, zone))| {
+            let mut key = Vec::new();
+            codec
+                .encode_value_refs(
+                    &[
+                        (sparse::RESERVED_COLUMN_ID_TABLE_ID, ValueRef::UInt32(42)),
+                        (
+                            sparse::RESERVED_COLUMN_ID_TSID,
+                            ValueRef::UInt64(index as u64),
+                        ),
+                        (10, ValueRef::String(host)),
+                        (20, ValueRef::String(zone)),
+                    ],
+                    &mut key,
+                )
+                .unwrap();
+            key
+        })
+        .collect::<Vec<_>>();
+    let batch = RecordBatch::try_new(
+        Arc::new(Schema::new(vec![
+            Field::new(consts::PRIMARY_KEY_COLUMN_NAME, DataType::Binary, false),
+            Field::new("host", DataType::Utf8, false),
+        ])),
+        vec![
+            Arc::new(BinaryArray::from_iter_values(keys)),
+            Arc::new(StringArray::from_iter_values(
+                tags.iter().map(|(host, _)| *host),
+            )),
+        ],
+    )
+    .unwrap();
+    let (schema, data_header, payload) = flight::record_batch_to_ipc(batch.clone()).unwrap();
+    let request = RegionRequest {
+        body: Some(Body::BulkInsert(BulkInsertRequest {
+            region_id: RegionId::new(1, region).as_u64(),
+            partition_expr_version: version.map(|value| PartitionExprVersion { value }),
+            body: Some(bulk_insert_request::Body::ArrowIpc(ArrowIpc {
+                schema,
+                data_header,
+                payload,
+            })),
+            ..Default::default()
+        })),
+        ..Default::default()
+    };
+    (request, batch)
+}
+
+#[tokio::test]
+async fn test_write_retry_restores_changed_partition_tags_for_failed_regions() {
+    let old_server = RegionTestServer::start().await;
+    let new_server = RegionTestServer::start().await;
+    old_server.fail_region(2, [RetryHint::RetryAfterRouteRefresh]);
+    let backend: KvBackendRef = Arc::new(MemoryKvBackend::new());
+    let metadata = TableMetadataManager::new(backend.clone());
+    let mut table_info = test_util::new_test_table_info(1, "physical", [1, 2].into_iter());
+    table_info.meta.schema = Arc::new(schema::Schema::new(vec![
+        schema::ColumnSchema::new("host", ConcreteDataType::string_datatype(), true),
+        schema::ColumnSchema::new("zone", ConcreteDataType::string_datatype(), true),
+    ]));
+    table_info.meta.primary_key_indices = vec![0, 1];
+    table_info.meta.partition_key_indices = vec![0];
+    table_info.meta.column_ids = vec![10, 20];
+    table_info.meta.options.extra_options.insert(
+        metric_engine_consts::PHYSICAL_TABLE_METADATA_KEY.to_string(),
+        String::new(),
+    );
+    let routes = [
+        expr::col("host").lt(value::Value::String("m".into())),
+        expr::col("host").gt_eq(value::Value::String("m".into())),
+    ]
+    .into_iter()
+    .enumerate()
+    .map(|(index, expr)| RegionRoute {
+        region: router::Region {
+            id: RegionId::new(1, index as u32 + 1),
+            partition_expr: expr.as_json_str().unwrap(),
+            ..Default::default()
+        },
+        leader_peer: Some(old_server.peer.clone()),
+        ..Default::default()
+    })
+    .collect();
+    metadata
+        .create_table_metadata(
+            table_info,
+            TableRouteValue::physical(routes),
+            Default::default(),
+        )
+        .await
+        .unwrap();
+    let (partition_manager, table_info_cache, registry, catalog_manager) =
+        create_routing_caches(backend.clone());
+    // Warm the catalog's name-keyed TableCache before the partition column changes.
+    let cached_table = catalog_manager
+        .table("greptime", "public", "physical", None)
+        .await
+        .unwrap()
+        .unwrap();
+    let cached_info = cached_table.table_info();
+    let (_, old_versions) = partition_manager
+        .find_table_partition_rule(&cached_info)
+        .await
+        .unwrap();
+    let current_info = metadata.table_info_manager().get(1).await.unwrap().unwrap();
+    let mut updated_info = current_info.table_info.clone();
+    updated_info.meta.partition_key_indices = vec![1];
+    metadata
+        .update_table_info(&current_info, None, updated_info)
+        .await
+        .unwrap();
+    let current_route = metadata
+        .table_route_manager()
+        .table_route_storage()
+        .get_with_raw_bytes(1)
+        .await
+        .unwrap()
+        .unwrap();
+    let mut routes = current_route.region_routes().unwrap().clone();
+    for (route, expr) in routes.iter_mut().zip([
+        expr::col("zone").lt(value::Value::String("m".into())),
+        expr::col("zone").gt_eq(value::Value::String("m".into())),
+    ]) {
+        route.region.partition_expr = expr.as_json_str().unwrap();
+        route.leader_peer = Some(new_server.peer.clone());
+    }
+    let invalidator = Arc::new(RecordingCacheInvalidator {
+        calls: Mutex::default(),
+        inner: Some(registry),
+        route_update: Mutex::new(Some((backend, current_route.update(routes).unwrap()))),
+        ..Default::default()
+    });
+    let clients = Arc::new(NodeClients::new(ChannelConfig::default()));
+    let dispatcher = WriteDispatcher::new(clients, partition_manager.clone()).with_retry(
+        build_retry_options(1),
+        catalog_manager,
+        invalidator.clone(),
+    );
+    // The successful row would move under the new rule, but must not be replayed.
+    let (successful, _) = build_sparse_bulk_request(1, old_versions[&1], &[("a", "west")]);
+    let (failed, batch) =
+        build_sparse_bulk_request(2, old_versions[&2], &[("z", "east"), ("z", "west")]);
+    dispatcher.dispatch(vec![successful, failed]).await.unwrap();
+    let counts = HashMap::from([
+        (RegionId::new(1, 1).as_u64(), 1),
+        (RegionId::new(1, 2).as_u64(), 1),
+    ]);
+    assert_eq!(old_server.attempt_counts(), counts);
+    assert_eq!(new_server.attempt_counts(), counts);
+    assert_eq!(
+        *invalidator.calls.lock().unwrap(),
+        vec![
+            vec![CacheIdent::TableId(1)],
+            vec![CacheIdent::TableName(TableName::new(
+                "greptime", "public", "physical"
+            ))],
+        ]
+    );
+    let refreshed_info = table_info_cache.get(1).await.unwrap().unwrap();
+    assert_eq!(refreshed_info.meta.partition_key_indices, vec![1]);
+    let (_, versions) = partition_manager
+        .find_table_partition_rule(&refreshed_info)
+        .await
+        .unwrap();
+    for request in new_server.service.requests.lock().unwrap().iter() {
+        let Some(Body::BulkInsert(bulk)) = &request.body else {
+            unreachable!()
+        };
+        let region = RegionId::from_u64(bulk.region_id).region_number();
+        assert_eq!(
+            bulk.partition_expr_version.map(|version| version.value),
+            versions[&region]
+        );
+        let Some(bulk_insert_request::Body::ArrowIpc(ipc)) = &bulk.body else {
+            unreachable!()
+        };
+        let actual = FlightDecoder::try_from_schema_bytes(&ipc.schema)
+            .unwrap()
+            .try_decode_record_batch(&ipc.data_header, &ipc.payload)
+            .unwrap();
+        assert_eq!(actual, batch.slice(region as usize - 1, 1));
+        assert!(actual.column_by_name("zone").is_none());
+    }
+}
+
+#[tokio::test]
+async fn test_resolve_peers_batches_logical_and_physical_regions() {
+    let backend = test_util::prepare_mocked_backend().await;
+    let partition_manager = test_util::create_partition_rule_manager(backend.clone()).await;
+    TableMetadataManager::new(backend)
+        .create_table_metadata(
+            test_util::new_test_table_info(42, "dispatcher_logical", [1, 2, 3].into_iter()),
+            TableRouteValue::logical(1),
+            Default::default(),
+        )
+        .await
+        .unwrap();
+    let clients = Arc::new(NodeClients::new(ChannelConfig::default()));
+    let dispatcher = WriteDispatcher::new(clients, partition_manager.clone());
+    let regions = [
+        RegionId::new(1, 1),
+        RegionId::new(1, 2),
+        RegionId::new(42, 1),
+        RegionId::new(42, 2),
+        RegionId::new(42, 1),
+    ];
+    let peers = dispatcher.resolve_peers(&regions).await.unwrap();
+    assert_eq!(peers.len(), 4);
+    for region in regions {
+        assert_eq!(
+            peers[&region].as_ref(),
+            &partition_manager.find_region_leader(region).await.unwrap()
+        );
+    }
+    assert!(Arc::ptr_eq(
+        &peers[&RegionId::new(1, 1)],
+        &peers[&RegionId::new(42, 1)],
+    ));
+    let missing = RegionId::new(42, 999);
+    let expected = partition_manager
+        .find_region_leader(missing)
+        .await
+        .unwrap_err();
+    let actual = dispatcher.resolve_peers(&[missing]).await.unwrap_err();
+    assert_eq!(actual.status_code(), expected.status_code());
+    assert_eq!(actual.retry_hint(), expected.retry_hint());
+    assert!(dispatcher.resolve_peers(&[]).await.unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn test_resolve_peers_shares_only_identical_peers() {
+    let backend = test_util::prepare_mocked_backend().await;
+    test_util::create_partition_rule_manager(backend.clone()).await;
+    let manager = TableRouteManager::new(backend.clone());
+    let storage = manager.table_route_storage();
+    let current = storage.get_with_raw_bytes(1).await.unwrap().unwrap();
+    let mut routes = current.region_routes().unwrap().clone();
+    let peer = Peer::new(7, "same-address");
+    let other = Peer::new(7, "other-address");
+    for route in &mut routes {
+        route.leader_peer = Some(if route.region.id.region_number() == 3 {
+            other.clone()
+        } else {
+            peer.clone()
+        });
+    }
+    let updated = current.update(routes).unwrap();
+    let (txn, _) = storage.build_update_txn(1, &current, &updated).unwrap();
+    assert!(backend.txn(txn).await.unwrap().succeeded);
+    let (partition_manager, _, _, _) = create_routing_caches(backend);
+    let dispatcher = WriteDispatcher::new(Arc::new(NodeClients::default()), partition_manager);
+    let regions = [1, 2, 3].map(|region| RegionId::new(1, region));
+    let peers = dispatcher.resolve_peers(&regions).await.unwrap();
+    assert_eq!(peers.len(), 3);
+    assert_eq!(peers[&regions[0]].as_ref(), &peer);
+    assert_eq!(peers[&regions[1]].as_ref(), &peer);
+    assert_eq!(peers[&regions[2]].as_ref(), &other);
+    assert!(Arc::ptr_eq(&peers[&regions[0]], &peers[&regions[1]]));
+    assert!(!Arc::ptr_eq(&peers[&regions[0]], &peers[&regions[2]]));
+}
+
+#[tokio::test]
+async fn test_dispatch_preserves_write_payloads_and_envelopes() {
+    let backend = test_util::prepare_mocked_backend().await;
+    let partition_manager = test_util::create_partition_rule_manager(backend.clone()).await;
+    TableMetadataManager::new(backend)
+        .create_table_metadata(
+            test_util::new_test_table_info(42, "dispatcher_logical", [1, 2, 3].into_iter()),
+            TableRouteValue::logical(1),
+            Default::default(),
+        )
+        .await
+        .unwrap();
+    let (sender, mut received) = tokio::sync::mpsc::channel(8);
+    let watcher = DatanodeWatcher::new(sender).with_handler(|_, _| Ok(RegionResponse::new(1)));
+    let dispatcher = WriteDispatcher::new(
+        Arc::new(MockDatanodeManager::new(watcher)),
+        partition_manager,
+    );
+    // Physical and logical regions share a peer but retain distinct region IDs.
+    let regions = [RegionId::new(1, 1), RegionId::new(42, 1)];
+    let rows = Rows {
+        schema: vec![helper::tag_column_schema("a", ColumnDataType::Int32)],
+        rows: vec![Row {
+            values: vec![ValueData::I32Value(7).into()],
+        }],
+    };
+    let version = Some(PartitionExprVersion { value: 17 });
+    let bodies = [
+        Body::Inserts(InsertRequests {
+            requests: regions
+                .iter()
+                .map(|region| InsertRequest {
+                    region_id: region.as_u64(),
+                    rows: Some(rows.clone()),
+                    partition_expr_version: version,
+                    skip_wal: true,
+                })
+                .collect(),
+        }),
+        Body::Deletes(DeleteRequests {
+            requests: regions
+                .iter()
+                .map(|region| DeleteRequest {
+                    region_id: region.as_u64(),
+                    rows: Some(rows.clone()),
+                    partition_expr_version: version,
+                })
+                .collect(),
+        }),
+    ];
+    for body in bodies {
+        let requests = ["first", "second"].map(|dbname| RegionRequest {
+            header: Some(RegionRequestHeader {
+                dbname: dbname.to_string(),
+                ..Default::default()
+            }),
+            body: Some(body.clone()),
+        });
+        let writes = dispatcher.prepare(requests.to_vec()).await.unwrap();
+        assert!(received.try_recv().is_err());
+        let response = dispatcher.execute(writes, None, None).await.unwrap();
+        assert_eq!(response.affected_rows, 2);
+        for request in requests {
+            assert_eq!(received.try_recv().unwrap(), (Peer::new(1, ""), request));
+        }
+        assert!(received.try_recv().is_err());
+    }
+    let requests = regions.map(|region| RegionRequest {
+        header: Some(RegionRequestHeader {
+            dbname: "bulk".to_string(),
+            ..Default::default()
+        }),
+        body: Some(Body::BulkInsert(BulkInsertRequest {
+            region_id: region.as_u64(),
+            partition_expr_version: version,
+            aligned_schema_version: None,
+            skip_wal: true,
+            body: Some(bulk_insert_request::Body::ArrowIpc(ArrowIpc {
+                schema: "schema".into(),
+                data_header: "header".into(),
+                payload: "payload".into(),
+            })),
+        })),
+    });
+    let response = dispatcher.dispatch(requests.to_vec()).await.unwrap();
+    assert_eq!(response.affected_rows, 2);
+    for request in requests {
+        assert_eq!(received.try_recv().unwrap(), (Peer::new(1, ""), request));
+    }
+    assert!(received.try_recv().is_err());
+
+    let error = dispatcher
+        .prepare(vec![build_insert_request(&[1, 999])])
+        .await
+        .unwrap_err();
+    assert!(matches!(error, Error::FindRegionLeader { .. }));
+    assert!(received.try_recv().is_err());
+}
+
+#[derive(Clone)]
+struct GatedDatanodeHandler {
+    entered: Arc<Barrier>,
+    rejected: Arc<AtomicBool>,
+    completed: Arc<AtomicBool>,
+    release: Arc<Notify>,
+}
+
+#[async_trait::async_trait]
+impl MockDatanodeHandler for GatedDatanodeHandler {
+    async fn handle(&self, peer: &Peer, _request: RegionRequest) -> Result<RegionResponse> {
+        self.entered.wait().await;
+        if peer.id == 1 {
+            self.rejected.store(true, Ordering::SeqCst);
+            return UnexpectedSnafu {
+                err_msg: "first region rejected",
+            }
+            .fail();
+        }
+        self.release.notified().await;
+        self.completed.store(true, Ordering::SeqCst);
+        Ok(RegionResponse::new(1))
+    }
+
+    async fn handle_query(
+        &self,
+        _peer: &Peer,
+        _request: QueryRequest,
+    ) -> Result<SendableRecordBatchStream> {
+        unimplemented!()
+    }
+}
+
+#[tokio::test]
+async fn test_dispatch_sends_concurrently_and_waits_for_siblings_after_error() {
+    let backend = test_util::prepare_mocked_backend().await;
+    let partition_manager = test_util::create_partition_rule_manager(backend).await;
+    let handler = GatedDatanodeHandler {
+        entered: Arc::new(Barrier::new(2)),
+        rejected: Arc::default(),
+        completed: Arc::default(),
+        release: Arc::default(),
+    };
+    let dispatcher = WriteDispatcher::new(
+        Arc::new(MockDatanodeManager::new(handler.clone())),
+        partition_manager,
+    );
+    let dispatch = dispatcher.dispatch(vec![build_insert_request(&[1, 2])]);
+    tokio::pin!(dispatch);
+    tokio::time::timeout(
+        Duration::from_secs(1),
+        futures::future::poll_fn(|cx| {
+            assert!(
+                dispatch.as_mut().poll(cx).is_pending(),
+                "dispatch returned while a sibling remained blocked"
+            );
+            if handler.rejected.load(Ordering::SeqCst) {
+                Poll::Ready(())
+            } else {
+                Poll::Pending
+            }
+        }),
+    )
+    .await
+    .expect("both region sends must reach the barrier concurrently");
+    assert!(!handler.completed.load(Ordering::SeqCst));
+    handler.release.notify_one();
+    let error = tokio::time::timeout(Duration::from_secs(1), dispatch)
+        .await
+        .unwrap()
+        .unwrap_err();
+    assert!(error.to_string().contains("first region rejected"));
+    assert!(handler.completed.load(Ordering::SeqCst));
+}
+
+#[tokio::test]
+async fn test_resolve_peers_cache_lookup_ablation() {
+    common_telemetry::init_default_ut_logging();
+    let backend = test_util::prepare_mocked_backend().await;
+    test_util::create_partition_rule_manager(backend.clone()).await;
+    TableMetadataManager::new(backend.clone())
+        .create_table_metadata(
+            test_util::new_test_table_info(42, "resolution_ablation", [1, 2, 3].into_iter()),
+            TableRouteValue::logical(1),
+            Default::default(),
+        )
+        .await
+        .unwrap();
+    // A dedicated cache label isolates counters from other concurrently running tests.
+    let cache_name = "write_dispatcher_resolution_ablation_table_route";
+    let routes = Arc::new(meta_cache::new_table_route_cache(
+        cache_name.to_string(),
+        moka::future::Cache::new(16),
+        backend.clone(),
+    ));
+    let partitions = Arc::new(partition::cache::new_partition_info_cache(
+        "write_dispatcher_resolution_ablation_partitions".to_string(),
+        moka::future::Cache::new(16),
+        routes.clone(),
+    ));
+    let partition_manager = Arc::new(PartitionRuleManager::new(backend, routes, partitions));
+    let dispatcher =
+        WriteDispatcher::new(Arc::new(NodeClients::default()), partition_manager.clone());
+    let regions = (0..256)
+        .map(|index| RegionId::new(if index % 2 == 0 { 1 } else { 42 }, index % 3 + 1))
+        .collect::<Vec<_>>();
+    let expected = dispatcher.resolve_peers(&regions).await.unwrap();
+    let counter = common_meta::metrics::CACHE_CONTAINER_CACHE_GET.with_label_values(&[cache_name]);
+    for run in 0..6 {
+        // Alternate order; compare the same warm cache, routes and deterministic workload.
+        let modes = if run % 2 == 0 {
+            ["delete", "insert", "batched"]
+        } else {
+            ["batched", "insert", "delete"]
+        };
+        for mode in modes {
+            let before = counter.get();
+            let started = Instant::now();
+            let (elapsed, peers_match) = if mode == "batched" {
+                let peers = dispatcher.resolve_peers(&regions).await.unwrap();
+                (started.elapsed(), peers == expected)
+            } else {
+                let mut peers = HashMap::new();
+                for region in &regions {
+                    if mode == "insert" && peers.contains_key(region) {
+                        continue;
+                    }
+                    peers.insert(
+                        *region,
+                        partition_manager.find_region_leader(*region).await.unwrap(),
+                    );
+                }
+                let elapsed = started.elapsed();
+                let peers_match = peers.len() == expected.len()
+                    && peers.iter().all(|(region, peer)| {
+                        expected
+                            .get(region)
+                            .is_some_and(|expected| expected.as_ref() == peer)
+                    });
+                (elapsed, peers_match)
+            };
+            let gets = counter.get() - before;
+            assert!(peers_match, "{mode}");
+            let expected_gets = match mode {
+                "delete" => 384,
+                "insert" => 9,
+                "batched" => 3,
+                _ => unreachable!(),
+            };
+            assert_eq!(gets, expected_gets);
+            common_telemetry::info!(
+                "route_resolution_ablation run={run} mode={mode} regions={} cache_gets={gets} elapsed_ns={}",
+                regions.len(),
+                elapsed.as_nanos()
+            );
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_insert_retry_rebuilds_logical_rows_in_mixed_table_envelope() {
+    check_write_retry_rebuilds_logical_rows_in_mixed_table_envelope(WriteKind::Insert).await;
+}
+
+#[tokio::test]
+async fn test_delete_retry_rebuilds_logical_rows_in_mixed_table_envelope() {
+    check_write_retry_rebuilds_logical_rows_in_mixed_table_envelope(WriteKind::Delete).await;
+}
+
+async fn check_write_retry_rebuilds_logical_rows_in_mixed_table_envelope(kind: WriteKind) {
+    let server = RegionTestServer::start().await;
+    let backend = test_util::prepare_mocked_backend().await;
+    test_util::create_partition_rule_manager(backend.clone()).await;
+    let metadata = TableMetadataManager::new(backend.clone());
+    let current = metadata.table_info_manager().get(1).await.unwrap().unwrap();
+    let mut physical_info = current.table_info.clone();
+    physical_info.meta.engine = metric_engine_consts::METRIC_ENGINE_NAME.to_string();
+    physical_info.meta.options.extra_options.insert(
+        metric_engine_consts::PHYSICAL_TABLE_METADATA_KEY.to_string(),
+        String::new(),
+    );
+    metadata
+        .update_table_info(&current, None, physical_info)
+        .await
+        .unwrap();
+    let mut logical_info =
+        test_util::new_test_table_info(42, "retry_logical", [1, 2, 3].into_iter());
+    logical_info.meta.engine = metric_engine_consts::METRIC_ENGINE_NAME.to_string();
+    logical_info.meta.options.extra_options.insert(
+        metric_engine_consts::LOGICAL_TABLE_METADATA_KEY.to_string(),
+        "table_1".to_string(),
+    );
+    // Persisted logical metadata inherits partition columns from the physical table.
+    logical_info.meta.partition_key_indices.clear();
+    // Physical column `a` is at index 0, but logical column `a` is at index 2.
+    let mut columns = logical_info.meta.schema.column_schemas().to_vec();
+    columns.swap(0, 2);
+    logical_info.meta.schema = Arc::new(schema::Schema::new(columns));
+    logical_info.meta.primary_key_indices = vec![2];
+    metadata
+        .create_table_metadata(
+            logical_info,
+            TableRouteValue::logical(1),
+            Default::default(),
+        )
+        .await
+        .unwrap();
+    update_table_leader(&backend, &server.peer).await;
+    let (partition_manager, table_info_cache, registry, catalog_manager) =
+        create_routing_caches(backend);
+    let table_info = table_info_cache.get(1).await.unwrap().unwrap();
+    assert_eq!(table_info.meta.partition_key_indices, vec![0]);
+    assert!(
+        table_info_cache
+            .get(42)
+            .await
+            .unwrap()
+            .unwrap()
+            .meta
+            .partition_key_indices
+            .is_empty()
+    );
+    let (_, versions) = partition_manager
+        .find_table_partition_rule(&table_info)
+        .await
+        .unwrap();
+    let invalidator = Arc::new(RecordingCacheInvalidator {
+        inner: Some(registry),
+        ..Default::default()
+    });
+    let clients = Arc::new(NodeClients::new(ChannelConfig::default()));
+    let dispatcher = WriteDispatcher::new(clients, partition_manager).with_retry(
+        build_retry_options(2),
+        catalog_manager,
+        invalidator.clone(),
+    );
+    let physical_id = RegionId::new(1, 1).as_u64();
+    let stale_logical_id = RegionId::new(42, 2).as_u64();
+    let rebuilt_logical_ids = [1, 3].map(|region| RegionId::new(42, region).as_u64());
+    let mut status = Status::unavailable("partition changed");
+    status.metadata_mut().insert(
+        common_error::GREPTIME_DB_HEADER_ERROR_RETRY_HINT,
+        RetryHint::RetryAfterRouteRefresh.as_str().parse().unwrap(),
+    );
+    server
+        .service
+        .rejections
+        .lock()
+        .unwrap()
+        .insert(stale_logical_id, VecDeque::from([status]));
+
+    let header = Some(RegionRequestHeader {
+        dbname: "greptime.public".to_string(),
+        ..Default::default()
+    });
+    let mut physical = build_partitioned_request(kind, 1, versions[&1], &[70]);
+    physical.header = header.clone();
+    // Only the failed logical rows are split again, preserving their logical table ID.
+    let mut logical = build_partitioned_request(kind, 2, Some(0), &[1, 70]);
+    let mut rebuilt_lower = build_partitioned_request(kind, 3, versions[&3], &[1]);
+    let mut rebuilt_upper = build_partitioned_request(kind, 1, versions[&1], &[70]);
+    for request in [&mut logical, &mut rebuilt_lower, &mut rebuilt_upper] {
+        request.header = header.clone();
+        let region_id = match request.body.as_mut().unwrap() {
+            Body::Inserts(inserts) => &mut inserts.requests[0].region_id,
+            Body::Deletes(deletes) => &mut deletes.requests[0].region_id,
+            _ => unreachable!(),
+        };
+        *region_id = RegionId::new(42, RegionId::from_u64(*region_id).region_number()).as_u64();
+    }
+    let mut envelope = physical.clone();
+    match (
+        envelope.body.as_mut().unwrap(),
+        logical.body.clone().unwrap(),
+    ) {
+        (Body::Inserts(physical), Body::Inserts(logical)) => {
+            physical.requests.extend(logical.requests);
+        }
+        (Body::Deletes(physical), Body::Deletes(logical)) => {
+            physical.requests.extend(logical.requests);
+        }
+        _ => unreachable!(),
+    }
+    let response = dispatcher.dispatch(vec![envelope]).await.unwrap();
+    assert_eq!(response.affected_rows, 3, "{kind:?}");
+    assert_eq!(
+        server.attempt_counts(),
+        HashMap::from([
+            (physical_id, 1),
+            (stale_logical_id, 1),
+            (rebuilt_logical_ids[0], 1),
+            (rebuilt_logical_ids[1], 1),
+        ]),
+        "{kind:?}"
+    );
+    let mut requests = server.service.requests.lock().unwrap().clone();
+    requests.sort_by_key(|request| write_region_id(request).unwrap().as_u64());
+    assert_eq!(
+        requests,
+        vec![physical, rebuilt_upper, logical, rebuilt_lower],
+        "{kind:?}"
+    );
+    let calls = invalidator.calls.lock().unwrap();
+    assert_eq!(calls.len(), 2, "{kind:?}");
+    assert_eq!(calls[0].len(), 2, "{kind:?}");
+    assert!(calls[0].contains(&CacheIdent::TableId(1)));
+    assert!(calls[0].contains(&CacheIdent::TableId(42)));
+    assert_eq!(
+        calls[1],
+        vec![CacheIdent::TableName(TableName::new(
+            "greptime",
+            "public",
+            "retry_logical"
+        ))],
+        "{kind:?}"
+    );
+}
+
+#[tokio::test]
+async fn test_write_retry_rejects_reused_table_name() {
+    let server = RegionTestServer::start().await;
+    server.fail_region(2, [RetryHint::RetryAfterRouteRefresh]);
+    let backend = test_util::prepare_mocked_backend().await;
+    test_util::create_partition_rule_manager(backend.clone()).await;
+    update_table_leader(&backend, &server.peer).await;
+    let (partition_manager, _, registry, catalog_manager) = create_routing_caches(backend.clone());
+    // Prime both name-keyed caches with the old identity before the concurrent rename.
+    let original = catalog_manager
+        .table("greptime", "public", "table_1", None)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(original.table_info().table_id(), 1);
+    let invalidator = Arc::new(RecordingCacheInvalidator {
+        inner: Some(registry),
+        rename_and_recreate: Mutex::new(Some(backend)),
+        ..Default::default()
+    });
+    let dispatcher = WriteDispatcher::new(Arc::new(NodeClients::default()), partition_manager)
+        .with_retry(build_retry_options(1), catalog_manager.clone(), invalidator);
+    let error = dispatcher
+        .dispatch(vec![build_partitioned_request(
+            WriteKind::Insert,
+            2,
+            Some(0),
+            &[20],
+        )])
+        .await
+        .unwrap_err();
+    assert!(
+        error.to_string().contains("changed ID from 1 to 42"),
+        "{error:?}"
+    );
+    assert_eq!(
+        server.attempt_counts(),
+        HashMap::from([(RegionId::new(1, 2).as_u64(), 1)])
+    );
+    let replacement = catalog_manager
+        .table("greptime", "public", "table_1", None)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(replacement.table_info().table_id(), 42);
+}
+
+#[tokio::test]
+async fn test_with_retry_can_disable_previously_enabled_retries() {
+    let server = RegionTestServer::start().await;
+    let dispatcher = server.create_dispatcher(1).await;
+    let retry = dispatcher.retry.as_ref().unwrap();
+    let catalog_manager = retry.catalog_manager.clone();
+    let cache_invalidator = retry.cache_invalidator.clone();
+    let dispatcher =
+        dispatcher.with_retry(build_retry_options(0), catalog_manager, cache_invalidator);
+    assert!(dispatcher.retry.is_none());
+    server.fail_region(1, [RetryHint::Retryable]);
+    assert!(
+        dispatcher
+            .dispatch(vec![build_insert_request(&[1])])
+            .await
+            .is_err()
+    );
+    assert_eq!(server.attempt_counts()[&RegionId::new(1, 1).as_u64()], 1);
+}
diff --git a/src/partition/src/manager.rs b/src/partition/src/manager.rs
index 89bb61c4174..68c9586e908 100644
--- a/src/partition/src/manager.rs
+++ b/src/partition/src/manager.rs
@@ -206,17 +206,25 @@ impl PartitionRuleManager {
             .iter()
             .map(|r| (r.id.region_number(), r.partition_expr_version))
             .collect::<HashMap<RegionNumber, Option<u64>>>();
-        let regions = partition_info
+        let (mut regions, exprs): (Vec<_>, Vec<_>) = partition_info
             .partitions
             .iter()
-            .map(|x| x.id.region_number())
-            .collect::<Vec<RegionNumber>>();
-        let exprs = partition_info
-            .partitions
-            .iter()
-            .filter_map(|x| x.partition_expr.as_ref())
-            .cloned()
-            .collect::<Vec<_>>();
+            .filter_map(|partition| {
+                partition
+                    .partition_expr
+                    .as_ref()
+                    .map(|expr| (partition.id.region_number(), expr.clone()))
+            })
+            .unzip();
+        // Empty expressions belong to the default region. Keep it after the
+        // explicit regions so expression indices still identify the right region.
+        regions.extend(
+            partition_info
+                .partitions
+                .iter()
+                .filter(|partition| partition.partition_expr.is_none())
+                .map(|partition| partition.id.region_number()),
+        );
         let partition_rule = Arc::new(MultiDimPartitionRule::try_new(
             partition_columns,
             regions,
diff --git a/src/pipeline/src/etl/transform/transformer/greptime.rs b/src/pipeline/src/etl/transform/transformer/greptime.rs
index eb25071c91c..16c9e3399b6 100644
--- a/src/pipeline/src/etl/transform/transformer/greptime.rs
+++ b/src/pipeline/src/etl/transform/transformer/greptime.rs
@@ -911,7 +911,7 @@ fn identity_pipeline_inner(
     }
 
     let column_count = schema_info.schema.len();
-    for (_, row) in opt_map.iter_mut() {
+    for row in opt_map.values_mut() {
         for row in row.iter_mut() {
             assert!(
                 column_count >= row.values.len(),
diff --git a/src/promql/benches/bench_range_fn.rs b/src/promql/benches/bench_range_fn.rs
index b4e026bae3d..51e0aefdc79 100644
--- a/src/promql/benches/bench_range_fn.rs
+++ b/src/promql/benches/bench_range_fn.rs
@@ -17,25 +17,14 @@
 use std::sync::Arc;
 
 use criterion::{BenchmarkId, Criterion, criterion_group};
-use datafusion::arrow::array::{
-    Array, ArrayRef, DictionaryArray, Float64Array, TimestampMillisecondArray,
-};
-use datafusion::arrow::datatypes::{
-    DataType as ArrowDataType, Field as ArrowField, Int64Type, Schema,
-};
-use datafusion::arrow::record_batch::RecordBatch;
-use datafusion::common::ToDFSchema;
-use datafusion::datasource::memory::MemorySourceConfig;
-use datafusion::datasource::source::DataSourceExec;
-use datafusion::execution::context::TaskContext;
-use datafusion::logical_expr::{EmptyRelation, LogicalPlan};
-use datafusion::physical_plan::{ColumnarValue, ExecutionPlan};
+use datafusion::arrow::array::{Array, Float64Array, TimestampMillisecondArray};
+use datafusion::arrow::datatypes::TimeUnit;
+use datafusion::physical_plan::ColumnarValue;
 use datafusion_common::ScalarValue;
 use datafusion_common::config::ConfigOptions;
 use datafusion_expr::ScalarFunctionArgs;
 use datatypes::arrow::datatypes::{DataType, Field};
-use futures::StreamExt;
-use promql::extension_plan::RangeManipulate;
+use promql::extension_plan::RangeManipulateStream;
 use promql::functions::{
     AbsentOverTime, Changes, CountOverTime, Delta, DoubleExponentialSmoothing, IDelta, Increase,
     LastOverTime, MaxOverTime, MinOverTime, PredictLinear, PresentOverTime, QuantileOverTime, Rate,
@@ -964,223 +953,294 @@ fn bench_edge_count_functions(c: &mut Criterion) {
     group.finish();
 }
 
-const RANGE_MANIPULATE_CADENCE_MS: i64 = 15_000;
+/// One cursor-scan workload: the timeline, the window and the aligned instants to visit.
+#[derive(Clone, Debug)]
+struct CursorScanWorkload {
+    time_unit: TimeUnit,
+    offset_ms: i64,
+    timestamps: Vec<i64>,
+    window_ms: i64,
+    interval_ms: i64,
+    start_ms: i64,
+    end_ms: i64,
+}
 
-fn make_range_manipulate_batch(timestamps: Vec<i64>, field_count: usize) -> RecordBatch {
-    let mut fields = Vec::with_capacity(field_count + 1);
-    let mut columns: Vec<ArrayRef> = Vec::with_capacity(field_count + 1);
-    fields.push(ArrowField::new(
-        "timestamp",
-        ArrowDataType::Timestamp(datafusion::arrow::datatypes::TimeUnit::Millisecond, None),
-        false,
-    ));
-    columns.push(Arc::new(TimestampMillisecondArray::from(timestamps)) as _);
-
-    for field_index in 0..field_count {
-        fields.push(ArrowField::new(
-            format!("value_{field_index}"),
-            ArrowDataType::Float64,
-            false,
-        ));
-        let values = (0..columns[0].len())
-            .map(|row| row as f64 + field_index as f64 * 0.01)
-            .collect::<Vec<_>>();
-        columns.push(Arc::new(Float64Array::from(values)) as _);
+impl CursorScanWorkload {
+    /// The workload through the narrow `i64` carrier, or `None` when production would fall
+    /// back to `i128` for it.
+    ///
+    /// For the fallback cases the fast path is timed on a twin workload: the same shape
+    /// translated onto a timeline the narrow carrier holds, which keeps the number of sample
+    /// and window comparisons identical to the fallback run.
+    fn bench_scan_narrow(&self) -> Option<Vec<(u32, u32)>> {
+        RangeManipulateStream::bench_scan_narrow(
+            self.time_unit,
+            self.offset_ms,
+            self.window_ms,
+            self.interval_ms,
+            &self.timestamps,
+            self.start_ms,
+            self.end_ms,
+        )
     }
 
-    RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).unwrap()
-}
+    /// The workload through the exact `i128` carrier, the fallback production takes
+    /// whenever [`Self::bench_scan_narrow`] returns `None`.
+    fn bench_scan_wide(&self) -> Vec<(u32, u32)> {
+        RangeManipulateStream::bench_scan_wide(
+            self.time_unit,
+            self.offset_ms,
+            self.window_ms,
+            self.interval_ms,
+            &self.timestamps,
+            self.start_ms,
+            self.end_ms,
+        )
+    }
 
-async fn execute_and_drain(
-    plan: Arc<dyn ExecutionPlan>,
-    task_ctx: Arc<TaskContext>,
-) -> Vec<RecordBatch> {
-    let mut stream = plan.execute(0, task_ctx).unwrap();
-    let mut output = Vec::new();
-    while let Some(batch) = stream.next().await {
-        output.push(batch.unwrap());
+    fn evaluations(&self) -> usize {
+        ((self.end_ms - self.start_ms) / self.interval_ms) as usize + 1
+    }
+
+    fn label(&self) -> String {
+        format!(
+            "N{}_eval{}_window{}x{}ms",
+            self.timestamps.len(),
+            self.evaluations(),
+            self.window_ms / self.interval_ms,
+            self.interval_ms
+        )
     }
-    output
 }
 
-fn range_keys(batch: &RecordBatch, index: usize) -> Vec<(u32, u32)> {
-    let ranges = batch
-        .column(index)
-        .as_any()
-        .downcast_ref::<DictionaryArray<Int64Type>>()
-        .unwrap()
-        .clone();
-    RangeArray::try_new(ranges)
-        .unwrap()
-        .ranges()
-        .map(Option::unwrap)
-        .collect()
+/// Cadence of the cursor-scan benchmarks: PromQL's usual 15s step.
+const CURSOR_SCAN_CADENCE_MS: i64 = 15_000;
+
+/// Milliseconds of a one-hour window, the widest window benchmarked here.
+const CURSOR_SCAN_HOUR_MS: i64 = 3_600_000;
+
+/// Builds a workload from a first timestamp and a sample count.
+///
+/// `sample_spacing_native` is the distance between samples in native ticks: 15s worth, so
+/// every native-precision workload has the same shape (one sample per cadence, 20 samples
+/// per 300s window). The aligned instants start at the first shifted sample, so every
+/// window overlaps the input the same way in both arms of the A/B comparison.
+fn cursor_scan_workload(
+    time_unit: TimeUnit,
+    offset_ms: i64,
+    first_timestamp: i64,
+    samples: usize,
+    window_ms: i64,
+    sample_spacing_native: i64,
+) -> CursorScanWorkload {
+    let interval_ms = CURSOR_SCAN_CADENCE_MS;
+    let timestamps = (0..samples as i64)
+        .map(|index| first_timestamp + index * sample_spacing_native)
+        .collect::<Vec<_>>();
+    // `Millisecond` instants of the first shifted sample, flooring like `calculate_range`.
+    let start_ms = shifted_floor_millis(time_unit, offset_ms, first_timestamp);
+    let evaluations = samples - 1;
+    CursorScanWorkload {
+        time_unit,
+        offset_ms,
+        timestamps,
+        window_ms,
+        interval_ms,
+        start_ms,
+        end_ms: start_ms + evaluations as i64 * interval_ms,
+    }
 }
 
-fn brute_force_range_keys(
-    timestamps: &[i64],
-    evaluations: usize,
-    window_points: usize,
-) -> Vec<(u32, u32)> {
-    let range = window_points as i64 * RANGE_MANIPULATE_CADENCE_MS;
-    (0..evaluations)
-        .map(|evaluation| {
-            let current = evaluation as i64 * RANGE_MANIPULATE_CADENCE_MS;
-            let mut offset = None;
-            let mut length = 0;
-            for (index, timestamp) in timestamps.iter().enumerate() {
-                if *timestamp > current - range && *timestamp <= current {
-                    offset.get_or_insert(index as u32);
-                    length += 1;
-                }
-            }
-            (offset.unwrap_or(0), length)
-        })
-        .collect()
+/// Native ticks of one benchmark cadence, i.e. 15s in the given precision.
+fn cadence_in_native_ticks(time_unit: TimeUnit) -> i64 {
+    match time_unit {
+        TimeUnit::Second => CURSOR_SCAN_CADENCE_MS / 1_000,
+        TimeUnit::Millisecond => CURSOR_SCAN_CADENCE_MS,
+        TimeUnit::Microsecond => CURSOR_SCAN_CADENCE_MS * 1_000,
+        TimeUnit::Nanosecond => CURSOR_SCAN_CADENCE_MS * 1_000_000,
+    }
 }
 
-fn validate_range_manipulate_output(
-    output: &[RecordBatch],
-    field_count: usize,
-    expected_range_keys: Option<&[(u32, u32)]>,
-) {
-    let Some(expected_range_keys) = expected_range_keys else {
-        assert!(output.is_empty());
-        return;
+/// Floor of a shifted sample in milliseconds, in exact `i128` native precision.
+fn shifted_floor_millis(time_unit: TimeUnit, offset_ms: i64, timestamp: i64) -> i64 {
+    let scale = match time_unit {
+        TimeUnit::Second => 1_000_000_000i128,
+        TimeUnit::Millisecond => 1_000_000i128,
+        TimeUnit::Microsecond => 1_000i128,
+        TimeUnit::Nanosecond => 1i128,
+    };
+    i64::try_from(
+        ((timestamp as i128) * scale + (offset_ms as i128) * 1_000_000).div_euclid(1_000_000),
+    )
+    .expect("the shifted millisecond must stay legal")
+}
+
+/// A/B benchmark of the cursor-scan carriers behind `RangeManipulate::scan_ranges`.
+///
+/// `RangeManipulate` scans the aligned instants in `i64` nanoseconds whenever
+/// `narrow_scan` proves the batch and the bounds fit, and in exact `i128` nanoseconds
+/// otherwise. Both arms below drive the production scan through the carrier the operator
+/// would pick, so the numbers isolate the carrier and not the surrounding operator work:
+///
+/// - `ms_zero_offset`: millisecond batch with no offset, the `i64` fast path. The same
+///   workload is also timed through `i128` to price the fallback on this input.
+/// - `ms_zero_offset_long_window`: same, with a one-hour window, where the scan advances
+///   both cursors much further per evaluation.
+/// - `ms_large_offset`: an offset whose nanosecond product overflows `i64`, so production
+///   falls back to `i128`. The `i64` arm times the identical workload shape translated onto
+///   a narrow timeline, which keeps the selections and thus the work identical.
+/// - `ns_native_floor`: nanosecond batch at the `i64::MIN` floor, where the shifted start
+///   bound underflows `i64` nanoseconds, so production falls back to `i128`. The `i64` arm
+///   again times the translated narrow shape.
+///
+/// Every arm asserts that both carriers selected the same ranges, so the comparison cannot
+/// be won by doing less work. The fallback triggers themselves are pinned by the unit tests
+/// in `range_manipulate.rs` (`scan_falls_back_to_i128_when_only_the_sample_tail_overflows`
+/// and `scan_carriers_split_at_the_nanosecond_boundaries`).
+fn bench_cursor_scan_carriers(c: &mut Criterion) {
+    const SAMPLES: usize = 4_096;
+    const SHORT_WINDOW_MS: i64 = 20 * CURSOR_SCAN_CADENCE_MS;
+    // `i64::MAX` milliseconds is ~9.22e18 ms; one microsecond past it in the nanosecond
+    // product makes `narrow_scan` reject the offset, while the shifted millisecond stays legal.
+    const LARGE_OFFSET_MS: i64 = 9_223_372_036_855;
+    const LARGE_OFFSET_BASE_MS: i64 = 1_000_000_000_000_000;
+    const NANOSECOND_FLOOR_SHIFT_NS: i64 = 9_223_372_036_000_000_000;
+    const NANOSECOND_FLOOR_SAMPLES: usize = 4_096;
+
+    let ms_zero_offset = cursor_scan_workload(
+        TimeUnit::Millisecond,
+        0,
+        0,
+        SAMPLES,
+        SHORT_WINDOW_MS,
+        cadence_in_native_ticks(TimeUnit::Millisecond),
+    );
+    let ms_zero_offset_long_window = cursor_scan_workload(
+        TimeUnit::Millisecond,
+        0,
+        0,
+        SAMPLES,
+        CURSOR_SCAN_HOUR_MS,
+        cadence_in_native_ticks(TimeUnit::Millisecond),
+    );
+    // The large offset is shifted inside one millisecond of the nanosecond ceiling, so the
+    // payload stays legal: the fallback is driven by the product, not by an illegal instant.
+    let ms_large_offset = cursor_scan_workload(
+        TimeUnit::Millisecond,
+        LARGE_OFFSET_MS,
+        LARGE_OFFSET_BASE_MS,
+        SAMPLES,
+        SHORT_WINDOW_MS,
+        cadence_in_native_ticks(TimeUnit::Millisecond),
+    );
+    // The narrow twin of `ms_large_offset`: the same batch shape without the offset.
+    let ms_large_offset_narrow = cursor_scan_workload(
+        TimeUnit::Millisecond,
+        0,
+        0,
+        SAMPLES,
+        SHORT_WINDOW_MS,
+        cadence_in_native_ticks(TimeUnit::Millisecond),
+    );
+
+    // Nanosecond batch on the native floor: samples at `i64::MIN + i * 15s`, whose shifted
+    // start bound underflows `i64` nanoseconds.
+    let nanosecond_floor_first = i64::MIN;
+    let nanosecond_floor = cursor_scan_workload(
+        TimeUnit::Nanosecond,
+        0,
+        nanosecond_floor_first,
+        NANOSECOND_FLOOR_SAMPLES,
+        SHORT_WINDOW_MS,
+        cadence_in_native_ticks(TimeUnit::Nanosecond),
+    );
+    // The narrow twin: the same shape translated by a multiple of one millisecond, so both
+    // the samples and the aligned instants keep their relative geometry.
+    let nanosecond_floor_narrow = CursorScanWorkload {
+        time_unit: TimeUnit::Nanosecond,
+        offset_ms: 0,
+        timestamps: nanosecond_floor
+            .timestamps
+            .iter()
+            .map(|timestamp| timestamp + NANOSECOND_FLOOR_SHIFT_NS)
+            .collect(),
+        window_ms: nanosecond_floor.window_ms,
+        interval_ms: nanosecond_floor.interval_ms,
+        start_ms: nanosecond_floor.start_ms + NANOSECOND_FLOOR_SHIFT_NS / 1_000_000,
+        end_ms: nanosecond_floor.end_ms + NANOSECOND_FLOOR_SHIFT_NS / 1_000_000,
     };
 
-    assert_eq!(output.len(), 1);
-    let batch = &output[0];
-    assert_eq!(batch.num_rows(), expected_range_keys.len());
-
-    let timestamp_range_keys = range_keys(batch, field_count + 1);
-    assert_eq!(timestamp_range_keys, expected_range_keys);
-
-    for field_index in 0..field_count {
-        assert_eq!(range_keys(batch, field_index + 1), expected_range_keys);
-    }
-}
-
-fn bench_range_manipulate_wall_time(c: &mut Criterion) {
-    let mut group = c.benchmark_group("range_manipulate_wall_time");
-    let primary_points = 4_096;
-    let sparse_evaluations = primary_points - 1;
-    let mut cases = vec![
+    let cases = [
         (
-            "one_field",
-            (0..primary_points)
-                .map(|point| point as i64 * RANGE_MANIPULATE_CADENCE_MS)
-                .collect::<Vec<_>>(),
-            primary_points,
-            4,
-            1,
+            "ms_zero_offset",
+            ms_zero_offset.clone(),
+            ms_zero_offset,
             false,
         ),
         (
-            "one_field",
-            (0..primary_points)
-                .map(|point| point as i64 * RANGE_MANIPULATE_CADENCE_MS)
-                .collect::<Vec<_>>(),
-            primary_points,
-            20,
-            1,
+            "ms_zero_offset_long_window",
+            ms_zero_offset_long_window.clone(),
+            ms_zero_offset_long_window,
             false,
         ),
         (
-            "one_field",
-            (0..primary_points)
-                .map(|point| point as i64 * RANGE_MANIPULATE_CADENCE_MS)
-                .collect::<Vec<_>>(),
-            primary_points,
-            240,
-            1,
-            false,
-        ),
-        (
-            "regular_sparse",
-            (0..sparse_evaluations)
-                .step_by(2)
-                .map(|point| point as i64 * RANGE_MANIPULATE_CADENCE_MS)
-                .collect::<Vec<_>>(),
-            sparse_evaluations,
-            20,
-            1,
-            false,
-        ),
-        (
-            "all_empty_pathological",
-            (0..primary_points)
-                .map(|point| {
-                    (primary_points as i64 + 21 + point as i64) * RANGE_MANIPULATE_CADENCE_MS
-                })
-                .collect::<Vec<_>>(),
-            primary_points,
-            20,
-            1,
+            "ms_large_offset",
+            ms_large_offset_narrow,
+            ms_large_offset,
             true,
         ),
         (
-            "multi_field_control",
-            (0..primary_points)
-                .map(|point| point as i64 * RANGE_MANIPULATE_CADENCE_MS)
-                .collect::<Vec<_>>(),
-            primary_points,
-            20,
-            4,
-            false,
+            "ns_native_floor",
+            nanosecond_floor_narrow,
+            nanosecond_floor,
+            true,
         ),
     ];
 
-    for (case_name, timestamps, evaluations, window_points, field_count, expect_empty) in
-        cases.drain(..)
-    {
-        let expected_range_keys = (!expect_empty)
-            .then(|| brute_force_range_keys(&timestamps, evaluations, window_points));
-        let input_batch = make_range_manipulate_batch(timestamps, field_count);
-        let input_rows = input_batch.num_rows();
-        let input_schema = input_batch.schema();
-        let logical_input = LogicalPlan::EmptyRelation(EmptyRelation {
-            produce_one_row: false,
-            schema: input_schema.clone().to_dfschema_ref().unwrap(),
-        });
-        let field_columns = (0..field_count)
-            .map(|field_index| format!("value_{field_index}"))
-            .collect::<Vec<_>>();
-        let logical_plan = RangeManipulate::new(
-            0,
-            (evaluations as i64 - 1) * RANGE_MANIPULATE_CADENCE_MS,
-            RANGE_MANIPULATE_CADENCE_MS,
-            0,
-            window_points as i64 * RANGE_MANIPULATE_CADENCE_MS,
-            "timestamp".to_string(),
-            field_columns,
-            logical_input,
-        )
-        .unwrap();
-        let physical_input: Arc<dyn ExecutionPlan> = Arc::new(DataSourceExec::new(Arc::new(
-            MemorySourceConfig::try_new(&[vec![input_batch]], input_schema, None).unwrap(),
-        )));
-        let execution_plan = logical_plan.to_execution_plan(physical_input);
-        let runtime = tokio::runtime::Runtime::new().unwrap();
-        let task_ctx = datafusion::prelude::SessionContext::new().task_ctx();
+    let mut group = c.benchmark_group("cursor_scan_carriers");
+    group.warm_up_time(std::time::Duration::from_millis(500));
+    group.measurement_time(std::time::Duration::from_secs(2));
+    group.sample_size(50);
 
-        // Validate the public operator output and RangeArray keys before timing.
-        let output = runtime.block_on(execute_and_drain(execution_plan.clone(), task_ctx.clone()));
-        validate_range_manipulate_output(&output, field_count, expected_range_keys.as_deref());
+    for (case_name, narrow, wide, wide_falls_back) in cases {
+        // Both arms must be timed on work the operator would really do: the narrow arm in
+        // `i64`, and the wide arm in `i128` exactly when the narrow baselines overflow.
+        let narrow_expected = narrow
+            .bench_scan_narrow()
+            .unwrap_or_else(|| panic!("{case_name}: the i64 arm must fit the narrow carrier"));
+        assert_eq!(
+            wide.bench_scan_narrow().is_none(),
+            wide_falls_back,
+            "{case_name}: the i128 arm's fallback trigger"
+        );
+        // Fairness check before timing: both carriers have to select the same ranges, which
+        // makes the sample and window comparisons of the two arms identical.
+        assert_eq!(
+            wide.bench_scan_wide(),
+            narrow_expected,
+            "{case_name}: the two carriers must select the same ranges"
+        );
+        assert_eq!(
+            narrow_expected.len(),
+            narrow.evaluations(),
+            "{case_name}: one range per aligned evaluation instant"
+        );
 
-        // This measures public RangeManipulate execution wall time, including stream draining.
+        group.throughput(criterion::Throughput::Elements(
+            narrow.timestamps.len() as u64
+        ));
         group.bench_with_input(
-            BenchmarkId::new(
-                case_name,
-                format!("N{input_rows}_eval{evaluations}_window{window_points}x15s"),
-            ),
-            &(),
-            |b, _| {
-                b.iter(|| {
-                    let output = runtime
-                        .block_on(execute_and_drain(execution_plan.clone(), task_ctx.clone()));
-                    std::hint::black_box(output);
-                })
+            BenchmarkId::new(format!("{case_name}/i64"), narrow.label()),
+            &narrow,
+            |b, workload| {
+                b.iter(|| std::hint::black_box(workload.bench_scan_narrow()));
+            },
+        );
+        group.bench_with_input(
+            BenchmarkId::new(format!("{case_name}/i128"), wide.label()),
+            &wide,
+            |b, workload| {
+                b.iter(|| std::hint::black_box(workload.bench_scan_wide()));
             },
         );
     }
@@ -1196,5 +1256,5 @@ criterion_group!(
     bench_rate_window_steps,
     bench_edge_count_functions,
     bench_extrema_functions,
-    bench_range_manipulate_wall_time
+    bench_cursor_scan_carriers
 );
diff --git a/src/promql/src/extension_plan/absent.rs b/src/promql/src/extension_plan/absent.rs
index fa811b3df7d..9afe85873c5 100644
--- a/src/promql/src/extension_plan/absent.rs
+++ b/src/promql/src/extension_plan/absent.rs
@@ -34,7 +34,7 @@ use datafusion::physical_plan::{
     Partitioning, PhysicalExpr, PlanProperties, RecordBatchStream, SendableRecordBatchStream,
 };
 use datafusion_common::DFSchema;
-use datafusion_expr::{EmptyRelation, col};
+use datafusion_expr::{EmptyRelation, ident};
 use datatypes::arrow;
 use datatypes::arrow::array::{ArrayRef, Float64Array, TimestampMillisecondArray};
 use datatypes::arrow::datatypes::{DataType, Field, SchemaRef, TimeUnit};
@@ -108,7 +108,7 @@ impl UserDefinedLogicalNodeCore for Absent {
             return vec![];
         }
 
-        vec![col(&self.time_index_column)]
+        vec![ident(&self.time_index_column)]
     }
 
     fn necessary_children_exprs(&self, _output_columns: &[usize]) -> Option<Vec<Vec<usize>>> {
diff --git a/src/promql/src/extension_plan/empty_metric.rs b/src/promql/src/extension_plan/empty_metric.rs
index 91c8a1666a2..a534bf20493 100644
--- a/src/promql/src/extension_plan/empty_metric.rs
+++ b/src/promql/src/extension_plan/empty_metric.rs
@@ -40,7 +40,7 @@ use datafusion::physical_plan::{
     SendableRecordBatchStream, StatisticsArgs,
 };
 use datafusion::physical_planner::PhysicalPlanner;
-use datafusion::prelude::{Expr, col, lit};
+use datafusion::prelude::{Expr, ident, lit};
 use datafusion_expr::LogicalPlanBuilder;
 use datatypes::arrow::array::TimestampMillisecondArray;
 use datatypes::arrow::datatypes::SchemaRef;
@@ -109,6 +109,11 @@ impl EmptyMetric {
         })
     }
 
+    /// Returns the expression used to generate metric values.
+    pub fn expr(&self) -> Option<&Expr> {
+        self.expr.as_ref()
+    }
+
     pub const fn name() -> &'static str {
         "EmptyMetric"
     }
@@ -409,7 +414,7 @@ fn build_ts_only_schema(column_name: &str) -> DFSchema {
 pub fn build_special_time_expr(time_index_column_name: &str) -> Expr {
     let input_schema = build_ts_only_schema(time_index_column_name);
     // safety: should not failed (UT covers this)
-    col(time_index_column_name)
+    ident(time_index_column_name)
         .cast_to(&DataType::Int64, &input_schema)
         .unwrap()
         .cast_to(&DataType::Float64, &input_schema)
diff --git a/src/promql/src/extension_plan/histogram_fold.rs b/src/promql/src/extension_plan/histogram_fold.rs
index 94769df28a4..fb691cbc00d 100644
--- a/src/promql/src/extension_plan/histogram_fold.rs
+++ b/src/promql/src/extension_plan/histogram_fold.rs
@@ -41,7 +41,7 @@ use datafusion::physical_plan::{
     SendableRecordBatchStream, StatisticsArgs,
 };
 use datafusion::prelude::{Column, Expr};
-use datafusion_expr::{EmptyRelation, col};
+use datafusion_expr::{EmptyRelation, ident};
 use datatypes::arrow_array::string_array_value_at_index;
 use datatypes::prelude::{ConcreteDataType, DataType as GtDataType};
 use datatypes::value::{OrderedF64, Value, ValueRef};
@@ -141,14 +141,14 @@ impl UserDefinedLogicalNodeCore for HistogramFold {
         }
 
         let mut exprs = vec![
-            col(&self.le_column),
-            col(&self.ts_column),
-            col(&self.field_column),
+            ident(&self.le_column),
+            ident(&self.ts_column),
+            ident(&self.field_column),
         ];
         exprs.extend(self.input.schema().fields().iter().filter_map(|f| {
             let name = f.name();
             if name != &self.le_column && name != &self.ts_column && name != &self.field_column {
-                Some(col(name))
+                Some(ident(name))
             } else {
                 None
             }
@@ -385,10 +385,7 @@ impl HistogramFold {
         let output_schema: SchemaRef = self.output_schema.inner().clone();
         let properties = Arc::new(PlanProperties::new(
             EquivalenceProperties::new(output_schema.clone()),
-            Partitioning::Hash(
-                partition_exprs.clone(),
-                exec_input.output_partitioning().partition_count(),
-            ),
+            Partitioning::UnknownPartitioning(exec_input.output_partitioning().partition_count()),
             EmissionType::Incremental,
             Boundedness::Bounded,
         ));
@@ -604,10 +601,7 @@ impl ExecutionPlan for HistogramFoldExec {
         let new_input = children[0].clone();
         let properties = Arc::new(PlanProperties::new(
             EquivalenceProperties::new(self.output_schema.clone()),
-            Partitioning::Hash(
-                self.partition_exprs.clone(),
-                new_input.output_partitioning().partition_count(),
-            ),
+            Partitioning::UnknownPartitioning(new_input.output_partitioning().partition_count()),
             EmissionType::Incremental,
             Boundedness::Bounded,
         ));
@@ -846,6 +840,8 @@ impl HistogramFoldStream {
         self.find_first_complete_bucket(&batch)
     }
 
+    /// Returns the first group's candidate bucket count once a group boundary is
+    /// observed. Optimistic validation checks its bounds before folding.
     fn find_first_complete_bucket(&self, batch: &RecordBatch) -> DataFusionResult<Option<usize>> {
         if batch.num_rows() == 0 {
             return Ok(None);
@@ -853,21 +849,14 @@ impl HistogramFoldStream {
 
         let vectors = Helper::try_into_vectors(batch.columns())
             .map_err(|e| DataFusionError::Execution(e.to_string()))?;
-        let le_array = batch.column(self.le_column_index);
-
         let mut tag_values_buf = Vec::with_capacity(self.normal_indices.len());
         self.collect_tag_values(&vectors, 0, &mut tag_values_buf);
-        let mut group_start = 0usize;
 
-        for row in 0..batch.num_rows() {
+        for row in 1..batch.num_rows() {
             if !self.is_same_group(&vectors, row, &tag_values_buf) {
-                // new group begins
-                self.collect_tag_values(&vectors, row, &mut tag_values_buf);
-                group_start = row;
-            }
-
-            if Self::is_positive_infinity(le_array, row) {
-                return Ok(Some(row - group_start + 1));
+                // A new series/timestamp proves that the previous group is
+                // complete, including any numerically equal +Inf boundaries.
+                return Ok(Some(row));
             }
         }
 
@@ -888,7 +877,10 @@ impl HistogramFoldStream {
         let field_array = field_array.as_primitive::<Float64Type>();
         let mut tag_values_buf = Vec::with_capacity(self.normal_indices.len());
 
-        while remaining_rows >= bucket_num && self.mode == FoldMode::Optimistic {
+        // Keep one row of lookahead: +Inf alone does not prove completion.
+        // A group ending at the batch boundary stays buffered until more input
+        // arrives, or flush_remaining completes it at EOF.
+        while remaining_rows > bucket_num && self.mode == FoldMode::Optimistic {
             self.collect_tag_values(&vectors, cursor, &mut tag_values_buf);
             if !self.validate_optimistic_group(
                 &vectors,
@@ -987,6 +979,9 @@ impl HistogramFoldStream {
         tag_values: &[ValueRef<'_>],
     ) -> bool {
         let inf_index = cursor + bucket_num - 1;
+        if self.is_same_group(vectors, inf_index + 1, tag_values) {
+            return false;
+        }
         if !Self::is_positive_infinity(le_array, inf_index) {
             return false;
         }
@@ -1217,7 +1212,7 @@ impl HistogramFoldStream {
 
     fn flush_remaining(&mut self) -> DataFusionResult<()> {
         if self.mode == FoldMode::Optimistic && self.input_buffered_rows > 0 {
-            let buffered_batches: Vec<_> = self.input_buffer.drain(..).collect();
+            let buffered_batches: Vec<_> = std::mem::take(&mut self.input_buffer);
             if !buffered_batches.is_empty() {
                 let batch = concat_batches(&self.input_schema, buffered_batches.as_slice())?;
                 self.switch_to_safe_mode(batch)?;
@@ -1274,8 +1269,31 @@ impl HistogramFoldStream {
             }
         }
 
-        // check input value
-        if !bucket.windows(2).all(|w| w[0] <= w[1]) {
+        // Detect equal numeric boundaries during validation so unique buckets
+        // need neither another scan nor an allocation.
+        let has_duplicates = !bucket.windows(2).all(|w| w[0] < w[1]);
+        if has_duplicates && !bucket.windows(2).all(|w| w[0] <= w[1]) {
+            return Ok(f64::NAN);
+        }
+        // Counts must be coalesced before repairing monotonicity.
+        let coalesced = has_duplicates.then(|| {
+            let mut bounds = Vec::with_capacity(bucket.len());
+            let mut counts = Vec::with_capacity(counter.len());
+            for (&bound, &count) in bucket.iter().zip(counter) {
+                if bounds.last() == Some(&bound) {
+                    *counts.last_mut().unwrap() += count;
+                } else {
+                    bounds.push(bound);
+                    counts.push(count);
+                }
+            }
+            (bounds, counts)
+        });
+        let (bucket, counter) = match &coalesced {
+            Some((bounds, counts)) => (bounds.as_slice(), counts.as_slice()),
+            None => (bucket, counter),
+        };
+        if matches!(operation, HistogramFoldOperation::Quantile(_)) && bucket.len() < 2 {
             return Ok(f64::NAN);
         }
         let counter = match operation {
@@ -1339,26 +1357,6 @@ impl HistogramFoldStream {
     }
 
     fn evaluate_fraction(lower: f64, upper: f64, bucket: &[f64], counter: &[f64]) -> f64 {
-        let coalesced = bucket
-            .windows(2)
-            .any(|bounds| bounds[0] == bounds[1])
-            .then(|| {
-                let mut bounds = Vec::with_capacity(bucket.len());
-                let mut counts = Vec::with_capacity(counter.len());
-                for (&bound, &count) in bucket.iter().zip(counter) {
-                    if bounds.last() == Some(&bound) {
-                        *counts.last_mut().unwrap() += count;
-                    } else {
-                        bounds.push(bound);
-                        counts.push(count);
-                    }
-                }
-                (bounds, counts)
-            });
-        let (bucket, counter) = match &coalesced {
-            Some((bounds, counts)) => (bounds.as_slice(), counts.as_slice()),
-            None => (bucket, counter),
-        };
         let total = *counter.last().unwrap();
         if total == 0.0 || lower.is_nan() || upper.is_nan() {
             return f64::NAN;
@@ -1438,6 +1436,7 @@ mod test {
     use datafusion::datasource::memory::MemorySourceConfig;
     use datafusion::datasource::source::DataSourceExec;
     use datafusion::logical_expr::EmptyRelation;
+    use datafusion::physical_plan::{ChildrenPropertiesMode, ReplaceChildrenOptions};
     use datafusion::prelude::SessionContext;
     use datatypes::arrow_array::StringArray;
     use futures::FutureExt;
@@ -1457,7 +1456,9 @@ mod test {
         RecordBatch::try_new(schema, columns).unwrap()
     }
 
-    fn prepare_test_data() -> DataSourceExec {
+    /// The batches and schema shared by [`prepare_test_data`] and
+    /// [`prepare_test_data_with_two_partitions`].
+    fn prepare_test_data_batches() -> (Vec<RecordBatch>, SchemaRef) {
         let schema = Arc::new(Schema::new(vec![
             Field::new("host", DataType::Utf8, true),
             Field::new("le", DataType::Utf8, true),
@@ -1466,8 +1467,8 @@ mod test {
 
         // 12 items
         let host_column_1 = Arc::new(StringArray::from(vec![
-            "host_1", "host_1", "host_1", "host_1", "host_1", "host_1", "host_1", "host_1",
-            "host_1", "host_1", "host_1", "host_1",
+            "host_1", "host_1", "host_1", "host_1", "host_1", "host_2", "host_2", "host_2",
+            "host_2", "host_2", "host_3", "host_3",
         ])) as _;
         let le_column_1 = Arc::new(StringArray::from(vec![
             "0.001", "0.1", "10", "1000", "+Inf", "0.001", "0.1", "10", "1000", "+inf", "0.001",
@@ -1478,14 +1479,14 @@ mod test {
         ])) as _;
 
         // 2 items
-        let host_column_2 = Arc::new(StringArray::from(vec!["host_1", "host_1"])) as _;
+        let host_column_2 = Arc::new(StringArray::from(vec!["host_3", "host_3"])) as _;
         let le_column_2 = Arc::new(StringArray::from(vec!["10", "1000"])) as _;
         let val_column_2 = Arc::new(Float64Array::from(vec![1.0, 1.0])) as _;
 
         // 11 items
         let host_column_3 = Arc::new(StringArray::from(vec![
-            "host_1", "host_2", "host_2", "host_2", "host_2", "host_2", "host_2", "host_2",
-            "host_2", "host_2", "host_2",
+            "host_3", "host_4", "host_4", "host_4", "host_4", "host_4", "host_5", "host_5",
+            "host_5", "host_5", "host_5",
         ])) as _;
         let le_column_3 = Arc::new(StringArray::from(vec![
             "+INF", "0.001", "0.1", "10", "1000", "+iNf", "0.001", "0.1", "10", "1000", "+Inf",
@@ -1510,8 +1511,24 @@ mod test {
         )
         .unwrap();
 
+        (vec![data_1, data_2, data_3], schema)
+    }
+
+    fn prepare_test_data() -> DataSourceExec {
+        let (batches, schema) = prepare_test_data_batches();
         DataSourceExec::new(Arc::new(
-            MemorySourceConfig::try_new(&[vec![data_1, data_2, data_3]], schema, None).unwrap(),
+            MemorySourceConfig::try_new(&[batches], schema, None).unwrap(),
+        ))
+    }
+
+    /// The batches from [`prepare_test_data_batches`], laid out over two
+    /// partitions, so that partitioning metadata is checked against a real
+    /// multi-partition input.
+    fn prepare_test_data_with_two_partitions() -> DataSourceExec {
+        let (mut batches, schema) = prepare_test_data_batches();
+        let first_partition = vec![batches.remove(0)];
+        DataSourceExec::new(Arc::new(
+            MemorySourceConfig::try_new(&[first_partition, batches], schema, None).unwrap(),
         ))
     }
 
@@ -1599,9 +1616,8 @@ mod test {
 
         let properties = PlanProperties::new(
             EquivalenceProperties::new(output_schema.clone()),
-            Partitioning::Hash(
-                partition_exprs.clone(),
-                input.output_partitioning().partition_count(),
+            Partitioning::UnknownPartitioning(
+                input.properties().output_partitioning().partition_count(),
             ),
             EmissionType::Incremental,
             Boundedness::Bounded,
@@ -1651,10 +1667,10 @@ mod test {
 | host   | val               |
 +--------+-------------------+
 | host_1 | 257.5             |
-| host_1 | 5.05              |
-| host_1 | 0.0004            |
-| host_2 | NaN               |
-| host_2 | 6.040000000000001 |
+| host_2 | 5.05              |
+| host_3 | 0.0004            |
+| host_4 | NaN               |
+| host_5 | 6.040000000000001 |
 +--------+-------------------+",
         );
         assert_eq!(result_literal, expected);
@@ -1804,6 +1820,39 @@ mod test {
         assert!(broken_result.is_err());
     }
 
+    #[test]
+    fn fold_does_not_claim_hash_partitioning() {
+        let input: Arc<dyn ExecutionPlan> = Arc::new(prepare_test_data_with_two_partitions());
+        let logical_input = LogicalPlan::EmptyRelation(EmptyRelation {
+            produce_one_row: false,
+            schema: Arc::new(input.schema().to_dfschema().unwrap()),
+        });
+        let logical_fold = HistogramFold::new(
+            "le".to_string(),
+            "val".to_string(),
+            "host".to_string(),
+            0.5,
+            logical_input,
+        )
+        .unwrap();
+        let constructed = logical_fold.to_execution_plan(input.clone());
+        assert!(matches!(
+            constructed.output_partitioning(),
+            Partitioning::UnknownPartitioning(2)
+        ));
+
+        let rebuilt = constructed
+            .replace_children(
+                vec![input],
+                ReplaceChildrenOptions::new(ChildrenPropertiesMode::Recompute),
+            )
+            .unwrap();
+        assert!(matches!(
+            rebuilt.output_partitioning(),
+            Partitioning::UnknownPartitioning(2)
+        ));
+    }
+
     #[test]
     fn confirm_schema() {
         let input_schema = Schema::new(vec![
@@ -1831,7 +1880,7 @@ mod test {
             Field::new("le", DataType::Utf8, true),
             Field::new("val", DataType::Float64, true),
         ]));
-        let host_column = Arc::new(StringArray::from(vec!["a", "a", "a", "a", "b", "b"])) as _;
+        let host_column = Arc::new(StringArray::from(vec!["a", "a", "b", "b", "c", "c"])) as _;
         let le_column = Arc::new(StringArray::from(vec![
             "0.1", "+Inf", "0.1", "1.0", "0.1", "+Inf",
         ])) as _;
@@ -1852,8 +1901,8 @@ mod test {
 | host | val |
 +------+-----+
 | a    | 0.1 |
-| a    | NaN |
-| b    | 0.1 |
+| b    | NaN |
+| c    | 0.1 |
 +------+-----+",
         );
         assert_eq!(result_literal, expected);
@@ -1930,6 +1979,79 @@ mod test {
         );
     }
 
+    #[tokio::test]
+    async fn trailing_invalid_bounds_fall_back_before_eof() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("host", DataType::Utf8, false),
+            Field::new("le", DataType::Utf8, true),
+            Field::new("val", DataType::Float64, false),
+        ]));
+        for trailing_bound in [Some("bad"), None] {
+            let batch = RecordBatch::try_new(
+                schema.clone(),
+                vec![
+                    Arc::new(StringArray::from(vec![
+                        "a", "a", "a", "b", "b", "b", "c", "c", "c",
+                    ])),
+                    Arc::new(StringArray::from(
+                        [Some("1"), Some("+Inf"), trailing_bound].repeat(3),
+                    )),
+                    Arc::new(Float64Array::from([2.0, 4.0, 99.0].repeat(3))),
+                ],
+            )
+            .unwrap();
+            let fold = build_fold_exec_from_batches(vec![batch.clone()], schema.clone(), 0.5, 0);
+            let mut stream = HistogramFoldStream {
+                le_column_index: 1,
+                field_column_index: 2,
+                histogram_column_index: None,
+                operation: fold.operation,
+                normal_indices: vec![0],
+                bucket_size: None,
+                batch_size: 1,
+                output_schema: fold.output_schema.clone(),
+                input_schema: schema.clone(),
+                mode: FoldMode::Optimistic,
+                safe_group: None,
+                input_buffer: vec![],
+                input_buffered_rows: 0,
+                output_buffer: HistogramFoldStream::empty_output_buffer(&schema).unwrap(),
+                output_buffered_rows: 0,
+                input: fold
+                    .input
+                    .execute(0, SessionContext::default().task_ctx())
+                    .unwrap(),
+                metric: BaselineMetrics::new(&fold.metric, 0),
+            };
+
+            // Neither +Inf nor a batch boundary alone completes the group.
+            assert!(stream.fold_input(batch.slice(0, 2)).unwrap().is_none());
+            assert!(stream.fold_input(batch.slice(2, 1)).unwrap().is_none());
+            assert_eq!(stream.mode, FoldMode::Optimistic);
+
+            for (offset, host) in [(3, "a"), (6, "b")] {
+                let output = stream
+                    .fold_input(batch.slice(offset, 3))
+                    .unwrap()
+                    .expect("a completed group should produce output before EOF")
+                    .unwrap();
+                assert_eq!(stream.mode, FoldMode::Safe);
+                assert_eq!(stream.input_buffered_rows, 0);
+                assert!(stream.input_buffer.is_empty());
+                assert_eq!(output.num_rows(), 1);
+                assert_eq!(string_array_value_at_index(output.column(0), 0), Some(host));
+                assert_eq!(output.column(1).as_primitive::<Float64Type>().value(0), 1.0);
+            }
+
+            stream.flush_remaining().unwrap();
+            let output = stream.take_output_buf().unwrap().unwrap();
+            assert_eq!(output.num_rows(), 1);
+            assert_eq!(string_array_value_at_index(output.column(0), 0), Some("c"));
+            assert_eq!(output.column(1).as_primitive::<Float64Type>().value(0), 1.0);
+            assert!(stream.take_output_buf().unwrap().is_none());
+        }
+    }
+
     #[tokio::test]
     async fn safe_mode_handles_misaligned_groups() {
         let schema = Arc::new(Schema::new(vec![
@@ -2045,6 +2167,171 @@ mod test {
         assert!((values[1] - 0.55).abs() < 1e-10, "{values:?}");
     }
 
+    #[test]
+    fn evaluate_quantile_duplicate_bounds() {
+        let cases = [
+            // Issue #9443: coalesce before repairing the count at 1000.
+            (
+                vec![10.0, 10.0, 100.0, 100.0, 1000.0, f64::INFINITY],
+                vec![40.0, 40.0, 50.0, 50.0, 50.0, 100.0],
+                0.95,
+                77.5,
+            ),
+            // Repairing the split counts first would incorrectly inflate them.
+            (
+                vec![10.0, 10.0, 100.0, 100.0, f64::INFINITY],
+                vec![30.0, 10.0, 40.0, 20.0, 60.0],
+                0.5,
+                7.5,
+            ),
+            (
+                vec![10.0, f64::INFINITY, f64::INFINITY],
+                vec![40.0, 20.0, 30.0],
+                0.5,
+                6.25,
+            ),
+            (
+                vec![f64::INFINITY, f64::INFINITY],
+                vec![20.0, 30.0],
+                0.5,
+                f64::NAN,
+            ),
+            (
+                vec![-0.0, 0.0, 10.0, f64::INFINITY],
+                vec![10.0, 10.0, 40.0, 40.0],
+                0.75,
+                5.0,
+            ),
+        ];
+        for (bounds, counts, quantile, expected) in cases {
+            let actual = HistogramFoldStream::evaluate_row(
+                HistogramFoldOperation::Quantile(quantile.into()),
+                &bounds,
+                &counts,
+            )
+            .unwrap();
+            if expected.is_nan() {
+                assert!(actual.is_nan());
+            } else {
+                assert!((actual - expected).abs() < 1e-10, "{actual} != {expected}");
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn duplicate_infinity_bounds_across_batches() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new(
+                "ts",
+                DataType::Timestamp(TimeUnit::Millisecond, None),
+                false,
+            ),
+            Field::new("le", DataType::Utf8, false),
+            Field::new("val", DataType::Float64, false),
+        ]));
+        let duplicate = [("10", 20.0), ("10.0", 20.0), ("+Inf", 25.0), ("+inf", 25.0)];
+        let regular = [("10", 20.0), ("10.0", 20.0), ("+Inf", 50.0)];
+        // Cover discovery, an already established optimistic bucket count,
+        // fallback, and the final group at EOF.
+        for groups in [
+            vec![duplicate.as_slice()],
+            vec![duplicate.as_slice(), regular.as_slice()],
+            vec![regular.as_slice(), duplicate.as_slice(), regular.as_slice()],
+        ] {
+            let mut timestamps = Vec::new();
+            let mut bounds = Vec::new();
+            let mut counts = Vec::new();
+            for (timestamp, group) in groups.iter().enumerate() {
+                for &(bound, count) in *group {
+                    timestamps.push(timestamp as i64);
+                    bounds.push(bound);
+                    counts.push(count);
+                }
+            }
+            let batch = RecordBatch::try_new(
+                schema.clone(),
+                vec![
+                    Arc::new(TimestampMillisecondArray::from(timestamps)),
+                    Arc::new(StringArray::from(bounds)),
+                    Arc::new(Float64Array::from(counts)),
+                ],
+            )
+            .unwrap();
+            for batch_size in 1..=batch.num_rows() {
+                let batches = (0..batch.num_rows())
+                    .step_by(batch_size)
+                    .map(|offset| batch.slice(offset, batch_size.min(batch.num_rows() - offset)))
+                    .collect();
+                let fold = build_fold_exec_from_batches(batches, schema.clone(), 0.5, 0);
+                let result =
+                    datafusion::physical_plan::collect(fold, SessionContext::default().task_ctx())
+                        .await
+                        .unwrap();
+                let values: Vec<_> = result
+                    .iter()
+                    .flat_map(|batch| {
+                        batch
+                            .column(1)
+                            .as_primitive::<Float64Type>()
+                            .values()
+                            .iter()
+                            .copied()
+                    })
+                    .collect();
+                assert_eq!(values, vec![6.25; groups.len()], "batch size {batch_size}");
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn duplicate_bounds_across_batches_and_safe_fallback() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new(
+                "ts",
+                DataType::Timestamp(TimeUnit::Millisecond, None),
+                false,
+            ),
+            Field::new("le", DataType::Utf8, false),
+            Field::new("val", DataType::Float64, false),
+        ]));
+        // The first group establishes six buckets for optimistic folding. The
+        // shorter second group forces safe mode; both have duplicate bounds.
+        let batch = RecordBatch::try_new(
+            schema.clone(),
+            vec![
+                Arc::new(TimestampMillisecondArray::from(vec![
+                    1000, 1000, 1000, 1000, 1000, 1000, 2000, 2000, 2000, 2000, 2000,
+                ])),
+                Arc::new(StringArray::from(vec![
+                    "10", "10.0", "100", "100.0", "1000", "+Inf", "10", "10.0", "100", "100.0",
+                    "+Inf",
+                ])),
+                Arc::new(Float64Array::from(vec![
+                    40.0, 40.0, 50.0, 50.0, 50.0, 100.0, 40.0, 40.0, 50.0, 50.0, 100.0,
+                ])),
+            ],
+        )
+        .unwrap();
+        // Split each pair of equal boundaries across an input batch boundary.
+        let batches = (0..batch.num_rows()).map(|i| batch.slice(i, 1)).collect();
+        let fold = build_fold_exec_from_batches(batches, schema, 0.95, 0);
+        let result = datafusion::physical_plan::collect(fold, SessionContext::default().task_ctx())
+            .await
+            .unwrap();
+        let values: Vec<_> = result
+            .iter()
+            .flat_map(|batch| {
+                batch
+                    .column(1)
+                    .as_primitive::<Float64Type>()
+                    .values()
+                    .iter()
+                    .copied()
+            })
+            .collect();
+        assert_eq!(values, vec![77.5, 77.5]);
+    }
+
     #[test]
     fn evaluate_row_normal_case() {
         let bucket = [0.0, 1.0, 2.0, 3.0, 4.0, f64::INFINITY];
diff --git a/src/promql/src/extension_plan/instant_manipulate.rs b/src/promql/src/extension_plan/instant_manipulate.rs
index 45857879d73..4a9a3fe5fb8 100644
--- a/src/promql/src/extension_plan/instant_manipulate.rs
+++ b/src/promql/src/extension_plan/instant_manipulate.rs
@@ -37,7 +37,7 @@ use datafusion::physical_plan::{
     PhysicalExpr, PlanProperties, RecordBatchStream, SendableRecordBatchStream, Statistics,
     StatisticsArgs,
 };
-use datafusion_expr::col;
+use datafusion_expr::ident;
 use datatypes::arrow::compute;
 use datatypes::timestamp::timestamp_array_to_primitive;
 use futures::{Stream, StreamExt, ready};
@@ -46,6 +46,7 @@ use prost::Message;
 use snafu::ResultExt;
 
 use crate::error::{DeserializeSnafu, Result};
+use crate::extension_plan::range_manipulate::{Nanoseconds, ScanNanoseconds, narrow_scan};
 use crate::extension_plan::series_divide::SeriesDivide;
 use crate::extension_plan::{
     METRIC_NUM_SERIES, Millisecond, is_prometheus_stale_sample, local_offset,
@@ -140,8 +141,8 @@ impl UserDefinedLogicalNodeCore for InstantManipulate {
             return vec![];
         }
 
-        let mut exprs = vec![col(&self.time_index_column)];
-        exprs.extend(self.staleness_field_columns().map(col));
+        let mut exprs = vec![ident(&self.time_index_column)];
+        exprs.extend(self.staleness_field_columns().map(ident));
         exprs
     }
 
@@ -691,6 +692,7 @@ impl InstantManipulateStream {
         let (timestamps, _) = timestamp_array_to_primitive(ts_column).ok_or_else(|| {
             DataFusionError::Execution("Time index column is not a timestamp".into())
         })?;
+        let timestamp_null_count = timestamps.null_count();
         let timestamps = timestamps.values();
         let len = timestamps.len();
         // Shift the native-tick timeline in i128 before comparing samples. Doing
@@ -735,28 +737,77 @@ impl InstantManipulateStream {
         let estimated_points = estimated_points as usize;
         let aligned_start = aligned_start as i64;
         let aligned_end = aligned_end as i64;
-        let mut take_indices = Vec::with_capacity(estimated_points);
-        let mut aligned_ts = Vec::with_capacity(estimated_points);
-        let mut cursor = 0;
-        for expected_ms in (aligned_start..=aligned_end).step_by(self.interval as usize) {
-            let expected = (expected_ms as i128) * 1_000_000;
+        // Narrow `i64` nanoseconds whenever the batch fits them, exact `i128` otherwise.
+        let narrow = (timestamp_null_count == 0)
+            .then(|| {
+                narrow_scan(
+                    self.time_unit,
+                    self.offset,
+                    self.lookback_delta,
+                    timestamps,
+                    aligned_start,
+                    aligned_end,
+                )
+            })
+            .flatten();
+        if let Some(scan) = &narrow {
+            debug_assert_eq!(i64::try_from(first_ns), Ok(scan.shift(timestamps[0])));
+            debug_assert_eq!(i64::try_from(last_ns), Ok(scan.shift(timestamps[len - 1])));
+        }
+        let (take_indices, aligned_ts) = match narrow {
+            Some(scan) => self.scan_instants::<i64>(
+                timestamps,
+                aligned_start,
+                aligned_end,
+                &scan,
+                estimated_points,
+                &is_stale,
+            ),
+            None => self.scan_instants::<i128>(
+                timestamps,
+                aligned_start,
+                aligned_end,
+                &ScanNanoseconds::<i128>::wide(self.time_unit, self.offset, self.lookback_delta),
+                estimated_points,
+                &is_stale,
+            ),
+        };
+        self.take_record_batch_optional(input, take_indices, aligned_ts)
+    }
+
+    /// Chooses the sample of every aligned evaluation instant, in `Ns` nanoseconds.
+    ///
+    /// Keeps the first row among exact timestamp ties and the latest preceding row
+    /// otherwise; zero lookback admits only exact samples. Staleness is tested after
+    /// choosing: a selected stale marker suppresses this evaluation rather than
+    /// falling back to an older finite value.
+    fn scan_instants<Ns: Nanoseconds>(
+        &self,
+        timestamps: &[i64],
+        start: Millisecond,
+        end: Millisecond,
+        scan: &ScanNanoseconds<Ns>,
+        capacity: usize,
+        is_stale: impl Fn(usize) -> bool,
+    ) -> (Vec<u64>, Vec<Millisecond>) {
+        let len = timestamps.len();
+        let mut cursor = 0usize;
+        let mut take_indices = Vec::with_capacity(capacity);
+        let mut aligned_ts = Vec::with_capacity(capacity);
+        for expected_ms in (start..=end).step_by(self.interval as usize) {
+            let expected = scan.instant(expected_ms);
             let mut exact_candidate = None;
-            while cursor < len && to_nanoseconds(timestamps[cursor]) <= expected {
-                if to_nanoseconds(timestamps[cursor]) == expected && exact_candidate.is_none() {
+            while cursor < len && scan.shift(timestamps[cursor]) <= expected {
+                if scan.shift(timestamps[cursor]) == expected && exact_candidate.is_none() {
                     exact_candidate = Some(cursor);
                 }
                 cursor += 1;
             }
-            // Keep the first row among exact timestamp ties; otherwise use the
-            // latest preceding row. Zero lookback admits only exact samples.
-            // Test staleness after choosing: a selected stale marker suppresses
-            // this evaluation rather than falling back to an older finite value.
             let Some(candidate) = exact_candidate.or_else(|| cursor.checked_sub(1)) else {
                 continue;
             };
-            let candidate_ts = to_nanoseconds(timestamps[candidate]);
-            let lower = expected - (self.lookback_delta as i128) * 1_000_000;
-            if (candidate_ts == expected || candidate_ts > lower)
+            let candidate_ts = scan.shift(timestamps[candidate]);
+            if (candidate_ts == expected || candidate_ts > scan.window_start(expected))
                 && candidate_ts <= expected
                 && !is_stale(candidate)
             {
@@ -764,7 +815,7 @@ impl InstantManipulateStream {
                 aligned_ts.push(expected_ms);
             }
         }
-        self.take_record_batch_optional(input, take_indices, aligned_ts)
+        (take_indices, aligned_ts)
     }
 
     /// Helper function to apply "take" on record batch.
@@ -1775,6 +1826,81 @@ mod test {
         .await;
     }
 
+    #[test]
+    fn nullable_interior_timestamp_matches_wide_scan() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new(
+                TIME_INDEX_COLUMN,
+                DataType::Timestamp(TimeUnit::Second, None),
+                true,
+            ),
+            Field::new("value", DataType::Float64, false),
+        ]));
+        let timestamps = [0, i64::MAX, 1];
+        let array = TimestampSecondArray::new(
+            timestamps.to_vec().into(),
+            Some(NullBuffer::from(vec![false, false, true])),
+        );
+        let input = RecordBatch::try_new(
+            schema.clone(),
+            vec![
+                Arc::new(array),
+                Arc::new(Float64Array::from(vec![1.0, 2.0, 3.0])),
+            ],
+        )
+        .unwrap();
+        let stream = InstantManipulateStream {
+            offset: 0,
+            start: 0,
+            end: 1_000,
+            lookback_delta: 1_000,
+            interval: 1_000,
+            time_index: 0,
+            time_unit: TimeUnit::Second,
+            field_indices: [Some(1), None],
+            tsid_index: None,
+            reuse_tsid_column: false,
+            schema: Arc::new(Schema::new(vec![
+                Field::new(
+                    TIME_INDEX_COLUMN,
+                    DataType::Timestamp(TimeUnit::Millisecond, None),
+                    false,
+                ),
+                Field::new("value", DataType::Float64, false),
+            ])),
+            input: Box::pin(
+                datafusion::physical_plan::memory::MemoryStream::try_new(vec![], schema, None)
+                    .unwrap(),
+            ),
+            metric: BaselineMetrics::new(&ExecutionPlanMetricsSet::new(), 0),
+            num_series: Count::new(),
+        };
+
+        let output = stream.manipulate(input).unwrap();
+        let output_timestamps = output
+            .column(0)
+            .as_any()
+            .downcast_ref::<TimestampMillisecondArray>()
+            .unwrap();
+        let output_values = output
+            .column(1)
+            .as_any()
+            .downcast_ref::<Float64Array>()
+            .unwrap();
+        let wide = stream.scan_instants::<i128>(
+            &timestamps,
+            0,
+            1_000,
+            &ScanNanoseconds::<i128>::wide(TimeUnit::Second, 0, 1_000),
+            2,
+            |_| false,
+        );
+        assert_eq!(output_timestamps.values(), &[0]);
+        assert_eq!(output_values.values(), &[1.0]);
+        assert_eq!(wide, (vec![0], vec![0]));
+        assert_eq!(wide.1, output_timestamps.values().to_vec());
+    }
+
     #[test]
     fn exact_ties_select_first_and_lookback_uses_latest() {
         for (values, expected_timestamp) in [
diff --git a/src/promql/src/extension_plan/normalize.rs b/src/promql/src/extension_plan/normalize.rs
index 1ca015b10f1..b1ea6ca3e7c 100644
--- a/src/promql/src/extension_plan/normalize.rs
+++ b/src/promql/src/extension_plan/normalize.rs
@@ -33,7 +33,7 @@ use datafusion::physical_plan::{
     InputDistributionRequirements, PhysicalExpr, PlanProperties, RecordBatchStream,
     SendableRecordBatchStream, StatisticsArgs,
 };
-use datafusion_expr::col;
+use datafusion_expr::ident;
 use datatypes::arrow::array::TimestampMillisecondArray;
 use datatypes::arrow::datatypes::{SchemaRef, TimestampMillisecondType};
 use datatypes::arrow::record_batch::RecordBatch;
@@ -93,8 +93,8 @@ impl UserDefinedLogicalNodeCore for SeriesNormalize {
 
         self.tag_columns
             .iter()
-            .map(col)
-            .chain(std::iter::once(col(&self.time_index_column_name)))
+            .map(ident)
+            .chain(std::iter::once(ident(&self.time_index_column_name)))
             .collect()
     }
 
diff --git a/src/promql/src/extension_plan/range_manipulate.rs b/src/promql/src/extension_plan/range_manipulate.rs
index 96a0c97778d..38ecb7aa4db 100644
--- a/src/promql/src/extension_plan/range_manipulate.rs
+++ b/src/promql/src/extension_plan/range_manipulate.rs
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 use std::collections::HashSet;
+use std::ops::{Add, Mul, Sub};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
@@ -20,7 +21,7 @@ use std::task::{Context, Poll};
 use common_telemetry::{debug, warn};
 use datafusion::arrow::array::{Array, ArrayRef, Int64Array, TimestampMillisecondArray};
 use datafusion::arrow::compute;
-use datafusion::arrow::datatypes::{DataType, Field, SchemaRef, TimeUnit};
+use datafusion::arrow::datatypes::{DataType, Field, Int64Type, SchemaRef, TimeUnit};
 use datafusion::arrow::error::ArrowError;
 use datafusion::arrow::record_batch::RecordBatch;
 use datafusion::common::stats::Precision;
@@ -38,7 +39,7 @@ use datafusion::physical_plan::{
     InputDistributionRequirements, PhysicalExpr, PlanProperties, RecordBatchStream,
     SendableRecordBatchStream, Statistics, StatisticsArgs,
 };
-use datafusion_expr::col;
+use datafusion_expr::ident;
 use datatypes::timestamp::timestamp_array_to_primitive;
 use futures::{Stream, StreamExt, ready};
 use greptime_proto::substrait_extension as pb;
@@ -318,8 +319,8 @@ impl UserDefinedLogicalNodeCore for RangeManipulate {
         }
 
         let mut exprs = Vec::with_capacity(1 + self.field_columns.len());
-        exprs.push(col(&self.time_index));
-        exprs.extend(self.field_columns.iter().map(col));
+        exprs.push(ident(&self.time_index));
+        exprs.extend(self.field_columns.iter().map(ident));
         exprs
     }
 
@@ -702,33 +703,68 @@ impl RangeManipulateStream {
             new_columns[*index] = new_column;
         }
 
-        // The timestamp range payload is always millisecond ABI. Shift in wide
-        // native precision before truncating toward zero, preserving null validity.
-        let scale = nanoseconds_per_native_tick(self.time_unit);
-        let (timestamps, _) = timestamp_array_to_primitive(input.column(self.time_index))
-            .ok_or_else(|| {
+        // The timestamp range payload is always millisecond ABI. A column is reusable as-is
+        // only when its own data type already is that ABI: the output schema fixes the
+        // dictionary value type, so a millisecond column carrying a timezone must be
+        // converted like any other native unit.
+        let ts_column = input.column(self.time_index);
+        let timestamp_values: ArrayRef = if self.offset == 0
+            && matches!(
+                ts_column.data_type(),
+                DataType::Timestamp(TimeUnit::Millisecond, None)
+            ) {
+            ts_column.clone()
+        } else {
+            // Shift in wide native precision before truncating toward zero, preserving
+            // null validity.
+            let scale = nanoseconds_per_native_tick(self.time_unit);
+            let (timestamps, _) = timestamp_array_to_primitive(ts_column).ok_or_else(|| {
                 DataFusionError::Execution("Time index column is not a timestamp".into())
             })?;
-        let timestamp_values = timestamps
-            .values()
-            .iter()
-            .enumerate()
-            .map(|(index, timestamp)| {
-                if !input.column(self.time_index).is_valid(index) {
-                    return Ok(None);
+            // Single pass over the timestamps: an i128 intermediate holds any native
+            // timestamp shift; only the final millisecond result must fit i64. Null-free
+            // batches (the dominant PromQL case) take arrow's infallible `unary` kernel,
+            // which LLVM can vectorize, and report overflow through a shared cell. But
+            // `unary` visits NULL slots' underlying values, so a NULL slot holding an
+            // arbitrary overflowing value would raise a false batch-wide error; nullable
+            // batches therefore take `try_unary`, which applies the closure to valid rows
+            // only.
+            let offset_ns = (self.offset as i128) * 1_000_000;
+            let timestamp_values = if timestamps.null_count() == 0 {
+                let overflow = std::cell::Cell::new(false);
+                let shifted = compute::unary::<Int64Type, _, Int64Type>(&timestamps, |v| {
+                    let shifted_ns = (v as i128) * scale + offset_ns;
+                    let shifted_ms = shifted_ns / 1_000_000;
+                    match i64::try_from(shifted_ms) {
+                        Ok(ms) => ms,
+                        Err(_) => {
+                            overflow.set(true);
+                            0
+                        }
+                    }
+                });
+                if overflow.get() {
+                    return Err(DataFusionError::Execution(
+                        "RangeManipulate timestamp payload overflow".into(),
+                    ));
                 }
-                let shifted_ns = (*timestamp as i128) * scale + (self.offset as i128) * 1_000_000;
-                i64::try_from(shifted_ns / 1_000_000)
-                    .map(Some)
-                    .map_err(|_| {
+                shifted
+            } else {
+                compute::try_unary::<Int64Type, _, Int64Type>(&timestamps, |v| {
+                    let shifted_ns = (v as i128) * scale + offset_ns;
+                    i64::try_from(shifted_ns / 1_000_000).map_err(|_| {
                         ArrowError::ComputeError(
                             "RangeManipulate timestamp payload overflow".into(),
                         )
                     })
-            })
-            .collect::<std::result::Result<Vec<_>, _>>()?;
-        let timestamp_values = TimestampMillisecondArray::from(timestamp_values);
-        let ts_range_column = RangeArray::from_ranges(Arc::new(timestamp_values), ranges.clone())
+                })?
+            };
+            Arc::new(TimestampMillisecondArray::new(
+                timestamp_values.values().clone(),
+                timestamp_values.nulls().cloned(),
+            ))
+        };
+        let ts_range_column = RangeArray::from_ranges(timestamp_values, ranges.clone())
             .map_err(|e| ArrowError::InvalidArgumentError(e.to_string()))?
             .into_dict();
         new_columns.push(Arc::new(ts_range_column));
@@ -770,6 +806,7 @@ impl RangeManipulateStream {
         let (timestamps, _) = timestamp_array_to_primitive(ts_column).ok_or_else(|| {
             DataFusionError::Execution("Time index column is not a timestamp".into())
         })?;
+        let timestamp_null_count = timestamps.null_count();
         let timestamps = timestamps.values();
         let timestamp =
             |index| (timestamps[index] as i128) * scale + (self.offset as i128) * 1_000_000;
@@ -799,36 +836,193 @@ impl RangeManipulateStream {
         // The intersection is within the declared i64 query bounds.
         let start = start as i64;
         let end = end as i64;
-        let mut ranges = Vec::new();
 
         // Range membership is decided on shifted native ticks, before the
         // timestamp-range payload is converted to its millisecond ABI. This
         // keeps sub-millisecond samples distinct in a range; equal millisecond
         // payload values are not a reason to deduplicate input samples.
         //
-        // Calculate for every aligned timestamp (`curr_ts`), assuming ordered timestamps.
-        let mut left = 0usize;
-        let mut right = 0usize;
-        for curr_ts in (start..=end).step_by(self.interval as _) {
-            let start_ts = (curr_ts as i128) * 1_000_000 - (self.range as i128) * 1_000_000;
-
-            while left < len && timestamp(left) <= start_ts {
-                left += 1;
+        // Calculate for every aligned timestamp (`curr_ts`), assuming ordered
+        // timestamps: the scan compares shifted samples in `i64` nanoseconds
+        // whenever they fit the batch, and in exact `i128` nanoseconds otherwise.
+        let narrow = (timestamp_null_count == 0)
+            .then(|| {
+                narrow_scan(
+                    self.time_unit,
+                    self.offset,
+                    self.range,
+                    timestamps,
+                    start,
+                    end,
+                )
+            })
+            .flatten();
+        let ranges = match narrow {
+            Some(scan) => scan_ranges::<i64>(self.interval, timestamps, start, end, &scan),
+            None => {
+                let scan = ScanNanoseconds::<i128>::wide(self.time_unit, self.offset, self.range);
+                scan_ranges::<i128>(self.interval, timestamps, start, end, &scan)
             }
-            right = right.max(left);
-            while right < len && timestamp(right) <= (curr_ts as i128) * 1_000_000 {
-                right += 1;
-            }
-
-            if left == right {
-                ranges.push((0, 0));
-            } else {
-                ranges.push((left as _, (right - left) as _));
-            }
-        }
+        };
 
         Ok((ranges, (start, end)))
     }
+
+    /// Cursor scan of `timestamps` through the narrow `i64` carrier, for benchmarks.
+    ///
+    /// `bench_range_fn` times the fast path directly, next to the exact `i128` fallback in
+    /// [`RangeManipulateStream::bench_scan_wide`]; production selects the carrier through
+    /// [`narrow_scan`] inside `calculate_range`. Returns `None` when that carrier is
+    /// rejected, which is exactly the condition that makes the operator fall back to `i128`.
+    #[doc(hidden)]
+    pub fn bench_scan_narrow(
+        time_unit: TimeUnit,
+        offset: Millisecond,
+        window: Millisecond,
+        interval: Millisecond,
+        timestamps: &[i64],
+        start: Millisecond,
+        end: Millisecond,
+    ) -> Option<Vec<(u32, u32)>> {
+        let scan = narrow_scan(time_unit, offset, window, timestamps, start, end)?;
+        Some(scan_ranges::<i64>(interval, timestamps, start, end, &scan))
+    }
+
+    /// Cursor scan of `timestamps` through the exact `i128` carrier, for benchmarks.
+    ///
+    /// The carrier is exact for every input, so this times the fallback that
+    /// [`narrow_scan`] selects whenever the narrow baselines would overflow.
+    #[doc(hidden)]
+    pub fn bench_scan_wide(
+        time_unit: TimeUnit,
+        offset: Millisecond,
+        window: Millisecond,
+        interval: Millisecond,
+        timestamps: &[i64],
+        start: Millisecond,
+        end: Millisecond,
+    ) -> Vec<(u32, u32)> {
+        scan_ranges::<i128>(
+            interval,
+            timestamps,
+            start,
+            end,
+            &ScanNanoseconds::<i128>::wide(time_unit, offset, window),
+        )
+    }
+}
+
+/// Cursor scan over the aligned evaluation points, in `Ns` nanoseconds.
+fn scan_ranges<Ns: Nanoseconds>(
+    interval: Millisecond,
+    timestamps: &[i64],
+    start: Millisecond,
+    end: Millisecond,
+    scan: &ScanNanoseconds<Ns>,
+) -> Vec<(u32, u32)> {
+    let len = timestamps.len();
+    let mut ranges = Vec::new();
+    let mut left = 0usize;
+    let mut right = 0usize;
+    for curr_ts in (start..=end).step_by(interval as _) {
+        let curr_ts_ns = scan.instant(curr_ts);
+        let start_ts = scan.window_start(curr_ts_ns);
+
+        while left < len && scan.shift(timestamps[left]) <= start_ts {
+            left += 1;
+        }
+        right = right.max(left);
+        while right < len && scan.shift(timestamps[right]) <= curr_ts_ns {
+            right += 1;
+        }
+
+        if left == right {
+            ranges.push((0, 0));
+        } else {
+            ranges.push((left as _, (right - left) as _));
+        }
+    }
+    ranges
+}
+
+/// Cursor scan baselines in nanoseconds, shared with `InstantManipulate`.
+///
+/// The narrow `i64` baselines come from [`narrow_scan`], the exact ones from
+/// [`ScanNanoseconds::wide`].
+#[derive(Debug, Clone, Copy)]
+pub(super) struct ScanNanoseconds<Ns> {
+    /// Nanoseconds per timestamp tick.
+    scale: Ns,
+    /// The offset shift in nanoseconds.
+    offset_ns: Ns,
+    /// The range or lookback window in nanoseconds.
+    window_ns: Ns,
+}
+
+/// Nanoseconds carrier of the cursor scans: `i64` where [`narrow_scan`] proved that
+/// the batch fits, `i128` for the exact fallback.
+pub(super) trait Nanoseconds:
+    Copy + PartialOrd + From<i64> + Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self>
+{
+}
+
+impl<T> Nanoseconds for T where
+    T: Copy + PartialOrd + From<i64> + Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self>
+{
+}
+
+impl ScanNanoseconds<i128> {
+    /// The `i128` baselines, exact for every input.
+    pub(super) fn wide(time_unit: TimeUnit, offset: Millisecond, window: Millisecond) -> Self {
+        Self {
+            scale: nanoseconds_per_native_tick(time_unit),
+            offset_ns: i128::from(offset) * 1_000_000,
+            window_ns: i128::from(window) * 1_000_000,
+        }
+    }
+}
+
+impl<Ns: Nanoseconds> ScanNanoseconds<Ns> {
+    /// Shifted nanoseconds of an input timestamp.
+    pub(super) fn shift(&self, timestamp: i64) -> Ns {
+        Ns::from(timestamp) * self.scale + self.offset_ns
+    }
+
+    /// Nanoseconds of an evaluation instant given in milliseconds.
+    pub(super) fn instant(&self, millis: Millisecond) -> Ns {
+        Ns::from(millis) * Ns::from(1_000_000)
+    }
+
+    /// The exclusive lower boundary of the window ending at `instant`.
+    pub(super) fn window_start(&self, instant: Ns) -> Ns {
+        instant - self.window_ns
+    }
+}
+
+/// The narrow `i64` baselines of a sorted batch, or `None` when they would overflow.
+pub(super) fn narrow_scan(
+    time_unit: TimeUnit,
+    offset: Millisecond,
+    window: Millisecond,
+    timestamps: &[i64],
+    start: Millisecond,
+    end: Millisecond,
+) -> Option<ScanNanoseconds<i64>> {
+    let scale = i64::try_from(nanoseconds_per_native_tick(time_unit)).ok()?;
+    let offset_ns = offset.checked_mul(1_000_000)?;
+    let window_ns = window.checked_mul(1_000_000)?;
+    // Sorted samples, so the checked endpoints bound every interior shift and product.
+    let shift = |timestamp: i64| timestamp.checked_mul(scale)?.checked_add(offset_ns);
+    shift(*timestamps.first()?)?;
+    shift(*timestamps.last()?)?;
+    // The checked `[start, end]` bounds every instant and every `instant - window`.
+    start.checked_mul(1_000_000)?.checked_sub(window_ns)?;
+    end.checked_mul(1_000_000)?.checked_sub(window_ns)?;
+    Some(ScanNanoseconds {
+        scale,
+        offset_ns,
+        window_ns,
+    })
 }
 
 #[cfg(test)]
@@ -859,6 +1053,9 @@ mod test {
 
     const TIME_INDEX_COLUMN: &str = "timestamp";
 
+    /// The `(offset, length)` selections of one cursor scan.
+    type RangeSelections = Vec<(u32, u32)>;
+
     fn project_batch(batch: &RecordBatch, indices: &[usize]) -> RecordBatch {
         let fields = indices
             .iter()
@@ -1711,6 +1908,36 @@ mod test {
         stream.calculate_range(&batch).unwrap()
     }
 
+    #[test]
+    fn calculate_range_nullable_interior_timestamp_matches_wide_scan() {
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            TIME_INDEX_COLUMN,
+            DataType::Timestamp(TimeUnit::Second, None),
+            true,
+        )]));
+        let stream = scan_stream_for_test(TimeUnit::Second, 0, 0, 1_000, 1_000, 1_000);
+        let timestamps = [0, i64::MAX, 1];
+        let array = TimestampSecondArray::new(
+            timestamps.to_vec().into(),
+            Some(NullBuffer::from(vec![false, false, true])),
+        );
+        let batch = RecordBatch::try_new(schema, vec![Arc::new(array)]).unwrap();
+
+        let (ranges, bounds) = stream.calculate_range(&batch).unwrap();
+        let wide = RangeManipulateStream::bench_scan_wide(
+            TimeUnit::Second,
+            0,
+            1_000,
+            1_000,
+            &timestamps,
+            bounds.0,
+            bounds.1,
+        );
+        assert_eq!(bounds, (0, 1_000));
+        assert_eq!(ranges, vec![(0, 1), (0, 0)]);
+        assert_eq!(ranges, wide);
+    }
+
     #[test]
     fn calculate_range_keeps_query_aligned_tail() {
         let (ranges, bounds) = calculate_range_for_test(4, 94, 30, 15, &[20, 50, 80]);
@@ -1954,4 +2181,898 @@ mod test {
             );
         }
     }
+
+    /// Nanoseconds per native tick, as kept by the narrow carrier.
+    fn native_scale(time_unit: TimeUnit) -> i64 {
+        i64::try_from(nanoseconds_per_native_tick(time_unit)).unwrap()
+    }
+
+    /// Shifted nanoseconds of a sample, computed in the exact `i128` carrier.
+    fn shifted_nanoseconds(time_unit: TimeUnit, offset: Millisecond, timestamp: i64) -> i128 {
+        (timestamp as i128) * nanoseconds_per_native_tick(time_unit) + (offset as i128) * 1_000_000
+    }
+
+    /// Shifted milliseconds of the instant grid of a sample, flooring like `calculate_range`.
+    fn shifted_floor_millis(
+        time_unit: TimeUnit,
+        offset: Millisecond,
+        timestamp: i64,
+    ) -> Millisecond {
+        Millisecond::try_from(
+            shifted_nanoseconds(time_unit, offset, timestamp).div_euclid(1_000_000),
+        )
+        .unwrap()
+    }
+
+    /// Shifted milliseconds kept by the range payload of a sample.
+    ///
+    /// The payload conversion truncates toward zero, so samples below the epoch may keep
+    /// the millisecond above their own native tick.
+    fn shifted_millis(time_unit: TimeUnit, offset: Millisecond, timestamp: i64) -> Millisecond {
+        Millisecond::try_from(shifted_nanoseconds(time_unit, offset, timestamp) / 1_000_000)
+            .unwrap()
+    }
+
+    /// Stream whose cursor scan the differential tests below drive directly.
+    fn scan_stream_for_test(
+        time_unit: TimeUnit,
+        offset: Millisecond,
+        start: Millisecond,
+        end: Millisecond,
+        interval: Millisecond,
+        range: Millisecond,
+    ) -> RangeManipulateStream {
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            TIME_INDEX_COLUMN,
+            DataType::Timestamp(time_unit, None),
+            false,
+        )]));
+        let empty_stream = MemoryStream::try_new(vec![], schema.clone(), None).unwrap();
+        RangeManipulateStream {
+            offset,
+            start,
+            end,
+            interval,
+            range,
+            time_index: 0,
+            time_unit,
+            field_columns: vec![],
+            aligned_ts_array: Arc::new(TimestampMillisecondArray::from(vec![0i64; 0])),
+            output_schema: schema,
+            input: Box::pin(empty_stream),
+            metric: BaselineMetrics::new(&ExecutionPlanMetricsSet::new(), 0),
+            num_series: Count::new(),
+        }
+    }
+
+    /// Exact expectations of the cursor scan, formulated outside the production loops.
+    ///
+    /// Every evaluation instant keeps the samples of `(instant - range, instant]` in
+    /// shifted nanoseconds: the lower boundary is exclusive, the upper one inclusive, and
+    /// native ticks below a millisecond stay distinct.
+    fn scan_oracle(
+        time_unit: TimeUnit,
+        offset: Millisecond,
+        range: Millisecond,
+        timestamps: &[i64],
+        start: Millisecond,
+        end: Millisecond,
+        interval: Millisecond,
+    ) -> Vec<(u32, u32)> {
+        let window_ns = (range as i128) * 1_000_000;
+        let shifted = timestamps
+            .iter()
+            .map(|timestamp| shifted_nanoseconds(time_unit, offset, *timestamp))
+            .collect::<Vec<_>>();
+        (start..=end)
+            .step_by(interval as usize)
+            .map(|instant| {
+                let instant_ns = (instant as i128) * 1_000_000;
+                let mut offset = None;
+                let mut length = 0u32;
+                for (index, timestamp) in shifted.iter().enumerate() {
+                    if *timestamp > instant_ns - window_ns && *timestamp <= instant_ns {
+                        offset.get_or_insert(index as u32);
+                        length += 1;
+                    }
+                }
+                (offset.unwrap_or(0), length)
+            })
+            .collect()
+    }
+
+    /// Runs the cursor scan of one input through both carriers.
+    fn scan_both_carriers(
+        stream: &RangeManipulateStream,
+        timestamps: &[i64],
+        start: Millisecond,
+        end: Millisecond,
+    ) -> (Option<RangeSelections>, RangeSelections) {
+        let exact = scan_ranges::<i128>(
+            stream.interval,
+            timestamps,
+            start,
+            end,
+            &ScanNanoseconds::<i128>::wide(stream.time_unit, stream.offset, stream.range),
+        );
+        let narrow = narrow_scan(
+            stream.time_unit,
+            stream.offset,
+            stream.range,
+            timestamps,
+            start,
+            end,
+        )
+        .map(|scan| scan_ranges::<i64>(stream.interval, timestamps, start, end, &scan));
+        // The benchmark hooks must measure the very scans the operator runs.
+        assert_eq!(
+            RangeManipulateStream::bench_scan_wide(
+                stream.time_unit,
+                stream.offset,
+                stream.range,
+                stream.interval,
+                timestamps,
+                start,
+                end,
+            ),
+            exact,
+            "the i128 benchmark hook diverged from the cursor scan"
+        );
+        if let Some(narrow) = &narrow {
+            assert_eq!(
+                RangeManipulateStream::bench_scan_narrow(
+                    stream.time_unit,
+                    stream.offset,
+                    stream.range,
+                    stream.interval,
+                    timestamps,
+                    start,
+                    end,
+                ),
+                Some(narrow.clone()),
+                "the i64 benchmark hook diverged from the cursor scan"
+            );
+        } else {
+            assert_eq!(
+                RangeManipulateStream::bench_scan_narrow(
+                    stream.time_unit,
+                    stream.offset,
+                    stream.range,
+                    stream.interval,
+                    timestamps,
+                    start,
+                    end,
+                ),
+                None,
+                "the i64 benchmark hook must report the fallback"
+            );
+        }
+        (narrow, exact)
+    }
+
+    /// Asserts the narrow carrier was taken and matches the exact scan evaluation by evaluation.
+    fn assert_narrow_carrier_agrees(
+        narrow: Option<Vec<(u32, u32)>>,
+        exact: &[(u32, u32)],
+        context: &str,
+    ) {
+        let Some(narrow) = narrow else {
+            panic!("the i64 carrier was expected, but narrow_scan rejected the input: {context}");
+        };
+        assert_eq!(
+            narrow.len(),
+            exact.len(),
+            "carriers disagree on the number of evaluations: {context}"
+        );
+        for (evaluation, (narrow_range, exact_range)) in narrow.iter().zip(exact).enumerate() {
+            assert_eq!(
+                narrow_range, exact_range,
+                "carriers disagree on evaluation {evaluation}: {context}"
+            );
+        }
+    }
+
+    /// Replays the cursor scan in checked `i64` arithmetic.
+    ///
+    /// Reports whether the narrow carrier overflows on an operation the scan evaluates,
+    /// which is what makes the `i128` fallback unavoidable for an input.
+    fn narrow_carrier_overflows(
+        time_unit: TimeUnit,
+        offset: Millisecond,
+        range: Millisecond,
+        timestamps: &[i64],
+        start: Millisecond,
+        end: Millisecond,
+        interval: Millisecond,
+    ) -> bool {
+        let Ok(scale) = i64::try_from(nanoseconds_per_native_tick(time_unit)) else {
+            return true;
+        };
+        let Some(offset_ns) = offset.checked_mul(1_000_000) else {
+            return true;
+        };
+        let Some(window_ns) = range.checked_mul(1_000_000) else {
+            return true;
+        };
+        let shift = |timestamp: i64| timestamp.checked_mul(scale)?.checked_add(offset_ns);
+        let mut left = 0usize;
+        let mut right = 0usize;
+        for instant in (start..=end).step_by(interval as usize) {
+            let Some(instant_ns) = instant.checked_mul(1_000_000) else {
+                return true;
+            };
+            let Some(window_start) = instant_ns.checked_sub(window_ns) else {
+                return true;
+            };
+            while left < timestamps.len() {
+                let Some(shifted) = shift(timestamps[left]) else {
+                    return true;
+                };
+                if shifted <= window_start {
+                    left += 1;
+                } else {
+                    break;
+                }
+            }
+            right = right.max(left);
+            while right < timestamps.len() {
+                let Some(shifted) = shift(timestamps[right]) else {
+                    return true;
+                };
+                if shifted <= instant_ns {
+                    right += 1;
+                } else {
+                    break;
+                }
+            }
+        }
+        false
+    }
+
+    /// The checked `i64` operation that makes [`narrow_scan`] reject an input, if any.
+    ///
+    /// Mirrors the rejection criteria of [`narrow_scan`] so the deterministic cases below
+    /// can pin which boundary drives the `i128` fallback.
+    fn narrow_carrier_rejection(
+        time_unit: TimeUnit,
+        offset: Millisecond,
+        range: Millisecond,
+        timestamps: &[i64],
+        start: Millisecond,
+        end: Millisecond,
+    ) -> Option<&'static str> {
+        let Ok(scale) = i64::try_from(nanoseconds_per_native_tick(time_unit)) else {
+            return Some("nanoseconds per native tick do not fit i64");
+        };
+        let Some(offset_ns) = offset.checked_mul(1_000_000) else {
+            return Some("offset in nanoseconds does not fit i64");
+        };
+        let Some(window_ns) = range.checked_mul(1_000_000) else {
+            return Some("range in nanoseconds does not fit i64");
+        };
+        let shift = |timestamp: i64| timestamp.checked_mul(scale)?.checked_add(offset_ns);
+        let (Some(first), Some(last)) = (timestamps.first(), timestamps.last()) else {
+            return Some("empty batch has no endpoints");
+        };
+        if shift(*first).is_none() || shift(*last).is_none() {
+            return Some("sample nanoseconds do not fit i64");
+        }
+        if start
+            .checked_mul(1_000_000)
+            .and_then(|nanoseconds| nanoseconds.checked_sub(window_ns))
+            .is_none()
+        {
+            return Some("start bound in nanoseconds does not fit i64");
+        }
+        if end
+            .checked_mul(1_000_000)
+            .and_then(|nanoseconds| nanoseconds.checked_sub(window_ns))
+            .is_none()
+        {
+            return Some("end bound in nanoseconds do not fit i64");
+        }
+        None
+    }
+
+    #[test]
+    fn scan_carriers_agree_on_range_boundaries_within_one_millisecond() {
+        // Membership is `(lower, upper]` on native ticks: the sample exactly on the lower
+        // boundary is dropped, the sample exactly on the upper boundary is kept, and the
+        // three samples sharing one millisecond payload stay distinct and survive together.
+        let cases = [
+            (
+                TimeUnit::Microsecond,
+                vec![1_000_000, 1_000_001, 1_000_999, 1_001_000, 1_001_001],
+            ),
+            (
+                TimeUnit::Nanosecond,
+                vec![
+                    1_000_000_000,
+                    1_000_000_001,
+                    1_000_000_999,
+                    1_001_000_000,
+                    1_001_000_001,
+                ],
+            ),
+        ];
+
+        for (time_unit, timestamps) in cases {
+            let (start, end, interval, range) = (1_001, 1_001, 1, 1);
+            let context = format!("unit={time_unit:?}, timestamps={timestamps:?}");
+            let stream = scan_stream_for_test(time_unit, 0, start, end, interval, range);
+
+            let oracle = scan_oracle(time_unit, 0, range, &timestamps, start, end, interval);
+            assert_eq!(
+                oracle,
+                vec![(1, 3)],
+                "{context}: (lower, upper] expectations"
+            );
+
+            let (narrow, exact) = scan_both_carriers(&stream, &timestamps, start, end);
+            assert_eq!(exact, oracle, "{context}: i128 carrier must stay exact");
+            assert_narrow_carrier_agrees(narrow, &exact, &context);
+
+            // Two distinct native ticks below the upper boundary share the millisecond
+            // payload `1_000`; they must not be deduplicated by going through that ABI.
+            let payloads = timestamps[1..4]
+                .iter()
+                .map(|timestamp| shifted_millis(time_unit, 0, *timestamp))
+                .collect::<Vec<_>>();
+            assert_eq!(
+                payloads,
+                vec![1_000, 1_000, 1_001],
+                "{context}: kept samples in one millisecond keep both native ticks"
+            );
+            assert_ne!(
+                timestamps[1], timestamps[2],
+                "{context}: the two ticks sharing a payload must stay distinct"
+            );
+        }
+    }
+
+    #[test]
+    fn scan_falls_back_to_i128_when_only_the_sample_tail_overflows() {
+        // `narrow_scan` inspects the sorted endpoints, so a batch whose prefix fits the
+        // `i64` carrier but whose tail does not has to take the exact carrier. The tail
+        // sample stays outside every window, so the selections keep the prefix ones.
+        struct Case {
+            time_unit: TimeUnit,
+            narrow_safe: Vec<i64>,
+            overflowing: i64,
+            start: Millisecond,
+            end: Millisecond,
+            interval: Millisecond,
+            range: Millisecond,
+        }
+
+        let cases = [
+            Case {
+                time_unit: TimeUnit::Second,
+                narrow_safe: vec![9_223_372_034, 9_223_372_035, 9_223_372_036],
+                overflowing: 9_223_372_037,
+                start: 9_223_372_034_000,
+                end: 9_223_372_036_000,
+                interval: 1_000,
+                range: 1_000,
+            },
+            Case {
+                time_unit: TimeUnit::Millisecond,
+                narrow_safe: vec![9_223_372_036_853, 9_223_372_036_854],
+                overflowing: 9_223_372_036_855,
+                start: 9_223_372_036_853,
+                end: 9_223_372_036_854,
+                interval: 1,
+                range: 1,
+            },
+            Case {
+                time_unit: TimeUnit::Microsecond,
+                narrow_safe: vec![9_223_372_036_853_999, 9_223_372_036_854_000],
+                overflowing: 9_223_372_036_854_776,
+                start: 9_223_372_036_854,
+                end: 9_223_372_036_854,
+                interval: 1,
+                range: 1,
+            },
+        ];
+
+        for case in cases {
+            let Case {
+                time_unit,
+                narrow_safe,
+                overflowing,
+                start,
+                end,
+                interval,
+                range,
+            } = case;
+            let context = format!("unit={time_unit:?}, timestamps={narrow_safe:?} + {overflowing}");
+            let scale = native_scale(time_unit);
+            // The prefix fits the narrow carrier, the tail sample does not...
+            assert!(
+                narrow_safe
+                    .iter()
+                    .all(|timestamp| timestamp.checked_mul(scale).is_some()),
+                "{context}: prefix samples must fit i64 nanoseconds"
+            );
+            assert!(
+                overflowing.checked_mul(scale).is_none(),
+                "{context}: the tail sample must overflow i64 nanoseconds"
+            );
+            // ...even though the millisecond payload of the tail stays legal.
+            let payload = shifted_millis(time_unit, 0, overflowing);
+            assert!(
+                payload.abs() < i64::MAX / 2,
+                "{context}: the shifted payload {payload} must stay legal"
+            );
+
+            let stream = scan_stream_for_test(time_unit, 0, start, end, interval, range);
+
+            let (narrow, prefix_exact) = scan_both_carriers(&stream, &narrow_safe, start, end);
+            let prefix_oracle =
+                scan_oracle(time_unit, 0, range, &narrow_safe, start, end, interval);
+            assert_eq!(
+                prefix_exact, prefix_oracle,
+                "{context}: prefix i128 carrier"
+            );
+            assert_narrow_carrier_agrees(narrow, &prefix_exact, &format!("{context} prefix"));
+
+            let mut timestamps = narrow_safe.clone();
+            timestamps.push(overflowing);
+            assert_eq!(
+                narrow_carrier_rejection(time_unit, 0, range, &timestamps, start, end),
+                Some("sample nanoseconds do not fit i64"),
+                "{context}: the overflowing endpoint must reject the narrow carrier"
+            );
+            assert!(
+                narrow_carrier_overflows(time_unit, 0, range, &timestamps, start, end, interval),
+                "{context}: the scan evaluates the overflowing tail"
+            );
+
+            let (narrow, exact) = scan_both_carriers(&stream, &timestamps, start, end);
+            assert!(
+                narrow.is_none(),
+                "{context}: the i128 carrier must be taken"
+            );
+            let oracle = scan_oracle(time_unit, 0, range, &timestamps, start, end, interval);
+            assert_eq!(exact, oracle, "{context}: exact carrier on the full batch");
+            assert_eq!(
+                exact, prefix_exact,
+                "{context}: the out-of-window tail keeps the prefix selections"
+            );
+        }
+    }
+
+    #[test]
+    fn scan_carriers_split_at_the_nanosecond_boundaries() {
+        // Nanoseconds are not scaled, so the `i64` carrier is rejected by the query bounds:
+        // below the millisecond of `i64::MIN` the start bound underflows, while a batch near
+        // `i64::MAX` still fits. Both keep a legal millisecond payload.
+        let low = i64::MIN;
+        let low_floor = shifted_floor_millis(TimeUnit::Nanosecond, 0, low);
+        assert_eq!(low_floor, -9_223_372_036_855);
+        assert!(low_floor.checked_mul(1_000_000).is_none());
+        assert_eq!(
+            shifted_millis(TimeUnit::Nanosecond, 0, low),
+            -9_223_372_036_854
+        );
+
+        let timestamps = vec![low, low + 1_000_000];
+        let (start, end, interval, range) = (low_floor, low_floor + 1, 1, 1);
+        let context = format!("nanosecond floor, timestamps={timestamps:?}");
+        let stream = scan_stream_for_test(TimeUnit::Nanosecond, 0, start, end, interval, range);
+        assert_eq!(
+            narrow_carrier_rejection(TimeUnit::Nanosecond, 0, range, &timestamps, start, end),
+            Some("start bound in nanoseconds does not fit i64"),
+            "{context}"
+        );
+        let (narrow, exact) = scan_both_carriers(&stream, &timestamps, start, end);
+        assert!(
+            narrow.is_none(),
+            "{context}: the i128 carrier must be taken"
+        );
+        let oracle = scan_oracle(
+            TimeUnit::Nanosecond,
+            0,
+            range,
+            &timestamps,
+            start,
+            end,
+            interval,
+        );
+        assert_eq!(exact, oracle, "{context}: i128 carrier must stay exact");
+
+        // The ceiling side still fits the narrow carrier, so both carriers have to agree.
+        let high = i64::MAX - 2_000_000;
+        let high_floor = shifted_floor_millis(TimeUnit::Nanosecond, 0, high);
+        assert!(high_floor.checked_mul(1_000_000).is_some());
+        let timestamps = vec![high, high + 1_000_000, high + 2_000_000];
+        let (start, end, interval, range) = (high_floor, high_floor + 2, 1, 1);
+        let context = format!("nanosecond ceiling, timestamps={timestamps:?}");
+        let stream = scan_stream_for_test(TimeUnit::Nanosecond, 0, start, end, interval, range);
+        assert_eq!(
+            narrow_carrier_rejection(TimeUnit::Nanosecond, 0, range, &timestamps, start, end),
+            None,
+            "{context}: the ceiling batch still fits the narrow carrier"
+        );
+        let (narrow, exact) = scan_both_carriers(&stream, &timestamps, start, end);
+        let oracle = scan_oracle(
+            TimeUnit::Nanosecond,
+            0,
+            range,
+            &timestamps,
+            start,
+            end,
+            interval,
+        );
+        assert_eq!(exact, oracle, "{context}: i128 carrier must stay exact");
+        assert_narrow_carrier_agrees(narrow, &exact, &context);
+    }
+
+    #[test]
+    fn scan_carriers_agree_for_seeded_native_precision_matrix() {
+        // Seeded matrix over all four native precisions: positive and negative offsets,
+        // negative times, sub-millisecond samples sharing a millisecond payload, and native
+        // extremes whose intermediate product overflows while the shifted millisecond stays
+        // legal.
+        let units = [
+            TimeUnit::Second,
+            TimeUnit::Millisecond,
+            TimeUnit::Microsecond,
+            TimeUnit::Nanosecond,
+        ];
+        // `narrow_scan` rejects the two large offsets: `offset * 1ms` overflows `i64`.
+        let offsets = [0, 1, -1, 250, -250, 9_223_372_036_855, -9_223_372_036_855];
+        let extremes = |time_unit: TimeUnit| match time_unit {
+            TimeUnit::Second => [-9_223_372_037, 9_223_372_037],
+            TimeUnit::Millisecond => [-9_223_372_036_855, 9_223_372_036_855],
+            TimeUnit::Microsecond => [-9_223_372_036_854_776, 9_223_372_036_854_776],
+            TimeUnit::Nanosecond => [i64::MIN, i64::MAX],
+        };
+        let mut prng = TinyPrng(0x5ca1_ab1e_d1ff_0001);
+        let mut narrow_cases = 0usize;
+        let mut wide_cases = 0usize;
+        let mut skipped = 0usize;
+
+        for case in 0..256usize {
+            let time_unit = units[case % units.len()];
+            let offset = offsets[(case / units.len()) % offsets.len()];
+            let [low, high] = extremes(time_unit);
+            let anchor = match prng.next_i64(0, 3) {
+                0 => prng.next_i64(-2_000, 2_000),
+                1 => -prng.next_i64(1, 2_000),
+                2 => low,
+                _ => high,
+            };
+            // Samples stay within a few milliseconds, with a native granularity small
+            // enough that sub-millisecond samples share a millisecond payload.
+            let step = match time_unit {
+                TimeUnit::Second => 1,
+                TimeUnit::Millisecond => 1,
+                TimeUnit::Microsecond => 1 + prng.next_i64(0, 9),
+                TimeUnit::Nanosecond => 1 + prng.next_i64(0, 999_999),
+            };
+            let count = 1 + prng.next_i64(0, 4);
+            let ascending = anchor != high;
+            let mut timestamps = (0..count)
+                .map(|index| {
+                    let delta = index * step;
+                    if ascending {
+                        anchor + delta
+                    } else {
+                        anchor - delta
+                    }
+                })
+                .collect::<Vec<_>>();
+            if !ascending {
+                timestamps.reverse();
+            }
+            // The review shape keeps a legal millisecond payload; skip the extremes that the
+            // large offsets push out of the millisecond space.
+            let nanoseconds = timestamps
+                .iter()
+                .map(|timestamp| shifted_nanoseconds(time_unit, offset, *timestamp))
+                .collect::<Vec<_>>();
+            if nanoseconds
+                .iter()
+                .any(|value| i64::try_from(value / 1_000_000).is_err())
+            {
+                skipped += 1;
+                continue;
+            }
+
+            let first_millis = Millisecond::try_from(nanoseconds[0].div_euclid(1_000_000)).unwrap();
+            let interval = prng.next_i64(1, 4);
+            let points = 1 + prng.next_i64(0, 4);
+            let start = first_millis - interval;
+            let end = start + interval * (points - 1);
+            let range = prng.next_i64(0, 3) * interval;
+            let context = format!(
+                "case={case}, unit={time_unit:?}, offset={offset}, start={start}, end={end}, \
+                 interval={interval}, range={range}, timestamps={timestamps:?}"
+            );
+
+            let stream = scan_stream_for_test(time_unit, offset, start, end, interval, range);
+            let oracle = scan_oracle(time_unit, offset, range, &timestamps, start, end, interval);
+            let (narrow, exact) = scan_both_carriers(&stream, &timestamps, start, end);
+            assert_eq!(exact, oracle, "{context}: i128 carrier must stay exact");
+
+            match (
+                &narrow,
+                narrow_carrier_rejection(time_unit, offset, range, &timestamps, start, end),
+            ) {
+                (Some(_), None) => {
+                    narrow_cases += 1;
+                    assert!(
+                        !narrow_carrier_overflows(
+                            time_unit,
+                            offset,
+                            range,
+                            &timestamps,
+                            start,
+                            end,
+                            interval
+                        ),
+                        "{context}: every narrow operation must fit i64"
+                    );
+                    assert_narrow_carrier_agrees(narrow, &exact, &context);
+                }
+                (None, Some(_reason)) => {
+                    wide_cases += 1;
+                }
+                (narrow, rejection) => panic!(
+                    "{context}: narrow_scan and its mirror disagree, narrow={}, rejection={rejection:?}",
+                    narrow.is_some()
+                ),
+            }
+        }
+
+        assert!(
+            narrow_cases > 0 && wide_cases > 0,
+            "both carriers must be covered: {narrow_cases} narrow, {wide_cases} wide \
+             ({skipped} skipped)"
+        );
+        assert!(
+            skipped < 64,
+            "the generator skipped too many cases: {skipped}"
+        );
+    }
+
+    /// Builds the single-column timestamp batch the cursor scans consume.
+    fn timestamp_batch(time_unit: TimeUnit, timestamps: &[i64]) -> RecordBatch {
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            TIME_INDEX_COLUMN,
+            DataType::Timestamp(time_unit, None),
+            false,
+        )]));
+        let array: ArrayRef = match time_unit {
+            TimeUnit::Second => Arc::new(TimestampSecondArray::from(timestamps.to_vec())),
+            TimeUnit::Millisecond => Arc::new(TimestampMillisecondArray::from(timestamps.to_vec())),
+            TimeUnit::Microsecond => Arc::new(TimestampMicrosecondArray::from(timestamps.to_vec())),
+            TimeUnit::Nanosecond => Arc::new(TimestampNanosecondArray::from(timestamps.to_vec())),
+        };
+        RecordBatch::try_new(schema, vec![array]).unwrap()
+    }
+
+    #[test]
+    fn calculate_range_dispatches_carriers_and_agrees_pointwise() {
+        // Production dispatch, not the hooks: `calculate_range` must scan through the narrow
+        // carrier while the batch fits and through the exact one once the shifted tail does
+        // not, and both must select the same ranges for the bounds it derives itself.
+        let narrow_timestamps = [0i64, 15_000, 30_000];
+        let wide_timestamps = [9_223_372_036_853, 9_223_372_036_854, 9_223_372_036_855];
+        let cases: [(&str, &[i64], Millisecond, Millisecond, bool); 2] = [
+            ("narrow carrier", &narrow_timestamps, 0, 30_000, true),
+            (
+                "i128 fallback",
+                &wide_timestamps,
+                wide_timestamps[0],
+                wide_timestamps[1],
+                false,
+            ),
+        ];
+
+        for (name, timestamps, query_start, query_end, expect_narrow) in cases {
+            let (interval, range) = if expect_narrow {
+                (15_000, 15_000)
+            } else {
+                (1, 1)
+            };
+            // `scan_stream_for_test` panics on an empty batch when `narrow_scan` is asked for
+            // the endpoints, so the batch below is never empty.
+            let stream = scan_stream_for_test(
+                TimeUnit::Millisecond,
+                0,
+                query_start,
+                query_end,
+                interval,
+                range,
+            );
+            let batch = timestamp_batch(TimeUnit::Millisecond, timestamps);
+            let (ranges, (start, end)) = stream.calculate_range(&batch).unwrap();
+
+            let oracle = scan_oracle(
+                TimeUnit::Millisecond,
+                0,
+                range,
+                timestamps,
+                start,
+                end,
+                interval,
+            );
+            assert_eq!(ranges, oracle, "{name}: calculate_range pointwise");
+
+            let rejection =
+                narrow_carrier_rejection(TimeUnit::Millisecond, 0, range, timestamps, start, end);
+            assert_eq!(
+                rejection.is_none(),
+                expect_narrow,
+                "{name}: carrier choice by narrow_scan, rejection={rejection:?}"
+            );
+            let (narrow, exact) = scan_both_carriers(&stream, timestamps, start, end);
+            assert_eq!(exact, ranges, "{name}: i128 carrier is the oracle");
+            assert_eq!(narrow.is_some(), expect_narrow, "{name}: narrow carrier");
+            assert_eq!(
+                RangeManipulateStream::bench_scan_wide(
+                    stream.time_unit,
+                    stream.offset,
+                    stream.range,
+                    interval,
+                    timestamps,
+                    start,
+                    end,
+                ),
+                ranges,
+                "{name}: the benchmark hook matches calculate_range"
+            );
+        }
+    }
+
+    /// Stream whose single millisecond timestamp column is folded into the range payload.
+    fn payload_stream(
+        offset: Millisecond,
+        start: Millisecond,
+        end: Millisecond,
+        interval: Millisecond,
+        range: Millisecond,
+    ) -> RangeManipulateStream {
+        let payload_type = DataType::Timestamp(TimeUnit::Millisecond, None);
+        let schema = Arc::new(Schema::new(vec![
+            Field::new(TIME_INDEX_COLUMN, payload_type.clone(), false),
+            Field::new(
+                RangeManipulate::build_timestamp_range_name(TIME_INDEX_COLUMN),
+                RangeArray::convert_data_type(payload_type),
+                false,
+            ),
+        ]));
+        let mut stream =
+            scan_stream_for_test(TimeUnit::Millisecond, offset, start, end, interval, range);
+        stream.output_schema = schema;
+        stream
+    }
+
+    /// Builds the single-column millisecond timestamp batch the payload tests consume.
+    fn timestamp_batch_with_timezone(timezone: Option<&str>, timestamps: &[i64]) -> RecordBatch {
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            TIME_INDEX_COLUMN,
+            DataType::Timestamp(TimeUnit::Millisecond, timezone.map(Arc::from)),
+            false,
+        )]));
+        let array: ArrayRef = Arc::new(
+            TimestampMillisecondArray::from(timestamps.to_vec()).with_timezone_opt(timezone),
+        );
+        RecordBatch::try_new(schema, vec![array]).unwrap()
+    }
+
+    /// Millisecond payload values of the range timestamp column of a manipulated batch.
+    fn payload_millis(batch: &RecordBatch) -> Vec<i64> {
+        let dict = batch
+            .column(batch.num_columns() - 1)
+            .as_any()
+            .downcast_ref::<DictionaryArray<Int64Type>>()
+            .expect("the timestamp range payload must be a folded dictionary")
+            .clone();
+        let payload = RangeArray::try_new(dict).unwrap();
+        assert_eq!(
+            payload.values().data_type(),
+            &DataType::Timestamp(TimeUnit::Millisecond, None),
+            "the payload value type must agree with the output schema"
+        );
+        payload
+            .values()
+            .as_any()
+            .downcast_ref::<TimestampMillisecondArray>()
+            .unwrap()
+            .values()
+            .to_vec()
+    }
+
+    #[test]
+    fn manipulate_timezone_time_index_skips_zero_copy_payload() {
+        // Oracle-verified regression: `Timestamp(Millisecond, Some(tz))` passes a
+        // `time_unit == Millisecond` check but is not the payload ABI. Cloning such a column
+        // would stamp a dictionary value type disagreeing with the output schema and
+        // `RecordBatch::try_new` would fail, so the reuse must be guarded on the data type.
+        let timestamps = [0i64, 1_000, 2_000, 3_000];
+        let stream = payload_stream(0, 0, 3_000, 1_000, 1_000);
+
+        // With offset 0 the data type is the only reason to convert, and the `try_unary`
+        // path is the identity for a millisecond index.
+        let zoned = stream
+            .manipulate(timestamp_batch_with_timezone(Some("+08:00"), &timestamps))
+            .expect("a timezone-carrying index must still build the output batch")
+            .expect("the ranges are not all empty");
+        assert_eq!(
+            payload_millis(&zoned),
+            timestamps,
+            "the converted payload must keep the try_unary values"
+        );
+
+        // The same logical samples without a timezone do take the zero-copy path; both paths
+        // must agree on the payload.
+        let plain = stream
+            .manipulate(timestamp_batch(TimeUnit::Millisecond, &timestamps))
+            .unwrap()
+            .unwrap();
+        assert_eq!(
+            payload_millis(&plain),
+            payload_millis(&zoned),
+            "the zero-copy and the converted path must agree"
+        );
+    }
+
+    /// A NULL slot's underlying value must never trigger the payload overflow
+    /// error: a nullable batch is converted with arrow's `try_unary`, which applies
+    /// the closure to valid rows only. The same value as a *valid* sample must still
+    /// error, through the null-free `unary` + overflow-cell path.
+    #[test]
+    fn manipulate_null_slot_underlying_value_does_not_overflow() {
+        // Second-slot underlying value i64::MAX seconds overflows on conversion,
+        // but the slot is NULL so the conversion must not see it. offset=1ms
+        // keeps the batch off the zero-copy path. The query range must be bounded
+        // and contain the first sample: with `end == 0` no range is selected and
+        // the conversion (and so the regression) is skipped, while an unbounded
+        // `end` makes the range scan visit `end - start` evaluation points.
+        let timestamps = [0i64, i64::MAX];
+        let validity = NullBuffer::from(vec![true, false]);
+        let array: ArrayRef = Arc::new(TimestampSecondArray::new(
+            timestamps.to_vec().into(),
+            Some(validity),
+        ));
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            TIME_INDEX_COLUMN,
+            DataType::Timestamp(TimeUnit::Second, None),
+            true,
+        )]));
+        let batch = RecordBatch::try_new(schema, vec![array]).unwrap();
+
+        let mut stream = payload_stream(1, 0, 1_000, 1, 1_000);
+        stream.time_unit = TimeUnit::Second;
+        let output = stream
+            .manipulate(batch)
+            .expect("a NULL slot's underlying value must not overflow the payload")
+            .expect("the first sample (0s + 1ms) is inside the query range");
+        assert_eq!(
+            payload_millis(&output)[0],
+            1,
+            "the valid sample must be converted to its shifted millisecond payload"
+        );
+
+        // Same underlying value, but now valid: the conversion must reject it.
+        let array: ArrayRef = Arc::new(TimestampSecondArray::from(timestamps.to_vec()));
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            TIME_INDEX_COLUMN,
+            DataType::Timestamp(TimeUnit::Second, None),
+            false,
+        )]));
+        let batch = RecordBatch::try_new(schema, vec![array]).unwrap();
+        let mut stream = payload_stream(1, 0, 1_000, 1, 1_000);
+        stream.time_unit = TimeUnit::Second;
+        let error = stream
+            .manipulate(batch)
+            .expect_err("a valid overflowing timestamp must still error");
+        assert!(
+            error.to_string().contains("timestamp payload overflow"),
+            "unexpected error: {error}"
+        );
+    }
 }
diff --git a/src/promql/src/extension_plan/scalar_calculate.rs b/src/promql/src/extension_plan/scalar_calculate.rs
index e71333837f3..0b330dfc00f 100644
--- a/src/promql/src/extension_plan/scalar_calculate.rs
+++ b/src/promql/src/extension_plan/scalar_calculate.rs
@@ -33,7 +33,7 @@ use datafusion::physical_plan::{
     SendableRecordBatchStream, StatisticsArgs,
 };
 use datafusion::prelude::Expr;
-use datafusion_expr::col;
+use datafusion_expr::ident;
 use datatypes::arrow::array::{Array, ArrayRef, Float64Array, TimestampMillisecondArray};
 use datatypes::arrow::compute::{CastOptions, cast_with_options, concat_batches};
 use datatypes::arrow::datatypes::{DataType, Field, Schema, SchemaRef, TimeUnit};
@@ -282,9 +282,9 @@ impl UserDefinedLogicalNodeCore for ScalarCalculate {
 
         self.tag_columns
             .iter()
-            .map(col)
-            .chain(std::iter::once(col(&self.time_index)))
-            .chain(std::iter::once(col(&self.field_column)))
+            .map(ident)
+            .chain(std::iter::once(ident(&self.time_index)))
+            .chain(std::iter::once(ident(&self.field_column)))
             .collect()
     }
 
@@ -413,7 +413,7 @@ impl ExecutionPlan for ScalarCalculateExec {
     }
 
     fn maintains_input_order(&self) -> Vec<bool> {
-        vec![true; self.children().len()]
+        vec![false]
     }
 
     fn input_distribution_requirements(&self) -> InputDistributionRequirements {
diff --git a/src/promql/src/extension_plan/series_divide.rs b/src/promql/src/extension_plan/series_divide.rs
index bf62f2c3332..bdd90696d26 100644
--- a/src/promql/src/extension_plan/series_divide.rs
+++ b/src/promql/src/extension_plan/series_divide.rs
@@ -38,7 +38,7 @@ use datafusion::physical_plan::{
     DisplayAs, DisplayFormatType, Distribution, ExecutionPlan, InputDistributionRequirements,
     PhysicalExpr, PlanProperties, RecordBatchStream, SendableRecordBatchStream,
 };
-use datafusion_expr::col;
+use datafusion_expr::ident;
 use datatypes::arrow::compute;
 use datatypes::arrow_array::string_array_value_at_index;
 use datatypes::compute::SortOptions;
@@ -186,8 +186,8 @@ impl UserDefinedLogicalNodeCore for SeriesDivide {
 
         self.tag_columns
             .iter()
-            .map(col)
-            .chain(std::iter::once(col(&self.time_index_column)))
+            .map(ident)
+            .chain(std::iter::once(ident(&self.time_index_column)))
             .collect()
     }
 
diff --git a/src/promql/src/extension_plan/union_distinct_on.rs b/src/promql/src/extension_plan/union_distinct_on.rs
index 774904a27aa..90d9dda637e 100644
--- a/src/promql/src/extension_plan/union_distinct_on.rs
+++ b/src/promql/src/extension_plan/union_distinct_on.rs
@@ -34,7 +34,7 @@ use datafusion::physical_plan::{
     Partitioning, PhysicalExpr, PlanProperties, RecordBatchStream, SendableRecordBatchStream,
     hash_utils,
 };
-use datafusion_expr::col;
+use datafusion_expr::ident;
 use datatypes::arrow::compute;
 use futures::{Stream, StreamExt, ready};
 use greptime_proto::substrait_extension as pb;
@@ -278,12 +278,12 @@ impl UserDefinedLogicalNodeCore for UnionDistinctOn {
         let mut exprs = self
             .compare_key_indices
             .iter()
-            .filter_map(|index| fields.get(*index).map(|field| col(field.name())))
+            .filter_map(|index| fields.get(*index).map(|field| ident(field.name())))
             .collect::<Vec<_>>();
         if !self.compare_key_indices.contains(&self.ts_col_idx)
             && let Some(field) = fields.get(self.ts_col_idx)
         {
-            exprs.push(col(field.name()));
+            exprs.push(ident(field.name()));
         }
         exprs
     }
diff --git a/src/promql/src/functions.rs b/src/promql/src/functions.rs
index 34618f0a953..6703505c277 100644
--- a/src/promql/src/functions.rs
+++ b/src/promql/src/functions.rs
@@ -19,6 +19,7 @@ mod double_exponential_smoothing;
 mod edge_count;
 mod extrapolate_rate;
 mod idelta;
+mod ieee_float;
 mod native_histogram;
 mod predict_linear;
 mod quantile;
@@ -45,6 +46,7 @@ pub use deriv::Deriv;
 pub use double_exponential_smoothing::DoubleExponentialSmoothing;
 pub use extrapolate_rate::{Delta, Increase, Rate};
 pub use idelta::IDelta;
+pub use ieee_float::{IeeeComparison, IeeeSqrt};
 pub use native_histogram::{
     MixedRange, NativeHistogramAbsentOverTime, NativeHistogramAdd, NativeHistogramAggAvg,
     NativeHistogramAggSum, NativeHistogramAvg, NativeHistogramAvgOverTime, NativeHistogramChanges,
diff --git a/src/promql/src/functions/idelta.rs b/src/promql/src/functions/idelta.rs
index 35ce44ba270..5734733234d 100644
--- a/src/promql/src/functions/idelta.rs
+++ b/src/promql/src/functions/idelta.rs
@@ -140,8 +140,13 @@ impl<const IS_RATE: bool> IDelta<IS_RATE> {
 
             let last_offset = ts_offset + last_position;
             let prev_offset = ts_offset + prev_position;
-            let sampled_interval =
-                (ts_values[last_offset] - ts_values[prev_offset]) as f64 / 1000.0;
+            let sampled_interval_ms = ts_values[last_offset] - ts_values[prev_offset];
+            // Sub-millisecond samples round to the same ms; skip instead of dividing by zero.
+            if sampled_interval_ms == 0 {
+                result_builder.append_null();
+                continue;
+            }
+            let sampled_interval = sampled_interval_ms as f64 / 1000.0;
 
             let last_value = value_values[value_offset + last_position];
             let prev_value = value_values[value_offset + prev_position];
@@ -263,4 +268,30 @@ mod test {
             vec![Some(3.0), None, None],
         );
     }
+
+    #[test]
+    fn idelta_skips_samples_in_same_millisecond() {
+        // The last two samples of the first range share 999ms; the second range is 1ms apart.
+        let ts_array = Arc::new(TimestampMillisecondArray::from_iter_values([
+            999i64, 999, 999, 1000,
+        ]));
+        let values_array = Arc::new(Float64Array::from_iter([10.0, 13.0, 999.0, 1000.0]));
+        let ranges = [(0, 3), (2, 2)];
+
+        simple_range_udf_runner(
+            IDelta::<false>::scalar_udf(),
+            RangeArray::from_ranges(ts_array.clone(), ranges).unwrap(),
+            RangeArray::from_ranges(values_array.clone(), ranges).unwrap(),
+            vec![],
+            vec![None, Some(1.0)],
+        );
+
+        simple_range_udf_runner(
+            IDelta::<true>::scalar_udf(),
+            RangeArray::from_ranges(ts_array, ranges).unwrap(),
+            RangeArray::from_ranges(values_array, ranges).unwrap(),
+            vec![],
+            vec![None, Some(1000.0)],
+        );
+    }
 }
diff --git a/src/promql/src/functions/ieee_float.rs b/src/promql/src/functions/ieee_float.rs
new file mode 100644
index 00000000000..d13480d8071
--- /dev/null
+++ b/src/promql/src/functions/ieee_float.rs
@@ -0,0 +1,265 @@
+// 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.
+
+//! PromQL comparison operators and `sqrt()`, which follow IEEE 754.
+//!
+//! Arrow compares floats by total order, where NaN equals NaN and is greater than `+Inf`, and
+//! DataFusion's `sqrt` rejects negative input. In PromQL every comparison involving NaN is false
+//! except `!=`, and the square root of a negative number is NaN. NULL input gives NULL output.
+//!
+//! The functions report the column name of the expression they replace (`a < b`, `sqrt(a)`), so
+//! query output columns are unchanged.
+
+use std::sync::Arc;
+
+use datafusion::arrow::array::{AsArray, BooleanArray, Float64Array};
+use datafusion::arrow::datatypes::{DataType, Float64Type};
+use datafusion::error::Result as DfResult;
+use datafusion::logical_expr::{
+    ColumnarValue, Operator, ScalarFunctionArgs, ScalarUDF, ScalarUDFImpl, Signature, Volatility,
+};
+use datafusion_expr::Expr;
+
+/// A PromQL comparison operator on two float operands.
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct IeeeComparison {
+    op: Operator,
+    signature: Signature,
+}
+
+impl IeeeComparison {
+    /// The comparison UDF for `op`, which must be a comparison operator.
+    pub fn scalar_udf(op: Operator) -> ScalarUDF {
+        ScalarUDF::new_from_impl(Self {
+            op,
+            signature: Signature::uniform(2, vec![DataType::Float64], Volatility::Immutable),
+        })
+    }
+
+    /// All comparison UDFs, for registering them where plans are decoded.
+    pub fn all() -> Vec<ScalarUDF> {
+        [
+            Operator::Eq,
+            Operator::NotEq,
+            Operator::Lt,
+            Operator::LtEq,
+            Operator::Gt,
+            Operator::GtEq,
+        ]
+        .into_iter()
+        .map(Self::scalar_udf)
+        .collect()
+    }
+
+    fn compare(&self, lhs: f64, rhs: f64) -> bool {
+        match self.op {
+            Operator::Eq => lhs == rhs,
+            Operator::NotEq => lhs != rhs,
+            Operator::Lt => lhs < rhs,
+            Operator::LtEq => lhs <= rhs,
+            Operator::Gt => lhs > rhs,
+            Operator::GtEq => lhs >= rhs,
+            _ => unreachable!("not a comparison operator: {}", self.op),
+        }
+    }
+}
+
+impl ScalarUDFImpl for IeeeComparison {
+    fn name(&self) -> &str {
+        match self.op {
+            Operator::Eq => "prom_eq",
+            Operator::NotEq => "prom_ne",
+            Operator::Lt => "prom_lt",
+            Operator::LtEq => "prom_le",
+            Operator::Gt => "prom_gt",
+            Operator::GtEq => "prom_ge",
+            _ => unreachable!("not a comparison operator: {}", self.op),
+        }
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> DfResult<DataType> {
+        Ok(DataType::Boolean)
+    }
+
+    fn schema_name(&self, args: &[Expr]) -> DfResult<String> {
+        Ok(format!(
+            "{} {} {}",
+            args[0].schema_name(),
+            self.op,
+            args[1].schema_name()
+        ))
+    }
+
+    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> DfResult<ColumnarValue> {
+        let arrays = ColumnarValue::values_to_arrays(&args.args)?;
+        let lhs = arrays[0].as_primitive::<Float64Type>();
+        let rhs = arrays[1].as_primitive::<Float64Type>();
+        let result: BooleanArray = lhs
+            .iter()
+            .zip(rhs.iter())
+            .map(|(lhs, rhs)| Some(self.compare(lhs?, rhs?)))
+            .collect();
+        Ok(ColumnarValue::Array(Arc::new(result)))
+    }
+}
+
+/// PromQL `sqrt()`.
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct IeeeSqrt {
+    signature: Signature,
+}
+
+impl IeeeSqrt {
+    pub fn scalar_udf() -> ScalarUDF {
+        ScalarUDF::new_from_impl(Self {
+            signature: Signature::uniform(1, vec![DataType::Float64], Volatility::Immutable),
+        })
+    }
+}
+
+impl ScalarUDFImpl for IeeeSqrt {
+    fn name(&self) -> &str {
+        "prom_sqrt"
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> DfResult<DataType> {
+        Ok(DataType::Float64)
+    }
+
+    fn schema_name(&self, args: &[Expr]) -> DfResult<String> {
+        Ok(format!("sqrt({})", args[0].schema_name()))
+    }
+
+    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> DfResult<ColumnarValue> {
+        let arrays = ColumnarValue::values_to_arrays(&args.args)?;
+        let input = arrays[0].as_primitive::<Float64Type>();
+        let result: Float64Array = input.unary(f64::sqrt);
+        Ok(ColumnarValue::Array(Arc::new(result)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use datafusion::arrow::array::{Array, ArrayRef};
+    use datafusion::arrow::datatypes::Field;
+    use datafusion_common::config::ConfigOptions;
+
+    use super::*;
+
+    fn invoke(udf: &ScalarUDF, args: Vec<ArrayRef>, return_type: DataType) -> ArrayRef {
+        let number_rows = args[0].len();
+        let arg_fields = args
+            .iter()
+            .map(|array| Arc::new(Field::new("a", array.data_type().clone(), true)))
+            .collect();
+        let result = udf
+            .invoke_with_args(ScalarFunctionArgs {
+                args: args.into_iter().map(ColumnarValue::Array).collect(),
+                arg_fields,
+                number_rows,
+                return_field: Arc::new(Field::new("r", return_type, true)),
+                config_options: Arc::new(ConfigOptions::default()),
+            })
+            .unwrap();
+        match result {
+            ColumnarValue::Array(array) => array,
+            ColumnarValue::Scalar(_) => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn comparisons_follow_ieee_and_propagate_null() {
+        let lhs: ArrayRef = Arc::new(Float64Array::from(vec![
+            Some(1.0),
+            Some(f64::NAN),
+            Some(f64::NAN),
+            None,
+            Some(f64::INFINITY),
+        ]));
+        let rhs: ArrayRef = Arc::new(Float64Array::from(vec![
+            Some(1.0),
+            Some(f64::NAN),
+            Some(1.0),
+            Some(f64::NAN),
+            Some(f64::NAN),
+        ]));
+        let expected = [
+            (
+                Operator::Eq,
+                [Some(true), Some(false), Some(false), None, Some(false)],
+            ),
+            (
+                Operator::NotEq,
+                [Some(false), Some(true), Some(true), None, Some(true)],
+            ),
+            (
+                Operator::Lt,
+                [Some(false), Some(false), Some(false), None, Some(false)],
+            ),
+            (
+                Operator::LtEq,
+                [Some(true), Some(false), Some(false), None, Some(false)],
+            ),
+            (
+                Operator::Gt,
+                [Some(false), Some(false), Some(false), None, Some(false)],
+            ),
+            (
+                Operator::GtEq,
+                [Some(true), Some(false), Some(false), None, Some(false)],
+            ),
+        ];
+        for (op, expected) in expected {
+            let result = invoke(
+                &IeeeComparison::scalar_udf(op),
+                vec![lhs.clone(), rhs.clone()],
+                DataType::Boolean,
+            );
+            let result: Vec<_> = result.as_boolean().iter().collect();
+            assert_eq!(result, expected, "{op}");
+        }
+    }
+
+    #[test]
+    fn sqrt_of_negative_is_nan() {
+        let input: ArrayRef = Arc::new(Float64Array::from(vec![Some(4.0), Some(-1.0), None]));
+        let result = invoke(&IeeeSqrt::scalar_udf(), vec![input], DataType::Float64);
+        let result = result.as_primitive::<Float64Type>();
+        assert_eq!(result.value(0), 2.0);
+        assert!(result.value(1).is_nan());
+        assert!(result.is_null(2));
+    }
+
+    #[test]
+    fn column_names_match_the_replaced_expressions() {
+        let a = datafusion_expr::col("a");
+        let b = datafusion_expr::lit(1.5_f64);
+        let comparison =
+            IeeeComparison::scalar_udf(Operator::LtEq).call(vec![a.clone(), b.clone()]);
+        assert_eq!(
+            comparison.schema_name().to_string(),
+            a.clone().lt_eq(b).schema_name().to_string()
+        );
+        let sqrt = IeeeSqrt::scalar_udf().call(vec![a.clone()]);
+        assert_eq!(sqrt.schema_name().to_string(), "sqrt(a)");
+    }
+}
diff --git a/src/promql/src/functions/round.rs b/src/promql/src/functions/round.rs
index 72736ef6e2e..c5ba4c218c0 100644
--- a/src/promql/src/functions/round.rs
+++ b/src/promql/src/functions/round.rs
@@ -66,13 +66,7 @@ impl Round {
                     let null_array = Float64Array::new_null(value_array.len());
                     return Ok(ColumnarValue::Array(Arc::new(null_array)));
                 };
-                let op = |a: f64| {
-                    if nearest == 0.0 {
-                        a.round()
-                    } else {
-                        (a / nearest).round() * nearest
-                    }
-                };
+                let op = |a: f64| round_to_nearest(a, nearest);
                 let result: PrimitiveArray<Float64Type> =
                     value_array.as_primitive::<Float64Type>().unary(op);
                 Ok(ColumnarValue::Array(Arc::new(result) as _))
@@ -90,14 +84,10 @@ impl Round {
                 )?;
 
                 let result: PrimitiveArray<Float64Type> =
-                    datatypes::arrow::compute::binary(value_array, nearest_array, |a, nearest| {
-                        if nearest == 0.0 {
-                            a.round()
-                        } else {
-                            (a / nearest).round() * nearest
-                        }
-                    })
-                    .map_err(|err: ArrowError| DataFusionError::ArrowError(Box::new(err), None))?;
+                    datatypes::arrow::compute::binary(value_array, nearest_array, round_to_nearest)
+                        .map_err(|err: ArrowError| {
+                            DataFusionError::ArrowError(Box::new(err), None)
+                        })?;
 
                 Ok(ColumnarValue::Array(Arc::new(result) as _))
             }
@@ -105,6 +95,13 @@ impl Round {
     }
 }
 
+/// Rounds like Prometheus: ties round up (towards +Inf), and multiplying by the inverse
+/// of `nearest` follows its float behavior, including NaN for `nearest == 0`.
+fn round_to_nearest(value: f64, nearest: f64) -> f64 {
+    let inverse = 1.0 / nearest;
+    (value * inverse + 0.5).floor() / inverse
+}
+
 #[cfg(test)]
 mod tests {
     use datafusion_common::config::ConfigOptions;
@@ -143,14 +140,43 @@ mod tests {
 
     #[test]
     fn test_round() {
+        // Expected values are Prometheus 3.15 `round()` results.
         test_round_f64(vec![123.456], 0.001, vec![123.456]);
-        test_round_f64(vec![123.456], 0.01, vec![123.46000000000001]);
+        test_round_f64(vec![123.456], 0.01, vec![123.46]);
         test_round_f64(vec![123.456], 0.1, vec![123.5]);
-        test_round_f64(vec![123.456], 0.0, vec![123.0]);
         test_round_f64(vec![123.456], 1.0, vec![123.0]);
         test_round_f64(vec![123.456], 10.0, vec![120.0]);
         test_round_f64(vec![123.456], 100.0, vec![100.0]);
-        test_round_f64(vec![123.456], 105.0, vec![105.0]);
+        test_round_f64(vec![123.456], 105.0, vec![104.99999999999999]);
         test_round_f64(vec![123.456], 1000.0, vec![0.0]);
     }
+
+    #[test]
+    fn test_round_ties_towards_positive_infinity() {
+        test_round_f64(vec![-0.5], 1.0, vec![0.0]);
+        test_round_f64(vec![-2.5], 1.0, vec![-2.0]);
+        test_round_f64(vec![2.5], 1.0, vec![3.0]);
+    }
+
+    #[test]
+    fn test_round_to_zero_is_nan() {
+        let round_udf = Round::scalar_udf();
+        let input = vec![
+            ColumnarValue::Array(Arc::new(Float64Array::from(vec![123.456]))),
+            ColumnarValue::Scalar(ScalarValue::Float64(Some(0.0))),
+        ];
+        let arg_fields = vec![
+            Arc::new(Field::new("a", input[0].data_type(), false)),
+            Arc::new(Field::new("b", input[1].data_type(), false)),
+        ];
+        let args = ScalarFunctionArgs {
+            args: input,
+            arg_fields,
+            number_rows: 1,
+            return_field: Arc::new(Field::new("c", DataType::Float64, false)),
+            config_options: Arc::new(ConfigOptions::default()),
+        };
+        let result = extract_array(&round_udf.invoke_with_args(args).unwrap()).unwrap();
+        assert!(result.as_primitive::<Float64Type>().value(0).is_nan());
+    }
 }
diff --git a/src/promql/src/functions/vector_matching.rs b/src/promql/src/functions/vector_matching.rs
index fdef83f6f05..ef96e8aa5ea 100644
--- a/src/promql/src/functions/vector_matching.rs
+++ b/src/promql/src/functions/vector_matching.rs
@@ -34,6 +34,8 @@ pub enum MatchGroupViolation {
     ImplicitManyToOne,
     /// A group modifier left several matches with the same result label set.
     AmbiguousGroupLabels,
+    /// A function rewrote labels so that several series share the same label set.
+    DuplicateLabelSet,
 }
 
 impl MatchGroupViolation {
@@ -54,6 +56,9 @@ impl MatchGroupViolation {
             Self::AmbiguousGroupLabels => format!(
                 "multiple matches for labels {group}: grouping labels must ensure unique matches"
             ),
+            Self::DuplicateLabelSet => {
+                "vector cannot contain metrics with the same labelset".to_string()
+            }
         }
     }
 }
diff --git a/src/query/src/datafusion.rs b/src/query/src/datafusion.rs
index 970f3109804..72788461836 100644
--- a/src/query/src/datafusion.rs
+++ b/src/query/src/datafusion.rs
@@ -68,6 +68,7 @@ use crate::metrics::{
     OnDone, QUERY_STAGE_ELAPSED, maybe_attach_region_watermark_metrics,
     should_collect_region_watermark_from_query_ctx,
 };
+use crate::optimizer::expr_depth;
 use crate::options::ScheduledTimeExtension;
 use crate::physical_wrapper::PhysicalPlanWrapperRef;
 use crate::planner::{DfLogicalPlanner, LogicalPlanner};
@@ -381,6 +382,8 @@ impl DatafusionQueryEngine {
             }
         }
 
+        expr_depth::validate_plan(logical_plan)?;
+
         let mut logger = PanicLogger {
             input_logical_plan: logical_plan,
             after_analyze: None,
@@ -408,6 +411,7 @@ impl DatafusionQueryEngine {
             |_, _| {},
         )?;
 
+        expr_depth::validate_plan(&analyzed_plan)?;
         logger.after_analyze = Some(analyzed_plan.clone());
 
         common_telemetry::debug!("Create physical plan, analyzed plan: {analyzed_plan}");
@@ -423,6 +427,7 @@ impl DatafusionQueryEngine {
                 .optimize(analyzed_plan, state, |_, _| {})?
         };
 
+        expr_depth::validate_plan(&optimized_plan)?;
         common_telemetry::debug!("Create physical plan, optimized plan: {optimized_plan}");
         logger.after_optimize = Some(optimized_plan.clone());
 
diff --git a/src/query/src/dist_plan.rs b/src/query/src/dist_plan.rs
index 969f00e7c9c..a982eb1d8bf 100644
--- a/src/query/src/dist_plan.rs
+++ b/src/query/src/dist_plan.rs
@@ -27,7 +27,7 @@ mod remote_dyn_filter_registry;
 pub use analyzer::{DistPlannerAnalyzer, DistPlannerOptions};
 pub use filter_id::{FilterFingerprint, FilterId, ParseFilterIdError, RemoteDynFilterProducerId};
 pub use merge_scan::{MergeScanExec, MergeScanLogicalPlan};
-pub(crate) use merge_sort::MergeSortExec;
+pub(crate) use merge_sort::{MergeSortExec, MergeSortLogicalPlan};
 pub use planner::{DistExtensionPlanner, MergeSortExtensionPlanner};
 pub use predicate_extractor::PredicateExtractor;
 pub use region_pruner::ConstraintPruner;
diff --git a/src/query/src/dist_plan/analyzer.rs b/src/query/src/dist_plan/analyzer.rs
index 2c1d066054a..d90e5d31f9f 100644
--- a/src/query/src/dist_plan/analyzer.rs
+++ b/src/query/src/dist_plan/analyzer.rs
@@ -53,6 +53,8 @@ use crate::dist_plan::commutativity::{
 use crate::dist_plan::merge_scan::MergeScanLogicalPlan;
 use crate::dist_plan::merge_sort::MergeSortLogicalPlan;
 use crate::metrics::PUSH_DOWN_FALLBACK_ERRORS_TOTAL;
+use crate::optimizer::expr_depth;
+use crate::optimizer::infer_aggregate_input_bounds::InferAggregateInputBoundsRule;
 use crate::options::ScheduledTimeExtension;
 use crate::plan::ExtractExpr;
 use crate::query_engine::DefaultSerializer;
@@ -118,6 +120,7 @@ impl AnalyzerRule for DistPlannerAnalyzer {
         plan: LogicalPlan,
         config: &ConfigOptions,
     ) -> datafusion_common::Result<LogicalPlan> {
+        expr_depth::validate_plan(&plan)?;
         let mut config = config.clone();
         // Aligned with the behavior in `datafusion_optimizer::OptimizerContext::new()`.
         config.optimizer.filter_null_join_keys = true;
@@ -142,6 +145,7 @@ impl AnalyzerRule for DistPlannerAnalyzer {
         let plan = plan
             .rewrite_with_subqueries(&mut PlanTreeExpressionSimplifier::new(optimizer_context))?
             .data;
+        expr_depth::validate_plan(&plan)?;
         let fallback_plan = plan.clone();
 
         // Run a filter-focused optimizer subset before MergeScan wraps remote
@@ -222,6 +226,7 @@ fn pre_merge_scan_optimizer() -> Optimizer {
         Arc::new(EliminateFilter::new()),
         Arc::new(PropagateEmptyRelation::new()),
         Arc::new(FilterNullJoinKeys::default()),
+        Arc::new(InferAggregateInputBoundsRule),
         Arc::new(PushDownFilter::new()),
         Arc::new(SimplifyExpressions::new()),
     ])
@@ -653,7 +658,7 @@ impl PlanRewriter {
                 ))
             })?;
 
-            for (_col_name, alias_set) in part_cols.iter_mut() {
+            for alias_set in part_cols.values_mut() {
                 let aliased_cols = aliased_columns_for(
                     &alias_set.clone().into_iter().collect(),
                     plan,
@@ -768,14 +773,7 @@ impl PlanRewriter {
         );
 
         // add merge scan as the new root
-        let mut node = MergeScanLogicalPlan::new(
-            on_node.clone(),
-            false,
-            // at this stage, the partition cols should be set
-            // treat it as non-partitioned if None
-            self.partition_cols.clone().unwrap_or_default(),
-        )
-        .into_logical_plan();
+        let mut node = MergeScanLogicalPlan::new(on_node.clone(), false).into_logical_plan();
 
         // expand stages
         for new_stage in self.stage.drain(..) {
diff --git a/src/query/src/dist_plan/analyzer/fallback.rs b/src/query/src/dist_plan/analyzer/fallback.rs
index 86c7f50628d..0aabdd6cfd8 100644
--- a/src/query/src/dist_plan/analyzer/fallback.rs
+++ b/src/query/src/dist_plan/analyzer/fallback.rs
@@ -17,18 +17,11 @@
 //! This is a temporary solution, and will be removed once we have a more robust plan rewriter
 //!
 
-use std::collections::BTreeSet;
-
-use common_telemetry::debug;
-use datafusion::datasource::DefaultTableSource;
 use datafusion_common::Result as DfResult;
 use datafusion_common::tree_node::{Transformed, TreeNodeRewriter};
 use datafusion_expr::LogicalPlan;
-use table::metadata::TableType;
-use table::table::adapter::DfTableProviderAdapter;
 
 use crate::dist_plan::MergeScanLogicalPlan;
-use crate::dist_plan::analyzer::{AliasMapping, OTHER_PHY_PART_COL_PLACEHOLDER};
 
 /// FallbackPlanRewriter is a plan rewriter that will only push down table scan node
 /// This is used when `PlanRewriter` produce errors when trying to rewrite the plan
@@ -44,69 +37,8 @@ impl TreeNodeRewriter for FallbackPlanRewriter {
         &mut self,
         plan: Self::Node,
     ) -> DfResult<datafusion_common::tree_node::Transformed<Self::Node>> {
-        if let LogicalPlan::TableScan(table_scan) = &plan {
-            let partition_cols = if let Some(source) =
-                table_scan.source.downcast_ref::<DefaultTableSource>()
-            {
-                if let Some(provider) = source
-                    .table_provider
-                    .downcast_ref::<DfTableProviderAdapter>()
-                {
-                    if provider.table().table_type() == TableType::Base {
-                        let info = provider.table().table_info();
-                        let partition_key_indices = info.meta.partition_key_indices.clone();
-                        let schema = info.meta.schema.clone();
-                        let partition_cols = partition_key_indices
-                            .iter()
-                            .map(|index| schema.column_name_by_index(*index).to_string())
-                            .collect::<Vec<String>>();
-                        debug!(
-                            "FallbackPlanRewriter: loaded table partition metadata, table: {}, table_id: {}, partition_key_indices: {:?}, partition_columns: {:?}",
-                            info.name,
-                            info.ident.table_id,
-                            info.meta.partition_key_indices,
-                            partition_cols,
-                        );
-                        Some(partition_cols
-                                .into_iter()
-                                .map(|c| {
-                                    if c == OTHER_PHY_PART_COL_PLACEHOLDER {
-                                        // for placeholder, just return a empty alias
-                                        return Ok((c.clone(), BTreeSet::new()));
-                                    }
-                                    let index =
-                                        plan.schema().index_of_column_by_name(None, &c).ok_or_else(|| {
-                                            datafusion_common::DataFusionError::Internal(
-                                                format!(
-                                                    "PlanRewriter: maybe_set_partitions: column {c} not found in schema of plan: {plan}"
-                                                ),
-                                            )
-                                        })?;
-                                    let column = plan.schema().columns().get(index).cloned().ok_or_else(|| {
-                                        datafusion_common::DataFusionError::Internal(format!(
-                                            "PlanRewriter: maybe_set_partitions: column index {index} out of bounds in schema of plan: {plan}"
-                                        ))
-                                    })?;
-                                    Ok((c.clone(), BTreeSet::from([column])))
-                                })
-                                .collect::<DfResult<AliasMapping>>()?)
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                }
-            } else {
-                None
-            };
-            let node = MergeScanLogicalPlan::new(
-                plan,
-                false,
-                // at this stage, the partition cols should be set
-                // treat it as non-partitioned if None
-                partition_cols.clone().unwrap_or_default(),
-            )
-            .into_logical_plan();
+        if matches!(plan, LogicalPlan::TableScan(_)) {
+            let node = MergeScanLogicalPlan::new(plan, false).into_logical_plan();
             Ok(Transformed::yes(node))
         } else {
             Ok(Transformed::no(plan))
diff --git a/src/query/src/dist_plan/analyzer/test.rs b/src/query/src/dist_plan/analyzer/test.rs
index 694f2bcde59..a689d94c282 100644
--- a/src/query/src/dist_plan/analyzer/test.rs
+++ b/src/query/src/dist_plan/analyzer/test.rs
@@ -58,6 +58,7 @@ use table::table::numbers::NumbersTable;
 use table::{Table, TableRef};
 
 use super::*;
+use crate::optimizer::count_wildcard::CountWildcardToTimeIndexRule;
 
 fn collect_merge_scan_remote_dyn_filter_producer_ids(
     plan: &LogicalPlan,
@@ -1633,6 +1634,116 @@ fn sibling_merge_scans_have_unique_remote_dyn_filter_producer_ids() {
     );
 }
 
+#[tokio::test]
+async fn having_bound_reaches_remote_scan_before_aggregate_splitting() {
+    for pushdown in [FilterPushDownType::Inexact, FilterPushDownType::Exact] {
+        let table = TestTable::table_with_filter_pushdown(0, "t".to_string(), pushdown);
+        let ctx = SessionContext::new();
+        ctx.register_table("t", Arc::new(DfTableProviderAdapter::new(table)))
+            .unwrap();
+        // Both region-local groups and groups requiring coordinator aggregation
+        // must receive the bound before MIN/SUM become state aggregates.
+        for group_by in ["pk1, pk2", "pk3"] {
+            let sql = format!(
+                "SELECT {group_by}, MIN(CAST(ts AS BIGINT)) FROM t GROUP BY {group_by}
+                 HAVING SUM(CASE WHEN number > 0 AND CAST(ts AS BIGINT) >= 10
+                     AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0"
+            );
+            let state = ctx.state();
+            let plan = state.create_logical_plan(&sql).await.unwrap();
+            let plan = state
+                .analyzer()
+                .execute_and_check(plan, state.config_options(), |_, _| {})
+                .unwrap();
+            let planned = DistPlannerAnalyzer
+                .analyze(plan, state.config_options())
+                .unwrap();
+            let remote = find_merge_scan_for_table(&planned, "t").unwrap().input();
+            let scan = find_table_scan(remote, "t").unwrap();
+            let bound = datafusion_expr::cast(col("t.ts"), DataType::Int64).lt(lit(20_i64));
+            assert!(scan.filters.contains(&bound), "{planned}");
+            assert!(
+                planned.to_string().contains("> Int64(0)"),
+                "HAVING must remain: {planned}"
+            );
+            assert_remote_table_scan_filters_are_safe(&planned);
+        }
+    }
+}
+
+#[tokio::test]
+async fn frontend_having_does_not_reinfer_remote_bounds() {
+    let ctx = SessionContext::new();
+    for (id, name) in [(0, "t"), (1, "u")] {
+        let table = TestTable::table_with_filter_pushdown(
+            id,
+            name.to_string(),
+            FilterPushDownType::Inexact,
+        );
+        ctx.register_table(name, Arc::new(DfTableProviderAdapter::new(table)))
+            .unwrap();
+    }
+    for source in [
+        "SELECT t.pk3, t.ts, t.number FROM t JOIN u ON t.pk1 = u.pk1",
+        "SELECT pk3, ts, number FROM t UNION ALL SELECT pk3, ts, number FROM u",
+    ] {
+        let sql = format!(
+            "SELECT s.pk3, MIN(CAST(s.ts AS BIGINT)) FROM ({source}) s
+            GROUP BY s.pk3 HAVING SUM(CASE WHEN s.number > 0 AND CAST(s.ts AS BIGINT) < 20
+            THEN 1 ELSE 0 END) > 0"
+        );
+        let state = ctx.state();
+        let plan = state.create_logical_plan(&sql).await.unwrap();
+        let plan = state
+            .analyzer()
+            .execute_and_check(plan, state.config_options(), |_, _| {})
+            .unwrap();
+        let planned = DistPlannerAnalyzer
+            .analyze(plan, state.config_options())
+            .unwrap();
+        let remote = find_merge_scan_for_table(&planned, "t").unwrap().input();
+        let scan = find_table_scan(remote, "t").unwrap();
+        let bound = datafusion_expr::cast(col("t.ts"), DataType::Int64).lt(lit(20_i64));
+        assert!(scan.filters.contains(&bound), "{planned}");
+
+        let config = datafusion_optimizer::OptimizerContext::new();
+        let rule_only = Optimizer::with_rules(vec![Arc::new(InferAggregateInputBoundsRule)]);
+        assert_eq!(
+            planned,
+            rule_only
+                .optimize(planned.clone(), &config, |_, _| {})
+                .unwrap()
+        );
+
+        let mut optimizer = Optimizer::new();
+        let index = optimizer
+            .rules
+            .iter()
+            .position(|rule| rule.name() == "push_down_filter")
+            .unwrap();
+        optimizer
+            .rules
+            .insert(index, Arc::new(InferAggregateInputBoundsRule));
+        let optimized = optimizer.optimize(planned, &config, |_, _| {}).unwrap();
+        // MergeScan hides remote filters from this walk. Only HAVING should
+        // remain on the frontend, not another copy of the input bound.
+        let mut filters = 0;
+        optimized
+            .apply(|plan| {
+                filters += usize::from(matches!(plan, LogicalPlan::Filter(_)));
+                Ok(TreeNodeRecursion::Continue)
+            })
+            .unwrap();
+        assert_eq!(1, filters, "{optimized}");
+        assert_eq!(
+            optimized,
+            optimizer
+                .optimize(optimized.clone(), &config, |_, _| {})
+                .unwrap()
+        );
+    }
+}
+
 #[test]
 fn pre_merge_scan_optimizer_eliminates_projected_false_filter() {
     init_default_ut_logging();
@@ -1887,6 +1998,98 @@ fn expand_step_aggr_avg_limit() {
     assert_eq!(expected, result.to_string());
 }
 
+/// `count(*)` and `count(1)` are rewritten to `count(ts)` with their names preserved, so
+/// all three share one state expression and must share one state column.
+#[test]
+fn expand_step_aggr_count_wildcard_and_time_index() {
+    init_default_ut_logging();
+    let test_table = TestTable::table_with_name(0, "t".to_string());
+    let table_source = Arc::new(DefaultTableSource::new(Arc::new(
+        DfTableProviderAdapter::new(test_table),
+    )));
+    let plan = LogicalPlanBuilder::scan_with_filters("t", table_source, None, vec![])
+        .unwrap()
+        .aggregate(
+            Vec::<Expr>::new(),
+            vec![
+                datafusion::functions_aggregate::count::count_all(),
+                datafusion::functions_aggregate::expr_fn::count(lit(1i64)),
+                datafusion::functions_aggregate::expr_fn::count(col("ts")),
+            ],
+        )
+        .unwrap()
+        .project(vec![
+            col("count(*)").alias("a"),
+            col("count(Int64(1))"),
+            col("count(t.ts)").alias("b"),
+        ])
+        .unwrap()
+        .build()
+        .unwrap();
+
+    let config = ConfigOptions::default();
+    let plan = CountWildcardToTimeIndexRule.analyze(plan, &config).unwrap();
+    let result = DistPlannerAnalyzer {}.analyze(plan, &config).unwrap();
+    let expected = [
+        "Projection: count(*) AS a, count(Int64(1)), count(t.ts) AS b",
+        "  Projection: count(*), count(Int64(1)), count(t.ts)",
+        "    Aggregate: groupBy=[[]], aggr=[[__count_merge(__count_state(t.ts)) AS count(*), __count_merge(__count_state(t.ts)) AS count(Int64(1)), __count_merge(__count_state(t.ts)) AS count(t.ts)]]",
+        "      MergeScan [is_placeholder=false, remote_input=[",
+        "Aggregate: groupBy=[[]], aggr=[[__count_state(t.ts)]]",
+        "  TableScan: t",
+        "]]",
+    ]
+    .join("\n");
+    assert_eq!(expected, result.to_string());
+}
+
+/// After the `count(*)` rewrite, `count(ts)` and the casts of `ts` are different states with
+/// the same schema name, as schema names hide casts. The output alias `t.ts` and the second
+/// cast make sure a renamed state never takes a name that is already allocated.
+#[test]
+fn expand_step_aggr_count_wildcard_and_cast_time_index() {
+    init_default_ut_logging();
+    let test_table = TestTable::table_with_name(0, "t".to_string());
+    let table_source = Arc::new(DefaultTableSource::new(Arc::new(
+        DfTableProviderAdapter::new(test_table),
+    )));
+    let plan = LogicalPlanBuilder::scan_with_filters("t", table_source, None, vec![])
+        .unwrap()
+        .aggregate(
+            Vec::<Expr>::new(),
+            vec![
+                datafusion::functions_aggregate::count::count_all(),
+                datafusion::functions_aggregate::expr_fn::count(datafusion_expr::cast(
+                    col("ts"),
+                    DataType::Int64,
+                ))
+                .alias("t.ts"),
+                datafusion::functions_aggregate::expr_fn::count(datafusion_expr::cast(
+                    col("ts"),
+                    DataType::Utf8,
+                ))
+                .alias("c"),
+            ],
+        )
+        .unwrap()
+        .build()
+        .unwrap();
+
+    let config = ConfigOptions::default();
+    let plan = CountWildcardToTimeIndexRule.analyze(plan, &config).unwrap();
+    let result = DistPlannerAnalyzer {}.analyze(plan, &config).unwrap();
+    let expected = [
+        "Projection: count(*), t.ts, c",
+        "  Aggregate: groupBy=[[]], aggr=[[__count_merge(__count_state(t.ts)) AS count(*), __count_merge(__count_state(t.ts)_1) AS t.ts, __count_merge(__count_state(t.ts)_2) AS c]]",
+        "    MergeScan [is_placeholder=false, remote_input=[",
+        "Aggregate: groupBy=[[]], aggr=[[__count_state(t.ts), __count_state(CAST(t.ts AS Int64)) AS __count_state(t.ts)_1, __count_state(CAST(t.ts AS Utf8)) AS __count_state(t.ts)_2]]",
+        "  TableScan: t",
+        "]]",
+    ]
+    .join("\n");
+    assert_eq!(expected, result.to_string());
+}
+
 /// notice how `Limit` can still get expanded
 #[test]
 fn expand_part_col_aggr_limit() {
diff --git a/src/query/src/dist_plan/merge_scan.rs b/src/query/src/dist_plan/merge_scan.rs
index ee4e9574280..9717c436e0b 100644
--- a/src/query/src/dist_plan/merge_scan.rs
+++ b/src/query/src/dist_plan/merge_scan.rs
@@ -17,7 +17,7 @@ use std::cell::Cell;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use ahash::{HashMap, HashSet};
+use ahash::HashMap;
 use arrow_schema::{
     ArrowError, DataType as ArrowDataType, Field, Schema as ArrowSchema,
     SchemaRef as ArrowSchemaRef, SortOptions,
@@ -44,10 +44,9 @@ use datafusion::physical_plan::{
 };
 use datafusion_common::stats::Precision;
 use datafusion_common::tree_node::TreeNodeRecursion;
-use datafusion_common::{Column as ColumnExpr, DFSchemaRef, DataFusionError, Result, Statistics};
+use datafusion_common::{DFSchemaRef, DataFusionError, Result, Statistics};
 use datafusion_expr::{Expr, Extension, FetchType, LogicalPlan, UserDefinedLogicalNodeCore};
-use datafusion_physical_expr::expressions::Column;
-use datafusion_physical_expr::{Distribution, EquivalenceProperties, PhysicalSortExpr};
+use datafusion_physical_expr::{EquivalenceProperties, PhysicalSortExpr};
 use datatypes::extension::json::is_any_json_extension_type;
 use futures_util::StreamExt;
 use greptime_proto::v1::region::RegionRequestHeader;
@@ -64,7 +63,6 @@ use tokio::time;
 use tokio::time::Instant;
 use tracing::{Instrument, Span};
 
-use crate::dist_plan::analyzer::AliasMapping;
 use crate::dist_plan::analyzer::utils::patch_batch_timezone;
 use crate::dist_plan::dyn_filter_bridge::{
     CapturedDynFilter, capture_remote_dyn_filters_for_pushdown,
@@ -169,8 +167,20 @@ fn is_json_field(field: &Field) -> bool {
             == Some("Json")
 }
 
+/// Returns true when the remote field's nullability fits the expected field.
+///
+/// The remote physical optimizer may narrow a nullable column to non-nullable,
+/// as DataFusion's own schema invariant permits: `AggregateStatistics`
+/// replaces an aggregate over an empty region with a non-null literal. Batches
+/// are rebuilt with the expected schema, so the narrowing does not leak.
+/// Widening is rejected. Nested field nullability is part of the data type and
+/// still has to match exactly.
+fn nullability_compatible(expected_field: &Field, actual_field: &Field) -> bool {
+    expected_field.is_nullable() || !actual_field.is_nullable()
+}
+
 /// Returns true when two fields describe the same column semantics: same
-/// name, same data type, and same nullability.
+/// name, same data type, and compatible nullability.
 ///
 /// Arrow `Field` metadata is auxiliary information (indexing, encoding,
 /// compression hints, ...) and does not participate in the comparison. This
@@ -181,7 +191,7 @@ fn is_json_field(field: &Field) -> bool {
 fn fields_semantically_equal(expected_field: &Field, actual_field: &Field) -> bool {
     expected_field.name() == actual_field.name()
         && expected_field.data_type() == actual_field.data_type()
-        && expected_field.is_nullable() == actual_field.is_nullable()
+        && nullability_compatible(expected_field, actual_field)
 }
 
 /// Returns true when two fields are semantically equivalent JSON columns.
@@ -198,7 +208,7 @@ fn json_fields_compatible(expected_field: &Field, actual_field: &Field) -> bool
     is_json_field(expected_field)
         && is_json_field(actual_field)
         && expected_field.name() == actual_field.name()
-        && expected_field.is_nullable() == actual_field.is_nullable()
+        && nullability_compatible(expected_field, actual_field)
         // Both must carry the same JSON marker.
         && expected_field.metadata().get(datatypes::schema::TYPE_KEY)
             == actual_field.metadata().get(datatypes::schema::TYPE_KEY)
@@ -214,14 +224,15 @@ fn json_fields_compatible(expected_field: &Field, actual_field: &Field) -> bool
 /// Validates the remote schema before positional column handling.
 ///
 /// Field metadata (indexing/encoding/compression hints) is non-semantic at
-/// this boundary and is ignored: two fields are equal when their name, data
-/// type, and nullability match (see [`fields_semantically_equal`]). A
-/// timestamp timezone difference is the only intentional exception, accepted
-/// when the fields share the same timestamp unit, distinct timezones, and
-/// equal name and nullability. Top-level Arrow schema metadata is
-/// non-semantic at this boundary as well. JSON columns are compared
-/// semantically (see [`json_fields_compatible`]) because their wire and
-/// decoded representations use different physical arrow types.
+/// this boundary and is ignored: two fields are equal when their name and
+/// data type match and their nullability is compatible (see
+/// [`fields_semantically_equal`]). A timestamp timezone difference is the only
+/// intentional exception, accepted when the fields share the same timestamp
+/// unit, distinct timezones, equal name, and compatible nullability.
+/// Top-level Arrow schema metadata is non-semantic at this boundary as well.
+/// JSON columns are compared semantically (see [`json_fields_compatible`])
+/// because their wire and decoded representations use different physical
+/// arrow types.
 fn validate_remote_schema(
     expected: &ArrowSchema,
     actual: &ArrowSchema,
@@ -262,7 +273,7 @@ fn validate_remote_schema(
             ) if expected_unit == actual_unit
                 && expected_timezone != actual_timezone
                 && expected_field.name() == actual_field.name()
-                && expected_field.is_nullable() == actual_field.is_nullable()
+                && nullability_compatible(expected_field, actual_field)
         );
         if !timezone_only_difference {
             return Err(remote_schema_mismatch(format!(
@@ -339,7 +350,6 @@ pub struct MergeScanLogicalPlan {
     output_schema: DFSchemaRef,
     /// If this plan is a placeholder
     is_placeholder: bool,
-    partition_cols: AliasMapping,
     /// Assigned after dist-plan rewriting so rewriters only deal with plan shape.
     remote_dyn_filter_producer_id: Option<RemoteDynFilterProducerId>,
 }
@@ -350,29 +360,20 @@ impl PartialOrd for MergeScanLogicalPlan {
             input,
             output_schema,
             is_placeholder,
-            partition_cols,
             remote_dyn_filter_producer_id,
         } = self;
         let Self {
             input: other_input,
             output_schema: other_output_schema,
             is_placeholder: other_is_placeholder,
-            partition_cols: other_partition_cols,
             remote_dyn_filter_producer_id: other_remote_dyn_filter_producer_id,
         } = other;
 
-        let ordering = (
-            input,
-            is_placeholder,
-            partition_cols,
-            remote_dyn_filter_producer_id,
-        )
-            .partial_cmp(&(
-                other_input,
-                other_is_placeholder,
-                other_partition_cols,
-                other_remote_dyn_filter_producer_id,
-            ));
+        let ordering = (input, is_placeholder, remote_dyn_filter_producer_id).partial_cmp(&(
+            other_input,
+            other_is_placeholder,
+            other_remote_dyn_filter_producer_id,
+        ));
         match ordering {
             Some(std::cmp::Ordering::Equal) if output_schema != other_output_schema => None,
             ordering => ordering,
@@ -419,12 +420,11 @@ impl UserDefinedLogicalNodeCore for MergeScanLogicalPlan {
 
 impl MergeScanLogicalPlan {
     /// Creates a merge scan with the input plan's schema.
-    pub fn new(input: LogicalPlan, is_placeholder: bool, partition_cols: AliasMapping) -> Self {
+    pub fn new(input: LogicalPlan, is_placeholder: bool) -> Self {
         Self {
             output_schema: input.schema().clone(),
             input,
             is_placeholder,
-            partition_cols,
             remote_dyn_filter_producer_id: None,
         }
     }
@@ -462,10 +462,6 @@ impl MergeScanLogicalPlan {
         &self.input
     }
 
-    pub fn partition_cols(&self) -> &AliasMapping {
-        &self.partition_cols
-    }
-
     pub fn remote_dyn_filter_producer_id(&self) -> Option<RemoteDynFilterProducerId> {
         self.remote_dyn_filter_producer_id
     }
@@ -489,7 +485,6 @@ pub struct MergeScanExec {
     remote_dyn_filter_producer_id: Option<RemoteDynFilterProducerId>,
     captured_remote_dyn_filters: Arc<Mutex<Vec<CapturedDynFilter>>>,
     target_partition: usize,
-    partition_cols: AliasMapping,
     enable_per_region_metrics: bool,
 }
 
@@ -514,7 +509,6 @@ impl MergeScanExec {
         region_query_handler: RegionQueryHandlerRef,
         query_ctx: QueryContextRef,
         target_partition: usize,
-        partition_cols: AliasMapping,
         remote_dyn_filter_producer_id: Option<RemoteDynFilterProducerId>,
         enable_per_region_metrics: bool,
     ) -> Result<Self> {
@@ -551,24 +545,8 @@ impl MergeScanExec {
             EquivalenceProperties::new(arrow_schema.clone())
         };
 
-        let partition_exprs = partition_cols
-            .iter()
-            .filter_map(|col| {
-                if let Some(first_alias) = col.1.first() {
-                    session_state
-                        .create_physical_expr(
-                            Expr::Column(ColumnExpr::new_unqualified(
-                                first_alias.name().to_string(),
-                            )),
-                            plan.schema(),
-                        )
-                        .ok()
-                } else {
-                    None
-                }
-            })
-            .collect();
-        let partitioning = Partitioning::Hash(partition_exprs, output_partition_count);
+        // Region stripes are positional, not hash buckets; do not advertise a hash distribution.
+        let partitioning = Partitioning::UnknownPartitioning(output_partition_count);
 
         let properties = Arc::new(PlanProperties::new(
             eq_properties,
@@ -590,7 +568,6 @@ impl MergeScanExec {
             remote_dyn_filter_producer_id,
             captured_remote_dyn_filters: Arc::default(),
             target_partition,
-            partition_cols,
             enable_per_region_metrics,
         })
     }
@@ -912,78 +889,6 @@ impl MergeScanExec {
         )))
     }
 
-    pub fn try_with_new_distribution(&self, distribution: Distribution) -> Option<Self> {
-        let Distribution::KeyPartitioned(hash_exprs) = distribution else {
-            // not applicable
-            return None;
-        };
-
-        if let Partitioning::Hash(curr_dist, _) = &self.properties.partitioning
-            && curr_dist == &hash_exprs
-        {
-            // No need to change the distribution
-            return None;
-        }
-
-        let hash_expr_col_names: HashSet<_> = hash_exprs
-            .iter()
-            .filter_map(|expr| {
-                expr.downcast_ref::<Column>()
-                    .map(|col_expr| col_expr.name())
-            })
-            .collect();
-
-        let covers_all_partition_cols = self.partition_cols.values().all(|aliases| {
-            aliases
-                .iter()
-                .any(|col| hash_expr_col_names.contains(col.name()))
-        });
-        if !covers_all_partition_cols {
-            return None;
-        }
-
-        let all_partition_col_aliases: HashSet<_> = self
-            .partition_cols
-            .values()
-            .flat_map(|aliases| aliases.iter().map(|c| c.name()))
-            .collect();
-        let overlaps: Vec<_> = hash_exprs
-            .iter()
-            .filter(|expr| {
-                expr.downcast_ref::<Column>()
-                    .is_some_and(|col_expr| all_partition_col_aliases.contains(col_expr.name()))
-            })
-            .cloned()
-            .collect();
-
-        if overlaps.is_empty() {
-            return None;
-        }
-
-        Some(Self {
-            table: self.table.clone(),
-            regions: self.regions.clone(),
-            plan: self.plan.clone(),
-            arrow_schema: self.arrow_schema.clone(),
-            region_query_handler: self.region_query_handler.clone(),
-            metric: self.metric.clone(),
-            properties: Arc::new(PlanProperties::new(
-                self.properties.eq_properties.clone(),
-                Partitioning::Hash(overlaps, self.partition_count()),
-                self.properties.emission_type,
-                self.properties.boundedness,
-            )),
-            sub_stage_metrics: self.sub_stage_metrics.clone(),
-            partition_metrics: self.partition_metrics.clone(),
-            query_ctx: self.query_ctx.clone(),
-            remote_dyn_filter_producer_id: self.remote_dyn_filter_producer_id,
-            captured_remote_dyn_filters: self.captured_remote_dyn_filters.clone(),
-            target_partition: self.target_partition,
-            partition_cols: self.partition_cols.clone(),
-            enable_per_region_metrics: self.enable_per_region_metrics,
-        })
-    }
-
     fn captured_remote_dyn_filters(&self) -> Vec<CapturedDynFilter> {
         self.captured_remote_dyn_filters.lock().unwrap().clone()
     }
@@ -1037,13 +942,6 @@ impl MergeScanExec {
     }
 }
 
-#[cfg(test)]
-impl MergeScanExec {
-    fn remote_dyn_filter_producer_id(&self) -> Option<RemoteDynFilterProducerId> {
-        self.remote_dyn_filter_producer_id
-    }
-}
-
 /// Metrics for a region of a partition.
 #[derive(Debug, Clone)]
 struct RegionMetrics {
@@ -1420,7 +1318,7 @@ impl MergeScanMetric {
 
 #[cfg(test)]
 mod tests {
-    use std::collections::{BTreeSet, HashMap as StdHashMap};
+    use std::collections::HashMap as StdHashMap;
     use std::pin::Pin;
     use std::sync::atomic::{AtomicUsize, Ordering};
     use std::task::{Context, Poll};
@@ -1441,15 +1339,15 @@ mod tests {
     };
     use datafusion::config::ConfigOptions;
     use datafusion::execution::SessionStateBuilder;
+    use datafusion::physical_plan::Partitioning;
     use datafusion::physical_plan::filter_pushdown::ChildFilterPushdownResult;
     use datafusion::physical_plan::repartition::RepartitionExec;
     use datafusion::physical_plan::{StatisticsArgs, StatisticsContext};
-    use datafusion_common::TableReference;
     use datafusion_expr::{LogicalPlanBuilder, col, lit};
+    use datafusion_physical_expr::PhysicalExpr;
     use datafusion_physical_expr::expressions::{
         Column, DynamicFilterPhysicalExpr, lit as physical_lit,
     };
-    use datafusion_physical_expr::{Distribution, PhysicalExpr};
     use datatypes::prelude::{ConcreteDataType, VectorRef};
     use datatypes::schema::{ColumnSchema, Schema};
     use datatypes::vectors::{Int64Vector, StringVector, TimestampMillisecondVector};
@@ -1517,7 +1415,6 @@ mod tests {
             Arc::new(TestRegionQueryHandler::default()),
             QueryContext::arc(),
             target_partition,
-            AliasMapping::new(),
             None,
             false,
         )
@@ -1560,7 +1457,6 @@ mod tests {
             handler,
             query_ctx,
             1,
-            AliasMapping::new(),
             Some(RemoteDynFilterProducerId::new(42)),
             false,
         )
@@ -1661,6 +1557,10 @@ mod tests {
                 exec.properties().output_partitioning().partition_count(),
                 expected
             );
+            assert!(matches!(
+                exec.properties().output_partitioning(),
+                Partitioning::UnknownPartitioning(count) if *count == expected
+            ));
         }
     }
 
@@ -1874,7 +1774,6 @@ mod tests {
             handler.clone(),
             query_ctx,
             1,
-            AliasMapping::new(),
             Some(RemoteDynFilterProducerId::new(42)),
             false,
         )
@@ -2682,7 +2581,6 @@ mod tests {
             handler,
             QueryContext::arc(),
             target_partition,
-            AliasMapping::new(),
             None,
             false,
         )
@@ -2806,6 +2704,30 @@ mod tests {
         assert_eq!(batches[0].schema().as_ref(), &expected_schema);
     }
 
+    #[tokio::test]
+    async fn qbs_merge_scan_remote_schema_identity_emits_expected_schema_on_nullability_narrowing()
+    {
+        let batch = record_batch(
+            int64_schema(&["a", "b"]),
+            vec![
+                Arc::new(Int64Vector::from_slice([11])) as _,
+                Arc::new(Int64Vector::from_slice([12])) as _,
+            ],
+        );
+        let expected_schema = ArrowSchema::new(vec![
+            Field::new("a", TestArrowDataType::Int64, true),
+            Field::new("b", TestArrowDataType::Int64, false),
+        ]);
+        let batches = collect_merge_scan(merge_scan_exec(
+            vec![(RegionId::new(1024, 1), batch)],
+            expected_schema.clone(),
+            1,
+        ))
+        .await
+        .unwrap();
+        assert_eq!(batches[0].schema().as_ref(), &expected_schema);
+    }
+
     #[tokio::test]
     async fn qbs_merge_scan_remote_schema_identity_rejects_incompatible_type() {
         let batch = record_batch(
@@ -3012,7 +2934,7 @@ mod tests {
     }
 
     #[test]
-    fn merge_scan_remote_schema_identity_ignores_field_metadata_but_rejects_nullability_mismatch() {
+    fn merge_scan_remote_schema_identity_ignores_field_metadata_but_rejects_nullability_widening() {
         let expected = expected_int64_schema();
         let metadata_mismatch = ArrowSchema::new_with_metadata(
             vec![
@@ -3041,6 +2963,30 @@ mod tests {
         assert!(validate_remote_schema(&expected, &nullability_mismatch, "test").is_err());
     }
 
+    #[test]
+    fn merge_scan_remote_schema_identity_accepts_top_level_nullability_narrowing_only() {
+        let state_type = |child_nullable| {
+            TestArrowDataType::Struct(arrow_schema::Fields::from(vec![Field::new(
+                "min[value]",
+                TestArrowDataType::Int64,
+                child_nullable,
+            )]))
+        };
+        let schema = |nullable, child_nullable| {
+            ArrowSchema::new(vec![Field::new(
+                "__min_state(t.v)",
+                state_type(child_nullable),
+                nullable,
+            )])
+        };
+
+        // `AggregateStatistics` turns the state aggregate over an empty region
+        // into a non-null struct literal.
+        assert!(validate_remote_schema(&schema(true, true), &schema(false, true), "test").is_ok());
+        assert!(validate_remote_schema(&schema(false, true), &schema(true, true), "test").is_err());
+        assert!(validate_remote_schema(&schema(true, true), &schema(true, false), "test").is_err());
+    }
+
     #[test]
     fn merge_scan_remote_schema_identity_ignores_skipping_index_field_metadata() {
         // Regression: a remote stream may advertise auxiliary field metadata
@@ -3288,73 +3234,6 @@ mod tests {
         assert_int64_batch(&batches[0], (11, 12));
     }
 
-    #[test]
-    fn try_with_new_distribution_preserves_remote_dyn_filter_producer_id() {
-        let remote_dyn_filter_producer_id = RemoteDynFilterProducerId::new(42);
-
-        // Build a plan whose schema contains "col1"
-        let plan = LogicalPlanBuilder::empty(true)
-            .project(vec![lit(1i32).alias("col1")])
-            .unwrap()
-            .build()
-            .unwrap();
-
-        let schema = plan.schema().as_arrow().clone();
-        let table = TableName::new("catalog", "schema", "table");
-        let regions = vec![RegionId::new(1024, 1)];
-        let query_ctx = QueryContext::arc();
-
-        // Non-empty partition_cols so try_with_new_distribution can detect an overlap
-        let mut partition_cols = AliasMapping::new();
-        partition_cols.insert(
-            "col1".to_string(),
-            BTreeSet::from([ColumnExpr::new(Some(TableReference::bare("table")), "col1")]),
-        );
-
-        let session_state = SessionStateBuilder::new().build();
-
-        let handler = Arc::new(TestRegionQueryHandler::default());
-        let target_partition = 2;
-
-        let exec = MergeScanExec::new(
-            &session_state,
-            table,
-            regions,
-            plan,
-            &schema,
-            handler,
-            query_ctx,
-            target_partition,
-            partition_cols,
-            Some(remote_dyn_filter_producer_id),
-            false,
-        )
-        .unwrap();
-
-        assert_eq!(
-            exec.remote_dyn_filter_producer_id(),
-            Some(remote_dyn_filter_producer_id)
-        );
-
-        // A distribution that differs from the current partitioning but shares a
-        // column name present in partition_cols, so try_with_new_distribution
-        // produces a clone instead of returning None.
-        let new_dist = Distribution::KeyPartitioned(vec![
-            Arc::new(Column::new("col1", 0)),
-            Arc::new(Column::new("col2", 1)),
-        ]);
-
-        let cloned = exec
-            .try_with_new_distribution(new_dist)
-            .expect("expected a cloned exec with overlapping partition col");
-
-        assert_eq!(
-            cloned.remote_dyn_filter_producer_id(),
-            Some(remote_dyn_filter_producer_id),
-            "try_with_new_distribution must preserve remote dynamic filter producer id"
-        );
-    }
-
     #[test]
     fn merge_scan_apply_expressions_exposes_remote_dyn_filter_id() {
         let query_ctx = QueryContext::arc();
@@ -3397,7 +3276,6 @@ mod tests {
             handler,
             query_ctx,
             1,
-            AliasMapping::new(),
             Some(remote_dyn_filter_producer_id),
             false,
         )
@@ -3503,7 +3381,6 @@ mod tests {
             Arc::new(TestRegionQueryHandler::default()),
             QueryContext::arc(),
             1,
-            AliasMapping::new(),
             None,
             true,
         )
@@ -3572,7 +3449,6 @@ mod tests {
             Arc::new(TestRegionQueryHandler::default()),
             QueryContext::arc(),
             1,
-            AliasMapping::new(),
             None,
             true,
         )
diff --git a/src/query/src/dist_plan/planner.rs b/src/query/src/dist_plan/planner.rs
index b2a2ade9b4f..34c0994f9e0 100644
--- a/src/query/src/dist_plan/planner.rs
+++ b/src/query/src/dist_plan/planner.rs
@@ -50,6 +50,7 @@ use crate::dist_plan::merge_scan::{MergeScanExec, MergeScanLogicalPlan};
 use crate::dist_plan::merge_sort::{MergeSortExec, MergeSortLogicalPlan};
 use crate::dist_plan::region_pruner::ConstraintPruner;
 use crate::error::{CatalogSnafu, PartitionRuleManagerSnafu, TableNotFoundSnafu};
+use crate::optimizer::expr_depth;
 use crate::region_query::RegionQueryHandlerRef;
 
 /// Planner for converting merge sort logical plan to physical plan.
@@ -228,7 +229,6 @@ impl ExtensionPlanner for DistExtensionPlanner {
             self.region_query_handler.clone(),
             query_ctx,
             session.config().target_partitions(),
-            merge_scan.partition_cols().clone(),
             merge_scan.remote_dyn_filter_producer_id(),
             self.enable_per_region_metrics,
         )?;
@@ -448,6 +448,7 @@ impl DistExtensionPlanner {
         session: &dyn Session,
         plan: &LogicalPlan,
     ) -> Result<LogicalPlan> {
+        expr_depth::validate_plan(plan)?;
         let session_state = session
             .as_any()
             .downcast_ref::<SessionState>()
diff --git a/src/query/src/dummy_catalog.rs b/src/query/src/dummy_catalog.rs
index 5644194f1f9..8f0a2c7ac60 100644
--- a/src/query/src/dummy_catalog.rs
+++ b/src/query/src/dummy_catalog.rs
@@ -31,6 +31,7 @@ use datafusion::physical_plan::ExecutionPlan;
 use datafusion_common::DataFusionError;
 use datafusion_expr::{Expr, TableProviderFilterPushDown, TableType};
 use datatypes::arrow::datatypes::SchemaRef;
+use datatypes::data_type::DataType;
 use datatypes::types::json_type::JsonNativeType;
 use futures::stream::BoxStream;
 use session::context::{QueryContext, QueryContextRef};
@@ -209,7 +210,13 @@ impl TableProvider for DummyTableProvider {
             .iter()
             .map(|e| {
                 // Simple filter on primary key columns are precisely evaluated.
-                if let Some(simple_filter) = SimpleFilterEvaluator::try_new(e) {
+                if let Some(simple_filter) =
+                    SimpleFilterEvaluator::try_new_with_column_type(e, &|name| {
+                        self.metadata
+                            .column_by_name(name)
+                            .map(|column| column.column_schema.data_type.as_arrow_type())
+                    })
+                {
                     if self
                         .metadata
                         .column_by_name(simple_filter.column_name())
@@ -646,6 +653,37 @@ mod tests {
         FLOW_RETURN_REGION_SEQ, FLOW_SINK_TABLE_ID,
     };
 
+    #[test]
+    fn test_nullable_label_filter_pushdown() {
+        use datafusion_expr::{Cast, col, lit};
+        use datatypes::arrow::datatypes::DataType as ArrowDataType;
+
+        let provider = crate::optimizer::test_util::mock_table_provider(RegionId::new(1, 1));
+        let cast_label = Expr::Cast(Cast::new(Box::new(col("k0")), ArrowDataType::Utf8));
+        let cast_field = Expr::Cast(Cast::new(Box::new(col("v0")), ArrowDataType::Utf8));
+        let filters = [
+            col("k0").is_null().or(col("k0").not_eq(lit("lo"))),
+            col("k0").is_null().or(cast_label.not_eq(lit("lo"))),
+            col("k0").is_null().or(col("v0").not_eq(lit(1.0))),
+            cast_field.eq(lit("1")),
+            col("k0").in_list(vec![lit(""), lit("lo")], false),
+            col("k0").in_list(vec![lit(""), lit("lo")], true),
+        ];
+        assert_eq!(
+            provider
+                .supports_filters_pushdown(&filters.iter().collect::<Vec<_>>())
+                .unwrap(),
+            vec![
+                TableProviderFilterPushDown::Exact,
+                TableProviderFilterPushDown::Exact,
+                TableProviderFilterPushDown::Inexact,
+                TableProviderFilterPushDown::Inexact,
+                TableProviderFilterPushDown::Inexact,
+                TableProviderFilterPushDown::Inexact,
+            ]
+        );
+    }
+
     fn test_region_id() -> RegionId {
         RegionId::new(1024, 1)
     }
diff --git a/src/query/src/metrics.rs b/src/query/src/metrics.rs
index d6d62c99c4f..3c0043dcc09 100644
--- a/src/query/src/metrics.rs
+++ b/src/query/src/metrics.rs
@@ -407,7 +407,7 @@ fn finalize_region_watermarks(merged: BTreeMap<u64, MergeState>) -> Vec<RegionWa
 
 #[cfg(test)]
 mod tests {
-    use std::collections::{BTreeMap, BTreeSet};
+    use std::collections::BTreeMap;
     use std::sync::Arc;
 
     use api::v1::region::{RemoteDynFilterUnregister, RemoteDynFilterUpdate};
@@ -493,7 +493,6 @@ mod tests {
                 Arc::new(NoopRegionQueryHandler),
                 query_ctx,
                 1,
-                BTreeMap::<String, BTreeSet<datafusion_common::Column>>::new(),
                 Some(RemoteDynFilterProducerId::new(0)),
                 false,
             )
diff --git a/src/query/src/optimizer.rs b/src/query/src/optimizer.rs
index fec001e7506..1fc0730c4fd 100644
--- a/src/query/src/optimizer.rs
+++ b/src/query/src/optimizer.rs
@@ -17,12 +17,13 @@ pub mod constant_term;
 pub mod count_nest_aggr;
 pub mod count_wildcard;
 pub mod enforce_sorting;
+pub(crate) mod expr_depth;
 pub mod global_limit;
+pub(crate) mod infer_aggregate_input_bounds;
 pub(crate) mod insert_assignment;
 pub(crate) mod json_schema_concretize;
 pub(crate) mod json_type_concretize;
 pub mod parallelize_scan;
-pub mod pass_distribution;
 pub mod promql_tsid_narrow_join;
 pub mod remove_duplicate;
 pub mod scan_hint;
diff --git a/src/query/src/optimizer/const_normalization.rs b/src/query/src/optimizer/const_normalization.rs
index d29f0aa4f39..64d39a5f668 100644
--- a/src/query/src/optimizer/const_normalization.rs
+++ b/src/query/src/optimizer/const_normalization.rs
@@ -23,8 +23,6 @@ use datafusion_expr::{Between, BinaryExpr, Expr, ExprSchemable, LogicalPlan, Ope
 use datafusion_expr_common::casts::try_cast_literal_to_type;
 use datafusion_optimizer::analyzer::AnalyzerRule;
 
-use crate::plan::ExtractExpr;
-
 /// ConstNormalizationRule rewrites castable constants against their
 /// non-constant comparison operand ahead of filter pushdown.
 #[derive(Debug)]
@@ -52,26 +50,12 @@ impl AnalyzerRule for ConstNormalizationRule {
 }
 
 fn rewrite_plan_exprs(plan: LogicalPlan, schema: DFSchemaRef) -> Result<Transformed<LogicalPlan>> {
-    let mut rewriter = ConstNormalizationRewriter {
-        schema,
-        transformed: false,
-    };
-    let exprs = plan
-        .expressions_consider_join()
-        .into_iter()
-        .map(|expr| expr.rewrite(&mut rewriter).map(|rewritten| rewritten.data))
-        .collect::<Result<Vec<_>>>()?;
-    if !rewriter.transformed {
-        return Ok(Transformed::no(plan));
-    }
-
-    let inputs = plan.inputs().into_iter().cloned().collect::<Vec<_>>();
-    plan.with_new_exprs(exprs, inputs).map(Transformed::yes)
+    let mut rewriter = ConstNormalizationRewriter { schema };
+    plan.map_expressions(|expr| expr.rewrite(&mut rewriter))
 }
 
 struct ConstNormalizationRewriter {
     schema: DFSchemaRef,
-    transformed: bool,
 }
 
 impl TreeNodeRewriter for ConstNormalizationRewriter {
@@ -91,44 +75,36 @@ impl TreeNodeRewriter for ConstNormalizationRewriter {
     }
 
     fn f_up(&mut self, expr: Expr) -> Result<Transformed<Expr>> {
-        let rewritten = rewrite_expr_node(expr, &self.schema)?;
-        self.transformed |= rewritten.transformed;
-        Ok(rewritten)
+        rewrite_expr_node(expr, &self.schema)
     }
 }
 
 fn rewrite_expr_node(expr: Expr, schema: &DFSchemaRef) -> Result<Transformed<Expr>> {
-    match expr {
-        Expr::BinaryExpr(binary) => match rewrite_binary_expr(binary.clone(), schema)? {
-            Some(expr) => Ok(Transformed::yes(expr)),
-            None => Ok(Transformed::no(Expr::BinaryExpr(binary))),
-        },
-        Expr::Between(between) => match rewrite_between_expr(between.clone(), schema)? {
-            Some(expr) => Ok(Transformed::yes(expr)),
-            None => Ok(Transformed::no(Expr::Between(between))),
-        },
-        Expr::InList(in_list) => match rewrite_in_list_expr(in_list.clone(), schema)? {
-            Some(expr) => Ok(Transformed::yes(expr)),
-            None => Ok(Transformed::no(Expr::InList(in_list))),
-        },
-        Expr::Like(like) => rewrite_like_expr(like, PatternMatchKind::Like, schema),
-        Expr::SimilarTo(like) => rewrite_like_expr(like, PatternMatchKind::SimilarTo, schema),
-        expr => Ok(Transformed::no(expr)),
-    }
+    // Borrow while checking eligibility: cloning unchanged subtrees here can overflow
+    // the stack even though DataFusion protects the surrounding rewrite traversal.
+    let rewritten = match &expr {
+        Expr::BinaryExpr(binary) => rewrite_binary_expr(binary, schema)?,
+        Expr::Between(between) => rewrite_between_expr(between, schema)?,
+        Expr::InList(in_list) => rewrite_in_list_expr(in_list, schema)?,
+        Expr::Like(like) => rewrite_like_expr(like, PatternMatchKind::Like, schema)?,
+        Expr::SimilarTo(like) => rewrite_like_expr(like, PatternMatchKind::SimilarTo, schema)?,
+        _ => None,
+    };
+    Ok(match rewritten {
+        Some(rewritten) => Transformed::yes(rewritten),
+        None => Transformed::no(expr),
+    })
 }
 
-fn rewrite_between_expr(between: Between, schema: &DFSchemaRef) -> Result<Option<Expr>> {
+fn rewrite_between_expr(between: &Between, schema: &DFSchemaRef) -> Result<Option<Expr>> {
     let Between {
         expr,
         negated,
         low,
         high,
     } = between;
-    let expr = *expr;
-    let low_expr = *low;
-    let high_expr = *high;
     let Some((target, constants)) =
-        extract_rewrite_operands(&expr, &[low_expr.clone(), high_expr.clone()], schema)?
+        extract_rewrite_operands(expr, [low.as_ref(), high.as_ref()], schema)?
     else {
         return Ok(None);
     };
@@ -142,7 +118,7 @@ fn rewrite_between_expr(between: Between, schema: &DFSchemaRef) -> Result<Option
             .expect("between normalization expects low constant");
         return Ok(Some(Expr::Between(Between {
             expr: Box::new(target.expr.clone()),
-            negated,
+            negated: *negated,
             low: Box::new(lit(low)),
             high: Box::new(lit(high)),
         })));
@@ -153,14 +129,13 @@ fn rewrite_between_expr(between: Between, schema: &DFSchemaRef) -> Result<Option
         .flatten())
 }
 
-fn rewrite_in_list_expr(in_list: InList, schema: &DFSchemaRef) -> Result<Option<Expr>> {
+fn rewrite_in_list_expr(in_list: &InList, schema: &DFSchemaRef) -> Result<Option<Expr>> {
     let InList {
         expr,
         list,
         negated,
     } = in_list;
-    let expr = *expr;
-    let Some((target, constants)) = extract_rewrite_operands(&expr, &list, schema)? else {
+    let Some((target, constants)) = extract_rewrite_operands(expr, list, schema)? else {
         return Ok(None);
     };
 
@@ -168,19 +143,15 @@ fn rewrite_in_list_expr(in_list: InList, schema: &DFSchemaRef) -> Result<Option<
         target
             .expr
             .clone()
-            .in_list(constants.into_iter().map(lit).collect(), negated)
+            .in_list(constants.into_iter().map(lit).collect(), *negated)
     }))
 }
 
 fn rewrite_like_expr(
-    like: Like,
+    like: &Like,
     kind: PatternMatchKind,
     schema: &DFSchemaRef,
-) -> Result<Transformed<Expr>> {
-    let original = match kind {
-        PatternMatchKind::Like => Expr::Like(like.clone()),
-        PatternMatchKind::SimilarTo => Expr::SimilarTo(like.clone()),
-    };
+) -> Result<Option<Expr>> {
     let Like {
         negated,
         expr,
@@ -188,36 +159,33 @@ fn rewrite_like_expr(
         escape_char,
         case_insensitive,
     } = like;
-    let expr = *expr;
-    let pattern = *pattern;
-    let Some((target, constants)) =
-        extract_rewrite_operands(&expr, std::slice::from_ref(&pattern), schema)?
+    let Some((target, constants)) = extract_rewrite_operands(expr, [pattern.as_ref()], schema)?
     else {
-        return Ok(Transformed::no(original));
+        return Ok(None);
     };
     let Some(mut constants) = target.normalize_constants(&constants) else {
-        return Ok(Transformed::no(original));
+        return Ok(None);
     };
 
     let pattern = lit(constants
         .pop()
         .expect("pattern normalization expects one constant"));
     let like = Like::new(
-        negated,
+        *negated,
         Box::new(target.expr.clone()),
         Box::new(pattern),
-        escape_char,
-        case_insensitive,
+        *escape_char,
+        *case_insensitive,
     );
     let rewritten = match kind {
         PatternMatchKind::Like => Expr::Like(like),
         PatternMatchKind::SimilarTo => Expr::SimilarTo(like),
     };
-    Ok(Transformed::yes(rewritten))
+    Ok(Some(rewritten))
 }
 
-fn rewrite_binary_expr(binary: BinaryExpr, schema: &DFSchemaRef) -> Result<Option<Expr>> {
-    if let Some(expr) = rewrite_dictionary_string_regex(binary.clone(), schema)? {
+fn rewrite_binary_expr(binary: &BinaryExpr, schema: &DFSchemaRef) -> Result<Option<Expr>> {
+    if let Some(expr) = rewrite_dictionary_string_regex(binary, schema)? {
         return Ok(Some(expr));
     }
 
@@ -226,9 +194,7 @@ fn rewrite_binary_expr(binary: BinaryExpr, schema: &DFSchemaRef) -> Result<Optio
     }
 
     let BinaryExpr { left, op, right } = binary;
-    let left = *left;
-    let right = *right;
-    if let Some(expr) = rewrite_binary_side(left.clone(), op, right.clone(), schema)? {
+    if let Some(expr) = rewrite_binary_side(left, *op, right, schema)? {
         return Ok(Some(expr));
     }
 
@@ -244,12 +210,12 @@ fn rewrite_binary_expr(binary: BinaryExpr, schema: &DFSchemaRef) -> Result<Optio
 /// Keeping the dictionary input lets DataFusion's physical regex kernel evaluate scalar patterns
 /// against dictionary values instead of materializing the string column first.
 fn rewrite_dictionary_string_regex(
-    binary: BinaryExpr,
+    binary: &BinaryExpr,
     schema: &DFSchemaRef,
 ) -> Result<Option<Expr>> {
     let BinaryExpr { left, op, right } = binary;
     if !matches!(
-        &op,
+        op,
         Operator::RegexMatch
             | Operator::RegexIMatch
             | Operator::RegexNotMatch
@@ -259,7 +225,7 @@ fn rewrite_dictionary_string_regex(
         return Ok(None);
     }
 
-    let Some((CastInputKind::Cast, source, DataType::Utf8)) = extract_cast_input(&left) else {
+    let Some((CastInputKind::Cast, source, DataType::Utf8)) = extract_cast_input(left) else {
         return Ok(None);
     };
     if !matches!(source, Expr::Column(_))
@@ -274,19 +240,18 @@ fn rewrite_dictionary_string_regex(
 
     Ok(Some(Expr::BinaryExpr(BinaryExpr {
         left: Box::new(source.clone()),
-        op,
-        right,
+        op: *op,
+        right: right.clone(),
     })))
 }
 
 fn rewrite_binary_side(
-    target_expr: Expr,
+    target_expr: &Expr,
     op: Operator,
-    constant_expr: Expr,
+    constant_expr: &Expr,
     schema: &DFSchemaRef,
 ) -> Result<Option<Expr>> {
-    let Some((target, constants)) =
-        extract_rewrite_operands(&target_expr, std::slice::from_ref(&constant_expr), schema)?
+    let Some((target, constants)) = extract_rewrite_operands(target_expr, [constant_expr], schema)?
     else {
         return Ok(None);
     };
@@ -305,11 +270,11 @@ fn rewrite_binary_side(
     Ok(target.normalize_timestamp_binary(op, &constants[0]))
 }
 
-fn extract_rewrite_operands(
-    target_expr: &Expr,
-    constant_exprs: &[Expr],
+fn extract_rewrite_operands<'a, 'b>(
+    target_expr: &'a Expr,
+    constant_exprs: impl IntoIterator<Item = &'b Expr>,
     schema: &DFSchemaRef,
-) -> Result<Option<(NormalizationTarget, Vec<ScalarValue>)>> {
+) -> Result<Option<(NormalizationTarget<'a>, Vec<ScalarValue>)>> {
     let Some(target) = extract_normalization_target(target_expr, schema)? else {
         return Ok(None);
     };
@@ -319,8 +284,8 @@ fn extract_rewrite_operands(
 }
 
 #[derive(Clone)]
-struct NormalizationTarget {
-    expr: Expr,
+struct NormalizationTarget<'a> {
+    expr: &'a Expr,
     data_type: DataType,
     kind: NormalizationKind,
 }
@@ -337,7 +302,7 @@ enum NormalizationKind {
     },
 }
 
-impl NormalizationTarget {
+impl NormalizationTarget<'_> {
     /// Normalizes constants for rewrites that can preserve the original predicate with a direct
     /// literal cast. Timestamp precision-changing casts are handled by timestamp-specific helpers.
     fn normalize_constants(&self, constants: &[ScalarValue]) -> Option<Vec<ScalarValue>> {
@@ -438,17 +403,17 @@ impl NormalizationTarget {
 ///
 /// Plain expressions normalize literals to their own type. Cast expressions only participate when
 /// the cast is lossless or when timestamp downcasts can be rewritten as wider source-side bounds.
-fn extract_normalization_target(
-    expr: &Expr,
+fn extract_normalization_target<'a>(
+    expr: &'a Expr,
     schema: &DFSchemaRef,
-) -> Result<Option<NormalizationTarget>> {
+) -> Result<Option<NormalizationTarget<'a>>> {
     if extract_constant_scalar(expr)?.is_some() {
         return Ok(None);
     }
 
     let Some((_, source_expr, target_type)) = extract_cast_input(expr) else {
         return Ok(Some(NormalizationTarget {
-            expr: expr.clone(),
+            expr,
             data_type: expr.get_type(schema)?,
             kind: NormalizationKind::Lossless,
         }));
@@ -460,7 +425,7 @@ fn extract_normalization_target(
     };
 
     Ok(Some(NormalizationTarget {
-        expr: source_expr.clone(),
+        expr: source_expr,
         data_type,
         kind,
     }))
@@ -520,8 +485,11 @@ enum PatternMatchKind {
     SimilarTo,
 }
 
-fn extract_constant_scalars(exprs: &[Expr]) -> Result<Option<Vec<ScalarValue>>> {
-    let mut values = Vec::with_capacity(exprs.len());
+fn extract_constant_scalars<'a>(
+    exprs: impl IntoIterator<Item = &'a Expr>,
+) -> Result<Option<Vec<ScalarValue>>> {
+    let exprs = exprs.into_iter();
+    let mut values = Vec::with_capacity(exprs.size_hint().0);
     for expr in exprs {
         let Some(value) = extract_constant_scalar(expr)? else {
             return Ok(None);
@@ -672,6 +640,41 @@ mod tests {
         rewrite_dictionary_string_regex, try_cast_literal_to_type,
     };
 
+    #[test]
+    fn test_normalize_deep_predicate() {
+        std::thread::Builder::new()
+            .stack_size(2 * 1024 * 1024)
+            .spawn(|| {
+                let mut predicate = col("t.v").eq(lit(0_i64));
+                for value in 1..1024_i64 {
+                    predicate = predicate.or(col("t.v").eq(lit(value)));
+                }
+                let schema = test_schema(vec![Field::new("v", DataType::Int32, false)]);
+                // Construct the filter directly to isolate this rule from other planner passes.
+                let plan = analyze_plan(LogicalPlan::Filter(
+                    datafusion_expr::Filter::try_new(predicate, Arc::new(build_scan_plan(schema)))
+                        .unwrap(),
+                ));
+                let LogicalPlan::Filter(filter) = plan else {
+                    panic!("expected filter");
+                };
+                // Inspect and consume the chain without recursive formatting or equality.
+                let mut predicate = filter.predicate;
+                for value in (1..1024_i32).rev() {
+                    let Expr::BinaryExpr(BinaryExpr { left, op, right }) = predicate else {
+                        panic!("expected binary predicate");
+                    };
+                    assert_eq!(op, Operator::Or);
+                    assert_eq!(*right, col("t.v").eq(lit(value)));
+                    predicate = *left;
+                }
+                assert_eq!(predicate, col("t.v").eq(lit(0_i32)));
+            })
+            .unwrap()
+            .join()
+            .unwrap();
+    }
+
     #[test]
     fn test_normalize_direct_integer_cast_comparison() {
         assert_filter_plan(
@@ -1411,7 +1414,7 @@ mod tests {
         op: Operator,
     ) -> Option<Expr> {
         rewrite_dictionary_string_regex(
-            BinaryExpr {
+            &BinaryExpr {
                 left: Box::new(left),
                 op,
                 right: Box::new(right),
diff --git a/src/query/src/optimizer/constant_term.rs b/src/query/src/optimizer/constant_term.rs
index 70ddcc2f647..915691604f9 100644
--- a/src/query/src/optimizer/constant_term.rs
+++ b/src/query/src/optimizer/constant_term.rs
@@ -18,6 +18,7 @@ use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
 use arrow::array::BooleanArray;
+use common_base::term_token::extract_term_probes;
 use common_function::scalars::matches_term::MatchesTermFinder;
 use datafusion::config::ConfigOptions;
 use datafusion::error::Result as DfResult;
@@ -179,12 +180,8 @@ impl PhysicalOptimizerRule for MatchesConstantTermOptimizer {
                             {
                                 let finder = MatchesTermFinder::new(term);
 
-                                // For debugging purpose. Not really precise but enough for most cases.
-                                let probes = term
-                                    .split(|c: char| !c.is_alphanumeric() && c != '_')
-                                    .filter(|s| !s.is_empty())
-                                    .map(|s| s.to_string())
-                                    .collect();
+                                // Shown in plans to explain fulltext bloom pruning.
+                                let probes = extract_term_probes(term);
 
                                 let expr = PreCompiledMatchesTermExpr {
                                     text: args[0].clone(),
@@ -201,10 +198,14 @@ impl PhysicalOptimizerRule for MatchesConstantTermOptimizer {
                     })?;
 
                     if new_pred.transformed {
-                        let exec = FilterExecBuilder::new(new_pred.data, filter.input().clone())
-                            .with_default_selectivity(filter.default_selectivity())
-                            .apply_projection_by_ref(filter.projection().as_ref())
-                            .and_then(|x| x.build())?;
+                        // `FilterExecBuilder::from(&FilterExec)` already carries over the
+                        // input, projection, default selectivity, batch size and fetch, so
+                        // only the predicate has to be replaced. Re-applying the projection
+                        // is not only pointless but wrong: `apply_projection` composes with
+                        // the projection copied from the builder.
+                        let exec = FilterExecBuilder::from(filter)
+                            .with_predicate(new_pred.data)
+                            .build()?;
                         return Ok(Transformed::yes(Arc::new(exec) as _));
                     }
                 }
@@ -491,7 +492,7 @@ mod tests {
         let plan_str = get_plan_string(&physical_plan).join("\n");
         assert!(plan_str.contains("MatchesConstTerm(text@0, term: \"foo\", probes: [\"foo\"]"));
         assert!(plan_str.contains(
-            "MatchesConstTerm(text@0, term: \"hello wo_rld\", probes: [\"hello\", \"wo_rld\"]"
+            "MatchesConstTerm(text@0, term: \"hello wo_rld\", probes: [\"hello\", \"wo\", \"rld\"]"
         ));
         assert!(plan_str.contains("MatchesConstTerm(text@0, term: \"world\", probes: [\"world\"]"));
         assert!(
diff --git a/src/query/src/optimizer/count_nest_aggr.rs b/src/query/src/optimizer/count_nest_aggr.rs
index 89ba4260742..6e3e9cdba05 100644
--- a/src/query/src/optimizer/count_nest_aggr.rs
+++ b/src/query/src/optimizer/count_nest_aggr.rs
@@ -15,6 +15,8 @@
 use std::collections::HashSet;
 use std::sync::Arc;
 
+use common_function::aggrs::aggr_wrapper::get_aggr_func;
+use common_function::aggrs::extremum::Extremum;
 use datafusion::config::ConfigOptions;
 use datafusion::functions_aggregate::count::count_udaf;
 use datafusion::logical_expr::{Extension, LogicalPlan, LogicalPlanBuilder, Sort};
@@ -236,9 +238,8 @@ impl CountNestAggrRule {
     where
         F: FnOnce(&str) -> bool,
     {
-        let Expr::AggregateFunction(func) = expr else {
-            return None;
-        };
+        // The PromQL planner aliases `prom_min`/`prom_max` to the builtin names.
+        let func = get_aggr_func(expr)?;
         let name = func.func.name();
         if !accept_name(name)
             || func.params.filter.is_some()
@@ -253,9 +254,19 @@ impl CountNestAggrRule {
     }
 
     fn is_supported_inner_aggregate(name: &str) -> bool {
+        // PromQL `min`/`max` plan to `prom_min`/`prom_max`, which return NULL for the same
+        // groups as the builtin ones.
         matches!(
             name,
-            "count" | "sum" | "avg" | "min" | "max" | "stddev_pop" | "var_pop"
+            "count"
+                | "sum"
+                | "avg"
+                | "min"
+                | "max"
+                | Extremum::MIN_NAME
+                | Extremum::MAX_NAME
+                | "stddev_pop"
+                | "var_pop"
         )
     }
 
diff --git a/src/query/src/optimizer/expr_depth.rs b/src/query/src/optimizer/expr_depth.rs
new file mode 100644
index 00000000000..fedf06b5c73
--- /dev/null
+++ b/src/query/src/optimizer/expr_depth.rs
@@ -0,0 +1,223 @@
+// 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_common::config::ConfigOptions;
+use datafusion_common::tree_node::{TreeNode, TreeNodeRecursion};
+use datafusion_common::{Result, plan_err};
+use datafusion_expr::{Expr, LogicalPlan, Partitioning};
+use datafusion_optimizer::analyzer::AnalyzerRule;
+use promql::extension_plan::EmptyMetric;
+
+use crate::dist_plan::{MergeScanLogicalPlan, MergeSortLogicalPlan};
+use crate::range_select::plan::RangeSelect;
+
+// A conservative optimizer input limit, not a guarantee for every recursive operation
+// performed while parsing, planning, or dropping an arbitrarily deep query.
+const MAX_EXPR_DEPTH: usize = 128;
+
+/// Checks the analyzer output, including the SessionState EXPLAIN path.
+#[derive(Debug)]
+pub(crate) struct ExprDepthRule;
+
+impl AnalyzerRule for ExprDepthRule {
+    fn name(&self) -> &str {
+        "expr_depth"
+    }
+
+    fn analyze(&self, plan: LogicalPlan, _: &ConfigOptions) -> Result<LogicalPlan> {
+        validate_plan(&plan)?;
+        Ok(plan)
+    }
+}
+
+/// Rejects deep expressions before recursive optimizer traversal, cloning, or display.
+/// Both plan and expression traversal are iterative. Subquery Arcs are retained so
+/// expressions supplied temporarily by extension nodes can also be inspected safely.
+pub(crate) fn validate_plan(plan: &LogicalPlan) -> Result<()> {
+    let mut subqueries = Vec::new();
+    validate_plan_exprs(plan, &mut subqueries)?;
+    while let Some(plan) = subqueries.pop() {
+        validate_plan_exprs(&plan, &mut subqueries)?;
+    }
+    Ok(())
+}
+
+fn validate_plan_exprs(plan: &LogicalPlan, subqueries: &mut Vec<Arc<LogicalPlan>>) -> Result<()> {
+    let mut plans = vec![plan];
+    while let Some(plan) = plans.pop() {
+        let mut check = |expr: &Expr| {
+            validate_expr(expr, subqueries)?;
+            Ok(TreeNodeRecursion::Continue)
+        };
+        match plan {
+            // apply_expressions clones range ordering expressions and extension
+            // expressions. Borrow the built-in nodes that can contain deep trees.
+            LogicalPlan::Repartition(repartition)
+                if let Partitioning::Range(range) = &repartition.partitioning_scheme =>
+            {
+                for sort in range.ordering() {
+                    check(&sort.expr)?;
+                }
+            }
+            LogicalPlan::Extension(extension) => {
+                let node = extension.node.as_any();
+                if let Some(range) = node.downcast_ref::<RangeSelect>() {
+                    for expr in &range.range_expr {
+                        check(&expr.expr)?;
+                    }
+                    check(&range.time_expr)?;
+                    for expr in &range.by {
+                        check(expr)?;
+                    }
+                } else if let Some(sort) = node.downcast_ref::<MergeSortLogicalPlan>() {
+                    for expr in &sort.expr {
+                        check(&expr.expr)?;
+                    }
+                } else if let Some(metric) = node.downcast_ref::<EmptyMetric>() {
+                    if let Some(expr) = metric.expr() {
+                        check(expr)?;
+                    }
+                } else if let Some(scan) = node.downcast_ref::<MergeScanLogicalPlan>() {
+                    // MergeScan deliberately hides this input from optimizer visitors.
+                    plans.push(scan.input());
+                } else {
+                    // The remaining built-in nodes only expose column expressions.
+                    // External extensions own the safety of their expressions() implementation.
+                    plan.apply_expressions(check)?;
+                }
+            }
+            LogicalPlan::Subquery(subquery) => {
+                for expr in &subquery.outer_ref_columns {
+                    check(expr)?;
+                }
+            }
+            _ => {
+                plan.apply_expressions(check)?;
+            }
+        }
+        plans.extend(plan.inputs());
+    }
+    Ok(())
+}
+
+fn validate_expr(expr: &Expr, subqueries: &mut Vec<Arc<LogicalPlan>>) -> Result<()> {
+    let mut expressions = vec![(expr, 1)];
+    while let Some((expr, depth)) = expressions.pop() {
+        if depth > MAX_EXPR_DEPTH {
+            return plan_err!(
+                "Expression depth exceeds the maximum supported depth of {MAX_EXPR_DEPTH}"
+            );
+        }
+        let subquery = match expr {
+            Expr::Exists(exists) => Some(&exists.subquery),
+            Expr::ScalarSubquery(subquery) => Some(subquery),
+            Expr::InSubquery(in_subquery) => Some(&in_subquery.subquery),
+            Expr::SetComparison(comparison) => Some(&comparison.subquery),
+            _ => None,
+        };
+        if let Some(subquery) = subquery {
+            subqueries.push(Arc::clone(&subquery.subquery));
+            expressions.extend(subquery.outer_ref_columns.iter().map(|expr| (expr, 1)));
+        }
+        expr.apply_children(|child| {
+            expressions.push((child, depth + 1));
+            Ok(TreeNodeRecursion::Continue)
+        })?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow_schema::{DataType, Field, Schema};
+    use datafusion_common::DFSchema;
+    use datafusion_expr::expr::{Exists, InSubquery, SetComparison, SetQuantifier};
+    use datafusion_expr::{EmptyRelation, Filter, Operator, Subquery, lit};
+
+    use super::*;
+
+    fn filter(predicate: Expr) -> LogicalPlan {
+        LogicalPlan::Filter(
+            Filter::try_new(
+                predicate,
+                Arc::new(LogicalPlan::EmptyRelation(EmptyRelation {
+                    produce_one_row: true,
+                    schema: Arc::new(
+                        DFSchema::try_from(Schema::new(vec![Field::new(
+                            "value",
+                            DataType::Boolean,
+                            false,
+                        )]))
+                        .unwrap(),
+                    ),
+                })),
+            )
+            .unwrap(),
+        )
+    }
+
+    #[test]
+    fn test_depth_in_subqueries_and_hidden_input() {
+        std::thread::Builder::new()
+            .stack_size(2 * 1024 * 1024)
+            .spawn(|| {
+                for depth in [MAX_EXPR_DEPTH, MAX_EXPR_DEPTH + 1, 512] {
+                    let mut predicate = lit(true);
+                    for _ in 1..depth {
+                        predicate = predicate.or(lit(false));
+                    }
+                    // MergeScan hides its input, and apply_children on an Expr
+                    // does not visit the plan embedded in its subquery.
+                    let plan = MergeScanLogicalPlan::new(filter(predicate), false)
+                        .into_logical_plan();
+                    let subquery = Subquery {
+                        subquery: Arc::new(plan),
+                        outer_ref_columns: vec![],
+                        spans: Default::default(),
+                    };
+                    for expr in [
+                        Expr::Exists(Exists::new(subquery.clone(), false)),
+                        Expr::ScalarSubquery(subquery.clone()),
+                        Expr::InSubquery(InSubquery::new(
+                            Box::new(lit(true)),
+                            subquery.clone(),
+                            false,
+                        )),
+                        Expr::SetComparison(SetComparison::new(
+                            Box::new(lit(true)),
+                            subquery.clone(),
+                            Operator::Eq,
+                            SetQuantifier::Any,
+                        )),
+                    ] {
+                        let result = validate_plan(&filter(expr));
+                        if depth <= MAX_EXPR_DEPTH {
+                            result.unwrap();
+                        } else {
+                            assert!(matches!(
+                                result,
+                                Err(datafusion_common::DataFusionError::Plan(message))
+                                    if message == "Expression depth exceeds the maximum supported depth of 128"
+                            ));
+                        }
+                    }
+                }
+            })
+            .unwrap()
+            .join()
+            .unwrap();
+    }
+}
diff --git a/src/query/src/optimizer/infer_aggregate_input_bounds.rs b/src/query/src/optimizer/infer_aggregate_input_bounds.rs
new file mode 100644
index 00000000000..87d8dc3df69
--- /dev/null
+++ b/src/query/src/optimizer/infer_aggregate_input_bounds.rs
@@ -0,0 +1,683 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::Arc;
+
+use arrow_schema::DataType;
+use datafusion::functions_aggregate::min_max::{max_udaf, min_udaf};
+use datafusion::functions_aggregate::sum::sum_udaf;
+use datafusion_common::tree_node::{Transformed, TreeNode};
+use datafusion_common::{Column, DFSchema, Result, ScalarValue};
+use datafusion_expr::expr::AggregateFunction;
+use datafusion_expr::utils::split_conjunction;
+use datafusion_expr::{Aggregate, Expr, ExprSchemable, Filter, LogicalPlan, Operator};
+use datafusion_optimizer::optimizer::ApplyOrder;
+use datafusion_optimizer::{OptimizerConfig, OptimizerRule};
+
+use crate::dist_plan::MergeScanLogicalPlan;
+
+/// Derives an input bound from an existential HAVING condition and MIN/MAX.
+///
+/// For example, `MIN(x), SUM(CASE WHEN p AND x < u THEN 1 ELSE 0 END)` with
+/// HAVING `SUM(...) > 0` can discard rows outside `x < u`: they contribute zero
+/// to SUM, and every surviving group has a witness below u, preserving its MIN.
+/// MAX permits the symmetric lower bound. The original HAVING must remain.
+///
+/// This deliberately requires exactly these two aggregates and ordinary column
+/// grouping. Extra aggregates, grouping sets, floating-point extrema and arbitrary
+/// expressions need separate preservation proofs. It must run before MergeScan
+/// hides remote inputs, as well as in the non-distributed logical optimizer.
+#[derive(Debug)]
+pub(crate) struct InferAggregateInputBoundsRule;
+
+impl OptimizerRule for InferAggregateInputBoundsRule {
+    fn name(&self) -> &str {
+        "infer_aggregate_input_bounds"
+    }
+
+    fn apply_order(&self) -> Option<ApplyOrder> {
+        Some(ApplyOrder::TopDown)
+    }
+
+    fn rewrite(
+        &self,
+        plan: LogicalPlan,
+        _config: &dyn OptimizerConfig,
+    ) -> Result<Transformed<LogicalPlan>> {
+        let LogicalPlan::Filter(mut having) = plan else {
+            return Ok(Transformed::no(plan));
+        };
+        let LogicalPlan::Aggregate(aggregate) = having.input.as_ref() else {
+            return Ok(Transformed::no(LogicalPlan::Filter(having)));
+        };
+        // The pre-MergeScan pass already handled remote inputs. Their filters
+        // are hidden from this pass, so re-inference can add useless local work.
+        if aggregate.input.exists(|plan| {
+            Ok(matches!(plan, LogicalPlan::Extension(extension)
+                if extension.node.as_any().is::<MergeScanLogicalPlan>()))
+        })? {
+            return Ok(Transformed::no(LogicalPlan::Filter(having)));
+        }
+        let Some(bound) = infer_bound(aggregate, &having.predicate)? else {
+            return Ok(Transformed::no(LogicalPlan::Filter(having)));
+        };
+        if already_filtered(&aggregate.input, &bound) {
+            return Ok(Transformed::no(LogicalPlan::Filter(having)));
+        }
+
+        let mut aggregate = aggregate.clone();
+        aggregate.input = Arc::new(LogicalPlan::Filter(Filter::try_new(
+            bound,
+            aggregate.input,
+        )?));
+        having.input = Arc::new(LogicalPlan::Aggregate(aggregate));
+        Ok(Transformed::yes(LogicalPlan::Filter(having)))
+    }
+}
+
+fn infer_bound(aggregate: &Aggregate, having: &Expr) -> Result<Option<Expr>> {
+    if aggregate.aggr_expr.len() != 2
+        || aggregate.group_expr.is_empty()
+        || !aggregate
+            .group_expr
+            .iter()
+            .all(|e| matches!(e, Expr::Column(_)))
+        || !safe_predicate(having, aggregate.schema.as_ref())?
+    {
+        return Ok(None);
+    }
+
+    for conjunct in split_conjunction(having) {
+        let Some(sum_index) = positive_sum_index(conjunct, aggregate) else {
+            continue;
+        };
+        let Some(sum) = plain_aggregate(&aggregate.aggr_expr[sum_index]) else {
+            continue;
+        };
+        let Some(extremum) = plain_aggregate(&aggregate.aggr_expr[1 - sum_index]) else {
+            continue;
+        };
+        if let Some(bound) = bound_from_aggregates(sum, extremum, &aggregate.input)? {
+            return Ok(Some(bound));
+        }
+    }
+    Ok(None)
+}
+
+fn positive_sum_index(predicate: &Expr, aggregate: &Aggregate) -> Option<usize> {
+    let Expr::BinaryExpr(comparison) = predicate else {
+        return None;
+    };
+    let (output, threshold, operator) = match (comparison.left.as_ref(), comparison.right.as_ref())
+    {
+        (Expr::Column(column), literal) => (column, literal, comparison.op),
+        (literal, Expr::Column(column)) => (column, literal, comparison.op.swap()?),
+        _ => return None,
+    };
+    if !((operator == Operator::Gt && integer_literal(threshold) == Some(0))
+        || (operator == Operator::GtEq && integer_literal(threshold) == Some(1)))
+    {
+        return None;
+    }
+    let index = aggregate.schema.index_of_column(output).ok()?;
+    index
+        .checked_sub(aggregate.group_expr.len())
+        .filter(|&i| i < 2)
+}
+
+fn plain_aggregate(expr: &Expr) -> Option<&AggregateFunction> {
+    let expr = match expr {
+        Expr::Alias(alias) => alias.expr.as_ref(),
+        _ => expr,
+    };
+    let Expr::AggregateFunction(function) = expr else {
+        return None;
+    };
+    let params = &function.params;
+    (params.args.len() == 1
+        && !params.distinct
+        && params.filter.is_none()
+        && params.order_by.is_empty()
+        && params.null_treatment.is_none())
+    .then_some(function)
+}
+
+fn bound_from_aggregates(
+    sum: &AggregateFunction,
+    extremum: &AggregateFunction,
+    input: &LogicalPlan,
+) -> Result<Option<Expr>> {
+    let schema = input.schema();
+    // Compare function identities, not names: a user-defined "sum" need not
+    // have the built-in aggregate's zero-contribution semantics.
+    if sum.func != sum_udaf() || (extremum.func != min_udaf() && extremum.func != max_udaf()) {
+        return Ok(None);
+    }
+    let argument = &extremum.params.args[0];
+    let argument_type = argument.get_type(schema)?;
+    if !(argument_type.is_integer() || matches!(argument_type, DataType::Timestamp(..)))
+        || !safe_operand(argument, schema)?
+    {
+        return Ok(None);
+    }
+    let Some(condition) = indicator_condition(&sum.params.args[0]) else {
+        return Ok(None);
+    };
+    if !safe_predicate(condition, schema)?
+        || !columns_are_from_scan(argument, input)?
+        || !columns_are_from_scan(condition, input)?
+    {
+        return Ok(None);
+    }
+    Ok(split_conjunction(condition)
+        .into_iter()
+        .find_map(|predicate| extremum_bound(predicate, argument, extremum, &argument_type)))
+}
+
+fn indicator_condition(expr: &Expr) -> Option<&Expr> {
+    let Expr::Case(case) = expr else {
+        return None;
+    };
+    let [(condition, contribution)] = case.when_then_expr.as_slice() else {
+        return None;
+    };
+    (case.expr.is_none()
+        && integer_literal(contribution) == Some(1)
+        && case.else_expr.as_deref().and_then(integer_literal) == Some(0))
+    .then_some(condition)
+}
+
+fn extremum_bound(
+    predicate: &Expr,
+    argument: &Expr,
+    extremum: &AggregateFunction,
+    argument_type: &DataType,
+) -> Option<Expr> {
+    let Expr::BinaryExpr(comparison) = predicate else {
+        return None;
+    };
+    let (literal, operator) = if comparison.left.as_ref() == argument {
+        (comparison.right.as_ref(), comparison.op)
+    } else if comparison.right.as_ref() == argument {
+        (comparison.left.as_ref(), comparison.op.swap()?)
+    } else {
+        return None;
+    };
+    let Expr::Literal(bound, _) = literal else {
+        return None;
+    };
+    if bound.is_null() || &bound.data_type() != argument_type {
+        return None;
+    }
+    let preserves_extremum = if extremum.func == min_udaf() {
+        matches!(operator, Operator::Lt | Operator::LtEq)
+    } else {
+        matches!(operator, Operator::Gt | Operator::GtEq)
+    };
+    preserves_extremum.then(|| predicate.clone())
+}
+
+fn integer_literal(expr: &Expr) -> Option<i64> {
+    match expr {
+        Expr::Literal(ScalarValue::Int64(integer), _) => *integer,
+        Expr::Literal(ScalarValue::Int32(integer), _) => integer.map(i64::from),
+        _ => None,
+    }
+}
+
+/// Rejects explicitly volatile, fallible or subquery expressions. Column
+/// references additionally require input-plan provenance checks.
+fn safe_predicate(expr: &Expr, schema: &DFSchema) -> Result<bool> {
+    match expr {
+        Expr::BinaryExpr(binary) => Ok(matches!(
+            binary.op,
+            Operator::And
+                | Operator::Or
+                | Operator::Eq
+                | Operator::NotEq
+                | Operator::Lt
+                | Operator::LtEq
+                | Operator::Gt
+                | Operator::GtEq
+        ) && safe_predicate(&binary.left, schema)?
+            && safe_predicate(&binary.right, schema)?),
+        Expr::IsNull(expr) | Expr::IsNotNull(expr) => safe_operand(expr, schema),
+        _ => safe_operand(expr, schema),
+    }
+}
+
+fn safe_operand(expr: &Expr, schema: &DFSchema) -> Result<bool> {
+    match expr {
+        Expr::Column(_) | Expr::Literal(..) => Ok(true),
+        // Timestamp-to-Int64 preserves its native unit and cannot fail. Keep
+        // the cast intact rather than assuming timestamps are nanoseconds.
+        Expr::Cast(cast) => Ok(cast.field.data_type() == &DataType::Int64
+            && matches!(cast.expr.as_ref(), Expr::Column(_))
+            && matches!(cast.expr.get_type(schema)?, DataType::Timestamp(..))),
+        _ => Ok(false),
+    }
+}
+
+/// A projected column can hide division, a fallible cast or a volatile UDF.
+/// PushDownFilter may inline it below the WHERE that made evaluation safe.
+fn columns_are_from_scan(expr: &Expr, input: &LogicalPlan) -> Result<bool> {
+    for column in expr.column_refs() {
+        if !column_is_from_scan(column, input)? {
+            return Ok(false);
+        }
+    }
+    Ok(true)
+}
+
+fn column_is_from_scan(column: &Column, input: &LogicalPlan) -> Result<bool> {
+    let index = input.schema().index_of_column(column)?;
+    match input {
+        LogicalPlan::TableScan(_) => Ok(true),
+        LogicalPlan::Filter(filter) => column_is_from_scan(column, &filter.input),
+        LogicalPlan::SubqueryAlias(alias) => column_at_is_from_scan(index, &alias.input),
+        LogicalPlan::Projection(projection) => {
+            let expr = match &projection.expr[index] {
+                Expr::Alias(alias) => alias.expr.as_ref(),
+                expr => expr,
+            };
+            Ok(safe_operand(expr, projection.input.schema())?
+                && columns_are_from_scan(expr, &projection.input)?)
+        }
+        LogicalPlan::Join(join) => {
+            match (
+                join.left.schema().has_column(column),
+                join.right.schema().has_column(column),
+            ) {
+                (true, false) => column_is_from_scan(column, &join.left),
+                (false, true) => column_is_from_scan(column, &join.right),
+                _ => Ok(false),
+            }
+        }
+        LogicalPlan::Union(union) => {
+            for input in &union.inputs {
+                if !column_at_is_from_scan(index, input)? {
+                    return Ok(false);
+                }
+            }
+            Ok(true)
+        }
+        // Unknown plan nodes may synthesize columns or hide their origin.
+        _ => Ok(false),
+    }
+}
+
+fn column_at_is_from_scan(index: usize, input: &LogicalPlan) -> Result<bool> {
+    let (qualifier, field) = input.schema().qualified_field(index);
+    column_is_from_scan(&Column::new(qualifier.cloned(), field.name()), input)
+}
+
+fn already_filtered(input: &LogicalPlan, bound: &Expr) -> bool {
+    match input {
+        LogicalPlan::Filter(filter) => {
+            split_conjunction(&filter.predicate).contains(&bound)
+                || already_filtered(&filter.input, bound)
+        }
+        LogicalPlan::TableScan(scan) => scan
+            .filters
+            .iter()
+            .any(|predicate| split_conjunction(predicate).contains(&bound)),
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow::array::{
+        BooleanArray, DictionaryArray, Float64Array, Int64Array, StringArray,
+        TimestampMillisecondArray, TimestampNanosecondArray, UInt32Array,
+    };
+    use arrow::datatypes::UInt32Type;
+    use arrow::record_batch::RecordBatch;
+    use arrow::util::pretty::pretty_format_batches;
+    use datafusion::prelude::SessionContext;
+    use datafusion_optimizer::OptimizerContext;
+    use datafusion_optimizer::optimizer::Optimizer;
+    use datafusion_optimizer::push_down_filter::PushDownFilter;
+    use datafusion_optimizer::simplify_expressions::SimplifyExpressions;
+
+    use super::*;
+
+    fn context() -> SessionContext {
+        // Covers an earlier nonmatching row, both interval endpoints, NULL
+        // values/predicates/group keys, and groups with no matching rows.
+        let keys = vec![
+            Some("a"),
+            Some("a"),
+            Some("a"),
+            Some("a"),
+            Some("a"),
+            Some("b"),
+            Some("c"),
+            Some("c"),
+            None,
+            None,
+            None,
+        ];
+        let numbers = vec![
+            Some(5),
+            Some(10),
+            Some(20),
+            Some(25),
+            None,
+            Some(25),
+            Some(15),
+            Some(4),
+            Some(2),
+            Some(12),
+            Some(22),
+        ];
+        let flags = vec![
+            Some(false),
+            Some(true),
+            Some(true),
+            Some(true),
+            Some(true),
+            Some(true),
+            None,
+            Some(false),
+            Some(false),
+            Some(true),
+            Some(false),
+        ];
+        let services = DictionaryArray::<UInt32Type>::try_new(
+            UInt32Array::from(
+                flags
+                    .iter()
+                    .map(|flag| flag.map(|f| u32::from(!f)))
+                    .collect::<Vec<_>>(),
+            ),
+            Arc::new(StringArray::from(vec!["cart", "other"])),
+        )
+        .unwrap();
+        let batch = RecordBatch::try_from_iter(vec![
+            ("k", Arc::new(StringArray::from(keys)) as _),
+            ("service", Arc::new(services) as _),
+            ("v", Arc::new(Int64Array::from(numbers.clone())) as _),
+            (
+                "f",
+                Arc::new(Float64Array::from(vec![1.0; numbers.len()])) as _,
+            ),
+            (
+                "ts",
+                Arc::new(TimestampNanosecondArray::from(numbers.clone())) as _,
+            ),
+            (
+                "ts_ms",
+                Arc::new(TimestampMillisecondArray::from(numbers)) as _,
+            ),
+            ("flag", Arc::new(BooleanArray::from(flags)) as _),
+        ])
+        .unwrap();
+        let ctx = SessionContext::new();
+        ctx.register_batch("t", batch).unwrap();
+        ctx
+    }
+
+    async fn analyzed(ctx: &SessionContext, sql: &str) -> LogicalPlan {
+        let state = ctx.state();
+        let plan = state.create_logical_plan(sql).await.unwrap();
+        let plan = state
+            .analyzer()
+            .execute_and_check(plan, state.config_options(), |_, _| {})
+            .unwrap();
+        Optimizer::with_rules(vec![Arc::new(SimplifyExpressions::new())])
+            .optimize(plan, &OptimizerContext::new(), |_, _| {})
+            .unwrap()
+    }
+
+    fn optimize(plan: LogicalPlan) -> LogicalPlan {
+        Optimizer::with_rules(vec![Arc::new(InferAggregateInputBoundsRule)])
+            .optimize(plan, &OptimizerContext::new(), |_, _| {})
+            .unwrap()
+    }
+
+    fn aggregate_input_bound(plan: &LogicalPlan) -> Option<&Expr> {
+        if let LogicalPlan::Aggregate(aggregate) = plan
+            && let LogicalPlan::Filter(filter) = aggregate.input.as_ref()
+        {
+            return Some(&filter.predicate);
+        }
+        plan.inputs().into_iter().find_map(aggregate_input_bound)
+    }
+
+    async fn rows(ctx: &SessionContext, plan: LogicalPlan) -> String {
+        let batches = ctx
+            .execute_logical_plan(plan)
+            .await
+            .unwrap()
+            .collect()
+            .await
+            .unwrap();
+        pretty_format_batches(&batches).unwrap().to_string()
+    }
+
+    #[tokio::test]
+    async fn existential_having_preserves_extrema_and_conditional_sum() {
+        let ctx = context();
+        for (extremum, argument, condition, having, expected_bound) in [
+            (
+                "MIN",
+                "v",
+                "service = 'cart' AND v >= 10 AND v < 20",
+                "n > 0",
+                "t.v < Int64(20)",
+            ),
+            ("MIN", "v", "flag AND v <= 20", "n >= 1", "t.v <= Int64(20)"),
+            (
+                "MAX",
+                "v",
+                "flag AND v >= 10 AND v < 20",
+                "0 < n",
+                "t.v >= Int64(10)",
+            ),
+            ("MAX", "v", "flag AND 10 < v", "1 <= n", "t.v > Int64(10)"),
+            (
+                "MIN",
+                "CAST(ts AS BIGINT)",
+                "flag AND CAST(ts AS BIGINT) < 20",
+                "n > 0",
+                "CAST(t.ts AS Int64) < Int64(20)",
+            ),
+            (
+                "MIN",
+                "CAST(ts_ms AS BIGINT)",
+                "flag AND CAST(ts_ms AS BIGINT) < 20",
+                "n > 0",
+                "CAST(t.ts_ms AS Int64) < Int64(20)",
+            ),
+            (
+                "MIN",
+                "ts",
+                "flag AND ts < TIMESTAMP '1970-01-01 00:00:00.000000020'",
+                "n > 0",
+                "t.ts < TimestampNanosecond(20, None)",
+            ),
+        ] {
+            let sql = format!(
+                "SELECT k, {extremum}({argument}) AS endpoint,
+                SUM(CASE WHEN {condition} THEN 1 ELSE 0 END) AS n
+                FROM t GROUP BY k HAVING {having} ORDER BY k NULLS FIRST"
+            );
+            let original = analyzed(&ctx, &sql).await;
+            let optimized = optimize(original.clone());
+            assert_eq!(
+                aggregate_input_bound(&optimized).unwrap().to_string(),
+                expected_bound,
+                "{sql}"
+            );
+            assert_eq!(
+                optimized,
+                optimize(optimized.clone()),
+                "rule must be idempotent: {sql}"
+            );
+            assert_eq!(
+                rows(&ctx, original).await,
+                rows(&ctx, optimized).await,
+                "{sql}"
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn guarded_derived_operands_are_not_pruned() {
+        let ctx = SessionContext::new();
+        let batch = RecordBatch::try_from_iter(vec![
+            ("k", Arc::new(StringArray::from(vec!["a", "a", "b"])) as _),
+            ("v", Arc::new(Int64Array::from(vec![12, 5, 25])) as _),
+            ("d", Arc::new(Int64Array::from(vec![0, 1, 1])) as _),
+            (
+                "raw",
+                Arc::new(StringArray::from(vec!["bad", "5", "25"])) as _,
+            ),
+        ])
+        .unwrap();
+        ctx.register_batch("guarded", batch).unwrap();
+        ctx.sql("CREATE VIEW guarded_view AS SELECT k, v / d AS r FROM guarded WHERE abs(d) > 0")
+            .await
+            .unwrap()
+            .collect()
+            .await
+            .unwrap();
+        for source in [
+            "SELECT k, v / d AS r FROM guarded WHERE abs(d) > 0",
+            "SELECT k, quotient AS r FROM (SELECT k, v / d AS quotient FROM guarded WHERE abs(d) > 0) q",
+            "SELECT k, CAST(raw AS BIGINT) AS r FROM guarded WHERE abs(d) > 0",
+            "SELECT k, r FROM guarded_view",
+            "SELECT k, v AS r FROM guarded UNION ALL SELECT k, v / d AS r FROM guarded WHERE abs(d) > 0",
+            "SELECT l.k, l.r FROM guarded_view l JOIN guarded q ON l.k = q.k",
+        ] {
+            let sql = format!(
+                "SELECT k, MIN(r) FROM ({source}) s GROUP BY k
+                HAVING SUM(CASE WHEN r < 20 THEN 1 ELSE 0 END) > 0 ORDER BY k"
+            );
+            let original = analyzed(&ctx, &sql).await;
+            let optimized = optimize(original.clone());
+            assert_eq!(
+                rows(&ctx, original.clone()).await,
+                rows(&ctx, optimized.clone()).await,
+                "{sql}"
+            );
+            assert_eq!(original, optimized, "{sql}");
+        }
+    }
+
+    #[tokio::test]
+    async fn scan_column_aliases_still_allow_bounds() {
+        let ctx = context();
+        for source in [
+            "SELECT k, v AS r FROM t",
+            "SELECT k, renamed AS r FROM (SELECT k, v AS renamed FROM t) q",
+            "SELECT k, CAST(ts AS BIGINT) AS r FROM t",
+            "SELECT k, v AS r FROM t UNION ALL SELECT k, v AS r FROM t",
+            "SELECT l.k, l.v AS r FROM t l JOIN t r ON l.k = r.k",
+        ] {
+            let sql = format!(
+                "SELECT k, MIN(r) FROM ({source}) s GROUP BY k
+                HAVING SUM(CASE WHEN r < 20 THEN 1 ELSE 0 END) > 0 ORDER BY k NULLS FIRST"
+            );
+            let original = analyzed(&ctx, &sql).await;
+            let optimized = optimize(original.clone());
+            assert!(aggregate_input_bound(&optimized).is_some(), "{sql}");
+            assert_eq!(
+                rows(&ctx, original).await,
+                rows(&ctx, optimized).await,
+                "{sql}"
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn unsafe_or_unsupported_aggregates_are_not_pruned() {
+        let ctx = context();
+        let indicator = "SUM(CASE WHEN flag AND v < 20 THEN 1 ELSE 0 END)";
+        for sql in [
+            format!("SELECT k, MIN(v), COUNT(*) FROM t GROUP BY k HAVING {indicator}>0"),
+            format!("SELECT k, MIN(v), MAX(v) FROM t GROUP BY k HAVING {indicator}>0"),
+            format!("SELECT k, MIN(f) FROM t GROUP BY k HAVING {indicator}>0"),
+            format!("SELECT k, MAX(v) FROM t GROUP BY k HAVING {indicator}>0"),
+            format!("SELECT MIN(v) FROM t HAVING {indicator}>0"),
+            format!("SELECT k, MIN(v) FROM t GROUP BY ROLLUP(k) HAVING {indicator}>0"),
+            format!("SELECT k, MIN(v) FROM t GROUP BY k HAVING {indicator}=0"),
+            format!("SELECT k, MIN(v) FROM t GROUP BY k HAVING {indicator}>0 OR MIN(v)>0"),
+            format!("SELECT k, MIN(v) FILTER (WHERE flag) FROM t GROUP BY k HAVING {indicator}>0"),
+            "SELECT k, MIN(v) FROM t GROUP BY k HAVING SUM(CASE WHEN v<20 THEN 1 ELSE 2 END)>0".into(),
+            "SELECT k, MIN(v) FROM t GROUP BY k HAVING SUM(CASE WHEN v<20 THEN 1 END)>0".into(),
+            "SELECT k, MIN(v) FROM t GROUP BY k HAVING SUM(DISTINCT CASE WHEN v<20 THEN 1 ELSE 0 END)>0".into(),
+            "SELECT k, MIN(v) FROM t GROUP BY k HAVING SUM(CASE WHEN v<20 OR flag THEN 1 ELSE 0 END)>0".into(),
+            "SELECT k, MIN(v) FROM t GROUP BY k HAVING SUM(CASE WHEN random()>0.5 AND v<20 THEN 1 ELSE 0 END)>0".into(),
+            "SELECT k, MIN(CAST(k AS BIGINT)) FROM t GROUP BY k HAVING SUM(CASE WHEN CAST(k AS BIGINT)<20 THEN 1 ELSE 0 END)>0".into(),
+            "SELECT k, MIN(v) FROM t GROUP BY k HAVING SUM(CASE WHEN v<20 THEN 1 WHEN flag THEN 1 ELSE 0 END)>0".into(),
+            "SELECT k, MIN(f) FROM t GROUP BY k HAVING SUM(CASE WHEN f<20.0 THEN 1 ELSE 0 END)>0".into(),
+            "SELECT k, MIN(v) FROM t GROUP BY k HAVING SUM(CASE WHEN v<20 THEN 1 ELSE 0 END)>0 AND SUM(CASE WHEN v<100 THEN 1 ELSE 0 END)>0".into(),
+        ] {
+            let original = analyzed(&ctx, &sql).await;
+            assert_eq!(original, optimize(original.clone()), "{sql}");
+        }
+    }
+
+    #[tokio::test]
+    async fn nonpositive_thresholds_preserve_zero_match_groups() {
+        let ctx = context();
+        let expected = [
+            "+---+----------+",
+            "| k | endpoint |",
+            "+---+----------+",
+            "|   | 2        |",
+            "| a | 5        |",
+            "| b | 25       |",
+            "| c | 4        |",
+            "+---+----------+",
+        ]
+        .join("\n");
+        for threshold in [">= 0", "> -1"] {
+            let sql = format!(
+                "SELECT k, MIN(v) AS endpoint FROM t GROUP BY k
+                HAVING SUM(CASE WHEN flag AND v < 20 THEN 1 ELSE 0 END) {threshold}
+                ORDER BY k NULLS FIRST"
+            );
+            let original = analyzed(&ctx, &sql).await;
+            let optimized = optimize(original.clone());
+            assert_eq!(original, optimized, "{sql}");
+            assert_eq!(expected, rows(&ctx, optimized).await, "{sql}");
+        }
+    }
+
+    #[tokio::test]
+    async fn bound_survives_filter_pushdown_without_being_added_again() {
+        let ctx = context();
+        let original = analyzed(
+            &ctx,
+            "SELECT k, MIN(v) FROM t GROUP BY k
+            HAVING SUM(CASE WHEN flag AND v<20 THEN 1 ELSE 0 END)>0",
+        )
+        .await;
+        let optimizer = Optimizer::with_rules(vec![
+            Arc::new(InferAggregateInputBoundsRule),
+            Arc::new(PushDownFilter::new()),
+        ]);
+        let optimized = optimizer
+            .optimize(original, &OptimizerContext::new(), |_, _| {})
+            .unwrap();
+        let repeated = optimizer
+            .optimize(optimized.clone(), &OptimizerContext::new(), |_, _| {})
+            .unwrap();
+        assert_eq!(optimized, repeated);
+        assert!(aggregate_input_bound(&optimized).is_some());
+    }
+}
diff --git a/src/query/src/optimizer/json_schema_concretize.rs b/src/query/src/optimizer/json_schema_concretize.rs
index 12f71d44c31..9ea3531853d 100644
--- a/src/query/src/optimizer/json_schema_concretize.rs
+++ b/src/query/src/optimizer/json_schema_concretize.rs
@@ -192,8 +192,7 @@ mod tests {
             produce_one_row: false,
             schema,
         });
-        let merge_scan =
-            MergeScanLogicalPlan::new(input, false, Default::default()).into_logical_plan();
+        let merge_scan = MergeScanLogicalPlan::new(input, false).into_logical_plan();
         let plan = LogicalPlanBuilder::from(merge_scan)
             .project(vec![col("j")])?
             .build()?;
diff --git a/src/query/src/optimizer/pass_distribution.rs b/src/query/src/optimizer/pass_distribution.rs
deleted file mode 100644
index 732168e962f..00000000000
--- a/src/query/src/optimizer/pass_distribution.rs
+++ /dev/null
@@ -1,362 +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::config::ConfigOptions;
-use datafusion::physical_optimizer::PhysicalOptimizerRule;
-use datafusion::physical_plan::projection::ProjectionExec;
-use datafusion::physical_plan::repartition::RepartitionExec;
-use datafusion::physical_plan::{
-    ChildrenPropertiesMode, ExecutionPlan, Partitioning, ReplaceChildrenOptions,
-};
-use datafusion_common::Result as DfResult;
-use datafusion_physical_expr::Distribution;
-use datafusion_physical_expr::utils::map_columns_before_projection;
-
-use crate::dist_plan::MergeScanExec;
-
-/// This is a [`PhysicalOptimizerRule`] to pass distribution requirement to
-/// [`MergeScanExec`] to avoid unnecessary shuffling.
-///
-/// This rule is expected to be run before [`EnforceDistribution`].
-///
-/// [`EnforceDistribution`]: datafusion::physical_optimizer::enforce_distribution::EnforceDistribution
-/// [`MergeScanExec`]: crate::dist_plan::MergeScanExec
-#[derive(Debug)]
-pub struct PassDistribution;
-
-impl PhysicalOptimizerRule for PassDistribution {
-    fn optimize(
-        &self,
-        plan: Arc<dyn ExecutionPlan>,
-        config: &ConfigOptions,
-    ) -> DfResult<Arc<dyn ExecutionPlan>> {
-        Self::do_optimize(plan, config)
-    }
-
-    fn name(&self) -> &str {
-        "PassDistributionRule"
-    }
-
-    fn schema_check(&self) -> bool {
-        false
-    }
-}
-
-impl PassDistribution {
-    fn do_optimize(
-        plan: Arc<dyn ExecutionPlan>,
-        _config: &ConfigOptions,
-    ) -> DfResult<Arc<dyn ExecutionPlan>> {
-        // Start from root with no requirement
-        Self::rewrite_with_distribution(plan, None)
-    }
-
-    /// Top-down rewrite that propagates distribution requirements to children.
-    fn rewrite_with_distribution(
-        plan: Arc<dyn ExecutionPlan>,
-        current_req: Option<Distribution>,
-    ) -> DfResult<Arc<dyn ExecutionPlan>> {
-        // If this is a MergeScanExec, try to apply the current requirement.
-        if let Some(merge_scan) = plan.downcast_ref::<MergeScanExec>()
-            && let Some(Distribution::KeyPartitioned(hash_exprs)) = current_req.as_ref()
-        {
-            if let Partitioning::Hash(current_hash_exprs, _) = &merge_scan.properties().partitioning
-                && *current_hash_exprs == *hash_exprs
-            {
-                return Ok(plan);
-            }
-
-            if let Some(new_plan) = merge_scan
-                .try_with_new_distribution(Distribution::KeyPartitioned(hash_exprs.clone()))
-            {
-                // Leaf node; no children to process
-                return Ok(Arc::new(new_plan) as _);
-            }
-
-            let partitioning = Partitioning::Hash(
-                hash_exprs.clone(),
-                merge_scan.properties().partitioning.partition_count(),
-            );
-            return Ok(Arc::new(RepartitionExec::try_new(plan, partitioning)?) as _);
-        }
-
-        // Compute per-child requirements from the current node.
-        let children = plan.children();
-        if children.is_empty() {
-            return Ok(plan);
-        }
-
-        let required = plan.input_distribution_requirements();
-        let mut new_children = Vec::with_capacity(children.len());
-        for (idx, child) in children.into_iter().enumerate() {
-            let child_req = match required.child_distribution(idx) {
-                Some(Distribution::UnspecifiedDistribution) if idx == 0 => {
-                    Self::map_hash_requirement_through_projection(plan.as_ref(), &current_req)
-                }
-                Some(Distribution::UnspecifiedDistribution) => None,
-                None => current_req.clone(),
-                Some(req) => Some(req.clone()),
-            };
-            let new_child = Self::rewrite_with_distribution(child.clone(), child_req)?;
-            new_children.push(new_child);
-        }
-
-        // Rebuild the node only if any child changed (pointer inequality)
-        let unchanged = plan
-            .children()
-            .into_iter()
-            .zip(new_children.iter())
-            .all(|(old, new)| Arc::ptr_eq(old, new));
-        if unchanged {
-            Ok(plan)
-        } else {
-            plan.replace_children(
-                new_children,
-                ReplaceChildrenOptions::new(ChildrenPropertiesMode::Recompute),
-            )
-        }
-    }
-
-    fn map_hash_requirement_through_projection(
-        plan: &dyn ExecutionPlan,
-        current_req: &Option<Distribution>,
-    ) -> Option<Distribution> {
-        let Some(Distribution::KeyPartitioned(required_exprs)) = current_req else {
-            return None;
-        };
-
-        let projection = plan.downcast_ref::<ProjectionExec>()?;
-        let proj_exprs = projection
-            .expr()
-            .iter()
-            .map(|expr| (Arc::clone(&expr.expr), expr.alias.clone()))
-            .collect::<Vec<_>>();
-        let mapped = map_columns_before_projection(required_exprs, &proj_exprs);
-
-        (mapped.len() == required_exprs.len()).then_some(Distribution::KeyPartitioned(mapped))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::{BTreeMap, BTreeSet};
-
-    use api::v1::region::{RemoteDynFilterUnregister, RemoteDynFilterUpdate};
-    use arrow_schema::{DataType, Field, Schema, SchemaRef, TimeUnit};
-    use async_trait::async_trait;
-    use common_query::request::QueryRequest;
-    use datafusion::common::NullEquality;
-    use datafusion::execution::SessionStateBuilder;
-    use datafusion::physical_optimizer::PhysicalOptimizerRule;
-    use datafusion::physical_plan::joins::{HashJoinExec, PartitionMode};
-    use datafusion::physical_plan::projection::{ProjectionExec, ProjectionExpr};
-    use datafusion::physical_plan::{ExecutionPlanProperties, Partitioning};
-    use datafusion_expr::{JoinType, LogicalPlanBuilder};
-    use datafusion_physical_expr::PhysicalExpr;
-    use datafusion_physical_expr::expressions::Column as PhysicalColumn;
-    use session::ReadPreference;
-    use session::context::QueryContext;
-    use store_api::metric_engine_consts::DATA_SCHEMA_TSID_COLUMN_NAME;
-    use store_api::storage::RegionId;
-    use table::table_name::TableName;
-
-    use super::*;
-    use crate::dist_plan::RemoteDynFilterProducerId;
-    use crate::error::Result as QueryResult;
-    use crate::region_query::RegionQueryHandler;
-
-    struct NoopRegionQueryHandler;
-
-    #[async_trait]
-    impl RegionQueryHandler for NoopRegionQueryHandler {
-        async fn select_target(
-            &self,
-            _read_preference: ReadPreference,
-            _region_id: RegionId,
-        ) -> QueryResult<crate::region_query::RegionQueryTarget> {
-            unreachable!("pass distribution tests should not execute remote queries")
-        }
-
-        async fn do_get(
-            &self,
-            _target: &crate::region_query::RegionQueryTarget,
-            _request: QueryRequest,
-        ) -> QueryResult<common_recordbatch::SendableRecordBatchStream> {
-            unreachable!("pass distribution tests should not execute remote queries")
-        }
-
-        async fn handle_remote_dyn_filter_update(
-            &self,
-            _target: &crate::region_query::RegionQueryTarget,
-            _query_id: String,
-            _update: RemoteDynFilterUpdate,
-        ) -> QueryResult<()> {
-            unreachable!("pass distribution tests should not send remote dyn filter updates")
-        }
-
-        async fn handle_remote_dyn_filter_unregister(
-            &self,
-            _target: &crate::region_query::RegionQueryTarget,
-            _query_id: String,
-            _unregister: RemoteDynFilterUnregister,
-        ) -> QueryResult<()> {
-            unreachable!("pass distribution tests should not send remote dyn filter unregisters")
-        }
-    }
-
-    #[test]
-    fn passes_hash_requirement_through_projection_to_merge_scan() {
-        let schema = test_schema();
-        let left_merge_scan = Arc::new(test_merge_scan_exec(schema.clone()));
-        let right_merge_scan = Arc::new(test_merge_scan_exec(schema.clone()));
-        let left_projection = Arc::new(
-            ProjectionExec::try_new(
-                vec![
-                    ProjectionExpr::new(partition_column("greptime_value", 3), "greptime_value"),
-                    ProjectionExpr::new(
-                        partition_column(DATA_SCHEMA_TSID_COLUMN_NAME, 1),
-                        DATA_SCHEMA_TSID_COLUMN_NAME,
-                    ),
-                    ProjectionExpr::new(
-                        partition_column("greptime_timestamp", 2),
-                        "greptime_timestamp",
-                    ),
-                ],
-                left_merge_scan,
-            )
-            .unwrap(),
-        ) as Arc<dyn datafusion::physical_plan::ExecutionPlan>;
-        let join = Arc::new(
-            HashJoinExec::try_new(
-                left_projection,
-                right_merge_scan,
-                vec![
-                    (
-                        partition_column(DATA_SCHEMA_TSID_COLUMN_NAME, 1),
-                        partition_column(DATA_SCHEMA_TSID_COLUMN_NAME, 1),
-                    ),
-                    (
-                        partition_column("greptime_timestamp", 2),
-                        partition_column("greptime_timestamp", 2),
-                    ),
-                ],
-                None,
-                &JoinType::Inner,
-                None,
-                PartitionMode::Partitioned,
-                NullEquality::NullEqualsNull,
-                false,
-            )
-            .unwrap(),
-        ) as Arc<dyn datafusion::physical_plan::ExecutionPlan>;
-
-        let optimized = PassDistribution
-            .optimize(join, &ConfigOptions::default())
-            .unwrap();
-        let hash_join = optimized.downcast_ref::<HashJoinExec>().unwrap();
-        let left_projection = hash_join.left().downcast_ref::<ProjectionExec>().unwrap();
-        let left_partitioning = left_projection.input().output_partitioning();
-        let right_partitioning = hash_join.right().output_partitioning();
-
-        let Partitioning::Hash(left_exprs, left_count) = left_partitioning else {
-            panic!("expected left merge scan hash partitioning");
-        };
-        let Partitioning::Hash(right_exprs, right_count) = right_partitioning else {
-            panic!("expected right merge scan hash partitioning");
-        };
-
-        assert_eq!(*left_count, 2);
-        assert_eq!(*right_count, 2);
-        assert_eq!(
-            column_names(left_exprs),
-            vec![DATA_SCHEMA_TSID_COLUMN_NAME, "greptime_timestamp"]
-        );
-        assert_eq!(
-            column_names(right_exprs),
-            vec![DATA_SCHEMA_TSID_COLUMN_NAME, "greptime_timestamp"]
-        );
-    }
-
-    #[test]
-    fn merge_scan_rejects_hash_requirement_on_partition_key_subset() {
-        let merge_scan = test_merge_scan_exec(test_schema());
-
-        let new_plan = merge_scan.try_with_new_distribution(Distribution::KeyPartitioned(vec![
-            partition_column(DATA_SCHEMA_TSID_COLUMN_NAME, 1),
-        ]));
-
-        assert!(
-            new_plan.is_none(),
-            "partitioning by a subset of multi-column partition keys is not sufficient"
-        );
-    }
-
-    fn test_merge_scan_exec(schema: SchemaRef) -> MergeScanExec {
-        let session_state = SessionStateBuilder::new().with_default_features().build();
-        let partition_cols = BTreeMap::from([
-            (
-                DATA_SCHEMA_TSID_COLUMN_NAME.to_string(),
-                BTreeSet::from([datafusion_common::Column::from_name(
-                    DATA_SCHEMA_TSID_COLUMN_NAME,
-                )]),
-            ),
-            (
-                "greptime_timestamp".to_string(),
-                BTreeSet::from([datafusion_common::Column::from_name("greptime_timestamp")]),
-            ),
-        ]);
-        let plan = LogicalPlanBuilder::empty(false).build().unwrap();
-
-        MergeScanExec::new(
-            &session_state,
-            TableName::new("greptime", "public", "test"),
-            vec![RegionId::new(1, 0), RegionId::new(1, 1)],
-            plan,
-            schema.as_ref(),
-            Arc::new(NoopRegionQueryHandler),
-            QueryContext::arc(),
-            32,
-            partition_cols,
-            Some(RemoteDynFilterProducerId::new(1)),
-            false,
-        )
-        .unwrap()
-    }
-
-    fn test_schema() -> SchemaRef {
-        Arc::new(Schema::new(vec![
-            Field::new("host", DataType::Utf8, true),
-            Field::new(DATA_SCHEMA_TSID_COLUMN_NAME, DataType::UInt64, false),
-            Field::new(
-                "greptime_timestamp",
-                DataType::Timestamp(TimeUnit::Millisecond, None),
-                false,
-            ),
-            Field::new("greptime_value", DataType::Float64, true),
-        ]))
-    }
-
-    fn partition_column(name: &str, index: usize) -> Arc<dyn PhysicalExpr> {
-        Arc::new(PhysicalColumn::new(name, index))
-    }
-
-    fn column_names(exprs: &[Arc<dyn PhysicalExpr>]) -> Vec<&str> {
-        exprs
-            .iter()
-            .map(|expr| expr.downcast_ref::<PhysicalColumn>().unwrap().name())
-            .collect()
-    }
-}
diff --git a/src/query/src/parser.rs b/src/query/src/parser.rs
index 87b827e0cc1..c89c47392f6 100644
--- a/src/query/src/parser.rs
+++ b/src/query/src/parser.rs
@@ -224,11 +224,31 @@ impl QueryLanguageParser {
             // also report rfc3339 error if float parsing fails
             .map_err(|_| rfc3339_result.unwrap_err())?;
 
-        let duration =
-            Duration::try_from_secs_f64(secs).context(TryIntoDurationSnafu { raw: timestamp })?;
-        SystemTime::UNIX_EPOCH
-            .checked_add(duration)
-            .context(AddSystemTimeOverflowSnafu { duration })
+        // Prometheus accepts timestamps before the Unix epoch. Follow the arithmetic of its
+        // `parseTime` and `timestamp.FromTime` step by step: the float fraction is rounded to
+        // milliseconds before any conversion to nanoseconds, which decides boundary values
+        // like 1.0005, whose fraction is just below 0.0005.
+        let magnitude = Duration::try_from_secs_f64(secs.abs())
+            .context(TryIntoDurationSnafu { raw: timestamp })?;
+        let whole = secs.trunc();
+        let fraction = ((secs - whole) * 1000.0).round() / 1000.0;
+        let nanos = whole as i128 * 1_000_000_000 + (fraction * 1e9) as i128;
+        let millis = nanos.div_euclid(1_000_000);
+        let duration = u64::try_from(millis.unsigned_abs())
+            .ok()
+            .map(Duration::from_millis)
+            .context(AddSystemTimeOverflowSnafu {
+                duration: magnitude,
+            })?;
+        if millis < 0 {
+            SystemTime::UNIX_EPOCH
+                .checked_sub(duration)
+                .context(AddSystemTimeOverflowSnafu { duration })
+        } else {
+            SystemTime::UNIX_EPOCH
+                .checked_add(duration)
+                .context(AddSystemTimeOverflowSnafu { duration })
+        }
     }
 }
 
@@ -380,6 +400,31 @@ mod test {
         }
     }
 
+    #[test]
+    fn parse_promql_timestamp_matches_prometheus_millis() {
+        // Expected values are Prometheus' `timestamp.FromTime(parseTime(input))`.
+        for (input, millis) in [
+            ("-30000.5", -30_000_500),
+            ("-0.001", -1),
+            ("-0.0006", -1),
+            ("-1.2346", -1235),
+            ("1.2346", 1235),
+            ("0.0004", 0),
+            ("1.0005", 1000),
+            ("-1.0005", -1000),
+            ("0.0004999999", 0),
+            ("1969-12-31T23:59:59.9999Z", -1),
+            ("1970-01-01T00:00:00.0009Z", 0),
+        ] {
+            let result = QueryLanguageParser::parse_promql_timestamp(input).unwrap();
+            assert_eq!(
+                crate::promql::label_values::signed_millis_since_epoch(result).unwrap(),
+                millis,
+                "{input}"
+            );
+        }
+    }
+
     #[test]
     fn parse_promql_timestamp() {
         let cases = vec![
diff --git a/src/query/src/planner.rs b/src/query/src/planner.rs
index b8501e1a6db..44cd1653cee 100644
--- a/src/query/src/planner.rs
+++ b/src/query/src/planner.rs
@@ -55,6 +55,7 @@ use crate::error::{
     UnimplementedSnafu,
 };
 use crate::log_query::planner::LogQueryPlanner;
+use crate::optimizer::expr_depth;
 use crate::parser::{DEFAULT_LOOKBACK_STRING, PromQuery, QueryLanguageParser, QueryStatement};
 use crate::promql::planner::PromPlanner;
 use crate::query_engine::{DefaultPlanDecoder, QueryEngineState};
@@ -267,6 +268,7 @@ impl DfLogicalPlanner {
                 .context(PlanSqlSnafu)?
         };
 
+        expr_depth::validate_plan(&result)?;
         common_telemetry::debug!("Logical planner, statement to plan result: {result}");
         let plan = RangePlanRewriter::new(table_provider, query_ctx.clone())
             .rewrite(result)
diff --git a/src/query/src/promql/error.rs b/src/query/src/promql/error.rs
index 6cd45d9e57c..78e7289b479 100644
--- a/src/query/src/promql/error.rs
+++ b/src/query/src/promql/error.rs
@@ -130,6 +130,20 @@ pub enum Error {
         location: Location,
     },
 
+    #[snafu(display("Subquery step must be positive"))]
+    ZeroSubqueryStep {
+        #[snafu(implicit)]
+        location: Location,
+    },
+
+    #[snafu(display(
+        "invalid expression type \"range vector\" for range query, must be Scalar or instant Vector"
+    ))]
+    RangeVectorInRangeQuery {
+        #[snafu(implicit)]
+        location: Location,
+    },
+
     #[snafu(display(
         "The end time must be greater than start time, start: {:?}, end: {:?}",
         start,
@@ -142,6 +156,16 @@ pub enum Error {
         location: Location,
     },
 
+    #[snafu(display(
+        "The subquery child window is outside the representable millisecond range: {}",
+        timestamp
+    ))]
+    SubqueryTimestampOutOfRange {
+        timestamp: String,
+        #[snafu(implicit)]
+        location: Location,
+    },
+
     #[snafu(display("Cannot find column {col}"))]
     ColumnNotFound {
         col: String,
@@ -217,12 +241,6 @@ pub enum Error {
         location: Location,
     },
 
-    #[snafu(display("vector cannot contain metrics with the same labelset"))]
-    SameLabelSet {
-        #[snafu(implicit)]
-        location: Location,
-    },
-
     #[snafu(display("Invalid regular expression in label_replace(): {}", regex))]
     InvalidRegularExpression {
         regex: String,
@@ -249,14 +267,16 @@ impl ErrorExt for Error {
             | MultipleVector { .. }
             | ExpectRangeSelector { .. }
             | ZeroRangeSelector { .. }
+            | RangeVectorInRangeQuery { .. }
+            | ZeroSubqueryStep { .. }
             | InvalidTimeRange { .. }
+            | SubqueryTimestampOutOfRange { .. }
             | ColumnNotFound { .. }
             | FunctionInvalidArgument { .. }
             | UnsupportedVectorMatch { .. }
             | CombineTableColumnMismatch { .. }
             | UnexpectedPlanExpr { .. }
             | UnsupportedMatcherOp { .. }
-            | SameLabelSet { .. }
             | TimestampOutOfRange { .. }
             | SystemTimeOutOfRange { .. }
             | AtModifierTimestampOutOfRange { .. }
diff --git a/src/query/src/promql/label_values.rs b/src/query/src/promql/label_values.rs
index 841666758e4..cae53c64853 100644
--- a/src/query/src/promql/label_values.rs
+++ b/src/query/src/promql/label_values.rs
@@ -33,13 +33,20 @@ use crate::promql::error::{
 /// a negative duration, and an RFC3339 query parameter can name one, so the sign
 /// is recovered here instead of unwrapping.
 fn millis_since_epoch(time: SystemTime) -> Result<Timestamp> {
+    Ok(Timestamp::new_millisecond(signed_millis_since_epoch(time)?))
+}
+
+/// Converts a [`SystemTime`] to signed milliseconds since the Unix epoch, rejecting instants
+/// outside the `i64` millisecond range.
+///
+/// Sub-millisecond parts round down, also before the epoch, like Prometheus'
+/// `timestamp.FromTime`.
+pub(crate) fn signed_millis_since_epoch(time: SystemTime) -> Result<i64> {
     let (millis, before_epoch) = match time.duration_since(UNIX_EPOCH) {
         Ok(duration) => (duration.as_millis(), false),
-        Err(earlier) => (earlier.duration().as_millis(), true),
+        Err(earlier) => (earlier.duration().as_nanos().div_ceil(1_000_000), true),
     };
-    let millis =
-        signed_millis(millis, before_epoch).with_context(|| SystemTimeOutOfRangeSnafu { time })?;
-    Ok(Timestamp::new_millisecond(millis))
+    signed_millis(millis, before_epoch).with_context(|| SystemTimeOutOfRangeSnafu { time })
 }
 
 /// Converts a millisecond magnitude and epoch direction without platform time limits.
diff --git a/src/query/src/promql/planner.rs b/src/query/src/promql/planner.rs
index be0c1364489..afe52c7b560 100644
--- a/src/query/src/promql/planner.rs
+++ b/src/query/src/promql/planner.rs
@@ -21,13 +21,13 @@ mod set_operator;
 
 use std::collections::{BTreeSet, HashSet, VecDeque};
 use std::sync::Arc;
-use std::time::UNIX_EPOCH;
 
 use arrow::datatypes::IntervalDayTime;
 use async_recursion::async_recursion;
 use catalog::table_source::DfTableSourceProvider;
 use common_error::ext::ErrorExt;
 use common_error::status_code::StatusCode;
+use common_function::aggrs::extremum::Extremum;
 use common_function::function::FunctionContext;
 use common_query::native_histogram::native_histogram_value_type;
 use common_query::prelude::{
@@ -48,7 +48,7 @@ use datafusion::functions_window::row_number::RowNumber;
 use datafusion::logical_expr::expr::{Alias, ScalarFunction, WindowFunction};
 use datafusion::logical_expr::expr_rewriter::normalize_cols;
 use datafusion::logical_expr::{
-    BinaryExpr, Cast, Extension, LogicalPlan, LogicalPlanBuilder, Operator,
+    BinaryExpr, Cast, EmptyRelation, Extension, LogicalPlan, LogicalPlanBuilder, Operator,
     ScalarUDF as ScalarUdfDef, WindowFrame, WindowFunctionDefinition,
 };
 use datafusion::prelude as df_prelude;
@@ -58,7 +58,7 @@ use datafusion_common::{DFSchema, NullEquality, TableReference};
 use datafusion_expr::expr::WindowFunctionParams;
 use datafusion_expr::expr_fn::when;
 use datafusion_expr::utils::{conjunction, disjunction};
-use datafusion_expr::{ExprSchemable, Literal, SortExpr, TableSource, col, lit};
+use datafusion_expr::{ExprSchemable, Literal, SortExpr, TableSource, ident, lit};
 use datafusion_functions::core::coalesce;
 use datatypes::arrow::datatypes::{DataType as ArrowDataType, TimeUnit as ArrowTimeUnit};
 use datatypes::data_type::{ConcreteDataType, DataType as GreptimeDataType};
@@ -70,18 +70,18 @@ use promql::extension_plan::{
 };
 use promql::functions::{
     AbsentOverTime, AvgOverTime, Changes, CountOverTime, Delta, Deriv, DoubleExponentialSmoothing,
-    IDelta, Increase, LastOverTime, MatchGroupViolation, MaxOverTime, MinOverTime, MixedRange,
-    NativeHistogramAbsentOverTime, NativeHistogramAdd, NativeHistogramAggAvg,
-    NativeHistogramAggSum, NativeHistogramAvg, NativeHistogramAvgOverTime, NativeHistogramChanges,
-    NativeHistogramCount, NativeHistogramCountOverTime, NativeHistogramDelta,
-    NativeHistogramDivScalar, NativeHistogramDrop, NativeHistogramEq, NativeHistogramIDelta,
-    NativeHistogramIRate, NativeHistogramIncrease, NativeHistogramLastOverTime,
-    NativeHistogramMulScalar, NativeHistogramNeg, NativeHistogramNotEq,
-    NativeHistogramPresentOverTime, NativeHistogramRate, NativeHistogramResets,
-    NativeHistogramScalarMul, NativeHistogramStddev, NativeHistogramStdvar, NativeHistogramSub,
-    NativeHistogramSum, NativeHistogramSumOverTime, NativeHistogramToString, PredictLinear,
-    PresentOverTime, PromqlFloatToString, QuantileOverTime, Rate, Resets, Round, StddevOverTime,
-    StdvarOverTime, SumOverTime, UniqueMatchGroup, quantile_udaf,
+    IDelta, IeeeComparison, IeeeSqrt, Increase, LastOverTime, MatchGroupViolation, MaxOverTime,
+    MinOverTime, MixedRange, NativeHistogramAbsentOverTime, NativeHistogramAdd,
+    NativeHistogramAggAvg, NativeHistogramAggSum, NativeHistogramAvg, NativeHistogramAvgOverTime,
+    NativeHistogramChanges, NativeHistogramCount, NativeHistogramCountOverTime,
+    NativeHistogramDelta, NativeHistogramDivScalar, NativeHistogramDrop, NativeHistogramEq,
+    NativeHistogramIDelta, NativeHistogramIRate, NativeHistogramIncrease,
+    NativeHistogramLastOverTime, NativeHistogramMulScalar, NativeHistogramNeg,
+    NativeHistogramNotEq, NativeHistogramPresentOverTime, NativeHistogramRate,
+    NativeHistogramResets, NativeHistogramScalarMul, NativeHistogramStddev, NativeHistogramStdvar,
+    NativeHistogramSub, NativeHistogramSum, NativeHistogramSumOverTime, NativeHistogramToString,
+    PredictLinear, PresentOverTime, PromqlFloatToString, QuantileOverTime, Rate, Resets, Round,
+    StddevOverTime, StdvarOverTime, SumOverTime, UniqueMatchGroup, quantile_udaf,
 };
 use promql_parser::label::{METRIC_NAME, MatchOp, Matcher, Matchers};
 use promql_parser::parser::token::TokenType;
@@ -107,12 +107,17 @@ use crate::promql::error::{
     CatalogSnafu, ColumnNotFoundSnafu, DataFusionPlanningSnafu, ExpectRangeSelectorSnafu,
     FunctionInvalidArgumentSnafu, InvalidDestinationLabelNameSnafu, InvalidRegularExpressionSnafu,
     InvalidTimeRangeSnafu, MultiFieldsNotSupportedSnafu, MultipleMetricMatchersSnafu,
-    MultipleVectorSnafu, NoMetricMatcherSnafu, Result, SameLabelSetSnafu, TableNameNotFoundSnafu,
-    TimeIndexNotFoundSnafu, UnexpectedPlanExprSnafu, UnexpectedTokenSnafu, UnknownTableSnafu,
-    UnsupportedExprSnafu, UnsupportedMatcherOpSnafu, ValueNotFoundSnafu, ZeroRangeSelectorSnafu,
+    MultipleVectorSnafu, NoMetricMatcherSnafu, RangeVectorInRangeQuerySnafu, Result,
+    SubqueryTimestampOutOfRangeSnafu, TableNameNotFoundSnafu, TimeIndexNotFoundSnafu,
+    UnexpectedPlanExprSnafu, UnexpectedTokenSnafu, UnknownTableSnafu, UnsupportedExprSnafu,
+    UnsupportedMatcherOpSnafu, ValueNotFoundSnafu, ZeroRangeSelectorSnafu, ZeroSubqueryStepSnafu,
 };
+use crate::promql::label_values::signed_millis_since_epoch;
 use crate::query_engine::QueryEngineState;
 
+/// Step of a subquery without an explicit one (`x[5m:]`). Prometheus uses the global
+/// evaluation interval, whose default is one minute, rather than the query step.
+const DEFAULT_SUBQUERY_STEP_MS: Millisecond = 60_000;
 /// `time()` function in PromQL.
 const SPECIAL_TIME_FUNCTION: &str = "time";
 /// `scalar()` function in PromQL.
@@ -240,10 +245,11 @@ impl BinaryResultLabels {
 }
 
 impl PromPlannerContext {
-    fn from_eval_stmt(stmt: &EvalStmt) -> Self {
-        let start = stmt.start.duration_since(UNIX_EPOCH).unwrap().as_millis() as Millisecond;
-        let end = stmt.end.duration_since(UNIX_EPOCH).unwrap().as_millis() as Millisecond;
-        Self {
+    fn from_eval_stmt(stmt: &EvalStmt) -> Result<Self> {
+        // Evaluation times before the Unix epoch are valid in Prometheus.
+        let start = signed_millis_since_epoch(stmt.start)?;
+        let end = signed_millis_since_epoch(stmt.end)?;
+        Ok(Self {
             start,
             end,
             interval: stmt.interval.as_millis() as _,
@@ -251,7 +257,7 @@ impl PromPlannerContext {
             stmt_start: start,
             stmt_end: end,
             ..Default::default()
-        }
+        })
     }
 
     /// Reset all planner states
@@ -308,12 +314,12 @@ impl PromPlanner {
     ) -> Result<LogicalPlan> {
         let mut planner = Self {
             table_provider,
-            ctx: PromPlannerContext::from_eval_stmt(stmt),
+            ctx: PromPlannerContext::from_eval_stmt(stmt)?,
             promql_annotations,
         };
 
         let plan = planner
-            .prom_expr_to_plan(&stmt.expr, query_engine_state)
+            .prom_root_expr_to_plan(&stmt.expr, query_engine_state)
             .await?;
 
         // Never leak internal series identifier to output.
@@ -397,24 +403,231 @@ impl PromPlanner {
         Ok(res)
     }
 
+    /// Plans the root expression of a statement, or the expression wrapped by a root extension
+    /// such as `EXPLAIN` or an alias.
+    ///
+    /// Prometheus only accepts a range-vector expression in an instant query, whose result is
+    /// the matrix of samples the expression selects.
+    async fn prom_root_expr_to_plan(
+        &mut self,
+        prom_expr: &PromExpr,
+        query_engine_state: &QueryEngineState,
+    ) -> Result<LogicalPlan> {
+        if matches!(prom_expr, PromExpr::Extension(_))
+            || prom_expr.value_type() != ValueType::Matrix
+        {
+            return self.prom_expr_to_plan(prom_expr, query_engine_state).await;
+        }
+        ensure!(self.ctx.start == self.ctx.end, RangeVectorInRangeQuerySnafu);
+        self.prom_range_vector_result_to_plan(prom_expr, query_engine_state)
+            .await
+    }
+
+    /// Plans the result of a range-vector expression in an instant query: the raw samples of a
+    /// range selector, or the evaluation points of a subquery, with their own timestamps.
+    ///
+    /// Range functions consume the same expressions through [`RangeManipulate`], whose range
+    /// arrays are an internal representation that must not reach the query output.
+    async fn prom_range_vector_result_to_plan(
+        &mut self,
+        prom_expr: &PromExpr,
+        query_engine_state: &QueryEngineState,
+    ) -> Result<LogicalPlan> {
+        let mut expr = prom_expr;
+        while let PromExpr::Paren(ParenExpr { expr: inner }) = expr {
+            expr = inner;
+        }
+        match expr {
+            PromExpr::MatrixSelector(selector) => {
+                self.prom_range_selector_samples_to_plan(selector).await
+            }
+            PromExpr::Subquery(subquery) => {
+                self.prom_subquery_samples_to_plan(subquery, query_engine_state)
+                    .await
+            }
+            _ => UnsupportedExprSnafu {
+                name: format!("range vector result of {expr:?}"),
+            }
+            .fail(),
+        }
+    }
+
+    /// Selects the samples of `selector` in `(t - offset - range, t - offset]`, where `t` is the
+    /// evaluation time or the `@` anchor. Stale markers are dropped and timestamps are kept.
+    async fn prom_range_selector_samples_to_plan(
+        &mut self,
+        selector: &MatrixSelector,
+    ) -> Result<LogicalPlan> {
+        let MatrixSelector { vs, range } = selector;
+        let VectorSelector {
+            name,
+            offset,
+            matchers,
+            at,
+        } = vs;
+        let matchers = self.preprocess_label_matchers(matchers, name)?;
+        ensure!(!range.is_zero(), ZeroRangeSelectorSnafu);
+        self.ctx.range = Some(range.as_millis() as _);
+        let offset_ms = match self.at_modifier_offset(at, offset)? {
+            Some(at_offset) => at_offset,
+            None => Self::offset_millis(offset),
+        };
+        if let Some(empty_plan) = self.setup_context().await? {
+            return Ok(empty_plan);
+        }
+        let plan = self
+            .selector_to_series_normalize_plan(offset_ms, matchers, true)
+            .await?;
+        self.millisecond_time_index_plan(plan)
+    }
+
+    /// Casts a microsecond or nanosecond time index to milliseconds, the precision of every
+    /// other PromQL result and the only one the Prometheus HTTP API encodes.
+    fn millisecond_time_index_plan(&self, plan: LogicalPlan) -> Result<LogicalPlan> {
+        let time_index =
+            self.ctx
+                .time_index_column
+                .as_deref()
+                .with_context(|| TimeIndexNotFoundSnafu {
+                    table: self.ctx.table_name.clone().unwrap_or_default(),
+                })?;
+        let (_, field) = plan
+            .schema()
+            .qualified_field_with_unqualified_name(time_index)
+            .context(DataFusionPlanningSnafu)?;
+        let millis = match field.data_type() {
+            ArrowDataType::Timestamp(ArrowTimeUnit::Millisecond, _) => return Ok(plan),
+            ArrowDataType::Timestamp(_, timezone) => {
+                ArrowDataType::Timestamp(ArrowTimeUnit::Millisecond, timezone.clone())
+            }
+            other => unreachable!("time index is a timestamp, got {other}"),
+        };
+        let exprs = plan
+            .schema()
+            .iter()
+            .map(|(qualifier, field)| {
+                let column = DfExpr::Column(Column::new(qualifier.cloned(), field.name()));
+                if field.name() == time_index {
+                    column
+                        .cast_to(&millis, plan.schema())
+                        .map(|cast| cast.alias_qualified(qualifier.cloned(), field.name().clone()))
+                } else {
+                    Ok(column)
+                }
+            })
+            .collect::<datafusion::error::Result<Vec<_>>>()
+            .context(DataFusionPlanningSnafu)?;
+        LogicalPlanBuilder::from(plan)
+            .project(exprs)
+            .context(DataFusionPlanningSnafu)?
+            .build()
+            .context(DataFusionPlanningSnafu)
+    }
+
+    /// Evaluates the inner expression of `subquery` at the multiples of its step in
+    /// `(t - offset - range, t - offset]`, where `t` is the evaluation time or the `@` anchor.
+    async fn prom_subquery_samples_to_plan(
+        &mut self,
+        subquery: &SubqueryExpr,
+        query_engine_state: &QueryEngineState,
+    ) -> Result<LogicalPlan> {
+        let SubqueryExpr {
+            expr,
+            range,
+            step,
+            offset,
+            at,
+            ..
+        } = subquery;
+        ensure!(!range.is_zero(), ZeroRangeSelectorSnafu);
+        let end = match self.at_ref_time(at, offset)? {
+            Some(anchor) => anchor,
+            None => Self::anchor_sub(self.ctx.end, Self::offset_millis(offset))?,
+        };
+        self.ctx.interval = match step {
+            Some(step) => step.as_millis() as _,
+            None => DEFAULT_SUBQUERY_STEP_MS,
+        };
+        let interval = self.ctx.interval;
+        ensure!(interval > 0, ZeroSubqueryStepSnafu);
+        let window = Self::subquery_child_window(end, end, 0, 0, range.as_millis() as _, interval)?;
+        let Some((start, end)) = window else {
+            // No step multiple falls in the window; plan the inner expression only for its
+            // schema.
+            self.ctx.start = end;
+            self.ctx.end = end;
+            let plan = self.prom_expr_to_plan(expr, query_engine_state).await?;
+            return Ok(LogicalPlan::EmptyRelation(EmptyRelation {
+                produce_one_row: false,
+                schema: plan.schema().clone(),
+            }));
+        };
+        self.ctx.start = start;
+        self.ctx.end = end;
+        self.prom_expr_to_plan(expr, query_engine_state).await
+    }
+
     async fn prom_subquery_expr_to_plan(
         &mut self,
         query_engine_state: &QueryEngineState,
         subquery_expr: &SubqueryExpr,
     ) -> Result<LogicalPlan> {
         let SubqueryExpr {
-            expr, range, step, ..
+            expr,
+            range,
+            step,
+            offset,
+            ..
         } = subquery_expr;
 
+        // Shift the child window back; `RangeManipulate` restores the outer timeline.
+        let offset_ms = match offset {
+            Some(Offset::Pos(duration)) => duration.as_millis() as Millisecond,
+            Some(Offset::Neg(duration)) => -(duration.as_millis() as Millisecond),
+            None => 0,
+        };
+
         let current_interval = self.ctx.interval;
-        if let Some(step) = step {
-            self.ctx.interval = step.as_millis() as _;
-        }
+        self.ctx.interval = match step {
+            Some(step) => step.as_millis() as _,
+            None => DEFAULT_SUBQUERY_STEP_MS,
+        };
+        ensure!(self.ctx.interval > 0, ZeroRangeSelectorSnafu);
         let current_start = self.ctx.start;
-        self.ctx.start -= range.as_millis() as i64 - self.ctx.interval;
+        let current_end = self.ctx.end;
+        // Reject an invalid parent window rather than treating it as empty.
+        ensure!(
+            current_start <= current_end,
+            InvalidTimeRangeSnafu {
+                start: current_start,
+                end: current_end,
+            }
+        );
+        // An empty child needs only its schema; plan it over the valid caller window.
+        let child_window = Self::subquery_child_window(
+            current_start,
+            current_end,
+            current_interval,
+            offset_ms,
+            range.as_millis() as Millisecond,
+            self.ctx.interval,
+        )?;
+        if let Some((child_start, child_end)) = child_window {
+            self.ctx.start = child_start;
+            self.ctx.end = child_end;
+        }
         let input = self.prom_expr_to_plan(expr, query_engine_state).await?;
         self.ctx.interval = current_interval;
         self.ctx.start = current_start;
+        self.ctx.end = current_end;
+        // Return no rows with the child schema so enclosing fallbacks still work.
+        let input = match child_window {
+            Some(_) => input,
+            None => LogicalPlan::EmptyRelation(EmptyRelation {
+                produce_one_row: false,
+                schema: input.schema().clone(),
+            }),
+        };
 
         ensure!(!range.is_zero(), ZeroRangeSelectorSnafu);
         let range_ms = range.as_millis() as _;
@@ -471,26 +684,42 @@ impl PromPlanner {
             .context(DataFusionPlanningSnafu)?;
         let divide_plan = LogicalPlan::Extension(Extension {
             node: Arc::new(SeriesDivide::new(
-                series_key_columns,
+                series_key_columns.clone(),
                 time_index_column.clone(),
                 sort_plan,
             )),
         });
 
+        // `RangeManipulate` has no offset in its protobuf message; decoding recovers it from the
+        // `SeriesNormalize` directly below. Stale markers are not filtered: the input is computed.
+        let divide_plan = if offset_ms != 0 {
+            LogicalPlan::Extension(Extension {
+                node: Arc::new(SeriesNormalize::new(
+                    offset_ms,
+                    time_index_column.clone(),
+                    false,
+                    series_key_columns,
+                    divide_plan,
+                )),
+            })
+        } else {
+            divide_plan
+        };
+
         let manipulate = RangeManipulate::new(
             self.ctx.start,
             self.ctx.end,
             self.ctx.interval,
-            0,
+            offset_ms,
             range_ms,
             time_index_column,
             self.ctx.field_columns.clone(),
             divide_plan,
         )
         .context(DataFusionPlanningSnafu)?;
-        // A subquery always folds with offset 0, so its payload timestamps are already on the
-        // evaluation timeline a function above it reads; see [`Self::create_range_eval_ts_expr`].
-        self.ctx.range_fold_offset = Some(0);
+        // The payload timestamps are shifted by the subquery offset; see
+        // [`Self::create_range_eval_ts_expr`].
+        self.ctx.range_fold_offset = Some(offset_ms);
 
         Ok(LogicalPlan::Extension(Extension {
             node: Arc::new(manipulate),
@@ -646,7 +875,7 @@ impl PromPlanner {
                         .cloned()
                         .chain(prev_field_exprs.clone())
                         .collect::<Vec<_>>();
-                    group_exprs.push(col(label));
+                    group_exprs.push(ident(label));
                     let project_fields = self
                         .create_field_column_exprs()?
                         .into_iter()
@@ -766,10 +995,10 @@ impl PromPlanner {
                     ),
                     self.promql_annotations.clone(),
                 )),
-                args: vec![col(&histogram_column)],
+                args: vec![ident(&histogram_column)],
             });
-            let keep_float = when(col(&histogram_column).is_not_null(), drop_histogram)
-                .otherwise(col(&float_column).is_not_null())
+            let keep_float = when(ident(&histogram_column).is_not_null(), drop_histogram)
+                .otherwise(ident(&float_column).is_not_null())
                 .context(DataFusionPlanningSnafu)?;
             input = LogicalPlanBuilder::from(input)
                 .filter(keep_float)
@@ -820,7 +1049,7 @@ impl PromPlanner {
             .iter()
             .fold(None, |expr, rank| {
                 let predicate = DfExpr::BinaryExpr(BinaryExpr {
-                    left: Box::new(col(rank)),
+                    left: Box::new(ident(rank)),
                     op: Operator::LtEq,
                     right: Box::new(val.clone()),
                 });
@@ -836,7 +1065,7 @@ impl PromPlanner {
             })
             .unwrap();
 
-        let rank_columns: Vec<_> = rank_columns.into_iter().map(col).collect();
+        let rank_columns: Vec<_> = rank_columns.into_iter().map(ident).collect();
 
         let mut new_group_exprs = group_exprs.clone();
         // Order by ranks
@@ -889,10 +1118,12 @@ impl PromPlanner {
             if Self::field_column_is_native_histogram(&input_schema, col) {
                 Ok(DfExpr::ScalarFunction(ScalarFunction {
                     func: Arc::new(NativeHistogramNeg::scalar_udf()),
-                    args: vec![DfExpr::Column(col.into())],
+                    args: vec![DfExpr::Column(Column::from_name(col))],
                 }))
             } else {
-                Ok(DfExpr::Negative(Box::new(DfExpr::Column(col.into()))))
+                Ok(DfExpr::Negative(Box::new(DfExpr::Column(
+                    Column::from_name(col),
+                ))))
             }
         })
     }
@@ -1002,7 +1233,7 @@ impl PromPlanner {
                     let binary_expr_builder = Self::prom_token_to_binary_expr_builder(*op)?;
                     let rhs_is_histogram =
                         Self::field_column_is_native_histogram(&input_schema, col);
-                    let rhs = DfExpr::Column(col.into());
+                    let rhs = DfExpr::Column(Column::from_name(col));
                     let mut binary_expr = match Self::native_histogram_binary_expr(
                         *op,
                         expr.clone(),
@@ -1069,7 +1300,7 @@ impl PromPlanner {
                     let binary_expr_builder = Self::prom_token_to_binary_expr_builder(*op)?;
                     let lhs_is_histogram =
                         Self::field_column_is_native_histogram(&input_schema, col);
-                    let lhs = DfExpr::Column(col.into());
+                    let lhs = DfExpr::Column(Column::from_name(col));
                     let mut binary_expr = match Self::native_histogram_binary_expr(
                         *op,
                         lhs.clone(),
@@ -1196,6 +1427,18 @@ impl PromPlanner {
                     }
                 } else if right_is_empty_metric && !left_is_empty_metric {
                     self.ctx = left_context.clone();
+                } else if rhs.value_type() == ValueType::Scalar
+                    && lhs.value_type() == ValueType::Vector
+                {
+                    // A computed scalar on the right (`time()`, `scalar(...)`) has no labels;
+                    // the result keeps the labels of the vector on the left.
+                    self.ctx = left_context.clone();
+                }
+                // An operand without a table name, such as a comparison filter's projection, is
+                // joined under the `""` qualifier; resolve the projected columns against it.
+                // Otherwise a time index present on both sides is ambiguous.
+                if self.ctx.table_name.is_none() {
+                    self.ctx.table_name = Some(String::new());
                 }
                 // Computed scalars reach this join path instead of the literal projection paths.
                 // Broadcast them for arithmetic in the same way as literal scalars.
@@ -1622,6 +1865,47 @@ impl PromPlanner {
         }
     }
 
+    /// Returns the first absolute step multiple strictly after `start - offset - range`
+    /// through the last parent evaluation instant minus `offset`. Requires a positive step.
+    /// Returns `None` for an empty window; an unrepresentable nonempty bound is an error.
+    fn subquery_child_window(
+        start: Millisecond,
+        end: Millisecond,
+        interval: Millisecond,
+        offset: Millisecond,
+        range: Millisecond,
+        step: Millisecond,
+    ) -> Result<Option<(Millisecond, Millisecond)>> {
+        let window_start = i128::from(start) - i128::from(offset) - i128::from(range);
+        let grid_start = (window_start.div_euclid(i128::from(step)) + 1) * i128::from(step);
+        let grid_end = if interval > 0 {
+            let steps = (i128::from(end) - i128::from(start)) / i128::from(interval);
+            i128::from(start) + steps * i128::from(interval)
+        } else {
+            i128::from(end)
+        } - i128::from(offset);
+        // Check emptiness before converting bounds to i64.
+        if grid_start > grid_end {
+            return Ok(None);
+        }
+        let bound = |name: &str, value: i128| {
+            i64::try_from(value).map_err(|_| {
+                SubqueryTimestampOutOfRangeSnafu {
+                    timestamp: format!(
+                        "subquery child window {name} = {value} ms (start = {start} ms, \
+                         end = {end} ms, interval = {interval} ms, offset = {offset} ms, \
+                         range = {range} ms, step = {step} ms)"
+                    ),
+                }
+                .build()
+            })
+        };
+        Ok(Some((
+            bound("grid start", grid_start)?,
+            bound("grid end", grid_end)?,
+        )))
+    }
+
     /// The columns that identify one series, which is the series key expected by the PromQL plan
     /// nodes that hold exactly one series per input batch.
     fn series_key_columns(&self) -> Vec<String> {
@@ -1718,47 +2002,9 @@ impl PromPlanner {
                     DfExpr::Column(Column::new(qualifier.cloned(), field.name().clone()))
                 })
                 .collect::<Vec<_>>();
-            // `timestamp()` preserves the shifted selector timeline even though
-            // SeriesNormalize now retains raw native timestamp storage. Decimal
-            // arithmetic shifts before truncating to milliseconds.
-            let unit_factor = match col(&time_index_column)
-                .get_type(normalize.schema())
-                .context(DataFusionPlanningSnafu)?
-            {
-                ArrowDataType::Timestamp(ArrowTimeUnit::Second, _) => (1_000_i128, 4, 0),
-                ArrowDataType::Timestamp(ArrowTimeUnit::Millisecond, _) => (1, 1, 0),
-                ArrowDataType::Timestamp(ArrowTimeUnit::Microsecond, _) => (1, 4, 3),
-                ArrowDataType::Timestamp(ArrowTimeUnit::Nanosecond, _) => (1, 7, 6),
-                _ => unreachable!("time index is a timestamp"),
-            };
-            let sample_time = col(&time_index_column)
-                .cast_to(&ArrowDataType::Int64, normalize.schema())
-                .context(DataFusionPlanningSnafu)?
-                .cast_to(&ArrowDataType::Decimal128(19, 0), normalize.schema())
-                .context(DataFusionPlanningSnafu)?;
-            let sample_time = DfExpr::BinaryExpr(BinaryExpr {
-                left: Box::new(sample_time),
-                op: Operator::Multiply,
-                right: Box::new(lit(ScalarValue::Decimal128(
-                    Some(unit_factor.0),
-                    unit_factor.1,
-                    unit_factor.2,
-                ))),
-            });
-            let sample_time = DfExpr::BinaryExpr(BinaryExpr {
-                left: Box::new(sample_time),
-                op: Operator::Plus,
-                right: Box::new(lit(ScalarValue::Decimal128(Some(offset_ms as i128), 19, 0))),
-            })
-            .cast_to(&ArrowDataType::Int64, normalize.schema())
-            .context(DataFusionPlanningSnafu)?
-            .cast_to(&ArrowDataType::Float64, normalize.schema())
-            .context(DataFusionPlanningSnafu)?;
-            let sample_time = DfExpr::BinaryExpr(BinaryExpr {
-                left: Box::new(sample_time),
-                op: Operator::Divide,
-                right: Box::new(lit(1000.0)),
-            });
+            // The time index still holds the raw sample timestamp here, which is what
+            // `timestamp()` reports regardless of `offset` and `@`.
+            let sample_time = Self::timestamp_seconds_expr(&time_index_column, normalize.schema())?;
             project_exprs.push(sample_time.alias(&timestamp_value_column));
             let normalize = LogicalPlanBuilder::from(normalize)
                 .project(project_exprs)
@@ -1812,40 +2058,51 @@ impl PromPlanner {
             }),
         };
         if let Some(timestamp_value_column) = timestamp_value_column {
-            self.create_timestamp_func_plan(manipulate, &timestamp_value_column)
+            self.create_timestamp_func_plan(manipulate, ident(timestamp_value_column))
         } else {
             Ok(manipulate)
         }
     }
 
-    /// Builds a projection plan for the PromQL `timestamp()` function.
-    /// Projects the time index column as the value column for each row.
+    /// Converts the timestamp column `column` into PromQL seconds, truncated to milliseconds.
+    fn timestamp_seconds_expr(column: &str, schema: &DFSchema) -> Result<DfExpr> {
+        let column = DfExpr::Column(Column::from_name(column));
+        let ArrowDataType::Timestamp(_, timezone) =
+            column.get_type(schema).context(DataFusionPlanningSnafu)?
+        else {
+            unreachable!("time index is a timestamp")
+        };
+        let millis = column
+            .cast_to(
+                &ArrowDataType::Timestamp(ArrowTimeUnit::Millisecond, timezone),
+                schema,
+            )
+            .context(DataFusionPlanningSnafu)?
+            .cast_to(&ArrowDataType::Int64, schema)
+            .context(DataFusionPlanningSnafu)?
+            .cast_to(&ArrowDataType::Float64, schema)
+            .context(DataFusionPlanningSnafu)?;
+        Ok(DfExpr::BinaryExpr(BinaryExpr {
+            left: Box::new(millis),
+            op: Operator::Divide,
+            right: Box::new(lit(1000.0)),
+        }))
+    }
+
+    /// Builds a projection plan for the PromQL `timestamp()` function, which reports
+    /// `timestamp_value` as the value of each row, along with the original tag and time index
+    /// columns.
     ///
-    /// # Arguments
-    /// * `input` - Input [`LogicalPlan`] after instant-vector selection.
-    /// * `timestamp_value_column` - Private column containing each selected sample's timestamp.
-    ///
-    /// # Returns
-    /// Returns a [`Result<LogicalPlan>`] where the resulting logical plan projects the timestamp
-    /// column as the value column, along with the original tag and time index columns.
-    ///
-    /// # Timestamp vs. Time Function
-    ///
-    /// - **Timestamp Function (`timestamp()`)**: In PromQL, the `timestamp()` function returns the
-    ///   timestamp (time index) of each sample as the value column.
-    ///
-    /// - **Time Function (`time()`)**: The `time()` function returns the evaluation time of the query
-    ///   as a scalar value.
-    ///
-    /// # Side Effects
     /// Updates the planner context's field columns to the timestamp column name.
-    ///
     fn create_timestamp_func_plan(
         &mut self,
         input: LogicalPlan,
-        timestamp_value_column: &str,
+        timestamp_value: DfExpr,
     ) -> Result<LogicalPlan> {
-        let time_expr = col(timestamp_value_column).alias(DEFAULT_FIELD_COLUMN);
+        // A row whose fields are all NULL holds no sample, so it must not get a timestamp. The
+        // check reads the input fields, which the projection below replaces.
+        let has_sample = self.create_empty_values_filter_expr(true)?;
+        let time_expr = timestamp_value.alias(DEFAULT_FIELD_COLUMN);
         self.ctx.field_columns = vec![time_expr.schema_name().to_string()];
         let mut project_exprs = Vec::with_capacity(self.ctx.tag_columns.len() + 2);
         project_exprs.push(self.create_time_index_column_expr()?);
@@ -1853,6 +2110,8 @@ impl PromPlanner {
         project_exprs.extend(self.create_tag_column_exprs()?);
 
         LogicalPlanBuilder::from(input)
+            .filter(has_sample)
+            .context(DataFusionPlanningSnafu)?
             .project(project_exprs)
             .context(DataFusionPlanningSnafu)?
             .build()
@@ -1995,9 +2254,31 @@ impl PromPlanner {
 
         // transform function arguments
         let args = self.create_function_args(&args.args)?;
+        // Only a vector selector keeps the timestamps of its samples. Any other expression
+        // produces samples at the evaluation time, which is what `timestamp()` reports for it.
+        let mut timestamp_arg = args.input.as_ref();
+        while let Some(PromExpr::Paren(ParenExpr { expr })) = timestamp_arg {
+            timestamp_arg = Some(expr);
+        }
+        let timestamp_of_selector =
+            func.name == "timestamp" && matches!(timestamp_arg, Some(PromExpr::VectorSelector(_)));
         let input = if let Some(prom_expr) = &args.input {
-            self.prom_expr_to_plan_inner(prom_expr, func.name == "timestamp", query_engine_state)
-                .await?
+            let input = self
+                .prom_expr_to_plan_inner(prom_expr, timestamp_of_selector, query_engine_state)
+                .await?;
+            if func.name == "timestamp" && !timestamp_of_selector {
+                let time_index_column =
+                    self.ctx
+                        .time_index_column
+                        .clone()
+                        .with_context(|| TimeIndexNotFoundSnafu {
+                            table: self.ctx.table_name.clone().unwrap_or_default(),
+                        })?;
+                let eval_time = Self::timestamp_seconds_expr(&time_index_column, input.schema())?;
+                self.create_timestamp_func_plan(input, eval_time)?
+            } else {
+                input
+            }
         } else {
             self.ctx.time_index_column = Some(SPECIAL_TIME_FUNCTION.to_string());
             self.ctx.reset_table_name_and_schema();
@@ -2023,6 +2304,7 @@ impl PromPlanner {
         // `create_function_expr`: the function that reads it (`predict_linear`) then depends on an
         // argument instead of on planner state written by the selector below it.
         let range_fold_offset = self.ctx.range_fold_offset.take();
+        let input_tag_columns = self.ctx.tag_columns.clone();
         let (mut func_exprs, new_tags) = self.create_function_expr(
             func,
             args.literals.clone(),
@@ -2074,13 +2356,31 @@ impl PromPlanner {
             _ => builder,
         };
 
+        // Rewriting a label the input series already have can map several of them onto the same
+        // label set, which PromQL rejects. A new label keeps the series distinct.
+        let may_duplicate_label_sets = matches!(func.name, "label_join" | "label_replace")
+            && new_tags.iter().any(|tag| input_tag_columns.contains(tag));
+
         // Update context tags after building plan
         // We can't push them before planning, because they won't exist until projection.
         for tag in new_tags {
             self.ctx.tag_columns.push(tag);
         }
 
-        let plan = builder.build().context(DataFusionPlanningSnafu)?;
+        let mut plan = builder.build().context(DataFusionPlanningSnafu)?;
+        if may_duplicate_label_sets {
+            let labels = self.ctx.tag_columns.clone();
+            plan = Self::assert_unique_match_group(
+                plan,
+                labels
+                    .iter()
+                    .map(|label| DfExpr::Column(Column::from_name(label)))
+                    .collect(),
+                labels,
+                self.create_time_index_column_expr()?,
+                MatchGroupViolation::DuplicateLabelSet,
+            )?;
+        }
         common_telemetry::debug!("Created PromQL function plan: {plan:?} for {call_expr:?}");
 
         Ok(plan)
@@ -2095,7 +2395,7 @@ impl PromPlanner {
         let expr = &ext_expr.expr;
         let children = expr.children();
         let plan = self
-            .prom_expr_to_plan(&children[0], query_engine_state)
+            .prom_root_expr_to_plan(&children[0], query_engine_state)
             .await?;
         // Wrapper for the explanation/analyze of the existing plan
         // https://docs.rs/datafusion-expr/latest/datafusion_expr/logical_plan/builder/struct.LogicalPlanBuilder.html#method.explain
@@ -2475,7 +2775,7 @@ impl PromPlanner {
                 // collect remaining fields and convert to col expr
                 let mut exprs = all_fields
                     .into_iter()
-                    .map(|c| DfExpr::Column(Column::from(c)))
+                    .map(|c| DfExpr::Column(Column::from_name(c)))
                     .collect::<Vec<_>>();
 
                 // add timestamp column
@@ -2507,28 +2807,21 @@ impl PromPlanner {
             // for it, or the column exists but is NULL on that row — the latter
             // is the norm for logical metrics sharing a physical table, which
             // holds the union of their label columns.
+            let mut null_label = None;
             let col = if let Some(column_name) = column_name {
                 let column = DfExpr::Column(Column::from_name(&column_name));
                 let field = table_schema
                     .index_of_column_by_name(None, &column_name)
                     .map(|index| table_schema.field(index));
                 if accepts_empty
-                    && let Some(data_type) = field
-                        .filter(|field| {
-                            field.is_nullable()
-                                && Self::string_value_data_type(field.data_type()).is_some()
-                        })
-                        .map(|field| field.data_type())
-                {
-                    let empty = Self::string_scalar_value(data_type, Some(String::new()))
-                        .expect("nullable label has a string type");
-                    DfExpr::ScalarFunction(ScalarFunction {
-                        func: coalesce(),
-                        args: vec![column, DfExpr::Literal(empty, None)],
+                    && field.is_some_and(|field| {
+                        field.is_nullable()
+                            && Self::string_value_data_type(field.data_type()).is_some()
                     })
-                } else {
-                    column
+                {
+                    null_label = Some(column.clone().is_null());
                 }
+                column
             } else {
                 DfExpr::Literal(ScalarValue::Utf8(Some(String::new())), None)
             };
@@ -2581,6 +2874,10 @@ impl PromPlanner {
                     }
                 }
             };
+            let expr = match null_label {
+                Some(null_label) => null_label.or(expr),
+                None => expr,
+            };
             exprs.push(expr);
         }
 
@@ -3586,6 +3883,7 @@ impl PromPlanner {
                 let (concat_expr, dst_label) = Self::build_concat_labels_expr(
                     &mut other_input_exprs,
                     &self.ctx,
+                    input_schema,
                     query_engine_state,
                 )?;
 
@@ -3607,8 +3905,8 @@ impl PromPlanner {
             }
             "label_replace" => {
                 self.ctx.use_tsid = false;
-                if let Some((replace_expr, dst_label)) = self
-                    .build_regexp_replace_label_expr(&mut other_input_exprs, query_engine_state)?
+                if let Some((replace_expr, dst_label)) =
+                    self.build_regexp_replace_label_expr(&mut other_input_exprs, input_schema)?
                 {
                     // Reserve the current field columns except the `dst_label`.
                     for value in &self.ctx.field_columns {
@@ -3618,10 +3916,8 @@ impl PromPlanner {
                         }
                     }
 
-                    ensure!(
-                        !self.ctx.tag_columns.contains(&dst_label),
-                        SameLabelSetSnafu
-                    );
+                    // Remove it from tag columns if exists to avoid duplicated column names
+                    self.ctx.tag_columns.retain(|tag| *tag != dst_label);
                     new_tags.push(dst_label);
                     // Add the new label expr to evaluate
                     exprs.push(replace_expr);
@@ -3668,10 +3964,14 @@ impl PromPlanner {
             }
             "round" => {
                 if other_input_exprs.is_empty() {
-                    other_input_exprs.push_front(0.0f64.lit());
+                    other_input_exprs.push_front(1.0f64.lit());
                 }
                 ScalarFunc::DataFusionUdf(Arc::new(Round::scalar_udf()))
             }
+            // DataFusion's `sqrt` rejects negative input; PromQL returns NaN for it.
+            "sqrt" if !self.all_field_columns_are_native_histograms(input_schema) => {
+                ScalarFunc::DataFusionUdf(Arc::new(IeeeSqrt::scalar_udf()))
+            }
             "rad" | "deg" | "sgn" if self.all_field_columns_are_native_histograms(input_schema) => {
                 ScalarFunc::DataFusionUdf(native_histogram_drop_udf(func.name))
             }
@@ -3930,7 +4230,7 @@ impl PromPlanner {
     fn build_regexp_replace_label_expr(
         &self,
         other_input_exprs: &mut VecDeque<DfExpr>,
-        query_engine_state: &QueryEngineState,
+        input_schema: &DFSchemaRef,
     ) -> Result<Option<(DfExpr, String)>> {
         // label_replace(vector, dst_label, replacement, src_label, regex)
         let dst_label = match other_input_exprs.pop_front() {
@@ -3966,72 +4266,64 @@ impl PromPlanner {
             .fail()?,
         };
 
-        // Validate the regex before using it
+        // Like Prometheus, match the whole source value. A series whose source value matches gets
+        // `dst_label` set to the expanded replacement; any other series is left unchanged.
         // doc: https://prometheus.io/docs/prometheus/latest/querying/functions/#label_replace
-        regex::Regex::new(&regex).map_err(|_| {
-            InvalidRegularExpressionSnafu {
-                regex: regex.clone(),
-            }
-            .build()
-        })?;
+        let anchored = format!("^(?s:{regex})$");
+        let compiled = regex::Regex::new(&anchored)
+            .map_err(|_| InvalidRegularExpressionSnafu { regex }.build())?;
+        let dst_exists = self.ctx.tag_columns.contains(&dst_label);
 
-        // If the src_label exists and regex is empty, keep everything unchanged.
-        if self.ctx.tag_columns.contains(&src_label) && regex.is_empty() {
-            return Ok(None);
-        }
-
-        // If the src_label doesn't exists, and
+        // A missing source label reads as the empty string for every series, so the result is
+        // the same for all of them and is decided here.
         if !self.ctx.tag_columns.contains(&src_label) {
-            if replacement.is_empty() {
-                // the replacement is empty, keep everything unchanged.
+            let Some(captures) = compiled.captures("") else {
                 return Ok(None);
-            } else {
-                // the replacement is not empty, always adds dst_label with replacement value.
+            };
+            let mut value = String::new();
+            captures.expand(&replacement, &mut value);
+            if value.is_empty() {
+                // Setting a label to the empty string removes it, which is a no-op for a new
+                // label.
+                if !dst_exists {
+                    return Ok(None);
+                }
                 return Ok(Some((
-                    // alias literal `replacement` as dst_label
-                    lit(replacement).alias(&dst_label),
+                    lit(ScalarValue::Utf8(None)).alias(&dst_label),
                     dst_label,
                 )));
             }
+            return Ok(Some((lit(value).alias(&dst_label), dst_label)));
         }
 
-        // Preprocess the regex:
-        // https://github.com/prometheus/prometheus/blob/d902abc50d6652ba8fe9a81ff8e5cce936114eba/promql/functions.go#L1575C32-L1575C37
-        let regex = format!("^(?s:{regex})$");
+        let src = Self::label_value_expr(&src_label, input_schema)?;
+        let matched = DfExpr::ScalarFunction(ScalarFunction {
+            func: datafusion_functions::regex::regexp_like(),
+            args: vec![src.clone(), lit(anchored.clone())],
+        });
+        let replaced = Self::empty_label_to_null(DfExpr::ScalarFunction(ScalarFunction {
+            func: datafusion_functions::regex::regexp_replace(),
+            args: vec![src, lit(anchored), lit(replacement)],
+        }));
+        let unchanged = if dst_exists {
+            DfExpr::Column(Column::from_name(&dst_label))
+                .cast_to(&ArrowDataType::Utf8, input_schema)
+                .context(DataFusionPlanningSnafu)?
+        } else {
+            lit(ScalarValue::Utf8(None))
+        };
+        let replace_expr = when(matched, replaced)
+            .otherwise(unchanged)
+            .context(DataFusionPlanningSnafu)?;
 
-        let session_state = query_engine_state.session_state();
-        let func = session_state
-            .scalar_functions()
-            .get("regexp_replace")
-            .context(UnsupportedExprSnafu {
-                name: "regexp_replace",
-            })?;
-
-        // regexp_replace(src_label, regex, replacement)
-        let args = vec![
-            if src_label.is_empty() {
-                DfExpr::Literal(ScalarValue::Utf8(Some(String::new())), None)
-            } else {
-                DfExpr::Column(Column::from_name(src_label))
-            },
-            DfExpr::Literal(ScalarValue::Utf8(Some(regex)), None),
-            DfExpr::Literal(ScalarValue::Utf8(Some(replacement)), None),
-        ];
-
-        Ok(Some((
-            DfExpr::ScalarFunction(ScalarFunction {
-                func: func.clone(),
-                args,
-            })
-            .alias(&dst_label),
-            dst_label,
-        )))
+        Ok(Some((replace_expr.alias(&dst_label), dst_label)))
     }
 
     /// Build expr for `label_join` function
     fn build_concat_labels_expr(
         other_input_exprs: &mut VecDeque<DfExpr>,
         ctx: &PromPlannerContext,
+        input_schema: &DFSchemaRef,
         query_engine_state: &QueryEngineState,
     ) -> Result<(DfExpr, String)> {
         // label_join(vector, dst_label, separator, src_label_1, src_label_2, ...)
@@ -4063,17 +4355,19 @@ impl PromPlanner {
         let src_labels = other_input_exprs
             .iter()
             .map(|expr| {
-                // Cast source label into column or null literal
+                // `concat_ws` skips NULL arguments together with their separator, while an
+                // absent label joins as the empty string.
                 match expr {
                     DfExpr::Literal(ScalarValue::Utf8(Some(label)), None) => {
                         if label.is_empty() {
-                            Ok(DfExpr::Literal(ScalarValue::Null, None))
+                            FunctionInvalidArgumentSnafu {
+                                fn_name: "label_join",
+                            }
+                            .fail()
                         } else if available_columns.contains(label.as_str()) {
-                            // Label exists in the table schema
-                            Ok(DfExpr::Column(Column::from_name(label)))
+                            Self::label_value_expr(label, input_schema)
                         } else {
-                            // Label doesn't exist, treat as empty string (null)
-                            Ok(DfExpr::Literal(ScalarValue::Null, None))
+                            Ok(lit(""))
                         }
                     }
                     other => UnexpectedPlanExprSnafu {
@@ -4086,12 +4380,10 @@ impl PromPlanner {
                 }
             })
             .collect::<Result<Vec<_>>>()?;
-        ensure!(
-            !src_labels.is_empty(),
-            FunctionInvalidArgumentSnafu {
-                fn_name: "label_join"
-            }
-        );
+        // Joining no labels yields the empty string, i.e. removes `dst_label`.
+        if src_labels.is_empty() {
+            return Ok((lit(ScalarValue::Utf8(None)).alias(&dst_label), dst_label));
+        }
 
         let session_state = query_engine_state.session_state();
         let func = session_state
@@ -4105,15 +4397,37 @@ impl PromPlanner {
         args.extend(src_labels);
 
         Ok((
-            DfExpr::ScalarFunction(ScalarFunction {
+            Self::empty_label_to_null(DfExpr::ScalarFunction(ScalarFunction {
                 func: func.clone(),
                 args,
-            })
+            }))
             .alias(&dst_label),
             dst_label,
         ))
     }
 
+    /// The value of `label` as a string, where NULL (the series has no such label) reads as the
+    /// empty string, as in PromQL.
+    fn label_value_expr(label: &str, input_schema: &DFSchemaRef) -> Result<DfExpr> {
+        let value = DfExpr::Column(Column::from_name(label))
+            .cast_to(&ArrowDataType::Utf8, input_schema)
+            .context(DataFusionPlanningSnafu)?;
+        Ok(DfExpr::ScalarFunction(ScalarFunction {
+            func: coalesce(),
+            args: vec![value, lit("")],
+        }))
+    }
+
+    /// An empty label value means the label is absent in PromQL. Label functions represent it
+    /// as NULL, like a series that never had the label, so that both compare equal when label
+    /// sets are matched and neither is reported as a label.
+    fn empty_label_to_null(value: DfExpr) -> DfExpr {
+        DfExpr::ScalarFunction(ScalarFunction {
+            func: datafusion_functions::core::nullif(),
+            args: vec![value, lit("")],
+        })
+    }
+
     fn create_time_index_column_expr(&self) -> Result<DfExpr> {
         Ok(DfExpr::Column(Column::from_name(
             self.ctx
@@ -4365,19 +4679,41 @@ impl PromPlanner {
             vec![]
         };
 
-        // update value column name according to the aggregators,
-        let mut new_field_columns = Vec::with_capacity(self.ctx.field_columns.len());
+        // The alias is built from normalized columns so it matches the builtin's
+        // qualified name.
+        let exprs = normalize_cols(exprs, input_plan)
+            .context(DataFusionPlanningSnafu)?
+            .into_iter()
+            .map(Self::alias_extremum_as_builtin)
+            .collect::<Vec<_>>();
 
-        let normalized_exprs =
-            normalize_cols(exprs.iter().cloned(), input_plan).context(DataFusionPlanningSnafu)?;
-        for expr in normalized_exprs {
-            new_field_columns.push(expr.schema_name().to_string());
-        }
-        self.ctx.field_columns = new_field_columns;
+        // update value column name according to the aggregators,
+        self.ctx.field_columns = exprs
+            .iter()
+            .map(|expr| expr.schema_name().to_string())
+            .collect();
 
         Ok((exprs, prev_field_exprs))
     }
 
+    /// `prom_min`/`prom_max` keep their own names so SQL can use them next to `min`/`max`
+    /// in one aggregate. PromQL output columns keep the builtin names.
+    fn alias_extremum_as_builtin(expr: DfExpr) -> DfExpr {
+        let DfExpr::AggregateFunction(aggr) = &expr else {
+            return expr;
+        };
+        let builtin = match aggr.func.name() {
+            Extremum::MIN_NAME => min_udaf(),
+            Extremum::MAX_NAME => max_udaf(),
+            _ => return expr,
+        };
+        let name = builtin
+            .call(aggr.params.args.clone())
+            .schema_name()
+            .to_string();
+        expr.alias(name)
+    }
+
     fn create_numeric_aggregate_expr(
         op: TokenType,
         param: &Option<Box<PromExpr>>,
@@ -4395,8 +4731,8 @@ impl PromPlanner {
             }
             token::T_AVG => avg_udaf().call(vec![input]),
             token::T_COUNT_VALUES | token::T_COUNT => count_udaf().call(vec![input]),
-            token::T_MIN => min_udaf().call(vec![input]),
-            token::T_MAX => max_udaf().call(vec![input]),
+            token::T_MIN => Extremum::min_udaf().call(vec![input]),
+            token::T_MAX => Extremum::max_udaf().call(vec![input]),
             // PromQL's `group()` aggregator produces 1 for each group.
             // Use `max(1.0)` (per-group) to match semantics and output type (Float64).
             token::T_GROUP => max_udaf().call(vec![lit(1_f64)]),
@@ -4740,9 +5076,17 @@ impl PromPlanner {
             .field_columns
             .iter()
             .map(|col| {
-                let mut sort_exprs = Vec::with_capacity(self.ctx.tag_columns.len() + 1);
+                let mut sort_exprs = Vec::with_capacity(self.ctx.tag_columns.len() + 2);
+                // PromQL ranks NaN last for both `topk` and `bottomk`, while DataFusion
+                // orders NaN above every number.
+                sort_exprs.push(
+                    datafusion_functions::math::expr_fn::isnan(DfExpr::Column(Column::from_name(
+                        col,
+                    )))
+                    .sort(true, true),
+                );
                 // Order by value in the specific order
-                sort_exprs.push(DfExpr::Column(Column::from(col)).sort(asc, true));
+                sort_exprs.push(DfExpr::Column(Column::from_name(col)).sort(asc, true));
                 // Then tags if the values are equal,
                 // Try to ensure the relative stability of the output results.
                 sort_exprs.extend(tag_sort_exprs.clone());
@@ -4931,12 +5275,24 @@ impl PromPlanner {
             token::T_MOD => Ok(Box::new(move |lhs: DfExpr, rhs| {
                 Ok(cast_float(lhs) % cast_float(rhs))
             })),
-            token::T_EQLC => Ok(Box::new(|lhs, rhs| Ok(lhs.eq(rhs)))),
-            token::T_NEQ => Ok(Box::new(|lhs, rhs| Ok(lhs.not_eq(rhs)))),
-            token::T_GTR => Ok(Box::new(|lhs, rhs| Ok(lhs.gt(rhs)))),
-            token::T_LSS => Ok(Box::new(|lhs, rhs| Ok(lhs.lt(rhs)))),
-            token::T_GTE => Ok(Box::new(|lhs, rhs| Ok(lhs.gt_eq(rhs)))),
-            token::T_LTE => Ok(Box::new(|lhs, rhs| Ok(lhs.lt_eq(rhs)))),
+            token::T_EQLC => Ok(Box::new(|lhs, rhs| {
+                Ok(Self::ieee_comparison(lhs, Operator::Eq, rhs))
+            })),
+            token::T_NEQ => Ok(Box::new(|lhs, rhs| {
+                Ok(Self::ieee_comparison(lhs, Operator::NotEq, rhs))
+            })),
+            token::T_GTR => Ok(Box::new(|lhs, rhs| {
+                Ok(Self::ieee_comparison(lhs, Operator::Gt, rhs))
+            })),
+            token::T_LSS => Ok(Box::new(|lhs, rhs| {
+                Ok(Self::ieee_comparison(lhs, Operator::Lt, rhs))
+            })),
+            token::T_GTE => Ok(Box::new(|lhs, rhs| {
+                Ok(Self::ieee_comparison(lhs, Operator::GtEq, rhs))
+            })),
+            token::T_LTE => Ok(Box::new(|lhs, rhs| {
+                Ok(Self::ieee_comparison(lhs, Operator::LtEq, rhs))
+            })),
             token::T_POW => Ok(Box::new(move |lhs, rhs| {
                 Ok(DfExpr::ScalarFunction(ScalarFunction {
                     func: datafusion_functions::math::power(),
@@ -4953,6 +5309,14 @@ impl PromPlanner {
         }
     }
 
+    /// Compares two expressions with IEEE 754 semantics, as PromQL does; see [`IeeeComparison`].
+    fn ieee_comparison(lhs: DfExpr, op: Operator, rhs: DfExpr) -> DfExpr {
+        DfExpr::ScalarFunction(ScalarFunction {
+            func: Arc::new(IeeeComparison::scalar_udf(op)),
+            args: vec![lhs, rhs],
+        })
+    }
+
     /// Check if the given op is a [comparison operator](https://prometheus.io/docs/prometheus/latest/querying/operators/#comparison-binary-operators).
     fn is_token_a_comparison_op(token: TokenType) -> bool {
         matches!(
@@ -5515,7 +5879,7 @@ impl PromPlanner {
             .collect::<Vec<_>>();
         let assert_expr = DfExpr::ScalarFunction(ScalarFunction {
             func: Arc::new(UniqueMatchGroup::scalar_udf(group_labels, violation)),
-            args: std::iter::once(col(count_column.as_str()))
+            args: std::iter::once(ident(count_column.as_str()))
                 .chain(group_exprs)
                 .collect(),
         });
@@ -6154,7 +6518,7 @@ impl PromPlanner {
     /// Generate an expr like `date_part("hour", <TIME_INDEX>)`. Caller should ensure the
     /// time index column in context is set
     fn date_part_on_time_index(&self, date_part: &str) -> Result<DfExpr> {
-        let input_expr = datafusion::logical_expr::col(
+        let input_expr = datafusion::logical_expr::ident(
             self.ctx
                 .time_index_column
                 .as_ref()
diff --git a/src/query/src/promql/planner/at_modifier.rs b/src/query/src/promql/planner/at_modifier.rs
index bde7c51bcb1..545f1714a22 100644
--- a/src/query/src/promql/planner/at_modifier.rs
+++ b/src/query/src/promql/planner/at_modifier.rs
@@ -41,7 +41,7 @@ impl PromPlanner {
     /// - `offset` shifts the anchor backwards: the window ends at `anchor - offset`.
     ///
     /// Returns `None` when the selector has no `@` modifier.
-    fn at_ref_time(
+    pub(crate) fn at_ref_time(
         &self,
         at: &Option<AtModifier>,
         offset: &Option<Offset>,
diff --git a/src/query/src/promql/planner/function_plans.rs b/src/query/src/promql/planner/function_plans.rs
index 68a254dd2bc..4723fe35232 100644
--- a/src/query/src/promql/planner/function_plans.rs
+++ b/src/query/src/promql/planner/function_plans.rs
@@ -28,7 +28,7 @@ use datafusion::scalar::ScalarValue;
 use datafusion_common::DFSchema;
 use datafusion_expr::expr_fn::when;
 use datafusion_expr::simplify::SimplifyContext;
-use datafusion_expr::{col, lit};
+use datafusion_expr::{ident, lit};
 use datafusion_functions::core::coalesce;
 use datatypes::arrow::datatypes::DataType as ArrowDataType;
 use promql::extension_plan::{
@@ -253,12 +253,12 @@ impl PromPlanner {
                 "vector contains a mix of classic and native histograms".to_string(),
                 self.promql_annotations.clone(),
             )),
-            args: vec![col(&float_field), col(&histogram_field)],
+            args: vec![ident(&float_field), ident(&histogram_field)],
         });
         let keep = when(
-            col(&float_field)
+            ident(&float_field)
                 .is_not_null()
-                .and(col(&histogram_field).is_not_null()),
+                .and(ident(&histogram_field).is_not_null()),
             record_collision,
         )
         .otherwise(lit(true))
@@ -268,7 +268,7 @@ impl PromPlanner {
         let output_field = native_expr.schema_name().to_string();
         let value = DfExpr::ScalarFunction(ScalarFunction {
             func: coalesce(),
-            args: vec![col(&float_field), native_expr],
+            args: vec![ident(&float_field), native_expr],
         });
         self.ctx.field_columns = vec![output_field.clone()];
         LogicalPlanBuilder::from(LogicalPlan::Extension(Extension {
@@ -277,9 +277,9 @@ impl PromPlanner {
         .filter(keep)
         .context(DataFusionPlanningSnafu)?
         .project(
-            std::iter::once(col(&time_index_column))
+            std::iter::once(ident(&time_index_column))
                 .chain(std::iter::once(value.alias(output_field)))
-                .chain(tag_columns.iter().map(col)),
+                .chain(tag_columns.iter().map(ident)),
         )
         .context(DataFusionPlanningSnafu)?
         .build()
diff --git a/src/query/src/promql/planner/set_operator.rs b/src/query/src/promql/planner/set_operator.rs
index 51cc100408f..7a14ff38ad4 100644
--- a/src/query/src/promql/planner/set_operator.rs
+++ b/src/query/src/promql/planner/set_operator.rs
@@ -764,6 +764,7 @@ impl PromPlanner {
         let join_keys = left_tag_col_set
             .into_iter()
             .chain([left_time_index])
+            .map(Column::from_name)
             .collect::<Vec<_>>();
 
         ensure!(
diff --git a/src/query/src/promql/planner/test.rs b/src/query/src/promql/planner/test.rs
index a83a42bae53..ae40640b50b 100644
--- a/src/query/src/promql/planner/test.rs
+++ b/src/query/src/promql/planner/test.rs
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use std::collections::HashMap;
-use std::time::{Duration, UNIX_EPOCH};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use catalog::RegisterTableRequest;
 use catalog::memory::{MemoryCatalogManager, new_memory_catalog_manager};
@@ -36,7 +36,7 @@ use datafusion::datasource::memory::MemorySourceConfig;
 use datafusion::datasource::source::DataSourceExec;
 use datafusion::datasource::{MemTable, provider_as_source};
 use datafusion::execution::context::SessionContext;
-use datafusion::logical_expr::Extension;
+use datafusion::logical_expr::{Extension, col};
 use datatypes::prelude::ConcreteDataType;
 use datatypes::schema::{ColumnSchema, Schema};
 use promql::extension_plan::HistogramFold;
@@ -1210,8 +1210,10 @@ fn classic_and_native_histogram_table_provider(
     let table_name = "mixed_histogram";
     let catalog = MemoryCatalogManager::with_default_setup();
     let schema = Arc::new(Schema::new(vec![
+        // A dotted tag name guards the mixed histogram_quantile projection
+        // against qualified-name parsing (#9390).
         ColumnSchema::new(
-            "tag".to_string(),
+            "service.name".to_string(),
             ConcreteDataType::string_datatype(),
             false,
         ),
@@ -1677,7 +1679,18 @@ async fn single_sort_desc() {
 
 #[tokio::test]
 async fn single_sqrt() {
-    do_single_instant_function_call("sqrt", "sqrt").await;
+    // Negative input is mapped to NaN before DataFusion's `sqrt`, which rejects it.
+    indie_query_plan_compare(
+        r#"sqrt(some_metric{tag_0!="bar"})"#,
+        "Filter: sqrt(field_0) IS NOT NULL [timestamp:Timestamp(ms), sqrt(field_0):Float64;N, tag_0:Utf8]\
+            \n  Projection: some_metric.timestamp, prom_sqrt(some_metric.field_0) AS sqrt(field_0), some_metric.tag_0 [timestamp:Timestamp(ms), sqrt(field_0):Float64;N, tag_0:Utf8]\
+            \n    PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[timestamp] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+            \n      PromSeriesDivide: tags=[\"tag_0\"] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+            \n        Sort: some_metric.tag_0 ASC NULLS FIRST, some_metric.timestamp ASC NULLS FIRST [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+            \n          Filter: some_metric.tag_0 != Utf8(\"bar\") AND some_metric.timestamp >= TimestampMillisecond(-999, None) AND some_metric.timestamp <= TimestampMillisecond(100000000, None) [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+            \n            TableScan: some_metric [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]",
+    )
+    .await;
 }
 
 #[tokio::test]
@@ -1697,12 +1710,13 @@ async fn single_timestamp_plan_preserves_source_value() {
         "Filter: value IS NOT NULL [timestamp:Timestamp(ms), value:Float64, tag_0:Utf8]\
             \n  Projection: some_metric.timestamp, value AS value, some_metric.tag_0 [timestamp:Timestamp(ms), value:Float64, tag_0:Utf8]\
             \n    Projection: some_metric.timestamp, __promql_timestamp_value_ AS value, some_metric.tag_0 [timestamp:Timestamp(ms), value:Float64, tag_0:Utf8]\
-            \n      PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[timestamp] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, __promql_timestamp_value_:Float64]\
-            \n        Projection: some_metric.tag_0, some_metric.timestamp, some_metric.field_0, CAST(CAST(CAST(CAST(some_metric.timestamp AS Int64) AS Decimal128(19, 0)) * Decimal128(1,1,0) + Decimal128(0,19,0) AS Int64) AS Float64) / Float64(1000) AS __promql_timestamp_value_ [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, __promql_timestamp_value_:Float64]\
-            \n          PromSeriesDivide: tags=[\"tag_0\"] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
-            \n            Sort: some_metric.tag_0 ASC NULLS FIRST, some_metric.timestamp ASC NULLS FIRST [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
-            \n              Filter: some_metric.tag_0 != Utf8(\"bar\") AND some_metric.timestamp >= TimestampMillisecond(-999, None) AND some_metric.timestamp <= TimestampMillisecond(100000000, None) [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
-            \n                TableScan: some_metric [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]",
+            \n      Filter: some_metric.field_0 IS NOT NULL [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, __promql_timestamp_value_:Float64]\
+            \n        PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[timestamp] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, __promql_timestamp_value_:Float64]\
+            \n          Projection: some_metric.tag_0, some_metric.timestamp, some_metric.field_0, CAST(CAST(some_metric.timestamp AS Int64) AS Float64) / Float64(1000) AS __promql_timestamp_value_ [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, __promql_timestamp_value_:Float64]\
+            \n            PromSeriesDivide: tags=[\"tag_0\"] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+            \n              Sort: some_metric.tag_0 ASC NULLS FIRST, some_metric.timestamp ASC NULLS FIRST [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+            \n                Filter: some_metric.tag_0 != Utf8(\"bar\") AND some_metric.timestamp >= TimestampMillisecond(-999, None) AND some_metric.timestamp <= TimestampMillisecond(100000000, None) [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+            \n                  TableScan: some_metric [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]",
     );
 
     assert_eq!(plan.display_indent_schema().to_string(), expected);
@@ -1808,6 +1822,19 @@ async fn single_rad() {
 //     },
 // },
 async fn do_aggregate_expr_plan(fn_name: &str, plan_name: &str) {
+    do_aggregate_expr_plan_with_display(fn_name, plan_name, plan_name).await;
+}
+
+/// `display_name` is the aggregate function as the plan shows it, `plan_name` the name of the
+/// output column; they differ for PromQL `min`/`max`.
+async fn do_aggregate_expr_plan_with_display(fn_name: &str, plan_name: &str, display_name: &str) {
+    let display = |field: &str| {
+        if display_name == plan_name {
+            format!("{plan_name}({field})")
+        } else {
+            format!("{display_name}({field}) AS {plan_name}({field})")
+        }
+    };
     let prom_expr = parser::parse(&format!(
         "{fn_name} by (tag_1)(some_metric{{tag_0!=\"bar\"}})",
     ))
@@ -1834,13 +1861,16 @@ async fn do_aggregate_expr_plan(fn_name: &str, plan_name: &str) {
         .unwrap();
     let expected_no_without = String::from(
         "Sort: some_metric.tag_1 ASC NULLS LAST, some_metric.timestamp ASC NULLS LAST [tag_1:Utf8, timestamp:Timestamp(ms), TEMPLATE(some_metric.field_0):Float64;N, TEMPLATE(some_metric.field_1):Float64;N]\
-            \n  Aggregate: groupBy=[[some_metric.tag_1, some_metric.timestamp]], aggr=[[TEMPLATE(some_metric.field_0), TEMPLATE(some_metric.field_1)]] [tag_1:Utf8, timestamp:Timestamp(ms), TEMPLATE(some_metric.field_0):Float64;N, TEMPLATE(some_metric.field_1):Float64;N]\
+            \n  Aggregate: groupBy=[[some_metric.tag_1, some_metric.timestamp]], aggr=[[DISPLAY_0, DISPLAY_1]] [tag_1:Utf8, timestamp:Timestamp(ms), TEMPLATE(some_metric.field_0):Float64;N, TEMPLATE(some_metric.field_1):Float64;N]\
             \n    PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[timestamp] [tag_0:Utf8, tag_1:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, field_1:Float64;N]\
             \n      PromSeriesDivide: tags=[\"tag_0\", \"tag_1\"] [tag_0:Utf8, tag_1:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, field_1:Float64;N]\
             \n        Sort: some_metric.tag_0 ASC NULLS FIRST, some_metric.tag_1 ASC NULLS FIRST, some_metric.timestamp ASC NULLS FIRST [tag_0:Utf8, tag_1:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, field_1:Float64;N]\
             \n          Filter: some_metric.tag_0 != Utf8(\"bar\") AND some_metric.timestamp >= TimestampMillisecond(-999, None) AND some_metric.timestamp <= TimestampMillisecond(100000000, None) [tag_0:Utf8, tag_1:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, field_1:Float64;N]\
             \n            TableScan: some_metric [tag_0:Utf8, tag_1:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, field_1:Float64;N]"
-    ).replace("TEMPLATE", plan_name);
+    )
+    .replace("TEMPLATE", plan_name)
+    .replace("DISPLAY_0", &display("some_metric.field_0"))
+    .replace("DISPLAY_1", &display("some_metric.field_1"));
     assert_eq!(
         plan.display_indent_schema().to_string(),
         expected_no_without
@@ -1863,13 +1893,15 @@ async fn do_aggregate_expr_plan(fn_name: &str, plan_name: &str) {
         .unwrap();
     let expected_without = String::from(
         "Sort: some_metric.tag_0 ASC NULLS LAST, some_metric.timestamp ASC NULLS LAST [tag_0:Utf8, timestamp:Timestamp(ms), TEMPLATE(some_metric.field_0):Float64;N, TEMPLATE(some_metric.field_1):Float64;N]\
-            \n  Aggregate: groupBy=[[some_metric.tag_0, some_metric.timestamp]], aggr=[[TEMPLATE(some_metric.field_0), TEMPLATE(some_metric.field_1)]] [tag_0:Utf8, timestamp:Timestamp(ms), TEMPLATE(some_metric.field_0):Float64;N, TEMPLATE(some_metric.field_1):Float64;N]\
+            \n  Aggregate: groupBy=[[some_metric.tag_0, some_metric.timestamp]], aggr=[[DISPLAY_0, DISPLAY_1]] [tag_0:Utf8, timestamp:Timestamp(ms), TEMPLATE(some_metric.field_0):Float64;N, TEMPLATE(some_metric.field_1):Float64;N]\
             \n    PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[timestamp] [tag_0:Utf8, tag_1:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, field_1:Float64;N]\
             \n      PromSeriesDivide: tags=[\"tag_0\", \"tag_1\"] [tag_0:Utf8, tag_1:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, field_1:Float64;N]\
             \n        Sort: some_metric.tag_0 ASC NULLS FIRST, some_metric.tag_1 ASC NULLS FIRST, some_metric.timestamp ASC NULLS FIRST [tag_0:Utf8, tag_1:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, field_1:Float64;N]\
             \n          Filter: some_metric.tag_0 != Utf8(\"bar\") AND some_metric.timestamp >= TimestampMillisecond(-999, None) AND some_metric.timestamp <= TimestampMillisecond(100000000, None) [tag_0:Utf8, tag_1:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, field_1:Float64;N]\
             \n            TableScan: some_metric [tag_0:Utf8, tag_1:Utf8, timestamp:Timestamp(ms), field_0:Float64;N, field_1:Float64;N]"
-    ).replace("TEMPLATE", plan_name);
+    ).replace("TEMPLATE", plan_name)
+    .replace("DISPLAY_0", &display("some_metric.field_0"))
+    .replace("DISPLAY_1", &display("some_metric.field_1"));
     assert_eq!(plan.display_indent_schema().to_string(), expected_without);
 }
 
@@ -2411,9 +2443,9 @@ async fn at_modifier_keeps_multi_series_roots_out_of_promoted_subtree() {
 async fn at_modifier_does_not_promote_label_join() {
     for query in [
         // Directly above the anchored instant selector...
-        "label_join(some_metric @ 300, \"tag_0\", \"-\", \"\")",
+        "label_join(some_metric @ 300, \"tag_0\", \"-\", \"tag_0\", \"tag_0\")",
         // ... and below another call, which is planned as usual over the join.
-        "abs(label_join(some_metric @ 300, \"tag_0\", \"-\", \"\"))",
+        "abs(label_join(some_metric @ 300, \"tag_0\", \"-\", \"tag_0\", \"tag_0\"))",
     ] {
         let plan = build_at_modifier_plan(query, 0, 1000).await;
         let plan_str = plan.display_indent_schema().to_string();
@@ -2446,7 +2478,7 @@ async fn at_modifier_does_not_promote_label_join() {
     // A range call below the join is still promoted on its own: the anchored window is folded
     // once per series, and the join above it is evaluated at every step over that replay.
     let plan = build_at_modifier_plan(
-        "label_join(rate(some_metric[5m] @ 300), \"tag_0\", \"-\", \"\")",
+        "label_join(rate(some_metric[5m] @ 300), \"tag_0\", \"-\", \"tag_0\", \"tag_0\")",
         0,
         1000,
     )
@@ -3294,7 +3326,7 @@ async fn comparison_binary_join_uses_tsid_and_keeps_it_in_filtered_result() {
     .await;
     let mut planner = PromPlanner {
         table_provider,
-        ctx: PromPlannerContext::from_eval_stmt(&eval_stmt),
+        ctx: PromPlannerContext::from_eval_stmt(&eval_stmt).unwrap(),
         promql_annotations: None,
     };
     let plan = planner
@@ -3895,12 +3927,12 @@ async fn aggregate_count() {
 
 #[tokio::test]
 async fn aggregate_min() {
-    do_aggregate_expr_plan("min", "min").await;
+    do_aggregate_expr_plan_with_display("min", "min", "prom_min").await;
 }
 
 #[tokio::test]
 async fn aggregate_max() {
-    do_aggregate_expr_plan("max", "max").await;
+    do_aggregate_expr_plan_with_display("max", "max", "prom_max").await;
 }
 
 #[tokio::test]
@@ -4078,7 +4110,7 @@ async fn binary_op_literal_literal() {
 async fn simple_bool_grammar() {
     let query = "some_metric != bool 1.2345";
     let expected = String::from(
-        "Projection: some_metric.tag_0, some_metric.timestamp, CAST(some_metric.field_0 != Float64(1.2345) AS Float64) AS field_0 != Float64(1.2345) [tag_0:Utf8, timestamp:Timestamp(ms), field_0 != Float64(1.2345):Float64;N]\
+        "Projection: some_metric.tag_0, some_metric.timestamp, CAST(prom_ne(some_metric.field_0, Float64(1.2345)) AS Float64) AS field_0 != Float64(1.2345) [tag_0:Utf8, timestamp:Timestamp(ms), field_0 != Float64(1.2345):Float64;N]\
             \n  PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[timestamp] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
             \n    PromSeriesDivide: tags=[\"tag_0\"] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
             \n      Sort: some_metric.tag_0 ASC NULLS FIRST, some_metric.timestamp ASC NULLS FIRST [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
@@ -4093,7 +4125,7 @@ async fn simple_bool_grammar() {
 async fn bool_with_additional_arithmetic() {
     let query = "some_metric + (1 == bool 2)";
     let expected = String::from(
-        "Projection: some_metric.tag_0, some_metric.timestamp, CAST(some_metric.field_0 AS Float64) + CAST(Float64(1) = Float64(2) AS Float64) AS field_0 + Float64(1) = Float64(2) [tag_0:Utf8, timestamp:Timestamp(ms), field_0 + Float64(1) = Float64(2):Float64;N]\
+        "Projection: some_metric.tag_0, some_metric.timestamp, CAST(some_metric.field_0 AS Float64) + CAST(prom_eq(Float64(1), Float64(2)) AS Float64) AS field_0 + Float64(1) = Float64(2) [tag_0:Utf8, timestamp:Timestamp(ms), field_0 + Float64(1) = Float64(2):Float64;N]\
             \n  PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[timestamp] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
             \n    PromSeriesDivide: tags=[\"tag_0\"] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
             \n      Sort: some_metric.tag_0 ASC NULLS FIRST, some_metric.timestamp ASC NULLS FIRST [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
@@ -4386,7 +4418,7 @@ async fn mixed_histogram_helpers_execute_classic_and_native_samples() {
             .iter()
             .flat_map(|batch| {
                 let tags = batch
-                    .column_by_name("tag")
+                    .column_by_name("service.name")
                     .unwrap()
                     .as_any()
                     .downcast_ref::<StringArray>()
@@ -5061,7 +5093,7 @@ async fn native_histogram_mixed_field_table_behaves() {
 async fn less_filter_on_value() {
     let query = "some_metric < 1.2345";
     let expected = String::from(
-        "Filter: some_metric.field_0 < Float64(1.2345) [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+        "Filter: prom_lt(some_metric.field_0, Float64(1.2345)) [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
             \n  PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[timestamp] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
             \n    PromSeriesDivide: tags=[\"tag_0\"] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
             \n      Sort: some_metric.tag_0 ASC NULLS FIRST, some_metric.timestamp ASC NULLS FIRST [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
@@ -5109,6 +5141,619 @@ async fn count_over_time_subquery() {
     indie_query_plan_compare(query, expected).await;
 }
 
+/// `offset` on a subquery must shift the inner evaluation window back and be
+/// carried into the outer range manipulation. See
+/// <https://github.com/GreptimeTeam/greptimedb/issues/9330>.
+#[tokio::test]
+async fn count_over_time_subquery_with_offset() {
+    let query = "count_over_time(some_metric[10m:1m] offset 5m)";
+    let expected = String::from(
+        "Filter: prom_count_over_time(timestamp_range,field_0) IS NOT NULL [timestamp:Timestamp(ms), prom_count_over_time(timestamp_range,field_0):Float64;N, tag_0:Utf8]\
+        \n  Projection: some_metric.timestamp, prom_count_over_time(timestamp_range, field_0) AS prom_count_over_time(timestamp_range,field_0), some_metric.tag_0 [timestamp:Timestamp(ms), prom_count_over_time(timestamp_range,field_0):Float64;N, tag_0:Utf8]\
+        \n    PromRangeManipulate: req range=[0..100000000], interval=[5000], eval range=[600000], time index=[timestamp], values=[\"field_0\"] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Dictionary(Int64, Float64);N, timestamp_range:Dictionary(Int64, Timestamp(ms))]\
+        \n      PromSeriesNormalize: offset=[300000], time index=[timestamp], filter NaN: [false] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+        \n        PromSeriesDivide: tags=[\"tag_0\"] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+        \n          Sort: some_metric.tag_0 ASC NULLS FIRST, some_metric.timestamp ASC NULLS FIRST [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+        \n            PromInstantManipulate: range=[-840000..99700000], lookback=[1000], interval=[60000], time index=[timestamp] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+        \n              PromSeriesDivide: tags=[\"tag_0\"] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+        \n                Sort: some_metric.tag_0 ASC NULLS FIRST, some_metric.timestamp ASC NULLS FIRST [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+        \n                  Filter: some_metric.timestamp >= TimestampMillisecond(-840999, None) AND some_metric.timestamp <= TimestampMillisecond(99700000, None) [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]\
+        \n                    TableScan: some_metric [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]",
+    );
+    indie_query_plan_compare(query, expected).await;
+}
+
+/// Time-varying samples on and off the subquery step grid expose incorrect window folding.
+async fn build_subquery_offset_probe_provider() -> DfTableSourceProvider {
+    let catalog_list = MemoryCatalogManager::with_default_setup();
+    let probe_rows = (0..=6_i64)
+        .map(|step| (step * 10_000, (step + 1) as f64))
+        .collect::<Vec<_>>();
+    let offgrid_rows = (0..6_i64)
+        .map(|step| (step * 10_000 + 5_000, (step + 1) as f64))
+        .collect::<Vec<_>>();
+
+    for (table_id, name, rows) in [
+        (7_001_u32, "subquery_offset_probe", &probe_rows),
+        (7_002_u32, "subquery_offset_offgrid", &offgrid_rows),
+    ] {
+        let schema = Arc::new(Schema::new(vec![
+            ColumnSchema::new(
+                "host".to_string(),
+                ConcreteDataType::string_datatype(),
+                false,
+            ),
+            ColumnSchema::new(
+                "timestamp".to_string(),
+                ConcreteDataType::timestamp_millisecond_datatype(),
+                false,
+            )
+            .with_time_index(true),
+            ColumnSchema::new(
+                "val".to_string(),
+                ConcreteDataType::float64_datatype(),
+                true,
+            ),
+        ]));
+        let batch = RecordBatch::try_new(
+            schema.arrow_schema().clone(),
+            vec![
+                Arc::new(StringArray::from(vec!["a"; rows.len()])),
+                Arc::new(TimestampMillisecondArray::from_iter_values(
+                    rows.iter().map(|(ts, _)| *ts),
+                )),
+                Arc::new(Float64Array::from_iter_values(
+                    rows.iter().map(|(_, value)| *value),
+                )),
+            ],
+        )
+        .unwrap();
+        let backing = GreptimeMemTable::new_with_catalog(
+            name,
+            GreptimeRecordBatch::from_df_record_batch(schema.clone(), batch),
+            table_id,
+            DEFAULT_CATALOG_NAME.to_string(),
+            DEFAULT_SCHEMA_NAME.to_string(),
+        );
+        let table_meta = TableMetaBuilder::empty()
+            .schema(schema)
+            .primary_key_indices(vec![0])
+            .value_indices(vec![2])
+            .next_column_id(3)
+            .build()
+            .unwrap();
+        let table_info = Arc::new(
+            TableInfoBuilder::default()
+                .table_id(table_id)
+                .name(name)
+                .meta(table_meta)
+                .build()
+                .unwrap(),
+        );
+        let table = Arc::new(Table::new(
+            table_info,
+            FilterPushDownType::Unsupported,
+            backing.data_source(),
+        ));
+        assert!(
+            catalog_list
+                .register_table_sync(RegisterTableRequest {
+                    catalog: DEFAULT_CATALOG_NAME.to_string(),
+                    schema: DEFAULT_SCHEMA_NAME.to_string(),
+                    table_name: name.to_string(),
+                    table_id,
+                    table,
+                })
+                .is_ok()
+        );
+    }
+
+    DfTableSourceProvider::new(
+        catalog_list,
+        false,
+        QueryContext::arc(),
+        DummyDecoder::arc(),
+        false,
+    )
+}
+
+/// Plans on a seconds-based evaluation grid.
+async fn plan_subquery_offset_probe(
+    query: &str,
+    start: u64,
+    end: u64,
+    step: u64,
+) -> Result<LogicalPlan> {
+    let eval_stmt = EvalStmt {
+        expr: parser::parse(query).unwrap(),
+        start: UNIX_EPOCH + Duration::from_secs(start),
+        end: UNIX_EPOCH + Duration::from_secs(end),
+        interval: Duration::from_secs(step),
+        lookback_delta: Duration::from_secs(300),
+    };
+    PromPlanner::stmt_to_plan(
+        build_subquery_offset_probe_provider().await,
+        &eval_stmt,
+        &build_query_engine_state(),
+    )
+    .await
+}
+
+/// Evaluates seconds-based bounds and returns sorted `(timestamp_ms, value)` rows.
+async fn run_subquery_offset_probe(
+    query: &str,
+    start: u64,
+    end: u64,
+    step: u64,
+) -> Vec<(i64, f64)> {
+    let state = build_query_engine_state();
+    let plan = plan_subquery_offset_probe(query, start, end, step)
+        .await
+        .unwrap();
+
+    let (_, batches) = execute(plan, &state).await;
+    let mut rows = Vec::new();
+    for batch in &batches {
+        let timestamp_index = batch
+            .schema()
+            .fields()
+            .iter()
+            .position(|field| matches!(field.data_type(), ArrowDataType::Timestamp(..)))
+            .expect("no timestamp column");
+        let value_index = batch
+            .schema()
+            .fields()
+            .iter()
+            .position(|field| field.data_type() == &ArrowDataType::Float64)
+            .expect("no Float64 value column");
+        let timestamps = batch
+            .column(timestamp_index)
+            .as_any()
+            .downcast_ref::<TimestampMillisecondArray>()
+            .expect("timestamp column is not a millisecond timestamp");
+        let values = batch
+            .column(value_index)
+            .as_any()
+            .downcast_ref::<Float64Array>()
+            .expect("value column is not Float64");
+        rows.extend(
+            timestamps
+                .iter()
+                .zip(values.iter())
+                .map(|(timestamp, value)| (timestamp.unwrap(), value.unwrap())),
+        );
+    }
+    rows.sort_by_key(|(timestamp, _)| *timestamp);
+    rows
+}
+
+#[tokio::test]
+async fn subquery_own_offset_shifts_the_inner_window_but_keeps_evaluation_timestamps() {
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_probe[20s:10s] offset 30s)",
+            45,
+            45,
+            1
+        )
+        .await,
+        vec![(45_000, 3.0)],
+    );
+    assert_eq!(
+        run_subquery_offset_probe("sum_over_time(subquery_offset_probe[20s:10s])", 15, 15, 1).await,
+        vec![(15_000, 3.0)],
+    );
+
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_probe[20s:10s] offset 30s)",
+            30,
+            60,
+            30
+        )
+        .await,
+        vec![(30_000, 1.0), (60_000, 7.0)],
+    );
+    assert_eq!(
+        run_subquery_offset_probe("sum_over_time(subquery_offset_probe[20s:10s])", 0, 30, 30).await,
+        vec![(0, 1.0), (30_000, 7.0)],
+    );
+
+    // Negative offsets look ahead while retaining outer timestamps.
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_probe[20s:10s] offset -30s)",
+            0,
+            30,
+            30
+        )
+        .await,
+        vec![(0, 7.0), (30_000, 13.0)],
+    );
+    assert_eq!(
+        run_subquery_offset_probe("sum_over_time(subquery_offset_probe[20s:10s])", 30, 60, 30)
+            .await,
+        vec![(30_000, 7.0), (60_000, 13.0)],
+    );
+}
+
+/// Expectations match Prometheus v3.14.0.
+#[tokio::test]
+async fn subquery_inner_points_are_anchored_on_absolute_step_multiples() {
+    assert_eq!(
+        run_subquery_offset_probe("sum_over_time(subquery_offset_offgrid[20s:10s])", 45, 45, 1)
+            .await,
+        vec![(45_000, 7.0)],
+    );
+
+    // An off-grid offset distinguishes absolute anchoring from re-phasing.
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[20s:10s] offset 5s)",
+            30,
+            30,
+            1
+        )
+        .await,
+        vec![(30_000, 3.0)],
+    );
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[20s:10s] offset 5s)",
+            45,
+            45,
+            1
+        )
+        .await,
+        vec![(45_000, 7.0)],
+    );
+
+    // The window starts before the first sample.
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[20s:10s] offset 15s)",
+            30,
+            30,
+            1
+        )
+        .await,
+        vec![(30_000, 1.0)],
+    );
+
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[20s:10s] offset -5s)",
+            15,
+            15,
+            1
+        )
+        .await,
+        vec![(15_000, 3.0)],
+    );
+
+    // The negative grid start exercises Euclidean alignment.
+    assert_eq!(
+        run_subquery_offset_probe("sum_over_time(subquery_offset_offgrid[40s:10s])", 15, 15, 1)
+            .await,
+        vec![(15_000, 1.0)],
+    );
+
+    // Multi-step evaluation starts off the subquery grid.
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[20s:10s])",
+            35,
+            65,
+            30
+        )
+        .await,
+        vec![(35_000, 5.0), (65_000, 11.0)],
+    );
+
+    // Child points reach no sample at the first evaluation.
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[20s:10s] offset 30s)",
+            30,
+            60,
+            30
+        )
+        .await,
+        vec![(60_000, 5.0)],
+    );
+}
+
+#[test]
+fn subquery_child_window_is_the_child_grid_window() {
+    let child_window = PromPlanner::subquery_child_window;
+    // Exclusive lower bound; upper bound is the last parent evaluation step.
+    assert_eq!(
+        child_window(30_000, 60_000, 10_000, 0, 20_000, 10_000).unwrap(),
+        Some((20_000, 60_000))
+    );
+    assert_eq!(
+        child_window(45_000, 60_000, 10_000, 0, 20_000, 10_000).unwrap(),
+        Some((30_000, 55_000))
+    );
+    assert_eq!(
+        child_window(25_000, 60_000, 10_000, 0, 20_000, 10_000).unwrap(),
+        Some((10_000, 55_000))
+    );
+    assert_eq!(
+        child_window(35_000, 65_000, 30_000, 0, 20_000, 10_000).unwrap(),
+        Some((20_000, 65_000))
+    );
+    assert_eq!(
+        child_window(0, 55_000, 30_000, 0, 20_000, 10_000).unwrap(),
+        Some((-10_000, 30_000))
+    );
+    // A nonempty child window can contribute no parent rows.
+    assert_eq!(
+        child_window(35_000, 65_000, 10_000, 0, 5_000, 10_000).unwrap(),
+        Some((40_000, 65_000))
+    );
+    // The first child point is past the parent’s last evaluation.
+    assert_eq!(
+        child_window(35_000, 44_000, 10_000, 0, 5_000, 10_000).unwrap(),
+        None
+    );
+    assert_eq!(
+        child_window(30_000, 30_000, 1_000, 5_000, 20_000, 10_000).unwrap(),
+        Some((10_000, 25_000))
+    );
+    assert_eq!(
+        child_window(15_000, 15_000, 1_000, -5_000, 20_000, 10_000).unwrap(),
+        Some((10_000, 20_000))
+    );
+    // Boundaries before the epoch floor towards minus infinity.
+    assert_eq!(
+        child_window(-15_000, -15_000, 1_000, 0, 20_000, 10_000).unwrap(),
+        Some((-30_000, -15_000))
+    );
+    assert_eq!(
+        child_window(-45_000, -45_000, 1_000, -10_000, 20_000, 10_000).unwrap(),
+        Some((-50_000, -35_000))
+    );
+    // A grid start before the first sample is not clamped to it.
+    assert_eq!(
+        child_window(0, 0, 1_000, 0, 20_000, 10_000).unwrap(),
+        Some((-10_000, 0))
+    );
+    // A zero parent interval leaves the upper bound unaligned.
+    assert_eq!(
+        child_window(0, 55_000, 0, 0, 20_000, 10_000).unwrap(),
+        Some((-10_000, 55_000))
+    );
+
+    // Only the derived start overflows.
+    let err = child_window(i64::MIN + 1_000, i64::MIN + 1_000, 1_000, 0, 2_000, 10).unwrap_err();
+    assert!(
+        matches!(
+            &err,
+            crate::promql::error::Error::SubqueryTimestampOutOfRange { timestamp, .. }
+                if timestamp.contains("grid start") && timestamp.contains("-9223372036854776800")
+        ),
+        "{err}"
+    );
+    assert_eq!(err.status_code(), StatusCode::InvalidArguments, "{err}");
+    // Only the derived end overflows.
+    let err = child_window(i64::MAX - 1_000, i64::MAX - 1_000, 1, -2_000, 3_000, 10).unwrap_err();
+    assert!(
+        matches!(
+            &err,
+            crate::promql::error::Error::SubqueryTimestampOutOfRange { timestamp, .. }
+                if timestamp.contains("grid end") && timestamp.contains("9223372036854776807")
+        ),
+        "{err}"
+    );
+    assert_eq!(err.status_code(), StatusCode::InvalidArguments, "{err}");
+    // The wide window is nonempty even though its start overflows.
+    let err = child_window(i64::MIN, i64::MAX, 10_000, i64::MAX, i64::MAX, 1_000).unwrap_err();
+    assert!(
+        matches!(
+            &err,
+            crate::promql::error::Error::SubqueryTimestampOutOfRange { timestamp, .. }
+                if timestamp.contains("grid start")
+        ),
+        "{err}"
+    );
+    // Both derived bounds overflow; report the exact start without clipping.
+    let err = child_window(i64::MAX - 1_000, i64::MAX - 1_000, 1, i64::MIN, 10, 1).unwrap_err();
+    assert!(
+        matches!(
+            &err,
+            crate::promql::error::Error::SubqueryTimestampOutOfRange { timestamp, .. }
+                if timestamp.contains("grid start")
+                    && timestamp.contains("18446744073709550606")
+        ),
+        "{err}"
+    );
+    assert_eq!(err.status_code(), StatusCode::InvalidArguments, "{err}");
+    // Check emptiness before converting overflowing bounds.
+    assert_eq!(
+        child_window(i64::MAX, i64::MAX, 1_000, i64::MIN, 0, 1_000).unwrap(),
+        None
+    );
+}
+
+#[tokio::test]
+async fn subquery_child_window_without_a_step_reports_no_row() {
+    // The first child point is after the parent’s only evaluation.
+    assert_eq!(
+        run_subquery_offset_probe("sum_over_time(subquery_offset_offgrid[5s:10s])", 35, 44, 10)
+            .await,
+        vec![],
+    );
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[5s:10s]) or vector(1)",
+            35,
+            44,
+            10
+        )
+        .await,
+        vec![(35_000, 1.0)],
+    );
+    // Multi-step: every step of the grid reports no child point and falls back.
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[5s:10s]) or vector(1)",
+            35,
+            65,
+            10
+        )
+        .await,
+        vec![(35_000, 1.0), (45_000, 1.0), (55_000, 1.0), (65_000, 1.0)],
+    );
+    // A nonempty child grid can yield no parent rows; a longer range does.
+    assert_eq!(
+        run_subquery_offset_probe("sum_over_time(subquery_offset_offgrid[5s:10s])", 35, 65, 10)
+            .await,
+        vec![],
+    );
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[20s:10s])",
+            35,
+            65,
+            10
+        )
+        .await,
+        vec![(35_000, 5.0), (45_000, 7.0), (55_000, 9.0), (65_000, 11.0)],
+    );
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[20s:10s] offset 5s)",
+            35,
+            65,
+            10
+        )
+        .await,
+        vec![(35_000, 5.0), (45_000, 7.0), (55_000, 9.0), (65_000, 11.0)],
+    );
+    // A negative offset makes the short window reach a child point.
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time(subquery_offset_offgrid[5s:10s] offset -5s)",
+            35,
+            44,
+            10
+        )
+        .await,
+        vec![(35_000, 4.0)],
+    );
+
+    // An empty outer window suppresses inner results, but not an outer fallback.
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time((sum_over_time(subquery_offset_offgrid[5s:10s]))[5s:10s])",
+            35,
+            44,
+            10
+        )
+        .await,
+        vec![],
+    );
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time((sum_over_time(subquery_offset_offgrid[5s:10s]))[5s:10s]) or vector(1)",
+            35,
+            44,
+            10
+        )
+        .await,
+        vec![(35_000, 1.0)],
+    );
+    assert_eq!(
+        run_subquery_offset_probe(
+            "sum_over_time((sum_over_time(subquery_offset_offgrid[5s:10s]) or vector(1))[5s:10s])",
+            35,
+            44,
+            10
+        )
+        .await,
+        vec![],
+    );
+}
+
+#[tokio::test]
+async fn subquery_rejects_invalid_range_and_zero_step() {
+    let err =
+        plan_subquery_offset_probe("sum_over_time(subquery_offset_offgrid[5s:10s])", 44, 35, 10)
+            .await
+            .unwrap_err();
+    assert!(
+        matches!(
+            &err,
+            crate::promql::error::Error::InvalidTimeRange {
+                start: 44_000,
+                end: 35_000,
+                ..
+            }
+        ),
+        "{err}"
+    );
+    let err = plan_subquery_offset_probe(
+        "sum_over_time((sum_over_time(subquery_offset_offgrid[5s:10s]))[5s:10s])",
+        44,
+        35,
+        10,
+    )
+    .await
+    .unwrap_err();
+    assert_eq!(err.status_code(), StatusCode::InvalidArguments, "{err}");
+
+    // `[5s:0]` parses to zero; planning rejects it.
+    let err = plan_subquery_offset_probe("sum_over_time(subquery_offset_offgrid[5s:0])", 60, 60, 1)
+        .await
+        .unwrap_err();
+    assert!(
+        matches!(&err, crate::promql::error::Error::ZeroRangeSelector { .. }),
+        "{err}"
+    );
+}
+
+/// Rejects nonempty child windows whose derived millisecond bounds are unrepresentable.
+#[tokio::test]
+async fn subquery_rejects_a_child_window_out_of_the_representable_range() {
+    // Offset is i64::MAX milliseconds; only the derived start overflows.
+    let err = plan_subquery_offset_probe(
+        "sum_over_time(subquery_offset_offgrid[21366776s:10s] offset 292471208y21366775s807ms)",
+        0,
+        60,
+        10,
+    )
+    .await
+    .unwrap_err();
+    assert!(
+        matches!(
+            &err,
+            crate::promql::error::Error::SubqueryTimestampOutOfRange { timestamp, .. }
+                if timestamp.contains("grid start = -9223372058221550000")
+        ),
+        "{err}"
+    );
+    assert_eq!(err.status_code(), StatusCode::InvalidArguments, "{err}");
+    // Offset is -i64::MAX milliseconds; only the derived end overflows.
+    let err = plan_subquery_offset_probe(
+        "sum_over_time(subquery_offset_offgrid[20s:10s] offset -292471208y21366775s807ms)",
+        0,
+        60,
+        10,
+    )
+    .await
+    .unwrap_err();
+    assert!(
+        matches!(
+            &err,
+            crate::promql::error::Error::SubqueryTimestampOutOfRange { timestamp, .. }
+                if timestamp.contains("grid end = 9223372036854835807")
+        ),
+        "{err}"
+    );
+    assert_eq!(err.status_code(), StatusCode::InvalidArguments, "{err}");
+}
+
 #[tokio::test]
 async fn test_hash_join() {
     let mut eval_stmt = EvalStmt {
@@ -5642,7 +6287,7 @@ async fn native_scan_bounds_preserve_zero_lookback_and_overflow() {
     .await;
     let mut planner = PromPlanner {
         table_provider,
-        ctx: PromPlannerContext::from_eval_stmt(&build_eval_stmt("some_metric")),
+        ctx: PromPlannerContext::from_eval_stmt(&build_eval_stmt("some_metric")).unwrap(),
         promql_annotations: None,
     };
     planner.ctx.time_index_column = Some("timestamp".to_string());
@@ -5878,7 +6523,7 @@ async fn test_label_join() {
 
     let expected = r#"
 Filter: up.field_0 IS NOT NULL [timestamp:Timestamp(ms), field_0:Float64;N, foo:Utf8;N, tag_0:Utf8, tag_1:Utf8, tag_2:Utf8, tag_3:Utf8]
-  Projection: up.timestamp, up.field_0, concat_ws(Utf8(","), up.tag_1, up.tag_2, up.tag_3) AS foo, up.tag_0, up.tag_1, up.tag_2, up.tag_3 [timestamp:Timestamp(ms), field_0:Float64;N, foo:Utf8;N, tag_0:Utf8, tag_1:Utf8, tag_2:Utf8, tag_3:Utf8]
+  Projection: up.timestamp, up.field_0, nullif(concat_ws(Utf8(","), coalesce(up.tag_1, Utf8("")), coalesce(up.tag_2, Utf8("")), coalesce(up.tag_3, Utf8(""))), Utf8("")) AS foo, up.tag_0, up.tag_1, up.tag_2, up.tag_3 [timestamp:Timestamp(ms), field_0:Float64;N, foo:Utf8;N, tag_0:Utf8, tag_1:Utf8, tag_2:Utf8, tag_3:Utf8]
     PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[timestamp] [tag_0:Utf8, tag_1:Utf8, tag_2:Utf8, tag_3:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]
       PromSeriesDivide: tags=["tag_0", "tag_1", "tag_2", "tag_3"] [tag_0:Utf8, tag_1:Utf8, tag_2:Utf8, tag_3:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]
         Sort: up.tag_0 ASC NULLS FIRST, up.tag_1 ASC NULLS FIRST, up.tag_2 ASC NULLS FIRST, up.tag_3 ASC NULLS FIRST, up.timestamp ASC NULLS FIRST [tag_0:Utf8, tag_1:Utf8, tag_2:Utf8, tag_3:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]
@@ -5913,7 +6558,7 @@ async fn test_label_replace() {
 
     let expected = r#"
 Filter: up.field_0 IS NOT NULL [timestamp:Timestamp(ms), field_0:Float64;N, foo:Utf8;N, tag_0:Utf8]
-  Projection: up.timestamp, up.field_0, regexp_replace(up.tag_0, Utf8("^(?s:(.*):.*)$"), Utf8("$1")) AS foo, up.tag_0 [timestamp:Timestamp(ms), field_0:Float64;N, foo:Utf8;N, tag_0:Utf8]
+  Projection: up.timestamp, up.field_0, CASE WHEN regexp_like(coalesce(up.tag_0, Utf8("")), Utf8("^(?s:(.*):.*)$")) THEN nullif(regexp_replace(coalesce(up.tag_0, Utf8("")), Utf8("^(?s:(.*):.*)$"), Utf8("$1")), Utf8("")) ELSE Utf8(NULL) END AS foo, up.tag_0 [timestamp:Timestamp(ms), field_0:Float64;N, foo:Utf8;N, tag_0:Utf8]
     PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[timestamp] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]
       PromSeriesDivide: tags=["tag_0"] [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]
         Sort: up.tag_0 ASC NULLS FIRST, up.timestamp ASC NULLS FIRST [tag_0:Utf8, timestamp:Timestamp(ms), field_0:Float64;N]
@@ -6026,9 +6671,9 @@ async fn test_topk_expr() {
         .await
         .unwrap();
     let expected = "Projection: sum(prometheus_tsdb_head_series.greptime_value), prometheus_tsdb_head_series.ip, prometheus_tsdb_head_series.greptime_timestamp [sum(prometheus_tsdb_head_series.greptime_value):Float64;N, ip:Utf8, greptime_timestamp:Timestamp(ms)]\
-        \n  Sort: prometheus_tsdb_head_series.greptime_timestamp ASC NULLS LAST, row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW ASC NULLS LAST [ip:Utf8, greptime_timestamp:Timestamp(ms), sum(prometheus_tsdb_head_series.greptime_value):Float64;N, row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64]\
-        \n    Filter: row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Float64(10) [ip:Utf8, greptime_timestamp:Timestamp(ms), sum(prometheus_tsdb_head_series.greptime_value):Float64;N, row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64]\
-        \n      WindowAggr: windowExpr=[[row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [ip:Utf8, greptime_timestamp:Timestamp(ms), sum(prometheus_tsdb_head_series.greptime_value):Float64;N, row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64]\
+        \n  Sort: prometheus_tsdb_head_series.greptime_timestamp ASC NULLS LAST, row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [isnan(sum(prometheus_tsdb_head_series.greptime_value)) ASC NULLS FIRST, sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW ASC NULLS LAST [ip:Utf8, greptime_timestamp:Timestamp(ms), sum(prometheus_tsdb_head_series.greptime_value):Float64;N, row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [isnan(sum(prometheus_tsdb_head_series.greptime_value)) ASC NULLS FIRST, sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64]\
+        \n    Filter: row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [isnan(sum(prometheus_tsdb_head_series.greptime_value)) ASC NULLS FIRST, sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Float64(10) [ip:Utf8, greptime_timestamp:Timestamp(ms), sum(prometheus_tsdb_head_series.greptime_value):Float64;N, row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [isnan(sum(prometheus_tsdb_head_series.greptime_value)) ASC NULLS FIRST, sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64]\
+        \n      WindowAggr: windowExpr=[[row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [isnan(sum(prometheus_tsdb_head_series.greptime_value)) ASC NULLS FIRST, sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [ip:Utf8, greptime_timestamp:Timestamp(ms), sum(prometheus_tsdb_head_series.greptime_value):Float64;N, row_number() PARTITION BY [prometheus_tsdb_head_series.greptime_timestamp] ORDER BY [isnan(sum(prometheus_tsdb_head_series.greptime_value)) ASC NULLS FIRST, sum(prometheus_tsdb_head_series.greptime_value) DESC NULLS FIRST, prometheus_tsdb_head_series.ip DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64]\
         \n        Sort: prometheus_tsdb_head_series.ip ASC NULLS LAST, prometheus_tsdb_head_series.greptime_timestamp ASC NULLS LAST [ip:Utf8, greptime_timestamp:Timestamp(ms), sum(prometheus_tsdb_head_series.greptime_value):Float64;N]\
         \n          Aggregate: groupBy=[[prometheus_tsdb_head_series.ip, prometheus_tsdb_head_series.greptime_timestamp]], aggr=[[sum(prometheus_tsdb_head_series.greptime_value)]] [ip:Utf8, greptime_timestamp:Timestamp(ms), sum(prometheus_tsdb_head_series.greptime_value):Float64;N]\
         \n            PromInstantManipulate: range=[0..100000000], lookback=[1000], interval=[5000], time index=[greptime_timestamp] [ip:Utf8, greptime_timestamp:Timestamp(ms), greptime_value:Float64;N]\
@@ -8248,3 +8893,31 @@ async fn test_count_values_groups_by_formatted_value_for_bigint_input() {
         vec![("9007199254740992", 2.0)]
     );
 }
+
+#[tokio::test]
+async fn eval_times_before_epoch() {
+    let plan = |start: SystemTime, end: SystemTime| async move {
+        let mut eval_stmt = build_eval_stmt("some_metric");
+        eval_stmt.start = start;
+        eval_stmt.end = end;
+        let table_provider = build_test_table_provider(
+            &[(DEFAULT_SCHEMA_NAME.to_string(), "some_metric".to_string())],
+            1,
+            1,
+        )
+        .await;
+        PromPlanner::stmt_to_plan(table_provider, &eval_stmt, &build_query_engine_state()).await
+    };
+
+    plan(
+        UNIX_EPOCH - Duration::from_secs(30_000),
+        UNIX_EPOCH - Duration::from_secs(29_000),
+    )
+    .await
+    .unwrap();
+    // Beyond the i64 millisecond range, which must not wrap into the future. Windows cannot
+    // represent this SystemTime.
+    if let Some(too_early) = UNIX_EPOCH.checked_sub(Duration::from_secs(10_000_000_000_000_000)) {
+        assert!(plan(too_early, too_early).await.is_err());
+    }
+}
diff --git a/src/query/src/promql/planner/test/delta.rs b/src/query/src/promql/planner/test/delta.rs
index a647821e0b3..9ca8a8b646c 100644
--- a/src/query/src/promql/planner/test/delta.rs
+++ b/src/query/src/promql/planner/test/delta.rs
@@ -535,6 +535,7 @@ async fn matchers_read_absent_labels_as_empty() {
         schema.clone(),
         vec![Arc::new(StringArray::from(vec![
             None,
+            Some(""),
             Some(GREPTIME_TEMPORALITY_DELTA),
         ]))],
     )
@@ -542,10 +543,19 @@ async fn matchers_read_absent_labels_as_empty() {
     let table = Arc::new(MemTable::try_new(schema, vec![vec![batch]]).unwrap());
 
     for (matcher, expected) in [
-        (r#"="""#, vec![None]),
-        (r#"!="delta""#, vec![None]),
-        (r#"=~".*""#, vec![None, Some(GREPTIME_TEMPORALITY_DELTA)]),
-        (r#"!~"delta""#, vec![None]),
+        (r#"="""#, vec![None, Some("")]),
+        (r#"!="delta""#, vec![None, Some("")]),
+        (
+            r#"=~".*""#,
+            vec![None, Some(""), Some(GREPTIME_TEMPORALITY_DELTA)],
+        ),
+        (r#"!~"delta""#, vec![None, Some("")]),
+        (r#"!="""#, vec![Some(GREPTIME_TEMPORALITY_DELTA)]),
+        (
+            r#"=~"delta|""#,
+            vec![None, Some(""), Some(GREPTIME_TEMPORALITY_DELTA)],
+        ),
+        (r#"!~"delta|""#, vec![]),
         (r#"="delta""#, vec![Some(GREPTIME_TEMPORALITY_DELTA)]),
     ] {
         let query = format!(r#"metric{{{marker}{matcher}}}"#);
@@ -558,10 +568,10 @@ async fn matchers_read_absent_labels_as_empty() {
         };
         let expressions = PromPlanner::matchers_to_expr(selector.matchers, scan.schema()).unwrap();
         let display = expressions.iter().map(ToString::to_string).join(" AND ");
-        if matcher == r#"="delta""# {
-            assert!(!display.contains("coalesce"), "{display}");
+        if [r#"="delta""#, r#"!="""#, r#"!~"delta|""#].contains(&matcher) {
+            assert!(!display.contains("IS NULL"), "{display}");
         } else if !expressions.is_empty() {
-            assert!(display.contains("coalesce"), "{display}");
+            assert!(display.contains("IS NULL"), "{display}");
         }
         let plan = if let Some(filter) = conjunction(expressions) {
             LogicalPlanBuilder::from(scan)
@@ -599,7 +609,7 @@ async fn matchers_read_absent_labels_as_empty() {
     // The rule is about NULL, not about the marker: any nullable label column
     // can be NULL where the series does not carry the label. A non-nullable one
     // has nothing to normalize.
-    for (nullable, wants_coalesce) in [(true, true), (false, false)] {
+    for (nullable, wants_null_filter) in [(true, true), (false, false)] {
         let ordinary_schema = Arc::new(ArrowSchema::new(vec![Field::new(
             "label",
             ArrowDataType::Utf8,
@@ -626,8 +636,8 @@ async fn matchers_read_absent_labels_as_empty() {
             .map(ToString::to_string)
             .join(" AND ");
         assert_eq!(
-            wants_coalesce,
-            expressions.contains("coalesce"),
+            wants_null_filter,
+            expressions.contains("IS NULL"),
             "nullable={nullable}: {expressions}"
         );
     }
@@ -1102,12 +1112,12 @@ async fn delta_offsets_survive_optimized_plan_serialization() {
         (
             "timestamp positive offset",
             r#"timestamp(delta_metric{series="cumulative"} offset 60s)"#,
-            120.0,
+            60.0,
         ),
         (
             "timestamp negative offset",
             r#"timestamp(delta_metric{series="cumulative"} offset -60s)"#,
-            120.0,
+            180.0,
         ),
         (
             "range positive offset",
diff --git a/src/query/src/query_engine/default_serializer.rs b/src/query/src/query_engine/default_serializer.rs
index f4d6b29fa2c..53887d78f75 100644
--- a/src/query/src/query_engine/default_serializer.rs
+++ b/src/query/src/query_engine/default_serializer.rs
@@ -30,7 +30,7 @@ use datafusion_expr::UserDefinedLogicalNode;
 use greptime_proto::substrait_extension::MergeScan as PbMergeScan;
 use promql::functions::{
     AbsentOverTime, AvgOverTime, Changes, CountOverTime, Delta, Deriv, DoubleExponentialSmoothing,
-    IDelta, Increase, LastOverTime, MaxOverTime, MinOverTime, MixedRange,
+    IDelta, IeeeComparison, IeeeSqrt, Increase, LastOverTime, MaxOverTime, MinOverTime, MixedRange,
     NativeHistogramAbsentOverTime, NativeHistogramAdd, NativeHistogramAggAvg,
     NativeHistogramAggSum, NativeHistogramAvg, NativeHistogramAvgOverTime, NativeHistogramChanges,
     NativeHistogramCount, NativeHistogramCountOverTime, NativeHistogramDelta,
@@ -151,6 +151,10 @@ impl SubstraitPlanDecoder for DefaultPlanDecoder {
         }
 
         let _ = session_state.register_udaf(quantile_udaf());
+        for udf in IeeeComparison::all() {
+            let _ = session_state.register_udf(Arc::new(udf));
+        }
+        let _ = session_state.register_udf(Arc::new(IeeeSqrt::scalar_udf()));
 
         let _ = session_state.register_udf(Arc::new(IDelta::<false>::scalar_udf()));
         let _ = session_state.register_udf(Arc::new(IDelta::<true>::scalar_udf()));
diff --git a/src/query/src/query_engine/state.rs b/src/query/src/query_engine/state.rs
index aa3b9417b14..361a0d2991d 100644
--- a/src/query/src/query_engine/state.rs
+++ b/src/query/src/query_engine/state.rs
@@ -66,11 +66,12 @@ use crate::optimizer::constant_term::MatchesConstantTermOptimizer;
 use crate::optimizer::count_nest_aggr::CountNestAggrRule;
 use crate::optimizer::count_wildcard::CountWildcardToTimeIndexRule;
 use crate::optimizer::enforce_sorting::EnforceSorting;
+use crate::optimizer::expr_depth;
 use crate::optimizer::global_limit::EnsureGlobalLimitForFetch;
+use crate::optimizer::infer_aggregate_input_bounds::InferAggregateInputBoundsRule;
 use crate::optimizer::json_schema_concretize::JsonSchemaConcretizeRule;
 use crate::optimizer::json_type_concretize::JsonTypeConcretizeRule;
 use crate::optimizer::parallelize_scan::ParallelizeScan;
-use crate::optimizer::pass_distribution::PassDistribution;
 use crate::optimizer::promql_tsid_narrow_join::PromqlTsidNarrowJoin;
 use crate::optimizer::remove_duplicate::RemoveDuplicate;
 use crate::optimizer::scan_hint::ScanHintRule;
@@ -213,6 +214,7 @@ impl QueryEngineState {
             analyzer.rules.push(Arc::new(JsonSchemaConcretizeRule));
         }
         analyzer.rules.push(Arc::new(FixStateUdafOrderingAnalyzer));
+        analyzer.rules.push(Arc::new(expr_depth::ExprDepthRule));
 
         // Note: Postgres oid-alias string coercion (`'x'::regclass`,
         // `'public'::regnamespace`, ...) is handled by the
@@ -223,6 +225,19 @@ impl QueryEngineState {
         // handled by the parser's blacklist.
 
         let mut optimizer = Optimizer::new();
+        // Constants must be simplified, but CASE arguments must not yet be
+        // hidden by common-subexpression extraction.
+        let filter_pushdown_index = optimizer
+            .rules
+            .iter()
+            .position(|rule| rule.name() == "push_down_filter")
+            .ok_or_else(|| {
+                datafusion_common::internal_datafusion_err!("Missing PushDownFilter rule")
+            })?;
+        optimizer.rules.insert(
+            filter_pushdown_index,
+            Arc::new(InferAggregateInputBoundsRule),
+        );
         optimizer.rules.push(Arc::new(ScanHintRule));
         optimizer.rules.push(Arc::new(JsonTypeConcretizeRule));
 
@@ -232,17 +247,13 @@ impl QueryEngineState {
         physical_optimizer
             .rules
             .insert(5, Arc::new(ParallelizeScan));
-        // Pass distribution requirement to MergeScanExec to avoid unnecessary shuffling
-        physical_optimizer
-            .rules
-            .insert(6, Arc::new(PassDistribution));
         // Prefer collecting narrow PromQL build sides over repartitioning wide label streams.
         physical_optimizer
             .rules
-            .insert(7, Arc::new(PromqlTsidNarrowJoin));
+            .insert(6, Arc::new(PromqlTsidNarrowJoin));
         // Re-enforce sorting after custom rules update scan partitioning and distribution.
         // Keep it immediately before DataFusion's default EnsureRequirements.
-        physical_optimizer.rules.insert(8, Arc::new(EnforceSorting));
+        physical_optimizer.rules.insert(7, Arc::new(EnforceSorting));
         // Add rule for windowed sort
         physical_optimizer
             .rules
@@ -316,15 +327,20 @@ impl QueryEngineState {
         plan: DfLogicalPlan,
         context: &QueryEngineContext,
     ) -> DfResult<DfLogicalPlan> {
+        expr_depth::validate_plan(&plan)?;
         self.extension_rules
             .iter()
             .try_fold(plan, |acc_plan, rule| {
-                rule.analyze(acc_plan, context, self.session_state().config_options())
+                let plan =
+                    rule.analyze(acc_plan, context, self.session_state().config_options())?;
+                expr_depth::validate_plan(&plan)?;
+                Ok(plan)
             })
     }
 
     /// Run the full logical plan optimize phase for the given plan.
     pub fn optimize_logical_plan(&self, plan: DfLogicalPlan) -> DfResult<DfLogicalPlan> {
+        expr_depth::validate_plan(&plan)?;
         self.session_state().optimize(&plan)
     }
 
diff --git a/src/servers/AGENTS.md b/src/servers/AGENTS.md
index 006ac59771c..a8222430857 100644
--- a/src/servers/AGENTS.md
+++ b/src/servers/AGENTS.md
@@ -41,3 +41,16 @@ cargo nextest run -p servers
 ```
 
 Keep protocol translation here and permissions/database behavior in frontend.
+Logical-table physical flushes retain partition columns in Arrow RPC payloads and
+pass all region writes to the operator write dispatcher together; the dispatcher
+owns peer resolution and retries. See `batcher/logical_table/region_write.rs`.
+
+`prom_remote_write/decode.rs` and `benches/prom_decode.rs` resolve
+`benches/write_request.pb.data` using `CARGO_MANIFEST_DIR` at **run time**
+(`std::env::var`, not `env!`). `cargo nextest run` and `cargo bench` set it;
+direct test/benchmark-binary execution requires setting it to the crate directory.
+Run this example from the repository root:
+
+```bash
+CARGO_MANIFEST_DIR="$PWD/src/servers" ./target/debug/deps/<test_or_bench_binary>
+```
diff --git a/src/servers/Cargo.toml b/src/servers/Cargo.toml
index f9c3b45832f..8a2b6ab2149 100644
--- a/src/servers/Cargo.toml
+++ b/src/servers/Cargo.toml
@@ -90,7 +90,7 @@ notify.workspace = true
 object-pool = "0.5"
 once_cell.workspace = true
 # Wait for https://github.com/databendlabs/opensrv/pull/81
-opensrv-mysql = { git = "https://github.com/GreptimeTeam/opensrv", rev = "f3135e5f00401e06075cf241c0cc26489e45b20a" }
+opensrv-mysql = { git = "https://github.com/GreptimeTeam/opensrv", rev = "1f3d88ccaafb5721be6cfcc3ccbca48642426119" }
 opentelemetry-proto.workspace = true
 operator.workspace = true
 otel-arrow-rust.workspace = true
diff --git a/src/servers/benches/flush_batch_physical.rs b/src/servers/benches/flush_batch_physical.rs
index be992692d13..d879486c2d3 100644
--- a/src/servers/benches/flush_batch_physical.rs
+++ b/src/servers/benches/flush_batch_physical.rs
@@ -15,8 +15,6 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use api::region::RegionResponse;
-use api::v1::meta::Peer;
 use api::v1::region::RegionRequest;
 use arrow::array::{Float64Array, StringArray, TimestampMillisecondArray};
 use arrow::datatypes::{DataType as ArrowDataType, Field, Schema as ArrowSchema, TimeUnit};
@@ -29,11 +27,10 @@ use datatypes::schema::{ColumnSchema as DtColumnSchema, Schema as DtSchema};
 use partition::error::Result as PartitionResult;
 use partition::partition::{PartitionRule, PartitionRuleRef, RegionMask};
 use servers::batcher::logical_table::{
-    PhysicalFlushCatalogProvider, PhysicalFlushNodeRequester, PhysicalFlushPartitionProvider,
+    PhysicalFlushCatalogProvider, PhysicalFlushPartitionProvider, PhysicalFlushWriteDispatcher,
     PhysicalTableMetadata, RecordBatchWithTsIdx, TableBatch, flush_batch_physical,
 };
-use servers::error::{self, Result};
-use store_api::storage::RegionId;
+use servers::error;
 use table::test_util::table_info::test_table_info;
 use tokio::runtime::Runtime;
 
@@ -95,24 +92,17 @@ impl PhysicalFlushPartitionProvider for BenchPartitionProvider {
     async fn find_table_partition_rule(
         &self,
         _table_info: &table::metadata::TableInfo,
-    ) -> PartitionResult<PartitionRuleRef> {
-        Ok(Arc::new(SingleRegionPartitionRule))
-    }
-
-    async fn find_region_leader(&self, _region_id: RegionId) -> Result<Peer> {
-        Ok(Peer {
-            id: 1,
-            addr: "bench-node".to_string(),
-        })
+    ) -> PartitionResult<(PartitionRuleRef, HashMap<u32, Option<u64>>)> {
+        Ok((Arc::new(SingleRegionPartitionRule), HashMap::new()))
     }
 }
 
-struct BenchNodeRequester;
+struct BenchWriteDispatcher;
 
 #[async_trait]
-impl PhysicalFlushNodeRequester for BenchNodeRequester {
-    async fn handle(&self, _peer: &Peer, _request: RegionRequest) -> error::Result<RegionResponse> {
-        Ok(RegionResponse::new(0))
+impl PhysicalFlushWriteDispatcher for BenchWriteDispatcher {
+    async fn dispatch(&self, _requests: Vec<RegionRequest>) -> error::Result<usize> {
+        Ok(0)
     }
 }
 
@@ -224,7 +214,7 @@ fn bench_flush_batch_physical(c: &mut Criterion) {
         table: make_physical_table_metadata(num_tags),
     };
     let partition_provider = BenchPartitionProvider;
-    let node_requester = BenchNodeRequester;
+    let write_dispatcher = BenchWriteDispatcher;
 
     let mut group = c.benchmark_group("flush_batch_physical");
 
@@ -244,7 +234,7 @@ fn bench_flush_batch_physical(c: &mut Criterion) {
                             "phy",
                             &ctx,
                             &partition_provider,
-                            &node_requester,
+                            &write_dispatcher,
                             &catalog_provider,
                         )
                         .await
@@ -271,7 +261,7 @@ fn bench_flush_batch_physical(c: &mut Criterion) {
                             "phy",
                             &ctx,
                             &partition_provider,
-                            &node_requester,
+                            &write_dispatcher,
                             &catalog_provider,
                         )
                         .await
diff --git a/src/servers/benches/prom_decode.rs b/src/servers/benches/prom_decode.rs
index 1cdc7d3782e..bbca7a4269f 100644
--- a/src/servers/benches/prom_decode.rs
+++ b/src/servers/benches/prom_decode.rs
@@ -27,7 +27,9 @@ use servers::prom_remote_write::validation::{PromValidationMode, validate_label_
 use servers::prom_store::to_grpc_row_insert_requests;
 
 fn load_fixture_v1_bytes() -> Vec<u8> {
-    let mut d = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let mut d = std::path::PathBuf::from(
+        std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set"),
+    );
     d.push("benches");
     d.push("write_request.pb.data");
     std::fs::read(d).expect("read write_request.pb.data fixture")
diff --git a/src/servers/src/batcher/logical_table.rs b/src/servers/src/batcher/logical_table.rs
index 7e0cea44b6a..f34b0ae406e 100644
--- a/src/servers/src/batcher/logical_table.rs
+++ b/src/servers/src/batcher/logical_table.rs
@@ -39,6 +39,7 @@ use common_query::prelude::GREPTIME_PHYSICAL_TABLE;
 use common_time::timestamp::TimeUnit;
 use meter_core::data::MeterRecord;
 use meter_macros::write_meter;
+use operator::write_dispatcher::WriteDispatcherRef;
 use partition::manager::PartitionRuleManagerRef;
 use session::context::QueryContextRef;
 use snafu::ResultExt;
@@ -52,7 +53,7 @@ use crate::batcher::logical_table::pending_worker::{
     PendingWorker, WorkerCommand, remove_worker_if_same_channel, start_worker,
 };
 pub use crate::batcher::logical_table::region_write::{
-    PhysicalFlushCatalogProvider, PhysicalFlushNodeRequester, PhysicalFlushPartitionProvider,
+    PhysicalFlushCatalogProvider, PhysicalFlushPartitionProvider, PhysicalFlushWriteDispatcher,
     PhysicalTableMetadata,
 };
 pub use crate::batcher::logical_table::tables::{
@@ -97,7 +98,7 @@ pub struct LogicalTablePendingRowsBatcher {
     flush_interval: Duration,
     flush_policy: TimingFlushPolicy,
     partition_manager: PartitionRuleManagerRef,
-    node_manager: NodeManagerRef,
+    write_dispatcher: WriteDispatcherRef,
     catalog_manager: CatalogManagerRef,
     flow_notification_tx: FlowNotifier,
     flush_limiter: FlushLimiter,
@@ -110,10 +111,12 @@ pub struct LogicalTablePendingRowsBatcher {
 }
 
 impl LogicalTablePendingRowsBatcher {
+    /// Creates the batcher when metric-engine batching is enabled.
     #[allow(clippy::too_many_arguments)]
     pub fn try_new(
         partition_manager: PartitionRuleManagerRef,
         node_manager: NodeManagerRef,
+        write_dispatcher: WriteDispatcherRef,
         catalog_manager: CatalogManagerRef,
         table_flownode_set_cache: TableFlownodeSetCacheRef,
         prom_store_with_metric_engine: bool,
@@ -153,7 +156,7 @@ impl LogicalTablePendingRowsBatcher {
             flush_interval,
             flush_policy,
             partition_manager,
-            node_manager,
+            write_dispatcher,
             catalog_manager,
             flow_notification_tx,
             prom_store_with_metric_engine,
@@ -404,7 +407,7 @@ impl LogicalTablePendingRowsBatcher {
             rx,
             self.shutdown.clone(),
             self.partition_manager.clone(),
-            self.node_manager.clone(),
+            self.write_dispatcher.clone(),
             self.catalog_manager.clone(),
             self.flow_notification_tx.clone(),
             worker_idle_timeout,
diff --git a/src/servers/src/batcher/logical_table/batch.rs b/src/servers/src/batcher/logical_table/batch.rs
index ac2db137de1..1ce90f39d01 100644
--- a/src/servers/src/batcher/logical_table/batch.rs
+++ b/src/servers/src/batcher/logical_table/batch.rs
@@ -18,45 +18,41 @@ use std::time::Instant;
 
 use catalog::CatalogManagerRef;
 use common_batcher::flush_limiter::FlushLimiter;
-use common_meta::node_manager::NodeManagerRef;
-use common_query::prelude::GREPTIME_PHYSICAL_TABLE;
+use common_query::prelude;
 use common_telemetry::{debug, warn};
+use operator::write_dispatcher::WriteDispatcherRef;
 use partition::manager::PartitionRuleManagerRef;
 use session::context::QueryContextRef;
 use snafu::OptionExt;
 
 use crate::batcher::flow_notifier::FlowNotifier;
-use crate::batcher::logical_table::PHYSICAL_TABLE_KEY;
-use crate::batcher::logical_table::batch_convert::{
-    TableBatch, concat_modified_batches, transform_logical_batches_to_physical,
-};
-use crate::batcher::logical_table::flow_notifier::enqueue_flow_notifications;
+use crate::batcher::logical_table;
+use crate::batcher::logical_table::batch_convert::{self, TableBatch};
+use crate::batcher::logical_table::flow_notifier;
 use crate::batcher::logical_table::pending_worker::FlushWaiter;
 use crate::batcher::logical_table::region_write::{
-    CatalogManagerPhysicalFlushAdapter, NodeManagerPhysicalFlushAdapter,
-    PartitionManagerPhysicalFlushAdapter, PhysicalFlushCatalogProvider, PhysicalFlushNodeRequester,
-    PhysicalFlushPartitionProvider, encode_region_write_requests, flush_region_writes_concurrently,
-    plan_region_batches, resolve_region_targets,
+    self, CatalogManagerPhysicalFlushAdapter, PartitionManagerPhysicalFlushAdapter,
+    PhysicalFlushCatalogProvider, PhysicalFlushPartitionProvider, PhysicalFlushWriteDispatcher,
+    WriteDispatcherPhysicalFlushAdapter,
 };
 use crate::error;
 use crate::error::Result;
-use crate::metrics::{
-    FLUSH_DROPPED_ROWS, FLUSH_ELAPSED, FLUSH_FAILURES, FLUSH_ROWS, FLUSH_TOTAL,
-    PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED,
-};
+use crate::metrics;
 
-pub(in crate::batcher::logical_table) struct Batch {
-    pub(in crate::batcher::logical_table) table_batches: Vec<TableBatch>,
-    pub(in crate::batcher::logical_table) total_row_count: usize,
-    pub(in crate::batcher::logical_table) db_string: String,
-    pub(in crate::batcher::logical_table) ctx: QueryContextRef,
-    pub(in crate::batcher::logical_table) waiters: Vec<FlushWaiter>,
+/// Rows and completion waiters owned by one physical flush.
+pub(crate) struct Batch {
+    pub(crate) table_batches: Vec<TableBatch>,
+    pub(crate) total_row_count: usize,
+    pub(crate) db_string: String,
+    pub(crate) ctx: QueryContextRef,
+    pub(crate) waiters: Vec<FlushWaiter>,
 }
 
-pub(in crate::batcher::logical_table) async fn spawn_flush(
+/// Spawns a physical flush with the configured concurrency limit.
+pub(crate) async fn spawn_flush(
     flush: Batch,
     partition_manager: PartitionRuleManagerRef,
-    node_manager: NodeManagerRef,
+    write_dispatcher: WriteDispatcherRef,
     catalog_manager: CatalogManagerRef,
     flow_notification_tx: FlowNotifier,
     flush_limiter: FlushLimiter,
@@ -68,7 +64,7 @@ pub(in crate::batcher::logical_table) async fn spawn_flush(
                 flush_batch_with_managers(
                     flush,
                     partition_manager,
-                    node_manager,
+                    write_dispatcher,
                     catalog_manager,
                     flow_notification_tx,
                 )
@@ -80,7 +76,7 @@ pub(in crate::batcher::logical_table) async fn spawn_flush(
             flush_batch_with_managers(
                 flush,
                 partition_manager,
-                node_manager,
+                write_dispatcher,
                 catalog_manager,
                 flow_notification_tx,
             )
@@ -89,32 +85,32 @@ pub(in crate::batcher::logical_table) async fn spawn_flush(
     }
 }
 
-pub(in crate::batcher::logical_table) async fn flush_batch_with_managers(
+/// Connects shared routing and dispatch dependencies to a physical flush.
+pub(crate) async fn flush_batch_with_managers(
     flush: Batch,
     partition_manager: PartitionRuleManagerRef,
-    node_manager: NodeManagerRef,
+    write_dispatcher: WriteDispatcherRef,
     catalog_manager: CatalogManagerRef,
     flow_notification_tx: FlowNotifier,
 ) {
     let partition_provider = PartitionManagerPhysicalFlushAdapter { partition_manager };
-    let node_requester = NodeManagerPhysicalFlushAdapter {
-        node_manager: node_manager.clone(),
-    };
+    let write_dispatcher = WriteDispatcherPhysicalFlushAdapter { write_dispatcher };
     let catalog_provider = CatalogManagerPhysicalFlushAdapter { catalog_manager };
     flush_batch(
         flush,
         &partition_provider,
-        &node_requester,
+        &write_dispatcher,
         &catalog_provider,
         flow_notification_tx,
     )
     .await;
 }
 
-pub(in crate::batcher::logical_table) async fn flush_batch(
+/// Flushes a batch and reports completion to its waiters.
+pub(crate) async fn flush_batch(
     flush: Batch,
     partition_manager: &(impl PhysicalFlushPartitionProvider + ?Sized),
-    node_manager: &(impl PhysicalFlushNodeRequester + ?Sized),
+    write_dispatcher: &(impl PhysicalFlushWriteDispatcher + ?Sized),
     catalog_manager: &(impl PhysicalFlushCatalogProvider + ?Sized),
     flow_notification_tx: FlowNotifier,
 ) {
@@ -130,21 +126,21 @@ pub(in crate::batcher::logical_table) async fn flush_batch(
     // Physical-table-level flush: transform all logical table batches
     // into physical format and write them together.
     let physical_table_name = ctx
-        .extension(PHYSICAL_TABLE_KEY)
-        .unwrap_or(GREPTIME_PHYSICAL_TABLE)
+        .extension(logical_table::PHYSICAL_TABLE_KEY)
+        .unwrap_or(prelude::GREPTIME_PHYSICAL_TABLE)
         .to_string();
     let result = flush_batch_physical(
         &table_batches,
         &physical_table_name,
         &ctx,
         partition_manager,
-        node_manager,
+        write_dispatcher,
         catalog_manager,
     )
     .await;
 
     let elapsed = start.elapsed().as_secs_f64();
-    FLUSH_ELAPSED.observe(elapsed);
+    metrics::FLUSH_ELAPSED.observe(elapsed);
 
     debug!(
         "Pending rows batch flushed, total rows: {}, elapsed time: {}s",
@@ -153,18 +149,18 @@ pub(in crate::batcher::logical_table) async fn flush_batch(
 
     match result {
         Ok(affected_rows) => {
-            FLUSH_TOTAL.inc();
-            FLUSH_ROWS.observe(total_row_count as f64);
+            metrics::FLUSH_TOTAL.inc();
+            metrics::FLUSH_ROWS.observe(total_row_count as f64);
             operator::metrics::DIST_INGEST_ROW_COUNT
                 .with_label_values(&[db_string.as_str()])
                 .inc_by(affected_rows as u64);
 
             notify_waiters(waiters, Ok(()));
-            enqueue_flow_notifications(table_batches, &flow_notification_tx);
+            flow_notifier::enqueue_flow_notifications(table_batches, &flow_notification_tx);
         }
         Err(err) => {
-            FLUSH_FAILURES.inc();
-            FLUSH_DROPPED_ROWS.inc_by(total_row_count as u64);
+            metrics::FLUSH_FAILURES.inc();
+            metrics::FLUSH_DROPPED_ROWS.inc_by(total_row_count as u64);
             notify_waiters(waiters, Err(err));
         }
     }
@@ -185,12 +181,12 @@ pub async fn flush_batch_physical(
     physical_table_name: &str,
     ctx: &QueryContextRef,
     partition_manager: &(impl PhysicalFlushPartitionProvider + ?Sized),
-    node_manager: &(impl PhysicalFlushNodeRequester + ?Sized),
+    write_dispatcher: &(impl PhysicalFlushWriteDispatcher + ?Sized),
     catalog_manager: &(impl PhysicalFlushCatalogProvider + ?Sized),
 ) -> Result<usize> {
     // 1. Resolve the physical table and get column ID mapping
     let physical_table = {
-        let _timer = PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
+        let _timer = metrics::PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
             .with_label_values(&["flush_physical_resolve_table"])
             .start_timer();
         catalog_manager
@@ -220,8 +216,8 @@ pub async fn flush_batch_physical(
         })?;
 
     // 2. Get the physical table's partition rule (one lookup instead of N)
-    let partition_rule = {
-        let _timer = PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
+    let (partition_rule, partition_versions) = {
+        let _timer = metrics::PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
             .with_label_values(&["flush_physical_fetch_partition_rule"])
             .start_timer();
         partition_manager
@@ -233,24 +229,29 @@ pub async fn flush_batch_physical(
         partition_columns.iter().map(String::as_str).collect();
 
     // 3. Transform each logical table batch into physical format
-    let modified_batches =
-        transform_logical_batches_to_physical(table_batches, &name_to_ids, &partition_columns_set)?;
+    let modified_batches = batch_convert::transform_logical_batches_to_physical(
+        table_batches,
+        &name_to_ids,
+        &partition_columns_set,
+    )?;
 
     // 4. Concatenate all modified batches (all share the same physical schema)
-    let combined_batch = concat_modified_batches(&modified_batches)?;
+    let combined_batch = batch_convert::concat_modified_batches(&modified_batches)?;
 
     // 5. Split by physical partition rule and send to regions
     let physical_table_id = physical_table_info.table_id();
-    let planned_batches = plan_region_batches(
+    let planned_batches = region_write::plan_region_batches(
         combined_batch,
         physical_table_id,
         partition_rule.as_ref(),
-        partition_columns,
     )?;
 
-    let resolved_batches = resolve_region_targets(planned_batches, partition_manager).await?;
-    let region_writes = encode_region_write_requests(resolved_batches, ctx.skip_wal())?;
-    flush_region_writes_concurrently(node_manager, region_writes).await
+    let region_writes = region_write::encode_region_write_requests(
+        planned_batches,
+        ctx.skip_wal(),
+        &partition_versions,
+    )?;
+    write_dispatcher.dispatch(region_writes).await
 }
 
 pub(in crate::batcher::logical_table) fn notify_waiters(
@@ -276,7 +277,6 @@ mod tests {
     use std::task::Poll;
     use std::time::Duration;
 
-    use api::region::RegionResponse;
     use api::v1::meta::Peer;
     use api::v1::region::RegionRequest;
     use arrow::record_batch::RecordBatch;
@@ -288,7 +288,6 @@ mod tests {
     use datatypes::schema::{ColumnSchema as DtColumnSchema, Schema as DtSchema};
     use partition::error::Result as PartitionResult;
     use partition::partition::{PartitionRule, PartitionRuleRef, RegionMask};
-    use store_api::storage::RegionId;
     use table::metadata::TableId;
     use table::test_util::table_info::test_table_info;
     use tokio::sync::{mpsc, oneshot};
@@ -300,7 +299,7 @@ mod tests {
     use crate::batcher::logical_table::batch_convert::TableBatch;
     use crate::batcher::logical_table::pending_worker::FlushWaiter;
     use crate::batcher::logical_table::region_write::{
-        PhysicalFlushCatalogProvider, PhysicalFlushNodeRequester, PhysicalFlushPartitionProvider,
+        PhysicalFlushCatalogProvider, PhysicalFlushPartitionProvider, PhysicalFlushWriteDispatcher,
         PhysicalTableMetadata,
     };
     use crate::batcher::logical_table::test_util::{
@@ -344,9 +343,8 @@ mod tests {
             },
             &MockFlushPartitionProvider {
                 partition_rule_calls: Arc::new(AtomicUsize::new(0)),
-                region_leader_calls: Arc::new(AtomicUsize::new(0)),
             },
-            &MockFlushNodeRequester {
+            &MockFlushWriteDispatcher {
                 writes: writes.clone(),
                 fail: false,
             },
@@ -405,9 +403,8 @@ mod tests {
             },
             &MockFlushPartitionProvider {
                 partition_rule_calls: Arc::new(AtomicUsize::new(0)),
-                region_leader_calls: Arc::new(AtomicUsize::new(0)),
             },
-            &MockFlushNodeRequester {
+            &MockFlushWriteDispatcher {
                 writes: writes.clone(),
                 fail: true,
             },
@@ -451,8 +448,7 @@ mod tests {
             row_count: 1,
         }];
         let partition_calls = Arc::new(AtomicUsize::new(0));
-        let leader_calls = Arc::new(AtomicUsize::new(0));
-        let node = MockFlushNodeRequester::default();
+        let dispatcher = MockFlushWriteDispatcher::default();
         let ctx = session::context::QueryContext::arc();
 
         flush_batch_physical(
@@ -461,9 +457,8 @@ mod tests {
             &ctx,
             &MockFlushPartitionProvider {
                 partition_rule_calls: partition_calls.clone(),
-                region_leader_calls: leader_calls.clone(),
             },
-            &node,
+            &dispatcher,
             &MockFlushCatalogProvider {
                 table: Some(mock_physical_table_metadata(1024)),
             },
@@ -472,8 +467,7 @@ mod tests {
         .unwrap();
 
         assert_eq!(1, partition_calls.load(Ordering::SeqCst));
-        assert_eq!(1, leader_calls.load(Ordering::SeqCst));
-        assert_eq!(1, node.writes.load(Ordering::SeqCst));
+        assert_eq!(1, dispatcher.writes.load(Ordering::SeqCst));
     }
 
     #[tokio::test]
@@ -492,9 +486,8 @@ mod tests {
             &ctx,
             &MockFlushPartitionProvider {
                 partition_rule_calls: Arc::new(AtomicUsize::new(0)),
-                region_leader_calls: Arc::new(AtomicUsize::new(0)),
             },
-            &AffectedRowsFlushNodeRequester { affected_rows: 7 },
+            &AffectedRowsFlushWriteDispatcher { affected_rows: 7 },
             &MockFlushCatalogProvider {
                 table: Some(mock_physical_table_metadata(1024)),
             },
@@ -506,7 +499,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_flush_batch_physical_stops_before_partition_and_node_when_table_missing() {
+    async fn test_flush_batch_physical_stops_before_partition_and_dispatch_when_table_missing() {
         let table_batches = vec![TableBatch {
             table_name: "t1".to_string(),
             table_id: 11,
@@ -514,8 +507,7 @@ mod tests {
             row_count: 1,
         }];
         let partition_calls = Arc::new(AtomicUsize::new(0));
-        let leader_calls = Arc::new(AtomicUsize::new(0));
-        let node = MockFlushNodeRequester::default();
+        let dispatcher = MockFlushWriteDispatcher::default();
         let ctx = session::context::QueryContext::arc();
 
         let err = flush_batch_physical(
@@ -524,9 +516,8 @@ mod tests {
             &ctx,
             &MockFlushPartitionProvider {
                 partition_rule_calls: partition_calls.clone(),
-                region_leader_calls: leader_calls.clone(),
             },
-            &node,
+            &dispatcher,
             &MockFlushCatalogProvider { table: None },
         )
         .await
@@ -537,8 +528,7 @@ mod tests {
                 .contains("Physical table 'missing_phy' not found")
         );
         assert_eq!(0, partition_calls.load(Ordering::SeqCst));
-        assert_eq!(0, leader_calls.load(Ordering::SeqCst));
-        assert_eq!(0, node.writes.load(Ordering::SeqCst));
+        assert_eq!(0, dispatcher.writes.load(Ordering::SeqCst));
     }
 
     #[tokio::test]
@@ -558,8 +548,7 @@ mod tests {
             },
         ];
         let partition_calls = Arc::new(AtomicUsize::new(0));
-        let leader_calls = Arc::new(AtomicUsize::new(0));
-        let node = MockFlushNodeRequester::default();
+        let dispatcher = MockFlushWriteDispatcher::default();
         let ctx = session::context::QueryContext::arc();
 
         let err = flush_batch_physical(
@@ -568,9 +557,8 @@ mod tests {
             &ctx,
             &MockFlushPartitionProvider {
                 partition_rule_calls: partition_calls.clone(),
-                region_leader_calls: leader_calls.clone(),
             },
-            &node,
+            &dispatcher,
             &MockFlushCatalogProvider {
                 table: Some(mock_physical_table_metadata(1024)),
             },
@@ -580,8 +568,7 @@ mod tests {
 
         assert!(err.to_string().contains("unknown_tag"));
         assert_eq!(1, partition_calls.load(Ordering::SeqCst));
-        assert_eq!(0, leader_calls.load(Ordering::SeqCst));
-        assert_eq!(0, node.writes.load(Ordering::SeqCst));
+        assert_eq!(0, dispatcher.writes.load(Ordering::SeqCst));
     }
 
     fn mock_physical_table_metadata(table_id: TableId) -> PhysicalTableMetadata {
@@ -671,7 +658,6 @@ mod tests {
 
     struct MockFlushPartitionProvider {
         partition_rule_calls: Arc<AtomicUsize>,
-        region_leader_calls: Arc<AtomicUsize>,
     }
 
     #[async_trait]
@@ -679,40 +665,28 @@ mod tests {
         async fn find_table_partition_rule(
             &self,
             _table_info: &table::metadata::TableInfo,
-        ) -> PartitionResult<PartitionRuleRef> {
+        ) -> PartitionResult<(PartitionRuleRef, HashMap<u32, Option<u64>>)> {
             self.partition_rule_calls.fetch_add(1, Ordering::SeqCst);
-            Ok(Arc::new(SingleRegionPartitionRule))
-        }
-
-        async fn find_region_leader(&self, _region_id: RegionId) -> error::Result<Peer> {
-            self.region_leader_calls.fetch_add(1, Ordering::SeqCst);
-            Ok(Peer {
-                id: 1,
-                addr: "node-1".to_string(),
-            })
+            Ok((Arc::new(SingleRegionPartitionRule), HashMap::new()))
         }
     }
 
     #[derive(Default)]
-    struct MockFlushNodeRequester {
+    struct MockFlushWriteDispatcher {
         writes: Arc<AtomicUsize>,
         fail: bool,
     }
 
     #[async_trait]
-    impl PhysicalFlushNodeRequester for MockFlushNodeRequester {
-        async fn handle(
-            &self,
-            _peer: &Peer,
-            _request: RegionRequest,
-        ) -> error::Result<RegionResponse> {
+    impl PhysicalFlushWriteDispatcher for MockFlushWriteDispatcher {
+        async fn dispatch(&self, _requests: Vec<RegionRequest>) -> error::Result<usize> {
             self.writes.fetch_add(1, Ordering::SeqCst);
             if self.fail {
                 return Err(Error::Internal {
                     err_msg: "physical write failed".to_string(),
                 });
             }
-            Ok(RegionResponse::new(0))
+            Ok(0)
         }
     }
 
@@ -726,18 +700,14 @@ mod tests {
     }
 
     #[derive(Default)]
-    struct AffectedRowsFlushNodeRequester {
+    struct AffectedRowsFlushWriteDispatcher {
         affected_rows: usize,
     }
 
     #[async_trait]
-    impl PhysicalFlushNodeRequester for AffectedRowsFlushNodeRequester {
-        async fn handle(
-            &self,
-            _peer: &Peer,
-            _request: RegionRequest,
-        ) -> error::Result<RegionResponse> {
-            Ok(RegionResponse::new(self.affected_rows))
+    impl PhysicalFlushWriteDispatcher for AffectedRowsFlushWriteDispatcher {
+        async fn dispatch(&self, _requests: Vec<RegionRequest>) -> error::Result<usize> {
+            Ok(self.affected_rows)
         }
     }
 }
diff --git a/src/servers/src/batcher/logical_table/batch_convert.rs b/src/servers/src/batcher/logical_table/batch_convert.rs
index 37080dbe258..65204ec038c 100644
--- a/src/servers/src/batcher/logical_table/batch_convert.rs
+++ b/src/servers/src/batcher/logical_table/batch_convert.rs
@@ -29,8 +29,6 @@ use crate::error;
 use crate::error::Result;
 use crate::metrics::PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED;
 
-pub(in crate::batcher::logical_table) const PHYSICAL_REGION_ESSENTIAL_COLUMN_COUNT: usize = 3;
-
 /// An aligned logical record batch and its timestamp column index.
 #[derive(Debug, Clone)]
 pub struct RecordBatchWithTsIdx {
@@ -188,23 +186,6 @@ pub(in crate::batcher::logical_table) fn columns_taxonomy(
     Ok((tag_columns, essential_column_indices))
 }
 
-pub(in crate::batcher::logical_table) fn strip_partition_columns_from_batch(
-    batch: RecordBatch,
-) -> Result<RecordBatch> {
-    ensure!(
-        batch.num_columns() >= PHYSICAL_REGION_ESSENTIAL_COLUMN_COUNT,
-        error::InternalSnafu {
-            err_msg: format!(
-                "Expected at least {} columns in physical batch, got {}",
-                PHYSICAL_REGION_ESSENTIAL_COLUMN_COUNT,
-                batch.num_columns()
-            ),
-        }
-    );
-    let essential_indices: Vec<usize> = (0..PHYSICAL_REGION_ESSENTIAL_COLUMN_COUNT).collect();
-    batch.project(&essential_indices).context(error::ArrowSnafu)
-}
-
 /// Transforms logical table batches into physical format (sparse primary key encoding).
 ///
 /// It identifies tag columns and essential columns (timestamp, value) for each logical batch
@@ -290,79 +271,18 @@ mod tests {
     use std::collections::{HashMap, HashSet};
     use std::sync::Arc;
 
-    use arrow::array::{Array, BinaryArray, StringArray, TimestampMillisecondArray};
+    use arrow::array::{Array, StringArray, TimestampMillisecondArray};
     use arrow::datatypes::{DataType as ArrowDataType, Field, Schema as ArrowSchema};
     use arrow::record_batch::RecordBatch;
     use metric_engine::batch_modifier::modify_batch_sparse;
     use smallvec::SmallVec;
 
     use crate::batcher::logical_table::batch_convert::{
-        TableBatch, columns_taxonomy, strip_partition_columns_from_batch,
-        transform_logical_batches_to_physical,
+        TableBatch, columns_taxonomy, transform_logical_batches_to_physical,
     };
     use crate::batcher::logical_table::test_util::mock_aligned_tag_batch;
     use crate::error::Error;
 
-    #[test]
-    fn test_strip_partition_columns_from_batch_removes_partition_tags() {
-        let batch = RecordBatch::try_new(
-            Arc::new(ArrowSchema::new(vec![
-                Field::new("__primary_key", ArrowDataType::Binary, false),
-                Field::new(
-                    "greptime_timestamp",
-                    ArrowDataType::Timestamp(arrow::datatypes::TimeUnit::Millisecond, None),
-                    false,
-                ),
-                Field::new("greptime_value", ArrowDataType::Float64, true),
-                Field::new("host", ArrowDataType::Utf8, true),
-            ])),
-            vec![
-                Arc::new(BinaryArray::from(vec![b"k1".as_slice()])),
-                Arc::new(TimestampMillisecondArray::from(vec![1000_i64])),
-                Arc::new(arrow::array::Float64Array::from(vec![42.0_f64])),
-                Arc::new(StringArray::from(vec!["node-1"])),
-            ],
-        )
-        .unwrap();
-
-        let stripped = strip_partition_columns_from_batch(batch).unwrap();
-
-        assert_eq!(3, stripped.num_columns());
-        assert_eq!("__primary_key", stripped.schema().field(0).name());
-        assert_eq!("greptime_timestamp", stripped.schema().field(1).name());
-        assert_eq!("greptime_value", stripped.schema().field(2).name());
-    }
-
-    #[test]
-    fn test_strip_partition_columns_from_batch_projects_essential_columns_without_lookup() {
-        let batch = RecordBatch::try_new(
-            Arc::new(ArrowSchema::new(vec![
-                Field::new("__primary_key", ArrowDataType::Binary, false),
-                Field::new(
-                    "greptime_timestamp",
-                    ArrowDataType::Timestamp(arrow::datatypes::TimeUnit::Millisecond, None),
-                    false,
-                ),
-                Field::new("greptime_value", ArrowDataType::Float64, true),
-                Field::new("host", ArrowDataType::Utf8, true),
-            ])),
-            vec![
-                Arc::new(BinaryArray::from(vec![b"k1".as_slice()])),
-                Arc::new(TimestampMillisecondArray::from(vec![1000_i64])),
-                Arc::new(arrow::array::Float64Array::from(vec![42.0_f64])),
-                Arc::new(StringArray::from(vec!["node-1"])),
-            ],
-        )
-        .unwrap();
-
-        let stripped = strip_partition_columns_from_batch(batch).unwrap();
-
-        assert_eq!(3, stripped.num_columns());
-        assert_eq!("__primary_key", stripped.schema().field(0).name());
-        assert_eq!("greptime_timestamp", stripped.schema().field(1).name());
-        assert_eq!("greptime_value", stripped.schema().field(2).name());
-    }
-
     #[test]
     fn test_collect_tag_columns_and_non_tag_indices_keeps_partition_tag_column() {
         let schema = Arc::new(ArrowSchema::new(vec![
diff --git a/src/servers/src/batcher/logical_table/pending_worker.rs b/src/servers/src/batcher/logical_table/pending_worker.rs
index 4a83d8a87f4..ff363c7637c 100644
--- a/src/servers/src/batcher/logical_table/pending_worker.rs
+++ b/src/servers/src/batcher/logical_table/pending_worker.rs
@@ -22,8 +22,8 @@ use common_batcher::flush_policy::FlushTrigger;
 use common_batcher::flush_policy::timing::TimingFlushPolicy;
 use common_batcher::pending_worker::PendingWorker as PendingCore;
 use common_batcher::worker_registry::WorkerRegistry;
-use common_meta::node_manager::NodeManagerRef;
 use common_telemetry::debug;
+use operator::write_dispatcher::WriteDispatcherRef;
 use partition::manager::PartitionRuleManagerRef;
 use session::context::QueryContextRef;
 use table::metadata::TableId;
@@ -31,7 +31,7 @@ use tokio::sync::{OwnedSemaphorePermit, broadcast, mpsc, oneshot};
 
 use crate::batcher::flow_notifier::FlowNotifier;
 use crate::batcher::logical_table::BatchKey;
-use crate::batcher::logical_table::batch::{Batch, flush_batch_with_managers, spawn_flush};
+use crate::batcher::logical_table::batch::{self, Batch};
 use crate::batcher::logical_table::batch_convert::{RecordBatchWithTsIdx, TableBatch};
 use crate::error::Error;
 use crate::metrics::{PENDING_BATCHES, PENDING_ROWS, PENDING_WORKERS};
@@ -53,7 +53,8 @@ pub(in crate::batcher::logical_table) struct PendingWorker {
     pub(in crate::batcher::logical_table) tx: mpsc::Sender<WorkerCommand>,
 }
 
-pub(in crate::batcher::logical_table) enum WorkerCommand {
+/// Commands accepted by a logical-table batching worker.
+pub(crate) enum WorkerCommand {
     Submit {
         table_batches: Vec<(String, u32, RecordBatchWithTsIdx)>,
         total_rows: usize,
@@ -92,15 +93,16 @@ impl PendingBatch {
     }
 }
 
+/// Starts a worker that accumulates logical rows and dispatches physical flushes.
 #[allow(clippy::too_many_arguments)]
-pub(in crate::batcher::logical_table) fn start_worker(
+pub(crate) fn start_worker(
     key: BatchKey,
     worker_tx: mpsc::Sender<WorkerCommand>,
     workers: Arc<WorkerRegistry<BatchKey, WorkerCommand>>,
     mut rx: mpsc::Receiver<WorkerCommand>,
     shutdown: broadcast::Sender<()>,
     partition_manager: PartitionRuleManagerRef,
-    node_manager: NodeManagerRef,
+    write_dispatcher: WriteDispatcherRef,
     catalog_manager: CatalogManagerRef,
     flow_notification_tx: FlowNotifier,
     worker_idle_timeout: Duration,
@@ -140,10 +142,10 @@ pub(in crate::batcher::logical_table) fn start_worker(
                             PENDING_ROWS.add(total_rows as i64);
 
                             if let Some(flush) = drain_batch(&mut batch, &mut pending_flush, Some(FlushTrigger::Submission)) {
-                                spawn_flush(
+                                batch::spawn_flush(
                                     flush,
                                     partition_manager.clone(),
-                                    node_manager.clone(),
+                                    write_dispatcher.clone(),
                                     catalog_manager.clone(),
                                     flow_notification_tx.clone(),
                                     flush_limiter.clone(),
@@ -152,10 +154,10 @@ pub(in crate::batcher::logical_table) fn start_worker(
                         }
                         None => {
                             if let Some(flush) = drain_batch(&mut batch, &mut pending_flush, None) {
-                                flush_batch_with_managers(
+                                batch::flush_batch_with_managers(
                                     flush,
                                     partition_manager.clone(),
-                                    node_manager.clone(),
+                                    write_dispatcher.clone(),
                                     catalog_manager.clone(),
                                     flow_notification_tx.clone(),
                                 ).await;
@@ -189,10 +191,10 @@ pub(in crate::batcher::logical_table) fn start_worker(
                 }
                 _ = pending_flush.wait_flush() => {
                     if let Some(flush) = drain_batch(&mut batch, &mut pending_flush, Some(FlushTrigger::Deadline)) {
-                        spawn_flush(
+                        batch::spawn_flush(
                             flush,
                             partition_manager.clone(),
-                            node_manager.clone(),
+                            write_dispatcher.clone(),
                             catalog_manager.clone(),
                             flow_notification_tx.clone(),
                             flush_limiter.clone(),
@@ -201,10 +203,10 @@ pub(in crate::batcher::logical_table) fn start_worker(
                 }
                 _ = shutdown_rx.recv() => {
                     if let Some(flush) = drain_batch(&mut batch, &mut pending_flush, None) {
-                        flush_batch_with_managers(
+                        batch::flush_batch_with_managers(
                             flush,
                             partition_manager.clone(),
-                            node_manager.clone(),
+                            write_dispatcher.clone(),
                             catalog_manager.clone(),
                             flow_notification_tx.clone(),
                         ).await;
@@ -286,6 +288,7 @@ mod tests {
     use common_meta::kv_backend::memory::MemoryKvBackend;
     use common_meta::node_manager::NodeManagerRef;
     use moka::future::CacheBuilder;
+    use operator::write_dispatcher::WriteDispatcher;
     use partition::cache::new_partition_info_cache;
     use partition::manager::PartitionRuleManager;
     use tokio::sync::{Semaphore, broadcast, mpsc, oneshot};
@@ -502,6 +505,10 @@ mod tests {
         let node_manager: NodeManagerRef = Arc::new(ConcurrentMockNodeManager {
             datanodes: Arc::new(HashMap::new()),
         });
+        let write_dispatcher = Arc::new(WriteDispatcher::new(
+            node_manager,
+            partition_manager.clone(),
+        ));
         let catalog_manager = MemoryCatalogManager::with_default_setup();
         let (flow_notification_tx, _flow_notification_rx) =
             FlowNotifier::try_new(1, FLOW_NOTIFICATION_DROPPED.clone()).unwrap();
@@ -515,7 +522,7 @@ mod tests {
             worker_rx,
             shutdown.clone(),
             partition_manager,
-            node_manager,
+            write_dispatcher,
             catalog_manager,
             flow_notification_tx,
             worker_idle_timeout,
diff --git a/src/servers/src/batcher/logical_table/region_write.rs b/src/servers/src/batcher/logical_table/region_write.rs
index 71b558d1428..9511d21a998 100644
--- a/src/servers/src/batcher/logical_table/region_write.rs
+++ b/src/servers/src/batcher/logical_table/region_write.rs
@@ -14,29 +14,27 @@
 
 use std::collections::HashMap;
 
-use api::v1::ArrowIpc;
-use api::v1::meta::Peer;
 use api::v1::region::{
     BulkInsertRequest, RegionRequest, RegionRequestHeader, bulk_insert_request, region_request,
 };
-use arrow::compute::filter_record_batch;
+use api::v1::{ArrowIpc, PartitionExprVersion};
+use arrow::compute;
 use arrow::record_batch::RecordBatch;
 use async_trait::async_trait;
 use catalog::CatalogManagerRef;
 use common_grpc::error::Error as GrpcError;
-use common_grpc::flight::record_batch_to_ipc;
-use common_meta::node_manager::NodeManagerRef;
+use common_grpc::flight;
 use common_telemetry::tracing_context::TracingContext;
+use operator::write_dispatcher::WriteDispatcherRef;
 use partition::manager::PartitionRuleManagerRef;
 use partition::partition::PartitionRuleRef;
 use snafu::ResultExt;
 use store_api::storage::RegionId;
 use table::metadata::{TableId, TableInfo, TableInfoRef};
 
-use crate::batcher::logical_table::batch_convert::strip_partition_columns_from_batch;
 use crate::error;
 use crate::error::{Error, Result};
-use crate::metrics::PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED;
+use crate::metrics;
 
 #[derive(Clone)]
 pub struct PhysicalTableMetadata {
@@ -56,23 +54,21 @@ pub trait PhysicalFlushCatalogProvider: Send + Sync {
     ) -> catalog::error::Result<Option<PhysicalTableMetadata>>;
 }
 
+/// Loads the physical partition rule and its expression versions.
 #[async_trait]
 pub trait PhysicalFlushPartitionProvider: Send + Sync {
+    /// Loads a routing snapshot for the physical table.
     async fn find_table_partition_rule(
         &self,
         table_info: &TableInfo,
-    ) -> partition::error::Result<PartitionRuleRef>;
-
-    async fn find_region_leader(&self, region_id: RegionId) -> Result<Peer>;
+    ) -> partition::error::Result<(PartitionRuleRef, HashMap<u32, Option<u64>>)>;
 }
 
+/// Dispatches the region requests produced by a physical flush.
 #[async_trait]
-pub trait PhysicalFlushNodeRequester: Send + Sync {
-    async fn handle(
-        &self,
-        peer: &Peer,
-        request: RegionRequest,
-    ) -> Result<api::region::RegionResponse>;
+pub trait PhysicalFlushWriteDispatcher: Send + Sync {
+    /// Dispatches one physical flush together, sharing routing refreshes across its writes.
+    async fn dispatch(&self, requests: Vec<RegionRequest>) -> Result<usize>;
 }
 
 #[derive(Clone)]
@@ -115,125 +111,61 @@ impl PhysicalFlushPartitionProvider for PartitionManagerPhysicalFlushAdapter {
     async fn find_table_partition_rule(
         &self,
         table_info: &TableInfo,
-    ) -> partition::error::Result<PartitionRuleRef> {
+    ) -> partition::error::Result<(PartitionRuleRef, HashMap<u32, Option<u64>>)> {
         self.partition_manager
             .find_table_partition_rule(table_info)
             .await
-            .map(|(rule, _)| rule)
-    }
-
-    async fn find_region_leader(&self, region_id: RegionId) -> Result<Peer> {
-        let peer = self.partition_manager.find_region_leader(region_id).await?;
-        Ok(peer)
     }
 }
 
+/// Sends a physical flush through the shared write dispatcher.
 #[derive(Clone)]
-pub(in crate::batcher::logical_table) struct NodeManagerPhysicalFlushAdapter {
-    pub(in crate::batcher::logical_table) node_manager: NodeManagerRef,
+pub(crate) struct WriteDispatcherPhysicalFlushAdapter {
+    pub(crate) write_dispatcher: WriteDispatcherRef,
 }
 
 #[async_trait]
-impl PhysicalFlushNodeRequester for NodeManagerPhysicalFlushAdapter {
-    async fn handle(
-        &self,
-        peer: &Peer,
-        request: RegionRequest,
-    ) -> error::Result<api::region::RegionResponse> {
-        let datanode = self.node_manager.datanode(peer).await;
-        datanode
-            .handle(request)
+impl PhysicalFlushWriteDispatcher for WriteDispatcherPhysicalFlushAdapter {
+    async fn dispatch(&self, requests: Vec<RegionRequest>) -> Result<usize> {
+        self.write_dispatcher
+            .dispatch_with_metrics(
+                requests,
+                metrics::PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
+                    .with_label_values(&["flush_write_region"]),
+            )
             .await
             .context(error::CommonMetaSnafu)
+            .map(|response| response.affected_rows)
     }
 }
 
-pub(in crate::batcher::logical_table) struct FlushRegionWrite {
-    pub(in crate::batcher::logical_table) datanode: Peer,
-    pub(in crate::batcher::logical_table) request: RegionRequest,
-}
-
-pub(in crate::batcher::logical_table) struct PlannedRegionBatch {
-    pub(in crate::batcher::logical_table) region_id: RegionId,
-    pub(in crate::batcher::logical_table) batch: RecordBatch,
+/// Arrow rows selected for one physical region.
+pub(crate) struct PlannedRegionBatch {
+    pub(crate) region_id: RegionId,
+    pub(crate) batch: RecordBatch,
 }
 
 #[cfg(test)]
 impl PlannedRegionBatch {
-    pub(in crate::batcher::logical_table) fn num_rows(&self) -> usize {
+    pub(crate) fn num_rows(&self) -> usize {
         self.batch.num_rows()
     }
 }
 
-pub(in crate::batcher::logical_table) struct ResolvedRegionBatch {
-    pub(in crate::batcher::logical_table) planned: PlannedRegionBatch,
-    pub(in crate::batcher::logical_table) datanode: Peer,
-}
-
-pub(in crate::batcher::logical_table) fn should_dispatch_concurrently(
-    region_write_count: usize,
-) -> bool {
-    region_write_count > 1
-}
-
-pub(in crate::batcher::logical_table) async fn flush_region_writes_concurrently(
-    node_manager: &(impl PhysicalFlushNodeRequester + ?Sized),
-    writes: Vec<FlushRegionWrite>,
-) -> Result<usize> {
-    let mut affected_rows = 0;
-    if !should_dispatch_concurrently(writes.len()) {
-        for write in writes {
-            let _timer = PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
-                .with_label_values(&["flush_write_region"])
-                .start_timer();
-            affected_rows += node_manager
-                .handle(&write.datanode, write.request)
-                .await?
-                .affected_rows;
-        }
-        return Ok(affected_rows);
-    }
-
-    let write_futures = writes.into_iter().map(|write| async move {
-        let _timer = PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
-            .with_label_values(&["flush_write_region"])
-            .start_timer();
-
-        let response = node_manager.handle(&write.datanode, write.request).await?;
-        Ok::<_, Error>(response.affected_rows)
-    });
-
-    // todo(hl): should be bounded.
-    let affected_rows = futures::future::try_join_all(write_futures)
-        .await?
-        .into_iter()
-        .sum();
-    Ok(affected_rows)
-}
-
 pub(in crate::batcher::logical_table) fn split_combined_batch_by_region(
     combined_batch: &RecordBatch,
     partition_rule: &dyn partition::partition::PartitionRule,
 ) -> Result<HashMap<u32, partition::partition::RegionMask>> {
-    let _timer = PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
+    let _timer = metrics::PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
         .with_label_values(&["flush_physical_split_record_batch"])
         .start_timer();
     let map = partition_rule.split_record_batch(combined_batch)?;
     Ok(map)
 }
 
-pub(in crate::batcher::logical_table) fn prepare_physical_region_routing_batch(
-    combined_batch: RecordBatch,
-    partition_columns: &[String],
-) -> Result<RecordBatch> {
-    if partition_columns.is_empty() {
-        return Ok(combined_batch);
-    }
-    strip_partition_columns_from_batch(combined_batch)
-}
-
-pub(in crate::batcher::logical_table) fn plan_region_batch(
-    stripped_batch: &RecordBatch,
+/// Selects the rows assigned to one physical region.
+pub(crate) fn plan_region_batch(
+    combined_batch: &RecordBatch,
     physical_table_id: TableId,
     region_number: u32,
     mask: &partition::partition::RegionMask,
@@ -243,12 +175,12 @@ pub(in crate::batcher::logical_table) fn plan_region_batch(
     }
 
     let region_batch = if mask.select_all() {
-        stripped_batch.clone()
+        combined_batch.clone()
     } else {
-        let _timer = PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
+        let _timer = metrics::PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
             .with_label_values(&["flush_physical_filter_record_batch"])
             .start_timer();
-        filter_record_batch(stripped_batch, mask.array()).context(error::ArrowSnafu)?
+        compute::filter_record_batch(combined_batch, mask.array()).context(error::ArrowSnafu)?
     };
 
     let row_count = region_batch.num_rows();
@@ -262,19 +194,20 @@ pub(in crate::batcher::logical_table) fn plan_region_batch(
     }))
 }
 
-pub(in crate::batcher::logical_table) fn plan_region_batches(
+/// Partitions a physical flush while retaining columns needed for rerouting.
+pub(crate) fn plan_region_batches(
     combined_batch: RecordBatch,
     physical_table_id: TableId,
     partition_rule: &dyn partition::partition::PartitionRule,
-    partition_columns: &[String],
 ) -> Result<Vec<PlannedRegionBatch>> {
     let region_masks = split_combined_batch_by_region(&combined_batch, partition_rule)?;
-    let stripped_batch = prepare_physical_region_routing_batch(combined_batch, partition_columns)?;
 
+    // Retain partition columns in the RPC payload so routing can be rebuilt after repartition.
+    // Mito's sparse bulk conversion projects the stored fields and encoded primary key.
     let mut planned_batches = Vec::new();
     for (region_number, mask) in region_masks {
         if let Some(planned_batch) =
-            plan_region_batch(&stripped_batch, physical_table_id, region_number, &mask)?
+            plan_region_batch(&combined_batch, physical_table_id, region_number, &mask)?
         {
             planned_batches.push(planned_batch);
         }
@@ -283,39 +216,20 @@ pub(in crate::batcher::logical_table) fn plan_region_batches(
     Ok(planned_batches)
 }
 
-pub(in crate::batcher::logical_table) async fn resolve_region_targets(
+/// Encodes each region batch with the partition version used to select its rows.
+pub(crate) fn encode_region_write_requests(
     planned_batches: Vec<PlannedRegionBatch>,
-    partition_manager: &(impl PhysicalFlushPartitionProvider + ?Sized),
-) -> Result<Vec<ResolvedRegionBatch>> {
-    let mut resolved_batches = Vec::with_capacity(planned_batches.len());
-    for planned in planned_batches {
-        let datanode = {
-            let _timer = PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
-                .with_label_values(&["flush_physical_resolve_region_leader"])
-                .start_timer();
-            partition_manager
-                .find_region_leader(planned.region_id)
-                .await?
-        };
-
-        resolved_batches.push(ResolvedRegionBatch { planned, datanode });
-    }
-
-    Ok(resolved_batches)
-}
-
-pub(in crate::batcher::logical_table) fn encode_region_write_requests(
-    resolved_batches: Vec<ResolvedRegionBatch>,
     skip_wal: bool,
-) -> Result<Vec<FlushRegionWrite>> {
-    let mut region_writes = Vec::with_capacity(resolved_batches.len());
-    for resolved in resolved_batches {
-        let region_id = resolved.planned.region_id;
+    partition_versions: &HashMap<u32, Option<u64>>,
+) -> Result<Vec<RegionRequest>> {
+    let mut region_writes = Vec::with_capacity(planned_batches.len());
+    for planned in planned_batches {
+        let region_id = planned.region_id;
         let (schema_bytes, data_header, payload) = {
-            let _timer = PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
+            let _timer = metrics::PENDING_ROWS_BATCH_FLUSH_STAGE_ELAPSED
                 .with_label_values(&["flush_physical_encode_ipc"])
                 .start_timer();
-            record_batch_to_ipc(resolved.planned.batch).map_err(map_ipc_error)?
+            flight::record_batch_to_ipc(planned.batch).map_err(map_ipc_error)?
         };
 
         let request = RegionRequest {
@@ -326,7 +240,11 @@ pub(in crate::batcher::logical_table) fn encode_region_write_requests(
             body: Some(region_request::Body::BulkInsert(BulkInsertRequest {
                 skip_wal,
                 region_id: region_id.as_u64(),
-                partition_expr_version: None,
+                partition_expr_version: partition_versions
+                    .get(&region_id.region_number())
+                    .copied()
+                    .flatten()
+                    .map(|value| PartitionExprVersion { value }),
                 // Set aligned_schema_version to None so that datanode will check the batch schema again to see if any
                 // column is missing.
                 aligned_schema_version: None,
@@ -338,10 +256,7 @@ pub(in crate::batcher::logical_table) fn encode_region_write_requests(
             })),
         };
 
-        region_writes.push(FlushRegionWrite {
-            datanode: resolved.datanode,
-            request,
-        });
+        region_writes.push(request);
     }
 
     Ok(region_writes)
@@ -359,89 +274,27 @@ pub(in crate::batcher::logical_table) fn map_ipc_error(error: GrpcError) -> Erro
 
 #[cfg(test)]
 mod tests {
-    use std::collections::HashMap;
+    use std::collections::{HashMap, HashSet};
     use std::sync::Arc;
-    use std::sync::atomic::{AtomicUsize, Ordering};
-    use std::time::Duration;
 
-    use api::region::RegionResponse;
-    use api::v1::meta::Peer;
-    use api::v1::region::{RegionRequest, region_request};
-    use arrow::array::{BinaryArray, BooleanArray, StringArray, TimestampMillisecondArray};
+    use api::v1::PartitionExprVersion;
+    use api::v1::region::{bulk_insert_request, region_request};
+    use arrow::array::{Array, BinaryArray, BooleanArray, StringArray, TimestampMillisecondArray};
     use arrow::datatypes::{DataType as ArrowDataType, Field, Schema as ArrowSchema};
     use arrow::record_batch::RecordBatch;
-    use async_trait::async_trait;
-    use common_meta::error::Result as MetaResult;
-    use common_meta::node_manager::{Datanode, DatanodeRef};
-    use common_query::request::QueryRequest;
-    use common_recordbatch::SendableRecordBatchStream;
+    use common_grpc::flight::FlightDecoder;
     use partition::partition::{PartitionRule, RegionMask};
     use store_api::storage::RegionId;
-    use tokio::time::sleep;
 
+    use crate::batcher::logical_table::batch_convert::{self, RecordBatchWithTsIdx, TableBatch};
     use crate::batcher::logical_table::region_write::{
-        FlushRegionWrite, PlannedRegionBatch, ResolvedRegionBatch, encode_region_write_requests,
-        flush_region_writes_concurrently, plan_region_batches, should_dispatch_concurrently,
+        PlannedRegionBatch, encode_region_write_requests, plan_region_batches,
     };
-    use crate::batcher::logical_table::test_util::ConcurrentMockNodeManager;
-
-    #[tokio::test]
-    async fn test_flush_region_writes_concurrently_dispatches_multiple_datanodes() {
-        let inflight = Arc::new(AtomicUsize::new(0));
-        let max_inflight = Arc::new(AtomicUsize::new(0));
-        let datanode1: DatanodeRef = Arc::new(ConcurrentMockDatanode {
-            delay: Duration::from_millis(100),
-            inflight: inflight.clone(),
-            max_inflight: max_inflight.clone(),
-        });
-        let datanode2: DatanodeRef = Arc::new(ConcurrentMockDatanode {
-            delay: Duration::from_millis(100),
-            inflight,
-            max_inflight: max_inflight.clone(),
-        });
-
-        let mut datanodes = HashMap::new();
-        datanodes.insert(1, datanode1);
-        datanodes.insert(2, datanode2);
-        let node_manager = Arc::new(ConcurrentMockNodeManager {
-            datanodes: Arc::new(datanodes),
-        });
-
-        let writes = vec![
-            FlushRegionWrite {
-                datanode: Peer {
-                    id: 1,
-                    addr: "node1".to_string(),
-                },
-                request: RegionRequest::default(),
-            },
-            FlushRegionWrite {
-                datanode: Peer {
-                    id: 2,
-                    addr: "node2".to_string(),
-                },
-                request: RegionRequest::default(),
-            },
-        ];
-
-        flush_region_writes_concurrently(node_manager.as_ref(), writes)
-            .await
-            .unwrap();
-        assert!(max_inflight.load(Ordering::SeqCst) >= 2);
-    }
 
     #[test]
-    fn test_should_dispatch_concurrently_by_region_count() {
-        assert!(!should_dispatch_concurrently(0));
-        assert!(!should_dispatch_concurrently(1));
-        assert!(should_dispatch_concurrently(2));
-    }
-
-    #[test]
-    fn test_plan_region_batches_splits_and_strips_partition_columns() {
-        let combined_batch = RecordBatch::try_new(
+    fn test_plan_region_batches_preserves_partition_columns_through_encoding() {
+        let logical_batch = RecordBatch::try_new(
             Arc::new(ArrowSchema::new(vec![
-                Field::new("__primary_key", ArrowDataType::Binary, false),
                 Field::new(
                     "greptime_timestamp",
                     ArrowDataType::Timestamp(arrow::datatypes::TimeUnit::Millisecond, None),
@@ -449,22 +302,38 @@ mod tests {
                 ),
                 Field::new("greptime_value", ArrowDataType::Float64, true),
                 Field::new("host", ArrowDataType::Utf8, true),
+                Field::new("zone", ArrowDataType::Utf8, true),
             ])),
             vec![
-                Arc::new(BinaryArray::from(vec![b"k1".as_slice(), b"k2".as_slice()])),
                 Arc::new(TimestampMillisecondArray::from(vec![1000_i64, 2000_i64])),
                 Arc::new(arrow::array::Float64Array::from(vec![1.0_f64, 2.0_f64])),
                 Arc::new(StringArray::from(vec!["node-1", "node-2"])),
+                Arc::new(StringArray::from(vec!["east", "west"])),
             ],
         )
         .unwrap();
+        let table_batches = [TableBatch {
+            table_name: "metric".to_string(),
+            table_id: 2048,
+            batches: vec![RecordBatchWithTsIdx::try_new(logical_batch, 0).unwrap()],
+            row_count: 2,
+        }];
+        let modified = batch_convert::transform_logical_batches_to_physical(
+            &table_batches,
+            &HashMap::from([("host".to_string(), 1), ("zone".to_string(), 2)]),
+            &HashSet::from(["host"]),
+        )
+        .unwrap();
+        let combined_batch = batch_convert::concat_modified_batches(&modified).unwrap();
+        assert!(combined_batch.column_by_name("host").is_some());
+        assert!(combined_batch.column_by_name("zone").is_none());
+        let expected = combined_batch.clone();
         let mut planned_batches = plan_region_batches(
             combined_batch,
             1024,
             &TwoRegionPartitionRule {
                 partition_columns: vec!["host".to_string()],
             },
-            &["host".to_string()],
         )
         .unwrap();
         planned_batches.sort_by_key(|planned| planned.region_id.region_number());
@@ -472,10 +341,45 @@ mod tests {
         assert_eq!(2, planned_batches.len());
         assert_eq!(RegionId::new(1024, 1), planned_batches[0].region_id);
         assert_eq!(1, planned_batches[0].num_rows());
-        assert_eq!(3, planned_batches[0].batch.num_columns());
+        assert_eq!(4, planned_batches[0].batch.num_columns());
         assert_eq!(RegionId::new(1024, 2), planned_batches[1].region_id);
         assert_eq!(1, planned_batches[1].num_rows());
-        assert_eq!(3, planned_batches[1].batch.num_columns());
+        assert_eq!(4, planned_batches[1].batch.num_columns());
+
+        let writes = encode_region_write_requests(
+            planned_batches,
+            false,
+            &HashMap::from([(1, Some(7)), (2, Some(8))]),
+        )
+        .unwrap();
+        for (index, write) in writes.into_iter().enumerate() {
+            let Some(region_request::Body::BulkInsert(request)) = write.body else {
+                panic!("expected bulk")
+            };
+            assert_eq!(
+                request.partition_expr_version.unwrap().value,
+                7 + index as u64
+            );
+            let Some(bulk_insert_request::Body::ArrowIpc(ipc)) = request.body else {
+                panic!("expected IPC")
+            };
+            let batch = FlightDecoder::try_from_schema_bytes(&ipc.schema)
+                .unwrap()
+                .try_decode_record_batch(&ipc.data_header, &ipc.payload)
+                .unwrap();
+            // The partition-only Arrow projection must retain the complete sparse key,
+            // including the zone tag that a later partition rule can require.
+            assert!(batch.column_by_name("zone").is_none());
+            assert_eq!(batch, expected.slice(index, 1));
+            let tags = batch
+                .column_by_name("host")
+                .unwrap()
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap();
+            assert_eq!(tags.len(), 1);
+            assert_eq!(tags.value(0), if index == 0 { "node-1" } else { "node-2" });
+        }
     }
 
     #[test]
@@ -520,44 +424,6 @@ mod tests {
         }
     }
 
-    #[derive(Clone)]
-    struct ConcurrentMockDatanode {
-        delay: Duration,
-        inflight: Arc<AtomicUsize>,
-        max_inflight: Arc<AtomicUsize>,
-    }
-
-    #[async_trait]
-    impl Datanode for ConcurrentMockDatanode {
-        async fn handle(&self, _request: RegionRequest) -> MetaResult<RegionResponse> {
-            let now = self.inflight.fetch_add(1, Ordering::SeqCst) + 1;
-            loop {
-                let max = self.max_inflight.load(Ordering::SeqCst);
-                if now <= max {
-                    break;
-                }
-                if self
-                    .max_inflight
-                    .compare_exchange(max, now, Ordering::SeqCst, Ordering::SeqCst)
-                    .is_ok()
-                {
-                    break;
-                }
-            }
-
-            sleep(self.delay).await;
-            self.inflight.fetch_sub(1, Ordering::SeqCst);
-            Ok(RegionResponse::new(0))
-        }
-
-        async fn handle_query(
-            &self,
-            _request: QueryRequest,
-        ) -> MetaResult<SendableRecordBatchStream> {
-            unimplemented!()
-        }
-    }
-
     fn check_encode_region_write_requests(skip_wal: bool) {
         let planned_batch = PlannedRegionBatch {
             region_id: RegionId::new(1024, 1),
@@ -579,21 +445,22 @@ mod tests {
             )
             .unwrap(),
         };
-        let resolved_batch = ResolvedRegionBatch {
-            planned: planned_batch,
-            datanode: Peer {
-                id: 1,
-                addr: "node-1".to_string(),
-            },
-        };
-        let writes = encode_region_write_requests(vec![resolved_batch], skip_wal).unwrap();
+        let writes = encode_region_write_requests(
+            vec![planned_batch],
+            skip_wal,
+            &HashMap::from([(1, Some(7))]),
+        )
+        .unwrap();
 
         assert_eq!(1, writes.len());
-        assert_eq!(1, writes[0].datanode.id);
-        let Some(region_request::Body::BulkInsert(request)) = &writes[0].request.body else {
+        let Some(region_request::Body::BulkInsert(request)) = &writes[0].body else {
             panic!("expected bulk insert request");
         };
         assert_eq!(RegionId::new(1024, 1).as_u64(), request.region_id);
         assert_eq!(skip_wal, request.skip_wal);
+        assert_eq!(
+            Some(PartitionExprVersion { value: 7 }),
+            request.partition_expr_version
+        );
     }
 }
diff --git a/src/servers/src/batcher/logical_table/test_util.rs b/src/servers/src/batcher/logical_table/test_util.rs
index 1cc81f9b615..491bd6ff2b3 100644
--- a/src/servers/src/batcher/logical_table/test_util.rs
+++ b/src/servers/src/batcher/logical_table/test_util.rs
@@ -15,10 +15,9 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use api::region::RegionResponse;
 use api::v1::flow::{DirtyWindowRequests, FlowRequest, FlowResponse};
 use api::v1::meta::Peer;
-use api::v1::region::{InsertRequests, RegionRequest};
+use api::v1::region::InsertRequests;
 use arrow::array::{StringArray, TimestampMillisecondArray};
 use arrow::datatypes::{DataType as ArrowDataType, Field, Schema as ArrowSchema};
 use arrow::record_batch::RecordBatch;
@@ -27,12 +26,9 @@ use common_meta::error::Result as MetaResult;
 use common_meta::node_manager::{
     DatanodeManager, DatanodeRef, Flownode, FlownodeManager, FlownodeRef,
 };
-use snafu::ResultExt;
 use tokio::sync::mpsc;
 
 use crate::batcher::logical_table::batch_convert::RecordBatchWithTsIdx;
-use crate::batcher::logical_table::region_write::PhysicalFlushNodeRequester;
-use crate::error;
 
 pub(in crate::batcher::logical_table) fn mock_tag_batch(
     tag_name: &str,
@@ -149,14 +145,3 @@ impl FlownodeManager for FlowNotificationMockNodeManager {
         self.flownode.clone()
     }
 }
-
-#[async_trait]
-impl PhysicalFlushNodeRequester for ConcurrentMockNodeManager {
-    async fn handle(&self, peer: &Peer, request: RegionRequest) -> error::Result<RegionResponse> {
-        let datanode = self.datanode(peer).await;
-        datanode
-            .handle(request)
-            .await
-            .context(error::CommonMetaSnafu)
-    }
-}
diff --git a/src/servers/src/http/jaeger.rs b/src/servers/src/http/jaeger.rs
index 32ef6a61682..16dbaf76e53 100644
--- a/src/servers/src/http/jaeger.rs
+++ b/src/servers/src/http/jaeger.rs
@@ -328,7 +328,7 @@ impl QueryTraceParams {
                     }
                     .build()
                 })?;
-            for (_, v) in tags_map.iter_mut() {
+            for v in tags_map.values_mut() {
                 if let Some(number) = convert_string_to_number(v) {
                     *v = number;
                 }
diff --git a/src/servers/src/http/prometheus.rs b/src/servers/src/http/prometheus.rs
index 420a0c8f4b4..e417044ef43 100644
--- a/src/servers/src/http/prometheus.rs
+++ b/src/servers/src/http/prometheus.rs
@@ -49,11 +49,11 @@ use futures::future::join_all;
 use futures::{StreamExt, TryStreamExt};
 use itertools::Itertools;
 use promql_parser::label::{METRIC_NAME, MatchOp, Matcher, Matchers};
-use promql_parser::parser::token::{self};
+use promql_parser::parser::token::TokenType;
 use promql_parser::parser::value::ValueType;
 use promql_parser::parser::{
-    AggregateExpr, BinaryExpr, Call, Expr as PromqlExpr, LabelModifier, MatrixSelector, ParenExpr,
-    SubqueryExpr, UnaryExpr, VectorSelector,
+    AggregateExpr, BinModifier, BinaryExpr, Call, Expr as PromqlExpr, LabelModifier,
+    MatrixSelector, ParenExpr, SubqueryExpr, UnaryExpr, VectorMatchCardinality, VectorSelector,
 };
 use query::parser::{DEFAULT_LOOKBACK_STRING, PromQuery, QueryLanguageParser, QueryStatement};
 use serde::de::{self, MapAccess, Visitor};
@@ -547,6 +547,12 @@ pub async fn range_query(
         StatusCode::InvalidArguments
     );
     let promql_expr = prom_query.expr();
+    // Prometheus rejects a range-vector expression in a range query even when start == end,
+    // which the planner cannot tell apart from an instant query.
+    if promql_expr.value_type() == ValueType::Matrix {
+        let err = query::promql::error::RangeVectorInRangeQuerySnafu.build();
+        return PrometheusJsonResponse::error(err.status_code(), err.output_msg());
+    }
 
     let metric_name_discovery =
         try_call_return_response!(find_metric_name_not_equal_matchers(promql_expr));
@@ -1373,6 +1379,72 @@ fn promql_expr_to_metric_name(expr: &PromqlExpr) -> Option<String> {
     }
 }
 
+/// Whether the metric name survives a binary operation; see
+/// [`binary_metric_name_side`] for the operand that supplies it.
+///
+/// Follows Prometheus' `shouldDropMetricName` and `resultMetric`: set operators
+/// and comparisons keep the name, while arithmetic operators drop it. A
+/// comparison also drops it when it returns a bool or is a one-to-one
+/// `on(...)` match that does not keep `__name__` or an `ignoring(...)` match
+/// that excludes it. Prometheus keeps only the `on(...)` labels or deletes the
+/// `ignoring(...)` labels for one-to-one matches.
+fn binary_keeps_metric_name(op: &TokenType, modifier: Option<&BinModifier>) -> bool {
+    if op.is_set_operator() {
+        return true;
+    }
+
+    if !op.is_comparison_operator() {
+        return false;
+    }
+
+    let Some(m) = modifier else {
+        return true;
+    };
+
+    if m.return_bool {
+        return false;
+    }
+
+    if m.card == VectorMatchCardinality::OneToOne {
+        match &m.matching {
+            Some(LabelModifier::Include(labels))
+                if !labels.labels.contains(&METRIC_NAME.to_string()) =>
+            {
+                return false;
+            }
+            Some(LabelModifier::Exclude(labels))
+                if labels.labels.contains(&METRIC_NAME.to_string()) =>
+            {
+                return false;
+            }
+            _ => {}
+        }
+    }
+
+    true
+}
+
+/// The operand whose labels supply the result metric name of a binary
+/// operation.
+///
+/// Prometheus builds the result from the side whose labels it carries, i.e. the
+/// "many" side of the match: `group_right` makes the right-hand operand that
+/// side, and a scalar left-hand operand (for example `0.5 < a`) leaves the
+/// vector on the right. Every other case takes the left-hand operand.
+fn binary_metric_name_side<'a>(
+    lhs: &'a PromqlExpr,
+    rhs: &'a PromqlExpr,
+    modifier: Option<&BinModifier>,
+) -> &'a PromqlExpr {
+    let group_right =
+        modifier.is_some_and(|m| matches!(m.card, VectorMatchCardinality::OneToMany(_)));
+    if group_right || matches!(lhs.value_type(), ValueType::Scalar) {
+        rhs
+    } else {
+        lhs
+    }
+}
+
 /// Recursively collect all metric names from a PromQL expression
 fn collect_metric_names(expr: &PromqlExpr, metric_names: &mut HashSet<String>) {
     match expr {
@@ -1395,14 +1467,16 @@ fn collect_metric_names(expr: &PromqlExpr, metric_names: &mut HashSet<String>) {
             collect_metric_names(expr, metric_names)
         }
         PromqlExpr::Unary(UnaryExpr { .. }) => metric_names.clear(),
-        PromqlExpr::Binary(BinaryExpr { lhs, op, .. }) => {
-            if matches!(
-                op.id(),
-                token::T_LAND // INTERSECT
-                    | token::T_LOR // UNION
-                    | token::T_LUNLESS // EXCEPT
-            ) {
-                collect_metric_names(lhs, metric_names)
+        PromqlExpr::Binary(BinaryExpr {
+            lhs,
+            op,
+            rhs,
+            modifier,
+            ..
+        }) => {
+            if binary_keeps_metric_name(op, modifier.as_ref()) {
+                let side = binary_metric_name_side(lhs, rhs, modifier.as_ref());
+                collect_metric_names(side, metric_names)
             } else {
                 metric_names.clear()
             }
@@ -2762,6 +2836,45 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn range_query_rejects_range_vector_with_equal_endpoints() {
+        let handler = Arc::new(TestPrometheusHandler {
+            catalog_manager: MemoryCatalogManager::new(),
+            deny_operation: false,
+            denied_table: None,
+            metric_names: Vec::new(),
+            label_metric_names: Vec::new(),
+            label_lookups: Mutex::new(Vec::new()),
+            queries: Mutex::new(Vec::new()),
+            ordered_outputs: Mutex::new(Vec::new()),
+        });
+        let response = range_query(
+            State(handler.clone() as PrometheusHandlerRef),
+            Query(RangeQuery {
+                query: Some("vector(1)[5m:]".to_string()),
+                start: Some("300".to_string()),
+                end: Some("300".to_string()),
+                step: Some("1".to_string()),
+                ..Default::default()
+            }),
+            Extension(QueryContext::with(
+                DEFAULT_CATALOG_NAME,
+                DEFAULT_SCHEMA_NAME,
+            )),
+            Form(RangeQuery::default()),
+        )
+        .await;
+
+        assert_eq!(Some(StatusCode::InvalidArguments), response.status_code);
+        assert_eq!(
+            response.error.as_deref(),
+            Some(
+                "invalid expression type \"range vector\" for range query, must be Scalar or instant Vector"
+            )
+        );
+        assert!(handler.queries.lock().unwrap().is_empty());
+    }
+
     #[tokio::test]
     async fn test_promql_timer_records_parse_errors() {
         let handler: PrometheusHandlerRef = Arc::new(TestPrometheusHandler {
@@ -3211,6 +3324,134 @@ mod tests {
                 expected_type: ValueType::Vector,
                 should_error: false,
             },
+            // Arithmetic operators always drop the metric name.
+            TestCase {
+                name: "arithmetic between metrics",
+                promql: "a + b",
+                expected_metric: None,
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "arithmetic with scalar",
+                promql: "a * 2",
+                expected_metric: None,
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            // Comparisons keep the metric name from the side whose labels the
+            // result carries, i.e. the "many" side of the match: normally the
+            // left operand, but `group_right` takes it from the right operand and
+            // a scalar left operand leaves the vector on the right. The name is
+            // dropped when the comparison returns a bool or is a one-to-one
+            // `on(...)` match that does not keep `__name__` or an `ignoring(...)`
+            // match that excludes it. A `group_left`/`group_right` modifier does
+            // not reduce the labels, so the name is kept.
+            TestCase {
+                name: "bool comparison between metrics",
+                promql: "a > bool b",
+                expected_metric: None,
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "bool comparison with scalar",
+                promql: "a > bool 0.5",
+                expected_metric: None,
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison with scalar",
+                promql: "a > 0.5",
+                expected_metric: Some("a"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison with scalar on the left",
+                promql: "0.5 < a",
+                expected_metric: Some("a"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "equality comparison with scalar",
+                promql: "up == 0",
+                expected_metric: Some("up"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison between metrics",
+                promql: "a > b",
+                expected_metric: Some("a"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison with ignoring",
+                promql: "a > ignoring(x) b",
+                expected_metric: Some("a"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison with ignoring __name__",
+                promql: "a > ignoring(__name__) b",
+                expected_metric: None,
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison with ignoring __name__ and group_left",
+                promql: "a > ignoring(__name__) group_left b",
+                expected_metric: Some("a"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison with ignoring __name__ and group_right",
+                promql: "a > ignoring(__name__) group_right b",
+                expected_metric: Some("b"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "unless with ignoring __name__",
+                promql: "a unless ignoring(__name__) b",
+                expected_metric: Some("a"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison with on",
+                promql: "a > on(x) b",
+                expected_metric: None,
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison with on keeping __name__",
+                promql: "a > on(__name__) b",
+                expected_metric: Some("a"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison with on and group_left",
+                promql: "a > on(x) group_left b",
+                expected_metric: Some("a"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
+            TestCase {
+                name: "comparison with on and group_right",
+                promql: "a > on(x) group_right b",
+                expected_metric: Some("b"),
+                expected_type: ValueType::Vector,
+                should_error: false,
+            },
             // Subquery cases
             TestCase {
                 name: "basic subquery",
diff --git a/src/servers/src/otlp/coerce.rs b/src/servers/src/otlp/coerce.rs
index 2e7dd36ed7a..2f8d25247cf 100644
--- a/src/servers/src/otlp/coerce.rs
+++ b/src/servers/src/otlp/coerce.rs
@@ -30,6 +30,9 @@ pub enum TraceCoerceError {
 // - String to Int64
 // - String to Float64
 // - String to Boolean
+// The empty string and "-" coerce to null instead of failing: instrumentations
+// fill numeric attributes from absent headers this way (PSR-7 `getHeaderLine`
+// returns ""), and rejecting the value would reject the whole span.
 //
 // Lossless signed-to-unsigned integer casts. These let the built-in data
 // models move from unsigned to signed integers while existing unsigned tables
@@ -86,6 +89,13 @@ pub fn coerce_value_data(
         return Ok(None);
     };
 
+    if let ValueData::StringValue(s) = v
+        && matches!(s.as_str(), "" | "-")
+        && is_supported_trace_coercion(request_type, target)
+    {
+        return Ok(None);
+    }
+
     let Some(value) = coerce_non_null_value(target, request_type, v) else {
         return Err(TraceCoerceError::Unsupported);
     };
@@ -273,6 +283,24 @@ mod tests {
         assert_eq!(result, Err(TraceCoerceError::Unsupported));
     }
 
+    #[test]
+    fn test_coerce_absent_value_strings_to_null() {
+        for s in ["", "-"] {
+            for target in [
+                ColumnDataType::Int64,
+                ColumnDataType::Float64,
+                ColumnDataType::Boolean,
+            ] {
+                let result = coerce_value_data(
+                    &Some(ValueData::StringValue(s.to_string())),
+                    target,
+                    ColumnDataType::String,
+                );
+                assert_eq!(result, Ok(None), "{s:?} to {target:?}");
+            }
+        }
+    }
+
     #[test]
     fn test_coerce_float64_to_int64_not_supported() {
         let result = coerce_value_data(
diff --git a/src/servers/src/otlp/metrics.rs b/src/servers/src/otlp/metrics.rs
index fd496db5a98..7a485545bdd 100644
--- a/src/servers/src/otlp/metrics.rs
+++ b/src/servers/src/otlp/metrics.rs
@@ -349,12 +349,13 @@ fn from_metric_type(data: &metric::Data) -> MetricType {
     }
 }
 
-/// Non-scalar values (bool, arrays, maps, bytes) are not representable as tags.
+/// Non-scalar values (arrays, maps, bytes) are not representable as tags.
 fn scalar_value_string(value: Option<&AnyValue>) -> Option<String> {
     match value.and_then(|v| v.value.as_ref())? {
         any_value::Value::StringValue(s) => Some(s.clone()),
         any_value::Value::IntValue(v) => Some(v.to_string()),
         any_value::Value::DoubleValue(v) => Some(v.to_string()),
+        any_value::Value::BoolValue(v) => Some(v.to_string()),
         _ => None,
     }
 }
@@ -1571,6 +1572,15 @@ mod tests {
         }
     }
 
+    fn bool_keyvalue(key: &str, value: bool) -> KeyValue {
+        KeyValue {
+            key: key.into(),
+            value: Some(AnyValue {
+                value: Some(Val::BoolValue(value)),
+            }),
+        }
+    }
+
     fn descriptor_ctx() -> OtlpMetricCtx {
         OtlpMetricCtx {
             resource_info: true,
@@ -1734,6 +1744,64 @@ mod tests {
         assert_eq!(attr_value(&attrs, "instance").as_deref(), Some("inst-1"));
     }
 
+    #[test]
+    fn test_boolean_attributes_keep_series_distinct() {
+        set_default_prefix(None).unwrap();
+        let request = metrics_request(vec![Metric {
+            name: "bool_repro".to_string(),
+            data: Some(metric::Data::Sum(Sum {
+                data_points: vec![
+                    NumberDataPoint {
+                        attributes: vec![bool_keyvalue("failed", false)],
+                        start_time_unix_nano: 1_000_000,
+                        time_unix_nano: 2_000_000,
+                        value: Some(Value::AsDouble(100.0)),
+                        ..Default::default()
+                    },
+                    NumberDataPoint {
+                        attributes: vec![bool_keyvalue("failed", true)],
+                        start_time_unix_nano: 1_000_000,
+                        time_unix_nano: 2_000_000,
+                        value: Some(Value::AsDouble(7.0)),
+                        ..Default::default()
+                    },
+                ],
+                aggregation_temporality: AggregationTemporality::Cumulative as i32,
+                is_monotonic: true,
+            })),
+            ..Default::default()
+        }]);
+        let conversion = to_grpc_insert_requests(request, &mut OtlpMetricCtx::default()).unwrap();
+
+        let rows = conversion
+            .requests
+            .inserts
+            .iter()
+            .find(|insert| insert.table_name == "bool_repro_total")
+            .expect("missing bool_repro_total table")
+            .rows
+            .as_ref()
+            .unwrap();
+        assert_eq!(2, rows.rows.len());
+        let failed = rows
+            .schema
+            .iter()
+            .position(|column| column.column_name == "failed")
+            .expect("boolean attribute `failed` was dropped from the label set");
+        let values = rows
+            .rows
+            .iter()
+            .map(|row| row.values[failed].value_data.clone())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            vec![
+                Some(ValueData::StringValue("false".to_string())),
+                Some(ValueData::StringValue("true".to_string())),
+            ],
+            values
+        );
+    }
+
     #[test]
     fn test_encode_gauge() {
         let mut tables = MultiTableData::default();
diff --git a/src/servers/src/prom_remote_write/decode.rs b/src/servers/src/prom_remote_write/decode.rs
index 6f635c7caf1..f7324b4be6e 100644
--- a/src/servers/src/prom_remote_write/decode.rs
+++ b/src/servers/src/prom_remote_write/decode.rs
@@ -448,7 +448,9 @@ mod tests {
 
     #[test]
     fn test_decode_write_request() {
-        let mut d = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        let mut d = std::path::PathBuf::from(
+            std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set"),
+        );
         d.push("benches");
         d.push("write_request.pb.data");
         let data = std::fs::read(d).unwrap();
diff --git a/src/servers/src/prom_remote_write/v2.rs b/src/servers/src/prom_remote_write/v2.rs
index b9e34dc7f24..9178748bc77 100644
--- a/src/servers/src/prom_remote_write/v2.rs
+++ b/src/servers/src/prom_remote_write/v2.rs
@@ -658,7 +658,7 @@ fn resolve_series_labels<'a>(
     let mut tags = Vec::with_capacity(labels_refs.len() / 2);
     label_names.clear();
 
-    for pair in labels_refs.chunks_exact(2) {
+    for pair in labels_refs.as_chunks::<2>().0 {
         let name = symbol_ref(symbols, pair[0], "label name")?;
         let value = symbol_ref(symbols, pair[1], "label value")?;
         validate_label(name)?;
diff --git a/src/servers/src/prom_store.rs b/src/servers/src/prom_store.rs
index ffd45b8401a..ff82f8f933b 100644
--- a/src/servers/src/prom_store.rs
+++ b/src/servers/src/prom_store.rs
@@ -37,7 +37,7 @@ use common_query::prelude::{greptime_timestamp, greptime_value};
 use common_recordbatch::{RecordBatch, RecordBatches};
 use common_telemetry::{tracing, warn};
 use datafusion::dataframe::DataFrame;
-use datafusion::prelude::{Expr, col, lit, regexp_match};
+use datafusion::prelude::{Expr, ident, lit, regexp_match};
 use datafusion_common::ScalarValue;
 use datafusion_expr::LogicalPlan;
 use snafu::{OptionExt, ResultExt, ensure};
@@ -153,8 +153,9 @@ pub fn query_to_plan(
     let mut conditions = Vec::with_capacity(label_matches.len() + 1);
 
     conditions
-        .push(col(timestamp_column_name).gt_eq(lit_timestamp_millisecond(start_timestamp_ms)));
-    conditions.push(col(timestamp_column_name).lt_eq(lit_timestamp_millisecond(end_timestamp_ms)));
+        .push(ident(timestamp_column_name).gt_eq(lit_timestamp_millisecond(start_timestamp_ms)));
+    conditions
+        .push(ident(timestamp_column_name).lt_eq(lit_timestamp_millisecond(end_timestamp_ms)));
 
     for m in label_matches {
         let name = &m.name;
@@ -173,18 +174,18 @@ pub fn query_to_plan(
 
         match m_type {
             MatcherType::Eq => {
-                conditions.push(col(name).eq(lit(value)));
+                conditions.push(ident(name).eq(lit(value)));
             }
             MatcherType::Neq => {
-                conditions.push(col(name).not_eq(lit(value)));
+                conditions.push(ident(name).not_eq(lit(value)));
             }
             // Case sensitive regexp match
             MatcherType::Re => {
-                conditions.push(regexp_match(col(name), lit(value), None).is_not_null());
+                conditions.push(regexp_match(ident(name), lit(value), None).is_not_null());
             }
             // Case sensitive regexp not match
             MatcherType::Nre => {
-                conditions.push(regexp_match(col(name), lit(value), None).is_null());
+                conditions.push(regexp_match(ident(name), lit(value), None).is_null());
             }
         }
     }
@@ -1028,6 +1029,8 @@ mod tests {
             ColumnSchema::new(greptime_value(), ConcreteDataType::float64_datatype(), true),
             ColumnSchema::new("instance", ConcreteDataType::string_datatype(), true),
             ColumnSchema::new("job", ConcreteDataType::string_datatype(), true),
+            ColumnSchema::new("service.name", ConcreteDataType::string_datatype(), true),
+            ColumnSchema::new("Region", ConcreteDataType::string_datatype(), true),
         ]));
         let recordbatch = RecordBatch::new(
             schema,
@@ -1036,6 +1039,8 @@ mod tests {
                 Arc::new(Float64Vector::from_vec(vec![3.0])) as _,
                 Arc::new(StringVector::from(vec!["host1"])) as _,
                 Arc::new(StringVector::from(vec!["job"])) as _,
+                Arc::new(StringVector::from(vec!["api"])) as _,
+                Arc::new(StringVector::from(vec!["us"])) as _,
             ],
         )
         .unwrap();
@@ -1074,6 +1079,16 @@ mod tests {
                     value: "localhost".to_string(),
                     r#type: NEQ_TYPE,
                 },
+                LabelMatcher {
+                    name: "service.name".to_string(),
+                    value: "api".to_string(),
+                    r#type: EQ_TYPE,
+                },
+                LabelMatcher {
+                    name: "Region".to_string(),
+                    value: "us".to_string(),
+                    r#type: EQ_TYPE,
+                },
             ],
             ..Default::default()
         };
@@ -1084,7 +1099,7 @@ mod tests {
 
         let ts_col = greptime_timestamp();
         let expected = format!(
-            "Filter: ?table?.{} >= TimestampMillisecond(1000, None) AND ?table?.{} <= TimestampMillisecond(2000, None) AND regexp_match(?table?.job, Utf8(\"*prom*\")) IS NOT NULL AND ?table?.instance != Utf8(\"localhost\")\n  TableScan: ?table?",
+            "Filter: ?table?.{} >= TimestampMillisecond(1000, None) AND ?table?.{} <= TimestampMillisecond(2000, None) AND regexp_match(?table?.job, Utf8(\"*prom*\")) IS NOT NULL AND ?table?.instance != Utf8(\"localhost\") AND ?table?.service.name = Utf8(\"api\") AND ?table?.Region = Utf8(\"us\")\n  TableScan: ?table?",
             ts_col, ts_col
         );
         assert_eq!(expected, display_string);
diff --git a/src/sql/src/parsers/create_parser.rs b/src/sql/src/parsers/create_parser.rs
index dd698ddbe57..c87d0274382 100644
--- a/src/sql/src/parsers/create_parser.rs
+++ b/src/sql/src/parsers/create_parser.rs
@@ -768,7 +768,7 @@ impl<'a> ParserContext<'a> {
         {
             return Err(ParserError::ParserError(format!(
                 "Cannot use keyword '{}' as column name. Hint: add quotes to the name.",
-                &name.value
+                name.value
             )));
         }
 
diff --git a/src/sql/src/statements/copy.rs b/src/sql/src/statements/copy.rs
index 7a59175538c..f47f26ec61a 100644
--- a/src/sql/src/statements/copy.rs
+++ b/src/sql/src/statements/copy.rs
@@ -46,7 +46,7 @@ pub struct CopyQueryTo {
 
 impl Display for CopyQueryTo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "COPY ({}) TO {}", &self.query, &self.arg.location)?;
+        write!(f, "COPY ({}) TO {}", self.query, self.arg.location)?;
         if !self.arg.with.is_empty() {
             let options = self.arg.with.kv_pairs();
             write!(f, " WITH ({})", options.join(", "))?;
@@ -70,11 +70,11 @@ impl Display for CopyTable {
         write!(f, "COPY ")?;
         let (with, connection) = match self {
             CopyTable::To(args) => {
-                write!(f, "{} TO {}", &args.table_name, &args.location)?;
+                write!(f, "{} TO {}", args.table_name, args.location)?;
                 (&args.with, &args.connection)
             }
             CopyTable::From(args) => {
-                write!(f, "{} FROM {}", &args.table_name, &args.location)?;
+                write!(f, "{} FROM {}", args.table_name, args.location)?;
                 (&args.with, &args.connection)
             }
         };
@@ -101,11 +101,11 @@ impl Display for CopyDatabase {
         write!(f, "COPY DATABASE ")?;
         let (with, connection) = match self {
             CopyDatabase::To(args) => {
-                write!(f, "{} TO {}", &args.database_name, &args.location)?;
+                write!(f, "{} TO {}", args.database_name, args.location)?;
                 (&args.with, &args.connection)
             }
             CopyDatabase::From(args) => {
-                write!(f, "{} FROM {}", &args.database_name, &args.location)?;
+                write!(f, "{} FROM {}", args.database_name, args.location)?;
                 (&args.with, &args.connection)
             }
         };
diff --git a/src/sql/src/statements/create.rs b/src/sql/src/statements/create.rs
index b5bda7b291e..acbd0b2dc29 100644
--- a/src/sql/src/statements/create.rs
+++ b/src/sql/src/statements/create.rs
@@ -379,14 +379,14 @@ impl Display for CreateTable {
         if self.if_not_exists {
             write!(f, "IF NOT EXISTS ")?;
         }
-        writeln!(f, "{} (", &self.name)?;
+        writeln!(f, "{} (", self.name)?;
         writeln!(f, "{},", format_list_indent!(self.columns))?;
         writeln!(f, "{}", format_table_constraint(&self.constraints))?;
         writeln!(f, ")")?;
         if let Some(partitions) = &self.partitions {
             writeln!(f, "{partitions}")?;
         }
-        writeln!(f, "ENGINE={}", &self.engine)?;
+        writeln!(f, "ENGINE={}", self.engine)?;
         if !self.options.is_empty() {
             let options = self.options.kv_pairs();
             write!(f, "WITH(\n{}\n)", format_list_indent!(options))?;
@@ -420,7 +420,7 @@ impl Display for CreateDatabase {
         if self.if_not_exists {
             write!(f, "IF NOT EXISTS ")?;
         }
-        write!(f, "{}", &self.name)?;
+        write!(f, "{}", self.name)?;
         if !self.options.is_empty() {
             let options = self.options.kv_pairs();
             write!(f, "\nWITH(\n{}\n)", format_list_indent!(options))?;
@@ -447,11 +447,11 @@ impl Display for CreateExternalTable {
         if self.if_not_exists {
             write!(f, "IF NOT EXISTS ")?;
         }
-        writeln!(f, "{} (", &self.name)?;
+        writeln!(f, "{} (", self.name)?;
         writeln!(f, "{},", format_list_indent!(self.columns))?;
         writeln!(f, "{}", format_table_constraint(&self.constraints))?;
         writeln!(f, ")")?;
-        writeln!(f, "ENGINE={}", &self.engine)?;
+        writeln!(f, "ENGINE={}", self.engine)?;
         if !self.options.is_empty() {
             let options = self.options.kv_pairs();
             write!(f, "WITH(\n{}\n)", format_list_indent!(options))?;
@@ -549,8 +549,8 @@ impl Display for CreateFlow {
         if self.if_not_exists {
             write!(f, "IF NOT EXISTS ")?;
         }
-        writeln!(f, "{}", &self.flow_name)?;
-        writeln!(f, "SINK TO {}", &self.sink_table_name)?;
+        writeln!(f, "{}", self.flow_name)?;
+        writeln!(f, "SINK TO {}", self.sink_table_name)?;
         if let Some(expire_after) = &self.expire_after {
             writeln!(f, "EXPIRE AFTER '{} s'", expire_after)?;
         }
@@ -571,7 +571,7 @@ impl Display for CreateFlow {
             let options = self.flow_options.kv_pairs();
             writeln!(f, "WITH ({})", format_list_comma!(options))?;
         }
-        write!(f, "AS {}", &self.query)
+        write!(f, "AS {}", self.query)
     }
 }
 
@@ -601,11 +601,11 @@ impl Display for CreateView {
         if self.if_not_exists {
             write!(f, "IF NOT EXISTS ")?;
         }
-        write!(f, "{} ", &self.name)?;
+        write!(f, "{} ", self.name)?;
         if !self.columns.is_empty() {
             write!(f, "({}) ", format_list_comma!(self.columns))?;
         }
-        write!(f, "AS {}", &self.query)
+        write!(f, "AS {}", self.query)
     }
 }
 
diff --git a/src/sql/src/statements/option_map.rs b/src/sql/src/statements/option_map.rs
index d562a61ce04..02351747151 100644
--- a/src/sql/src/statements/option_map.rs
+++ b/src/sql/src/statements/option_map.rs
@@ -151,7 +151,7 @@ impl OptionMap {
                 result.push(format!("{k} = '{}'", v.escape_debug()));
             }
         }
-        for (k, _) in self.secrets.iter() {
+        for k in self.secrets.keys() {
             if k.contains(".") {
                 result.push(format!("'{k}' = '******'"));
             } else {
@@ -221,10 +221,10 @@ impl Visit for OptionMap {
 
 impl VisitMut for OptionMap {
     fn visit<V: VisitorMut>(&mut self, visitor: &mut V) -> ControlFlow<V::Break> {
-        for (_, v) in self.options.iter_mut() {
+        for v in self.options.values_mut() {
             v.visit(visitor)?;
         }
-        for (_, v) in self.secrets.iter_mut() {
+        for v in self.secrets.values_mut() {
             v.expose_secret_mut().visit(visitor)?;
         }
         ControlFlow::Continue(())
diff --git a/src/sql/src/statements/show.rs b/src/sql/src/statements/show.rs
index 67624192b82..d1531de360d 100644
--- a/src/sql/src/statements/show.rs
+++ b/src/sql/src/statements/show.rs
@@ -41,7 +41,7 @@ impl Display for ShowKind {
 macro_rules! format_kind {
     ($self: expr, $f: expr) => {
         if $self.kind != ShowKind::All {
-            write!($f, " {}", &$self.kind)?;
+            write!($f, " {}", $self.kind)?;
         }
     };
 }
@@ -71,7 +71,7 @@ impl Display for ShowColumns {
         if self.full {
             write!(f, "FULL ")?;
         }
-        write!(f, "COLUMNS IN {}", &self.table)?;
+        write!(f, "COLUMNS IN {}", self.table)?;
         if let Some(database) = &self.database {
             write!(f, " IN {database}")?;
         }
@@ -90,7 +90,7 @@ pub struct ShowIndex {
 
 impl Display for ShowIndex {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "SHOW INDEX IN {}", &self.table)?;
+        write!(f, "SHOW INDEX IN {}", self.table)?;
         if let Some(database) = &self.database {
             write!(f, " IN {database}")?;
         }
@@ -110,7 +110,7 @@ pub struct ShowRegion {
 
 impl Display for ShowRegion {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "SHOW REGION IN {}", &self.table)?;
+        write!(f, "SHOW REGION IN {}", self.table)?;
         if let Some(database) = &self.database {
             write!(f, " IN {database}")?;
         }
diff --git a/src/standalone/src/datanode_manager.rs b/src/standalone/src/datanode_manager.rs
index 13a17ea2b43..a27a94b3c8d 100644
--- a/src/standalone/src/datanode_manager.rs
+++ b/src/standalone/src/datanode_manager.rs
@@ -77,7 +77,17 @@ impl RegionInvoker {
 
 #[async_trait]
 impl Datanode for RegionInvoker {
-    async fn handle(&self, request: RegionRequest) -> MetaResult<RegionResponse> {
+    async fn handle_request(&self, request: Arc<RegionRequest>) -> MetaResult<RegionResponse> {
+        // Local execution consumes the request; standalone does not retain it for retries.
+        let request = Arc::try_unwrap(request)
+            .map_err(|_| {
+                InvalidRegionRequestSnafu {
+                    reason: "local region request has multiple owners",
+                }
+                .build()
+            })
+            .map_err(BoxedError::new)
+            .context(meta_error::ExternalSnafu)?;
         let span = request
             .header
             .as_ref()
diff --git a/src/standalone/src/options.rs b/src/standalone/src/options.rs
index fbfcc2ccc1d..af72cabef09 100644
--- a/src/standalone/src/options.rs
+++ b/src/standalone/src/options.rs
@@ -25,7 +25,7 @@ use flow::FlowConfig;
 use frontend::frontend::FrontendOptions;
 use frontend::service_config::{
     InfluxdbOptions, JaegerOptions, MysqlOptions, OpentsdbOptions, OtlpOptions,
-    PendingRowsBatcherOptions, PostgresOptions, PromStoreOptions,
+    PendingRowsBatcherOptions, PostgresOptions, PromStoreOptions, WriteRetryOptions,
 };
 use mito2::config::MitoConfig;
 use pipeline::PipelineOptions;
@@ -172,6 +172,11 @@ impl StandaloneOptions {
             otlp: cloned_opts.otlp,
             prom_store: cloned_opts.prom_store,
             meta_client: None,
+            // Local region calls consume requests directly and do not use remote write retries.
+            write_retry: WriteRetryOptions {
+                max_retries: 0,
+                ..Default::default()
+            },
             logging: cloned_opts.logging,
             user_provider: cloned_opts.user_provider,
             query: cloned_opts.query,
@@ -221,6 +226,18 @@ mod tests {
 
     use crate::options::*;
 
+    #[test]
+    fn test_frontend_write_retries_disabled() {
+        assert!(FrontendOptions::default().write_retry.max_retries > 0);
+        assert_eq!(
+            StandaloneOptions::default()
+                .frontend_options()
+                .write_retry
+                .max_retries,
+            0
+        );
+    }
+
     #[test]
     fn test_logical_batcher_config_forwarding() {
         let opts: StandaloneOptions = toml::from_str("[pending_rows_batcher]\nprotocols = ['influxdb']\n[pending_rows_batcher.logical_table]\nprotocols = ['otlp', 'prom']\npending_rows_flush_interval = '10ms'").unwrap();
diff --git a/src/table/src/metadata.rs b/src/table/src/metadata.rs
index d91771b9c5f..c8941bb1a82 100644
--- a/src/table/src/metadata.rs
+++ b/src/table/src/metadata.rs
@@ -1143,7 +1143,7 @@ impl TableMeta {
                             .with_context(|_| error::CastDefaultValueSnafu {
                                 reason: format!(
                                     "Failed to cast default value from {:?} to type {:?}",
-                                    default_value, &change_column.target_type
+                                    default_value, change_column.target_type
                                 ),
                             })?,
                     )
diff --git a/src/table/src/predicate.rs b/src/table/src/predicate.rs
index 7290c35c70b..8dc85b610f4 100644
--- a/src/table/src/predicate.rs
+++ b/src/table/src/predicate.rs
@@ -505,13 +505,10 @@ fn extract_from_in_list_expr(
     for expr in list {
         if let Expr::Literal(scalar, _) = expr {
             return_none_if_utf8!(scalar);
-            if let Some(timestamp) = scalar_value_to_timestamp(scalar, None) {
-                init_range = init_range.or(&TimestampRange::single(timestamp))
-            } else {
-                // TODO(hl): maybe we should raise an error here since cannot parse
-                // timestamp value from in list expr
-                return None;
-            }
+            // TODO(hl): maybe we should raise an error here since cannot parse
+            // timestamp value from in list expr
+            let timestamp = scalar_value_to_timestamp(scalar, None)?;
+            init_range = init_range.or(&TimestampRange::single(timestamp));
         }
     }
     Some(init_range)
diff --git a/src/table/src/table/scan.rs b/src/table/src/table/scan.rs
index 2db051a1e9c..fc7aaa24dc6 100644
--- a/src/table/src/table/scan.rs
+++ b/src/table/src/table/scan.rs
@@ -118,21 +118,34 @@ impl RegionScanExec {
         }
 
         let metadata = scanner.metadata();
-        let mut pk_names = metadata
+        // Keep the primary key columns in the order reported by the metadata (for a metric
+        // region that is the physical row key order). Reordering them would let a projected
+        // logical tag look like a prefix of the row key, which yields ordering and
+        // partitioning claims the scanner cannot honour.
+        let pk_names = metadata
             .primary_key_columns()
             .map(|col| col.column_schema.name.clone())
             .collect::<Vec<_>>();
-        // workaround for logical table
-        if scanner.properties().is_logical_region() {
-            pk_names.sort_unstable();
-        }
+        // A region emits rows ordered by its primary key columns and then by the time
+        // index column. A primary key column that is not projected is absent from the
+        // arrow schema, and it also breaks the ordering of every primary key column that
+        // follows it (e.g. the physical `__table_id`/`__tsid` prefix of a metric region
+        // when reading a logical table). Thus only the longest fully projected prefix of
+        // the primary key can describe the output ordering, and that prefix can be empty.
+        let projected_pk_prefix_len = pk_names
+            .iter()
+            .position(|name| Column::new_with_schema(name, &arrow_schema).is_err())
+            .unwrap_or(pk_names.len());
+        // Whether the projected prefix covers the whole row key.
+        let all_pk_projected = projected_pk_prefix_len == pk_names.len();
+        let projected_pk_names = &pk_names[..projected_pk_prefix_len];
         let pk_columns = pk_names
             .iter()
             .filter_map(
                 |col| Some(Arc::new(Column::new_with_schema(col, &arrow_schema).ok()?) as _),
             )
             .collect::<Vec<_>>();
-        let pk_sort_columns: Vec<PhysicalSortExpr> = pk_names
+        let pk_sort_columns: Vec<PhysicalSortExpr> = projected_pk_names
             .iter()
             .filter_map(|col| {
                 Some(PhysicalSortExpr::new(
@@ -165,7 +178,9 @@ impl RegionScanExec {
                 let mut orderings = Vec::with_capacity(2);
 
                 let mut pk_time_ordering = pk_sort_columns.clone();
-                if let Some(ts) = ts_col.clone() {
+                // The time index column extends the ordering only when the whole row key
+                // precedes it; otherwise rows of different series can interleave.
+                if all_pk_projected && let Some(ts) = ts_col.clone() {
                     pk_time_ordering.push(ts);
                 }
                 orderings.push(pk_time_ordering);
@@ -213,7 +228,10 @@ impl RegionScanExec {
                     Ok(tsid_col) => {
                         Partitioning::Hash(vec![Arc::new(tsid_col) as _], num_output_partition)
                     }
-                    Err(_) => Partitioning::Hash(pk_columns.clone(), num_output_partition),
+                    Err(_) if pk_columns.len() == pk_names.len() => {
+                        Partitioning::Hash(pk_columns.clone(), num_output_partition)
+                    }
+                    Err(_) => Partitioning::UnknownPartitioning(num_output_partition),
                 }
             }
             Some(TimeSeriesDistribution::TimeWindowed) | None => {
@@ -504,13 +522,21 @@ impl ExecutionPlan for RegionScanExec {
         let statistics = if scanner.properties().total_rows_is_exact()
             && !scanner.has_predicate_without_region()
         {
+            // Only the row count is known. DataFusion answers `count(col)` as
+            // `num_rows - null_count` and `count(DISTINCT col)` as `distinct_count`
+            // without scanning, so these must stay absent unless the schema
+            // guarantees them. Non-nullable columns (including the time index that
+            // `count(*)` is rewritten to) keep an exact zero null count.
             let column_statistics = self
                 .arrow_schema
                 .fields
                 .iter()
-                .map(|_| ColumnStatistics {
-                    distinct_count: Precision::Exact(self.total_rows),
-                    null_count: Precision::Exact(0), // all null rows are counted for append-only table
+                .map(|field| ColumnStatistics {
+                    null_count: if field.is_nullable() {
+                        Precision::Absent
+                    } else {
+                        Precision::Exact(0)
+                    },
                     ..Default::default()
                 })
                 .collect();
@@ -691,10 +717,12 @@ mod test {
     use datatypes::vectors::{Int32Vector, TimestampMillisecondVector, VectorRef};
     use futures::TryStreamExt;
     use store_api::metadata::{ColumnMetadata, RegionMetadataBuilder};
+    use store_api::metric_engine_consts::DATA_SCHEMA_TABLE_ID_COLUMN_NAME;
     use store_api::region_engine::{
         PrepareRequest, QueryScanContext, RegionScanner, ScannerProperties, SinglePartitionScanner,
     };
-    use store_api::storage::RegionId;
+    use store_api::storage::consts::ReservedColumnId;
+    use store_api::storage::{RegionId, TimeSeriesDistribution};
 
     use super::*;
 
@@ -857,6 +885,340 @@ mod test {
         )
     }
 
+    #[test]
+    fn test_per_series_partitioning_requires_all_primary_keys() {
+        let full_schema = Arc::new(Schema::new(vec![
+            ColumnSchema::new("marker", ConcreteDataType::int32_datatype(), false),
+            ColumnSchema::new("host", ConcreteDataType::string_datatype(), false),
+            ColumnSchema::new(
+                "ts",
+                ConcreteDataType::timestamp_millisecond_datatype(),
+                false,
+            ),
+        ]));
+        let mut builder = RegionMetadataBuilder::new(RegionId::new(1234, 5683));
+        builder
+            .push_column_metadata(ColumnMetadata {
+                column_schema: ColumnSchema::new(
+                    "marker",
+                    ConcreteDataType::int32_datatype(),
+                    false,
+                ),
+                semantic_type: SemanticType::Tag,
+                column_id: 1,
+            })
+            .push_column_metadata(ColumnMetadata {
+                column_schema: ColumnSchema::new(
+                    "host",
+                    ConcreteDataType::string_datatype(),
+                    false,
+                ),
+                semantic_type: SemanticType::Tag,
+                column_id: 2,
+            })
+            .push_column_metadata(ColumnMetadata {
+                column_schema: ColumnSchema::new(
+                    "ts",
+                    ConcreteDataType::timestamp_millisecond_datatype(),
+                    false,
+                ),
+                semantic_type: SemanticType::Timestamp,
+                column_id: 3,
+            })
+            .primary_key(vec![1, 2]);
+        let metadata = Arc::new(builder.build().unwrap());
+
+        for (schema, expected) in [
+            (
+                full_schema.clone(),
+                Partitioning::Hash(
+                    vec![
+                        Arc::new(
+                            Column::new_with_schema("marker", full_schema.arrow_schema()).unwrap(),
+                        ) as _,
+                        Arc::new(
+                            Column::new_with_schema("host", full_schema.arrow_schema()).unwrap(),
+                        ) as _,
+                    ],
+                    2,
+                ),
+            ),
+            (
+                Arc::new(Schema::new(vec![
+                    ColumnSchema::new("marker", ConcreteDataType::int32_datatype(), false),
+                    ColumnSchema::new(
+                        "ts",
+                        ConcreteDataType::timestamp_millisecond_datatype(),
+                        false,
+                    ),
+                ])),
+                Partitioning::UnknownPartitioning(2),
+            ),
+        ] {
+            let batches = RecordBatches::try_new(schema, vec![]).unwrap();
+            let scanner = Box::new(RepeatableScanner {
+                batches,
+                properties: ScannerProperties::new(vec![vec![], vec![]], false, 0),
+                metadata: metadata.clone(),
+                dynamic_filters: Arc::new(Mutex::new(Vec::new())),
+            });
+            let request = ScanRequest {
+                distribution: Some(TimeSeriesDistribution::PerSeries),
+                ..Default::default()
+            };
+            let plan = RegionScanExec::new(scanner, request, None).unwrap();
+            let actual = plan.properties().output_partitioning();
+            match (&actual, &expected) {
+                (
+                    Partitioning::UnknownPartitioning(actual_count),
+                    Partitioning::UnknownPartitioning(expected_count),
+                ) => assert_eq!(actual_count, expected_count),
+                _ => assert_eq!(actual, &expected),
+            }
+        }
+    }
+
+    /// Returns whether the scan claims the given output ordering.
+    fn claims_ordering(plan: &RegionScanExec, names: &[&str]) -> bool {
+        plan.properties()
+            .equivalence_properties()
+            .ordering_satisfy(names.iter().map(|name| {
+                PhysicalSortExpr::new(
+                    Arc::new(Column::new_with_schema(name, &plan.arrow_schema).unwrap()),
+                    SortOptions {
+                        descending: false,
+                        nulls_first: true,
+                    },
+                )
+            }))
+            .unwrap()
+    }
+
+    /// Column schema used by the ordering fixtures below.
+    fn column_schema_of(name: &str) -> ColumnSchema {
+        let data_type = match name {
+            "ts" => ConcreteDataType::timestamp_millisecond_datatype(),
+            DATA_SCHEMA_TABLE_ID_COLUMN_NAME => ConcreteDataType::uint32_datatype(),
+            DATA_SCHEMA_TSID_COLUMN_NAME => ConcreteDataType::uint64_datatype(),
+            _ => ConcreteDataType::string_datatype(),
+        };
+        ColumnSchema::new(name, data_type, false)
+    }
+
+    /// The scan must describe its output ordering with the primary key order reported by
+    /// the metadata. Sorting the names (the removed logical-table workaround) would let a
+    /// projected column look like a row key prefix and claim an ordering the scanner does
+    /// not produce; the time index only extends a fully projected row key.
+    #[test]
+    fn test_per_series_ordering_follows_metadata_pk_order() {
+        // Deliberately not alphabetical: sorting these names would give `[a, b, z]`.
+        let mut builder = RegionMetadataBuilder::new(RegionId::new(1234, 5690));
+        for (index, name) in ["z", "a", "b", "ts"].into_iter().enumerate() {
+            builder.push_column_metadata(ColumnMetadata {
+                column_schema: column_schema_of(name),
+                semantic_type: if name == "ts" {
+                    SemanticType::Timestamp
+                } else {
+                    SemanticType::Tag
+                },
+                column_id: index as u32 + 1,
+            });
+        }
+        builder.primary_key(vec![1, 2, 3]);
+        let metadata = Arc::new(builder.build().unwrap());
+
+        // The claims must not depend on the scanner reporting a logical region.
+        for logical_region in [false, true] {
+            for (projection, claimed, unclaimed) in [
+                // Missing the first key: neither the remaining keys nor the time index are
+                // ordered.
+                (
+                    vec!["a", "b", "ts"],
+                    vec![],
+                    vec![vec!["a"], vec!["b"], vec!["ts"], vec!["a", "b"]],
+                ),
+                // Missing a key in the middle: only the prefix before it is ordered.
+                (
+                    vec!["z", "b", "ts"],
+                    vec![vec!["z"]],
+                    vec![vec!["b"], vec!["z", "b"], vec!["z", "ts"]],
+                ),
+                // A valid but incomplete prefix: the time index is not ordered after it.
+                (
+                    vec!["z", "a", "ts"],
+                    vec![vec!["z"], vec!["z", "a"]],
+                    vec![vec!["a", "z"], vec!["z", "a", "ts"]],
+                ),
+                // The whole row key followed by the time index.
+                (
+                    vec!["z", "a", "b", "ts"],
+                    vec![vec!["z", "a", "b"], vec!["z", "a", "b", "ts"]],
+                    vec![vec!["a"], vec!["a", "b", "z"]],
+                ),
+            ] {
+                let schema = Arc::new(Schema::new(
+                    projection
+                        .iter()
+                        .map(|name| column_schema_of(name))
+                        .collect(),
+                ));
+                let mut properties = ScannerProperties::new(vec![vec![], vec![]], false, 0);
+                properties.set_logical_region(logical_region);
+                let scanner = Box::new(RepeatableScanner {
+                    batches: RecordBatches::try_new(schema, vec![]).unwrap(),
+                    properties,
+                    metadata: metadata.clone(),
+                    dynamic_filters: Arc::new(Mutex::new(Vec::new())),
+                });
+                let plan = RegionScanExec::new(
+                    scanner,
+                    ScanRequest {
+                        distribution: Some(TimeSeriesDistribution::PerSeries),
+                        ..Default::default()
+                    },
+                    None,
+                )
+                .unwrap();
+
+                for ordering in claimed {
+                    assert!(
+                        claims_ordering(&plan, &ordering),
+                        "logical_region={logical_region} projection {projection:?} must claim \
+                         ordering {ordering:?}"
+                    );
+                }
+                for ordering in unclaimed {
+                    assert!(
+                        !claims_ordering(&plan, &ordering),
+                        "logical_region={logical_region} projection {projection:?} must not \
+                         claim ordering {ordering:?}"
+                    );
+                }
+            }
+        }
+    }
+
+    /// Metric TSID properties require projecting `__tsid` and restricting the scan to one
+    /// `__table_id`; hiding the physical row-key prefix must not claim a visible tag or time as
+    /// order or hash partition columns.
+    #[test]
+    fn test_metric_projection_claims_only_projected_row_key_prefix() {
+        let mut builder = RegionMetadataBuilder::new(RegionId::new(1234, 5691));
+        for (name, column_id) in [
+            (
+                DATA_SCHEMA_TABLE_ID_COLUMN_NAME,
+                ReservedColumnId::table_id(),
+            ),
+            (DATA_SCHEMA_TSID_COLUMN_NAME, ReservedColumnId::tsid()),
+            ("A", 1),
+            ("marker", 2),
+            ("ts", 3),
+        ] {
+            builder.push_column_metadata(ColumnMetadata {
+                column_schema: column_schema_of(name),
+                semantic_type: if name == "ts" {
+                    SemanticType::Timestamp
+                } else {
+                    SemanticType::Tag
+                },
+                column_id,
+            });
+        }
+        // The physical row key order: `__table_id`, `__tsid`, then the tag columns.
+        builder.primary_key(vec![
+            ReservedColumnId::table_id(),
+            ReservedColumnId::tsid(),
+            1,
+            2,
+        ]);
+        let metadata = Arc::new(builder.build().unwrap());
+
+        for (projection, partitioned_by_tsid, claimed, unclaimed) in [
+            // The logical projection drops the row key prefix, so `A` is not a prefix of the
+            // row key and neither `A` nor `ts` is ordered.
+            (
+                vec!["A", "marker", "ts"],
+                false,
+                vec![],
+                vec![vec!["A"], vec!["marker"], vec!["ts"], vec!["A", "ts"]],
+            ),
+            // Projecting internal `__tsid` plus the single-table filter preserves metric TSID properties.
+            (
+                vec![DATA_SCHEMA_TSID_COLUMN_NAME, "A", "marker", "ts"],
+                true,
+                vec![
+                    vec![DATA_SCHEMA_TSID_COLUMN_NAME],
+                    vec![DATA_SCHEMA_TSID_COLUMN_NAME, "ts"],
+                ],
+                vec![vec!["A"], vec!["ts"], vec!["A", "ts"]],
+            ),
+        ] {
+            let schema = Arc::new(Schema::new(
+                projection
+                    .iter()
+                    .map(|name| column_schema_of(name))
+                    .collect(),
+            ));
+            let mut properties = ScannerProperties::new(vec![vec![], vec![]], false, 0);
+            properties.set_logical_region(true);
+            let scanner = Box::new(RepeatableScanner {
+                batches: RecordBatches::try_new(schema, vec![]).unwrap(),
+                properties,
+                metadata: metadata.clone(),
+                dynamic_filters: Arc::new(Mutex::new(Vec::new())),
+            });
+            let plan = RegionScanExec::new(
+                scanner,
+                ScanRequest {
+                    distribution: Some(TimeSeriesDistribution::PerSeries),
+                    filters: if partitioned_by_tsid {
+                        vec![
+                            datafusion_expr::col(DATA_SCHEMA_TABLE_ID_COLUMN_NAME)
+                                .eq(datafusion_expr::lit(42u32)),
+                        ]
+                    } else {
+                        vec![]
+                    },
+                    ..Default::default()
+                },
+                None,
+            )
+            .unwrap();
+
+            let expected_partitioning = if partitioned_by_tsid {
+                Partitioning::Hash(
+                    vec![Arc::new(
+                        Column::new_with_schema(DATA_SCHEMA_TSID_COLUMN_NAME, &plan.arrow_schema)
+                            .unwrap(),
+                    ) as _],
+                    2,
+                )
+            } else {
+                Partitioning::UnknownPartitioning(2)
+            };
+            match (&plan.properties.partitioning, &expected_partitioning) {
+                (
+                    Partitioning::UnknownPartitioning(actual_count),
+                    Partitioning::UnknownPartitioning(expected_count),
+                ) => assert_eq!(actual_count, expected_count, "projection {projection:?}"),
+                (actual, expected) => assert_eq!(actual, expected, "projection {projection:?}"),
+            }
+
+            for ordering in claimed {
+                assert!(
+                    claims_ordering(&plan, &ordering),
+                    "projection {projection:?} must claim ordering {ordering:?}"
+                );
+            }
+            for ordering in unclaimed {
+                assert!(
+                    !claims_ordering(&plan, &ordering),
+                    "projection {projection:?} must not claim ordering {ordering:?}"
+                );
+            }
+        }
+    }
+
     #[test]
     fn test_count_statistics_require_exact_source_rows() {
         for (append_mode, exact, expected) in [
@@ -864,7 +1226,8 @@ mod test {
             (true, true, Precision::Exact(3)),
             (false, true, Precision::Absent),
         ] {
-            let (schema, batch, metadata) = dynamic_filter_test_data(5685, false);
+            // Column `a` is nullable and `ts` is not.
+            let (schema, batch, metadata) = dynamic_filter_test_data(5685, true);
             let scanner = Box::new(RepeatableScanner {
                 batches: RecordBatches::try_new(schema, vec![batch]).unwrap(),
                 properties: ScannerProperties::default()
@@ -875,13 +1238,19 @@ mod test {
                 dynamic_filters: Arc::new(Mutex::new(Vec::new())),
             });
             let plan = RegionScanExec::new(scanner, ScanRequest::default(), None).unwrap();
-            assert_eq!(
-                StatisticsContext::new()
-                    .compute(&plan, &StatisticsArgs::new())
-                    .unwrap()
-                    .num_rows,
-                expected,
-            );
+            let stats = StatisticsContext::new()
+                .compute(&plan, &StatisticsArgs::new())
+                .unwrap();
+            assert_eq!(stats.num_rows, expected);
+            if expected != Precision::Absent {
+                let [a, ts] = stats.column_statistics.as_slice() else {
+                    panic!("unexpected column statistics: {stats:?}");
+                };
+                assert_eq!(a.null_count, Precision::Absent);
+                assert_eq!(ts.null_count, Precision::Exact(0));
+                assert_eq!(a.distinct_count, Precision::Absent);
+                assert_eq!(ts.distinct_count, Precision::Absent);
+            }
             assert_eq!(
                 StatisticsContext::new()
                     .compute(&plan, &StatisticsArgs::new().with_partition(Some(0)))
diff --git a/src/table/src/test_util/memtable.rs b/src/table/src/test_util/memtable.rs
index 0ae751d35f4..a0824facd0d 100644
--- a/src/table/src/test_util/memtable.rs
+++ b/src/table/src/test_util/memtable.rs
@@ -188,7 +188,6 @@ impl Stream for MemtableStream {
 #[cfg(test)]
 mod test {
     use common_recordbatch::util;
-    use datatypes::prelude::*;
     use datatypes::schema::ColumnSchema;
     use datatypes::vectors::{Helper, Int32Vector, StringVector};
 
diff --git a/tests-integration/src/cluster.rs b/tests-integration/src/cluster.rs
index 4f762ba709b..21a0d5eba2d 100644
--- a/tests-integration/src/cluster.rs
+++ b/tests-integration/src/cluster.rs
@@ -380,7 +380,7 @@ impl GreptimeDbClusterBuilder {
                 let home_dir = if let Some(home_dir) = &self.shared_home_dir {
                     home_dir.path().to_str().unwrap().to_string()
                 } else {
-                    let home_tmp_dir = create_temp_dir(&format!("gt_home_{}", &self.cluster_name));
+                    let home_tmp_dir = create_temp_dir(&format!("gt_home_{}", self.cluster_name));
                     let home_dir = home_tmp_dir.path().to_str().unwrap().to_string();
                     guards.push(TestGuard {
                         home_guard: FileDirGuard::new(home_tmp_dir),
diff --git a/tests-integration/src/grpc/flight.rs b/tests-integration/src/grpc/flight.rs
index ef3df79f558..e74d4d5bf70 100644
--- a/tests-integration/src/grpc/flight.rs
+++ b/tests-integration/src/grpc/flight.rs
@@ -990,7 +990,7 @@ mod test {
             panic!("expected affected rows output");
         };
         assert_eq!(affected_rows, 9);
-        assert!(result.metrics.is_ready());
+        result.metrics.wait_ready().await;
         assert!(result.region_watermark_map().is_none());
 
         let err = client
@@ -1016,6 +1016,7 @@ mod test {
             panic!("expected affected rows output");
         };
         assert_eq!(affected_rows, 9);
+        result.metrics.wait_ready().await;
         assert_eq!(
             result.region_watermark_map(),
             Some(std::collections::HashMap::from([previous_watermark]))
diff --git a/tests-integration/src/standalone.rs b/tests-integration/src/standalone.rs
index 3fa1d394489..d0354477fac 100644
--- a/tests-integration/src/standalone.rs
+++ b/tests-integration/src/standalone.rs
@@ -388,7 +388,7 @@ impl GreptimeDbStandaloneBuilder {
         let procedure_config = ProcedureConfig::default();
 
         let kv_backend = standalone::build_metadata_kvbackend(
-            format!("{}/kv", &opts.storage.data_home),
+            format!("{}/kv", opts.storage.data_home),
             kv_backend_config,
         )
         .unwrap();
diff --git a/tests-integration/src/test_util.rs b/tests-integration/src/test_util.rs
index 64f9f4c6af1..0729e6ea96b 100644
--- a/tests-integration/src/test_util.rs
+++ b/tests-integration/src/test_util.rs
@@ -892,6 +892,7 @@ pub fn build_test_prom_server(
         LogicalTablePendingRowsBatcher::try_new(
             frontend_ref.partition_manager().clone(),
             frontend_ref.node_manager().clone(),
+            frontend_ref.inserter().write_dispatcher().clone(),
             frontend_ref.catalog_manager().clone(),
             frontend_ref.table_flownode_set_cache().clone(),
             true,
diff --git a/tests-integration/src/tests/instance_test.rs b/tests-integration/src/tests/instance_test.rs
index 7cc02cfc456..22a0b993d17 100644
--- a/tests-integration/src/tests/instance_test.rs
+++ b/tests-integration/src/tests/instance_test.rs
@@ -29,6 +29,7 @@ use frontend::error::Error;
 use frontend::instance::Instance;
 use operator::error::Error as OperatorError;
 use query::datafusion::QUERY_PARALLELISM_HINT;
+use query::options::QUERY_ENABLE_REMOTE_DYNAMIC_FILTER_PUSHDOWN;
 use rstest::rstest;
 use rstest_reuse::apply;
 use servers::error as server_error;
@@ -257,6 +258,697 @@ WHERE greptime_timestamp = (
     );
 }
 
+#[apply(both_instances_cases)]
+async fn test_metric_logical_scan_tag_order(instance: Arc<dyn MockInstance>) {
+    let frontend = instance.frontend();
+
+    execute_sql(
+        &frontend,
+        r#"CREATE TABLE f04_scan_phy (
+            host STRING PRIMARY KEY,
+            val DOUBLE,
+            ts TIMESTAMP TIME INDEX
+        ) ENGINE = metric WITH (physical_metric_table = 'true')"#,
+    )
+    .await;
+    execute_sql(
+        &frontend,
+        r#"CREATE TABLE f04_scan_logical (
+            host STRING PRIMARY KEY,
+            val DOUBLE,
+            ts TIMESTAMP TIME INDEX
+        ) ENGINE = metric WITH (on_physical_table = 'f04_scan_phy')"#,
+    )
+    .await;
+    execute_sql(
+        &frontend,
+        "INSERT INTO f04_scan_logical (host, val, ts) VALUES \
+         ('a', 1, 0), ('b', 2, 0), ('c', 3, 0), ('d', 4, 0), \
+         ('e', 5, 0), ('f', 6, 0), ('g', 7, 0), ('h', 8, 0)",
+    )
+    .await;
+
+    // The ordered rows are compared exactly as printed. Sorting them before
+    // comparing (or comparing them unordered) would accept a scan that returns
+    // the physical table's tag order instead of the requested `host` order.
+    async fn ordered_rows(instance: &Arc<Instance>, sql: &str, parallelism: usize) -> String {
+        execute_sql_with_query_parallelism(instance, sql, parallelism)
+            .await
+            .data
+            .pretty_print()
+            .await
+    }
+
+    let all_hosts = "\
++------+---------------------+-----+
+| host | ts                  | val |
++------+---------------------+-----+
+| a    | 1970-01-01T00:00:00 | 1.0 |
+| b    | 1970-01-01T00:00:00 | 2.0 |
+| c    | 1970-01-01T00:00:00 | 3.0 |
+| d    | 1970-01-01T00:00:00 | 4.0 |
+| e    | 1970-01-01T00:00:00 | 5.0 |
+| f    | 1970-01-01T00:00:00 | 6.0 |
+| g    | 1970-01-01T00:00:00 | 7.0 |
+| h    | 1970-01-01T00:00:00 | 8.0 |
++------+---------------------+-----+";
+    let first_three_hosts = "\
++------+---------------------+-----+
+| host | ts                  | val |
++------+---------------------+-----+
+| a    | 1970-01-01T00:00:00 | 1.0 |
+| b    | 1970-01-01T00:00:00 | 2.0 |
+| c    | 1970-01-01T00:00:00 | 3.0 |
++------+---------------------+-----+";
+
+    // `host` is NOT NULL, so `NULLS FIRST` and the SQL default `NULLS LAST` return the same
+    // rows. The `NULLS FIRST` queries spell out the ordering the scan used to claim, so the
+    // optimizer may drop the sort and expose a wrong tag order; the `NULLS LAST` queries
+    // keep the sort. Both are replayed in memory and after flushing the physical table.
+    let mut mismatches = Vec::new();
+    for flushed in [false, true] {
+        if flushed {
+            execute_sql(&frontend, "ADMIN FLUSH_TABLE('f04_scan_phy')").await;
+        }
+        for parallelism in [1, 4] {
+            for (query, expected) in [
+                (
+                    "SELECT host, ts, val FROM f04_scan_logical ORDER BY host NULLS FIRST",
+                    all_hosts,
+                ),
+                (
+                    "SELECT host, ts, val FROM f04_scan_logical ORDER BY host NULLS FIRST LIMIT 3",
+                    first_three_hosts,
+                ),
+                (
+                    "SELECT host, ts, val FROM f04_scan_logical ORDER BY host NULLS LAST",
+                    all_hosts,
+                ),
+                (
+                    "SELECT host, ts, val FROM f04_scan_logical ORDER BY host NULLS LAST LIMIT 3",
+                    first_three_hosts,
+                ),
+            ] {
+                let actual = ordered_rows(&frontend, query, parallelism).await;
+                if actual.trim() != expected.trim() {
+                    mismatches.push(format!(
+                        "query `{query}` with query_parallelism={parallelism} flushed={flushed} \
+                         returned:\n{actual}"
+                    ));
+                }
+            }
+        }
+    }
+    assert!(
+        mismatches.is_empty(),
+        "logical metric table rows are not ordered by host, expected `a`..`h`:\n{}",
+        mismatches.join("\n---\n")
+    );
+}
+
+/// The uppercase tag `"A"` sorts before the physical `__table_id`/`__tsid` row key prefix
+/// by name, but it is not a prefix of the row key. A scan that claims it as ordering or
+/// partitioning lets the optimizer skip the sort or the repartition the query needs, so the
+/// per-host count comes back split across scan partitions in physical tsid order.
+#[apply(both_instances_cases)]
+async fn test_metric_logical_scan_uppercase_tag_order(instance: Arc<dyn MockInstance>) {
+    let frontend = instance.frontend();
+
+    execute_sql(
+        &frontend,
+        r#"CREATE TABLE f04_upper_phy (
+            "A" STRING,
+            marker STRING,
+            val DOUBLE,
+            ts TIMESTAMP TIME INDEX,
+            PRIMARY KEY ("A", marker)
+        ) ENGINE = metric WITH (physical_metric_table = 'true')"#,
+    )
+    .await;
+    execute_sql(
+        &frontend,
+        r#"CREATE TABLE f04_upper_logical (
+            "A" STRING,
+            marker STRING,
+            val DOUBLE,
+            ts TIMESTAMP TIME INDEX,
+            PRIMARY KEY ("A", marker)
+        ) ENGINE = metric WITH (on_physical_table = 'f04_upper_phy')"#,
+    )
+    .await;
+
+    // 8 hosts x 4 markers x 2 timestamps = 64 rows. Every host spans four series, so a count
+    // computed per scan partition would return several rows per host with partial counts.
+    let mut rows = Vec::with_capacity(64);
+    for host in 0..8 {
+        for marker in ["a", "b", "c", "d"] {
+            for ts in [1000, 2000] {
+                rows.push(format!("('h{host}', '{marker}', {host}, {ts})"));
+            }
+        }
+    }
+    execute_sql(
+        &frontend,
+        &format!(
+            "INSERT INTO f04_upper_logical (\"A\", marker, val, ts) VALUES {}",
+            rows.join(", ")
+        ),
+    )
+    .await;
+
+    let expected = "\
++----+---+
+| A  | n |
++----+---+
+| h0 | 8 |
+| h1 | 8 |
+| h2 | 8 |
+| h3 | 8 |
+| h4 | 8 |
+| h5 | 8 |
+| h6 | 8 |
+| h7 | 8 |
++----+---+";
+
+    // The rows are compared exactly as printed: sorting them before comparing would accept
+    // a wrong count or a wrong row order. `NULLS FIRST` spells out the ordering the scan
+    // used to claim, so the optimizer may drop the sort; the default `NULLS LAST` keeps it
+    // and a failure there can only come from a wrong partitioning claim. Both orders are
+    // replayed in memory and after flushing the physical table.
+    let queries = [
+        "SELECT \"A\", count(*) AS n FROM f04_upper_logical GROUP BY \"A\" ORDER BY \"A\"",
+        "SELECT \"A\", count(*) AS n FROM f04_upper_logical GROUP BY \"A\" ORDER BY \"A\" NULLS FIRST",
+    ];
+
+    let mut mismatches = Vec::new();
+    for flushed in [false, true] {
+        if flushed {
+            execute_sql(&frontend, "ADMIN FLUSH_TABLE('f04_upper_phy')").await;
+        }
+        for parallelism in [1, 4] {
+            for query in queries {
+                let actual = execute_sql_with_query_parallelism(&frontend, query, parallelism)
+                    .await
+                    .data
+                    .pretty_print()
+                    .await;
+                if actual.trim() != expected.trim() {
+                    mismatches.push(format!(
+                        "query `{query}` with query_parallelism={parallelism} flushed={flushed} \
+                         returned:\n{actual}"
+                    ));
+                }
+            }
+        }
+    }
+    assert!(
+        mismatches.is_empty(),
+        "logical metric table must return one row of eight per host in `A` order:\n{}",
+        mismatches.join("\n---\n")
+    );
+}
+
+/// The small shape of the same problem: four rows and two groups. Each host has two series,
+/// so the count must not be computed per scan partition, and `ORDER BY "A"` pins the exact
+/// row order at query_parallelism 4 as well as at 1.
+#[apply(both_instances_cases)]
+async fn test_metric_logical_scan_small_group_count(instance: Arc<dyn MockInstance>) {
+    let frontend = instance.frontend();
+
+    execute_sql(
+        &frontend,
+        r#"CREATE TABLE f04_upper_min_phy (
+            "A" STRING,
+            marker STRING,
+            val DOUBLE,
+            ts TIMESTAMP TIME INDEX,
+            PRIMARY KEY ("A", marker)
+        ) ENGINE = metric WITH (physical_metric_table = 'true')"#,
+    )
+    .await;
+    execute_sql(
+        &frontend,
+        r#"CREATE TABLE f04_upper_min_logical (
+            "A" STRING,
+            marker STRING,
+            val DOUBLE,
+            ts TIMESTAMP TIME INDEX,
+            PRIMARY KEY ("A", marker)
+        ) ENGINE = metric WITH (on_physical_table = 'f04_upper_min_phy')"#,
+    )
+    .await;
+    execute_sql(
+        &frontend,
+        "INSERT INTO f04_upper_min_logical (\"A\", marker, val, ts) VALUES \
+         ('h0', 'a', 1, 1000), ('h0', 'b', 2, 1000), \
+         ('h1', 'a', 3, 1000), ('h1', 'b', 4, 1000)",
+    )
+    .await;
+
+    let expected = "\
++----+---+
+| A  | n |
++----+---+
+| h0 | 2 |
+| h1 | 2 |
++----+---+";
+    // `NULLS FIRST` spells out the ordering the scan used to claim and is replayed next to
+    // the default `NULLS LAST` order, in memory and after flushing the physical table.
+    let queries = [
+        "SELECT \"A\", count(*) AS n FROM f04_upper_min_logical GROUP BY \"A\" ORDER BY \"A\"",
+        "SELECT \"A\", count(*) AS n FROM f04_upper_min_logical GROUP BY \"A\" ORDER BY \"A\" NULLS FIRST",
+    ];
+
+    let mut mismatches = Vec::new();
+    for flushed in [false, true] {
+        if flushed {
+            execute_sql(&frontend, "ADMIN FLUSH_TABLE('f04_upper_min_phy')").await;
+        }
+        for parallelism in [1, 4] {
+            for query in queries {
+                let actual = execute_sql_with_query_parallelism(&frontend, query, parallelism)
+                    .await
+                    .data
+                    .pretty_print()
+                    .await;
+                if actual.trim() != expected.trim() {
+                    mismatches.push(format!(
+                        "query `{query}` with query_parallelism={parallelism} flushed={flushed} \
+                         returned:\n{actual}"
+                    ));
+                }
+            }
+        }
+    }
+    assert!(
+        mismatches.is_empty(),
+        "small logical metric grouping must return [h0, 2] and [h1, 2]:\n{}",
+        mismatches.join("\n---\n")
+    );
+}
+
+#[apply(both_instances_cases)]
+async fn test_partitioned_merge_scan_left_join_repartitions(instance: Arc<dyn MockInstance>) {
+    let frontend = instance.frontend();
+    execute_sql(
+        &frontend,
+        r#"
+CREATE TABLE join_repro (
+    k STRING,
+    kind STRING,
+    v DOUBLE,
+    ts TIMESTAMP NOT NULL,
+    TIME INDEX (ts)
+)
+PARTITION ON COLUMNS (k) (
+    k < '1',
+    k >= '1' AND k < '2',
+    k >= '2' AND k < '3',
+    k >= '3' AND k < '4',
+    k >= '4' AND k < '5',
+    k >= '5' AND k < '6',
+    k >= '6' AND k < '7',
+    k >= '7' AND k < '8',
+    k >= '8' AND k < '9',
+    k >= '9' AND k < 'a',
+    k >= 'a' AND k < 'b',
+    k >= 'b' AND k < 'c',
+    k >= 'c' AND k < 'd',
+    k >= 'd' AND k < 'e',
+    k >= 'e' AND k < 'f',
+    k >= 'f'
+)
+ENGINE = mito
+WITH (append_mode = 'true')
+"#,
+    )
+    .await;
+
+    let mut rows = Vec::new();
+    for key in [
+        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'z',
+    ] {
+        rows.push(format!("('{key}', 'root', 1.0, '2024-01-01 00:00:00')"));
+        if key != 'z' {
+            for _ in 0..3 {
+                rows.push(format!("('{key}', 'child', 1.0, '2024-01-01 00:00:00')"));
+            }
+        }
+    }
+    execute_sql(
+        &frontend,
+        &format!("INSERT INTO join_repro VALUES {}", rows.join(",")),
+    )
+    .await;
+
+    let aggregate_sql = r#"SELECT count(*) roots, count(c.n) roots_with_children, sum(c.n) children
+FROM (SELECT k FROM join_repro WHERE kind = 'root') r
+LEFT JOIN (SELECT k, count(*) n FROM join_repro WHERE kind = 'child' GROUP BY k) c ON c.k = r.k"#;
+    for parallelism in [16, 8] {
+        let output = execute_sql_with_query_parallelism(&frontend, aggregate_sql, parallelism)
+            .await
+            .data
+            .pretty_print()
+            .await;
+        assert_eq!(
+            output,
+            "+-------+---------------------+----------+\n| roots | roots_with_children | children |\n+-------+---------------------+----------+\n| 17    | 16                  | 48       |\n+-------+---------------------+----------+"
+        );
+
+        let explain = execute_sql_with_query_parallelism(
+            &frontend,
+            &format!("EXPLAIN {aggregate_sql}"),
+            parallelism,
+        )
+        .await
+        .data
+        .pretty_print()
+        .await;
+        assert!(
+            explain.contains("HashJoinExec: mode=Partitioned"),
+            "query_parallelism={parallelism} should use a partitioned hash join; explain:\n{explain}"
+        );
+        assert!(
+            explain.contains("RepartitionExec: partitioning=Hash([k@0]"),
+            "query_parallelism={parallelism} should repartition on the join key; explain:\n{explain}"
+        );
+
+        let ordered_sql = r#"SELECT r.k, c.n
+FROM (SELECT k FROM join_repro WHERE kind = 'root') r
+LEFT JOIN (SELECT k, count(*) n FROM join_repro WHERE kind = 'child' GROUP BY k) c ON c.k = r.k
+ORDER BY r.k"#;
+        let ordered = execute_sql_with_query_parallelism(&frontend, ordered_sql, parallelism)
+            .await
+            .data
+            .pretty_print()
+            .await;
+        assert_eq!(
+            ordered,
+            r#"+---+---+
+| k | n |
++---+---+
+| 0 | 3 |
+| 1 | 3 |
+| 2 | 3 |
+| 3 | 3 |
+| 4 | 3 |
+| 5 | 3 |
+| 6 | 3 |
+| 7 | 3 |
+| 8 | 3 |
+| 9 | 3 |
+| a | 3 |
+| b | 3 |
+| c | 3 |
+| d | 3 |
+| e | 3 |
+| f | 3 |
+| z |   |
++---+---+"#
+        );
+
+        let pruned_sql = r#"SELECT count(*) roots, count(c.n) roots_with_children, sum(c.n) children
+FROM (SELECT k FROM join_repro WHERE kind = 'root' AND k >= '1' AND k < '9') r
+LEFT JOIN (SELECT k, count(*) n FROM join_repro WHERE kind = 'child' AND k < '8' GROUP BY k) c ON c.k = r.k"#;
+        let pruned = execute_sql_with_query_parallelism(&frontend, pruned_sql, parallelism)
+            .await
+            .data
+            .pretty_print()
+            .await;
+        assert_eq!(
+            pruned,
+            "+-------+---------------------+----------+\n| roots | roots_with_children | children |\n+-------+---------------------+----------+\n| 8     | 7                   | 21       |\n+-------+---------------------+----------+"
+        );
+
+        let pruned_explain = execute_sql_with_query_parallelism(
+            &frontend,
+            &format!("EXPLAIN {pruned_sql}"),
+            parallelism,
+        )
+        .await
+        .data
+        .pretty_print()
+        .await;
+        assert!(
+            pruned_explain.contains("HashJoinExec: mode=Partitioned"),
+            "query_parallelism={parallelism} pruned join should remain partitioned; explain:\n{pruned_explain}"
+        );
+        let hash_repartition_lines = pruned_explain
+            .lines()
+            .filter(|line| line.contains("RepartitionExec: partitioning=Hash([k@0]"))
+            .count();
+        assert_eq!(
+            hash_repartition_lines, 2,
+            "query_parallelism={parallelism} pruned join should repartition both inputs on k; explain:\n{pruned_explain}"
+        );
+    }
+}
+
+/// Regression test for `MatchesConstantTermOptimizer` dropping `FilterExec`'s `fetch`.
+///
+/// On a single-partition plan the `LIMIT` is enforced by the `fetch` that the physical
+/// `LimitPushdown` rule leaves on the `FilterExec`, so a rule rebuilding that `FilterExec`
+/// has to carry the `fetch` over. While it does not, the limit is silently lifted for
+/// `matches_term` filters and
+/// `SELECT count(*) FROM (SELECT ts, msg FROM t WHERE matches_term(msg, 'foo') LIMIT 1) s`
+/// returns the number of matching rows (2) instead of 1.
+///
+/// `query_parallelism=4` is expected to stay correct, because the limit is then materialized
+/// above the scan instead of being delegated to the `FilterExec`; the test pins down that
+/// contrast. The metric-engine logical table covers the same filter on a shared physical
+/// region.
+///
+/// Both matching rows share `ts` and `msg`, so the limited output does not depend on the
+/// order in which the scan returns them.
+#[apply(both_instances_cases)]
+async fn test_matches_term_subquery_limit_count(instance: Arc<dyn MockInstance>) {
+    let frontend = instance.frontend();
+
+    execute_sql(
+        &frontend,
+        r#"
+CREATE TABLE f07_mito_msgs (
+    ts TIMESTAMP TIME INDEX,
+    host STRING PRIMARY KEY,
+    msg STRING,
+    val DOUBLE
+)
+ENGINE = mito
+"#,
+    )
+    .await;
+    execute_sql(
+        &frontend,
+        r#"INSERT INTO f07_mito_msgs (ts, host, msg, val) VALUES
+    (0, 'host1', 'foo bar', 1.0),
+    (0, 'host2', 'foo bar', 2.0),
+    (0, 'host3', 'other baz', 3.0)"#,
+    )
+    .await;
+
+    execute_sql(
+        &frontend,
+        r#"
+CREATE TABLE f07_metric_phy (
+    ts TIMESTAMP TIME INDEX,
+    val DOUBLE,
+    host STRING,
+    msg STRING,
+    PRIMARY KEY (host, msg)
+)
+ENGINE = metric
+WITH ('physical_metric_table' = '')
+"#,
+    )
+    .await;
+    execute_sql(
+        &frontend,
+        r#"
+CREATE TABLE f07_metric_msgs (
+    ts TIMESTAMP TIME INDEX,
+    val DOUBLE,
+    host STRING,
+    msg STRING,
+    PRIMARY KEY (host, msg)
+)
+ENGINE = metric
+WITH ('on_physical_table' = 'f07_metric_phy')
+"#,
+    )
+    .await;
+    execute_sql(
+        &frontend,
+        r#"INSERT INTO f07_metric_msgs (ts, host, msg, val) VALUES
+    (0, 'host1', 'foo bar', 1.0),
+    (0, 'host2', 'foo bar', 2.0),
+    (0, 'host3', 'other baz', 3.0)"#,
+    )
+    .await;
+
+    for table in ["f07_mito_msgs", "f07_metric_msgs"] {
+        let limited = format!("SELECT ts, msg FROM {table} WHERE matches_term(msg, 'foo') LIMIT 1");
+        let count = format!("SELECT count(*) FROM ({limited}) s");
+
+        let limit_rows = execute_sql_with_query_parallelism(&frontend, &limited, 1)
+            .await
+            .data
+            .pretty_print()
+            .await;
+        assert_eq!(
+            limit_rows,
+            r#"+---------------------+---------+
+| ts                  | msg     |
++---------------------+---------+
+| 1970-01-01T00:00:00 | foo bar |
++---------------------+---------+"#,
+            "query_parallelism=1: `{limited}` must return exactly the single limited row"
+        );
+
+        for parallelism in [1, 4] {
+            let count_rows = execute_sql_with_query_parallelism(&frontend, &count, parallelism)
+                .await
+                .data
+                .pretty_print()
+                .await;
+            assert_eq!(
+                count_rows,
+                r#"+----------+
+| count(*) |
++----------+
+| 1        |
++----------+"#,
+                "query_parallelism={parallelism}: the LIMIT 1 of the subquery must cap `{count}` to one row"
+            );
+        }
+    }
+}
+
+#[apply(both_instances_cases)]
+async fn test_partitioned_merge_scan_semi_join_repartitions(instance: Arc<dyn MockInstance>) {
+    let frontend = instance.frontend();
+    execute_sql(
+        &frontend,
+        r#"
+CREATE TABLE semi_join_repro (
+    ts TIMESTAMP TIME INDEX,
+    key_id INT,
+    is_match BOOLEAN,
+    PRIMARY KEY (key_id)
+)
+PARTITION ON COLUMNS (key_id) (
+    key_id < 10,
+    key_id >= 10 AND key_id < 20,
+    key_id >= 20 AND key_id < 30,
+    key_id >= 30
+)
+ENGINE = mito
+"#,
+    )
+    .await;
+    execute_sql(
+        &frontend,
+        r#"INSERT INTO semi_join_repro VALUES
+('2026-10-09 00:00:00', 1, false),
+('2026-10-09 00:00:01', 1, true),
+('2026-10-09 00:00:00', 11, false),
+('2026-10-09 00:00:01', 11, true),
+('2026-10-09 00:00:00', 21, false),
+('2026-10-09 00:00:01', 21, true),
+('2026-10-09 00:00:00', 31, false),
+('2026-10-09 00:00:01', 31, true)"#,
+    )
+    .await;
+
+    let query = r#"SELECT t.key_id, MIN(t.ts) AS first_ts
+FROM semi_join_repro t
+WHERE t.key_id IN (
+    SELECT s.key_id FROM semi_join_repro s WHERE s.is_match = true
+)
+GROUP BY t.key_id
+ORDER BY t.key_id"#;
+    let mut query_ctx = QueryContext::with_db_name(None);
+    query_ctx.set_extension(QUERY_PARALLELISM_HINT, "2");
+    query_ctx.set_extension(QUERY_ENABLE_REMOTE_DYNAMIC_FILTER_PUSHDOWN, "true");
+    let query_ctx = Arc::new(query_ctx);
+    let output = execute_sql_with(&frontend, query, query_ctx.clone())
+        .await
+        .data
+        .pretty_print()
+        .await;
+    let expected = r#"+--------+---------------------+
+| key_id | first_ts            |
++--------+---------------------+
+| 1      | 2026-10-09T00:00:00 |
+| 11     | 2026-10-09T00:00:00 |
+| 21     | 2026-10-09T00:00:00 |
+| 31     | 2026-10-09T00:00:00 |
++--------+---------------------+"#;
+    assert_eq!(output, expected);
+
+    let explain = execute_sql_with(&frontend, &format!("EXPLAIN {query}"), query_ctx.clone())
+        .await
+        .data
+        .pretty_print()
+        .await;
+    assert!(
+        explain.contains("HashJoinExec: mode=Partitioned, join_type=LeftSemi"),
+        "parallel IN query should use a partitioned left-semi join; explain:\n{explain}"
+    );
+    assert!(
+        explain.contains("RepartitionExec: partitioning=Hash([key_id@1], 2)")
+            && explain.contains("RepartitionExec: partitioning=Hash([key_id@0], 2)"),
+        "parallel left-semi join should repartition both inputs on key_id; explain:\n{explain}"
+    );
+
+    let analyze_explain = execute_sql_with(
+        &frontend,
+        &format!("EXPLAIN ANALYZE VERBOSE {query}"),
+        query_ctx.clone(),
+    )
+    .await
+    .data
+    .pretty_print()
+    .await;
+    let has_remote_dyn_filter = |explain: &str| {
+        explain.lines().any(|line| {
+            line.contains("SeqScan: region=")
+                && line.contains("\"dyn_filters\"")
+                && line.contains("DynamicFilter")
+        })
+    };
+    assert!(
+        has_remote_dyn_filter(&analyze_explain),
+        "expected remote region SeqScan dyn_filters to include DynamicFilter; explain:\n{analyze_explain}"
+    );
+
+    let mut query_ctx_without_rdf = QueryContext::with_db_name(None);
+    query_ctx_without_rdf.set_extension(QUERY_PARALLELISM_HINT, "2");
+    query_ctx_without_rdf.set_extension(QUERY_ENABLE_REMOTE_DYNAMIC_FILTER_PUSHDOWN, "false");
+    let query_ctx_without_rdf = Arc::new(query_ctx_without_rdf);
+    let output_without_rdf = execute_sql_with(&frontend, query, query_ctx_without_rdf.clone())
+        .await
+        .data
+        .pretty_print()
+        .await;
+    assert_eq!(output_without_rdf, expected);
+
+    let analyze_explain_without_rdf = execute_sql_with(
+        &frontend,
+        &format!("EXPLAIN ANALYZE VERBOSE {query}"),
+        query_ctx_without_rdf,
+    )
+    .await
+    .data
+    .pretty_print()
+    .await;
+    assert!(
+        !analyze_explain_without_rdf
+            .lines()
+            .any(|line| line.contains("SeqScan: region=") && line.contains("\"dyn_filters\"")),
+        "expected no region SeqScan dyn_filters line when remote dynamic filter pushdown is disabled; explain:\n{analyze_explain_without_rdf}"
+    );
+}
+
 #[apply(both_instances_cases)]
 async fn test_show_create_table(instance: Arc<dyn MockInstance>) {
     let frontend = instance.frontend();
@@ -2648,7 +3340,7 @@ async fn test_execute_copy_from_orc_with_cast(instance: Arc<dyn MockInstance>) {
 
     let output = execute_sql(
         &instance,
-        &format!("copy demo from '{}' WITH(FORMAT='orc');", &filepath),
+        &format!("copy demo from '{}' WITH(FORMAT='orc');", filepath),
     )
     .await
     .data;
@@ -2687,7 +3379,7 @@ async fn test_execute_copy_from_orc(instance: Arc<dyn MockInstance>) {
 
     let output = execute_sql(
         &instance,
-        &format!("copy demo from '{}' WITH(FORMAT='orc');", &filepath),
+        &format!("copy demo from '{}' WITH(FORMAT='orc');", filepath),
     )
     .await
     .data;
@@ -2724,7 +3416,7 @@ async fn test_cast_type_issue_1594(instance: Arc<dyn MockInstance>) {
 
     let output = execute_sql(
         &instance,
-        &format!("copy tsbs_cpu from '{}' WITH(FORMAT='csv');", &filepath),
+        &format!("copy tsbs_cpu from '{}' WITH(FORMAT='csv');", filepath),
     )
     .await;
 
@@ -2762,7 +3454,7 @@ async fn test_copy_from_csv_skip_bad_records(instance: Arc<dyn MockInstance>) {
         &instance,
         &format!(
             "copy csv_skip_bad_records from '{}' WITH(FORMAT='csv', skip_bad_records='true');",
-            &filepath
+            filepath
         ),
     )
     .await
diff --git a/tests-integration/src/tests/promql_test.rs b/tests-integration/src/tests/promql_test.rs
index 74114bbd6c4..7796be4d15b 100644
--- a/tests-integration/src/tests/promql_test.rs
+++ b/tests-integration/src/tests/promql_test.rs
@@ -22,10 +22,13 @@ use api::v1::{
 use common_query::prometheus::PROMETHEUS_STALE_NAN_BITS;
 use common_query::{Output, OutputData};
 use common_recordbatch::util::collect_batches;
-use datatypes::arrow::array::{Float64Array, Int64Array, StringArray, TimestampMillisecondArray};
+use datatypes::arrow::array::{
+    Array, Float64Array, Int64Array, StringArray, TimestampMillisecondArray,
+};
 use datatypes::arrow::compute::cast;
 use datatypes::arrow::datatypes::DataType;
 use frontend::instance::Instance;
+use query::datafusion::QUERY_PARALLELISM_HINT;
 use query::parser::{PromQuery, QueryLanguageParser, QueryStatement};
 use rstest::rstest;
 use rstest_reuse::apply;
@@ -193,6 +196,139 @@ async fn promql_query_as_batches(
     }
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn histogram_fraction_binary_join_preserves_partitioned_rows() {
+    common_telemetry::init_default_ut_logging();
+
+    let distributed = crate::tests::create_distributed_instance(
+        "histogram_fraction_binary_join_preserves_partitioned_rows",
+    )
+    .await;
+    let instance = distributed.frontend();
+
+    for (table, create) in [
+        (
+            "pa_promql_m",
+            r#"CREATE TABLE pa_promql_m (
+                ts TIMESTAMP TIME INDEX,
+                host STRING,
+                shard STRING,
+                val DOUBLE,
+                PRIMARY KEY (host, shard)
+            ) PARTITION ON COLUMNS (shard) (
+                shard < 'b',
+                shard >= 'b' AND shard < 'c',
+                shard >= 'c' AND shard < 'd',
+                shard >= 'd'
+            );"#,
+        ),
+        (
+            "lg_hist_m_2",
+            r#"CREATE TABLE phy_hist_m_2 (
+                ts TIMESTAMP TIME INDEX,
+                host STRING,
+                shard STRING,
+                val DOUBLE,
+                PRIMARY KEY (host, shard)
+            ) PARTITION ON COLUMNS (shard) (
+                shard < 'b',
+                shard >= 'b' AND shard < 'c',
+                shard >= 'c' AND shard < 'd',
+                shard >= 'd'
+            ) ENGINE=metric WITH ('physical_metric_table' = 'true');
+            CREATE TABLE lg_hist_m_2 (
+                ts TIMESTAMP TIME INDEX,
+                host STRING,
+                shard STRING,
+                val DOUBLE,
+                PRIMARY KEY (host, shard)
+            ) PARTITION ON COLUMNS (shard) (
+                shard < 'b',
+                shard >= 'b' AND shard < 'c',
+                shard >= 'c' AND shard < 'd',
+                shard >= 'd'
+            ) ENGINE=metric WITH ('on_physical_table' = 'phy_hist_m_2');"#,
+        ),
+    ] {
+        execute_all(
+            &instance,
+            &format!(
+                "{create}\nINSERT INTO {table} (ts, host, shard, val) VALUES\n                    (0, 'h', 'a', 1),\n                    (0, 'h', 'b', 1),\n                    (0, 'h', 'c', 1),\n                    (0, 'h', 'd', 1);"
+            ),
+            QueryContext::arc(),
+        )
+        .await;
+
+        let expr = format!(
+            r#"histogram_fraction(-Inf,+Inf,abs(label_replace(({table} + on(host) group_left() (sum by(host)({table}))),"le","+Inf","missing_label",".*")))"#
+        );
+        for parallelism in [1, 4] {
+            let mut query_ctx = QueryContext::with_db_name(None);
+            query_ctx.set_extension(QUERY_PARALLELISM_HINT, parallelism.to_string());
+            let query_ctx = Arc::new(query_ctx);
+            for (query, expected_value) in [
+                (format!("TQL EVAL (0, 0, '1s') {expr}"), 1.0),
+                (
+                    format!("TQL EVAL (0, 0, '1s') {expr} + on(host, shard) {table}"),
+                    2.0,
+                ),
+            ] {
+                let output = instance
+                    .do_query(&query, query_ctx.clone())
+                    .await
+                    .remove(0)
+                    .unwrap();
+                let batches = match output.data {
+                    OutputData::Stream(stream) => collect_batches(stream).await.unwrap(),
+                    OutputData::RecordBatches(batches) => batches,
+                    other => panic!("expected result batches, got {other:?}"),
+                };
+                let mut rows = batches
+                    .iter()
+                    .flat_map(|batch| {
+                        let ts = batch
+                            .column_by_name("ts")
+                            .unwrap()
+                            .as_any()
+                            .downcast_ref::<TimestampMillisecondArray>()
+                            .unwrap();
+                        let host_array =
+                            cast(batch.column_by_name("host").unwrap(), &DataType::Utf8).unwrap();
+                        let host = host_array.as_any().downcast_ref::<StringArray>().unwrap();
+                        let shard_array =
+                            cast(batch.column_by_name("shard").unwrap(), &DataType::Utf8).unwrap();
+                        let shard = shard_array.as_any().downcast_ref::<StringArray>().unwrap();
+                        let value = batch
+                            .columns()
+                            .iter()
+                            .find_map(|column| column.as_any().downcast_ref::<Float64Array>())
+                            .unwrap();
+                        (0..batch.num_rows())
+                            .map(move |row| {
+                                (
+                                    ts.value(row),
+                                    host.value(row).to_owned(),
+                                    shard.value(row).to_owned(),
+                                    value.value(row),
+                                )
+                            })
+                            .collect::<Vec<_>>()
+                    })
+                    .collect::<Vec<_>>();
+                rows.sort_by(|left, right| left.2.cmp(&right.2));
+                assert_eq!(
+                    rows,
+                    ["a", "b", "c", "d"]
+                        .into_iter()
+                        .map(|shard| (0, "h".to_owned(), shard.to_owned(), expected_value))
+                        .collect::<Vec<_>>(),
+                    "query_parallelism={parallelism}, query={query}"
+                );
+            }
+        }
+    }
+}
+
 const ANON_PROMQL_RATIO_REPRO_DB: &str = "repro_db";
 
 const ANON_PROMQL_RATIO_REPRO_CREATE: &str = r#"
@@ -1176,3 +1312,443 @@ async fn promql_stale_marker_excludes_series_across_flushes(instance: Arc<dyn Mo
         assert_nan_series(extract_samples(query_at(2_500).await), 2_500);
     }
 }
+
+// ---------------------------------------------------------------------------
+// F06: `ScalarCalculate` (`scalar()` in TQL) order contract
+// ---------------------------------------------------------------------------
+//
+// `scalar()` inside a TQL CTE is planned as `ScalarCalculate`
+// (`src/promql/src/extension_plan/scalar_calculate.rs`). Before this fix, its execution plan
+// claimed `maintains_input_order() == true` even though the node projects its
+// input down to `(time_index, scalar(field))`, so its output column `ts@0` is
+// not the input column `0`. DataFusion's sort push-down mapped the sort key by
+// column index, so the SQL-level sort over `scalar()` read the wrong column:
+//
+// * `ORDER BY ts DESC` really sorted by `host` (ordinary Mito table) or by `val`
+//   (metric logical table) and silently returned the wrong row order.
+// * `ORDER BY "scalar(val)" ASC` did not order by the scalar value at all.
+// * `LAG(...) OVER (ORDER BY ts DESC)` could not be planned before this fix:
+//   the window needed `ts@0 DESC` while the pushed-down sort provided
+//   `host@0 DESC` / `val@0 DESC`, so planning failed with code 3000.
+//
+// The controls below must keep passing: a bare selector keeps the `ts` order of
+// its input, and `ORDER BY ts DESC LIMIT 3` keeps the correct `TopK` above
+// `ScalarCalculate` (the fetch blocks the wrong push-down).
+//
+// Every comparison below is row-by-row in result order: sorting the rows before
+// comparing them would hide exactly this bug.
+
+/// `(ts_millis, val)` fixture shared by both engines.
+///
+/// The values are deliberately neither ascending nor descending, so a wrong row
+/// order is visible in the value column too: `ORDER BY ts DESC` must pair
+/// `ts = 3000` with `2.0`, not with `4.0`.
+const F06_FIXTURE_ROWS: &[(i64, f64)] = &[(0, 4.0), (1000, 1.0), (2000, 3.0), (3000, 2.0)];
+
+/// Truth of `ORDER BY ts DESC` over the F06 fixture.
+const F06_ROWS_BY_TS_DESC: &[(i64, f64)] = &[(3000, 2.0), (2000, 3.0), (1000, 1.0), (0, 4.0)];
+
+/// Truth of `ORDER BY ts DESC LIMIT 3` over the F06 fixture.
+const F06_ROWS_BY_TS_DESC_LIMIT_3: &[(i64, f64)] = &[(3000, 2.0), (2000, 3.0), (1000, 1.0)];
+
+/// Truth of `ORDER BY "scalar(val)" ASC` over the F06 fixture.
+const F06_ROWS_BY_VALUE_ASC: &[(i64, f64)] = &[(1000, 1.0), (3000, 2.0), (2000, 3.0), (0, 4.0)];
+
+/// Truth of `LAG("scalar(val)") OVER (ORDER BY ts DESC)` over the F06 fixture:
+/// the row order, the scalar values and the lagged values `(ts_millis, val,
+/// prev)`. The window's first row has no predecessor, so its `prev` is `NULL`.
+const F06_ROWS_LAG_BY_TS_DESC: &[(i64, f64, Option<f64>)] = &[
+    (3000, 2.0, None),
+    (2000, 3.0, Some(2.0)),
+    (1000, 1.0, Some(3.0)),
+    (0, 4.0, Some(1.0)),
+];
+
+/// Output column of a `scalar()` TQL query; it has to be quoted in SQL.
+const F06_SCALAR_VALUE_COLUMN: &str = "scalar(val)";
+
+/// Ordinary Mito fixture. `host` stays the first column on purpose: the wrong
+/// push-down reuses output index `0` (`ts`) as input column `0` (`host`).
+const F06_ORDINARY_TABLE: &str = "f06_scalar_plain";
+
+const F06_ORDINARY_CREATE: &str = r#"
+CREATE TABLE f06_scalar_plain (
+    host STRING PRIMARY KEY,
+    ts TIMESTAMP TIME INDEX,
+    val DOUBLE
+);
+"#;
+
+/// Metric fixture; the physical table only carries the logical table, all
+/// `INSERT`s, reads and TQL queries go to the logical `f06_scalar_metric`.
+/// `ScalarCalculate` sees its input columns as `(val, host, ts)`, so the wrong
+/// push-down turns `ts@0` into `val@0`.
+const F06_METRIC_TABLE: &str = "f06_scalar_metric";
+
+const F06_METRIC_CREATE: &str = r#"
+CREATE TABLE f06_scalar_phy (
+    ts TIMESTAMP TIME INDEX,
+    val DOUBLE
+) ENGINE=metric WITH ("physical_metric_table" = "");
+
+CREATE TABLE f06_scalar_metric (
+    host STRING,
+    ts TIMESTAMP TIME INDEX,
+    val DOUBLE,
+    PRIMARY KEY (host)
+) ENGINE=metric WITH (on_physical_table = 'f06_scalar_phy');
+"#;
+
+fn f06_insert_sql(table: &str) -> String {
+    format!(
+        "INSERT INTO {table} (host, ts, val) VALUES \
+         ('h', 0, 4), ('h', 1000, 1), ('h', 2000, 3), ('h', 3000, 2)"
+    )
+}
+
+fn f06_fixture_sql(table: &str) -> String {
+    format!("SELECT ts, val FROM {table} ORDER BY ts")
+}
+
+/// `ORDER BY ts DESC` over `scalar()`; this is the repro of the wrong sort
+/// push-down.
+fn f06_scalar_order_by_ts_desc_sql(table: &str) -> String {
+    format!("WITH q AS (TQL EVAL (0, 3, '1s') scalar({table})) SELECT * FROM q ORDER BY ts DESC")
+}
+
+/// Same as [`f06_scalar_order_by_ts_desc_sql`] but with a fetch, which keeps the
+/// correct `TopK` above `ScalarCalculate`.
+fn f06_scalar_order_by_ts_desc_limit_3_sql(table: &str) -> String {
+    format!(
+        "WITH q AS (TQL EVAL (0, 3, '1s') scalar({table})) SELECT * FROM q \
+         ORDER BY ts DESC LIMIT 3"
+    )
+}
+
+/// `ORDER BY` on the scalar value instead of on the time index.
+fn f06_scalar_order_by_value_asc_sql(table: &str) -> String {
+    format!(
+        r#"WITH q AS (TQL EVAL (0, 3, '1s') scalar({table})) SELECT * FROM q ORDER BY "scalar(val)" ASC"#
+    )
+}
+
+/// A SQL window over `scalar()`; the window requires the `ts` order that the
+/// wrong push-down removes.
+fn f06_scalar_lag_order_by_ts_desc_sql(table: &str) -> String {
+    format!(
+        r#"WITH q AS (TQL EVAL (0, 3, '1s') scalar({table})) SELECT ts, "scalar(val)" AS val, LAG("scalar(val)") OVER (ORDER BY ts DESC) AS prev FROM q ORDER BY ts DESC"#
+    )
+}
+
+/// Selector control: the `ts` order of a bare selector must stay correct.
+fn f06_selector_order_by_ts_desc_sql(table: &str) -> String {
+    format!("WITH q AS (TQL EVAL (0, 3, '1s') {table}) SELECT ts, val FROM q ORDER BY ts DESC")
+}
+
+/// Creates and fills one F06 fixture and also guards the fixture itself: an
+/// ordering regression is only meaningful if the stored rows read back in `ts`
+/// order.
+async fn f06_setup(instance: &Arc<Instance>, create: &str, table: &str) {
+    let insert = f06_insert_sql(table);
+    for sql in [create, insert.as_str()] {
+        for result in instance.do_query(sql, QueryContext::arc()).await {
+            if let Err(err) = result {
+                panic!("F06: setup statement failed: {err}\n{sql}");
+            }
+        }
+    }
+
+    let sql = f06_fixture_sql(table);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_rows(instance, &sql, parallelism, "val").await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_FIXTURE_ROWS,
+            "F06: fixture `{table}` must read back in `ts` order (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
+
+/// Runs one F06 query with a query parallelism hint and returns its rows in
+/// result order as `(ts_millis, value_column)`; the rows are never sorted here.
+async fn f06_ordered_rows(
+    instance: &Arc<Instance>,
+    sql: &str,
+    parallelism: usize,
+    value_column: &str,
+) -> Vec<(i64, f64)> {
+    let mut query_ctx = QueryContext::with_db_name(None);
+    query_ctx.set_extension(QUERY_PARALLELISM_HINT, parallelism.to_string());
+    let output = instance
+        .do_query(sql, Arc::new(query_ctx))
+        .await
+        .remove(0)
+        .unwrap_or_else(|err| panic!("F06: query failed: {err}\n{sql}"));
+    let batches = match output.data {
+        OutputData::Stream(stream) => collect_batches(stream).await.unwrap(),
+        OutputData::RecordBatches(batches) => batches,
+        _ => unreachable!("F06: expected a query result"),
+    };
+
+    let mut rows = Vec::new();
+    for batch in batches.iter() {
+        let ts = cast(
+            batch.column_by_name("ts").unwrap().as_ref(),
+            &DataType::Int64,
+        )
+        .unwrap();
+        let ts = ts.as_any().downcast_ref::<Int64Array>().unwrap();
+        let values = batch.column_by_name(value_column).unwrap();
+        let values = values.as_any().downcast_ref::<Float64Array>().unwrap();
+        for row in 0..batch.num_rows() {
+            rows.push((ts.value(row), values.value(row)));
+        }
+    }
+    rows
+}
+
+/// Runs the F06 `LAG` query and returns its rows in result order as
+/// `(ts_millis, val, prev)`; `prev` is `None` for the first row of the window.
+/// The rows are never sorted here.
+async fn f06_ordered_lag_rows(
+    instance: &Arc<Instance>,
+    sql: &str,
+    parallelism: usize,
+) -> Vec<(i64, f64, Option<f64>)> {
+    let mut query_ctx = QueryContext::with_db_name(None);
+    query_ctx.set_extension(QUERY_PARALLELISM_HINT, parallelism.to_string());
+    let output = instance
+        .do_query(sql, Arc::new(query_ctx))
+        .await
+        .remove(0)
+        .unwrap_or_else(|err| panic!("F06: query failed: {err}\n{sql}"));
+    let batches = match output.data {
+        OutputData::Stream(stream) => collect_batches(stream).await.unwrap(),
+        OutputData::RecordBatches(batches) => batches,
+        _ => unreachable!("F06: expected a query result"),
+    };
+
+    let mut rows = Vec::new();
+    for batch in batches.iter() {
+        let ts = cast(
+            batch.column_by_name("ts").unwrap().as_ref(),
+            &DataType::Int64,
+        )
+        .unwrap();
+        let ts = ts.as_any().downcast_ref::<Int64Array>().unwrap();
+        let values = batch.column_by_name("val").unwrap();
+        let values = values.as_any().downcast_ref::<Float64Array>().unwrap();
+        let prevs = batch.column_by_name("prev").unwrap();
+        let prevs = prevs.as_any().downcast_ref::<Float64Array>().unwrap();
+        for row in 0..batch.num_rows() {
+            let prev = if prevs.is_null(row) {
+                None
+            } else {
+                Some(prevs.value(row))
+            };
+            rows.push((ts.value(row), values.value(row), prev));
+        }
+    }
+    rows
+}
+
+/// Repro of the wrong sort push-down: `ORDER BY ts DESC` over `scalar()` is
+/// pushed into the TQL input as `host@0 DESC` and silently returns the wrong row
+/// order (the fixture order, not `ts`-descending).
+#[apply(both_instances_cases)]
+async fn f06_scalar_ordinary_table_order_by_ts_desc(instance: Arc<dyn MockInstance>) {
+    let instance = instance.frontend();
+    f06_setup(&instance, F06_ORDINARY_CREATE, F06_ORDINARY_TABLE).await;
+
+    let sql = f06_scalar_order_by_ts_desc_sql(F06_ORDINARY_TABLE);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_rows(&instance, &sql, parallelism, F06_SCALAR_VALUE_COLUMN).await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_ROWS_BY_TS_DESC,
+            "F06: `ORDER BY ts DESC` over scalar() must return `ts`-descending rows \
+             (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
+
+/// Same repro as [`f06_scalar_ordinary_table_order_by_ts_desc`] for a metric
+/// logical table, where the wrong push-down uses `val@0 DESC`.
+#[apply(both_instances_cases)]
+async fn f06_scalar_metric_table_order_by_ts_desc(instance: Arc<dyn MockInstance>) {
+    let instance = instance.frontend();
+    f06_setup(&instance, F06_METRIC_CREATE, F06_METRIC_TABLE).await;
+
+    let sql = f06_scalar_order_by_ts_desc_sql(F06_METRIC_TABLE);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_rows(&instance, &sql, parallelism, F06_SCALAR_VALUE_COLUMN).await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_ROWS_BY_TS_DESC,
+            "F06: `ORDER BY ts DESC` over scalar() must return `ts`-descending rows \
+             (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
+
+/// Repro: ordering by the scalar value is broken as well, the rows come back in
+/// the fixture order instead of `1.0, 2.0, 3.0, 4.0`.
+#[apply(both_instances_cases)]
+async fn f06_scalar_ordinary_table_order_by_value_asc(instance: Arc<dyn MockInstance>) {
+    let instance = instance.frontend();
+    f06_setup(&instance, F06_ORDINARY_CREATE, F06_ORDINARY_TABLE).await;
+
+    let sql = f06_scalar_order_by_value_asc_sql(F06_ORDINARY_TABLE);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_rows(&instance, &sql, parallelism, F06_SCALAR_VALUE_COLUMN).await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_ROWS_BY_VALUE_ASC,
+            "F06: `ORDER BY \"scalar(val)\" ASC` must order by the scalar value \
+             (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
+
+/// Same as [`f06_scalar_ordinary_table_order_by_value_asc`] for a metric logical
+/// table.
+#[apply(both_instances_cases)]
+async fn f06_scalar_metric_table_order_by_value_asc(instance: Arc<dyn MockInstance>) {
+    let instance = instance.frontend();
+    f06_setup(&instance, F06_METRIC_CREATE, F06_METRIC_TABLE).await;
+
+    let sql = f06_scalar_order_by_value_asc_sql(F06_METRIC_TABLE);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_rows(&instance, &sql, parallelism, F06_SCALAR_VALUE_COLUMN).await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_ROWS_BY_VALUE_ASC,
+            "F06: `ORDER BY \"scalar(val)\" ASC` must order by the scalar value \
+             (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
+
+/// Control that must stay correct: the fetch keeps the `TopK` above
+/// `ScalarCalculate`, so the `ts` order is right although the plain
+/// `ORDER BY ts DESC` repro is wrong.
+#[apply(both_instances_cases)]
+async fn f06_scalar_ordinary_table_order_by_ts_desc_limit_3_control(
+    instance: Arc<dyn MockInstance>,
+) {
+    let instance = instance.frontend();
+    f06_setup(&instance, F06_ORDINARY_CREATE, F06_ORDINARY_TABLE).await;
+
+    let sql = f06_scalar_order_by_ts_desc_limit_3_sql(F06_ORDINARY_TABLE);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_rows(&instance, &sql, parallelism, F06_SCALAR_VALUE_COLUMN).await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_ROWS_BY_TS_DESC_LIMIT_3,
+            "F06: `ORDER BY ts DESC LIMIT 3` over scalar() must keep returning the newest rows \
+             (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
+
+/// Metric logical table variant of
+/// [`f06_scalar_ordinary_table_order_by_ts_desc_limit_3_control`].
+#[apply(both_instances_cases)]
+async fn f06_scalar_metric_table_order_by_ts_desc_limit_3_control(instance: Arc<dyn MockInstance>) {
+    let instance = instance.frontend();
+    f06_setup(&instance, F06_METRIC_CREATE, F06_METRIC_TABLE).await;
+
+    let sql = f06_scalar_order_by_ts_desc_limit_3_sql(F06_METRIC_TABLE);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_rows(&instance, &sql, parallelism, F06_SCALAR_VALUE_COLUMN).await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_ROWS_BY_TS_DESC_LIMIT_3,
+            "F06: `ORDER BY ts DESC LIMIT 3` over scalar() must keep returning the newest rows \
+             (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
+
+/// Selector control that must stay correct: a bare selector does not go through
+/// `ScalarCalculate`, so `ORDER BY ts DESC` over it is right.
+#[apply(both_instances_cases)]
+async fn f06_selector_ordinary_table_order_by_ts_desc_control(instance: Arc<dyn MockInstance>) {
+    let instance = instance.frontend();
+    f06_setup(&instance, F06_ORDINARY_CREATE, F06_ORDINARY_TABLE).await;
+
+    let sql = f06_selector_order_by_ts_desc_sql(F06_ORDINARY_TABLE);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_rows(&instance, &sql, parallelism, "val").await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_ROWS_BY_TS_DESC,
+            "F06: a bare selector must keep its `ts` order under `ORDER BY ts DESC` \
+             (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
+
+/// Metric logical table variant of
+/// [`f06_selector_ordinary_table_order_by_ts_desc_control`].
+#[apply(both_instances_cases)]
+async fn f06_selector_metric_table_order_by_ts_desc_control(instance: Arc<dyn MockInstance>) {
+    let instance = instance.frontend();
+    f06_setup(&instance, F06_METRIC_CREATE, F06_METRIC_TABLE).await;
+
+    let sql = f06_selector_order_by_ts_desc_sql(F06_METRIC_TABLE);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_rows(&instance, &sql, parallelism, "val").await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_ROWS_BY_TS_DESC,
+            "F06: a bare selector must keep its `ts` order under `ORDER BY ts DESC` \
+             (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
+
+/// Repro of the planning failure that the wrong sort push-down used to cause:
+/// the window needs `ts@0 DESC`, the pushed-down sort only provided
+/// `host@0 DESC`, so this query failed with code 3000 while `ScalarCalculate`
+/// claimed `maintains_input_order`.
+///
+/// Now that the node stops claiming the input order, the window is planned
+/// above the correct sort and the query must return exactly
+/// `(3000, 2.0, NULL)`, `(2000, 3.0, 2.0)`, `(1000, 1.0, 3.0)`,
+/// `(0, 4.0, 1.0)`.
+#[apply(both_instances_cases)]
+async fn f06_scalar_ordinary_table_lag_order_by_ts_desc(instance: Arc<dyn MockInstance>) {
+    let instance = instance.frontend();
+    f06_setup(&instance, F06_ORDINARY_CREATE, F06_ORDINARY_TABLE).await;
+
+    let sql = f06_scalar_lag_order_by_ts_desc_sql(F06_ORDINARY_TABLE);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_lag_rows(&instance, &sql, parallelism).await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_ROWS_LAG_BY_TS_DESC,
+            "F06: `LAG(...) OVER (ORDER BY ts DESC)` over scalar() must return `ts`-descending \
+             rows with the lagged scalar values (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
+
+/// Metric logical table variant of
+/// [`f06_scalar_ordinary_table_lag_order_by_ts_desc`].
+#[apply(both_instances_cases)]
+async fn f06_scalar_metric_table_lag_order_by_ts_desc(instance: Arc<dyn MockInstance>) {
+    let instance = instance.frontend();
+    f06_setup(&instance, F06_METRIC_CREATE, F06_METRIC_TABLE).await;
+
+    let sql = f06_scalar_lag_order_by_ts_desc_sql(F06_METRIC_TABLE);
+    for parallelism in [1, 4] {
+        let rows = f06_ordered_lag_rows(&instance, &sql, parallelism).await;
+        assert_eq!(
+            rows.as_slice(),
+            F06_ROWS_LAG_BY_TS_DESC,
+            "F06: `LAG(...) OVER (ORDER BY ts DESC)` over scalar() must return `ts`-descending \
+             rows with the lagged scalar values (parallelism={parallelism})\n{sql}"
+        );
+    }
+}
diff --git a/tests-integration/tests/http.rs b/tests-integration/tests/http.rs
index bd9226f724b..8b608fe7694 100644
--- a/tests-integration/tests/http.rs
+++ b/tests-integration/tests/http.rs
@@ -1022,6 +1022,31 @@ pub async fn test_prometheus_label_replace_response(store_type: StorageType) {
         .unwrap()
     );
 
+    // A series whose source value does not match keeps its labels, without `host_copy`.
+    let query = encode(r#"label_replace(demo, "host_copy", "$1", "host", "other(.*)")"#);
+    let res = client
+        .get(&format!("/v1/prometheus/api/v1/query?query={query}&time=0"))
+        .send()
+        .await;
+
+    assert_eq!(res.status(), StatusCode::OK);
+    let body = res.json::<PrometheusJsonResponse>().await;
+    assert_eq!(body.status, "success");
+    assert_eq!(
+        body.data,
+        serde_json::from_value::<PrometheusResponse>(json!({
+            "resultType": "vector",
+            "result": [{
+                "metric": {
+                    "__name__": "demo",
+                    "host": "host1"
+                },
+                "value": [0.0, "1.1"]
+            }]
+        }))
+        .unwrap()
+    );
+
     guard.remove_all().await;
 }
 
@@ -1997,6 +2022,7 @@ pub async fn test_promql_over_non_millisecond_physical_tables(store_type: Storag
         "query_range?query=unit_gauge&start=0&end=5&step=1",
         "query?query=avg_over_time(unit_gauge[1m])&time=2",
         "query?query=rate(unit_gauge[1m])&time=2",
+        "query?query=unit_gauge[1m]&time=2",
     ];
     for path in query_paths {
         let mut baseline: Option<(String, PrometheusResponse)> = None;
@@ -2064,6 +2090,24 @@ pub async fn test_promql_over_non_millisecond_physical_tables(store_type: Storag
         .unwrap()
     );
 
+    let res = client
+        .get("/v1/prometheus/api/v1/query?db=promql_units_ms&query=unit_gauge[1m]&time=2")
+        .send()
+        .await;
+    assert_eq!(res.status(), StatusCode::OK);
+    let body = res.json::<PrometheusJsonResponse>().await;
+    assert_eq!(
+        body.data,
+        serde_json::from_value::<PrometheusResponse>(json!({
+            "resultType": "matrix",
+            "result": [{
+                "metric": {"__name__": "unit_gauge", "job": "demo"},
+                "values": [[1.0, "1.0"], [2.0, "2.0"]]
+            }]
+        }))
+        .unwrap()
+    );
+
     let res = client
         .get("/v1/prometheus/api/v1/query?db=promql_units_ms&query=avg_over_time(unit_gauge[1m])&time=2")
         .send()
diff --git a/tests-integration/tests/sql.rs b/tests-integration/tests/sql.rs
index cb3d151fa85..d88fcecf1cd 100644
--- a/tests-integration/tests/sql.rs
+++ b/tests-integration/tests/sql.rs
@@ -86,6 +86,7 @@ macro_rules! sql_tests {
                 test_postgres_datestyle,
                 test_postgres_intervalstyle,
                 test_postgres_parameter_inference,
+                test_postgres_expression_depth,
                 test_postgres_regclass_bind_parameter,
                 test_postgres_uint64_parameter,
                 test_postgres_explain_bind_parameter,
@@ -1602,6 +1603,56 @@ pub async fn test_postgres_parameter_inference(store_type: StorageType) {
     guard.remove_all().await;
 }
 
+// Regression for #9553: reject the predicate before DataFusion's simplifier
+// overflows the worker stack, and keep the extended-query connection usable.
+pub async fn test_postgres_expression_depth(store_type: StorageType) {
+    let (mut guard, server) = setup_pg_server(store_type, "test_postgres_expression_depth").await;
+    let addr = server.bind_addr().unwrap();
+    let (client, connection) = tokio_postgres::connect(&format!("postgres://{addr}/public"), NoTls)
+        .await
+        .unwrap();
+    let connection = tokio::spawn(connection);
+    client
+        .simple_query(
+            "CREATE TABLE depth_guard (ts TIMESTAMP TIME INDEX, v INT); \
+             INSERT INTO depth_guard VALUES (0, 42)",
+        )
+        .await
+        .unwrap();
+
+    let query = |terms: usize| {
+        let predicate = std::iter::once("CAST(v AS BIGINT) = $1".to_string())
+            .chain((1..terms).map(|i| format!("CAST(v AS BIGINT) = {i}")))
+            .collect::<Vec<_>>()
+            .join(" OR ");
+        format!("SELECT count(*) FROM depth_guard WHERE {predicate}")
+    };
+    let row = client.query_one(&query(64), &[&42_i64]).await.unwrap();
+    assert_eq!(row.get::<_, i64>(0), 1);
+
+    for prefix in ["", "EXPLAIN ", "EXPLAIN ANALYZE "] {
+        let error = client
+            .query(&format!("{prefix}{}", query(512)), &[&42_i64])
+            .await
+            .unwrap_err();
+        assert!(
+            error
+                .as_db_error()
+                .unwrap()
+                .message()
+                .contains("Expression depth exceeds the maximum supported depth of 128"),
+            "{error}"
+        );
+        let row = client.query_one("SELECT 42::BIGINT", &[]).await.unwrap();
+        assert_eq!(row.get::<_, i64>(0), 42);
+    }
+
+    drop(client);
+    connection.await.unwrap().unwrap();
+    server.shutdown().await.unwrap();
+    guard.remove_all().await;
+}
+
 pub async fn test_postgres_regclass_bind_parameter(store_type: StorageType) {
     let (mut guard, fe_pg_server) =
         setup_pg_server(store_type, "test_postgres_regclass_bind_parameter").await;
diff --git a/tests/cases/distributed/explain/step_aggr_advance.result b/tests/cases/distributed/explain/step_aggr_advance.result
index 348021360ff..11adf22f866 100644
--- a/tests/cases/distributed/explain/step_aggr_advance.result
+++ b/tests/cases/distributed/explain/step_aggr_advance.result
@@ -21,26 +21,26 @@ Affected Rows: 0
 -- SQLNESS REPLACE (Hash.*) REDACTED
 tql explain (1752591864, 1752592164, '30s') max by (a, b, c) (max_over_time(aggr_optimize_not [2m]));
 
-+---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| plan_type     | plan                                                                                                                                                                                                                                                                    |
-+---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| logical_plan  | MergeSort: aggr_optimize_not.a ASC NULLS LAST, aggr_optimize_not.b ASC NULLS LAST, aggr_optimize_not.c ASC NULLS LAST, aggr_optimize_not.greptime_timestamp ASC NULLS LAST                                                                                              |
-|               |   MergeScan [is_placeholder=false, remote_input=[                                                                                                                                                                                                                       |
-|               | Sort: aggr_optimize_not.a ASC NULLS LAST, aggr_optimize_not.b ASC NULLS LAST, aggr_optimize_not.c ASC NULLS LAST, aggr_optimize_not.greptime_timestamp ASC NULLS LAST                                                                                                   |
-|               |   Aggregate: groupBy=[[aggr_optimize_not.a, aggr_optimize_not.b, aggr_optimize_not.c, aggr_optimize_not.greptime_timestamp]], aggr=[[max(prom_max_over_time(greptime_timestamp_range,greptime_value))]]                                                                 |
-|               |     Filter: prom_max_over_time(greptime_timestamp_range,greptime_value) IS NOT NULL                                                                                                                                                                                     |
-|               |       Projection: aggr_optimize_not.greptime_timestamp, prom_max_over_time(greptime_timestamp_range, greptime_value) AS prom_max_over_time(greptime_timestamp_range,greptime_value), aggr_optimize_not.a, aggr_optimize_not.b, aggr_optimize_not.c, aggr_optimize_not.d |
-|               |         PromRangeManipulate: req range=[1752591864000..1752592164000], interval=[30000], eval range=[120000], time index=[greptime_timestamp], values=["greptime_value"]                                                                                                |
-|               |           PromSeriesNormalize: offset=[0], time index=[greptime_timestamp], filter NaN: [true]                                                                                                                                                                          |
-|               |             PromSeriesDivide: tags=["a", "b", "c", "d"]                                                                                                                                                                                                                 |
-|               |               Sort: aggr_optimize_not.a ASC NULLS FIRST, aggr_optimize_not.b ASC NULLS FIRST, aggr_optimize_not.c ASC NULLS FIRST, aggr_optimize_not.d ASC NULLS FIRST, aggr_optimize_not.greptime_timestamp ASC NULLS FIRST                                            |
-|               |                 Filter: aggr_optimize_not.greptime_timestamp >= TimestampMillisecond(1752591744001, None) AND aggr_optimize_not.greptime_timestamp <= TimestampMillisecond(1752592164000, None)                                                                         |
-|               |                   TableScan: aggr_optimize_not, partial_filters=[aggr_optimize_not.greptime_timestamp >= TimestampMillisecond(1752591744001, None), aggr_optimize_not.greptime_timestamp <= TimestampMillisecond(1752592164000, None)]                                  |
-|               | ]]                                                                                                                                                                                                                                                                      |
-| physical_plan | MergeSortExec: [a@0 ASC NULLS LAST, b@1 ASC NULLS LAST, c@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST]                                                                                                                                                        |
++---------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                                                                                                                                             |
++---------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeSort: aggr_optimize_not.a ASC NULLS LAST, aggr_optimize_not.b ASC NULLS LAST, aggr_optimize_not.c ASC NULLS LAST, aggr_optimize_not.greptime_timestamp ASC NULLS LAST                                                                                                       |
+|               |   MergeScan [is_placeholder=false, remote_input=[                                                                                                                                                                                                                                |
+|               | Sort: aggr_optimize_not.a ASC NULLS LAST, aggr_optimize_not.b ASC NULLS LAST, aggr_optimize_not.c ASC NULLS LAST, aggr_optimize_not.greptime_timestamp ASC NULLS LAST                                                                                                            |
+|               |   Aggregate: groupBy=[[aggr_optimize_not.a, aggr_optimize_not.b, aggr_optimize_not.c, aggr_optimize_not.greptime_timestamp]], aggr=[[prom_max(prom_max_over_time(greptime_timestamp_range,greptime_value)) AS max(prom_max_over_time(greptime_timestamp_range,greptime_value))]] |
+|               |     Filter: prom_max_over_time(greptime_timestamp_range,greptime_value) IS NOT NULL                                                                                                                                                                                              |
+|               |       Projection: aggr_optimize_not.greptime_timestamp, prom_max_over_time(greptime_timestamp_range, greptime_value) AS prom_max_over_time(greptime_timestamp_range,greptime_value), aggr_optimize_not.a, aggr_optimize_not.b, aggr_optimize_not.c, aggr_optimize_not.d          |
+|               |         PromRangeManipulate: req range=[1752591864000..1752592164000], interval=[30000], eval range=[120000], time index=[greptime_timestamp], values=["greptime_value"]                                                                                                         |
+|               |           PromSeriesNormalize: offset=[0], time index=[greptime_timestamp], filter NaN: [true]                                                                                                                                                                                   |
+|               |             PromSeriesDivide: tags=["a", "b", "c", "d"]                                                                                                                                                                                                                          |
+|               |               Sort: aggr_optimize_not.a ASC NULLS FIRST, aggr_optimize_not.b ASC NULLS FIRST, aggr_optimize_not.c ASC NULLS FIRST, aggr_optimize_not.d ASC NULLS FIRST, aggr_optimize_not.greptime_timestamp ASC NULLS FIRST                                                     |
+|               |                 Filter: aggr_optimize_not.greptime_timestamp >= TimestampMillisecond(1752591744001, None) AND aggr_optimize_not.greptime_timestamp <= TimestampMillisecond(1752592164000, None)                                                                                  |
+|               |                   TableScan: aggr_optimize_not, partial_filters=[aggr_optimize_not.greptime_timestamp >= TimestampMillisecond(1752591744001, None), aggr_optimize_not.greptime_timestamp <= TimestampMillisecond(1752592164000, None)]                                           |
+|               | ]]                                                                                                                                                                                                                                                                               |
+| physical_plan | MergeSortExec: [a@0 ASC NULLS LAST, b@1 ASC NULLS LAST, c@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST]                                                                                                                                                                 |
 |               |   MergeScanExec: REDACTED
-|               |                                                                                                                                                                                                                                                                         |
-+---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|               |                                                                                                                                                                                                                                                                                  |
++---------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 -- SQLNESS REPLACE (metrics.*) REDACTED
 -- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
@@ -57,11 +57,12 @@ tql analyze (1752591864, 1752592164, '30s') max by (a, b, c) (max_over_time(aggr
 | 0_| 0_|_MergeSortExec: [a@0 ASC NULLS LAST, b@1 ASC NULLS LAST, c@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST] REDACTED
 |_|_|_MergeScanExec: REDACTED
 |_|_|_|
-| 1_| 0_|_SortPreservingMergeExec: [a@0 ASC NULLS LAST, b@1 ASC NULLS LAST, c@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST] REDACTED
+| 1_| 0_|_ProjectionExec: expr=[a@0 as a, b@1 as b, c@2 as c, greptime_timestamp@3 as greptime_timestamp, prom_max(prom_max_over_time(greptime_timestamp_range,greptime_value))@4 as max(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+|_|_|_SortPreservingMergeExec: [a@0 ASC NULLS LAST, b@1 ASC NULLS LAST, c@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST] REDACTED
 |_|_|_SortExec: expr=[a@0 ASC NULLS LAST, b@1 ASC NULLS LAST, c@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST], preserve_partitioning=[true] REDACTED
-|_|_|_AggregateExec: mode=FinalPartitioned, gby=[a@0 as a, b@1 as b, c@2 as c, greptime_timestamp@3 as greptime_timestamp], aggr=[max(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+|_|_|_AggregateExec: mode=FinalPartitioned, gby=[a@0 as a, b@1 as b, c@2 as c, greptime_timestamp@3 as greptime_timestamp], aggr=[prom_max(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
 |_|_|_RepartitionExec: partitioning=REDACTED
-|_|_|_AggregateExec: mode=Partial, gby=[a@2 as a, b@3 as b, c@4 as c, greptime_timestamp@0 as greptime_timestamp], aggr=[max(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+|_|_|_AggregateExec: mode=Partial, gby=[a@2 as a, b@3 as b, c@4 as c, greptime_timestamp@0 as greptime_timestamp], aggr=[prom_max(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
 |_|_|_FilterExec: prom_max_over_time(greptime_timestamp_range,greptime_value)@1 IS NOT NULL REDACTED
 |_|_|_ProjectionExec: expr=[greptime_timestamp@4 as greptime_timestamp, prom_max_over_time(greptime_timestamp_range@6, greptime_value@5) as prom_max_over_time(greptime_timestamp_range,greptime_value), a@0 as a, b@1 as b, c@2 as c] REDACTED
 |_|_|_PromRangeManipulateExec: req range=[1752591864000..1752592164000], interval=[30000], eval range=[120000], time index=[greptime_timestamp] REDACTED
@@ -69,11 +70,12 @@ tql analyze (1752591864, 1752592164, '30s') max by (a, b, c) (max_over_time(aggr
 |_|_|_PromSeriesDivideExec: tags=["a", "b", "c", "d"] REDACTED
 |_|_|_SeriesScan: region=REDACTED, "partition_count":{"count":0, "mem_ranges":0, "files":0, "file_ranges":0}, "distribution":"PerSeries", "mode":"legacy" REDACTED
 |_|_|_|
-| 1_| 1_|_SortPreservingMergeExec: [a@0 ASC NULLS LAST, b@1 ASC NULLS LAST, c@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST] REDACTED
+| 1_| 1_|_ProjectionExec: expr=[a@0 as a, b@1 as b, c@2 as c, greptime_timestamp@3 as greptime_timestamp, prom_max(prom_max_over_time(greptime_timestamp_range,greptime_value))@4 as max(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+|_|_|_SortPreservingMergeExec: [a@0 ASC NULLS LAST, b@1 ASC NULLS LAST, c@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST] REDACTED
 |_|_|_SortExec: expr=[a@0 ASC NULLS LAST, b@1 ASC NULLS LAST, c@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST], preserve_partitioning=[true] REDACTED
-|_|_|_AggregateExec: mode=FinalPartitioned, gby=[a@0 as a, b@1 as b, c@2 as c, greptime_timestamp@3 as greptime_timestamp], aggr=[max(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+|_|_|_AggregateExec: mode=FinalPartitioned, gby=[a@0 as a, b@1 as b, c@2 as c, greptime_timestamp@3 as greptime_timestamp], aggr=[prom_max(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
 |_|_|_RepartitionExec: partitioning=REDACTED
-|_|_|_AggregateExec: mode=Partial, gby=[a@2 as a, b@3 as b, c@4 as c, greptime_timestamp@0 as greptime_timestamp], aggr=[max(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+|_|_|_AggregateExec: mode=Partial, gby=[a@2 as a, b@3 as b, c@4 as c, greptime_timestamp@0 as greptime_timestamp], aggr=[prom_max(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
 |_|_|_FilterExec: prom_max_over_time(greptime_timestamp_range,greptime_value)@1 IS NOT NULL REDACTED
 |_|_|_ProjectionExec: expr=[greptime_timestamp@4 as greptime_timestamp, prom_max_over_time(greptime_timestamp_range@6, greptime_value@5) as prom_max_over_time(greptime_timestamp_range,greptime_value), a@0 as a, b@1 as b, c@2 as c] REDACTED
 |_|_|_PromRangeManipulateExec: req range=[1752591864000..1752592164000], interval=[30000], eval range=[120000], time index=[greptime_timestamp] REDACTED
@@ -305,31 +307,31 @@ tql analyze (1752591864, 1752592164, '30s') count by (a, b, c, d) (max_over_time
 -- SQLNESS REPLACE (Hash.*) REDACTED
 tql explain (1752591864, 1752592164, '30s') min by (b, c, d) (max_over_time(aggr_optimize_not [2m]));
 
-+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| plan_type     | plan                                                                                                                                                                                                                                                                                             |
-+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| logical_plan  | Sort: aggr_optimize_not.b ASC NULLS LAST, aggr_optimize_not.c ASC NULLS LAST, aggr_optimize_not.d ASC NULLS LAST, aggr_optimize_not.greptime_timestamp ASC NULLS LAST                                                                                                                            |
-|               |   Aggregate: groupBy=[[aggr_optimize_not.b, aggr_optimize_not.c, aggr_optimize_not.d, aggr_optimize_not.greptime_timestamp]], aggr=[[__min_merge(__min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))) AS min(prom_max_over_time(greptime_timestamp_range,greptime_value))]] |
-|               |     MergeScan [is_placeholder=false, remote_input=[                                                                                                                                                                                                                                              |
-|               | Aggregate: groupBy=[[aggr_optimize_not.b, aggr_optimize_not.c, aggr_optimize_not.d, aggr_optimize_not.greptime_timestamp]], aggr=[[__min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))]]                                                                                    |
-|               |   Filter: prom_max_over_time(greptime_timestamp_range,greptime_value) IS NOT NULL                                                                                                                                                                                                                |
-|               |     Projection: aggr_optimize_not.greptime_timestamp, prom_max_over_time(greptime_timestamp_range, greptime_value) AS prom_max_over_time(greptime_timestamp_range,greptime_value), aggr_optimize_not.a, aggr_optimize_not.b, aggr_optimize_not.c, aggr_optimize_not.d                            |
-|               |       PromRangeManipulate: req range=[1752591864000..1752592164000], interval=[30000], eval range=[120000], time index=[greptime_timestamp], values=["greptime_value"]                                                                                                                           |
-|               |         PromSeriesNormalize: offset=[0], time index=[greptime_timestamp], filter NaN: [true]                                                                                                                                                                                                     |
-|               |           PromSeriesDivide: tags=["a", "b", "c", "d"]                                                                                                                                                                                                                                            |
-|               |             Sort: aggr_optimize_not.a ASC NULLS FIRST, aggr_optimize_not.b ASC NULLS FIRST, aggr_optimize_not.c ASC NULLS FIRST, aggr_optimize_not.d ASC NULLS FIRST, aggr_optimize_not.greptime_timestamp ASC NULLS FIRST                                                                       |
-|               |               Filter: aggr_optimize_not.greptime_timestamp >= TimestampMillisecond(1752591744001, None) AND aggr_optimize_not.greptime_timestamp <= TimestampMillisecond(1752592164000, None)                                                                                                    |
-|               |                 TableScan: aggr_optimize_not, partial_filters=[aggr_optimize_not.greptime_timestamp >= TimestampMillisecond(1752591744001, None), aggr_optimize_not.greptime_timestamp <= TimestampMillisecond(1752592164000, None)]                                                             |
-|               | ]]                                                                                                                                                                                                                                                                                               |
-| physical_plan | SortPreservingMergeExec: [b@0 ASC NULLS LAST, c@1 ASC NULLS LAST, d@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST]                                                                                                                                                                       |
-|               |   SortExec: expr=[b@0 ASC NULLS LAST, c@1 ASC NULLS LAST, d@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST], preserve_partitioning=[true]                                                                                                                                                 |
-|               |     AggregateExec: mode=FinalPartitioned, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__min_merge(__min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))) as min(prom_max_over_time(greptime_timestamp_range,greptime_value))]       |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                                                                                                                                                                       |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | Sort: aggr_optimize_not.b ASC NULLS LAST, aggr_optimize_not.c ASC NULLS LAST, aggr_optimize_not.d ASC NULLS LAST, aggr_optimize_not.greptime_timestamp ASC NULLS LAST                                                                                                                                      |
+|               |   Aggregate: groupBy=[[aggr_optimize_not.b, aggr_optimize_not.c, aggr_optimize_not.d, aggr_optimize_not.greptime_timestamp]], aggr=[[__prom_min_merge(__prom_min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))) AS min(prom_max_over_time(greptime_timestamp_range,greptime_value))]] |
+|               |     MergeScan [is_placeholder=false, remote_input=[                                                                                                                                                                                                                                                        |
+|               | Aggregate: groupBy=[[aggr_optimize_not.b, aggr_optimize_not.c, aggr_optimize_not.d, aggr_optimize_not.greptime_timestamp]], aggr=[[__prom_min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))]]                                                                                         |
+|               |   Filter: prom_max_over_time(greptime_timestamp_range,greptime_value) IS NOT NULL                                                                                                                                                                                                                          |
+|               |     Projection: aggr_optimize_not.greptime_timestamp, prom_max_over_time(greptime_timestamp_range, greptime_value) AS prom_max_over_time(greptime_timestamp_range,greptime_value), aggr_optimize_not.a, aggr_optimize_not.b, aggr_optimize_not.c, aggr_optimize_not.d                                      |
+|               |       PromRangeManipulate: req range=[1752591864000..1752592164000], interval=[30000], eval range=[120000], time index=[greptime_timestamp], values=["greptime_value"]                                                                                                                                     |
+|               |         PromSeriesNormalize: offset=[0], time index=[greptime_timestamp], filter NaN: [true]                                                                                                                                                                                                               |
+|               |           PromSeriesDivide: tags=["a", "b", "c", "d"]                                                                                                                                                                                                                                                      |
+|               |             Sort: aggr_optimize_not.a ASC NULLS FIRST, aggr_optimize_not.b ASC NULLS FIRST, aggr_optimize_not.c ASC NULLS FIRST, aggr_optimize_not.d ASC NULLS FIRST, aggr_optimize_not.greptime_timestamp ASC NULLS FIRST                                                                                 |
+|               |               Filter: aggr_optimize_not.greptime_timestamp >= TimestampMillisecond(1752591744001, None) AND aggr_optimize_not.greptime_timestamp <= TimestampMillisecond(1752592164000, None)                                                                                                              |
+|               |                 TableScan: aggr_optimize_not, partial_filters=[aggr_optimize_not.greptime_timestamp >= TimestampMillisecond(1752591744001, None), aggr_optimize_not.greptime_timestamp <= TimestampMillisecond(1752592164000, None)]                                                                       |
+|               | ]]                                                                                                                                                                                                                                                                                                         |
+| physical_plan | SortPreservingMergeExec: [b@0 ASC NULLS LAST, c@1 ASC NULLS LAST, d@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST]                                                                                                                                                                                 |
+|               |   SortExec: expr=[b@0 ASC NULLS LAST, c@1 ASC NULLS LAST, d@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST], preserve_partitioning=[true]                                                                                                                                                           |
+|               |     AggregateExec: mode=FinalPartitioned, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__prom_min_merge(__prom_min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))) as min(prom_max_over_time(greptime_timestamp_range,greptime_value))]       |
 |               |       RepartitionExec: partitioning=REDACTED
-|               |         AggregateExec: mode=Partial, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__min_merge(__min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))) as min(prom_max_over_time(greptime_timestamp_range,greptime_value))]            |
+|               |         AggregateExec: mode=Partial, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__prom_min_merge(__prom_min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))) as min(prom_max_over_time(greptime_timestamp_range,greptime_value))]            |
 |               |           RepartitionExec: partitioning=REDACTED
 |               |             MergeScanExec: REDACTED
-|               |                                                                                                                                                                                                                                                                                                  |
-+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|               |                                                                                                                                                                                                                                                                                                            |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 -- SQLNESS REPLACE (metrics.*) REDACTED
 -- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
@@ -345,15 +347,15 @@ tql analyze (1752591864, 1752592164, '30s') min by (b, c, d) (max_over_time(aggr
 +-+-+-+
 | 0_| 0_|_SortPreservingMergeExec: [b@0 ASC NULLS LAST, c@1 ASC NULLS LAST, d@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST] REDACTED
 |_|_|_SortExec: expr=[b@0 ASC NULLS LAST, c@1 ASC NULLS LAST, d@2 ASC NULLS LAST, greptime_timestamp@3 ASC NULLS LAST], preserve_partitioning=[true] REDACTED
-|_|_|_AggregateExec: mode=FinalPartitioned, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__min_merge(__min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))) as min(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+|_|_|_AggregateExec: mode=FinalPartitioned, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__prom_min_merge(__prom_min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))) as min(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
 |_|_|_RepartitionExec: partitioning=REDACTED
-|_|_|_AggregateExec: mode=Partial, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__min_merge(__min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))) as min(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+|_|_|_AggregateExec: mode=Partial, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__prom_min_merge(__prom_min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))) as min(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
 |_|_|_RepartitionExec: partitioning=REDACTED
 |_|_|_MergeScanExec: REDACTED
 |_|_|_|
-| 1_| 0_|_AggregateExec: mode=FinalPartitioned, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+| 1_| 0_|_AggregateExec: mode=FinalPartitioned, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__prom_min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
 |_|_|_RepartitionExec: partitioning=REDACTED
-|_|_|_AggregateExec: mode=Partial, gby=[b@2 as b, c@3 as c, d@4 as d, greptime_timestamp@0 as greptime_timestamp], aggr=[__min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+|_|_|_AggregateExec: mode=Partial, gby=[b@2 as b, c@3 as c, d@4 as d, greptime_timestamp@0 as greptime_timestamp], aggr=[__prom_min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
 |_|_|_FilterExec: prom_max_over_time(greptime_timestamp_range,greptime_value)@1 IS NOT NULL REDACTED
 |_|_|_ProjectionExec: expr=[greptime_timestamp@4 as greptime_timestamp, prom_max_over_time(greptime_timestamp_range@6, greptime_value@5) as prom_max_over_time(greptime_timestamp_range,greptime_value), b@1 as b, c@2 as c, d@3 as d] REDACTED
 |_|_|_PromRangeManipulateExec: req range=[1752591864000..1752592164000], interval=[30000], eval range=[120000], time index=[greptime_timestamp] REDACTED
@@ -361,9 +363,9 @@ tql analyze (1752591864, 1752592164, '30s') min by (b, c, d) (max_over_time(aggr
 |_|_|_PromSeriesDivideExec: tags=["a", "b", "c", "d"] REDACTED
 |_|_|_SeriesScan: region=REDACTED, "partition_count":{"count":0, "mem_ranges":0, "files":0, "file_ranges":0}, "distribution":"PerSeries", "mode":"legacy" REDACTED
 |_|_|_|
-| 1_| 1_|_AggregateExec: mode=FinalPartitioned, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+| 1_| 1_|_AggregateExec: mode=FinalPartitioned, gby=[b@0 as b, c@1 as c, d@2 as d, greptime_timestamp@3 as greptime_timestamp], aggr=[__prom_min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
 |_|_|_RepartitionExec: partitioning=REDACTED
-|_|_|_AggregateExec: mode=Partial, gby=[b@2 as b, c@3 as c, d@4 as d, greptime_timestamp@0 as greptime_timestamp], aggr=[__min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
+|_|_|_AggregateExec: mode=Partial, gby=[b@2 as b, c@3 as c, d@4 as d, greptime_timestamp@0 as greptime_timestamp], aggr=[__prom_min_state(prom_max_over_time(greptime_timestamp_range,greptime_value))] REDACTED
 |_|_|_FilterExec: prom_max_over_time(greptime_timestamp_range,greptime_value)@1 IS NOT NULL REDACTED
 |_|_|_ProjectionExec: expr=[greptime_timestamp@4 as greptime_timestamp, prom_max_over_time(greptime_timestamp_range@6, greptime_value@5) as prom_max_over_time(greptime_timestamp_range,greptime_value), b@1 as b, c@2 as c, d@3 as d] REDACTED
 |_|_|_PromRangeManipulateExec: req range=[1752591864000..1752592164000], interval=[30000], eval range=[120000], time index=[greptime_timestamp] REDACTED
diff --git a/tests/cases/distributed/explain/subqueries.result b/tests/cases/distributed/explain/subqueries.result
index 28fe75df516..3d3f24777db 100644
--- a/tests/cases/distributed/explain/subqueries.result
+++ b/tests/cases/distributed/explain/subqueries.result
@@ -517,9 +517,10 @@ EXPLAIN SELECT a FROM ((SELECT a FROM t1) UNION ALL (SELECT a FROM t2)) u ORDER
 |_|_TableScan: t2_|
 |_| ]]_|
 | physical_plan | SortPreservingMergeExec: [a@0 ASC NULLS LAST]_|
+|_|_UnionExec_|
 |_|_SortExec: expr=[a@0 ASC NULLS LAST], preserve_partitioning=[true]_|
-|_|_InterleaveExec_|
 |_|_MergeScanExec: REDACTED
+|_|_SortExec: expr=[a@0 ASC NULLS LAST], preserve_partitioning=[true]_|
 |_|_MergeScanExec: REDACTED
 |_|_|
 +-+-+
diff --git a/tests/cases/distributed/flow-tql/flow_tql.result b/tests/cases/distributed/flow-tql/flow_tql.result
index 30158a176f8..73321d040e1 100644
--- a/tests/cases/distributed/flow-tql/flow_tql.result
+++ b/tests/cases/distributed/flow-tql/flow_tql.result
@@ -155,7 +155,7 @@ Error: 2000(InvalidSyntax), Invalid TQL syntax: sql parser error: Expected expre
 CREATE FLOW calc_reqs SINK TO cnt_reqs EVAL INTERVAL '1m' AS
 TQL EVAL (now() - now(), now()-(now()+'15s'::interval), '5s') count_values("status_code", http_requests);
 
-Error: 3001(EngineExecuteQuery), Failed to convert float seconds to duration, raw: -15
+Error: 3001(EngineExecuteQuery), The end time must be greater than start time, start: 0, end: -15000
 
 CREATE FLOW calc_reqs SINK TO cnt_reqs EVAL INTERVAL '1m' AS
 TQL EVAL (now() - now(), now()-now()+'15s'::interval, '5s') count_values("status_code", http_requests);
diff --git a/tests/cases/standalone/common/aggregate/append_count_nulls.result b/tests/cases/standalone/common/aggregate/append_count_nulls.result
new file mode 100644
index 00000000000..acb4714224b
--- /dev/null
+++ b/tests/cases/standalone/common/aggregate/append_count_nulls.result
@@ -0,0 +1,165 @@
+-- count(col) and count(DISTINCT col) on append-only tables must not be answered
+-- from row-count statistics, while count(*) still is.
+CREATE TABLE n1 (ts TIMESTAMP TIME INDEX, v BIGINT, s STRING) WITH (append_mode='true');
+
+Affected Rows: 0
+
+INSERT INTO n1 VALUES (1000, 1, 'a'), (2000, NULL, 'a'), (3000, NULL, NULL), (4000, 4, 'b');
+
+Affected Rows: 4
+
+SELECT count(*), count(v), count(s), count(DISTINCT s) FROM n1;
+
++----------+-------------+-------------+----------------------+
+| count(*) | count(n1.v) | count(n1.s) | count(DISTINCT n1.s) |
++----------+-------------+-------------+----------------------+
+| 4        | 2           | 3           | 2                    |
++----------+-------------+-------------+----------------------+
+
+SELECT count(v) FROM n1;
+
++-------------+
+| count(n1.v) |
++-------------+
+| 2           |
++-------------+
+
+-- SQLNESS REPLACE (metrics.*) REDACTED
+-- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE region=\d+\(\d+,\s+\d+\) region=REDACTED
+EXPLAIN ANALYZE SELECT count(*) FROM n1;
+
++-+-+-+
+| stage | node | plan_|
++-+-+-+
+| 0_| 0_|_CooperativeExec REDACTED
+|_|_|_MergeScanExec: REDACTED
+|_|_|_|
+| 1_| 0_|_ProjectionExec: expr=[4 as count(*)] REDACTED
+|_|_|_PlaceholderRowExec REDACTED
+|_|_|_|
+|_|_| Total rows: 1_|
++-+-+-+
+
+ADMIN FLUSH_TABLE('n1');
+
++-------------------------+
+| ADMIN FLUSH_TABLE('n1') |
++-------------------------+
+| 0                       |
++-------------------------+
+
+SELECT count(*), count(v), count(s), count(DISTINCT s) FROM n1;
+
++----------+-------------+-------------+----------------------+
+| count(*) | count(n1.v) | count(n1.s) | count(DISTINCT n1.s) |
++----------+-------------+-------------+----------------------+
+| 4        | 2           | 3           | 2                    |
++----------+-------------+-------------+----------------------+
+
+-- SQLNESS REPLACE (metrics.*) REDACTED
+-- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE region=\d+\(\d+,\s+\d+\) region=REDACTED
+EXPLAIN ANALYZE SELECT count(*) FROM n1;
+
++-+-+-+
+| stage | node | plan_|
++-+-+-+
+| 0_| 0_|_CooperativeExec REDACTED
+|_|_|_MergeScanExec: REDACTED
+|_|_|_|
+| 1_| 0_|_ProjectionExec: expr=[4 as count(*)] REDACTED
+|_|_|_PlaceholderRowExec REDACTED
+|_|_|_|
+|_|_| Total rows: 1_|
++-+-+-+
+
+DROP TABLE n1;
+
+Affected Rows: 0
+
+CREATE TABLE n2 (
+  host STRING,
+  ts TIMESTAMP TIME INDEX,
+  v BIGINT,
+  s STRING,
+  PRIMARY KEY (host)
+)
+PARTITION ON COLUMNS (host) (
+  host < 'm',
+  host >= 'm'
+)
+WITH (append_mode='true');
+
+Affected Rows: 0
+
+INSERT INTO n2 VALUES
+  ('a', 1000, 1, 'a'),
+  ('b', 2000, NULL, 'a'),
+  ('x', 3000, NULL, NULL),
+  ('y', 4000, 4, 'b');
+
+Affected Rows: 4
+
+-- count is pushed down to each region as a state aggregate.
+SELECT count(v), count(s) FROM n2;
+
++-------------+-------------+
+| count(n2.v) | count(n2.s) |
++-------------+-------------+
+| 2           | 3           |
++-------------+-------------+
+
+ADMIN FLUSH_TABLE('n2');
+
++-------------------------+
+| ADMIN FLUSH_TABLE('n2') |
++-------------------------+
+| 0                       |
++-------------------------+
+
+SELECT count(v), count(s) FROM n2;
+
++-------------+-------------+
+| count(n2.v) | count(n2.s) |
++-------------+-------------+
+| 2           | 3           |
++-------------+-------------+
+
+-- SQLNESS REPLACE (metrics.*) REDACTED
+-- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE region=\d+\(\d+,\s+\d+\) region=REDACTED
+EXPLAIN ANALYZE SELECT count(*) FROM n2;
+
++-+-+-+
+| stage | node | plan_|
++-+-+-+
+| 0_| 0_|_ProjectionExec: expr=[count(Int64(1))@0 as count(*)] REDACTED
+|_|_|_AggregateExec: mode=Final, gby=[], aggr=[__count_merge(__count_state(n2.ts)) as count(Int64(1))] REDACTED
+|_|_|_CoalescePartitionsExec REDACTED
+|_|_|_AggregateExec: mode=Partial, gby=[], aggr=[__count_merge(__count_state(n2.ts)) as count(Int64(1))] REDACTED
+|_|_|_RepartitionExec: partitioning=REDACTED
+|_|_|_MergeScanExec: REDACTED
+|_|_|_|
+| 1_| 0_|_ProjectionExec: expr=[{count[count]:2} as __count_state(n2.ts)] REDACTED
+|_|_|_PlaceholderRowExec REDACTED
+|_|_|_|
+| 1_| 1_|_ProjectionExec: expr=[{count[count]:2} as __count_state(n2.ts)] REDACTED
+|_|_|_PlaceholderRowExec REDACTED
+|_|_|_|
+|_|_| Total rows: 1_|
++-+-+-+
+
+DROP TABLE n2;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/aggregate/append_count_nulls.sql b/tests/cases/standalone/common/aggregate/append_count_nulls.sql
new file mode 100644
index 00000000000..8f2e1f5c2f7
--- /dev/null
+++ b/tests/cases/standalone/common/aggregate/append_count_nulls.sql
@@ -0,0 +1,67 @@
+-- count(col) and count(DISTINCT col) on append-only tables must not be answered
+-- from row-count statistics, while count(*) still is.
+CREATE TABLE n1 (ts TIMESTAMP TIME INDEX, v BIGINT, s STRING) WITH (append_mode='true');
+
+INSERT INTO n1 VALUES (1000, 1, 'a'), (2000, NULL, 'a'), (3000, NULL, NULL), (4000, 4, 'b');
+
+SELECT count(*), count(v), count(s), count(DISTINCT s) FROM n1;
+
+SELECT count(v) FROM n1;
+
+-- SQLNESS REPLACE (metrics.*) REDACTED
+-- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE region=\d+\(\d+,\s+\d+\) region=REDACTED
+EXPLAIN ANALYZE SELECT count(*) FROM n1;
+
+ADMIN FLUSH_TABLE('n1');
+
+SELECT count(*), count(v), count(s), count(DISTINCT s) FROM n1;
+
+-- SQLNESS REPLACE (metrics.*) REDACTED
+-- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE region=\d+\(\d+,\s+\d+\) region=REDACTED
+EXPLAIN ANALYZE SELECT count(*) FROM n1;
+
+DROP TABLE n1;
+
+CREATE TABLE n2 (
+  host STRING,
+  ts TIMESTAMP TIME INDEX,
+  v BIGINT,
+  s STRING,
+  PRIMARY KEY (host)
+)
+PARTITION ON COLUMNS (host) (
+  host < 'm',
+  host >= 'm'
+)
+WITH (append_mode='true');
+
+INSERT INTO n2 VALUES
+  ('a', 1000, 1, 'a'),
+  ('b', 2000, NULL, 'a'),
+  ('x', 3000, NULL, NULL),
+  ('y', 4000, 4, 'b');
+
+-- count is pushed down to each region as a state aggregate.
+SELECT count(v), count(s) FROM n2;
+
+ADMIN FLUSH_TABLE('n2');
+
+SELECT count(v), count(s) FROM n2;
+
+-- SQLNESS REPLACE (metrics.*) REDACTED
+-- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE region=\d+\(\d+,\s+\d+\) region=REDACTED
+EXPLAIN ANALYZE SELECT count(*) FROM n2;
+
+DROP TABLE n2;
diff --git a/tests/cases/standalone/common/aggregate/empty_region_stats.result b/tests/cases/standalone/common/aggregate/empty_region_stats.result
new file mode 100644
index 00000000000..5f4a1bc59b0
--- /dev/null
+++ b/tests/cases/standalone/common/aggregate/empty_region_stats.result
@@ -0,0 +1,126 @@
+-- Append-mode regions report exact row counts, so the datanode can answer
+-- count/min/max over a region from statistics. This only happens when every
+-- aggregate in the query can be answered that way.
+CREATE TABLE a1 (ts TIMESTAMP(9) TIME INDEX, k STRING, v BIGINT)
+PARTITION ON COLUMNS (k) (k < 'b', k >= 'b' AND k < 'c', k >= 'c')
+WITH (append_mode = 'true');
+
+Affected Rows: 0
+
+-- All regions are empty.
+SELECT min(v), max(v) FROM a1;
+
++-----------+-----------+
+| min(a1.v) | max(a1.v) |
++-----------+-----------+
+|           |           |
++-----------+-----------+
+
+SELECT count(*), count(v) FROM a1;
+
++----------+-------------+
+| count(*) | count(a1.v) |
++----------+-------------+
+| 0        | 0           |
++----------+-------------+
+
+INSERT INTO a1 VALUES (1000, 'a', 1), (2000, 'a', 2);
+
+Affected Rows: 2
+
+-- Two of three regions are empty.
+SELECT min(v) FROM a1;
+
++-----------+
+| min(a1.v) |
++-----------+
+| 1         |
++-----------+
+
+SELECT max(v) FROM a1;
+
++-----------+
+| max(a1.v) |
++-----------+
+| 2         |
++-----------+
+
+SELECT min(ts), max(k) FROM a1;
+
++----------------------------+-----------+
+| min(a1.ts)                 | max(a1.k) |
++----------------------------+-----------+
+| 1970-01-01T00:00:00.000001 | a         |
++----------------------------+-----------+
+
+SELECT count(*), count(v) FROM a1;
+
++----------+-------------+
+| count(*) | count(a1.v) |
++----------+-------------+
+| 2        | 2           |
++----------+-------------+
+
+SELECT min(v), count(*) FROM a1;
+
++-----------+----------+
+| min(a1.v) | count(*) |
++-----------+----------+
+| 1         | 2        |
++-----------+----------+
+
+SELECT sum(v), avg(v) FROM a1;
+
++-----------+-----------+
+| sum(a1.v) | avg(a1.v) |
++-----------+-----------+
+| 3         | 1.5       |
++-----------+-----------+
+
+SELECT k, min(v), max(v), count(*) FROM a1 GROUP BY k ORDER BY k;
+
++---+-----------+-----------+----------+
+| k | min(a1.v) | max(a1.v) | count(*) |
++---+-----------+-----------+----------+
+| a | 1         | 2         | 2        |
++---+-----------+-----------+----------+
+
+INSERT INTO a1 VALUES (3000, 'b', 3);
+
+Affected Rows: 1
+
+-- One of three regions is empty.
+SELECT min(v), max(v) FROM a1;
+
++-----------+-----------+
+| min(a1.v) | max(a1.v) |
++-----------+-----------+
+| 1         | 3         |
++-----------+-----------+
+
+SELECT k, min(v), max(v), count(*) FROM a1 GROUP BY k ORDER BY k;
+
++---+-----------+-----------+----------+
+| k | min(a1.v) | max(a1.v) | count(*) |
++---+-----------+-----------+----------+
+| a | 1         | 2         | 2        |
+| b | 3         | 3         | 1        |
++---+-----------+-----------+----------+
+
+INSERT INTO a1 VALUES (4000, 'c', 4);
+
+Affected Rows: 1
+
+-- No region is empty.
+SELECT min(v), max(v), count(*) FROM a1;
+
++-----------+-----------+----------+
+| min(a1.v) | max(a1.v) | count(*) |
++-----------+-----------+----------+
+| 1         | 4         | 4        |
++-----------+-----------+----------+
+
+DROP TABLE a1;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/aggregate/empty_region_stats.sql b/tests/cases/standalone/common/aggregate/empty_region_stats.sql
new file mode 100644
index 00000000000..a2d03e6b0e0
--- /dev/null
+++ b/tests/cases/standalone/common/aggregate/empty_region_stats.sql
@@ -0,0 +1,42 @@
+-- Append-mode regions report exact row counts, so the datanode can answer
+-- count/min/max over a region from statistics. This only happens when every
+-- aggregate in the query can be answered that way.
+CREATE TABLE a1 (ts TIMESTAMP(9) TIME INDEX, k STRING, v BIGINT)
+PARTITION ON COLUMNS (k) (k < 'b', k >= 'b' AND k < 'c', k >= 'c')
+WITH (append_mode = 'true');
+
+-- All regions are empty.
+SELECT min(v), max(v) FROM a1;
+
+SELECT count(*), count(v) FROM a1;
+
+INSERT INTO a1 VALUES (1000, 'a', 1), (2000, 'a', 2);
+
+-- Two of three regions are empty.
+SELECT min(v) FROM a1;
+
+SELECT max(v) FROM a1;
+
+SELECT min(ts), max(k) FROM a1;
+
+SELECT count(*), count(v) FROM a1;
+
+SELECT min(v), count(*) FROM a1;
+
+SELECT sum(v), avg(v) FROM a1;
+
+SELECT k, min(v), max(v), count(*) FROM a1 GROUP BY k ORDER BY k;
+
+INSERT INTO a1 VALUES (3000, 'b', 3);
+
+-- One of three regions is empty.
+SELECT min(v), max(v) FROM a1;
+
+SELECT k, min(v), max(v), count(*) FROM a1 GROUP BY k ORDER BY k;
+
+INSERT INTO a1 VALUES (4000, 'c', 4);
+
+-- No region is empty.
+SELECT min(v), max(v), count(*) FROM a1;
+
+DROP TABLE a1;
diff --git a/tests/cases/standalone/common/aggregate/having_input_bounds.result b/tests/cases/standalone/common/aggregate/having_input_bounds.result
new file mode 100644
index 00000000000..0f24ab70b8f
--- /dev/null
+++ b/tests/cases/standalone/common/aggregate/having_input_bounds.result
@@ -0,0 +1,229 @@
+-- Matching spans and the earliest/latest spans deliberately live in different regions.
+CREATE TABLE having_input_bounds (
+    trace_id STRING,
+    service_name STRING,
+    span_name STRING,
+    product STRING,
+    duration BIGINT,
+    ts TIMESTAMP(9) TIME INDEX,
+    PRIMARY KEY (service_name)
+)
+PARTITION ON COLUMNS (service_name) (
+    service_name < 'm',
+    service_name >= 'm'
+)
+WITH ('append_mode' = 'true');
+
+Affected Rows: 0
+
+INSERT INTO having_input_bounds VALUES
+    ('a', 'other', 'parent', NULL, 30, 5),
+    ('a', 'cart', 'GetCart', NULL, 6, 10),
+    ('a', 'frontend', 'GetProduct', 'product-7', 8, 15),
+    ('a', 'cart', 'GetCart', NULL, 6, 20),
+    ('a', 'other', 'parent', NULL, 30, 25),
+    ('b', 'other', 'parent', NULL, 1, 2),
+    ('b', 'frontend', 'GetProduct', 'product-x', 18, 12),
+    ('b', 'other', 'parent', NULL, 30, 22),
+    ('c', 'cart', 'GetCart', NULL, 5, 30),
+    ('d', 'frontend', NULL, 'product-7', 8, 15),
+    (NULL, 'other', 'parent', NULL, 2, 3),
+    (NULL, 'cart', 'GetCart', NULL, 6, 11),
+    (NULL, 'other', 'parent', NULL, 30, 25);
+
+Affected Rows: 13
+
+-- T02 shape: only the upper bound may be inferred; preserve earlier spans and NULL keys.
+SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'cart' AND span_name = 'GetCart'
+    AND CAST(ts AS BIGINT) >= 10 AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY trace_start, trace_id
+LIMIT 20;
+
++----------+-------------+
+| trace_id | trace_start |
++----------+-------------+
+|          | 3           |
+| a        | 5           |
++----------+-------------+
+
+-- Pin the optimization itself: the remote scan has only the inferred time upper
+-- bound, while HAVING stays above aggregation. Result equality alone cannot prove this.
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+-- SQLNESS REPLACE (RepartitionExec:.*) RepartitionExec: REDACTED
+-- SQLNESS REPLACE (MergeScanExec:.*) MergeScanExec: REDACTED
+EXPLAIN SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'cart' AND span_name = 'GetCart'
+    AND CAST(ts AS BIGINT) >= 10 AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY trace_start, trace_id
+LIMIT 20;
+
++-+-+
+| plan_type_| plan_|
++-+-+
+| logical_plan_| Sort: trace_start ASC NULLS LAST, having_input_bounds.trace_id ASC NULLS LAST, fetch=20_|
+|_|_Projection: having_input_bounds.trace_id, min(having_input_bounds.ts) AS trace_start_|
+|_|_Filter: sum(CASE WHEN having_input_bounds.service_name = Utf8("cart") AND having_input_bounds.span_name = Utf8("GetCart") AND having_input_bounds.ts >= Int64(10) AND having_input_bounds.ts < Int64(20) THEN Int64(1) ELSE Int64(0) END) > Int64(0)_|
+|_|_Aggregate: groupBy=[[having_input_bounds.trace_id]], aggr=[[__min_merge(__min_state(having_input_bounds.ts)) AS min(having_input_bounds.ts), __sum_merge(__sum_state(CASE WHEN having_input_bounds.service_name = Utf8("cart") AND having_input_bounds.span_name = Utf8("GetCart") AND having_input_bounds.ts >= Int64(10) AND having_input_bounds.ts < Int64(20) THEN Int64(1) ELSE Int64(0) END)) AS sum(CASE WHEN having_input_bounds.service_name = Utf8("cart") AND having_input_bounds.span_name = Utf8("GetCart") AND having_input_bounds.ts >= Int64(10) AND having_input_bounds.ts < Int64(20) THEN Int64(1) ELSE Int64(0) END)]]_|
+|_|_MergeScan [is_placeholder=false, remote_input=[_|
+|_| Aggregate: groupBy=[[having_input_bounds.trace_id]], aggr=[[__min_state(CAST(having_input_bounds.ts AS Int64)), __sum_state(CASE WHEN having_input_bounds.service_name = CAST(Utf8("cart") AS Dictionary(UInt32, Utf8)) AND having_input_bounds.span_name = Utf8("GetCart") AND CAST(having_input_bounds.ts AS Int64) >= Int64(10) AND CAST(having_input_bounds.ts AS Int64) < Int64(20) THEN Int64(1) ELSE Int64(0) END)]]_|
+|_|_Filter: CAST(having_input_bounds.ts AS Int64) < Int64(20)_|
+|_|_TableScan: having_input_bounds, partial_filters=[CAST(having_input_bounds.ts AS Int64) < Int64(20)]_|
+|_| ]]_|
+| physical_plan | SortPreservingMergeExec: [trace_start@1 ASC NULLS LAST, trace_id@0 ASC NULLS LAST], fetch=20_|
+|_|_SortExec: TopK(fetch=20), expr=[trace_start@1 ASC NULLS LAST, trace_id@0 ASC NULLS LAST], preserve_partitioning=[true]_|
+|_|_ProjectionExec: expr=[trace_id@0 as trace_id, min(having_input_bounds.ts)@1 as trace_start]_|
+|_|_FilterExec: sum(CASE WHEN having_input_bounds.service_name = Utf8("cart") AND having_input_bounds.span_name = Utf8("GetCart") AND having_input_bounds.ts >= Int64(10) AND having_input_bounds.ts < Int64(20) THEN Int64(1) ELSE Int64(0) END)@2 > 0, projection=[trace_id@0, min(having_input_bounds.ts)@1]_|
+|_|_AggregateExec: mode=FinalPartitioned, gby=[trace_id@0 as trace_id], aggr=[__min_merge(__min_state(having_input_bounds.ts)) as min(having_input_bounds.ts), __sum_merge(__sum_state(CASE WHEN having_input_bounds.service_name = Utf8("cart") AND having_input_bounds.span_name = Utf8("GetCart") AND having_input_bounds.ts >= Int64(10) AND having_input_bounds.ts < Int64(20) THEN Int64(1) ELSE Int64(0) END)) as sum(CASE WHEN having_input_bounds.service_name = Utf8("cart") AND having_input_bounds.span_name = Utf8("GetCart") AND having_input_bounds.ts >= Int64(10) AND having_input_bounds.ts < Int64(20) THEN Int64(1) ELSE Int64(0) END)] |
+|_|_RepartitionExec: REDACTED
+|_|_AggregateExec: mode=Partial, gby=[trace_id@0 as trace_id], aggr=[__min_merge(__min_state(having_input_bounds.ts)) as min(having_input_bounds.ts), __sum_merge(__sum_state(CASE WHEN having_input_bounds.service_name = Utf8("cart") AND having_input_bounds.span_name = Utf8("GetCart") AND having_input_bounds.ts >= Int64(10) AND having_input_bounds.ts < Int64(20) THEN Int64(1) ELSE Int64(0) END)) as sum(CASE WHEN having_input_bounds.service_name = Utf8("cart") AND having_input_bounds.span_name = Utf8("GetCart") AND having_input_bounds.ts >= Int64(10) AND having_input_bounds.ts < Int64(20) THEN Int64(1) ELSE Int64(0) END)]_|
+|_|_RepartitionExec: REDACTED
+|_|_MergeScanExec: REDACTED
+|_|_|
++-+-+
+
+-- T03 shape: a span attribute is part of the existence condition, not an input filter.
+SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'frontend' AND span_name = 'GetProduct'
+    AND product = 'product-7' AND CAST(ts AS BIGINT) >= 10
+    AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY trace_start, trace_id;
+
++----------+-------------+
+| trace_id | trace_start |
++----------+-------------+
+| a        | 5           |
++----------+-------------+
+
+-- T04 shape: bounds on a different expression must not become aggregate input bounds.
+SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'frontend' AND span_name = 'GetProduct'
+    AND duration >= 5 AND duration < 20 AND CAST(ts AS BIGINT) >= 10
+    AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY trace_start, trace_id;
+
++----------+-------------+
+| trace_id | trace_start |
++----------+-------------+
+| b        | 2           |
+| a        | 5           |
++----------+-------------+
+
+-- MAX is symmetric: preserve later spans by inferring only the lower bound.
+-- Also check that the conditional SUM itself remains unchanged.
+SELECT trace_id, MAX(CAST(ts AS BIGINT)) AS trace_end,
+    SUM(CASE WHEN service_name = 'cart' AND CAST(ts AS BIGINT) >= 10
+        AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) AS matches
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING matches >= 1
+ORDER BY trace_end, trace_id;
+
++----------+-----------+---------+
+| trace_id | trace_end | matches |
++----------+-----------+---------+
+| a        | 25        | 1       |
+|          | 25        | 1       |
++----------+-----------+---------+
+
+-- Full-group aggregates forbid pruning, even when the MIN would be preserved.
+SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start,
+    MAX(CAST(ts AS BIGINT)) AS trace_end, COUNT(*) AS spans
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'cart' AND CAST(ts AS BIGINT) >= 10
+    AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY trace_start, trace_id;
+
++----------+-------------+-----------+-------+
+| trace_id | trace_start | trace_end | spans |
++----------+-------------+-----------+-------+
+|          | 3           | 25        | 3     |
+| a        | 5           | 25        | 5     |
++----------+-------------+-----------+-------+
+
+-- OR does not guarantee a matching span in every surviving group.
+SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'cart' AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+    OR MIN(CAST(ts AS BIGINT)) > 20
+ORDER BY trace_start, trace_id;
+
++----------+-------------+
+| trace_id | trace_start |
++----------+-------------+
+|          | 3           |
+| a        | 5           |
+| c        | 30          |
++----------+-------------+
+
+DROP TABLE having_input_bounds;
+
+Affected Rows: 0
+
+-- A derived column must not move fallible arithmetic/casts ahead of its WHERE guard.
+CREATE TABLE having_guarded(k STRING, v BIGINT, d BIGINT, text_value STRING, ts TIMESTAMP TIME INDEX);
+
+Affected Rows: 0
+
+INSERT INTO having_guarded VALUES ('a', 12, 0, 'bad', 1), ('a', 5, 1, '5', 2), ('b', 25, 1, '25', 3);
+
+Affected Rows: 3
+
+SELECT k, MIN(r) FROM (
+    SELECT k, v / d AS r FROM having_guarded WHERE abs(d) > 0
+) s GROUP BY k
+HAVING SUM(CASE WHEN r < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY k;
+
++---+----------+
+| k | min(s.r) |
++---+----------+
+| a | 5        |
++---+----------+
+
+SELECT k, MIN(r) FROM (
+    SELECT k, CAST(text_value AS BIGINT) AS r FROM having_guarded WHERE abs(d) > 0
+) s GROUP BY k
+HAVING SUM(CASE WHEN r < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY k;
+
++---+----------+
+| k | min(s.r) |
++---+----------+
+| a | 5        |
++---+----------+
+
+CREATE VIEW having_guarded_view AS
+SELECT k, v / d AS r FROM having_guarded WHERE abs(d) > 0;
+
+Affected Rows: 0
+
+SELECT k, MIN(r) FROM having_guarded_view GROUP BY k
+HAVING SUM(CASE WHEN r < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY k;
+
++---+----------------------------+
+| k | min(having_guarded_view.r) |
++---+----------------------------+
+| a | 5                          |
++---+----------------------------+
+
+DROP VIEW having_guarded_view;
+
+Affected Rows: 0
+
+DROP TABLE having_guarded;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/aggregate/having_input_bounds.sql b/tests/cases/standalone/common/aggregate/having_input_bounds.sql
new file mode 100644
index 00000000000..b18b1e2a1e8
--- /dev/null
+++ b/tests/cases/standalone/common/aggregate/having_input_bounds.sql
@@ -0,0 +1,126 @@
+-- Matching spans and the earliest/latest spans deliberately live in different regions.
+CREATE TABLE having_input_bounds (
+    trace_id STRING,
+    service_name STRING,
+    span_name STRING,
+    product STRING,
+    duration BIGINT,
+    ts TIMESTAMP(9) TIME INDEX,
+    PRIMARY KEY (service_name)
+)
+PARTITION ON COLUMNS (service_name) (
+    service_name < 'm',
+    service_name >= 'm'
+)
+WITH ('append_mode' = 'true');
+
+INSERT INTO having_input_bounds VALUES
+    ('a', 'other', 'parent', NULL, 30, 5),
+    ('a', 'cart', 'GetCart', NULL, 6, 10),
+    ('a', 'frontend', 'GetProduct', 'product-7', 8, 15),
+    ('a', 'cart', 'GetCart', NULL, 6, 20),
+    ('a', 'other', 'parent', NULL, 30, 25),
+    ('b', 'other', 'parent', NULL, 1, 2),
+    ('b', 'frontend', 'GetProduct', 'product-x', 18, 12),
+    ('b', 'other', 'parent', NULL, 30, 22),
+    ('c', 'cart', 'GetCart', NULL, 5, 30),
+    ('d', 'frontend', NULL, 'product-7', 8, 15),
+    (NULL, 'other', 'parent', NULL, 2, 3),
+    (NULL, 'cart', 'GetCart', NULL, 6, 11),
+    (NULL, 'other', 'parent', NULL, 30, 25);
+
+-- T02 shape: only the upper bound may be inferred; preserve earlier spans and NULL keys.
+SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'cart' AND span_name = 'GetCart'
+    AND CAST(ts AS BIGINT) >= 10 AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY trace_start, trace_id
+LIMIT 20;
+
+-- Pin the optimization itself: the remote scan has only the inferred time upper
+-- bound, while HAVING stays above aggregation. Result equality alone cannot prove this.
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+-- SQLNESS REPLACE (RepartitionExec:.*) RepartitionExec: REDACTED
+-- SQLNESS REPLACE (MergeScanExec:.*) MergeScanExec: REDACTED
+EXPLAIN SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'cart' AND span_name = 'GetCart'
+    AND CAST(ts AS BIGINT) >= 10 AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY trace_start, trace_id
+LIMIT 20;
+
+-- T03 shape: a span attribute is part of the existence condition, not an input filter.
+SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'frontend' AND span_name = 'GetProduct'
+    AND product = 'product-7' AND CAST(ts AS BIGINT) >= 10
+    AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY trace_start, trace_id;
+
+-- T04 shape: bounds on a different expression must not become aggregate input bounds.
+SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'frontend' AND span_name = 'GetProduct'
+    AND duration >= 5 AND duration < 20 AND CAST(ts AS BIGINT) >= 10
+    AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY trace_start, trace_id;
+
+-- MAX is symmetric: preserve later spans by inferring only the lower bound.
+-- Also check that the conditional SUM itself remains unchanged.
+SELECT trace_id, MAX(CAST(ts AS BIGINT)) AS trace_end,
+    SUM(CASE WHEN service_name = 'cart' AND CAST(ts AS BIGINT) >= 10
+        AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) AS matches
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING matches >= 1
+ORDER BY trace_end, trace_id;
+
+-- Full-group aggregates forbid pruning, even when the MIN would be preserved.
+SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start,
+    MAX(CAST(ts AS BIGINT)) AS trace_end, COUNT(*) AS spans
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'cart' AND CAST(ts AS BIGINT) >= 10
+    AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY trace_start, trace_id;
+
+-- OR does not guarantee a matching span in every surviving group.
+SELECT trace_id, MIN(CAST(ts AS BIGINT)) AS trace_start
+FROM having_input_bounds
+GROUP BY trace_id
+HAVING SUM(CASE WHEN service_name = 'cart' AND CAST(ts AS BIGINT) < 20 THEN 1 ELSE 0 END) > 0
+    OR MIN(CAST(ts AS BIGINT)) > 20
+ORDER BY trace_start, trace_id;
+
+DROP TABLE having_input_bounds;
+
+-- A derived column must not move fallible arithmetic/casts ahead of its WHERE guard.
+CREATE TABLE having_guarded(k STRING, v BIGINT, d BIGINT, text_value STRING, ts TIMESTAMP TIME INDEX);
+INSERT INTO having_guarded VALUES ('a', 12, 0, 'bad', 1), ('a', 5, 1, '5', 2), ('b', 25, 1, '25', 3);
+
+SELECT k, MIN(r) FROM (
+    SELECT k, v / d AS r FROM having_guarded WHERE abs(d) > 0
+) s GROUP BY k
+HAVING SUM(CASE WHEN r < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY k;
+
+SELECT k, MIN(r) FROM (
+    SELECT k, CAST(text_value AS BIGINT) AS r FROM having_guarded WHERE abs(d) > 0
+) s GROUP BY k
+HAVING SUM(CASE WHEN r < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY k;
+
+CREATE VIEW having_guarded_view AS
+SELECT k, v / d AS r FROM having_guarded WHERE abs(d) > 0;
+
+SELECT k, MIN(r) FROM having_guarded_view GROUP BY k
+HAVING SUM(CASE WHEN r < 20 THEN 1 ELSE 0 END) > 0
+ORDER BY k;
+
+DROP VIEW having_guarded_view;
+DROP TABLE having_guarded;
diff --git a/tests/cases/standalone/common/aggregate/multi_regions.result b/tests/cases/standalone/common/aggregate/multi_regions.result
index 79ae85fbc04..bdfc5ed2dd1 100644
--- a/tests/cases/standalone/common/aggregate/multi_regions.result
+++ b/tests/cases/standalone/common/aggregate/multi_regions.result
@@ -131,6 +131,32 @@ select substr(host, 6, 1) as g, count(*), sum(val) from t group by g order by g;
 | y | 2        | 6.0        |
 +---+----------+------------+
 
+-- count(*) and count(1) are rewritten to count(ts), sharing the same state column
+select count(*), count(1), count(ts) from t;
+
++----------+-----------------+-------------+
+| count(*) | count(Int64(1)) | count(t.ts) |
++----------+-----------------+-------------+
+| 4        | 4               | 4           |
++----------+-----------------+-------------+
+
+select count(*) as a, count(ts) as b from t;
+
++---+---+
+| a | b |
++---+---+
+| 4 | 4 |
++---+---+
+
+-- the cast is hidden from the state column name
+select count(*), count(ts::bigint) from t;
+
++----------+-------------+
+| count(*) | count(t.ts) |
++----------+-------------+
+| 4        | 4           |
++----------+-------------+
+
 -- grouping sets are computed on the frontend, only the PostgreSQL dialect parses them
 -- SQLNESS PROTOCOL POSTGRES
 select host, idc, sum(val) from t group by grouping sets ((host, idc), (host)) order by host, idc;
diff --git a/tests/cases/standalone/common/aggregate/multi_regions.sql b/tests/cases/standalone/common/aggregate/multi_regions.sql
index 4f99e1ed465..9c8d8af4490 100644
--- a/tests/cases/standalone/common/aggregate/multi_regions.sql
+++ b/tests/cases/standalone/common/aggregate/multi_regions.sql
@@ -54,6 +54,14 @@ insert into t values
 -- group keys derived from the partition column span regions
 select substr(host, 6, 1) as g, count(*), sum(val) from t group by g order by g;
 
+-- count(*) and count(1) are rewritten to count(ts), sharing the same state column
+select count(*), count(1), count(ts) from t;
+
+select count(*) as a, count(ts) as b from t;
+
+-- the cast is hidden from the state column name
+select count(*), count(ts::bigint) from t;
+
 -- grouping sets are computed on the frontend, only the PostgreSQL dialect parses them
 -- SQLNESS PROTOCOL POSTGRES
 select host, idc, sum(val) from t group by grouping sets ((host, idc), (host)) order by host, idc;
diff --git a/tests/cases/standalone/common/aggregate/projected_pk_group_by.result b/tests/cases/standalone/common/aggregate/projected_pk_group_by.result
new file mode 100644
index 00000000000..7ca3f1e5826
--- /dev/null
+++ b/tests/cases/standalone/common/aggregate/projected_pk_group_by.result
@@ -0,0 +1,69 @@
+CREATE TABLE projected_pk_group_by (
+  marker TINYINT UNSIGNED,
+  host STRING,
+  ts TIMESTAMP TIME INDEX,
+  PRIMARY KEY (marker, host)
+);
+
+Affected Rows: 0
+
+INSERT INTO projected_pk_group_by VALUES
+  (0, 'a', 1000),
+  (0, 'a', 2000),
+  (0, 'b', 1000),
+  (0, 'b', 2000),
+  (0, 'c', 1000),
+  (1, NULL, 1000);
+
+Affected Rows: 6
+
+SELECT marker, count(*) AS row_count
+FROM projected_pk_group_by
+GROUP BY marker
+ORDER BY marker;
+
++--------+-----------+
+| marker | row_count |
++--------+-----------+
+| 0      | 5         |
+| 1      | 1         |
++--------+-----------+
+
+SELECT marker, host, count(*) AS row_count
+FROM projected_pk_group_by
+GROUP BY marker, host
+ORDER BY marker, host;
+
++--------+------+-----------+
+| marker | host | row_count |
++--------+------+-----------+
+| 0      | a    | 2         |
+| 0      | b    | 2         |
+| 0      | c    | 1         |
+| 1      |      | 1         |
++--------+------+-----------+
+
+ADMIN FLUSH_TABLE('projected_pk_group_by');
+
++--------------------------------------------+
+| ADMIN FLUSH_TABLE('projected_pk_group_by') |
++--------------------------------------------+
+| 0                                          |
++--------------------------------------------+
+
+SELECT marker, count(*) AS row_count
+FROM projected_pk_group_by
+GROUP BY marker
+ORDER BY marker;
+
++--------+-----------+
+| marker | row_count |
++--------+-----------+
+| 0      | 5         |
+| 1      | 1         |
++--------+-----------+
+
+DROP TABLE projected_pk_group_by;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/aggregate/projected_pk_group_by.sql b/tests/cases/standalone/common/aggregate/projected_pk_group_by.sql
new file mode 100644
index 00000000000..d525e16bc55
--- /dev/null
+++ b/tests/cases/standalone/common/aggregate/projected_pk_group_by.sql
@@ -0,0 +1,33 @@
+CREATE TABLE projected_pk_group_by (
+  marker TINYINT UNSIGNED,
+  host STRING,
+  ts TIMESTAMP TIME INDEX,
+  PRIMARY KEY (marker, host)
+);
+
+INSERT INTO projected_pk_group_by VALUES
+  (0, 'a', 1000),
+  (0, 'a', 2000),
+  (0, 'b', 1000),
+  (0, 'b', 2000),
+  (0, 'c', 1000),
+  (1, NULL, 1000);
+
+SELECT marker, count(*) AS row_count
+FROM projected_pk_group_by
+GROUP BY marker
+ORDER BY marker;
+
+SELECT marker, host, count(*) AS row_count
+FROM projected_pk_group_by
+GROUP BY marker, host
+ORDER BY marker, host;
+
+ADMIN FLUSH_TABLE('projected_pk_group_by');
+
+SELECT marker, count(*) AS row_count
+FROM projected_pk_group_by
+GROUP BY marker
+ORDER BY marker;
+
+DROP TABLE projected_pk_group_by;
diff --git a/tests/cases/standalone/common/alter/change_col_inverted_index.result b/tests/cases/standalone/common/alter/change_col_inverted_index.result
index df684fec436..c1265f2958e 100644
--- a/tests/cases/standalone/common/alter/change_col_inverted_index.result
+++ b/tests/cases/standalone/common/alter/change_col_inverted_index.result
@@ -180,3 +180,151 @@ DROP TABLE test_pk;
 
 Affected Rows: 0
 
+-- The old SST has an inverted index, but not on host.
+CREATE TABLE missing_inverted_index (
+    ts TIMESTAMP TIME INDEX,
+    indexed_col STRING INVERTED INDEX,
+    host STRING
+) WITH ('append_mode' = 'true');
+
+Affected Rows: 0
+
+INSERT INTO missing_inverted_index VALUES
+    (1, 'a', 'server1'),
+    (2, 'b', 'server2');
+
+Affected Rows: 2
+
+ADMIN FLUSH_TABLE('missing_inverted_index');
+
++---------------------------------------------+
+| ADMIN FLUSH_TABLE('missing_inverted_index') |
++---------------------------------------------+
+| 0                                           |
++---------------------------------------------+
+
+SELECT * FROM missing_inverted_index WHERE host = 'server1' ORDER BY ts;
+
++-------------------------+-------------+---------+
+| ts                      | indexed_col | host    |
++-------------------------+-------------+---------+
+| 1970-01-01T00:00:00.001 | a           | server1 |
++-------------------------+-------------+---------+
+
+ALTER TABLE missing_inverted_index MODIFY COLUMN host SET INVERTED INDEX;
+
+Affected Rows: 0
+
+SELECT * FROM missing_inverted_index WHERE host = 'server1' ORDER BY ts;
+
++-------------------------+-------------+---------+
+| ts                      | indexed_col | host    |
++-------------------------+-------------+---------+
+| 1970-01-01T00:00:00.001 | a           | server1 |
++-------------------------+-------------+---------+
+
+SELECT * FROM missing_inverted_index WHERE host = 'missing' ORDER BY ts;
+
++----+-------------+------+
+| ts | indexed_col | host |
++----+-------------+------+
++----+-------------+------+
+
+SELECT * FROM missing_inverted_index WHERE indexed_col = 'a' AND host = 'server1' ORDER BY ts;
+
++-------------------------+-------------+---------+
+| ts                      | indexed_col | host    |
++-------------------------+-------------+---------+
+| 1970-01-01T00:00:00.001 | a           | server1 |
++-------------------------+-------------+---------+
+
+SELECT * FROM missing_inverted_index WHERE indexed_col = 'b' AND host = 'server1' ORDER BY ts;
+
++----+-------------+------+
+| ts | indexed_col | host |
++----+-------------+------+
++----+-------------+------+
+
+-- New SSTs have both indexes; queries must also retain rows from the old SST.
+INSERT INTO missing_inverted_index VALUES
+    (3, 'a', 'server1'),
+    (4, 'b', 'server2');
+
+Affected Rows: 2
+
+ADMIN FLUSH_TABLE('missing_inverted_index');
+
++---------------------------------------------+
+| ADMIN FLUSH_TABLE('missing_inverted_index') |
++---------------------------------------------+
+| 0                                           |
++---------------------------------------------+
+
+SELECT * FROM missing_inverted_index WHERE host = 'server1' ORDER BY ts;
+
++-------------------------+-------------+---------+
+| ts                      | indexed_col | host    |
++-------------------------+-------------+---------+
+| 1970-01-01T00:00:00.001 | a           | server1 |
+| 1970-01-01T00:00:00.003 | a           | server1 |
++-------------------------+-------------+---------+
+
+SELECT * FROM missing_inverted_index WHERE indexed_col = 'a' AND host = 'server1' ORDER BY ts;
+
++-------------------------+-------------+---------+
+| ts                      | indexed_col | host    |
++-------------------------+-------------+---------+
+| 1970-01-01T00:00:00.001 | a           | server1 |
+| 1970-01-01T00:00:00.003 | a           | server1 |
++-------------------------+-------------+---------+
+
+-- SQLNESS ARG restart=true
+SELECT * FROM missing_inverted_index WHERE host = 'server1' ORDER BY ts;
+
++-------------------------+-------------+---------+
+| ts                      | indexed_col | host    |
++-------------------------+-------------+---------+
+| 1970-01-01T00:00:00.001 | a           | server1 |
+| 1970-01-01T00:00:00.003 | a           | server1 |
++-------------------------+-------------+---------+
+
+-- A column absent from old SSTs can still match its default value.
+ALTER TABLE missing_inverted_index ADD COLUMN source STRING DEFAULT 'legacy';
+
+Affected Rows: 0
+
+ALTER TABLE missing_inverted_index MODIFY COLUMN source SET INVERTED INDEX;
+
+Affected Rows: 0
+
+SELECT * FROM missing_inverted_index WHERE source = 'legacy' ORDER BY ts;
+
++-------------------------+-------------+---------+--------+
+| ts                      | indexed_col | host    | source |
++-------------------------+-------------+---------+--------+
+| 1970-01-01T00:00:00.001 | a           | server1 | legacy |
+| 1970-01-01T00:00:00.002 | b           | server2 | legacy |
+| 1970-01-01T00:00:00.003 | a           | server1 | legacy |
+| 1970-01-01T00:00:00.004 | b           | server2 | legacy |
++-------------------------+-------------+---------+--------+
+
+SELECT * FROM missing_inverted_index WHERE source = 'missing' ORDER BY ts;
+
++----+-------------+------+--------+
+| ts | indexed_col | host | source |
++----+-------------+------+--------+
++----+-------------+------+--------+
+
+SELECT * FROM missing_inverted_index WHERE indexed_col = 'a' AND source = 'legacy' ORDER BY ts;
+
++-------------------------+-------------+---------+--------+
+| ts                      | indexed_col | host    | source |
++-------------------------+-------------+---------+--------+
+| 1970-01-01T00:00:00.001 | a           | server1 | legacy |
+| 1970-01-01T00:00:00.003 | a           | server1 | legacy |
++-------------------------+-------------+---------+--------+
+
+DROP TABLE missing_inverted_index;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/alter/change_col_inverted_index.sql b/tests/cases/standalone/common/alter/change_col_inverted_index.sql
index aadc463d6fc..857bbb0aaf2 100644
--- a/tests/cases/standalone/common/alter/change_col_inverted_index.sql
+++ b/tests/cases/standalone/common/alter/change_col_inverted_index.sql
@@ -52,3 +52,48 @@ ALTER TABLE test_pk MODIFY COLUMN foo SET INVERTED INDEX;
 SHOW INDEX FROM test_pk;
 
 DROP TABLE test_pk;
+
+-- The old SST has an inverted index, but not on host.
+CREATE TABLE missing_inverted_index (
+    ts TIMESTAMP TIME INDEX,
+    indexed_col STRING INVERTED INDEX,
+    host STRING
+) WITH ('append_mode' = 'true');
+
+INSERT INTO missing_inverted_index VALUES
+    (1, 'a', 'server1'),
+    (2, 'b', 'server2');
+
+ADMIN FLUSH_TABLE('missing_inverted_index');
+
+SELECT * FROM missing_inverted_index WHERE host = 'server1' ORDER BY ts;
+
+ALTER TABLE missing_inverted_index MODIFY COLUMN host SET INVERTED INDEX;
+
+SELECT * FROM missing_inverted_index WHERE host = 'server1' ORDER BY ts;
+SELECT * FROM missing_inverted_index WHERE host = 'missing' ORDER BY ts;
+SELECT * FROM missing_inverted_index WHERE indexed_col = 'a' AND host = 'server1' ORDER BY ts;
+SELECT * FROM missing_inverted_index WHERE indexed_col = 'b' AND host = 'server1' ORDER BY ts;
+
+-- New SSTs have both indexes; queries must also retain rows from the old SST.
+INSERT INTO missing_inverted_index VALUES
+    (3, 'a', 'server1'),
+    (4, 'b', 'server2');
+
+ADMIN FLUSH_TABLE('missing_inverted_index');
+
+SELECT * FROM missing_inverted_index WHERE host = 'server1' ORDER BY ts;
+SELECT * FROM missing_inverted_index WHERE indexed_col = 'a' AND host = 'server1' ORDER BY ts;
+
+-- SQLNESS ARG restart=true
+SELECT * FROM missing_inverted_index WHERE host = 'server1' ORDER BY ts;
+
+-- A column absent from old SSTs can still match its default value.
+ALTER TABLE missing_inverted_index ADD COLUMN source STRING DEFAULT 'legacy';
+ALTER TABLE missing_inverted_index MODIFY COLUMN source SET INVERTED INDEX;
+
+SELECT * FROM missing_inverted_index WHERE source = 'legacy' ORDER BY ts;
+SELECT * FROM missing_inverted_index WHERE source = 'missing' ORDER BY ts;
+SELECT * FROM missing_inverted_index WHERE indexed_col = 'a' AND source = 'legacy' ORDER BY ts;
+
+DROP TABLE missing_inverted_index;
diff --git a/tests/cases/standalone/common/filter/expression_depth.result b/tests/cases/standalone/common/filter/expression_depth.result
new file mode 100644
index 00000000000..e0cc1a71337
--- /dev/null
+++ b/tests/cases/standalone/common/filter/expression_depth.result
@@ -0,0 +1,24 @@
+CREATE TABLE depth_guard (ts TIMESTAMP TIME INDEX, v INT);
+
+Affected Rows: 0
+
+INSERT INTO depth_guard VALUES (0, 42);
+
+Affected Rows: 1
+
+SELECT count(*) FROM depth_guard WHERE CAST(v AS BIGINT) = 0 OR CAST(v AS BIGINT) = 1 OR CAST(v AS BIGINT) = 2 OR CAST(v AS BIGINT) = 3 OR CAST(v AS BIGINT) = 4 OR CAST(v AS BIGINT) = 5 OR CAST(v AS BIGINT) = 6 OR CAST(v AS BIGINT) = 7 OR CAST(v AS BIGINT) = 8 OR CAST(v AS BIGINT) = 9 OR CAST(v AS BIGINT) = 10 OR CAST(v AS BIGINT) = 11 OR CAST(v AS BIGINT) = 12 OR CAST(v AS BIGINT) = 13 OR CAST(v AS BIGINT) = 14 OR CAST(v AS BIGINT) = 15 OR CAST(v AS BIGINT) = 16 OR CAST(v AS BIGINT) = 17 OR CAST(v AS BIGINT) = 18 OR CAST(v AS BIGINT) = 19 OR CAST(v AS BIGINT) = 20 OR CAST(v AS BIGINT) = 21 OR CAST(v AS BIGINT) = 22 OR CAST(v AS BIGINT) = 23 OR CAST(v AS BIGINT) = 24 OR CAST(v AS BIGINT) = 25 OR CAST(v AS BIGINT) = 26 OR CAST(v AS BIGINT) = 27 OR CAST(v AS BIGINT) = 28 OR CAST(v AS BIGINT) = 29 OR CAST(v AS BIGINT) = 30 OR CAST(v AS BIGINT) = 31 OR CAST(v AS BIGINT) = 32 OR CAST(v AS BIGINT) = 33 OR CAST(v AS BIGINT) = 34 OR CAST(v AS BIGINT) = 35 OR CAST(v AS BIGINT) = 36 OR CAST(v AS BIGINT) = 37 OR CAST(v AS BIGINT) = 38 OR CAST(v AS BIGINT) = 39 OR CAST(v AS BIGINT) = 40 OR CAST(v AS BIGINT) = 41 OR CAST(v AS BIGINT) = 42 OR CAST(v AS BIGINT) = 43 OR CAST(v AS BIGINT) = 44 OR CAST(v AS BIGINT) = 45 OR CAST(v AS BIGINT) = 46 OR CAST(v AS BIGINT) = 47 OR CAST(v AS BIGINT) = 48 OR CAST(v AS BIGINT) = 49 OR CAST(v AS BIGINT) = 50 OR CAST(v AS BIGINT) = 51 OR CAST(v AS BIGINT) = 52 OR CAST(v AS BIGINT) = 53 OR CAST(v AS BIGINT) = 54 OR CAST(v AS BIGINT) = 55 OR CAST(v AS BIGINT) = 56 OR CAST(v AS BIGINT) = 57 OR CAST(v AS BIGINT) = 58 OR CAST(v AS BIGINT) = 59 OR CAST(v AS BIGINT) = 60 OR CAST(v AS BIGINT) = 61 OR CAST(v AS BIGINT) = 62 OR CAST(v AS BIGINT) = 63 OR CAST(v AS BIGINT) = 64 OR CAST(v AS BIGINT) = 65 OR CAST(v AS BIGINT) = 66 OR CAST(v AS BIGINT) = 67 OR CAST(v AS BIGINT) = 68 OR CAST(v AS BIGINT) = 69 OR CAST(v AS BIGINT) = 70 OR CAST(v AS BIGINT) = 71 OR CAST(v AS BIGINT) = 72 OR CAST(v AS BIGINT) = 73 OR CAST(v AS BIGINT) = 74 OR CAST(v AS BIGINT) = 75 OR CAST(v AS BIGINT) = 76 OR CAST(v AS BIGINT) = 77 OR CAST(v AS BIGINT) = 78 OR CAST(v AS BIGINT) = 79 OR CAST(v AS BIGINT) = 80 OR CAST(v AS BIGINT) = 81 OR CAST(v AS BIGINT) = 82 OR CAST(v AS BIGINT) = 83 OR CAST(v AS BIGINT) = 84 OR CAST(v AS BIGINT) = 85 OR CAST(v AS BIGINT) = 86 OR CAST(v AS BIGINT) = 87 OR CAST(v AS BIGINT) = 88 OR CAST(v AS BIGINT) = 89 OR CAST(v AS BIGINT) = 90 OR CAST(v AS BIGINT) = 91 OR CAST(v AS BIGINT) = 92 OR CAST(v AS BIGINT) = 93 OR CAST(v AS BIGINT) = 94 OR CAST(v AS BIGINT) = 95 OR CAST(v AS BIGINT) = 96 OR CAST(v AS BIGINT) = 97 OR CAST(v AS BIGINT) = 98 OR CAST(v AS BIGINT) = 99 OR CAST(v AS BIGINT) = 100 OR CAST(v AS BIGINT) = 101 OR CAST(v AS BIGINT) = 102 OR CAST(v AS BIGINT) = 103 OR CAST(v AS BIGINT) = 104 OR CAST(v AS BIGINT) = 105 OR CAST(v AS BIGINT) = 106 OR CAST(v AS BIGINT) = 107 OR CAST(v AS BIGINT) = 108 OR CAST(v AS BIGINT) = 109 OR CAST(v AS BIGINT) = 110 OR CAST(v AS BIGINT) = 111 OR CAST(v AS BIGINT) = 112 OR CAST(v AS BIGINT) = 113 OR CAST(v AS BIGINT) = 114 OR CAST(v AS BIGINT) = 115 OR CAST(v AS BIGINT) = 116 OR CAST(v AS BIGINT) = 117 OR CAST(v AS BIGINT) = 118 OR CAST(v AS BIGINT) = 119 OR CAST(v AS BIGINT) = 120 OR CAST(v AS BIGINT) = 121 OR CAST(v AS BIGINT) = 122 OR CAST(v AS BIGINT) = 123 OR CAST(v AS BIGINT) = 124 OR CAST(v AS BIGINT) = 125 OR CAST(v AS BIGINT) = 126 OR CAST(v AS BIGINT) = 127 OR CAST(v AS BIGINT) = 128 OR CAST(v AS BIGINT) = 129;
+
+Error: 3000(PlanQuery), Error during planning: Expression depth exceeds the maximum supported depth of 128
+
+SELECT count(*) FROM depth_guard WHERE v = 42;
+
++----------+
+| count(*) |
++----------+
+| 1        |
++----------+
+
+DROP TABLE depth_guard;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/filter/expression_depth.sql b/tests/cases/standalone/common/filter/expression_depth.sql
new file mode 100644
index 00000000000..34e7b4d371b
--- /dev/null
+++ b/tests/cases/standalone/common/filter/expression_depth.sql
@@ -0,0 +1,9 @@
+CREATE TABLE depth_guard (ts TIMESTAMP TIME INDEX, v INT);
+
+INSERT INTO depth_guard VALUES (0, 42);
+
+SELECT count(*) FROM depth_guard WHERE CAST(v AS BIGINT) = 0 OR CAST(v AS BIGINT) = 1 OR CAST(v AS BIGINT) = 2 OR CAST(v AS BIGINT) = 3 OR CAST(v AS BIGINT) = 4 OR CAST(v AS BIGINT) = 5 OR CAST(v AS BIGINT) = 6 OR CAST(v AS BIGINT) = 7 OR CAST(v AS BIGINT) = 8 OR CAST(v AS BIGINT) = 9 OR CAST(v AS BIGINT) = 10 OR CAST(v AS BIGINT) = 11 OR CAST(v AS BIGINT) = 12 OR CAST(v AS BIGINT) = 13 OR CAST(v AS BIGINT) = 14 OR CAST(v AS BIGINT) = 15 OR CAST(v AS BIGINT) = 16 OR CAST(v AS BIGINT) = 17 OR CAST(v AS BIGINT) = 18 OR CAST(v AS BIGINT) = 19 OR CAST(v AS BIGINT) = 20 OR CAST(v AS BIGINT) = 21 OR CAST(v AS BIGINT) = 22 OR CAST(v AS BIGINT) = 23 OR CAST(v AS BIGINT) = 24 OR CAST(v AS BIGINT) = 25 OR CAST(v AS BIGINT) = 26 OR CAST(v AS BIGINT) = 27 OR CAST(v AS BIGINT) = 28 OR CAST(v AS BIGINT) = 29 OR CAST(v AS BIGINT) = 30 OR CAST(v AS BIGINT) = 31 OR CAST(v AS BIGINT) = 32 OR CAST(v AS BIGINT) = 33 OR CAST(v AS BIGINT) = 34 OR CAST(v AS BIGINT) = 35 OR CAST(v AS BIGINT) = 36 OR CAST(v AS BIGINT) = 37 OR CAST(v AS BIGINT) = 38 OR CAST(v AS BIGINT) = 39 OR CAST(v AS BIGINT) = 40 OR CAST(v AS BIGINT) = 41 OR CAST(v AS BIGINT) = 42 OR CAST(v AS BIGINT) = 43 OR CAST(v AS BIGINT) = 44 OR CAST(v AS BIGINT) = 45 OR CAST(v AS BIGINT) = 46 OR CAST(v AS BIGINT) = 47 OR CAST(v AS BIGINT) = 48 OR CAST(v AS BIGINT) = 49 OR CAST(v AS BIGINT) = 50 OR CAST(v AS BIGINT) = 51 OR CAST(v AS BIGINT) = 52 OR CAST(v AS BIGINT) = 53 OR CAST(v AS BIGINT) = 54 OR CAST(v AS BIGINT) = 55 OR CAST(v AS BIGINT) = 56 OR CAST(v AS BIGINT) = 57 OR CAST(v AS BIGINT) = 58 OR CAST(v AS BIGINT) = 59 OR CAST(v AS BIGINT) = 60 OR CAST(v AS BIGINT) = 61 OR CAST(v AS BIGINT) = 62 OR CAST(v AS BIGINT) = 63 OR CAST(v AS BIGINT) = 64 OR CAST(v AS BIGINT) = 65 OR CAST(v AS BIGINT) = 66 OR CAST(v AS BIGINT) = 67 OR CAST(v AS BIGINT) = 68 OR CAST(v AS BIGINT) = 69 OR CAST(v AS BIGINT) = 70 OR CAST(v AS BIGINT) = 71 OR CAST(v AS BIGINT) = 72 OR CAST(v AS BIGINT) = 73 OR CAST(v AS BIGINT) = 74 OR CAST(v AS BIGINT) = 75 OR CAST(v AS BIGINT) = 76 OR CAST(v AS BIGINT) = 77 OR CAST(v AS BIGINT) = 78 OR CAST(v AS BIGINT) = 79 OR CAST(v AS BIGINT) = 80 OR CAST(v AS BIGINT) = 81 OR CAST(v AS BIGINT) = 82 OR CAST(v AS BIGINT) = 83 OR CAST(v AS BIGINT) = 84 OR CAST(v AS BIGINT) = 85 OR CAST(v AS BIGINT) = 86 OR CAST(v AS BIGINT) = 87 OR CAST(v AS BIGINT) = 88 OR CAST(v AS BIGINT) = 89 OR CAST(v AS BIGINT) = 90 OR CAST(v AS BIGINT) = 91 OR CAST(v AS BIGINT) = 92 OR CAST(v AS BIGINT) = 93 OR CAST(v AS BIGINT) = 94 OR CAST(v AS BIGINT) = 95 OR CAST(v AS BIGINT) = 96 OR CAST(v AS BIGINT) = 97 OR CAST(v AS BIGINT) = 98 OR CAST(v AS BIGINT) = 99 OR CAST(v AS BIGINT) = 100 OR CAST(v AS BIGINT) = 101 OR CAST(v AS BIGINT) = 102 OR CAST(v AS BIGINT) = 103 OR CAST(v AS BIGINT) = 104 OR CAST(v AS BIGINT) = 105 OR CAST(v AS BIGINT) = 106 OR CAST(v AS BIGINT) = 107 OR CAST(v AS BIGINT) = 108 OR CAST(v AS BIGINT) = 109 OR CAST(v AS BIGINT) = 110 OR CAST(v AS BIGINT) = 111 OR CAST(v AS BIGINT) = 112 OR CAST(v AS BIGINT) = 113 OR CAST(v AS BIGINT) = 114 OR CAST(v AS BIGINT) = 115 OR CAST(v AS BIGINT) = 116 OR CAST(v AS BIGINT) = 117 OR CAST(v AS BIGINT) = 118 OR CAST(v AS BIGINT) = 119 OR CAST(v AS BIGINT) = 120 OR CAST(v AS BIGINT) = 121 OR CAST(v AS BIGINT) = 122 OR CAST(v AS BIGINT) = 123 OR CAST(v AS BIGINT) = 124 OR CAST(v AS BIGINT) = 125 OR CAST(v AS BIGINT) = 126 OR CAST(v AS BIGINT) = 127 OR CAST(v AS BIGINT) = 128 OR CAST(v AS BIGINT) = 129;
+
+SELECT count(*) FROM depth_guard WHERE v = 42;
+
+DROP TABLE depth_guard;
diff --git a/tests/cases/standalone/common/flow/flow_advance_ttl.result b/tests/cases/standalone/common/flow/flow_advance_ttl.result
index eae65328a6b..27a28babebf 100644
--- a/tests/cases/standalone/common/flow/flow_advance_ttl.result
+++ b/tests/cases/standalone/common/flow/flow_advance_ttl.result
@@ -414,3 +414,110 @@ DROP TABLE out_distinct_basic;
 
 Affected Rows: 0
 
+-- Streaming DISTINCT auto-sink retains all 1000 output tuples.
+CREATE TABLE distinct_auto_sink (
+    v INT,
+    ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP TIME INDEX
+) WITH ('ttl' = 'instant');
+
+Affected Rows: 0
+
+CREATE FLOW test_distinct_auto_sink SINK TO out_distinct_auto_sink AS
+SELECT DISTINCT v FROM distinct_auto_sink;
+
+Affected Rows: 0
+
+INSERT INTO distinct_auto_sink (v)
+SELECT number FROM numbers LIMIT 1000;
+
+Affected Rows: 0
+
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
+-- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
+ADMIN FLUSH_FLOW('test_distinct_auto_sink');
+
++---------------------------------------------+
+| ADMIN FLUSH_FLOW('test_distinct_auto_sink') |
++---------------------------------------------+
+|  FLOW_FLUSHED  |
++---------------------------------------------+
+
+SELECT count(*) AS rows, count(DISTINCT v) AS distinct_values, min(v) AS min_v, max(v) AS max_v
+FROM out_distinct_auto_sink;
+
++------+-----------------+-------+-------+
+| rows | distinct_values | min_v | max_v |
++------+-----------------+-------+-------+
+| 1000 | 1000            | 0     | 999   |
++------+-----------------+-------+-------+
+
+DROP FLOW test_distinct_auto_sink;
+
+Affected Rows: 0
+
+DROP TABLE distinct_auto_sink;
+
+Affected Rows: 0
+
+DROP TABLE out_distinct_auto_sink;
+
+Affected Rows: 0
+
+CREATE TABLE distinct_auto_sink_pk (
+    v INT,
+    k INT,
+    extra_value INT,
+    ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP TIME INDEX,
+    PRIMARY KEY (v, k)
+) WITH ('ttl' = 'instant');
+
+Affected Rows: 0
+
+CREATE FLOW test_distinct_auto_sink_pk SINK TO out_distinct_auto_sink_pk AS
+SELECT DISTINCT v, extra_value FROM distinct_auto_sink_pk;
+
+Affected Rows: 0
+
+INSERT INTO distinct_auto_sink_pk (v, k, extra_value)
+SELECT number % 10 AS v, number AS k, number AS extra_value FROM numbers LIMIT 1000;
+
+Affected Rows: 0
+
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
+-- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
+ADMIN FLUSH_FLOW('test_distinct_auto_sink_pk');
+
++------------------------------------------------+
+| ADMIN FLUSH_FLOW('test_distinct_auto_sink_pk') |
++------------------------------------------------+
+|  FLOW_FLUSHED  |
++------------------------------------------------+
+
+SELECT
+    count(*) AS rows,
+    count(DISTINCT extra_value) AS distinct_values,
+    min(extra_value) AS min_value,
+    max(extra_value) AS max_value,
+    sum(CASE WHEN v = extra_value % 10 THEN 0 ELSE 1 END) AS mismatched_keys
+FROM out_distinct_auto_sink_pk;
+
++------+-----------------+-----------+-----------+-----------------+
+| rows | distinct_values | min_value | max_value | mismatched_keys |
++------+-----------------+-----------+-----------+-----------------+
+| 1000 | 1000            | 0         | 999       | 0               |
++------+-----------------+-----------+-----------+-----------------+
+
+DROP FLOW test_distinct_auto_sink_pk;
+
+Affected Rows: 0
+
+DROP TABLE distinct_auto_sink_pk;
+
+Affected Rows: 0
+
+DROP TABLE out_distinct_auto_sink_pk;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/flow/flow_advance_ttl.sql b/tests/cases/standalone/common/flow/flow_advance_ttl.sql
index 2aacc0f9458..72356d96372 100644
--- a/tests/cases/standalone/common/flow/flow_advance_ttl.sql
+++ b/tests/cases/standalone/common/flow/flow_advance_ttl.sql
@@ -179,3 +179,58 @@ SELECT number FROM distinct_basic;
 DROP FLOW test_distinct_basic;
 DROP TABLE distinct_basic;
 DROP TABLE out_distinct_basic;
+
+-- Streaming DISTINCT auto-sink retains all 1000 output tuples.
+CREATE TABLE distinct_auto_sink (
+    v INT,
+    ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP TIME INDEX
+) WITH ('ttl' = 'instant');
+
+CREATE FLOW test_distinct_auto_sink SINK TO out_distinct_auto_sink AS
+SELECT DISTINCT v FROM distinct_auto_sink;
+
+INSERT INTO distinct_auto_sink (v)
+SELECT number FROM numbers LIMIT 1000;
+
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
+-- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
+ADMIN FLUSH_FLOW('test_distinct_auto_sink');
+
+SELECT count(*) AS rows, count(DISTINCT v) AS distinct_values, min(v) AS min_v, max(v) AS max_v
+FROM out_distinct_auto_sink;
+
+DROP FLOW test_distinct_auto_sink;
+DROP TABLE distinct_auto_sink;
+DROP TABLE out_distinct_auto_sink;
+
+CREATE TABLE distinct_auto_sink_pk (
+    v INT,
+    k INT,
+    extra_value INT,
+    ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP TIME INDEX,
+    PRIMARY KEY (v, k)
+) WITH ('ttl' = 'instant');
+
+CREATE FLOW test_distinct_auto_sink_pk SINK TO out_distinct_auto_sink_pk AS
+SELECT DISTINCT v, extra_value FROM distinct_auto_sink_pk;
+
+INSERT INTO distinct_auto_sink_pk (v, k, extra_value)
+SELECT number % 10 AS v, number AS k, number AS extra_value FROM numbers LIMIT 1000;
+
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
+-- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
+ADMIN FLUSH_FLOW('test_distinct_auto_sink_pk');
+
+SELECT
+    count(*) AS rows,
+    count(DISTINCT extra_value) AS distinct_values,
+    min(extra_value) AS min_value,
+    max(extra_value) AS max_value,
+    sum(CASE WHEN v = extra_value % 10 THEN 0 ELSE 1 END) AS mismatched_keys
+FROM out_distinct_auto_sink_pk;
+
+DROP FLOW test_distinct_auto_sink_pk;
+DROP TABLE distinct_auto_sink_pk;
+DROP TABLE out_distinct_auto_sink_pk;
diff --git a/tests/cases/standalone/common/flow/flow_null.result b/tests/cases/standalone/common/flow/flow_null.result
index 2386d676cd5..a141b9e03ab 100644
--- a/tests/cases/standalone/common/flow/flow_null.result
+++ b/tests/cases/standalone/common/flow/flow_null.result
@@ -261,6 +261,8 @@ VALUES
 
 Affected Rows: 3
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('calc_nullable_pk');
 
@@ -290,6 +292,8 @@ VALUES
 
 Affected Rows: 3
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('calc_nullable_pk');
 
diff --git a/tests/cases/standalone/common/flow/flow_null.sql b/tests/cases/standalone/common/flow/flow_null.sql
index 4cc71628092..6c1219df2db 100644
--- a/tests/cases/standalone/common/flow/flow_null.sql
+++ b/tests/cases/standalone/common/flow/flow_null.sql
@@ -164,6 +164,8 @@ VALUES
     (2, "name2", "2024-10-18 19:00:00"),
     (3, "name3", "2024-10-18 19:00:00");
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('calc_nullable_pk');
 
@@ -177,6 +179,8 @@ VALUES
     ("name2", "2024-10-18 19:00:00"),
     ("name3", "2024-10-18 19:00:00");
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('calc_nullable_pk');
 
diff --git a/tests/cases/standalone/common/flow/show_create_flow.result b/tests/cases/standalone/common/flow/show_create_flow.result
index f529cef1b9f..d451c552ec3 100644
--- a/tests/cases/standalone/common/flow/show_create_flow.result
+++ b/tests/cases/standalone/common/flow/show_create_flow.result
@@ -116,6 +116,8 @@ INSERT INTO numbers_input_show VALUES (10, 0),(15, 1),(16, 2);
 
 Affected Rows: 3
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
@@ -155,6 +157,8 @@ INSERT INTO numbers_input_show VALUES (4,4),(5,4),(10, 3),(11, 4);
 
 Affected Rows: 4
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
@@ -195,6 +199,8 @@ INSERT INTO numbers_input_show VALUES (3, 1),(4, 2),(10, 3),(11, 4);
 
 Affected Rows: 4
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
@@ -324,6 +330,8 @@ INSERT INTO numbers_input_show VALUES(-4,0), (-3,1), (-2,2), (-1,3);
 
 Affected Rows: 4
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
@@ -384,6 +392,8 @@ INSERT INTO numbers_input_show VALUES (10, 0),(15, 1),(16, 2);
 
 Affected Rows: 3
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
@@ -426,6 +436,8 @@ INSERT INTO numbers_input_show VALUES (10, 6),(11, 8),(15, 7),(18, 3);
 
 Affected Rows: 4
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
diff --git a/tests/cases/standalone/common/flow/show_create_flow.sql b/tests/cases/standalone/common/flow/show_create_flow.sql
index 9856a6041f8..a2bcc4c06d9 100644
--- a/tests/cases/standalone/common/flow/show_create_flow.sql
+++ b/tests/cases/standalone/common/flow/show_create_flow.sql
@@ -45,6 +45,8 @@ SELECT flow_name, table_catalog, flow_definition, source_table_names FROM INFORM
 -- makesure it's not replaced in flownode
 INSERT INTO numbers_input_show VALUES (10, 0),(15, 1),(16, 2);
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
@@ -59,6 +61,8 @@ SELECT flow_name, table_catalog, flow_definition, source_table_names FROM INFORM
 -- makesure it's not replaced in flownode
 INSERT INTO numbers_input_show VALUES (4,4),(5,4),(10, 3),(11, 4);
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
@@ -73,6 +77,8 @@ SELECT flow_name, table_catalog, flow_definition, source_table_names FROM INFORM
 -- makesure it's replaced in flownode
 INSERT INTO numbers_input_show VALUES (3, 1),(4, 2),(10, 3),(11, 4);
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
@@ -118,6 +124,8 @@ SELECT * FROM out_num_cnt_show;
 
 INSERT INTO numbers_input_show VALUES(-4,0), (-3,1), (-2,2), (-1,3);
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
@@ -145,6 +153,8 @@ CREATE FLOW filter_numbers_show SINK TO out_num_cnt_show AS SELECT number as n1
 
 INSERT INTO numbers_input_show VALUES (10, 0),(15, 1),(16, 2);
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
@@ -160,6 +170,8 @@ SELECT flow_definition, source_table_names FROM INFORMATION_SCHEMA.FLOWS WHERE f
 
 INSERT INTO numbers_input_show VALUES (10, 6),(11, 8),(15, 7),(18, 3);
 
+-- Mirror inserts reach the flownode asynchronously; wait before flushing.
+-- SQLNESS SLEEP 3s
 -- SQLNESS REPLACE (ADMIN\sFLUSH_FLOW\('\w+'\)\s+\|\n\+-+\+\n\|\s+)[0-9]+\s+\| $1 FLOW_FLUSHED  |
 ADMIN FLUSH_FLOW('filter_numbers_show');
 
diff --git a/tests/cases/standalone/common/function/admin/build_index_table_restart.result b/tests/cases/standalone/common/function/admin/build_index_table_restart.result
index f6e02582189..62b0a1c084a 100644
--- a/tests/cases/standalone/common/function/admin/build_index_table_restart.result
+++ b/tests/cases/standalone/common/function/admin/build_index_table_restart.result
@@ -147,7 +147,7 @@ WHERE table_id = (
 +------------+
 | index_size |
 +------------+
-| 318        |
+| 321        |
 +------------+
 
 -- SQLNESS ARG restart=true
diff --git a/tests/cases/standalone/common/function/fulltext_index_pruning.result b/tests/cases/standalone/common/function/fulltext_index_pruning.result
new file mode 100644
index 00000000000..10e4b56e2b6
--- /dev/null
+++ b/tests/cases/standalone/common/function/fulltext_index_pruning.result
@@ -0,0 +1,1076 @@
+-- Fulltext index pruning must never drop rows that `matches_term` or `LIKE` accepts.
+-- Each table holds the same rows in a single flushed SST. The unfiltered
+-- projections are the full-scan answers; every filtered query below must return
+-- exactly the rows marked true there.
+CREATE TABLE ft_en_bloom (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'English', backend = 'bloom', case_sensitive = 'false')
+);
+
+Affected Rows: 0
+
+INSERT INTO ft_en_bloom VALUES
+    (1, 'hello_world'),
+    (2, 'trace_id=abc'),
+    (3, '错误error日志'),
+    (4, '登录手机号18888888888的动态key'),
+    (5, '中国农业银行'),
+    (6, '连接timeout.5次'),
+    (7, '用户user-123登录'),
+    (8, 'Disk QUOTA Exceeded on VOL_7');
+
+Affected Rows: 8
+
+ADMIN flush_table('ft_en_bloom');
+
++----------------------------------+
+| ADMIN flush_table('ft_en_bloom') |
++----------------------------------+
+| 0                                |
++----------------------------------+
+
+SELECT ts, msg @@ 'world' AS "world", msg @@ 'id' AS "id", msg @@ 'error' AS "error", msg @@ '手机号' AS "手机号", msg @@ '手机' AS "手机", msg @@ '机号' AS "机号", msg @@ '18888888888' AS "18888888888", msg @@ '农业' AS "农业", msg @@ 'timeout' AS "timeout", msg @@ 'user' AS "user" FROM ft_en_bloom ORDER BY ts;
+
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+| ts                      | world | id    | error | 手机号 | 手机  | 机号  | 18888888888 | 农业  | timeout | user  |
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+| 1970-01-01T00:00:00.001 | true  | false | false | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.002 | false | true  | false | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.003 | false | false | true  | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.004 | false | false | false | true   | true  | true  | true        | false | false   | false |
+| 1970-01-01T00:00:00.005 | false | false | false | false  | false | false | false       | true  | false   | false |
+| 1970-01-01T00:00:00.006 | false | false | false | false  | false | false | false       | false | true    | false |
+| 1970-01-01T00:00:00.007 | false | false | false | false  | false | false | false       | false | false   | true  |
+| 1970-01-01T00:00:00.008 | false | false | false | false  | false | false | false       | false | false   | false |
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ 'world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ 'id' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ 'error' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.003 | 错误error日志 |
++-------------------------+---------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ '手机号' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ '手机' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ '机号' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ '18888888888' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ '农业' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.005 | 中国农业银行 |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ 'timeout' ORDER BY ts;
+
++-------------------------+-----------------+
+| ts                      | msg             |
++-------------------------+-----------------+
+| 1970-01-01T00:00:00.006 | 连接timeout.5次 |
++-------------------------+-----------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ 'user' ORDER BY ts;
+
++-------------------------+------------------+
+| ts                      | msg              |
++-------------------------+------------------+
+| 1970-01-01T00:00:00.007 | 用户user-123登录 |
++-------------------------+------------------+
+
+SELECT ts, msg LIKE '%world' AS "%world", msg LIKE 'hello\_world' AS "hello\_world", msg LIKE 'hello_world' AS "hello_world", msg LIKE '%id=%' AS "%id=%", msg LIKE 'trace%abc' AS "trace%abc", msg LIKE '%error%' AS "%error%", msg LIKE '%手机号1888%' AS "%手机号1888%", msg LIKE '%农业%' AS "%农业%", msg LIKE '连接timeout.%' AS "连接timeout.%", msg LIKE '%user-123%' AS "%user-123%" FROM ft_en_bloom ORDER BY ts;
+
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+| ts                      | %world | hello\_world | hello_world | %id=% | trace%abc | %error% | %手机号1888% | %农业% | 连接timeout.% | %user-123% |
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+| 1970-01-01T00:00:00.001 | true   | true         | true        | false | false     | false   | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.002 | false  | false        | false       | true  | true      | false   | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.003 | false  | false        | false       | false | false     | true    | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.004 | false  | false        | false       | false | false     | false   | true         | false  | false         | false      |
+| 1970-01-01T00:00:00.005 | false  | false        | false       | false | false     | false   | false        | true   | false         | false      |
+| 1970-01-01T00:00:00.006 | false  | false        | false       | false | false     | false   | false        | false  | true          | false      |
+| 1970-01-01T00:00:00.007 | false  | false        | false       | false | false     | false   | false        | false  | false         | true       |
+| 1970-01-01T00:00:00.008 | false  | false        | false       | false | false     | false   | false        | false  | false         | false      |
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE 'hello\_world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE 'hello_world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%id=%' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE 'trace%abc' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%error%' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.003 | 错误error日志 |
++-------------------------+---------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%手机号1888%' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%农业%' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.005 | 中国农业银行 |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '连接timeout.%' ORDER BY ts;
+
++-------------------------+-----------------+
+| ts                      | msg             |
++-------------------------+-----------------+
+| 1970-01-01T00:00:00.006 | 连接timeout.5次 |
++-------------------------+-----------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%user-123%' ORDER BY ts;
+
++-------------------------+------------------+
+| ts                      | msg              |
++-------------------------+------------------+
+| 1970-01-01T00:00:00.007 | 用户user-123登录 |
++-------------------------+------------------+
+
+SELECT ts, matches_term(lower(msg), 'quota') AS "matches_term(lower(msg), 'quota')", matches_term(lower(msg), 'vol') AS "matches_term(lower(msg), 'vol')", lower(msg) LIKE '%disk quota exceeded%' AS "lower(msg) LIKE '%disk quota exceeded%'", lower(msg) LIKE 'disk quota%' AS "lower(msg) LIKE 'disk quota%'" FROM ft_en_bloom ORDER BY ts;
+
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+| ts                      | matches_term(lower(msg), 'quota') | matches_term(lower(msg), 'vol') | lower(msg) LIKE '%disk quota exceeded%' | lower(msg) LIKE 'disk quota%' |
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+| 1970-01-01T00:00:00.001 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.002 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.003 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.004 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.005 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.006 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.007 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.008 | true                              | true                            | true                                    | true                          |
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE matches_term(lower(msg), 'quota') ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE matches_term(lower(msg), 'vol') ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE lower(msg) LIKE '%disk quota exceeded%' ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_en_bloom WHERE lower(msg) LIKE 'disk quota%' ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+DROP TABLE ft_en_bloom;
+
+Affected Rows: 0
+
+CREATE TABLE ft_zh_bloom (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'Chinese', backend = 'bloom', case_sensitive = 'false')
+);
+
+Affected Rows: 0
+
+INSERT INTO ft_zh_bloom VALUES
+    (1, 'hello_world'),
+    (2, 'trace_id=abc'),
+    (3, '错误error日志'),
+    (4, '登录手机号18888888888的动态key'),
+    (5, '中国农业银行'),
+    (6, '连接timeout.5次'),
+    (7, '用户user-123登录'),
+    (8, 'Disk QUOTA Exceeded on VOL_7');
+
+Affected Rows: 8
+
+ADMIN flush_table('ft_zh_bloom');
+
++----------------------------------+
+| ADMIN flush_table('ft_zh_bloom') |
++----------------------------------+
+| 0                                |
++----------------------------------+
+
+SELECT ts, msg @@ 'world' AS "world", msg @@ 'id' AS "id", msg @@ 'error' AS "error", msg @@ '手机号' AS "手机号", msg @@ '手机' AS "手机", msg @@ '机号' AS "机号", msg @@ '18888888888' AS "18888888888", msg @@ '农业' AS "农业", msg @@ 'timeout' AS "timeout", msg @@ 'user' AS "user" FROM ft_zh_bloom ORDER BY ts;
+
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+| ts                      | world | id    | error | 手机号 | 手机  | 机号  | 18888888888 | 农业  | timeout | user  |
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+| 1970-01-01T00:00:00.001 | true  | false | false | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.002 | false | true  | false | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.003 | false | false | true  | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.004 | false | false | false | true   | true  | true  | true        | false | false   | false |
+| 1970-01-01T00:00:00.005 | false | false | false | false  | false | false | false       | true  | false   | false |
+| 1970-01-01T00:00:00.006 | false | false | false | false  | false | false | false       | false | true    | false |
+| 1970-01-01T00:00:00.007 | false | false | false | false  | false | false | false       | false | false   | true  |
+| 1970-01-01T00:00:00.008 | false | false | false | false  | false | false | false       | false | false   | false |
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ 'world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ 'id' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ 'error' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.003 | 错误error日志 |
++-------------------------+---------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ '手机号' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ '手机' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ '机号' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ '18888888888' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ '农业' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.005 | 中国农业银行 |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ 'timeout' ORDER BY ts;
+
++-------------------------+-----------------+
+| ts                      | msg             |
++-------------------------+-----------------+
+| 1970-01-01T00:00:00.006 | 连接timeout.5次 |
++-------------------------+-----------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ 'user' ORDER BY ts;
+
++-------------------------+------------------+
+| ts                      | msg              |
++-------------------------+------------------+
+| 1970-01-01T00:00:00.007 | 用户user-123登录 |
++-------------------------+------------------+
+
+SELECT ts, msg LIKE '%world' AS "%world", msg LIKE 'hello\_world' AS "hello\_world", msg LIKE 'hello_world' AS "hello_world", msg LIKE '%id=%' AS "%id=%", msg LIKE 'trace%abc' AS "trace%abc", msg LIKE '%error%' AS "%error%", msg LIKE '%手机号1888%' AS "%手机号1888%", msg LIKE '%农业%' AS "%农业%", msg LIKE '连接timeout.%' AS "连接timeout.%", msg LIKE '%user-123%' AS "%user-123%" FROM ft_zh_bloom ORDER BY ts;
+
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+| ts                      | %world | hello\_world | hello_world | %id=% | trace%abc | %error% | %手机号1888% | %农业% | 连接timeout.% | %user-123% |
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+| 1970-01-01T00:00:00.001 | true   | true         | true        | false | false     | false   | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.002 | false  | false        | false       | true  | true      | false   | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.003 | false  | false        | false       | false | false     | true    | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.004 | false  | false        | false       | false | false     | false   | true         | false  | false         | false      |
+| 1970-01-01T00:00:00.005 | false  | false        | false       | false | false     | false   | false        | true   | false         | false      |
+| 1970-01-01T00:00:00.006 | false  | false        | false       | false | false     | false   | false        | false  | true          | false      |
+| 1970-01-01T00:00:00.007 | false  | false        | false       | false | false     | false   | false        | false  | false         | true       |
+| 1970-01-01T00:00:00.008 | false  | false        | false       | false | false     | false   | false        | false  | false         | false      |
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE 'hello\_world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE 'hello_world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%id=%' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE 'trace%abc' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%error%' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.003 | 错误error日志 |
++-------------------------+---------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%手机号1888%' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%农业%' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.005 | 中国农业银行 |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '连接timeout.%' ORDER BY ts;
+
++-------------------------+-----------------+
+| ts                      | msg             |
++-------------------------+-----------------+
+| 1970-01-01T00:00:00.006 | 连接timeout.5次 |
++-------------------------+-----------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%user-123%' ORDER BY ts;
+
++-------------------------+------------------+
+| ts                      | msg              |
++-------------------------+------------------+
+| 1970-01-01T00:00:00.007 | 用户user-123登录 |
++-------------------------+------------------+
+
+SELECT ts, matches_term(lower(msg), 'quota') AS "matches_term(lower(msg), 'quota')", matches_term(lower(msg), 'vol') AS "matches_term(lower(msg), 'vol')", lower(msg) LIKE '%disk quota exceeded%' AS "lower(msg) LIKE '%disk quota exceeded%'", lower(msg) LIKE 'disk quota%' AS "lower(msg) LIKE 'disk quota%'" FROM ft_zh_bloom ORDER BY ts;
+
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+| ts                      | matches_term(lower(msg), 'quota') | matches_term(lower(msg), 'vol') | lower(msg) LIKE '%disk quota exceeded%' | lower(msg) LIKE 'disk quota%' |
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+| 1970-01-01T00:00:00.001 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.002 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.003 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.004 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.005 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.006 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.007 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.008 | true                              | true                            | true                                    | true                          |
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE matches_term(lower(msg), 'quota') ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE matches_term(lower(msg), 'vol') ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE lower(msg) LIKE '%disk quota exceeded%' ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_zh_bloom WHERE lower(msg) LIKE 'disk quota%' ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+DROP TABLE ft_zh_bloom;
+
+Affected Rows: 0
+
+CREATE TABLE ft_en_tantivy (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'English', backend = 'tantivy', case_sensitive = 'false')
+);
+
+Affected Rows: 0
+
+INSERT INTO ft_en_tantivy VALUES
+    (1, 'hello_world'),
+    (2, 'trace_id=abc'),
+    (3, '错误error日志'),
+    (4, '登录手机号18888888888的动态key'),
+    (5, '中国农业银行'),
+    (6, '连接timeout.5次'),
+    (7, '用户user-123登录'),
+    (8, 'Disk QUOTA Exceeded on VOL_7');
+
+Affected Rows: 8
+
+ADMIN flush_table('ft_en_tantivy');
+
++------------------------------------+
+| ADMIN flush_table('ft_en_tantivy') |
++------------------------------------+
+| 0                                  |
++------------------------------------+
+
+SELECT ts, msg @@ 'world' AS "world", msg @@ 'id' AS "id", msg @@ 'error' AS "error", msg @@ '手机号' AS "手机号", msg @@ '手机' AS "手机", msg @@ '机号' AS "机号", msg @@ '18888888888' AS "18888888888", msg @@ '农业' AS "农业", msg @@ 'timeout' AS "timeout", msg @@ 'user' AS "user" FROM ft_en_tantivy ORDER BY ts;
+
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+| ts                      | world | id    | error | 手机号 | 手机  | 机号  | 18888888888 | 农业  | timeout | user  |
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+| 1970-01-01T00:00:00.001 | true  | false | false | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.002 | false | true  | false | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.003 | false | false | true  | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.004 | false | false | false | true   | true  | true  | true        | false | false   | false |
+| 1970-01-01T00:00:00.005 | false | false | false | false  | false | false | false       | true  | false   | false |
+| 1970-01-01T00:00:00.006 | false | false | false | false  | false | false | false       | false | true    | false |
+| 1970-01-01T00:00:00.007 | false | false | false | false  | false | false | false       | false | false   | true  |
+| 1970-01-01T00:00:00.008 | false | false | false | false  | false | false | false       | false | false   | false |
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ 'world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ 'id' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ 'error' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.003 | 错误error日志 |
++-------------------------+---------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ '手机号' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ '手机' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ '机号' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ '18888888888' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ '农业' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.005 | 中国农业银行 |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ 'timeout' ORDER BY ts;
+
++-------------------------+-----------------+
+| ts                      | msg             |
++-------------------------+-----------------+
+| 1970-01-01T00:00:00.006 | 连接timeout.5次 |
++-------------------------+-----------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ 'user' ORDER BY ts;
+
++-------------------------+------------------+
+| ts                      | msg              |
++-------------------------+------------------+
+| 1970-01-01T00:00:00.007 | 用户user-123登录 |
++-------------------------+------------------+
+
+SELECT ts, msg LIKE '%world' AS "%world", msg LIKE 'hello\_world' AS "hello\_world", msg LIKE 'hello_world' AS "hello_world", msg LIKE '%id=%' AS "%id=%", msg LIKE 'trace%abc' AS "trace%abc", msg LIKE '%error%' AS "%error%", msg LIKE '%手机号1888%' AS "%手机号1888%", msg LIKE '%农业%' AS "%农业%", msg LIKE '连接timeout.%' AS "连接timeout.%", msg LIKE '%user-123%' AS "%user-123%" FROM ft_en_tantivy ORDER BY ts;
+
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+| ts                      | %world | hello\_world | hello_world | %id=% | trace%abc | %error% | %手机号1888% | %农业% | 连接timeout.% | %user-123% |
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+| 1970-01-01T00:00:00.001 | true   | true         | true        | false | false     | false   | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.002 | false  | false        | false       | true  | true      | false   | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.003 | false  | false        | false       | false | false     | true    | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.004 | false  | false        | false       | false | false     | false   | true         | false  | false         | false      |
+| 1970-01-01T00:00:00.005 | false  | false        | false       | false | false     | false   | false        | true   | false         | false      |
+| 1970-01-01T00:00:00.006 | false  | false        | false       | false | false     | false   | false        | false  | true          | false      |
+| 1970-01-01T00:00:00.007 | false  | false        | false       | false | false     | false   | false        | false  | false         | true       |
+| 1970-01-01T00:00:00.008 | false  | false        | false       | false | false     | false   | false        | false  | false         | false      |
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE 'hello\_world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE 'hello_world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%id=%' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE 'trace%abc' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%error%' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.003 | 错误error日志 |
++-------------------------+---------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%手机号1888%' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%农业%' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.005 | 中国农业银行 |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '连接timeout.%' ORDER BY ts;
+
++-------------------------+-----------------+
+| ts                      | msg             |
++-------------------------+-----------------+
+| 1970-01-01T00:00:00.006 | 连接timeout.5次 |
++-------------------------+-----------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%user-123%' ORDER BY ts;
+
++-------------------------+------------------+
+| ts                      | msg              |
++-------------------------+------------------+
+| 1970-01-01T00:00:00.007 | 用户user-123登录 |
++-------------------------+------------------+
+
+SELECT ts, matches_term(lower(msg), 'quota') AS "matches_term(lower(msg), 'quota')", matches_term(lower(msg), 'vol') AS "matches_term(lower(msg), 'vol')", lower(msg) LIKE '%disk quota exceeded%' AS "lower(msg) LIKE '%disk quota exceeded%'", lower(msg) LIKE 'disk quota%' AS "lower(msg) LIKE 'disk quota%'" FROM ft_en_tantivy ORDER BY ts;
+
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+| ts                      | matches_term(lower(msg), 'quota') | matches_term(lower(msg), 'vol') | lower(msg) LIKE '%disk quota exceeded%' | lower(msg) LIKE 'disk quota%' |
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+| 1970-01-01T00:00:00.001 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.002 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.003 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.004 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.005 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.006 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.007 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.008 | true                              | true                            | true                                    | true                          |
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE matches_term(lower(msg), 'quota') ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE matches_term(lower(msg), 'vol') ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE lower(msg) LIKE '%disk quota exceeded%' ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_en_tantivy WHERE lower(msg) LIKE 'disk quota%' ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+DROP TABLE ft_en_tantivy;
+
+Affected Rows: 0
+
+CREATE TABLE ft_zh_tantivy (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'Chinese', backend = 'tantivy', case_sensitive = 'false')
+);
+
+Affected Rows: 0
+
+INSERT INTO ft_zh_tantivy VALUES
+    (1, 'hello_world'),
+    (2, 'trace_id=abc'),
+    (3, '错误error日志'),
+    (4, '登录手机号18888888888的动态key'),
+    (5, '中国农业银行'),
+    (6, '连接timeout.5次'),
+    (7, '用户user-123登录'),
+    (8, 'Disk QUOTA Exceeded on VOL_7');
+
+Affected Rows: 8
+
+ADMIN flush_table('ft_zh_tantivy');
+
++------------------------------------+
+| ADMIN flush_table('ft_zh_tantivy') |
++------------------------------------+
+| 0                                  |
++------------------------------------+
+
+SELECT ts, msg @@ 'world' AS "world", msg @@ 'id' AS "id", msg @@ 'error' AS "error", msg @@ '手机号' AS "手机号", msg @@ '手机' AS "手机", msg @@ '机号' AS "机号", msg @@ '18888888888' AS "18888888888", msg @@ '农业' AS "农业", msg @@ 'timeout' AS "timeout", msg @@ 'user' AS "user" FROM ft_zh_tantivy ORDER BY ts;
+
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+| ts                      | world | id    | error | 手机号 | 手机  | 机号  | 18888888888 | 农业  | timeout | user  |
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+| 1970-01-01T00:00:00.001 | true  | false | false | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.002 | false | true  | false | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.003 | false | false | true  | false  | false | false | false       | false | false   | false |
+| 1970-01-01T00:00:00.004 | false | false | false | true   | true  | true  | true        | false | false   | false |
+| 1970-01-01T00:00:00.005 | false | false | false | false  | false | false | false       | true  | false   | false |
+| 1970-01-01T00:00:00.006 | false | false | false | false  | false | false | false       | false | true    | false |
+| 1970-01-01T00:00:00.007 | false | false | false | false  | false | false | false       | false | false   | true  |
+| 1970-01-01T00:00:00.008 | false | false | false | false  | false | false | false       | false | false   | false |
++-------------------------+-------+-------+-------+--------+-------+-------+-------------+-------+---------+-------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ 'world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ 'id' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ 'error' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.003 | 错误error日志 |
++-------------------------+---------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ '手机号' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ '手机' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ '机号' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ '18888888888' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ '农业' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.005 | 中国农业银行 |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ 'timeout' ORDER BY ts;
+
++-------------------------+-----------------+
+| ts                      | msg             |
++-------------------------+-----------------+
+| 1970-01-01T00:00:00.006 | 连接timeout.5次 |
++-------------------------+-----------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ 'user' ORDER BY ts;
+
++-------------------------+------------------+
+| ts                      | msg              |
++-------------------------+------------------+
+| 1970-01-01T00:00:00.007 | 用户user-123登录 |
++-------------------------+------------------+
+
+SELECT ts, msg LIKE '%world' AS "%world", msg LIKE 'hello\_world' AS "hello\_world", msg LIKE 'hello_world' AS "hello_world", msg LIKE '%id=%' AS "%id=%", msg LIKE 'trace%abc' AS "trace%abc", msg LIKE '%error%' AS "%error%", msg LIKE '%手机号1888%' AS "%手机号1888%", msg LIKE '%农业%' AS "%农业%", msg LIKE '连接timeout.%' AS "连接timeout.%", msg LIKE '%user-123%' AS "%user-123%" FROM ft_zh_tantivy ORDER BY ts;
+
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+| ts                      | %world | hello\_world | hello_world | %id=% | trace%abc | %error% | %手机号1888% | %农业% | 连接timeout.% | %user-123% |
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+| 1970-01-01T00:00:00.001 | true   | true         | true        | false | false     | false   | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.002 | false  | false        | false       | true  | true      | false   | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.003 | false  | false        | false       | false | false     | true    | false        | false  | false         | false      |
+| 1970-01-01T00:00:00.004 | false  | false        | false       | false | false     | false   | true         | false  | false         | false      |
+| 1970-01-01T00:00:00.005 | false  | false        | false       | false | false     | false   | false        | true   | false         | false      |
+| 1970-01-01T00:00:00.006 | false  | false        | false       | false | false     | false   | false        | false  | true          | false      |
+| 1970-01-01T00:00:00.007 | false  | false        | false       | false | false     | false   | false        | false  | false         | true       |
+| 1970-01-01T00:00:00.008 | false  | false        | false       | false | false     | false   | false        | false  | false         | false      |
++-------------------------+--------+--------------+-------------+-------+-----------+---------+--------------+--------+---------------+------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE 'hello\_world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE 'hello_world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%id=%' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE 'trace%abc' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.002 | trace_id=abc |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%error%' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.003 | 错误error日志 |
++-------------------------+---------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%手机号1888%' ORDER BY ts;
+
++-------------------------+--------------------------------+
+| ts                      | msg                            |
++-------------------------+--------------------------------+
+| 1970-01-01T00:00:00.004 | 登录手机号18888888888的动态key |
++-------------------------+--------------------------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%农业%' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.005 | 中国农业银行 |
++-------------------------+--------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '连接timeout.%' ORDER BY ts;
+
++-------------------------+-----------------+
+| ts                      | msg             |
++-------------------------+-----------------+
+| 1970-01-01T00:00:00.006 | 连接timeout.5次 |
++-------------------------+-----------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%user-123%' ORDER BY ts;
+
++-------------------------+------------------+
+| ts                      | msg              |
++-------------------------+------------------+
+| 1970-01-01T00:00:00.007 | 用户user-123登录 |
++-------------------------+------------------+
+
+SELECT ts, matches_term(lower(msg), 'quota') AS "matches_term(lower(msg), 'quota')", matches_term(lower(msg), 'vol') AS "matches_term(lower(msg), 'vol')", lower(msg) LIKE '%disk quota exceeded%' AS "lower(msg) LIKE '%disk quota exceeded%'", lower(msg) LIKE 'disk quota%' AS "lower(msg) LIKE 'disk quota%'" FROM ft_zh_tantivy ORDER BY ts;
+
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+| ts                      | matches_term(lower(msg), 'quota') | matches_term(lower(msg), 'vol') | lower(msg) LIKE '%disk quota exceeded%' | lower(msg) LIKE 'disk quota%' |
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+| 1970-01-01T00:00:00.001 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.002 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.003 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.004 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.005 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.006 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.007 | false                             | false                           | false                                   | false                         |
+| 1970-01-01T00:00:00.008 | true                              | true                            | true                                    | true                          |
++-------------------------+-----------------------------------+---------------------------------+-----------------------------------------+-------------------------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE matches_term(lower(msg), 'quota') ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE matches_term(lower(msg), 'vol') ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE lower(msg) LIKE '%disk quota exceeded%' ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE lower(msg) LIKE 'disk quota%' ORDER BY ts;
+
++-------------------------+------------------------------+
+| ts                      | msg                          |
++-------------------------+------------------------------+
+| 1970-01-01T00:00:00.008 | Disk QUOTA Exceeded on VOL_7 |
++-------------------------+------------------------------+
+
+DROP TABLE ft_zh_tantivy;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/function/fulltext_index_pruning.sql b/tests/cases/standalone/common/function/fulltext_index_pruning.sql
new file mode 100644
index 00000000000..f4e711b94e0
--- /dev/null
+++ b/tests/cases/standalone/common/function/fulltext_index_pruning.sql
@@ -0,0 +1,296 @@
+-- Fulltext index pruning must never drop rows that `matches_term` or `LIKE` accepts.
+-- Each table holds the same rows in a single flushed SST. The unfiltered
+-- projections are the full-scan answers; every filtered query below must return
+-- exactly the rows marked true there.
+
+CREATE TABLE ft_en_bloom (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'English', backend = 'bloom', case_sensitive = 'false')
+);
+
+INSERT INTO ft_en_bloom VALUES
+    (1, 'hello_world'),
+    (2, 'trace_id=abc'),
+    (3, '错误error日志'),
+    (4, '登录手机号18888888888的动态key'),
+    (5, '中国农业银行'),
+    (6, '连接timeout.5次'),
+    (7, '用户user-123登录'),
+    (8, 'Disk QUOTA Exceeded on VOL_7');
+
+ADMIN flush_table('ft_en_bloom');
+
+SELECT ts, msg @@ 'world' AS "world", msg @@ 'id' AS "id", msg @@ 'error' AS "error", msg @@ '手机号' AS "手机号", msg @@ '手机' AS "手机", msg @@ '机号' AS "机号", msg @@ '18888888888' AS "18888888888", msg @@ '农业' AS "农业", msg @@ 'timeout' AS "timeout", msg @@ 'user' AS "user" FROM ft_en_bloom ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ 'world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ 'id' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ 'error' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ '手机号' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ '手机' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ '机号' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ '18888888888' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ '农业' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ 'timeout' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg @@ 'user' ORDER BY ts;
+
+SELECT ts, msg LIKE '%world' AS "%world", msg LIKE 'hello\_world' AS "hello\_world", msg LIKE 'hello_world' AS "hello_world", msg LIKE '%id=%' AS "%id=%", msg LIKE 'trace%abc' AS "trace%abc", msg LIKE '%error%' AS "%error%", msg LIKE '%手机号1888%' AS "%手机号1888%", msg LIKE '%农业%' AS "%农业%", msg LIKE '连接timeout.%' AS "连接timeout.%", msg LIKE '%user-123%' AS "%user-123%" FROM ft_en_bloom ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE 'hello\_world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE 'hello_world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%id=%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE 'trace%abc' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%error%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%手机号1888%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%农业%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '连接timeout.%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE msg LIKE '%user-123%' ORDER BY ts;
+
+SELECT ts, matches_term(lower(msg), 'quota') AS "matches_term(lower(msg), 'quota')", matches_term(lower(msg), 'vol') AS "matches_term(lower(msg), 'vol')", lower(msg) LIKE '%disk quota exceeded%' AS "lower(msg) LIKE '%disk quota exceeded%'", lower(msg) LIKE 'disk quota%' AS "lower(msg) LIKE 'disk quota%'" FROM ft_en_bloom ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE matches_term(lower(msg), 'quota') ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE matches_term(lower(msg), 'vol') ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE lower(msg) LIKE '%disk quota exceeded%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_bloom WHERE lower(msg) LIKE 'disk quota%' ORDER BY ts;
+
+DROP TABLE ft_en_bloom;
+
+CREATE TABLE ft_zh_bloom (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'Chinese', backend = 'bloom', case_sensitive = 'false')
+);
+
+INSERT INTO ft_zh_bloom VALUES
+    (1, 'hello_world'),
+    (2, 'trace_id=abc'),
+    (3, '错误error日志'),
+    (4, '登录手机号18888888888的动态key'),
+    (5, '中国农业银行'),
+    (6, '连接timeout.5次'),
+    (7, '用户user-123登录'),
+    (8, 'Disk QUOTA Exceeded on VOL_7');
+
+ADMIN flush_table('ft_zh_bloom');
+
+SELECT ts, msg @@ 'world' AS "world", msg @@ 'id' AS "id", msg @@ 'error' AS "error", msg @@ '手机号' AS "手机号", msg @@ '手机' AS "手机", msg @@ '机号' AS "机号", msg @@ '18888888888' AS "18888888888", msg @@ '农业' AS "农业", msg @@ 'timeout' AS "timeout", msg @@ 'user' AS "user" FROM ft_zh_bloom ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ 'world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ 'id' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ 'error' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ '手机号' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ '手机' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ '机号' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ '18888888888' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ '农业' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ 'timeout' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg @@ 'user' ORDER BY ts;
+
+SELECT ts, msg LIKE '%world' AS "%world", msg LIKE 'hello\_world' AS "hello\_world", msg LIKE 'hello_world' AS "hello_world", msg LIKE '%id=%' AS "%id=%", msg LIKE 'trace%abc' AS "trace%abc", msg LIKE '%error%' AS "%error%", msg LIKE '%手机号1888%' AS "%手机号1888%", msg LIKE '%农业%' AS "%农业%", msg LIKE '连接timeout.%' AS "连接timeout.%", msg LIKE '%user-123%' AS "%user-123%" FROM ft_zh_bloom ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE 'hello\_world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE 'hello_world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%id=%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE 'trace%abc' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%error%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%手机号1888%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%农业%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '连接timeout.%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE msg LIKE '%user-123%' ORDER BY ts;
+
+SELECT ts, matches_term(lower(msg), 'quota') AS "matches_term(lower(msg), 'quota')", matches_term(lower(msg), 'vol') AS "matches_term(lower(msg), 'vol')", lower(msg) LIKE '%disk quota exceeded%' AS "lower(msg) LIKE '%disk quota exceeded%'", lower(msg) LIKE 'disk quota%' AS "lower(msg) LIKE 'disk quota%'" FROM ft_zh_bloom ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE matches_term(lower(msg), 'quota') ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE matches_term(lower(msg), 'vol') ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE lower(msg) LIKE '%disk quota exceeded%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_bloom WHERE lower(msg) LIKE 'disk quota%' ORDER BY ts;
+
+DROP TABLE ft_zh_bloom;
+
+CREATE TABLE ft_en_tantivy (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'English', backend = 'tantivy', case_sensitive = 'false')
+);
+
+INSERT INTO ft_en_tantivy VALUES
+    (1, 'hello_world'),
+    (2, 'trace_id=abc'),
+    (3, '错误error日志'),
+    (4, '登录手机号18888888888的动态key'),
+    (5, '中国农业银行'),
+    (6, '连接timeout.5次'),
+    (7, '用户user-123登录'),
+    (8, 'Disk QUOTA Exceeded on VOL_7');
+
+ADMIN flush_table('ft_en_tantivy');
+
+SELECT ts, msg @@ 'world' AS "world", msg @@ 'id' AS "id", msg @@ 'error' AS "error", msg @@ '手机号' AS "手机号", msg @@ '手机' AS "手机", msg @@ '机号' AS "机号", msg @@ '18888888888' AS "18888888888", msg @@ '农业' AS "农业", msg @@ 'timeout' AS "timeout", msg @@ 'user' AS "user" FROM ft_en_tantivy ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ 'world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ 'id' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ 'error' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ '手机号' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ '手机' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ '机号' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ '18888888888' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ '农业' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ 'timeout' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg @@ 'user' ORDER BY ts;
+
+SELECT ts, msg LIKE '%world' AS "%world", msg LIKE 'hello\_world' AS "hello\_world", msg LIKE 'hello_world' AS "hello_world", msg LIKE '%id=%' AS "%id=%", msg LIKE 'trace%abc' AS "trace%abc", msg LIKE '%error%' AS "%error%", msg LIKE '%手机号1888%' AS "%手机号1888%", msg LIKE '%农业%' AS "%农业%", msg LIKE '连接timeout.%' AS "连接timeout.%", msg LIKE '%user-123%' AS "%user-123%" FROM ft_en_tantivy ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE 'hello\_world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE 'hello_world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%id=%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE 'trace%abc' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%error%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%手机号1888%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%农业%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '连接timeout.%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE msg LIKE '%user-123%' ORDER BY ts;
+
+SELECT ts, matches_term(lower(msg), 'quota') AS "matches_term(lower(msg), 'quota')", matches_term(lower(msg), 'vol') AS "matches_term(lower(msg), 'vol')", lower(msg) LIKE '%disk quota exceeded%' AS "lower(msg) LIKE '%disk quota exceeded%'", lower(msg) LIKE 'disk quota%' AS "lower(msg) LIKE 'disk quota%'" FROM ft_en_tantivy ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE matches_term(lower(msg), 'quota') ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE matches_term(lower(msg), 'vol') ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE lower(msg) LIKE '%disk quota exceeded%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_en_tantivy WHERE lower(msg) LIKE 'disk quota%' ORDER BY ts;
+
+DROP TABLE ft_en_tantivy;
+
+CREATE TABLE ft_zh_tantivy (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'Chinese', backend = 'tantivy', case_sensitive = 'false')
+);
+
+INSERT INTO ft_zh_tantivy VALUES
+    (1, 'hello_world'),
+    (2, 'trace_id=abc'),
+    (3, '错误error日志'),
+    (4, '登录手机号18888888888的动态key'),
+    (5, '中国农业银行'),
+    (6, '连接timeout.5次'),
+    (7, '用户user-123登录'),
+    (8, 'Disk QUOTA Exceeded on VOL_7');
+
+ADMIN flush_table('ft_zh_tantivy');
+
+SELECT ts, msg @@ 'world' AS "world", msg @@ 'id' AS "id", msg @@ 'error' AS "error", msg @@ '手机号' AS "手机号", msg @@ '手机' AS "手机", msg @@ '机号' AS "机号", msg @@ '18888888888' AS "18888888888", msg @@ '农业' AS "农业", msg @@ 'timeout' AS "timeout", msg @@ 'user' AS "user" FROM ft_zh_tantivy ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ 'world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ 'id' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ 'error' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ '手机号' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ '手机' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ '机号' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ '18888888888' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ '农业' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ 'timeout' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg @@ 'user' ORDER BY ts;
+
+SELECT ts, msg LIKE '%world' AS "%world", msg LIKE 'hello\_world' AS "hello\_world", msg LIKE 'hello_world' AS "hello_world", msg LIKE '%id=%' AS "%id=%", msg LIKE 'trace%abc' AS "trace%abc", msg LIKE '%error%' AS "%error%", msg LIKE '%手机号1888%' AS "%手机号1888%", msg LIKE '%农业%' AS "%农业%", msg LIKE '连接timeout.%' AS "连接timeout.%", msg LIKE '%user-123%' AS "%user-123%" FROM ft_zh_tantivy ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE 'hello\_world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE 'hello_world' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%id=%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE 'trace%abc' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%error%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%手机号1888%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%农业%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '连接timeout.%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE msg LIKE '%user-123%' ORDER BY ts;
+
+SELECT ts, matches_term(lower(msg), 'quota') AS "matches_term(lower(msg), 'quota')", matches_term(lower(msg), 'vol') AS "matches_term(lower(msg), 'vol')", lower(msg) LIKE '%disk quota exceeded%' AS "lower(msg) LIKE '%disk quota exceeded%'", lower(msg) LIKE 'disk quota%' AS "lower(msg) LIKE 'disk quota%'" FROM ft_zh_tantivy ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE matches_term(lower(msg), 'quota') ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE matches_term(lower(msg), 'vol') ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE lower(msg) LIKE '%disk quota exceeded%' ORDER BY ts;
+
+SELECT ts, msg FROM ft_zh_tantivy WHERE lower(msg) LIKE 'disk quota%' ORDER BY ts;
+
+DROP TABLE ft_zh_tantivy;
diff --git a/tests/cases/standalone/common/information_schema/ssts.result b/tests/cases/standalone/common/information_schema/ssts.result
index 289b4599387..d7c7814a995 100644
--- a/tests/cases/standalone/common/information_schema/ssts.result
+++ b/tests/cases/standalone/common/information_schema/ssts.result
@@ -120,9 +120,9 @@ SELECT * FROM information_schema.ssts_index_meta ORDER BY meta_json;
 +----------------------------+---------------------------------------------------------------------------------------------+---------------+----------+---------------+--------------+-----------------+--------------------------------------+-----------------+----------------+-------------+------------+--------------+-----------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------+
 | table_dir                  | index_file_path                                                                             | region_id     | table_id | region_number | region_group | region_sequence | file_id                              | index_file_size | index_type     | target_type | target_key | target_json  | blob_size | meta_json                                                                                                                                                                                                                | node_id |
 +----------------------------+---------------------------------------------------------------------------------------------+---------------+----------+---------------+--------------+-----------------+--------------------------------------+-----------------+----------------+-------------+------------+--------------+-----------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------+
-| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","case_sensitive":false}}                                                                     |<NUM>|
-| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","case_sensitive":false}}                                                                     |<NUM>|
-| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","case_sensitive":false}}                                                                     |<NUM>|
+| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","bloom_version":2,"case_sensitive":false}}                                                   |<NUM>|
+| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","bloom_version":2,"case_sensitive":false}}                                                   |<NUM>|
+| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","bloom_version":2,"case_sensitive":false}}                                                   |<NUM>|
 | data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| bloom_filter   | column      |<NUM>| {"column":1} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1}}                                                                                                                              |<NUM>|
 | data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| bloom_filter   | column      |<NUM>| {"column":1} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1}}                                                                                                                              |<NUM>|
 | data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| bloom_filter   | column      |<NUM>| {"column":1} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1}}                                                                                                                              |<NUM>|
@@ -191,15 +191,15 @@ SELECT * FROM information_schema.ssts_index_meta ORDER BY meta_json;
 +----------------------------+---------------------------------------------------------------------------------------------+---------------+----------+---------------+--------------+-----------------+--------------------------------------+-----------------+----------------+-------------+------------+--------------+-----------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------+
 | table_dir                  | index_file_path                                                                             | region_id     | table_id | region_number | region_group | region_sequence | file_id                              | index_file_size | index_type     | target_type | target_key | target_json  | blob_size | meta_json                                                                                                                                                                                                                 | node_id |
 +----------------------------+---------------------------------------------------------------------------------------------+---------------+----------+---------------+--------------+-----------------+--------------------------------------+-----------------+----------------+-------------+------------+--------------+-----------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------+
-| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","case_sensitive":false}}                                                                      |<NUM>|
-| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","case_sensitive":false}}                                                                      |<NUM>|
-| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","case_sensitive":false}}                                                                      |<NUM>|
-| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","case_sensitive":false}}                                                                      |<NUM>|
+| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","bloom_version":2,"case_sensitive":false}}                                                    |<NUM>|
+| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","bloom_version":2,"case_sensitive":false}}                                                    |<NUM>|
+| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","bloom_version":2,"case_sensitive":false}}                                                    |<NUM>|
+| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","bloom_version":2,"case_sensitive":false}}                                                    |<NUM>|
 | data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| bloom_filter   | column      |<NUM>| {"column":1} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1}}                                                                                                                               |<NUM>|
 | data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| bloom_filter   | column      |<NUM>| {"column":1} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1}}                                                                                                                               |<NUM>|
 | data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| bloom_filter   | column      |<NUM>| {"column":1} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1}}                                                                                                                               |<NUM>|
 | data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| bloom_filter   | column      |<NUM>| {"column":1} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":1,"rows_per_segment":10240,"segment_count":1}}                                                                                                                               |<NUM>|
-| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":2,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","case_sensitive":false}}                                                                      |<NUM>|
+| data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| fulltext_bloom | column      |<NUM>| {"column":2} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":2,"rows_per_segment":10240,"segment_count":1},"fulltext":{"analyzer":"English","bloom_version":2,"case_sensitive":false}}                                                    |<NUM>|
 | data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| bloom_filter   | column      |<NUM>| {"column":1} |<NUM>| {"bloom":{"bloom_filter_size":64,"row_count":2,"rows_per_segment":10240,"segment_count":1}}                                                                                                                               |<NUM>|
 | data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| inverted       | column      |<NUM>| {"column":0} |<NUM>| {"inverted":{"base_offset":0,"bitmap_type":"Roaring","fst_size":55,"inverted_index_size":81,"null_bitmap_size":8,"relative_fst_offset":26,"relative_null_bitmap_offset":0,"segment_row_count":1024,"total_row_count":1}}  |<NUM>|
 | data/greptime/public/<TABLE_ID>/ | data/greptime/public/<TABLE_ID>/<REGION_ID>_<REGION_NUMBER>/index/<UUID>.puffin |<NUM>|<NUM>|<NUM>|<NUM>|<NUM>| <UUID> |<NUM>| inverted       | column      |<NUM>| {"column":0} |<NUM>| {"inverted":{"base_offset":0,"bitmap_type":"Roaring","fst_size":55,"inverted_index_size":81,"null_bitmap_size":8,"relative_fst_offset":26,"relative_null_bitmap_offset":0,"segment_row_count":1024,"total_row_count":1}}  |<NUM>|
diff --git a/tests/cases/standalone/common/join/merge_scan_left_join.result b/tests/cases/standalone/common/join/merge_scan_left_join.result
new file mode 100644
index 00000000000..b50ff0f5bd5
--- /dev/null
+++ b/tests/cases/standalone/common/join/merge_scan_left_join.result
@@ -0,0 +1,148 @@
+-- Regression coverage for issues 9456/9492 (PR 9491): preserve merge-scan
+-- results for a pruned left join over partitioned append data.
+CREATE TABLE merge_left_data (
+  k STRING,
+  kind STRING,
+  ts TIMESTAMP TIME INDEX,
+  PRIMARY KEY (k, kind)
+)
+PARTITION ON COLUMNS (k) (
+  k < '1', k >= '1' AND k < '2', k >= '2' AND k < '3',
+  k >= '3' AND k < '4', k >= '4' AND k < '5', k >= '5' AND k < '6',
+  k >= '6' AND k < '7', k >= '7' AND k < '8', k >= '8' AND k < '9',
+  k >= '9' AND k < 'a', k >= 'a' AND k < 'b', k >= 'b' AND k < 'c',
+  k >= 'c' AND k < 'd', k >= 'd' AND k < 'e', k >= 'e' AND k < 'f',
+  k >= 'f'
+)
+ENGINE=mito WITH (append_mode = 'true');
+
+Affected Rows: 0
+
+INSERT INTO merge_left_data VALUES
+  ('0', 'root', '2026-10-09 00:00:00'),
+  ('1', 'root', '2026-10-09 00:00:00'),
+  ('2', 'root', '2026-10-09 00:00:00'),
+  ('3', 'root', '2026-10-09 00:00:00'),
+  ('4', 'root', '2026-10-09 00:00:00'),
+  ('5', 'root', '2026-10-09 00:00:00'),
+  ('6', 'root', '2026-10-09 00:00:00'),
+  ('7', 'root', '2026-10-09 00:00:00'),
+  ('8', 'root', '2026-10-09 00:00:00'),
+  ('9', 'root', '2026-10-09 00:00:00'),
+  ('a', 'root', '2026-10-09 00:00:00'),
+  ('b', 'root', '2026-10-09 00:00:00'),
+  ('c', 'root', '2026-10-09 00:00:00'),
+  ('d', 'root', '2026-10-09 00:00:00'),
+  ('e', 'root', '2026-10-09 00:00:00'),
+  ('f', 'root', '2026-10-09 00:00:00'),
+  ('z', 'root', '2026-10-09 00:00:00'),
+  ('0', 'child', '2026-10-09 00:00:00'), ('0', 'child', '2026-10-09 00:00:00'), ('0', 'child', '2026-10-09 00:00:00'),
+  ('1', 'child', '2026-10-09 00:00:00'), ('1', 'child', '2026-10-09 00:00:00'), ('1', 'child', '2026-10-09 00:00:00'),
+  ('2', 'child', '2026-10-09 00:00:00'), ('2', 'child', '2026-10-09 00:00:00'), ('2', 'child', '2026-10-09 00:00:00'),
+  ('3', 'child', '2026-10-09 00:00:00'), ('3', 'child', '2026-10-09 00:00:00'), ('3', 'child', '2026-10-09 00:00:00'),
+  ('4', 'child', '2026-10-09 00:00:00'), ('4', 'child', '2026-10-09 00:00:00'), ('4', 'child', '2026-10-09 00:00:00'),
+  ('5', 'child', '2026-10-09 00:00:00'), ('5', 'child', '2026-10-09 00:00:00'), ('5', 'child', '2026-10-09 00:00:00'),
+  ('6', 'child', '2026-10-09 00:00:00'), ('6', 'child', '2026-10-09 00:00:00'), ('6', 'child', '2026-10-09 00:00:00'),
+  ('7', 'child', '2026-10-09 00:00:00'), ('7', 'child', '2026-10-09 00:00:00'), ('7', 'child', '2026-10-09 00:00:00'),
+  ('8', 'child', '2026-10-09 00:00:00'), ('8', 'child', '2026-10-09 00:00:00'), ('8', 'child', '2026-10-09 00:00:00'),
+  ('9', 'child', '2026-10-09 00:00:00'), ('9', 'child', '2026-10-09 00:00:00'), ('9', 'child', '2026-10-09 00:00:00'),
+  ('a', 'child', '2026-10-09 00:00:00'), ('a', 'child', '2026-10-09 00:00:00'), ('a', 'child', '2026-10-09 00:00:00'),
+  ('b', 'child', '2026-10-09 00:00:00'), ('b', 'child', '2026-10-09 00:00:00'), ('b', 'child', '2026-10-09 00:00:00'),
+  ('c', 'child', '2026-10-09 00:00:00'), ('c', 'child', '2026-10-09 00:00:00'), ('c', 'child', '2026-10-09 00:00:00'),
+  ('d', 'child', '2026-10-09 00:00:00'), ('d', 'child', '2026-10-09 00:00:00'), ('d', 'child', '2026-10-09 00:00:00'),
+  ('e', 'child', '2026-10-09 00:00:00'), ('e', 'child', '2026-10-09 00:00:00'), ('e', 'child', '2026-10-09 00:00:00'),
+  ('f', 'child', '2026-10-09 00:00:00'), ('f', 'child', '2026-10-09 00:00:00'), ('f', 'child', '2026-10-09 00:00:00');
+
+Affected Rows: 65
+
+-- Full join: 17 roots, 16 matched roots, 48 child rows.
+SELECT r.k, c.n
+FROM (SELECT k FROM merge_left_data WHERE kind = 'root') r
+LEFT JOIN (
+  SELECT k, COUNT(*) AS n FROM merge_left_data WHERE kind = 'child' GROUP BY k
+) c ON r.k = c.k
+ORDER BY r.k;
+
++---+---+
+| k | n |
++---+---+
+| 0 | 3 |
+| 1 | 3 |
+| 2 | 3 |
+| 3 | 3 |
+| 4 | 3 |
+| 5 | 3 |
+| 6 | 3 |
+| 7 | 3 |
+| 8 | 3 |
+| 9 | 3 |
+| a | 3 |
+| b | 3 |
+| c | 3 |
+| d | 3 |
+| e | 3 |
+| f | 3 |
+| z |   |
++---+---+
+
+-- Assert partitioned hash join and both hash repartition keys at SQLness N=4.
+-- SQLNESS REPLACE (peers.*) peers=REDACTED
+EXPLAIN SELECT r.k, c.n
+FROM (SELECT k FROM merge_left_data WHERE kind = 'root' AND k >= '1' AND k < '5') r
+LEFT JOIN (
+  SELECT k, COUNT(*) AS n FROM merge_left_data
+  WHERE kind = 'child' AND k < '4' GROUP BY k
+) c ON r.k = c.k
+ORDER BY r.k;
+
++---------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                                                                                                                                                                                                                                                                                                  |
++---------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | Sort: r.k ASC NULLS LAST                                                                                                                                                                                                                                                                                                                                                                                                              |
+|               |   Projection: r.k, c.n                                                                                                                                                                                                                                                                                                                                                                                                                |
+|               |     Left Join: r.k = c.k                                                                                                                                                                                                                                                                                                                                                                                                              |
+|               |       MergeScan [is_placeholder=false, remote_input=[                                                                                                                                                                                                                                                                                                                                                                                 |
+|               | SubqueryAlias: r                                                                                                                                                                                                                                                                                                                                                                                                                      |
+|               |   Projection: merge_left_data.k                                                                                                                                                                                                                                                                                                                                                                                                       |
+|               |     Filter: merge_left_data.kind = Utf8("root") AND merge_left_data.k >= Utf8("1") AND merge_left_data.k < Utf8("5")                                                                                                                                                                                                                                                                                                                  |
+|               |       TableScan: merge_left_data, partial_filters=[merge_left_data.kind = Utf8("root"), merge_left_data.k >= Utf8("1"), merge_left_data.k < Utf8("5")]                                                                                                                                                                                                                                                                                |
+|               | ]]                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+|               |       MergeScan [is_placeholder=false, remote_input=[                                                                                                                                                                                                                                                                                                                                                                                 |
+|               | SubqueryAlias: c                                                                                                                                                                                                                                                                                                                                                                                                                      |
+|               |   Projection: merge_left_data.k, count(Int64(1)) AS count(*) AS n                                                                                                                                                                                                                                                                                                                                                                     |
+|               |     Aggregate: groupBy=[[merge_left_data.k]], aggr=[[count(merge_left_data.ts) AS count(Int64(1))]]                                                                                                                                                                                                                                                                                                                                   |
+|               |       Filter: merge_left_data.kind = Utf8("child") AND merge_left_data.k < Utf8("4") AND merge_left_data.k IS NOT NULL                                                                                                                                                                                                                                                                                                                |
+|               |         TableScan: merge_left_data, partial_filters=[merge_left_data.kind = Utf8("child"), merge_left_data.k < Utf8("4"), merge_left_data.k IS NOT NULL]                                                                                                                                                                                                                                                                              |
+|               | ]]                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| physical_plan | SortPreservingMergeExec: [k@0 ASC NULLS LAST]                                                                                                                                                                                                                                                                                                                                                                                         |
+|               |   SortExec: expr=[k@0 ASC NULLS LAST], preserve_partitioning=[true]                                                                                                                                                                                                                                                                                                                                                                   |
+|               |     HashJoinExec: mode=Partitioned, join_type=Left, on=[(k@0, k@0)], projection=[k@0, n@2]                                                                                                                                                                                                                                                                                                                                            |
+|               |       RepartitionExec: partitioning=Hash([k@0], 4), input_partitions=4                                                                                                                                                                                                                                                                                                                                                                |
+|               |         MergeScanExec: peers=REDACTED
+|               |       RepartitionExec: partitioning=Hash([k@0], 4), input_partitions=4                                                                                                                                                                                                                                                                                                                                                                |
+|               |         MergeScanExec: peers=REDACTED
+|               |                                                                                                                                                                                                                                                                                                                                                                                                                                       |
++---------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+-- Four roots, three matches, nine child rows; key 4 remains with NULL n.
+SELECT r.k, c.n
+FROM (SELECT k FROM merge_left_data WHERE kind = 'root' AND k >= '1' AND k < '5') r
+LEFT JOIN (
+  SELECT k, COUNT(*) AS n FROM merge_left_data
+  WHERE kind = 'child' AND k < '4' GROUP BY k
+) c ON r.k = c.k
+ORDER BY r.k;
+
++---+---+
+| k | n |
++---+---+
+| 1 | 3 |
+| 2 | 3 |
+| 3 | 3 |
+| 4 |   |
++---+---+
+
+DROP TABLE merge_left_data;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/join/merge_scan_left_join.sql b/tests/cases/standalone/common/join/merge_scan_left_join.sql
new file mode 100644
index 00000000000..72b5f75db7b
--- /dev/null
+++ b/tests/cases/standalone/common/join/merge_scan_left_join.sql
@@ -0,0 +1,81 @@
+-- Regression coverage for issues 9456/9492 (PR 9491): preserve merge-scan
+-- results for a pruned left join over partitioned append data.
+CREATE TABLE merge_left_data (
+  k STRING,
+  kind STRING,
+  ts TIMESTAMP TIME INDEX,
+  PRIMARY KEY (k, kind)
+)
+PARTITION ON COLUMNS (k) (
+  k < '1', k >= '1' AND k < '2', k >= '2' AND k < '3',
+  k >= '3' AND k < '4', k >= '4' AND k < '5', k >= '5' AND k < '6',
+  k >= '6' AND k < '7', k >= '7' AND k < '8', k >= '8' AND k < '9',
+  k >= '9' AND k < 'a', k >= 'a' AND k < 'b', k >= 'b' AND k < 'c',
+  k >= 'c' AND k < 'd', k >= 'd' AND k < 'e', k >= 'e' AND k < 'f',
+  k >= 'f'
+)
+ENGINE=mito WITH (append_mode = 'true');
+
+INSERT INTO merge_left_data VALUES
+  ('0', 'root', '2026-10-09 00:00:00'),
+  ('1', 'root', '2026-10-09 00:00:00'),
+  ('2', 'root', '2026-10-09 00:00:00'),
+  ('3', 'root', '2026-10-09 00:00:00'),
+  ('4', 'root', '2026-10-09 00:00:00'),
+  ('5', 'root', '2026-10-09 00:00:00'),
+  ('6', 'root', '2026-10-09 00:00:00'),
+  ('7', 'root', '2026-10-09 00:00:00'),
+  ('8', 'root', '2026-10-09 00:00:00'),
+  ('9', 'root', '2026-10-09 00:00:00'),
+  ('a', 'root', '2026-10-09 00:00:00'),
+  ('b', 'root', '2026-10-09 00:00:00'),
+  ('c', 'root', '2026-10-09 00:00:00'),
+  ('d', 'root', '2026-10-09 00:00:00'),
+  ('e', 'root', '2026-10-09 00:00:00'),
+  ('f', 'root', '2026-10-09 00:00:00'),
+  ('z', 'root', '2026-10-09 00:00:00'),
+  ('0', 'child', '2026-10-09 00:00:00'), ('0', 'child', '2026-10-09 00:00:00'), ('0', 'child', '2026-10-09 00:00:00'),
+  ('1', 'child', '2026-10-09 00:00:00'), ('1', 'child', '2026-10-09 00:00:00'), ('1', 'child', '2026-10-09 00:00:00'),
+  ('2', 'child', '2026-10-09 00:00:00'), ('2', 'child', '2026-10-09 00:00:00'), ('2', 'child', '2026-10-09 00:00:00'),
+  ('3', 'child', '2026-10-09 00:00:00'), ('3', 'child', '2026-10-09 00:00:00'), ('3', 'child', '2026-10-09 00:00:00'),
+  ('4', 'child', '2026-10-09 00:00:00'), ('4', 'child', '2026-10-09 00:00:00'), ('4', 'child', '2026-10-09 00:00:00'),
+  ('5', 'child', '2026-10-09 00:00:00'), ('5', 'child', '2026-10-09 00:00:00'), ('5', 'child', '2026-10-09 00:00:00'),
+  ('6', 'child', '2026-10-09 00:00:00'), ('6', 'child', '2026-10-09 00:00:00'), ('6', 'child', '2026-10-09 00:00:00'),
+  ('7', 'child', '2026-10-09 00:00:00'), ('7', 'child', '2026-10-09 00:00:00'), ('7', 'child', '2026-10-09 00:00:00'),
+  ('8', 'child', '2026-10-09 00:00:00'), ('8', 'child', '2026-10-09 00:00:00'), ('8', 'child', '2026-10-09 00:00:00'),
+  ('9', 'child', '2026-10-09 00:00:00'), ('9', 'child', '2026-10-09 00:00:00'), ('9', 'child', '2026-10-09 00:00:00'),
+  ('a', 'child', '2026-10-09 00:00:00'), ('a', 'child', '2026-10-09 00:00:00'), ('a', 'child', '2026-10-09 00:00:00'),
+  ('b', 'child', '2026-10-09 00:00:00'), ('b', 'child', '2026-10-09 00:00:00'), ('b', 'child', '2026-10-09 00:00:00'),
+  ('c', 'child', '2026-10-09 00:00:00'), ('c', 'child', '2026-10-09 00:00:00'), ('c', 'child', '2026-10-09 00:00:00'),
+  ('d', 'child', '2026-10-09 00:00:00'), ('d', 'child', '2026-10-09 00:00:00'), ('d', 'child', '2026-10-09 00:00:00'),
+  ('e', 'child', '2026-10-09 00:00:00'), ('e', 'child', '2026-10-09 00:00:00'), ('e', 'child', '2026-10-09 00:00:00'),
+  ('f', 'child', '2026-10-09 00:00:00'), ('f', 'child', '2026-10-09 00:00:00'), ('f', 'child', '2026-10-09 00:00:00');
+
+-- Full join: 17 roots, 16 matched roots, 48 child rows.
+SELECT r.k, c.n
+FROM (SELECT k FROM merge_left_data WHERE kind = 'root') r
+LEFT JOIN (
+  SELECT k, COUNT(*) AS n FROM merge_left_data WHERE kind = 'child' GROUP BY k
+) c ON r.k = c.k
+ORDER BY r.k;
+
+-- Assert partitioned hash join and both hash repartition keys at SQLness N=4.
+-- SQLNESS REPLACE (peers.*) peers=REDACTED
+EXPLAIN SELECT r.k, c.n
+FROM (SELECT k FROM merge_left_data WHERE kind = 'root' AND k >= '1' AND k < '5') r
+LEFT JOIN (
+  SELECT k, COUNT(*) AS n FROM merge_left_data
+  WHERE kind = 'child' AND k < '4' GROUP BY k
+) c ON r.k = c.k
+ORDER BY r.k;
+
+-- Four roots, three matches, nine child rows; key 4 remains with NULL n.
+SELECT r.k, c.n
+FROM (SELECT k FROM merge_left_data WHERE kind = 'root' AND k >= '1' AND k < '5') r
+LEFT JOIN (
+  SELECT k, COUNT(*) AS n FROM merge_left_data
+  WHERE kind = 'child' AND k < '4' GROUP BY k
+) c ON r.k = c.k
+ORDER BY r.k;
+
+DROP TABLE merge_left_data;
diff --git a/tests/cases/standalone/common/join/merge_scan_semi_join.result b/tests/cases/standalone/common/join/merge_scan_semi_join.result
new file mode 100644
index 00000000000..5eb70b1241b
--- /dev/null
+++ b/tests/cases/standalone/common/join/merge_scan_semi_join.result
@@ -0,0 +1,104 @@
+-- Regression coverage for issues 9456/9492 (PR 9491): preserve IN/semi-join
+-- results when merge-scan inputs are distributed across hash partitions.
+CREATE TABLE merge_semi_data (
+  ts TIMESTAMP TIME INDEX,
+  key_id INT,
+  is_match BOOLEAN,
+  PRIMARY KEY (key_id)
+)
+PARTITION ON COLUMNS (key_id) (
+  key_id < 10,
+  key_id >= 10 AND key_id < 20,
+  key_id >= 20 AND key_id < 30,
+  key_id >= 30
+)
+ENGINE=mito;
+
+Affected Rows: 0
+
+-- Three keys in each of four ranges; each key has a false row then a true row.
+INSERT INTO merge_semi_data VALUES
+  ('2026-10-09 00:00:00', 1, false), ('2026-10-09 00:00:01', 1, true),
+  ('2026-10-09 00:00:00', 2, false), ('2026-10-09 00:00:01', 2, true),
+  ('2026-10-09 00:00:00', 3, false), ('2026-10-09 00:00:01', 3, true),
+  ('2026-10-09 00:00:00', 11, false), ('2026-10-09 00:00:01', 11, true),
+  ('2026-10-09 00:00:00', 12, false), ('2026-10-09 00:00:01', 12, true),
+  ('2026-10-09 00:00:00', 13, false), ('2026-10-09 00:00:01', 13, true),
+  ('2026-10-09 00:00:00', 21, false), ('2026-10-09 00:00:01', 21, true),
+  ('2026-10-09 00:00:00', 22, false), ('2026-10-09 00:00:01', 22, true),
+  ('2026-10-09 00:00:00', 23, false), ('2026-10-09 00:00:01', 23, true),
+  ('2026-10-09 00:00:00', 31, false), ('2026-10-09 00:00:01', 31, true),
+  ('2026-10-09 00:00:00', 32, false), ('2026-10-09 00:00:01', 32, true),
+  ('2026-10-09 00:00:00', 33, false), ('2026-10-09 00:00:01', 33, true);
+
+Affected Rows: 24
+
+-- Check the plan retains the partitioned left-semi join and hash keys (N=4).
+-- SQLNESS REPLACE (peers.*) peers=REDACTED
+EXPLAIN SELECT key_id, MIN(ts) AS first_ts
+FROM merge_semi_data
+WHERE key_id IN (
+  SELECT key_id FROM merge_semi_data WHERE is_match = true
+)
+GROUP BY key_id ORDER BY key_id;
+
++---------------+---------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                  |
++---------------+---------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | Sort: merge_semi_data.key_id ASC NULLS LAST                                                                                           |
+|               |   Projection: merge_semi_data.key_id, min(merge_semi_data.ts) AS first_ts                                                             |
+|               |     Aggregate: groupBy=[[merge_semi_data.key_id]], aggr=[[min(merge_semi_data.ts)]]                                                   |
+|               |       LeftSemi Join: merge_semi_data.key_id = __correlated_sq_1.key_id                                                                |
+|               |         Projection: merge_semi_data.ts, merge_semi_data.key_id                                                                        |
+|               |           MergeScan [is_placeholder=false, remote_input=[                                                                             |
+|               | Filter: merge_semi_data.key_id IS NOT NULL                                                                                            |
+|               |   TableScan: merge_semi_data, partial_filters=[merge_semi_data.key_id IS NOT NULL]                                                    |
+|               | ]]                                                                                                                                    |
+|               |         MergeScan [is_placeholder=false, remote_input=[                                                                               |
+|               | SubqueryAlias: __correlated_sq_1                                                                                                      |
+|               |   Projection: merge_semi_data.key_id                                                                                                  |
+|               |     Filter: merge_semi_data.is_match AND merge_semi_data.key_id IS NOT NULL                                                           |
+|               |       TableScan: merge_semi_data, partial_filters=[merge_semi_data.is_match, merge_semi_data.key_id IS NOT NULL]                      |
+|               | ]]                                                                                                                                    |
+| physical_plan | SortPreservingMergeExec: [key_id@0 ASC NULLS LAST]                                                                                    |
+|               |   ProjectionExec: expr=[key_id@0 as key_id, min(merge_semi_data.ts)@1 as first_ts]                                                    |
+|               |     SortExec: expr=[key_id@0 ASC NULLS LAST], preserve_partitioning=[true]                                                            |
+|               |       AggregateExec: mode=SinglePartitioned, gby=[key_id@1 as key_id], aggr=[min(merge_semi_data.ts)]                                 |
+|               |         HashJoinExec: mode=Partitioned, join_type=LeftSemi, on=[(key_id@1, key_id@0)]                                                 |
+|               |           RepartitionExec: partitioning=Hash([key_id@1], 4), input_partitions=4                                                       |
+|               |             ProjectionExec: expr=[ts@0 as ts, key_id@1 as key_id]                                                                     |
+|               |               MergeScanExec: peers=REDACTED
+|               |           RepartitionExec: partitioning=Hash([key_id@0], 4), input_partitions=4                                                       |
+|               |             MergeScanExec: peers=REDACTED
+|               |                                                                                                                                       |
++---------------+---------------------------------------------------------------------------------------------------------------------------------------+
+
+-- Every key matches and reports its earliest (false-row) timestamp.
+SELECT key_id, MIN(ts) AS first_ts
+FROM merge_semi_data
+WHERE key_id IN (
+  SELECT key_id FROM merge_semi_data WHERE is_match = true
+)
+GROUP BY key_id ORDER BY key_id;
+
++--------+---------------------+
+| key_id | first_ts            |
++--------+---------------------+
+| 1      | 2026-10-09T00:00:00 |
+| 2      | 2026-10-09T00:00:00 |
+| 3      | 2026-10-09T00:00:00 |
+| 11     | 2026-10-09T00:00:00 |
+| 12     | 2026-10-09T00:00:00 |
+| 13     | 2026-10-09T00:00:00 |
+| 21     | 2026-10-09T00:00:00 |
+| 22     | 2026-10-09T00:00:00 |
+| 23     | 2026-10-09T00:00:00 |
+| 31     | 2026-10-09T00:00:00 |
+| 32     | 2026-10-09T00:00:00 |
+| 33     | 2026-10-09T00:00:00 |
++--------+---------------------+
+
+DROP TABLE merge_semi_data;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/join/merge_scan_semi_join.sql b/tests/cases/standalone/common/join/merge_scan_semi_join.sql
new file mode 100644
index 00000000000..34e7b226592
--- /dev/null
+++ b/tests/cases/standalone/common/join/merge_scan_semi_join.sql
@@ -0,0 +1,49 @@
+-- Regression coverage for issues 9456/9492 (PR 9491): preserve IN/semi-join
+-- results when merge-scan inputs are distributed across hash partitions.
+CREATE TABLE merge_semi_data (
+  ts TIMESTAMP TIME INDEX,
+  key_id INT,
+  is_match BOOLEAN,
+  PRIMARY KEY (key_id)
+)
+PARTITION ON COLUMNS (key_id) (
+  key_id < 10,
+  key_id >= 10 AND key_id < 20,
+  key_id >= 20 AND key_id < 30,
+  key_id >= 30
+)
+ENGINE=mito;
+
+-- Three keys in each of four ranges; each key has a false row then a true row.
+INSERT INTO merge_semi_data VALUES
+  ('2026-10-09 00:00:00', 1, false), ('2026-10-09 00:00:01', 1, true),
+  ('2026-10-09 00:00:00', 2, false), ('2026-10-09 00:00:01', 2, true),
+  ('2026-10-09 00:00:00', 3, false), ('2026-10-09 00:00:01', 3, true),
+  ('2026-10-09 00:00:00', 11, false), ('2026-10-09 00:00:01', 11, true),
+  ('2026-10-09 00:00:00', 12, false), ('2026-10-09 00:00:01', 12, true),
+  ('2026-10-09 00:00:00', 13, false), ('2026-10-09 00:00:01', 13, true),
+  ('2026-10-09 00:00:00', 21, false), ('2026-10-09 00:00:01', 21, true),
+  ('2026-10-09 00:00:00', 22, false), ('2026-10-09 00:00:01', 22, true),
+  ('2026-10-09 00:00:00', 23, false), ('2026-10-09 00:00:01', 23, true),
+  ('2026-10-09 00:00:00', 31, false), ('2026-10-09 00:00:01', 31, true),
+  ('2026-10-09 00:00:00', 32, false), ('2026-10-09 00:00:01', 32, true),
+  ('2026-10-09 00:00:00', 33, false), ('2026-10-09 00:00:01', 33, true);
+
+-- Check the plan retains the partitioned left-semi join and hash keys (N=4).
+-- SQLNESS REPLACE (peers.*) peers=REDACTED
+EXPLAIN SELECT key_id, MIN(ts) AS first_ts
+FROM merge_semi_data
+WHERE key_id IN (
+  SELECT key_id FROM merge_semi_data WHERE is_match = true
+)
+GROUP BY key_id ORDER BY key_id;
+
+-- Every key matches and reports its earliest (false-row) timestamp.
+SELECT key_id, MIN(ts) AS first_ts
+FROM merge_semi_data
+WHERE key_id IN (
+  SELECT key_id FROM merge_semi_data WHERE is_match = true
+)
+GROUP BY key_id ORDER BY key_id;
+
+DROP TABLE merge_semi_data;
diff --git a/tests/cases/standalone/common/order/order_by_exceptions.result b/tests/cases/standalone/common/order/order_by_exceptions.result
index bdf215f8f26..dc964ebfe09 100644
--- a/tests/cases/standalone/common/order/order_by_exceptions.result
+++ b/tests/cases/standalone/common/order/order_by_exceptions.result
@@ -83,7 +83,7 @@ EXPLAIN SELECT a % 2, b FROM test UNION SELECT a % 2 AS k, b FROM test ORDER BY
 |               |     RepartitionExec: REDACTED
 |               |       AggregateExec: mode=Partial, gby=[test.a % Int64(2)@0 as test.a % Int64(2), b@1 as b], aggr=[]      |
 |               |         RepartitionExec: REDACTED
-|               |           InterleaveExec                                                                                  |
+|               |           UnionExec                                                                                       |
 |               |             MergeScanExec: REDACTED
 |               |             MergeScanExec: REDACTED
 |               |                                                                                                           |
diff --git a/tests/cases/standalone/common/promql/at_modifier.result b/tests/cases/standalone/common/promql/at_modifier.result
index 0a19eac692c..27570231833 100644
--- a/tests/cases/standalone/common/promql/at_modifier.result
+++ b/tests/cases/standalone/common/promql/at_modifier.result
@@ -621,9 +621,6 @@ TQL EVAL (330, 390, '60s') predict_linear(at_modifier_gauge{host="a"}[5m] offset
 -- on its own and `timestamp()` reports the timestamp of the sample the anchor selected at every
 -- step (300s here). Its plan keeps the anchored selection below the replay of the grid and projects
 -- the timestamp above it.
---
--- Only an `@` without an `offset` is asserted here: the value of `timestamp()` for an anchored
--- selector that also carries an `offset` is a pre-existing question of its own, out of scope here.
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 240, '60s') timestamp(at_modifier_gauge @ 300);
 
@@ -642,95 +639,105 @@ TQL EVAL (0, 240, '60s') timestamp(at_modifier_gauge @ 300);
 | 1970-01-01T00:04:00 | 300.0 | b    |
 +---------------------+-------+------+
 
+-- With an `offset`, the anchor selects the sample at 240s, and `timestamp()` reports 240s.
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 120, '60s') timestamp(at_modifier_gauge @ 300 offset 1m);
+
++---------------------+-------+------+
+| ts                  | value | host |
++---------------------+-------+------+
+| 1970-01-01T00:00:00 | 240.0 | a    |
+| 1970-01-01T00:00:00 | 240.0 | b    |
+| 1970-01-01T00:01:00 | 240.0 | a    |
+| 1970-01-01T00:01:00 | 240.0 | b    |
+| 1970-01-01T00:02:00 | 240.0 | a    |
+| 1970-01-01T00:02:00 | 240.0 | b    |
++---------------------+-------+------+
+
 -- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
 -- SQLNESS REPLACE (peers.*) REDACTED
 -- SQLNESS REPLACE (Hash.*) REDACTED
 -- SQLNESS REPLACE (RepartitionExec:.*) RepartitionExec: REDACTED
 TQL EXPLAIN (0, 240, '60s') timestamp(at_modifier_gauge @ 300);
 
-+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| plan_type     | plan                                                                                                                                                                                                                                                                                 |
-+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                                                                                                                                                                      |
-|               | Projection: at_modifier_gauge.ts, value AS value, at_modifier_gauge.host                                                                                                                                                                                                             |
-|               |   Projection: at_modifier_gauge.ts, __promql_timestamp_value_ AS value, at_modifier_gauge.host                                                                                                                                                                                       |
-|               |     PromInstantManipulate: range=[0..240000], lookback=[240001], interval=[60000], time index=[ts]                                                                                                                                                                                   |
-|               |       PromInstantManipulate: range=[0..0], lookback=[300000], interval=[60000], time index=[ts]                                                                                                                                                                                      |
-|               |         Projection: at_modifier_gauge.ts, at_modifier_gauge.val, at_modifier_gauge.host, CAST(CAST(CAST(CAST(CAST(at_modifier_gauge.ts AS Int64) AS Decimal128(19, 0)) AS Decimal128(21, 0)) + Decimal128(0,19,0) AS Int64) AS Float64) / Float64(1000) AS __promql_timestamp_value_ |
-|               |           PromSeriesNormalize: offset=[-300000], time index=[ts], filter NaN: [false]                                                                                                                                                                                                |
-|               |             PromSeriesDivide: tags=["host"]                                                                                                                                                                                                                                          |
-|               |               Sort: at_modifier_gauge.host ASC NULLS FIRST, at_modifier_gauge.ts ASC NULLS FIRST                                                                                                                                                                                     |
-|               |                 Filter: at_modifier_gauge.ts >= TimestampMillisecond(1, None) AND at_modifier_gauge.ts <= TimestampMillisecond(300000, None)                                                                                                                                         |
-|               |                   TableScan: at_modifier_gauge, partial_filters=[at_modifier_gauge.ts >= TimestampMillisecond(1, None), at_modifier_gauge.ts <= TimestampMillisecond(300000, None)]                                                                                                  |
-|               | ]]                                                                                                                                                                                                                                                                                   |
-| physical_plan | CooperativeExec                                                                                                                                                                                                                                                                      |
++---------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                                                         |
++---------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                                                                              |
+|               | Projection: at_modifier_gauge.ts, value AS value, at_modifier_gauge.host                                                                                                                     |
+|               |   Projection: at_modifier_gauge.ts, __promql_timestamp_value_ AS value, at_modifier_gauge.host                                                                                               |
+|               |     Filter: at_modifier_gauge.val IS NOT NULL                                                                                                                                                |
+|               |       PromInstantManipulate: range=[0..240000], lookback=[240001], interval=[60000], time index=[ts]                                                                                         |
+|               |         PromInstantManipulate: range=[0..0], lookback=[300000], interval=[60000], time index=[ts]                                                                                            |
+|               |           Projection: at_modifier_gauge.ts, at_modifier_gauge.val, at_modifier_gauge.host, CAST(CAST(at_modifier_gauge.ts AS Int64) AS Float64) / Float64(1000) AS __promql_timestamp_value_ |
+|               |             PromSeriesNormalize: offset=[-300000], time index=[ts], filter NaN: [false]                                                                                                      |
+|               |               PromSeriesDivide: tags=["host"]                                                                                                                                                |
+|               |                 Sort: at_modifier_gauge.host ASC NULLS FIRST, at_modifier_gauge.ts ASC NULLS FIRST                                                                                           |
+|               |                   Filter: at_modifier_gauge.ts >= TimestampMillisecond(1, None) AND at_modifier_gauge.ts <= TimestampMillisecond(300000, None)                                               |
+|               |                     TableScan: at_modifier_gauge, partial_filters=[at_modifier_gauge.ts >= TimestampMillisecond(1, None), at_modifier_gauge.ts <= TimestampMillisecond(300000, None)]        |
+|               | ]]                                                                                                                                                                                           |
+| physical_plan | CooperativeExec                                                                                                                                                                              |
 |               |   MergeScanExec: REDACTED
-|               |                                                                                                                                                                                                                                                                                      |
-+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|               |                                                                                                                                                                                              |
++---------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 -- 11. `label_join` above an anchored selector. The call rewrites the label the input series are
--- told apart by (`host` becomes the empty string), so it is never promoted: it must stay above the
+-- told apart by (`host` becomes `a-a` and `b-b`), so it is never promoted: it must stay above the
 -- per-series replay of the selector and be evaluated at every step. Both hosts are still reported,
 -- with their own value, at every step. A promoted `label_join` would instead be replayed through
 -- the labels it just rewrote and report the two series as a single timeline, i.e. one mixed row
 -- per step.
---
--- The invariant asserted here is scoped to the replay: it must not drop or mix the input rows.
--- It is not a claim about the final PromQL semantics of this query: joining `host` to one value
--- leaves two samples with the same label set at the same timestamp, which Prometheus rejects,
--- while `label_join` does not validate that yet (`label_replace` errors on such a rewrite
--- instead). That duplicate-labelset validation gap is pre-existing and out of scope here.
 -- SQLNESS SORT_RESULT 3 1
-TQL EVAL (300, 480, '60s') label_join(at_modifier_gauge @ 300, "host", "", "");
+TQL EVAL (300, 480, '60s') label_join(at_modifier_gauge @ 300, "host", "-", "host", "host");
 
 +---------------------+------+------+
 | ts                  | val  | host |
 +---------------------+------+------+
-| 1970-01-01T00:05:00 | 12.0 |      |
-| 1970-01-01T00:05:00 | 5.0  |      |
-| 1970-01-01T00:06:00 | 12.0 |      |
-| 1970-01-01T00:06:00 | 5.0  |      |
-| 1970-01-01T00:07:00 | 12.0 |      |
-| 1970-01-01T00:07:00 | 5.0  |      |
-| 1970-01-01T00:08:00 | 12.0 |      |
-| 1970-01-01T00:08:00 | 5.0  |      |
+| 1970-01-01T00:05:00 | 12.0 | b-b  |
+| 1970-01-01T00:05:00 | 5.0  | a-a  |
+| 1970-01-01T00:06:00 | 12.0 | b-b  |
+| 1970-01-01T00:06:00 | 5.0  | a-a  |
+| 1970-01-01T00:07:00 | 12.0 | b-b  |
+| 1970-01-01T00:07:00 | 5.0  | a-a  |
+| 1970-01-01T00:08:00 | 12.0 | b-b  |
+| 1970-01-01T00:08:00 | 5.0  | a-a  |
 +---------------------+------+------+
 
 -- The same join below another call: neither is promoted, and both are evaluated at every step over
 -- the per-series replay of the anchored selector.
 -- SQLNESS SORT_RESULT 3 1
-TQL EVAL (300, 480, '60s') abs(label_join(at_modifier_gauge @ 300, "host", "", ""));
+TQL EVAL (300, 480, '60s') abs(label_join(at_modifier_gauge @ 300, "host", "-", "host", "host"));
 
 +---------------------+----------+------+
 | ts                  | abs(val) | host |
 +---------------------+----------+------+
-| 1970-01-01T00:05:00 | 12.0     |      |
-| 1970-01-01T00:05:00 | 5.0      |      |
-| 1970-01-01T00:06:00 | 12.0     |      |
-| 1970-01-01T00:06:00 | 5.0      |      |
-| 1970-01-01T00:07:00 | 12.0     |      |
-| 1970-01-01T00:07:00 | 5.0      |      |
-| 1970-01-01T00:08:00 | 12.0     |      |
-| 1970-01-01T00:08:00 | 5.0      |      |
+| 1970-01-01T00:05:00 | 12.0     | b-b  |
+| 1970-01-01T00:05:00 | 5.0      | a-a  |
+| 1970-01-01T00:06:00 | 12.0     | b-b  |
+| 1970-01-01T00:06:00 | 5.0      | a-a  |
+| 1970-01-01T00:07:00 | 12.0     | b-b  |
+| 1970-01-01T00:07:00 | 5.0      | a-a  |
+| 1970-01-01T00:08:00 | 12.0     | b-b  |
+| 1970-01-01T00:08:00 | 5.0      | a-a  |
 +---------------------+----------+------+
 
 -- A range call below the join is still promoted on its own (it is the direct call over the
 -- anchored range selector): the anchored window is folded once per series, and the join above that
 -- replay reports the rate of both hosts at every step.
 -- SQLNESS SORT_RESULT 3 1
-TQL EVAL (300, 480, '60s') label_join(rate(at_modifier_counter_total[5m] @ 300), "host", "", "");
+TQL EVAL (300, 480, '60s') label_join(rate(at_modifier_counter_total[5m] @ 300), "host", "-", "host", "host");
 
 +---------------------+------------------------------------------+------+
 | ts                  | prom_rate(ts_range,val,ts,Int64(300000)) | host |
 +---------------------+------------------------------------------+------+
-| 1970-01-01T00:05:00 | 0.5                                      |      |
-| 1970-01-01T00:05:00 | 1.0                                      |      |
-| 1970-01-01T00:06:00 | 0.5                                      |      |
-| 1970-01-01T00:06:00 | 1.0                                      |      |
-| 1970-01-01T00:07:00 | 0.5                                      |      |
-| 1970-01-01T00:07:00 | 1.0                                      |      |
-| 1970-01-01T00:08:00 | 0.5                                      |      |
-| 1970-01-01T00:08:00 | 1.0                                      |      |
+| 1970-01-01T00:05:00 | 0.5                                      | b-b  |
+| 1970-01-01T00:05:00 | 1.0                                      | a-a  |
+| 1970-01-01T00:06:00 | 0.5                                      | b-b  |
+| 1970-01-01T00:06:00 | 1.0                                      | a-a  |
+| 1970-01-01T00:07:00 | 0.5                                      | b-b  |
+| 1970-01-01T00:07:00 | 1.0                                      | a-a  |
+| 1970-01-01T00:08:00 | 0.5                                      | b-b  |
+| 1970-01-01T00:08:00 | 1.0                                      | a-a  |
 +---------------------+------------------------------------------+------+
 
 DROP TABLE at_modifier_gauge;
diff --git a/tests/cases/standalone/common/promql/at_modifier.sql b/tests/cases/standalone/common/promql/at_modifier.sql
index 9e9bc21a9c1..b4fd9d1a552 100644
--- a/tests/cases/standalone/common/promql/at_modifier.sql
+++ b/tests/cases/standalone/common/promql/at_modifier.sql
@@ -258,12 +258,13 @@ TQL EVAL (330, 390, '60s') predict_linear(at_modifier_gauge{host="a"}[5m] offset
 -- on its own and `timestamp()` reports the timestamp of the sample the anchor selected at every
 -- step (300s here). Its plan keeps the anchored selection below the replay of the grid and projects
 -- the timestamp above it.
---
--- Only an `@` without an `offset` is asserted here: the value of `timestamp()` for an anchored
--- selector that also carries an `offset` is a pre-existing question of its own, out of scope here.
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 240, '60s') timestamp(at_modifier_gauge @ 300);
 
+-- With an `offset`, the anchor selects the sample at 240s, and `timestamp()` reports 240s.
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 120, '60s') timestamp(at_modifier_gauge @ 300 offset 1m);
+
 -- SQLNESS REPLACE (RoundRobinBatch.*) REDACTED
 -- SQLNESS REPLACE (peers.*) REDACTED
 -- SQLNESS REPLACE (Hash.*) REDACTED
@@ -271,30 +272,24 @@ TQL EVAL (0, 240, '60s') timestamp(at_modifier_gauge @ 300);
 TQL EXPLAIN (0, 240, '60s') timestamp(at_modifier_gauge @ 300);
 
 -- 11. `label_join` above an anchored selector. The call rewrites the label the input series are
--- told apart by (`host` becomes the empty string), so it is never promoted: it must stay above the
+-- told apart by (`host` becomes `a-a` and `b-b`), so it is never promoted: it must stay above the
 -- per-series replay of the selector and be evaluated at every step. Both hosts are still reported,
 -- with their own value, at every step. A promoted `label_join` would instead be replayed through
 -- the labels it just rewrote and report the two series as a single timeline, i.e. one mixed row
 -- per step.
---
--- The invariant asserted here is scoped to the replay: it must not drop or mix the input rows.
--- It is not a claim about the final PromQL semantics of this query: joining `host` to one value
--- leaves two samples with the same label set at the same timestamp, which Prometheus rejects,
--- while `label_join` does not validate that yet (`label_replace` errors on such a rewrite
--- instead). That duplicate-labelset validation gap is pre-existing and out of scope here.
 -- SQLNESS SORT_RESULT 3 1
-TQL EVAL (300, 480, '60s') label_join(at_modifier_gauge @ 300, "host", "", "");
+TQL EVAL (300, 480, '60s') label_join(at_modifier_gauge @ 300, "host", "-", "host", "host");
 
 -- The same join below another call: neither is promoted, and both are evaluated at every step over
 -- the per-series replay of the anchored selector.
 -- SQLNESS SORT_RESULT 3 1
-TQL EVAL (300, 480, '60s') abs(label_join(at_modifier_gauge @ 300, "host", "", ""));
+TQL EVAL (300, 480, '60s') abs(label_join(at_modifier_gauge @ 300, "host", "-", "host", "host"));
 
 -- A range call below the join is still promoted on its own (it is the direct call over the
 -- anchored range selector): the anchored window is folded once per series, and the join above that
 -- replay reports the rate of both hosts at every step.
 -- SQLNESS SORT_RESULT 3 1
-TQL EVAL (300, 480, '60s') label_join(rate(at_modifier_counter_total[5m] @ 300), "host", "", "");
+TQL EVAL (300, 480, '60s') label_join(rate(at_modifier_counter_total[5m] @ 300), "host", "-", "host", "host");
 
 DROP TABLE at_modifier_gauge;
 
diff --git a/tests/cases/standalone/common/promql/computed_scalar_rhs.result b/tests/cases/standalone/common/promql/computed_scalar_rhs.result
new file mode 100644
index 00000000000..96b925d1cf5
--- /dev/null
+++ b/tests/cases/standalone/common/promql/computed_scalar_rhs.result
@@ -0,0 +1,97 @@
+-- A vector combined with a computed scalar on the right keeps the vector's
+-- labels, like a scalar on the left does. Expected results are from Prometheus 3.
+create table computed_scalar_lhs (
+    ts timestamp time index,
+    val double,
+    host string primary key
+);
+
+Affected Rows: 0
+
+create table computed_scalar_rhs (
+    ts timestamp time index,
+    val double,
+    host string primary key
+);
+
+Affected Rows: 0
+
+insert into computed_scalar_lhs values
+    (0, 1.0, 'a'),
+    (0, 2.0, 'b');
+
+Affected Rows: 2
+
+insert into computed_scalar_rhs values
+    (0, 10.0, 'x');
+
+Affected Rows: 1
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') computed_scalar_lhs + time();
+
++------+---------------------+-------------------------------------------------+
+| host | ts                  | computed_scalar_lhs.val + .time / Float64(1000) |
++------+---------------------+-------------------------------------------------+
+| a    | 1970-01-01T00:01:00 | 61.0                                            |
+| b    | 1970-01-01T00:01:00 | 62.0                                            |
++------+---------------------+-------------------------------------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') time() + computed_scalar_lhs;
+
++------+---------------------+-------------------------------------------------+
+| host | ts                  | .time / Float64(1000) + computed_scalar_lhs.val |
++------+---------------------+-------------------------------------------------+
+| a    | 1970-01-01T00:01:00 | 61.0                                            |
+| b    | 1970-01-01T00:01:00 | 62.0                                            |
++------+---------------------+-------------------------------------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') computed_scalar_lhs * scalar(computed_scalar_rhs);
+
++------+---------------------+-----------------------------------------------------------+
+| host | ts                  | computed_scalar_lhs.val * computed_scalar_rhs.scalar(val) |
++------+---------------------+-----------------------------------------------------------+
+| a    | 1970-01-01T00:01:00 | 10.0                                                      |
+| b    | 1970-01-01T00:01:00 | 20.0                                                      |
++------+---------------------+-----------------------------------------------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') computed_scalar_lhs < bool (time() * 2);
+
++------+---------------------+--------------------------------------------------------------+
+| host | ts                  | computed_scalar_lhs.val < .time / Float64(1000) * Float64(2) |
++------+---------------------+--------------------------------------------------------------+
+| a    | 1970-01-01T00:01:00 | 1.0                                                          |
+| b    | 1970-01-01T00:01:00 | 1.0                                                          |
++------+---------------------+--------------------------------------------------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') (time() >= computed_scalar_lhs) ^ scalar(computed_scalar_rhs);
+
++------+---------------------+---------------------------------------------+
+| host | ts                  | power(.val,computed_scalar_rhs.scalar(val)) |
++------+---------------------+---------------------------------------------+
+| a    | 1970-01-01T00:01:00 | 1.0                                         |
+| b    | 1970-01-01T00:01:00 | 1024.0                                      |
++------+---------------------+---------------------------------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') scalar(computed_scalar_rhs) * (time() >= computed_scalar_lhs);
+
++------+---------------------+----------------------------------------+
+| host | ts                  | computed_scalar_rhs.scalar(val) * .val |
++------+---------------------+----------------------------------------+
+| a    | 1970-01-01T00:01:00 | 10.0                                   |
+| b    | 1970-01-01T00:01:00 | 20.0                                   |
++------+---------------------+----------------------------------------+
+
+drop table computed_scalar_lhs;
+
+Affected Rows: 0
+
+drop table computed_scalar_rhs;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/promql/computed_scalar_rhs.sql b/tests/cases/standalone/common/promql/computed_scalar_rhs.sql
new file mode 100644
index 00000000000..57cc431c1f9
--- /dev/null
+++ b/tests/cases/standalone/common/promql/computed_scalar_rhs.sql
@@ -0,0 +1,43 @@
+-- A vector combined with a computed scalar on the right keeps the vector's
+-- labels, like a scalar on the left does. Expected results are from Prometheus 3.
+
+create table computed_scalar_lhs (
+    ts timestamp time index,
+    val double,
+    host string primary key
+);
+
+create table computed_scalar_rhs (
+    ts timestamp time index,
+    val double,
+    host string primary key
+);
+
+insert into computed_scalar_lhs values
+    (0, 1.0, 'a'),
+    (0, 2.0, 'b');
+
+insert into computed_scalar_rhs values
+    (0, 10.0, 'x');
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') computed_scalar_lhs + time();
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') time() + computed_scalar_lhs;
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') computed_scalar_lhs * scalar(computed_scalar_rhs);
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') computed_scalar_lhs < bool (time() * 2);
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') (time() >= computed_scalar_lhs) ^ scalar(computed_scalar_rhs);
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') scalar(computed_scalar_rhs) * (time() >= computed_scalar_lhs);
+
+drop table computed_scalar_lhs;
+
+drop table computed_scalar_rhs;
diff --git a/tests/cases/standalone/common/promql/count_values.result b/tests/cases/standalone/common/promql/count_values.result
index 886c3a143b7..1d04301d73b 100644
--- a/tests/cases/standalone/common/promql/count_values.result
+++ b/tests/cases/standalone/common/promql/count_values.result
@@ -84,7 +84,7 @@ TQL EVAL (0, 15, '5s') abs(count_values("v", http_requests));
 TQL EVAL (0, 15, '5s') round(count_values("v", http_requests));
 
 +---------------------+-------------------------------------------------+-----+
-| ts                  | prom_round(count(http_requests.val),Float64(0)) | v   |
+| ts                  | prom_round(count(http_requests.val),Float64(1)) | v   |
 +---------------------+-------------------------------------------------+-----+
 | 1970-01-01T00:00:00 | 1.0                                             | 401 |
 | 1970-01-01T00:00:00 | 3.0                                             | 200 |
diff --git a/tests/cases/standalone/common/promql/delta_temporality.result b/tests/cases/standalone/common/promql/delta_temporality.result
index 787e72e8dc8..ac32a907cb9 100644
--- a/tests/cases/standalone/common/promql/delta_temporality.result
+++ b/tests/cases/standalone/common/promql/delta_temporality.result
@@ -162,7 +162,7 @@ TQL EVAL (180, 180, '1m') round(sum(rate(delta_temporality[3m])), 0.000001);
 +---------------------+----------------------------------------------------------------------------------------+
 | ts                  | prom_round(sum(prom_rate(ts_range,greptime_value,ts,Int64(180000))),Float64(0.000001)) |
 +---------------------+----------------------------------------------------------------------------------------+
-| 1970-01-01T00:03:00 | 0.45555599999999996                                                                    |
+| 1970-01-01T00:03:00 | 0.455556                                                                               |
 +---------------------+----------------------------------------------------------------------------------------+
 
 CREATE TABLE delta_marker_only (
diff --git a/tests/cases/standalone/common/promql/dotted_column_names.result b/tests/cases/standalone/common/promql/dotted_column_names.result
new file mode 100644
index 00000000000..bb4912bc94e
--- /dev/null
+++ b/tests/cases/standalone/common/promql/dotted_column_names.result
@@ -0,0 +1,505 @@
+-- https://github.com/GreptimeTeam/greptimedb/issues/9390
+-- Tag, field and time index names containing dots or upper case letters must
+-- be resolved as plain column names, not as `relation.column`. `Host` and `host`
+-- hold different values, so reading one for the other changes the output.
+CREATE TABLE "otel.m" (
+    "ts.time" TIMESTAMP(3) TIME INDEX,
+    "service.name" STRING,
+    "Host" STRING,
+    host STRING,
+    "v.val" DOUBLE,
+    PRIMARY KEY ("service.name", "Host", host)
+) PARTITION ON COLUMNS ("service.name") (
+    "service.name" < 'b',
+    "service.name" >= 'b'
+);
+
+Affected Rows: 0
+
+INSERT INTO "otel.m" VALUES
+    (0,     'a', 'h1', 'x', 1),
+    (0,     'a', 'h2', 'x', 2),
+    (0,     'b', 'h1', 'y', 3),
+    (5000,  'a', 'h1', 'x', 4),
+    (5000,  'a', 'h2', 'x', 5),
+    (5000,  'b', 'h1', 'y', 6),
+    (10000, 'a', 'h1', 'x', 8),
+    (10000, 'a', 'h2', 'x', 9),
+    (10000, 'b', 'h1', 'y', 8);
+
+Affected Rows: 9
+
+CREATE TABLE "otel.h" (
+    "ts.time" TIMESTAMP(3) TIME INDEX,
+    "service.name" STRING,
+    le STRING,
+    "v.val" DOUBLE,
+    PRIMARY KEY ("service.name", le)
+);
+
+Affected Rows: 0
+
+INSERT INTO "otel.h" VALUES
+    (0,     'a', '0.1',  1),
+    (0,     'a', '1',    3),
+    (0,     'a', '+Inf', 4),
+    (10000, 'a', '0.1',  2),
+    (10000, 'a', '1',    6),
+    (10000, 'a', '+Inf', 10);
+
+Affected Rows: 6
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} and {"otel.m", "Host"="h1"};
+
++---------------------+--------------+------+------+-------+
+| ts.time             | service.name | Host | host | v.val |
++---------------------+--------------+------+------+-------+
+| 1970-01-01T00:00:00 | a            | h1   | x    | 1.0   |
+| 1970-01-01T00:00:00 | b            | h1   | y    | 3.0   |
+| 1970-01-01T00:00:05 | a            | h1   | x    | 4.0   |
+| 1970-01-01T00:00:05 | b            | h1   | y    | 6.0   |
+| 1970-01-01T00:00:10 | a            | h1   | x    | 8.0   |
+| 1970-01-01T00:00:10 | b            | h1   | y    | 8.0   |
++---------------------+--------------+------+------+-------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} and on("service.name") {"otel.m", "service.name"="b"};
+
++---------------------+--------------+------+------+-------+
+| ts.time             | service.name | Host | host | v.val |
++---------------------+--------------+------+------+-------+
+| 1970-01-01T00:00:00 | b            | h1   | y    | 3.0   |
+| 1970-01-01T00:00:05 | b            | h1   | y    | 6.0   |
+| 1970-01-01T00:00:10 | b            | h1   | y    | 8.0   |
++---------------------+--------------+------+------+-------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} and on(host) {"otel.m", host="y"};
+
++---------------------+--------------+------+------+-------+
+| ts.time             | service.name | Host | host | v.val |
++---------------------+--------------+------+------+-------+
+| 1970-01-01T00:00:00 | b            | h1   | y    | 3.0   |
+| 1970-01-01T00:00:05 | b            | h1   | y    | 6.0   |
+| 1970-01-01T00:00:10 | b            | h1   | y    | 8.0   |
++---------------------+--------------+------+------+-------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} unless {"otel.m", "Host"="h1"};
+
++---------------------+--------------+------+------+-------+
+| ts.time             | service.name | Host | host | v.val |
++---------------------+--------------+------+------+-------+
+| 1970-01-01T00:00:00 | a            | h2   | x    | 2.0   |
+| 1970-01-01T00:00:05 | a            | h2   | x    | 5.0   |
+| 1970-01-01T00:00:10 | a            | h2   | x    | 9.0   |
++---------------------+--------------+------+------+-------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} unless on("service.name") {"otel.m", "service.name"="b"};
+
++---------------------+--------------+------+------+-------+
+| ts.time             | service.name | Host | host | v.val |
++---------------------+--------------+------+------+-------+
+| 1970-01-01T00:00:00 | a            | h1   | x    | 1.0   |
+| 1970-01-01T00:00:00 | a            | h2   | x    | 2.0   |
+| 1970-01-01T00:00:05 | a            | h1   | x    | 4.0   |
+| 1970-01-01T00:00:05 | a            | h2   | x    | 5.0   |
+| 1970-01-01T00:00:10 | a            | h1   | x    | 8.0   |
+| 1970-01-01T00:00:10 | a            | h2   | x    | 9.0   |
++---------------------+--------------+------+------+-------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} or {"otel.m", "Host"="h1"};
+
++---------------------+------+------+--------------+-------+
+| ts.time             | Host | host | service.name | v.val |
++---------------------+------+------+--------------+-------+
+| 1970-01-01T00:00:00 | h1   | x    | a            | 1.0   |
+| 1970-01-01T00:00:00 | h1   | y    | b            | 3.0   |
+| 1970-01-01T00:00:00 | h2   | x    | a            | 2.0   |
+| 1970-01-01T00:00:05 | h1   | x    | a            | 4.0   |
+| 1970-01-01T00:00:05 | h1   | y    | b            | 6.0   |
+| 1970-01-01T00:00:05 | h2   | x    | a            | 5.0   |
+| 1970-01-01T00:00:10 | h1   | x    | a            | 8.0   |
+| 1970-01-01T00:00:10 | h1   | y    | b            | 8.0   |
+| 1970-01-01T00:00:10 | h2   | x    | a            | 9.0   |
++---------------------+------+------+--------------+-------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') count_values("v.name", {"otel.m"});
+
++---------------------+---------------------+--------+
+| count(otel.m.v.val) | ts.time             | v.name |
++---------------------+---------------------+--------+
+| 1                   | 1970-01-01T00:00:00 | 1      |
+| 1                   | 1970-01-01T00:00:00 | 2      |
+| 1                   | 1970-01-01T00:00:00 | 3      |
+| 1                   | 1970-01-01T00:00:05 | 4      |
+| 1                   | 1970-01-01T00:00:05 | 5      |
+| 1                   | 1970-01-01T00:00:05 | 6      |
+| 1                   | 1970-01-01T00:00:10 | 9      |
+| 2                   | 1970-01-01T00:00:10 | 8      |
++---------------------+---------------------+--------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') count_values by ("service.name") ("v.name", {"otel.m"});
+
++---------------------+--------------+---------------------+--------+
+| count(otel.m.v.val) | service.name | ts.time             | v.name |
++---------------------+--------------+---------------------+--------+
+| 1                   | a            | 1970-01-01T00:00:00 | 1      |
+| 1                   | a            | 1970-01-01T00:00:00 | 2      |
+| 1                   | a            | 1970-01-01T00:00:05 | 4      |
+| 1                   | a            | 1970-01-01T00:00:05 | 5      |
+| 1                   | a            | 1970-01-01T00:00:10 | 8      |
+| 1                   | a            | 1970-01-01T00:00:10 | 9      |
+| 1                   | b            | 1970-01-01T00:00:00 | 3      |
+| 1                   | b            | 1970-01-01T00:00:05 | 6      |
+| 1                   | b            | 1970-01-01T00:00:10 | 8      |
++---------------------+--------------+---------------------+--------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') topk(1, {"otel.m"});
+
++-------+--------------+------+------+---------------------+
+| v.val | service.name | Host | host | ts.time             |
++-------+--------------+------+------+---------------------+
+| 3.0   | b            | h1   | y    | 1970-01-01T00:00:00 |
+| 6.0   | b            | h1   | y    | 1970-01-01T00:00:05 |
+| 9.0   | a            | h2   | x    | 1970-01-01T00:00:10 |
++-------+--------------+------+------+---------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') bottomk by ("service.name") (1, {"otel.m"});
+
++-------+--------------+------+------+---------------------+
+| v.val | service.name | Host | host | ts.time             |
++-------+--------------+------+------+---------------------+
+| 1.0   | a            | h1   | x    | 1970-01-01T00:00:00 |
+| 3.0   | b            | h1   | y    | 1970-01-01T00:00:00 |
+| 4.0   | a            | h1   | x    | 1970-01-01T00:00:05 |
+| 6.0   | b            | h1   | y    | 1970-01-01T00:00:05 |
+| 8.0   | a            | h1   | x    | 1970-01-01T00:00:10 |
+| 8.0   | b            | h1   | y    | 1970-01-01T00:00:10 |
++-------+--------------+------+------+---------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') sum by ("service.name") ({"otel.m"});
+
++--------------+---------------------+-------------------+
+| service.name | ts.time             | sum(otel.m.v.val) |
++--------------+---------------------+-------------------+
+| a            | 1970-01-01T00:00:00 | 3.0               |
+| a            | 1970-01-01T00:00:05 | 9.0               |
+| a            | 1970-01-01T00:00:10 | 17.0              |
+| b            | 1970-01-01T00:00:00 | 3.0               |
+| b            | 1970-01-01T00:00:05 | 6.0               |
+| b            | 1970-01-01T00:00:10 | 8.0               |
++--------------+---------------------+-------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') sum by ("Host") ({"otel.m"});
+
++------+---------------------+-------------------+
+| Host | ts.time             | sum(otel.m.v.val) |
++------+---------------------+-------------------+
+| h1   | 1970-01-01T00:00:00 | 4.0               |
+| h1   | 1970-01-01T00:00:05 | 10.0              |
+| h1   | 1970-01-01T00:00:10 | 16.0              |
+| h2   | 1970-01-01T00:00:00 | 2.0               |
+| h2   | 1970-01-01T00:00:05 | 5.0               |
+| h2   | 1970-01-01T00:00:10 | 9.0               |
++------+---------------------+-------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') sum by (host) ({"otel.m"});
+
++------+---------------------+-------------------+
+| host | ts.time             | sum(otel.m.v.val) |
++------+---------------------+-------------------+
+| x    | 1970-01-01T00:00:00 | 3.0               |
+| x    | 1970-01-01T00:00:05 | 9.0               |
+| x    | 1970-01-01T00:00:10 | 17.0              |
+| y    | 1970-01-01T00:00:00 | 3.0               |
+| y    | 1970-01-01T00:00:05 | 6.0               |
+| y    | 1970-01-01T00:00:10 | 8.0               |
++------+---------------------+-------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') sum without ("Host") ({"otel.m"});
+
++------+--------------+---------------------+-------------------+
+| host | service.name | ts.time             | sum(otel.m.v.val) |
++------+--------------+---------------------+-------------------+
+| x    | a            | 1970-01-01T00:00:00 | 3.0               |
+| x    | a            | 1970-01-01T00:00:05 | 9.0               |
+| x    | a            | 1970-01-01T00:00:10 | 17.0              |
+| y    | b            | 1970-01-01T00:00:00 | 3.0               |
+| y    | b            | 1970-01-01T00:00:05 | 6.0               |
+| y    | b            | 1970-01-01T00:00:10 | 8.0               |
++------+--------------+---------------------+-------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') -{"otel.m"};
+
++--------------+------+------+---------------------+-----------+
+| service.name | Host | host | ts.time             | (- v.val) |
++--------------+------+------+---------------------+-----------+
+| a            | h1   | x    | 1970-01-01T00:00:00 | -1.0      |
+| a            | h1   | x    | 1970-01-01T00:00:05 | -4.0      |
+| a            | h1   | x    | 1970-01-01T00:00:10 | -8.0      |
+| a            | h2   | x    | 1970-01-01T00:00:00 | -2.0      |
+| a            | h2   | x    | 1970-01-01T00:00:05 | -5.0      |
+| a            | h2   | x    | 1970-01-01T00:00:10 | -9.0      |
+| b            | h1   | y    | 1970-01-01T00:00:00 | -3.0      |
+| b            | h1   | y    | 1970-01-01T00:00:05 | -6.0      |
+| b            | h1   | y    | 1970-01-01T00:00:10 | -8.0      |
++--------------+------+------+---------------------+-----------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') 2 * {"otel.m"};
+
++--------------+------+------+---------------------+--------------------+
+| service.name | Host | host | ts.time             | Float64(2) * v.val |
++--------------+------+------+---------------------+--------------------+
+| a            | h1   | x    | 1970-01-01T00:00:00 | 2.0                |
+| a            | h1   | x    | 1970-01-01T00:00:05 | 8.0                |
+| a            | h1   | x    | 1970-01-01T00:00:10 | 16.0               |
+| a            | h2   | x    | 1970-01-01T00:00:00 | 4.0                |
+| a            | h2   | x    | 1970-01-01T00:00:05 | 10.0               |
+| a            | h2   | x    | 1970-01-01T00:00:10 | 18.0               |
+| b            | h1   | y    | 1970-01-01T00:00:00 | 6.0                |
+| b            | h1   | y    | 1970-01-01T00:00:05 | 12.0               |
+| b            | h1   | y    | 1970-01-01T00:00:10 | 16.0               |
++--------------+------+------+---------------------+--------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} - 1;
+
++--------------+------+------+---------------------+--------------------+
+| service.name | Host | host | ts.time             | v.val - Float64(1) |
++--------------+------+------+---------------------+--------------------+
+| a            | h1   | x    | 1970-01-01T00:00:00 | 0.0                |
+| a            | h1   | x    | 1970-01-01T00:00:05 | 3.0                |
+| a            | h1   | x    | 1970-01-01T00:00:10 | 7.0                |
+| a            | h2   | x    | 1970-01-01T00:00:00 | 1.0                |
+| a            | h2   | x    | 1970-01-01T00:00:05 | 4.0                |
+| a            | h2   | x    | 1970-01-01T00:00:10 | 8.0                |
+| b            | h1   | y    | 1970-01-01T00:00:00 | 2.0                |
+| b            | h1   | y    | 1970-01-01T00:00:05 | 5.0                |
+| b            | h1   | y    | 1970-01-01T00:00:10 | 7.0                |
++--------------+------+------+---------------------+--------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') timestamp({"otel.m"});
+
++---------------------+-------+--------------+------+------+
+| ts.time             | value | service.name | Host | host |
++---------------------+-------+--------------+------+------+
+| 1970-01-01T00:00:00 | 0.0   | a            | h1   | x    |
+| 1970-01-01T00:00:00 | 0.0   | a            | h2   | x    |
+| 1970-01-01T00:00:00 | 0.0   | b            | h1   | y    |
+| 1970-01-01T00:00:05 | 5.0   | a            | h1   | x    |
+| 1970-01-01T00:00:05 | 5.0   | a            | h2   | x    |
+| 1970-01-01T00:00:05 | 5.0   | b            | h1   | y    |
+| 1970-01-01T00:00:10 | 10.0  | a            | h1   | x    |
+| 1970-01-01T00:00:10 | 10.0  | a            | h2   | x    |
+| 1970-01-01T00:00:10 | 10.0  | b            | h1   | y    |
++---------------------+-------+--------------+------+------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') minute({"otel.m"});
+
++---------------------+-----------------------------------+--------------+------+------+
+| ts.time             | date_part(Utf8("minute"),ts.time) | service.name | Host | host |
++---------------------+-----------------------------------+--------------+------+------+
+| 1970-01-01T00:00:00 | 0                                 | a            | h1   | x    |
+| 1970-01-01T00:00:00 | 0                                 | a            | h2   | x    |
+| 1970-01-01T00:00:00 | 0                                 | b            | h1   | y    |
+| 1970-01-01T00:00:05 | 0                                 | a            | h1   | x    |
+| 1970-01-01T00:00:05 | 0                                 | a            | h2   | x    |
+| 1970-01-01T00:00:05 | 0                                 | b            | h1   | y    |
+| 1970-01-01T00:00:10 | 0                                 | a            | h1   | x    |
+| 1970-01-01T00:00:10 | 0                                 | a            | h2   | x    |
+| 1970-01-01T00:00:10 | 0                                 | b            | h1   | y    |
++---------------------+-----------------------------------+--------------+------+------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (5, 10, '5s') sum by ("service.name") (increase({"otel.m"}[10s]));
+
++--------------+---------------------+--------------------------------------------------------------+
+| service.name | ts.time             | sum(prom_increase(ts.time_range,v.val,ts.time,Int64(10000))) |
++--------------+---------------------+--------------------------------------------------------------+
+| a            | 1970-01-01T00:00:05 | 9.0                                                          |
+| a            | 1970-01-01T00:00:10 | 16.0                                                         |
+| b            | 1970-01-01T00:00:05 | 6.0                                                          |
+| b            | 1970-01-01T00:00:10 | 4.0                                                          |
++--------------+---------------------+--------------------------------------------------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') scalar(sum({"otel.m"})) * {"otel.m", "Host"="h2"};
+
++--------------+------+------+---------------------+-------------------------------------------+
+| service.name | Host | host | ts.time             | lhs.scalar(sum(otel.m.v.val)) * rhs.v.val |
++--------------+------+------+---------------------+-------------------------------------------+
+| a            | h2   | x    | 1970-01-01T00:00:00 | 12.0                                      |
+| a            | h2   | x    | 1970-01-01T00:00:05 | 75.0                                      |
+| a            | h2   | x    | 1970-01-01T00:00:10 | 225.0                                     |
++--------------+------+------+---------------------+-------------------------------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') absent({"otel.m", "service.name"="c"});
+
++---------------------+-------+--------------+
+| ts.time             | v.val | service.name |
++---------------------+-------+--------------+
+| 1970-01-01T00:00:00 | 1.0   | c            |
+| 1970-01-01T00:00:05 | 1.0   | c            |
+| 1970-01-01T00:00:10 | 1.0   | c            |
++---------------------+-------+--------------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') histogram_quantile(0.5, {"otel.h"});
+
++---------------------+--------------+-------+
+| ts.time             | service.name | v.val |
++---------------------+--------------+-------+
+| 1970-01-01T00:00:00 | a            | 0.55  |
+| 1970-01-01T00:00:05 | a            | 0.55  |
+| 1970-01-01T00:00:10 | a            | 0.775 |
++---------------------+--------------+-------+
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+TQL EXPLAIN (0, 10, '5s') {"otel.m"} and {"otel.m", "Host"="h1"};
+
++-+-+
+| plan_type_| plan_|
++-+-+
+| logical_plan_| LeftSemi Join: otel.m.Host = otel.m.Host, otel.m.host = otel.m.host, otel.m.service.name = otel.m.service.name, otel.m.ts.time = otel.m.ts.time_|
+|_|_Aggregate: groupBy=[[otel.m.ts.time, otel.m.service.name, otel.m.Host, otel.m.host, otel.m.v.val]], aggr=[[]]_|
+|_|_MergeScan [is_placeholder=false, remote_input=[_|
+|_| Distinct:_|
+|_|_PromInstantManipulate: range=[0..10000], lookback=[300000], interval=[5000], time index=[ts.time]_|
+|_|_PromSeriesDivide: tags=["service.name", "Host", "host"]_|
+|_|_Sort: otel.m.service.name ASC NULLS FIRST, otel.m.Host ASC NULLS FIRST, otel.m.host ASC NULLS FIRST, otel.m.ts.time ASC NULLS FIRST_|
+|_|_Filter: otel.m.ts.time >= TimestampMillisecond(-299999, None) AND otel.m.ts.time <= TimestampMillisecond(10000, None)_|
+|_|_TableScan: otel.m, partial_filters=[otel.m.ts.time >= TimestampMillisecond(-299999, None), otel.m.ts.time <= TimestampMillisecond(10000, None)]_|
+|_| ]]_|
+|_|_Projection: otel.m.ts.time, otel.m.service.name, otel.m.Host, otel.m.host_|
+|_|_PromInstantManipulate: range=[0..10000], lookback=[300000], interval=[5000], time index=[ts.time]_|
+|_|_PromSeriesDivide: tags=["service.name", "Host", "host"]_|
+|_|_Sort: otel.m.service.name ASC NULLS FIRST, otel.m.Host ASC NULLS FIRST, otel.m.host ASC NULLS FIRST, otel.m.ts.time ASC NULLS FIRST_|
+|_|_MergeScan [is_placeholder=false, remote_input=[_|
+|_| Filter: otel.m.Host = Utf8("h1") AND otel.m.ts.time >= TimestampMillisecond(-299999, None) AND otel.m.ts.time <= TimestampMillisecond(10000, None)_|
+|_|_TableScan: otel.m, partial_filters=[otel.m.Host = Utf8("h1"), otel.m.ts.time >= TimestampMillisecond(-299999, None), otel.m.ts.time <= TimestampMillisecond(10000, None)] |
+|_| ]]_|
+| physical_plan | HashJoinExec: mode=CollectLeft, join_type=RightSemi, on=[(Host@2, Host@2), (host@3, host@3), (service.name@1, service.name@1), (ts.time@0, ts.time@0)], NullsEqual: true_|
+|_|_CoalescePartitionsExec_|
+|_|_ProjectionExec: expr=[ts.time@0 as ts.time, service.name@1 as service.name, Host@2 as Host, host@3 as host]_|
+|_|_PromInstantManipulateExec: range=[0..10000], lookback=[300000], interval=[5000], time index=[ts.time]_|
+|_|_PromSeriesDivideExec: tags=["service.name", "Host", "host"]_|
+|_|_SortExec: expr=[service.name@1 ASC, Host@2 ASC, host@3 ASC, ts.time@0 ASC], preserve_REDACTED
+|_|_RepartitionExec: REDACTED
+|_|_MergeScanExec: REDACTED
+|_|_AggregateExec: mode=FinalPartitioned, gby=[ts.time@0 as ts.time, service.name@1 as service.name, Host@2 as Host, host@3 as host, v.val@4 as v.val], aggr=[]_|
+|_|_RepartitionExec: REDACTED
+|_|_AggregateExec: mode=Partial, gby=[ts.time@0 as ts.time, service.name@1 as service.name, Host@2 as Host, host@3 as host, v.val@4 as v.val], aggr=[]_|
+|_|_RepartitionExec: REDACTED
+|_|_MergeScanExec: REDACTED
+|_|_|
++-+-+
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+TQL EXPLAIN (0, 10, '5s') topk(1, {"otel.m"});
+
++-+-+
+| plan_type_| plan_|
++-+-+
+| logical_plan_| Projection: otel.m.v.val, otel.m.service.name, otel.m.Host, otel.m.host, otel.m.ts.time_|
+|_|_Sort: otel.m.ts.time ASC NULLS LAST, row_number() PARTITION BY [otel.m.ts.time] ORDER BY [isnan(otel.m.v.val) ASC NULLS FIRST, otel.m.v.val DESC NULLS FIRST, otel.m.service.name DESC NULLS FIRST, otel.m.Host DESC NULLS FIRST, otel.m.host DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW ASC NULLS LAST_|
+|_|_Filter: CAST(row_number() PARTITION BY [otel.m.ts.time] ORDER BY [isnan(otel.m.v.val) ASC NULLS FIRST, otel.m.v.val DESC NULLS FIRST, otel.m.service.name DESC NULLS FIRST, otel.m.Host DESC NULLS FIRST, otel.m.host DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS Float64) <= Float64(1)_|
+|_|_WindowAggr: windowExpr=[[row_number() PARTITION BY [otel.m.ts.time] ORDER BY [isnan(otel.m.v.val) ASC NULLS FIRST, otel.m.v.val DESC NULLS FIRST, otel.m.service.name DESC NULLS FIRST, otel.m.Host DESC NULLS FIRST, otel.m.host DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]]_|
+|_|_MergeScan [is_placeholder=false, remote_input=[_|
+|_| PromInstantManipulate: range=[0..10000], lookback=[300000], interval=[5000], time index=[ts.time]_|
+|_|_PromSeriesDivide: tags=["service.name", "Host", "host"]_|
+|_|_Sort: otel.m.service.name ASC NULLS FIRST, otel.m.Host ASC NULLS FIRST, otel.m.host ASC NULLS FIRST, otel.m.ts.time ASC NULLS FIRST_|
+|_|_Filter: otel.m.ts.time >= TimestampMillisecond(-299999, None) AND otel.m.ts.time <= TimestampMillisecond(10000, None)_|
+|_|_TableScan: otel.m, partial_filters=[otel.m.ts.time >= TimestampMillisecond(-299999, None), otel.m.ts.time <= TimestampMillisecond(10000, None)]_|
+|_| ]]_|
+| physical_plan | ProjectionExec: expr=[v.val@4 as v.val, service.name@1 as service.name, Host@2 as Host, host@3 as host, ts.time@0 as ts.time]_|
+|_|_SortPreservingMergeExec: [ts.time@0 ASC NULLS LAST, row_number() PARTITION BY [otel.m.ts.time] ORDER BY [isnan(otel.m.v.val) ASC NULLS FIRST, otel.m.v.val DESC NULLS FIRST, otel.m.service.name DESC NULLS FIRST, otel.m.Host DESC NULLS FIRST, otel.m.host DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW@5 ASC NULLS LAST]_|
+|_|_FilterExec: CAST(row_number() PARTITION BY [otel.m.ts.time] ORDER BY [isnan(otel.m.v.val) ASC NULLS FIRST, otel.m.v.val DESC NULLS FIRST, otel.m.service.name DESC NULLS FIRST, otel.m.Host DESC NULLS FIRST, otel.m.host DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW@5 AS Float64) <= 1_|
+|_|_BoundedWindowAggExec: wdw=[row_number() PARTITION BY [otel.m.ts.time] ORDER BY [isnan(otel.m.v.val) ASC NULLS FIRST, otel.m.v.val DESC NULLS FIRST, otel.m.service.name DESC NULLS FIRST, otel.m.Host DESC NULLS FIRST, otel.m.host DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW: Field { "row_number() PARTITION BY [otel.m.ts.time] ORDER BY [isnan(otel.m.v.val) ASC NULLS FIRST, otel.m.v.val DESC NULLS FIRST, otel.m.service.name DESC NULLS FIRST, otel.m.Host DESC NULLS FIRST, otel.m.host DESC NULLS FIRST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW": UInt64 }, frame: ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW], mode=[Sorted] |
+|_|_SortExec: expr=[ts.time@0 ASC NULLS LAST, isnan(v.val@4) ASC, v.val@4 DESC, service.name@1 DESC, Host@2 DESC, host@3 DESC], preserve_REDACTED
+|_|_RepartitionExec: REDACTED
+|_|_MergeScanExec: REDACTED
+|_|_|
++-+-+
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+TQL EXPLAIN (5, 10, '5s') sum by ("service.name") (increase({"otel.m"}[10s]));
+
++-+-+
+| plan_type_| plan_|
++-+-+
+| logical_plan_| MergeSort: otel.m.service.name ASC NULLS LAST, otel.m.ts.time ASC NULLS LAST_|
+|_|_MergeScan [is_placeholder=false, remote_input=[_|
+|_| Sort: otel.m.service.name ASC NULLS LAST, otel.m.ts.time ASC NULLS LAST_|
+|_|_Aggregate: groupBy=[[otel.m.service.name, otel.m.ts.time]], aggr=[[sum(prom_increase(ts.time_range,v.val,ts.time,Int64(10000)))]]_|
+|_|_Filter: prom_increase(ts.time_range,v.val,ts.time,Int64(10000)) IS NOT NULL_|
+|_|_Projection: otel.m.ts.time, prom_increase(ts.time_range, v.val, otel.m.ts.time, Int64(10000)) AS prom_increase(ts.time_range,v.val,ts.time,Int64(10000)), otel.m.service.name, otel.m.Host, otel.m.host |
+|_|_PromRangeManipulate: req range=[5000..10000], interval=[5000], eval range=[10000], time index=[ts.time], values=["v.val"]_|
+|_|_PromSeriesNormalize: offset=[0], time index=[ts.time], filter NaN: [true]_|
+|_|_PromSeriesDivide: tags=["service.name", "Host", "host"]_|
+|_|_Sort: otel.m.service.name ASC NULLS FIRST, otel.m.Host ASC NULLS FIRST, otel.m.host ASC NULLS FIRST, otel.m.ts.time ASC NULLS FIRST_|
+|_|_Filter: otel.m.ts.time >= TimestampMillisecond(-4999, None) AND otel.m.ts.time <= TimestampMillisecond(10000, None)_|
+|_|_TableScan: otel.m, partial_filters=[otel.m.ts.time >= TimestampMillisecond(-4999, None), otel.m.ts.time <= TimestampMillisecond(10000, None)]_|
+|_| ]]_|
+| physical_plan | MergeSortExec: [service.name@0 ASC NULLS LAST, ts.time@1 ASC NULLS LAST]_|
+|_|_MergeScanExec: REDACTED
+|_|_|
++-+-+
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+TQL EXPLAIN (0, 10, '5s') histogram_quantile(0.5, {"otel.h"});
+
++-+-+
+| plan_type_| plan_|
++-+-+
+| logical_plan_| HistogramFold: le=le, field=v.val, quantile=0.5_|
+|_|_MergeScan [is_placeholder=false, remote_input=[_|
+|_| PromInstantManipulate: range=[0..10000], lookback=[300000], interval=[5000], time index=[ts.time]_|
+|_|_PromSeriesDivide: tags=["service.name", "le"]_|
+|_|_Sort: otel.h.service.name ASC NULLS FIRST, otel.h.le ASC NULLS FIRST, otel.h.ts.time ASC NULLS FIRST_|
+|_|_Filter: otel.h.ts.time >= TimestampMillisecond(-299999, None) AND otel.h.ts.time <= TimestampMillisecond(10000, None)_|
+|_|_TableScan: otel.h, partial_filters=[otel.h.ts.time >= TimestampMillisecond(-299999, None), otel.h.ts.time <= TimestampMillisecond(10000, None)] |
+|_| ]]_|
+| physical_plan | HistogramFoldExec: le=@2, field=@3, quantile=0.5_|
+|_|_RepartitionExec: REDACTED
+|_|_SortExec: expr=[service.name@1 ASC NULLS LAST, ts.time@0 ASC NULLS LAST, TRY_CAST(le@2 AS Float64) ASC NULLS LAST], preserve_REDACTED
+|_|_MergeScanExec: REDACTED
+|_|_|
++-+-+
+
+DROP TABLE "otel.m";
+
+Affected Rows: 0
+
+DROP TABLE "otel.h";
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/promql/dotted_column_names.sql b/tests/cases/standalone/common/promql/dotted_column_names.sql
new file mode 100644
index 00000000000..e6edc71094b
--- /dev/null
+++ b/tests/cases/standalone/common/promql/dotted_column_names.sql
@@ -0,0 +1,139 @@
+-- https://github.com/GreptimeTeam/greptimedb/issues/9390
+-- Tag, field and time index names containing dots or upper case letters must
+-- be resolved as plain column names, not as `relation.column`. `Host` and `host`
+-- hold different values, so reading one for the other changes the output.
+CREATE TABLE "otel.m" (
+    "ts.time" TIMESTAMP(3) TIME INDEX,
+    "service.name" STRING,
+    "Host" STRING,
+    host STRING,
+    "v.val" DOUBLE,
+    PRIMARY KEY ("service.name", "Host", host)
+) PARTITION ON COLUMNS ("service.name") (
+    "service.name" < 'b',
+    "service.name" >= 'b'
+);
+
+INSERT INTO "otel.m" VALUES
+    (0,     'a', 'h1', 'x', 1),
+    (0,     'a', 'h2', 'x', 2),
+    (0,     'b', 'h1', 'y', 3),
+    (5000,  'a', 'h1', 'x', 4),
+    (5000,  'a', 'h2', 'x', 5),
+    (5000,  'b', 'h1', 'y', 6),
+    (10000, 'a', 'h1', 'x', 8),
+    (10000, 'a', 'h2', 'x', 9),
+    (10000, 'b', 'h1', 'y', 8);
+
+CREATE TABLE "otel.h" (
+    "ts.time" TIMESTAMP(3) TIME INDEX,
+    "service.name" STRING,
+    le STRING,
+    "v.val" DOUBLE,
+    PRIMARY KEY ("service.name", le)
+);
+
+INSERT INTO "otel.h" VALUES
+    (0,     'a', '0.1',  1),
+    (0,     'a', '1',    3),
+    (0,     'a', '+Inf', 4),
+    (10000, 'a', '0.1',  2),
+    (10000, 'a', '1',    6),
+    (10000, 'a', '+Inf', 10);
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} and {"otel.m", "Host"="h1"};
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} and on("service.name") {"otel.m", "service.name"="b"};
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} and on(host) {"otel.m", host="y"};
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} unless {"otel.m", "Host"="h1"};
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} unless on("service.name") {"otel.m", "service.name"="b"};
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} or {"otel.m", "Host"="h1"};
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') count_values("v.name", {"otel.m"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') count_values by ("service.name") ("v.name", {"otel.m"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') topk(1, {"otel.m"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') bottomk by ("service.name") (1, {"otel.m"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') sum by ("service.name") ({"otel.m"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') sum by ("Host") ({"otel.m"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') sum by (host) ({"otel.m"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') sum without ("Host") ({"otel.m"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') -{"otel.m"};
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') 2 * {"otel.m"};
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') {"otel.m"} - 1;
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') timestamp({"otel.m"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') minute({"otel.m"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (5, 10, '5s') sum by ("service.name") (increase({"otel.m"}[10s]));
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') scalar(sum({"otel.m"})) * {"otel.m", "Host"="h2"};
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') absent({"otel.m", "service.name"="c"});
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 10, '5s') histogram_quantile(0.5, {"otel.h"});
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+TQL EXPLAIN (0, 10, '5s') {"otel.m"} and {"otel.m", "Host"="h1"};
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+TQL EXPLAIN (0, 10, '5s') topk(1, {"otel.m"});
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+TQL EXPLAIN (5, 10, '5s') sum by ("service.name") (increase({"otel.m"}[10s]));
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+-- SQLNESS REPLACE (-+) -
+-- SQLNESS REPLACE (\s\s+) _
+TQL EXPLAIN (0, 10, '5s') histogram_quantile(0.5, {"otel.h"});
+
+DROP TABLE "otel.m";
+
+DROP TABLE "otel.h";
diff --git a/tests/cases/standalone/common/promql/encode_substrait.result b/tests/cases/standalone/common/promql/encode_substrait.result
index 230eadb02f7..53bd8a94b1e 100644
--- a/tests/cases/standalone/common/promql/encode_substrait.result
+++ b/tests/cases/standalone/common/promql/encode_substrait.result
@@ -12,40 +12,42 @@ Affected Rows: 0
 -- SQLNESS REPLACE (peers.*) REDACTED
 -- SQLNESS REPLACE (partitioning.*) REDACTED
 tql explain (0, 100, '1s') 
-    increase(count_total{
+    max_over_time(increase(count_total{
       tag_a="ffa",
-    }[1h])[12h:1h];
+    }[1h])[12h:1h]);
 
-+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| plan_type     | plan                                                                                                                                                                                                         |
-+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                                                                                              |
-|               | PromRangeManipulate: req range=[0..100000], interval=[1000], eval range=[43200000], time index=[ts], values=["prom_increase(ts_range,val,ts,Int64(3600000))"]                                                |
-|               |   PromSeriesDivide: tags=["tag_a", "tag_b"]                                                                                                                                                                  |
-|               |     Sort: count_total.tag_a ASC NULLS FIRST, count_total.tag_b ASC NULLS FIRST, count_total.ts ASC NULLS FIRST                                                                                               |
-|               |       Filter: prom_increase(ts_range,val,ts,Int64(3600000)) IS NOT NULL                                                                                                                                      |
-|               |         Projection: count_total.ts, prom_increase(ts_range, val, count_total.ts, Int64(3600000)) AS prom_increase(ts_range,val,ts,Int64(3600000)), count_total.tag_a, count_total.tag_b                      |
-|               |           PromRangeManipulate: req range=[-39600000..100000], interval=[3600000], eval range=[3600000], time index=[ts], values=["val"]                                                                      |
-|               |             PromSeriesNormalize: offset=[0], time index=[ts], filter NaN: [true]                                                                                                                             |
-|               |               PromSeriesDivide: tags=["tag_a", "tag_b"]                                                                                                                                                      |
-|               |                 Sort: count_total.tag_a ASC NULLS FIRST, count_total.tag_b ASC NULLS FIRST, count_total.ts ASC NULLS FIRST                                                                                   |
-|               |                   Filter: count_total.tag_a = Utf8("ffa") AND count_total.ts >= TimestampMillisecond(-43199999, None) AND count_total.ts <= TimestampMillisecond(100000, None)                               |
-|               |                     TableScan: count_total, partial_filters=[count_total.tag_a = Utf8("ffa"), count_total.ts >= TimestampMillisecond(-43199999, None), count_total.ts <= TimestampMillisecond(100000, None)] |
-|               | ]]                                                                                                                                                                                                           |
-| physical_plan | CooperativeExec                                                                                                                                                                                              |
++---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                                                                                          |
++---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                                                                                                               |
+|               | Filter: prom_max_over_time(ts_range,prom_increase(ts_range,val,ts,Int64(3600000))) IS NOT NULL                                                                                                                                |
+|               |   Projection: count_total.ts, prom_max_over_time(ts_range, prom_increase(ts_range,val,ts,Int64(3600000))) AS prom_max_over_time(ts_range,prom_increase(ts_range,val,ts,Int64(3600000))), count_total.tag_a, count_total.tag_b |
+|               |     PromRangeManipulate: req range=[0..100000], interval=[1000], eval range=[43200000], time index=[ts], values=["prom_increase(ts_range,val,ts,Int64(3600000))"]                                                             |
+|               |       PromSeriesDivide: tags=["tag_a", "tag_b"]                                                                                                                                                                               |
+|               |         Sort: count_total.tag_a ASC NULLS FIRST, count_total.tag_b ASC NULLS FIRST, count_total.ts ASC NULLS FIRST                                                                                                            |
+|               |           Filter: prom_increase(ts_range,val,ts,Int64(3600000)) IS NOT NULL                                                                                                                                                   |
+|               |             Projection: count_total.ts, prom_increase(ts_range, val, count_total.ts, Int64(3600000)) AS prom_increase(ts_range,val,ts,Int64(3600000)), count_total.tag_a, count_total.tag_b                                   |
+|               |               PromRangeManipulate: req range=[-39600000..100000], interval=[3600000], eval range=[3600000], time index=[ts], values=["val"]                                                                                   |
+|               |                 PromSeriesNormalize: offset=[0], time index=[ts], filter NaN: [true]                                                                                                                                          |
+|               |                   PromSeriesDivide: tags=["tag_a", "tag_b"]                                                                                                                                                                   |
+|               |                     Sort: count_total.tag_a ASC NULLS FIRST, count_total.tag_b ASC NULLS FIRST, count_total.ts ASC NULLS FIRST                                                                                                |
+|               |                       Filter: count_total.tag_a = Utf8("ffa") AND count_total.ts >= TimestampMillisecond(-43199999, None) AND count_total.ts <= TimestampMillisecond(100000, None)                                            |
+|               |                         TableScan: count_total, partial_filters=[count_total.tag_a = Utf8("ffa"), count_total.ts >= TimestampMillisecond(-43199999, None), count_total.ts <= TimestampMillisecond(100000, None)]              |
+|               | ]]                                                                                                                                                                                                                            |
+| physical_plan | CooperativeExec                                                                                                                                                                                                               |
 |               |   MergeScanExec: REDACTED
-|               |                                                                                                                                                                                                              |
-+---------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|               |                                                                                                                                                                                                                               |
++---------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 tql eval (0, 100, '1s') 
-    increase(count_total{
+    max_over_time(increase(count_total{
       tag_a="ffa",
-    }[1h])[12h:1h];
+    }[1h])[12h:1h]);
 
-+----+-----------------------------------------------+-------+-------+----------+
-| ts | prom_increase(ts_range,val,ts,Int64(3600000)) | tag_a | tag_b | ts_range |
-+----+-----------------------------------------------+-------+-------+----------+
-+----+-----------------------------------------------+-------+-------+----------+
++----+----------------------------------------------------------------------------+-------+-------+
+| ts | prom_max_over_time(ts_range,prom_increase(ts_range,val,ts,Int64(3600000))) | tag_a | tag_b |
++----+----------------------------------------------------------------------------+-------+-------+
++----+----------------------------------------------------------------------------+-------+-------+
 
 drop table count_total;
 
diff --git a/tests/cases/standalone/common/promql/encode_substrait.sql b/tests/cases/standalone/common/promql/encode_substrait.sql
index 195c383ebd2..6443f3e1959 100644
--- a/tests/cases/standalone/common/promql/encode_substrait.sql
+++ b/tests/cases/standalone/common/promql/encode_substrait.sql
@@ -10,13 +10,13 @@ create table count_total (
 -- SQLNESS REPLACE (peers.*) REDACTED
 -- SQLNESS REPLACE (partitioning.*) REDACTED
 tql explain (0, 100, '1s') 
-    increase(count_total{
+    max_over_time(increase(count_total{
       tag_a="ffa",
-    }[1h])[12h:1h];
+    }[1h])[12h:1h]);
 
 tql eval (0, 100, '1s') 
-    increase(count_total{
+    max_over_time(increase(count_total{
       tag_a="ffa",
-    }[1h])[12h:1h];
+    }[1h])[12h:1h]);
 
 drop table count_total;
diff --git a/tests/cases/standalone/common/promql/float_semantics.result b/tests/cases/standalone/common/promql/float_semantics.result
new file mode 100644
index 00000000000..e56db8b0ba6
--- /dev/null
+++ b/tests/cases/standalone/common/promql/float_semantics.result
@@ -0,0 +1,115 @@
+-- NaN and rounding follow Prometheus (IEEE 754) rather than SQL ordering.
+-- Expected results are from Prometheus 3.
+create table float_semantics (
+    ts timestamp time index,
+    val double,
+    host string primary key
+);
+
+Affected Rows: 0
+
+insert into float_semantics values
+    (0, 1.0, 'a'),
+    (0, 2.0, 'b'),
+    (0, 'NaN'::double, 'c'),
+    (0, -2.5, 'd');
+
+Affected Rows: 4
+
+tql eval (0, 0, '1s') max(float_semantics);
+
++---------------------+--------------------------+
+| ts                  | max(float_semantics.val) |
++---------------------+--------------------------+
+| 1970-01-01T00:00:00 | 2.0                      |
++---------------------+--------------------------+
+
+tql eval (0, 0, '1s') min(float_semantics);
+
++---------------------+--------------------------+
+| ts                  | min(float_semantics.val) |
++---------------------+--------------------------+
+| 1970-01-01T00:00:00 | -2.5                     |
++---------------------+--------------------------+
+
+tql eval (0, 0, '1s') topk(1, float_semantics);
+
++-----+------+---------------------+
+| val | host | ts                  |
++-----+------+---------------------+
+| 2.0 | b    | 1970-01-01T00:00:00 |
++-----+------+---------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (0, 0, '1s') float_semantics <= NaN;
+
++----+-----+------+
+| ts | val | host |
++----+-----+------+
++----+-----+------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (0, 0, '1s') float_semantics != bool NaN;
+
++------+---------------------+---------------------+
+| host | ts                  | val != Float64(NaN) |
++------+---------------------+---------------------+
+| a    | 1970-01-01T00:00:00 | 1.0                 |
+| b    | 1970-01-01T00:00:00 | 1.0                 |
+| c    | 1970-01-01T00:00:00 | 1.0                 |
+| d    | 1970-01-01T00:00:00 | 1.0                 |
++------+---------------------+---------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (0, 0, '1s') round(float_semantics);
+
++---------------------+----------------------------+------+
+| ts                  | prom_round(val,Float64(1)) | host |
++---------------------+----------------------------+------+
+| 1970-01-01T00:00:00 | -2.0                       | d    |
+| 1970-01-01T00:00:00 | 1.0                        | a    |
+| 1970-01-01T00:00:00 | 2.0                        | b    |
+| 1970-01-01T00:00:00 | NaN                        | c    |
++---------------------+----------------------------+------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (0, 0, '1s') sqrt(float_semantics);
+
++---------------------+--------------------+------+
+| ts                  | sqrt(val)          | host |
++---------------------+--------------------+------+
+| 1970-01-01T00:00:00 | 1.0                | a    |
+| 1970-01-01T00:00:00 | 1.4142135623730951 | b    |
+| 1970-01-01T00:00:00 | NaN                | c    |
+| 1970-01-01T00:00:00 | NaN                | d    |
++---------------------+--------------------+------+
+
+-- prom_min/prom_max have their own column names, so SQL can use them next to min/max.
+select min(val) as sql_lo, prom_min(val) as prom_lo from float_semantics;
+
++--------+---------+
+| sql_lo | prom_lo |
++--------+---------+
+| -2.5   | -2.5    |
++--------+---------+
+
+select max(val) as sql_hi, prom_max(val) as prom_hi from float_semantics;
+
++--------+---------+
+| sql_hi | prom_hi |
++--------+---------+
+| NaN    | 2.0     |
++--------+---------+
+
+select prom_min(val) as lo from float_semantics having min(val) < 0;
+
++------+
+| lo   |
++------+
+| -2.5 |
++------+
+
+drop table float_semantics;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/promql/float_semantics.sql b/tests/cases/standalone/common/promql/float_semantics.sql
new file mode 100644
index 00000000000..f23e95141c4
--- /dev/null
+++ b/tests/cases/standalone/common/promql/float_semantics.sql
@@ -0,0 +1,41 @@
+-- NaN and rounding follow Prometheus (IEEE 754) rather than SQL ordering.
+-- Expected results are from Prometheus 3.
+
+create table float_semantics (
+    ts timestamp time index,
+    val double,
+    host string primary key
+);
+
+insert into float_semantics values
+    (0, 1.0, 'a'),
+    (0, 2.0, 'b'),
+    (0, 'NaN'::double, 'c'),
+    (0, -2.5, 'd');
+
+tql eval (0, 0, '1s') max(float_semantics);
+
+tql eval (0, 0, '1s') min(float_semantics);
+
+tql eval (0, 0, '1s') topk(1, float_semantics);
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (0, 0, '1s') float_semantics <= NaN;
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (0, 0, '1s') float_semantics != bool NaN;
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (0, 0, '1s') round(float_semantics);
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (0, 0, '1s') sqrt(float_semantics);
+
+-- prom_min/prom_max have their own column names, so SQL can use them next to min/max.
+select min(val) as sql_lo, prom_min(val) as prom_lo from float_semantics;
+
+select max(val) as sql_hi, prom_max(val) as prom_hi from float_semantics;
+
+select prom_min(val) as lo from float_semantics having min(val) < 0;
+
+drop table float_semantics;
diff --git a/tests/cases/standalone/common/promql/functions.result b/tests/cases/standalone/common/promql/functions.result
index 325fbccd17d..1867413aec8 100644
--- a/tests/cases/standalone/common/promql/functions.result
+++ b/tests/cases/standalone/common/promql/functions.result
@@ -109,7 +109,7 @@ tql eval (4, 4, '1s') quantile_over_time(0.4 + 0.1, prom_series_q[4s]);
 tql eval (3, 3, '1s') round(prom_series_q);
 
 +---------------------+----------------------------+------+
-| ts                  | prom_round(val,Float64(0)) | host |
+| ts                  | prom_round(val,Float64(1)) | host |
 +---------------------+----------------------------+------+
 | 1970-01-01T00:00:03 | 346.0                      | q    |
 +---------------------+----------------------------+------+
@@ -133,8 +133,8 @@ tql eval (1, 4, '1s') round(prom_series_q, 0.05 + 0.05);
 | ts                  | prom_round(val,Float64(0.05) + Float64(0.05)) | host |
 +---------------------+-----------------------------------------------+------+
 | 1970-01-01T00:00:01 | 123.5                                         | q    |
-| 1970-01-01T00:00:02 | 234.60000000000002                            | q    |
-| 1970-01-01T00:00:03 | 345.70000000000005                            | q    |
+| 1970-01-01T00:00:02 | 234.6                                         | q    |
+| 1970-01-01T00:00:03 | 345.7                                         | q    |
 | 1970-01-01T00:00:04 | 456.8                                         | q    |
 +---------------------+-----------------------------------------------+------+
 
@@ -156,10 +156,10 @@ tql eval (1, 4, '1s') round(prom_series_q, 100.0 + 3.0);
 +---------------------+-------------------------------------------+------+
 | ts                  | prom_round(val,Float64(100) + Float64(3)) | host |
 +---------------------+-------------------------------------------+------+
-| 1970-01-01T00:00:01 | 103.0                                     | q    |
-| 1970-01-01T00:00:02 | 206.0                                     | q    |
+| 1970-01-01T00:00:01 | 103.00000000000001                        | q    |
+| 1970-01-01T00:00:02 | 206.00000000000003                        | q    |
 | 1970-01-01T00:00:03 | 309.0                                     | q    |
-| 1970-01-01T00:00:04 | 412.0                                     | q    |
+| 1970-01-01T00:00:04 | 412.00000000000006                        | q    |
 +---------------------+-------------------------------------------+------+
 
 -- SQLNESS SORT_RESULT 3 1
diff --git a/tests/cases/standalone/common/promql/label.result b/tests/cases/standalone/common/promql/label.result
index 112b6261715..f6e169eebe3 100644
--- a/tests/cases/standalone/common/promql/label.result
+++ b/tests/cases/standalone/common/promql/label.result
@@ -21,9 +21,23 @@ INSERT INTO TABLE test VALUES
 Affected Rows: 8
 
 -- Missing source labels --
+-- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_join(test{host="host1"}, "new_host", "-");
 
-Error: 1004(InvalidArguments), Invalid function argument for label_join
++---------------------+-----+----------+-------+------------+
+| ts                  | val | new_host | host  | idc        |
++---------------------+-----+----------+-------+------------+
+| 1970-01-01T00:00:00 | 1   |          | host1 | idc1       |
+| 1970-01-01T00:00:05 | 1   |          | host1 | idc1       |
+| 1970-01-01T00:00:05 | 3   |          | host1 | idc2:zone1 |
+| 1970-01-01T00:00:10 | 1   |          | host1 | idc1       |
+| 1970-01-01T00:00:10 | 3   |          | host1 | idc2:zone1 |
+| 1970-01-01T00:00:10 | 5   |          | host1 | idc3:zone2 |
+| 1970-01-01T00:00:15 | 1   |          | host1 | idc1       |
+| 1970-01-01T00:00:15 | 3   |          | host1 | idc2:zone1 |
+| 1970-01-01T00:00:15 | 5   |          | host1 | idc3:zone2 |
+| 1970-01-01T00:00:15 | 7   |          | host1 | idc4:zone3 |
++---------------------+-----+----------+-------+------------+
 
 -- dst_label is equal to source label --
 -- SQLNESS SORT_RESULT 3 1
@@ -63,24 +77,27 @@ TQL EVAL (0, 15, '5s') label_join(test{host="host1"}, "host", "-", "idc", "host"
 | 1970-01-01T00:00:15 | 7   | idc4:zone3-host1 | idc4:zone3 |
 +---------------------+-----+------------------+------------+
 
--- test the empty source label --
--- SQLNESS SORT_RESULT 3 1
+-- Absent labels join as empty strings and keep their separators --
+TQL EVAL (0, 15, '5s') label_join(label_join(vector(1), "a", "", "missing"), "b", "-", "a", "a");
+
++---------------------+----------------+---+---+
+| time                | greptime_value | b | a |
++---------------------+----------------+---+---+
+| 1970-01-01T00:00:00 | 1.0            | - |   |
+| 1970-01-01T00:00:05 | 1.0            | - |   |
+| 1970-01-01T00:00:10 | 1.0            | - |   |
+| 1970-01-01T00:00:15 | 1.0            | - |   |
++---------------------+----------------+---+---+
+
+-- An empty source label name is invalid --
 TQL EVAL (0, 15, '5s') label_join(test{host="host1"}, "host", "-", "");
 
-+---------------------+-----+------+------------+
-| ts                  | val | host | idc        |
-+---------------------+-----+------+------------+
-| 1970-01-01T00:00:00 | 1   |      | idc1       |
-| 1970-01-01T00:00:05 | 1   |      | idc1       |
-| 1970-01-01T00:00:05 | 3   |      | idc2:zone1 |
-| 1970-01-01T00:00:10 | 1   |      | idc1       |
-| 1970-01-01T00:00:10 | 3   |      | idc2:zone1 |
-| 1970-01-01T00:00:10 | 5   |      | idc3:zone2 |
-| 1970-01-01T00:00:15 | 1   |      | idc1       |
-| 1970-01-01T00:00:15 | 3   |      | idc2:zone1 |
-| 1970-01-01T00:00:15 | 5   |      | idc3:zone2 |
-| 1970-01-01T00:00:15 | 7   |      | idc4:zone3 |
-+---------------------+-----+------+------------+
+Error: 1004(InvalidArguments), Invalid function argument for label_join
+
+-- Both hosts are joined to the same `host` at 0s, leaving two series with the same label set --
+TQL EVAL (0, 15, '5s') label_join(test, "host", "-", "idc");
+
+Error: 3001(EngineExecuteQuery), Execution error: vector cannot contain metrics with the same labelset
 
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_join(test{host="host1"}, "new_host", "-", "idc", "host");
@@ -114,13 +131,13 @@ TQL EVAL (0, 15, '5s') label_replace(test{host="host1"}, "new_idc", "$2", "idc",
 +---------------------+-----+---------+-------+------------+
 | ts                  | val | new_idc | host  | idc        |
 +---------------------+-----+---------+-------+------------+
-| 1970-01-01T00:00:00 | 1   | idc1    | host1 | idc1       |
-| 1970-01-01T00:00:05 | 1   | idc1    | host1 | idc1       |
+| 1970-01-01T00:00:00 | 1   |         | host1 | idc1       |
+| 1970-01-01T00:00:05 | 1   |         | host1 | idc1       |
 | 1970-01-01T00:00:05 | 3   | zone1   | host1 | idc2:zone1 |
-| 1970-01-01T00:00:10 | 1   | idc1    | host1 | idc1       |
+| 1970-01-01T00:00:10 | 1   |         | host1 | idc1       |
 | 1970-01-01T00:00:10 | 3   | zone1   | host1 | idc2:zone1 |
 | 1970-01-01T00:00:10 | 5   | zone2   | host1 | idc3:zone2 |
-| 1970-01-01T00:00:15 | 1   | idc1    | host1 | idc1       |
+| 1970-01-01T00:00:15 | 1   |         | host1 | idc1       |
 | 1970-01-01T00:00:15 | 3   | zone1   | host1 | idc2:zone1 |
 | 1970-01-01T00:00:15 | 5   | zone2   | host1 | idc3:zone2 |
 | 1970-01-01T00:00:15 | 7   | zone3   | host1 | idc4:zone3 |
@@ -129,20 +146,20 @@ TQL EVAL (0, 15, '5s') label_replace(test{host="host1"}, "new_idc", "$2", "idc",
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_replace(test{host="host1"}, "new_idc", "idc99", "idc", "idc2.*");
 
-+---------------------+-----+------------+-------+------------+
-| ts                  | val | new_idc    | host  | idc        |
-+---------------------+-----+------------+-------+------------+
-| 1970-01-01T00:00:00 | 1   | idc1       | host1 | idc1       |
-| 1970-01-01T00:00:05 | 1   | idc1       | host1 | idc1       |
-| 1970-01-01T00:00:05 | 3   | idc99      | host1 | idc2:zone1 |
-| 1970-01-01T00:00:10 | 1   | idc1       | host1 | idc1       |
-| 1970-01-01T00:00:10 | 3   | idc99      | host1 | idc2:zone1 |
-| 1970-01-01T00:00:10 | 5   | idc3:zone2 | host1 | idc3:zone2 |
-| 1970-01-01T00:00:15 | 1   | idc1       | host1 | idc1       |
-| 1970-01-01T00:00:15 | 3   | idc99      | host1 | idc2:zone1 |
-| 1970-01-01T00:00:15 | 5   | idc3:zone2 | host1 | idc3:zone2 |
-| 1970-01-01T00:00:15 | 7   | idc4:zone3 | host1 | idc4:zone3 |
-+---------------------+-----+------------+-------+------------+
++---------------------+-----+---------+-------+------------+
+| ts                  | val | new_idc | host  | idc        |
++---------------------+-----+---------+-------+------------+
+| 1970-01-01T00:00:00 | 1   |         | host1 | idc1       |
+| 1970-01-01T00:00:05 | 1   |         | host1 | idc1       |
+| 1970-01-01T00:00:05 | 3   | idc99   | host1 | idc2:zone1 |
+| 1970-01-01T00:00:10 | 1   |         | host1 | idc1       |
+| 1970-01-01T00:00:10 | 3   | idc99   | host1 | idc2:zone1 |
+| 1970-01-01T00:00:10 | 5   |         | host1 | idc3:zone2 |
+| 1970-01-01T00:00:15 | 1   |         | host1 | idc1       |
+| 1970-01-01T00:00:15 | 3   | idc99   | host1 | idc2:zone1 |
+| 1970-01-01T00:00:15 | 5   |         | host1 | idc3:zone2 |
+| 1970-01-01T00:00:15 | 7   |         | host1 | idc4:zone3 |
++---------------------+-----+---------+-------+------------+
 
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_replace(test{host="host2"}, "new_idc", "$2", "idc", "(.*):(.*)");
@@ -150,26 +167,61 @@ TQL EVAL (0, 15, '5s') label_replace(test{host="host2"}, "new_idc", "$2", "idc",
 +---------------------+-----+---------+-------+------+
 | ts                  | val | new_idc | host  | idc  |
 +---------------------+-----+---------+-------+------+
-| 1970-01-01T00:00:00 | 2   | idc1    | host2 | idc1 |
-| 1970-01-01T00:00:05 | 2   | idc1    | host2 | idc1 |
-| 1970-01-01T00:00:05 | 4   | idc2    | host2 | idc2 |
-| 1970-01-01T00:00:10 | 2   | idc1    | host2 | idc1 |
-| 1970-01-01T00:00:10 | 4   | idc2    | host2 | idc2 |
-| 1970-01-01T00:00:10 | 6   | idc3    | host2 | idc3 |
-| 1970-01-01T00:00:15 | 2   | idc1    | host2 | idc1 |
-| 1970-01-01T00:00:15 | 4   | idc2    | host2 | idc2 |
-| 1970-01-01T00:00:15 | 6   | idc3    | host2 | idc3 |
-| 1970-01-01T00:00:15 | 8   | idc4    | host2 | idc4 |
+| 1970-01-01T00:00:00 | 2   |         | host2 | idc1 |
+| 1970-01-01T00:00:05 | 2   |         | host2 | idc1 |
+| 1970-01-01T00:00:05 | 4   |         | host2 | idc2 |
+| 1970-01-01T00:00:10 | 2   |         | host2 | idc1 |
+| 1970-01-01T00:00:10 | 4   |         | host2 | idc2 |
+| 1970-01-01T00:00:10 | 6   |         | host2 | idc3 |
+| 1970-01-01T00:00:15 | 2   |         | host2 | idc1 |
+| 1970-01-01T00:00:15 | 4   |         | host2 | idc2 |
+| 1970-01-01T00:00:15 | 6   |         | host2 | idc3 |
+| 1970-01-01T00:00:15 | 8   |         | host2 | idc4 |
 +---------------------+-----+---------+-------+------+
 
 -- dst_label is equal to source label --
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_replace(test{host="host2"}, "idc", "$2", "idc", "(.*):(.*)");
 
-Error: 1004(InvalidArguments), vector cannot contain metrics with the same labelset
++---------------------+-----+------+-------+
+| ts                  | val | idc  | host  |
++---------------------+-----+------+-------+
+| 1970-01-01T00:00:00 | 2   | idc1 | host2 |
+| 1970-01-01T00:00:05 | 2   | idc1 | host2 |
+| 1970-01-01T00:00:05 | 4   | idc2 | host2 |
+| 1970-01-01T00:00:10 | 2   | idc1 | host2 |
+| 1970-01-01T00:00:10 | 4   | idc2 | host2 |
+| 1970-01-01T00:00:10 | 6   | idc3 | host2 |
+| 1970-01-01T00:00:15 | 2   | idc1 | host2 |
+| 1970-01-01T00:00:15 | 4   | idc2 | host2 |
+| 1970-01-01T00:00:15 | 6   | idc3 | host2 |
+| 1970-01-01T00:00:15 | 8   | idc4 | host2 |
++---------------------+-----+------+-------+
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 15, '5s') label_replace(test{host="host1"}, "idc", "$2", "idc", "(.*):(.*)");
+
++---------------------+-----+-------+-------+
+| ts                  | val | idc   | host  |
++---------------------+-----+-------+-------+
+| 1970-01-01T00:00:00 | 1   | idc1  | host1 |
+| 1970-01-01T00:00:05 | 1   | idc1  | host1 |
+| 1970-01-01T00:00:05 | 3   | zone1 | host1 |
+| 1970-01-01T00:00:10 | 1   | idc1  | host1 |
+| 1970-01-01T00:00:10 | 3   | zone1 | host1 |
+| 1970-01-01T00:00:10 | 5   | zone2 | host1 |
+| 1970-01-01T00:00:15 | 1   | idc1  | host1 |
+| 1970-01-01T00:00:15 | 3   | zone1 | host1 |
+| 1970-01-01T00:00:15 | 5   | zone2 | host1 |
+| 1970-01-01T00:00:15 | 7   | zone3 | host1 |
++---------------------+-----+-------+-------+
+
+-- Both hosts are rewritten to the same `host`, leaving two series with the same label set --
+TQL EVAL (0, 15, '5s') label_replace(test, "host", "x", "host", ".*");
+
+Error: 3001(EngineExecuteQuery), Execution error: vector cannot contain metrics with the same labelset
 
 -- test the empty source label --
--- TODO(dennis): we can't remove the label currently --
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_replace(test{host="host2"}, "idc2", "", "", "");
 
@@ -221,20 +273,20 @@ TQL EVAL(0, 15, '5s') {__name__="test",host="host1"} + label_replace(vector(1),
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL(0, 15, '5s') label_replace(test{host="host1"}, "host2", "host2", "host", "");
 
-+---------------------+-----+-------+------------+
-| ts                  | val | host  | idc        |
-+---------------------+-----+-------+------------+
-| 1970-01-01T00:00:00 | 1   | host1 | idc1       |
-| 1970-01-01T00:00:05 | 1   | host1 | idc1       |
-| 1970-01-01T00:00:05 | 3   | host1 | idc2:zone1 |
-| 1970-01-01T00:00:10 | 1   | host1 | idc1       |
-| 1970-01-01T00:00:10 | 3   | host1 | idc2:zone1 |
-| 1970-01-01T00:00:10 | 5   | host1 | idc3:zone2 |
-| 1970-01-01T00:00:15 | 1   | host1 | idc1       |
-| 1970-01-01T00:00:15 | 3   | host1 | idc2:zone1 |
-| 1970-01-01T00:00:15 | 5   | host1 | idc3:zone2 |
-| 1970-01-01T00:00:15 | 7   | host1 | idc4:zone3 |
-+---------------------+-----+-------+------------+
++---------------------+-----+-------+-------+------------+
+| ts                  | val | host2 | host  | idc        |
++---------------------+-----+-------+-------+------------+
+| 1970-01-01T00:00:00 | 1   |       | host1 | idc1       |
+| 1970-01-01T00:00:05 | 1   |       | host1 | idc1       |
+| 1970-01-01T00:00:05 | 3   |       | host1 | idc2:zone1 |
+| 1970-01-01T00:00:10 | 1   |       | host1 | idc1       |
+| 1970-01-01T00:00:10 | 3   |       | host1 | idc2:zone1 |
+| 1970-01-01T00:00:10 | 5   |       | host1 | idc3:zone2 |
+| 1970-01-01T00:00:15 | 1   |       | host1 | idc1       |
+| 1970-01-01T00:00:15 | 3   |       | host1 | idc2:zone1 |
+| 1970-01-01T00:00:15 | 5   |       | host1 | idc3:zone2 |
+| 1970-01-01T00:00:15 | 7   |       | host1 | idc4:zone3 |
++---------------------+-----+-------+-------+------------+
 
 -- Empty regex with not existing source label
 -- SQLNESS SORT_RESULT 3 1
@@ -274,6 +326,23 @@ TQL EVAL(0, 15, '5s') label_replace(test{host="host1"}, "host2", "", "instance",
 | 1970-01-01T00:00:15 | 7   | host1 | idc4:zone3 |
 +---------------------+-----+-------+------------+
 
+-- An empty replacement removes an existing label --
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 15, '5s') label_replace(test{idc="idc1"}, "idc", "", "instance", "");
+
++---------------------+-----+-----+-------+
+| ts                  | val | idc | host  |
++---------------------+-----+-----+-------+
+| 1970-01-01T00:00:00 | 1   |     | host1 |
+| 1970-01-01T00:00:00 | 2   |     | host2 |
+| 1970-01-01T00:00:05 | 1   |     | host1 |
+| 1970-01-01T00:00:05 | 2   |     | host2 |
+| 1970-01-01T00:00:10 | 1   |     | host1 |
+| 1970-01-01T00:00:10 | 2   |     | host2 |
+| 1970-01-01T00:00:15 | 1   |     | host1 |
+| 1970-01-01T00:00:15 | 2   |     | host2 |
++---------------------+-----+-----+-------+
+
 -- Empty regex and different label value
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL(0, 15, '5s') {__name__="test",host="host1"} * label_replace(vector(1), "host", "host2", "host", "");
@@ -307,10 +376,10 @@ TQL EVAL (0, 15, '5s') label_replace(test{host="host1"}, "new_idc", "idc99", "id
 +---------------------+-----+---------+-------+------+
 | ts                  | val | new_idc | host  | idc  |
 +---------------------+-----+---------+-------+------+
-| 1970-01-01T00:00:00 | 1   | idc1    | host1 | idc1 |
-| 1970-01-01T00:00:05 | 1   | idc1    | host1 | idc1 |
-| 1970-01-01T00:00:10 | 1   | idc1    | host1 | idc1 |
-| 1970-01-01T00:00:15 | 1   | idc1    | host1 | idc1 |
+| 1970-01-01T00:00:00 | 1   |         | host1 | idc1 |
+| 1970-01-01T00:00:05 | 1   |         | host1 | idc1 |
+| 1970-01-01T00:00:10 | 1   |         | host1 | idc1 |
+| 1970-01-01T00:00:15 | 1   |         | host1 | idc1 |
 +---------------------+-----+---------+-------+------+
 
 -- SQLNESS SORT_RESULT 3 1
@@ -415,3 +484,52 @@ DROP TABLE test;
 
 Affected Rows: 0
 
+-- Issue 9444 --
+-- Normalizing mixed histogram boundary representations must not be rejected while
+-- another label still tells the series apart.
+CREATE TABLE demo_bucket (
+  ts timestamp(3) time index,
+  instance STRING,
+  le STRING,
+  val DOUBLE,
+  PRIMARY KEY(instance, le),
+);
+
+Affected Rows: 0
+
+INSERT INTO TABLE demo_bucket VALUES
+    (3000000, 'a', '10', 40),
+    (3000000, 'a', '100', 50),
+    (3000000, 'a', '+Inf', 50),
+    (3000000, 'b', '10.0', 40),
+    (3000000, 'b', '100.0', 50),
+    (3000000, 'b', '1000.0', 50),
+    (3000000, 'b', '+Inf', 50);
+
+Affected Rows: 7
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (3000, 3000, '5s') label_replace(demo_bucket, "le", "$1", "le", "([0-9]+)[.]0+");
+
++---------------------+------+------+----------+
+| ts                  | val  | le   | instance |
++---------------------+------+------+----------+
+| 1970-01-01T00:50:00 | 40.0 | 10   | a        |
+| 1970-01-01T00:50:00 | 40.0 | 10   | b        |
+| 1970-01-01T00:50:00 | 50.0 | +Inf | a        |
+| 1970-01-01T00:50:00 | 50.0 | +Inf | b        |
+| 1970-01-01T00:50:00 | 50.0 | 100  | a        |
+| 1970-01-01T00:50:00 | 50.0 | 100  | b        |
+| 1970-01-01T00:50:00 | 50.0 | 1000 | b        |
++---------------------+------+------+----------+
+
+-- Aggregating `instance` away first makes the same rewrite collapse two series into
+-- one label set, which is a genuine duplicate and must still fail.
+TQL EVAL (3000, 3000, '5s') label_replace(sum by (le) (demo_bucket), "le", "$1", "le", "([0-9]+)[.]0+");
+
+Error: 3001(EngineExecuteQuery), Execution error: vector cannot contain metrics with the same labelset
+
+DROP TABLE demo_bucket;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/promql/label.sql b/tests/cases/standalone/common/promql/label.sql
index 6a77e9b5214..e269b6a1783 100644
--- a/tests/cases/standalone/common/promql/label.sql
+++ b/tests/cases/standalone/common/promql/label.sql
@@ -17,6 +17,7 @@ INSERT INTO TABLE test VALUES
     (15000, 'host2', 'idc4',8);
 
 -- Missing source labels --
+-- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_join(test{host="host1"}, "new_host", "-");
 
 -- dst_label is equal to source label --
@@ -27,10 +28,15 @@ TQL EVAL (0, 15, '5s') label_join(test{host="host1"}, "host", "-", "host");
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_join(test{host="host1"}, "host", "-", "idc", "host");
 
--- test the empty source label --
--- SQLNESS SORT_RESULT 3 1
+-- Absent labels join as empty strings and keep their separators --
+TQL EVAL (0, 15, '5s') label_join(label_join(vector(1), "a", "", "missing"), "b", "-", "a", "a");
+
+-- An empty source label name is invalid --
 TQL EVAL (0, 15, '5s') label_join(test{host="host1"}, "host", "-", "");
 
+-- Both hosts are joined to the same `host` at 0s, leaving two series with the same label set --
+TQL EVAL (0, 15, '5s') label_join(test, "host", "-", "idc");
+
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_join(test{host="host1"}, "new_host", "-", "idc", "host");
 
@@ -50,8 +56,13 @@ TQL EVAL (0, 15, '5s') label_replace(test{host="host2"}, "new_idc", "$2", "idc",
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_replace(test{host="host2"}, "idc", "$2", "idc", "(.*):(.*)");
 
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 15, '5s') label_replace(test{host="host1"}, "idc", "$2", "idc", "(.*):(.*)");
+
+-- Both hosts are rewritten to the same `host`, leaving two series with the same label set --
+TQL EVAL (0, 15, '5s') label_replace(test, "host", "x", "host", ".*");
+
 -- test the empty source label --
--- TODO(dennis): we can't remove the label currently --
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 15, '5s') label_replace(test{host="host2"}, "idc2", "", "", "");
 
@@ -77,6 +88,10 @@ TQL EVAL(0, 15, '5s') label_replace(test{host="host1"}, "host2", "host2", "insta
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL(0, 15, '5s') label_replace(test{host="host1"}, "host2", "", "instance", "");
 
+-- An empty replacement removes an existing label --
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (0, 15, '5s') label_replace(test{idc="idc1"}, "idc", "", "instance", "");
+
 -- Empty regex and different label value
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL(0, 15, '5s') {__name__="test",host="host1"} * label_replace(vector(1), "host", "host2", "host", "");
@@ -129,3 +144,32 @@ TQL EVAL (0, 1, '5s') test{job=""};
 TQL EVAL (0, 1, '5s') test{job!=""};
 
 DROP TABLE test;
+
+-- Issue 9444 --
+-- Normalizing mixed histogram boundary representations must not be rejected while
+-- another label still tells the series apart.
+CREATE TABLE demo_bucket (
+  ts timestamp(3) time index,
+  instance STRING,
+  le STRING,
+  val DOUBLE,
+  PRIMARY KEY(instance, le),
+);
+
+INSERT INTO TABLE demo_bucket VALUES
+    (3000000, 'a', '10', 40),
+    (3000000, 'a', '100', 50),
+    (3000000, 'a', '+Inf', 50),
+    (3000000, 'b', '10.0', 40),
+    (3000000, 'b', '100.0', 50),
+    (3000000, 'b', '1000.0', 50),
+    (3000000, 'b', '+Inf', 50);
+
+-- SQLNESS SORT_RESULT 3 1
+TQL EVAL (3000, 3000, '5s') label_replace(demo_bucket, "le", "$1", "le", "([0-9]+)[.]0+");
+
+-- Aggregating `instance` away first makes the same rewrite collapse two series into
+-- one label set, which is a genuine duplicate and must still fail.
+TQL EVAL (3000, 3000, '5s') label_replace(sum by (le) (demo_bucket), "le", "$1", "le", "([0-9]+)[.]0+");
+
+DROP TABLE demo_bucket;
diff --git a/tests/cases/standalone/common/promql/math.result b/tests/cases/standalone/common/promql/math.result
index a6271c158cb..e1b884c50f1 100644
--- a/tests/cases/standalone/common/promql/math.result
+++ b/tests/cases/standalone/common/promql/math.result
@@ -55,15 +55,15 @@ TQL EVAL (0, 20, '5s') pi() + 1;
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 20, '5s') angles{unit="radians"} * pi();
 
-+---------------------+--------------------+
-| time                | angles.val * .pi() |
-+---------------------+--------------------+
-| 1970-01-01T00:00:00 | 0.0                |
-| 1970-01-01T00:00:05 | 4.934813740258847  |
-| 1970-01-01T00:00:10 | 9.869627480517694  |
-| 1970-01-01T00:00:15 | 14.80444122077654  |
-| 1970-01-01T00:00:20 | 19.73925496103539  |
-+---------------------+--------------------+
++---------+---------------------+--------------------+
+| unit    | ts                  | angles.val * .pi() |
++---------+---------------------+--------------------+
+| radians | 1970-01-01T00:00:00 | 0.0                |
+| radians | 1970-01-01T00:00:05 | 4.934813740258847  |
+| radians | 1970-01-01T00:00:10 | 9.869627480517694  |
+| radians | 1970-01-01T00:00:15 | 14.80444122077654  |
+| radians | 1970-01-01T00:00:20 | 19.73925496103539  |
++---------+---------------------+--------------------+
 
 -- Test rad() function (converts degrees to radians)
 -- SQLNESS SORT_RESULT 3 1
@@ -310,18 +310,18 @@ TQL EVAL (25, 35, '5s') sgn(angles - 42.5);
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (0, 35, '5s') sgn(angles{unit="radians"} - pi());
 
-+---------------------+----------------------------+
-| time                | signum(angles.val - .pi()) |
-+---------------------+----------------------------+
-| 1970-01-01T00:00:00 | -1.0                       |
-| 1970-01-01T00:00:05 | -1.0                       |
-| 1970-01-01T00:00:10 | 1.0                        |
-| 1970-01-01T00:00:15 | 1.0                        |
-| 1970-01-01T00:00:20 | 1.0                        |
-| 1970-01-01T00:00:25 | 1.0                        |
-| 1970-01-01T00:00:30 | 1.0                        |
-| 1970-01-01T00:00:35 | 1.0                        |
-+---------------------+----------------------------+
++---------------------+----------------------------+---------+
+| ts                  | signum(angles.val - .pi()) | unit    |
++---------------------+----------------------------+---------+
+| 1970-01-01T00:00:00 | -1.0                       | radians |
+| 1970-01-01T00:00:05 | -1.0                       | radians |
+| 1970-01-01T00:00:10 | 1.0                        | radians |
+| 1970-01-01T00:00:15 | 1.0                        | radians |
+| 1970-01-01T00:00:20 | 1.0                        | radians |
+| 1970-01-01T00:00:25 | 1.0                        | radians |
+| 1970-01-01T00:00:30 | 1.0                        | radians |
+| 1970-01-01T00:00:35 | 1.0                        | radians |
++---------------------+----------------------------+---------+
 
 -- SQLNESS SORT_RESULT 3 1
 TQL EVAL (25, 35, '5s') sgn(angles) * angles;
diff --git a/tests/cases/standalone/common/promql/native_time_selection.result b/tests/cases/standalone/common/promql/native_time_selection.result
index 2c0e20847cb..945189e68f6 100644
--- a/tests/cases/standalone/common/promql/native_time_selection.result
+++ b/tests/cases/standalone/common/promql/native_time_selection.result
@@ -613,6 +613,15 @@ TQL EVAL (1, 1, '1s', '1s') native_time_sec offset -500ms;
 | 11.0 | 1970-01-01T00:00:01 |
 +------+---------------------+
 
+-- `timestamp()` reports the timestamp of the selected sample (1s), without the offset applied.
+TQL EVAL (1, 1, '1s', '1s') timestamp(native_time_sec offset -500ms);
+
++---------------------+-------+
+| ts                  | value |
++---------------------+-------+
+| 1970-01-01T00:00:01 | 1.0   |
++---------------------+-------+
+
 DROP TABLE native_time_sec;
 
 Affected Rows: 0
diff --git a/tests/cases/standalone/common/promql/native_time_selection.sql b/tests/cases/standalone/common/promql/native_time_selection.sql
index ca795b0b3ad..204b047ef23 100644
--- a/tests/cases/standalone/common/promql/native_time_selection.sql
+++ b/tests/cases/standalone/common/promql/native_time_selection.sql
@@ -219,4 +219,6 @@ CREATE TABLE native_time_sec (ts TIMESTAMP(0) TIME INDEX, val DOUBLE);
 INSERT INTO native_time_sec VALUES (0, 10), (1, 11), (2, 12);
 TQL EVAL (1, 1, '1s', '1s') native_time_sec offset 500ms;
 TQL EVAL (1, 1, '1s', '1s') native_time_sec offset -500ms;
+-- `timestamp()` reports the timestamp of the selected sample (1s), without the offset applied.
+TQL EVAL (1, 1, '1s', '1s') timestamp(native_time_sec offset -500ms);
 DROP TABLE native_time_sec;
diff --git a/tests/cases/standalone/common/promql/range_vector_result.result b/tests/cases/standalone/common/promql/range_vector_result.result
new file mode 100644
index 00000000000..20d60c19480
--- /dev/null
+++ b/tests/cases/standalone/common/promql/range_vector_result.result
@@ -0,0 +1,143 @@
+-- An instant query of a range-vector expression returns the selected samples
+-- with their own timestamps. Expected results are from Prometheus 3.
+create table range_vector_result (
+    ts timestamp time index,
+    val double,
+    host string primary key
+);
+
+Affected Rows: 0
+
+insert into range_vector_result values
+    (0, 1.0, 'a'),
+    (10000, 2.0, 'a'),
+    (20000, 3.0, 'a'),
+    (30000, 4.0, 'a'),
+    (0, 10.0, 'b'),
+    (20000, 30.0, 'b');
+
+Affected Rows: 6
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[20s];
+
++---------------------+------+------+
+| ts                  | val  | host |
++---------------------+------+------+
+| 1970-01-01T00:00:20 | 3.0  | a    |
+| 1970-01-01T00:00:20 | 30.0 | b    |
+| 1970-01-01T00:00:30 | 4.0  | a    |
++---------------------+------+------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[20s] offset 10s;
+
++---------------------+------+------+
+| ts                  | val  | host |
++---------------------+------+------+
+| 1970-01-01T00:00:10 | 2.0  | a    |
+| 1970-01-01T00:00:20 | 3.0  | a    |
+| 1970-01-01T00:00:20 | 30.0 | b    |
++---------------------+------+------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[15s] @ 20;
+
++---------------------+------+------+
+| ts                  | val  | host |
++---------------------+------+------+
+| 1970-01-01T00:00:10 | 2.0  | a    |
+| 1970-01-01T00:00:20 | 3.0  | a    |
+| 1970-01-01T00:00:20 | 30.0 | b    |
++---------------------+------+------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[30s:10s];
+
++---------------------+------+------+
+| ts                  | val  | host |
++---------------------+------+------+
+| 1970-01-01T00:00:10 | 10.0 | b    |
+| 1970-01-01T00:00:10 | 2.0  | a    |
+| 1970-01-01T00:00:20 | 3.0  | a    |
+| 1970-01-01T00:00:20 | 30.0 | b    |
+| 1970-01-01T00:00:30 | 30.0 | b    |
+| 1970-01-01T00:00:30 | 4.0  | a    |
++---------------------+------+------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[35s:10s] offset 5s;
+
++---------------------+------+------+
+| ts                  | val  | host |
++---------------------+------+------+
+| 1970-01-01T00:00:00 | 1.0  | a    |
+| 1970-01-01T00:00:00 | 10.0 | b    |
+| 1970-01-01T00:00:10 | 10.0 | b    |
+| 1970-01-01T00:00:10 | 2.0  | a    |
+| 1970-01-01T00:00:20 | 3.0  | a    |
+| 1970-01-01T00:00:20 | 30.0 | b    |
++---------------------+------+------+
+
+tql eval (35, 35, '1s') range_vector_result[4s:10s];
+
++----+-----+------+
+| ts | val | host |
++----+-----+------+
++----+-----+------+
+
+tql eval (0, 30, '10s') range_vector_result[20s];
+
+Error: 1004(InvalidArguments), invalid expression type "range vector" for range query, must be Scalar or instant Vector
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[20s] as v;
+
++------+------+---------------------+
+| v    | host | ts                  |
++------+------+---------------------+
+| 3.0  | a    | 1970-01-01T00:00:20 |
+| 30.0 | b    | 1970-01-01T00:00:20 |
+| 4.0  | a    | 1970-01-01T00:00:30 |
++------+------+---------------------+
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+tql explain (30, 30, '1s') range_vector_result[20s];
+
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| plan_type     | plan                                                                                                                                                                               |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| logical_plan  | MergeScan [is_placeholder=false, remote_input=[                                                                                                                                    |
+|               | PromSeriesNormalize: offset=[0], time index=[ts], filter NaN: [true]                                                                                                               |
+|               |   PromSeriesDivide: tags=["host"]                                                                                                                                                  |
+|               |     Sort: range_vector_result.host ASC NULLS FIRST, range_vector_result.ts ASC NULLS FIRST                                                                                         |
+|               |       Filter: range_vector_result.ts >= TimestampMillisecond(10001, None) AND range_vector_result.ts <= TimestampMillisecond(30000, None)                                          |
+|               |         TableScan: range_vector_result, partial_filters=[range_vector_result.ts >= TimestampMillisecond(10001, None), range_vector_result.ts <= TimestampMillisecond(30000, None)] |
+|               | ]]                                                                                                                                                                                 |
+| physical_plan | CooperativeExec                                                                                                                                                                    |
+|               |   MergeScanExec: REDACTED
+|               |                                                                                                                                                                                    |
++---------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+tql eval (30, 30, '1s') range_vector_result[30s:0.0001];
+
+Error: 1004(InvalidArguments), Subquery step must be positive
+
+-- A subquery without a step uses the one-minute default, not the query step.
+tql eval (300, 300, '1s') vector(1)[5m:];
+
++---------------------+----------------+
+| time                | greptime_value |
++---------------------+----------------+
+| 1970-01-01T00:01:00 | 1.0            |
+| 1970-01-01T00:02:00 | 1.0            |
+| 1970-01-01T00:03:00 | 1.0            |
+| 1970-01-01T00:04:00 | 1.0            |
+| 1970-01-01T00:05:00 | 1.0            |
++---------------------+----------------+
+
+drop table range_vector_result;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/promql/range_vector_result.sql b/tests/cases/standalone/common/promql/range_vector_result.sql
new file mode 100644
index 00000000000..78fdbd81b4f
--- /dev/null
+++ b/tests/cases/standalone/common/promql/range_vector_result.sql
@@ -0,0 +1,49 @@
+-- An instant query of a range-vector expression returns the selected samples
+-- with their own timestamps. Expected results are from Prometheus 3.
+
+create table range_vector_result (
+    ts timestamp time index,
+    val double,
+    host string primary key
+);
+
+insert into range_vector_result values
+    (0, 1.0, 'a'),
+    (10000, 2.0, 'a'),
+    (20000, 3.0, 'a'),
+    (30000, 4.0, 'a'),
+    (0, 10.0, 'b'),
+    (20000, 30.0, 'b');
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[20s];
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[20s] offset 10s;
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[15s] @ 20;
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[30s:10s];
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[35s:10s] offset 5s;
+
+tql eval (35, 35, '1s') range_vector_result[4s:10s];
+
+tql eval (0, 30, '10s') range_vector_result[20s];
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (30, 30, '1s') range_vector_result[20s] as v;
+
+-- SQLNESS REPLACE (peers.*) REDACTED
+-- SQLNESS REPLACE (partitioning.*) REDACTED
+tql explain (30, 30, '1s') range_vector_result[20s];
+
+tql eval (30, 30, '1s') range_vector_result[30s:0.0001];
+
+-- A subquery without a step uses the one-minute default, not the query step.
+tql eval (300, 300, '1s') vector(1)[5m:];
+
+drop table range_vector_result;
diff --git a/tests/cases/standalone/common/promql/regex.result b/tests/cases/standalone/common/promql/regex.result
index c76b743eafa..c2a10626ff8 100644
--- a/tests/cases/standalone/common/promql/regex.result
+++ b/tests/cases/standalone/common/promql/regex.result
@@ -146,13 +146,93 @@ TQL ANALYZE VERBOSE (0, 0, '1s') test{host!~".+"};
 |_|_|_|
 | 1_| 0_|_PromInstantManipulateExec: range=[0..0], lookback=[300000], interval=[1000], time index=[ts] REDACTED
 |_|_|_PromSeriesDivideExec: tags=["host"] REDACTED
-|_|_|_FilterExec: CASE WHEN host@1 IS NOT NULL THEN host@1 ELSE_END = REDACTED
 |_|_|_CooperativeExec REDACTED
-|_|_|_SeriesScan: region=REDACTED, {"partition_count":{"count":1, "mem_ranges":1, "files":0, "file_ranges":0}, "distribution":"PerSeries", "projection": ["ts", "host", "val"], "filters": ["CASE WHEN host IS NOT NULL THEN host ELSE Dictionary(UInt32, Utf8(\"\")) END = Dictionary(UInt32, Utf8(\"\"))", "ts >= TimestampMillisecond(-299999, None)", "ts <= TimestampMillisecond(0, None)"], "REDACTED
+|_|_|_SeriesScan: region=REDACTED, {"partition_count":{"count":1, "mem_ranges":1, "files":0, "file_ranges":0}, "selector":"LastRow { after_merge: true }", "distribution":"PerSeries", "projection": ["ts", "host", "val"], "filters": ["host IS NULL OR host = Dictionary(UInt32, Utf8(\"\"))", "ts >= TimestampMillisecond(-299999, None)", "ts <= TimestampMillisecond(0, None)"], "REDACTED
 |_|_|_|
 |_|_| Total rows: 0_|
 +-+-+-+
 
+INSERT INTO test VALUES (0, NULL, 2), (0, '', 3), (0, 'ext4', 4), (0, 'tmpfs', 5);
+
+Affected Rows: 4
+
+TQL EVAL (0, 0, '1s') test{host!="tmpfs"};
+
++---------------------+-------------------+-----+
+| ts                  | host              | val |
++---------------------+-------------------+-----+
+| 1970-01-01T00:00:00 |                   | 2   |
+| 1970-01-01T00:00:00 |                   | 3   |
+| 1970-01-01T00:00:00 | 10.0.160.237:8080 | 1   |
+| 1970-01-01T00:00:00 | 10.0.160.237:8081 | 1   |
+| 1970-01-01T00:00:00 | ext4              | 4   |
++---------------------+-------------------+-----+
+
+TQL EVAL (0, 0, '1s') test{host!~"tmpfs|vfat"};
+
++---------------------+-------------------+-----+
+| ts                  | host              | val |
++---------------------+-------------------+-----+
+| 1970-01-01T00:00:00 |                   | 2   |
+| 1970-01-01T00:00:00 |                   | 3   |
+| 1970-01-01T00:00:00 | 10.0.160.237:8080 | 1   |
+| 1970-01-01T00:00:00 | 10.0.160.237:8081 | 1   |
+| 1970-01-01T00:00:00 | ext4              | 4   |
++---------------------+-------------------+-----+
+
+TQL EVAL (0, 0, '1s') test{host=""};
+
++---------------------+------+-----+
+| ts                  | host | val |
++---------------------+------+-----+
+| 1970-01-01T00:00:00 |      | 2   |
+| 1970-01-01T00:00:00 |      | 3   |
++---------------------+------+-----+
+
+TQL EVAL (0, 0, '1s') test{host!=""};
+
++---------------------+-------------------+-----+
+| ts                  | host              | val |
++---------------------+-------------------+-----+
+| 1970-01-01T00:00:00 | 10.0.160.237:8080 | 1   |
+| 1970-01-01T00:00:00 | 10.0.160.237:8081 | 1   |
+| 1970-01-01T00:00:00 | ext4              | 4   |
+| 1970-01-01T00:00:00 | tmpfs             | 5   |
++---------------------+-------------------+-----+
+
+TQL EVAL (0, 0, '1s') test{host=~"ext4|"};
+
++---------------------+------+-----+
+| ts                  | host | val |
++---------------------+------+-----+
+| 1970-01-01T00:00:00 |      | 2   |
+| 1970-01-01T00:00:00 |      | 3   |
+| 1970-01-01T00:00:00 | ext4 | 4   |
++---------------------+------+-----+
+
+TQL EVAL (0, 0, '1s') test{host!~"ext4|"};
+
++---------------------+-------------------+-----+
+| ts                  | host              | val |
++---------------------+-------------------+-----+
+| 1970-01-01T00:00:00 | 10.0.160.237:8080 | 1   |
+| 1970-01-01T00:00:00 | 10.0.160.237:8081 | 1   |
+| 1970-01-01T00:00:00 | tmpfs             | 5   |
++---------------------+-------------------+-----+
+
+TQL EVAL (0, 0, '1s') test{missing!="lo"};
+
++---------------------+-------------------+-----+
+| ts                  | host              | val |
++---------------------+-------------------+-----+
+| 1970-01-01T00:00:00 |                   | 2   |
+| 1970-01-01T00:00:00 |                   | 3   |
+| 1970-01-01T00:00:00 | 10.0.160.237:8080 | 1   |
+| 1970-01-01T00:00:00 | 10.0.160.237:8081 | 1   |
+| 1970-01-01T00:00:00 | ext4              | 4   |
+| 1970-01-01T00:00:00 | tmpfs             | 5   |
++---------------------+-------------------+-----+
+
 DROP TABLE test;
 
 Affected Rows: 0
diff --git a/tests/cases/standalone/common/promql/regex.sql b/tests/cases/standalone/common/promql/regex.sql
index 9804e098e64..80a8f3ed381 100644
--- a/tests/cases/standalone/common/promql/regex.sql
+++ b/tests/cases/standalone/common/promql/regex.sql
@@ -59,4 +59,14 @@ TQL ANALYZE VERBOSE (0, 0, '1s') test{host!~".*"};
 -- SQLNESS REPLACE (flat_format.*) REDACTED
 TQL ANALYZE VERBOSE (0, 0, '1s') test{host!~".+"};
 
+INSERT INTO test VALUES (0, NULL, 2), (0, '', 3), (0, 'ext4', 4), (0, 'tmpfs', 5);
+
+TQL EVAL (0, 0, '1s') test{host!="tmpfs"};
+TQL EVAL (0, 0, '1s') test{host!~"tmpfs|vfat"};
+TQL EVAL (0, 0, '1s') test{host=""};
+TQL EVAL (0, 0, '1s') test{host!=""};
+TQL EVAL (0, 0, '1s') test{host=~"ext4|"};
+TQL EVAL (0, 0, '1s') test{host!~"ext4|"};
+TQL EVAL (0, 0, '1s') test{missing!="lo"};
+
 DROP TABLE test;
diff --git a/tests/cases/standalone/common/promql/simple_histogram.result b/tests/cases/standalone/common/promql/simple_histogram.result
index a794a30e8b9..95cc6b6aa30 100644
--- a/tests/cases/standalone/common/promql/simple_histogram.result
+++ b/tests/cases/standalone/common/promql/simple_histogram.result
@@ -436,3 +436,92 @@ drop table histogram5_bucket;
 
 Affected Rows: 0
 
+-- Issue #9443: string labels stay distinct during aggregation, but equal
+-- numeric bucket boundaries must be coalesced before monotonicity repair.
+CREATE TABLE equivalent_bounds_bucket (
+    ts TIMESTAMP TIME INDEX,
+    instance STRING,
+    le STRING,
+    val DOUBLE,
+    PRIMARY KEY (instance, le)
+);
+
+Affected Rows: 0
+
+INSERT INTO equivalent_bounds_bucket VALUES
+    (3000000, 'a', '10', 40),
+    (3000000, 'a', '100', 50),
+    (3000000, 'a', '+Inf', 50),
+    (3000000, 'b', '10.0', 40),
+    (3000000, 'b', '100.0', 50),
+    (3000000, 'b', '1000.0', 50),
+    (3000000, 'b', '+Inf', 50);
+
+Affected Rows: 7
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (3000, 3000, '1s') sum by (le) (equivalent_bounds_bucket);
+
++--------+---------------------+-----------------------------------+
+| le     | ts                  | sum(equivalent_bounds_bucket.val) |
++--------+---------------------+-----------------------------------+
+| +Inf   | 1970-01-01T00:50:00 | 100.0                             |
+| 10     | 1970-01-01T00:50:00 | 40.0                              |
+| 10.0   | 1970-01-01T00:50:00 | 40.0                              |
+| 100    | 1970-01-01T00:50:00 | 50.0                              |
+| 100.0  | 1970-01-01T00:50:00 | 50.0                              |
+| 1000.0 | 1970-01-01T00:50:00 | 50.0                              |
++--------+---------------------+-----------------------------------+
+
+tql eval (3000, 3000, '1s') histogram_quantile(0.95, sum by (le) (equivalent_bounds_bucket));
+
++---------------------+-----------------------------------+
+| ts                  | sum(equivalent_bounds_bucket.val) |
++---------------------+-----------------------------------+
+| 1970-01-01T00:50:00 | 77.5                              |
++---------------------+-----------------------------------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (3000, 3000, '1s') histogram_quantile(0.95, sum by (instance, le) (equivalent_bounds_bucket));
+
++----------+---------------------+-----------------------------------+
+| instance | ts                  | sum(equivalent_bounds_bucket.val) |
++----------+---------------------+-----------------------------------+
+| a        | 1970-01-01T00:50:00 | 77.5                              |
+| b        | 1970-01-01T00:50:00 | 77.5                              |
++----------+---------------------+-----------------------------------+
+
+DROP TABLE equivalent_bounds_bucket;
+
+Affected Rows: 0
+
+-- Equivalent infinity labels belong to the same histogram until the group ends.
+CREATE TABLE infinity_bounds_bucket (
+    ts TIMESTAMP TIME INDEX,
+    le STRING,
+    val DOUBLE,
+    PRIMARY KEY (le)
+);
+
+Affected Rows: 0
+
+INSERT INTO infinity_bounds_bucket VALUES
+    (3000000, '10', 20),
+    (3000000, '10.0', 20),
+    (3000000, '+Inf', 25),
+    (3000000, '+inf', 25);
+
+Affected Rows: 4
+
+tql eval (3000, 3000, '1s') histogram_quantile(0.5, infinity_bounds_bucket);
+
++---------------------+------+
+| ts                  | val  |
++---------------------+------+
+| 1970-01-01T00:50:00 | 6.25 |
++---------------------+------+
+
+DROP TABLE infinity_bounds_bucket;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/promql/simple_histogram.sql b/tests/cases/standalone/common/promql/simple_histogram.sql
index ec0bf9b1439..6f73325a61f 100644
--- a/tests/cases/standalone/common/promql/simple_histogram.sql
+++ b/tests/cases/standalone/common/promql/simple_histogram.sql
@@ -253,3 +253,50 @@ insert into histogram5_bucket values
 tql eval (3000, 3015, '3s') histogram_quantile(0.5, histogram5_bucket);
 
 drop table histogram5_bucket;
+
+-- Issue #9443: string labels stay distinct during aggregation, but equal
+-- numeric bucket boundaries must be coalesced before monotonicity repair.
+CREATE TABLE equivalent_bounds_bucket (
+    ts TIMESTAMP TIME INDEX,
+    instance STRING,
+    le STRING,
+    val DOUBLE,
+    PRIMARY KEY (instance, le)
+);
+
+INSERT INTO equivalent_bounds_bucket VALUES
+    (3000000, 'a', '10', 40),
+    (3000000, 'a', '100', 50),
+    (3000000, 'a', '+Inf', 50),
+    (3000000, 'b', '10.0', 40),
+    (3000000, 'b', '100.0', 50),
+    (3000000, 'b', '1000.0', 50),
+    (3000000, 'b', '+Inf', 50);
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (3000, 3000, '1s') sum by (le) (equivalent_bounds_bucket);
+
+tql eval (3000, 3000, '1s') histogram_quantile(0.95, sum by (le) (equivalent_bounds_bucket));
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (3000, 3000, '1s') histogram_quantile(0.95, sum by (instance, le) (equivalent_bounds_bucket));
+
+DROP TABLE equivalent_bounds_bucket;
+
+-- Equivalent infinity labels belong to the same histogram until the group ends.
+CREATE TABLE infinity_bounds_bucket (
+    ts TIMESTAMP TIME INDEX,
+    le STRING,
+    val DOUBLE,
+    PRIMARY KEY (le)
+);
+
+INSERT INTO infinity_bounds_bucket VALUES
+    (3000000, '10', 20),
+    (3000000, '10.0', 20),
+    (3000000, '+Inf', 25),
+    (3000000, '+inf', 25);
+
+tql eval (3000, 3000, '1s') histogram_quantile(0.5, infinity_bounds_bucket);
+
+DROP TABLE infinity_bounds_bucket;
diff --git a/tests/cases/standalone/common/promql/sub_millisecond_interval.result b/tests/cases/standalone/common/promql/sub_millisecond_interval.result
new file mode 100644
index 00000000000..6461c8e0b0d
--- /dev/null
+++ b/tests/cases/standalone/common/promql/sub_millisecond_interval.result
@@ -0,0 +1,77 @@
+-- The last two 'sub_ms' samples are 400ns apart and share one millisecond, which
+-- irate and idelta cannot resolve, so they return no point instead of inf.
+-- The 'one_ms' samples are 1ms apart and still produce a rate.
+CREATE TABLE sub_ms_interval (
+    job STRING,
+    `value` DOUBLE,
+    ts TIMESTAMP(9) TIME INDEX,
+    PRIMARY KEY(job)
+);
+
+Affected Rows: 0
+
+INSERT INTO sub_ms_interval VALUES
+    ('sub_ms', 999, 999999900),
+    ('sub_ms', 10, 999999100),
+    ('sub_ms', 13, 999999500),
+    ('one_ms', 10, 998000000),
+    ('one_ms', 13, 999000000);
+
+Affected Rows: 5
+
+SELECT * FROM sub_ms_interval ORDER BY job, ts;
+
++--------+-------+-------------------------------+
+| job    | value | ts                            |
++--------+-------+-------------------------------+
+| one_ms | 10.0  | 1970-01-01T00:00:00.998       |
+| one_ms | 13.0  | 1970-01-01T00:00:00.999       |
+| sub_ms | 10.0  | 1970-01-01T00:00:00.999999100 |
+| sub_ms | 13.0  | 1970-01-01T00:00:00.999999500 |
+| sub_ms | 999.0 | 1970-01-01T00:00:00.999999900 |
++--------+-------+-------------------------------+
+
+TQL EVAL (1, 1, '1s') irate(sub_ms_interval[5s]);
+
++---------------------+----------------------------+--------+
+| ts                  | prom_irate(ts_range,value) | job    |
++---------------------+----------------------------+--------+
+| 1970-01-01T00:00:01 | 3000.0                     | one_ms |
++---------------------+----------------------------+--------+
+
+TQL EVAL (1, 1, '1s') idelta(sub_ms_interval[5s]);
+
++---------------------+-----------------------------+--------+
+| ts                  | prom_idelta(ts_range,value) | job    |
++---------------------+-----------------------------+--------+
+| 1970-01-01T00:00:01 | 3.0                         | one_ms |
++---------------------+-----------------------------+--------+
+
+ADMIN FLUSH_TABLE('sub_ms_interval');
+
++--------------------------------------+
+| ADMIN FLUSH_TABLE('sub_ms_interval') |
++--------------------------------------+
+| 0                                    |
++--------------------------------------+
+
+TQL EVAL (1, 1, '1s') irate(sub_ms_interval[5s]);
+
++---------------------+----------------------------+--------+
+| ts                  | prom_irate(ts_range,value) | job    |
++---------------------+----------------------------+--------+
+| 1970-01-01T00:00:01 | 3000.0                     | one_ms |
++---------------------+----------------------------+--------+
+
+TQL EVAL (1, 1, '1s') idelta(sub_ms_interval[5s]);
+
++---------------------+-----------------------------+--------+
+| ts                  | prom_idelta(ts_range,value) | job    |
++---------------------+-----------------------------+--------+
+| 1970-01-01T00:00:01 | 3.0                         | one_ms |
++---------------------+-----------------------------+--------+
+
+DROP TABLE sub_ms_interval;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/promql/sub_millisecond_interval.sql b/tests/cases/standalone/common/promql/sub_millisecond_interval.sql
new file mode 100644
index 00000000000..d643479390d
--- /dev/null
+++ b/tests/cases/standalone/common/promql/sub_millisecond_interval.sql
@@ -0,0 +1,30 @@
+-- The last two 'sub_ms' samples are 400ns apart and share one millisecond, which
+-- irate and idelta cannot resolve, so they return no point instead of inf.
+-- The 'one_ms' samples are 1ms apart and still produce a rate.
+CREATE TABLE sub_ms_interval (
+    job STRING,
+    `value` DOUBLE,
+    ts TIMESTAMP(9) TIME INDEX,
+    PRIMARY KEY(job)
+);
+
+INSERT INTO sub_ms_interval VALUES
+    ('sub_ms', 999, 999999900),
+    ('sub_ms', 10, 999999100),
+    ('sub_ms', 13, 999999500),
+    ('one_ms', 10, 998000000),
+    ('one_ms', 13, 999000000);
+
+SELECT * FROM sub_ms_interval ORDER BY job, ts;
+
+TQL EVAL (1, 1, '1s') irate(sub_ms_interval[5s]);
+
+TQL EVAL (1, 1, '1s') idelta(sub_ms_interval[5s]);
+
+ADMIN FLUSH_TABLE('sub_ms_interval');
+
+TQL EVAL (1, 1, '1s') irate(sub_ms_interval[5s]);
+
+TQL EVAL (1, 1, '1s') idelta(sub_ms_interval[5s]);
+
+DROP TABLE sub_ms_interval;
diff --git a/tests/cases/standalone/common/promql/subquery.result b/tests/cases/standalone/common/promql/subquery.result
index 12e65c4310c..1be8073a541 100644
--- a/tests/cases/standalone/common/promql/subquery.result
+++ b/tests/cases/standalone/common/promql/subquery.result
@@ -63,3 +63,270 @@ drop table metric_total;
 
 Affected Rows: 0
 
+-- Offset on a subquery shifts the subquery's own evaluation window back by the offset.
+-- Reference: Prometheus `evaluator.subqueryTimeRange` (promql/engine.go).
+-- The offset cases stay on the subquery step grid so they match Prometheus directly.
+create table subquery_offset_total (
+    ts timestamp time index,
+    host string primary key,
+    val double,
+);
+
+Affected Rows: 0
+
+insert into subquery_offset_total values
+    (0, 'a', 1),
+    (10000, 'a', 2),
+    (20000, 'a', 3),
+    (30000, 'a', 4),
+    (40000, 'a', 5),
+    (50000, 'a', 6),
+    (60000, 'a', 7);
+
+Affected Rows: 7
+
+-- baseline: no offset at t=60 covers the 10s subquery points in (40s, 60s] -> 6 + 7
+tql eval (60, 60, '1s') sum_over_time(subquery_offset_total[20s:10s]);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:01:00 | 13.0                             | a    |
++---------------------+----------------------------------+------+
+
+-- the same subquery evaluated at t=30 -> 3 + 4
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_total[20s:10s]);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:30 | 7.0                              | a    |
++---------------------+----------------------------------+------+
+
+-- `offset 30s` at t=60 must equal the un-offset subquery at t=30
+tql eval (60, 60, '1s') sum_over_time(subquery_offset_total[20s:10s] offset 30s);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:01:00 | 7.0                              | a    |
++---------------------+----------------------------------+------+
+
+-- a negative offset looks ahead of the evaluation time
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_total[20s:10s] offset -30s);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:30 | 13.0                             | a    |
++---------------------+----------------------------------+------+
+
+-- an offset on the inner selector composes additively with the subquery offset: Prometheus
+-- `subqueryTimes` accumulates "the sum of offsets and ranges of all subqueries in the path",
+-- and the inner selector subtracts its own offset from the already shifted step timestamps.
+-- 20s + 10s therefore behaves like the un-offset subquery at t=30.
+tql eval (60, 60, '1s') sum_over_time((subquery_offset_total offset 10s)[20s:10s] offset 20s);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:01:00 | 7.0                              | a    |
++---------------------+----------------------------------+------+
+
+-- ... and the inner offset alone accounts for the same total shift
+tql eval (60, 60, '1s') sum_over_time((subquery_offset_total offset 30s)[20s:10s]);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:01:00 | 7.0                              | a    |
++---------------------+----------------------------------+------+
+
+-- `predict_linear` predicts from the evaluation time: 4 + 0.1 * 30 = 7 and 7 - 0.1 * 30 = 4
+tql eval (60, 60, '1s') predict_linear(subquery_offset_total[20s:10s] offset 30s, 0);
+
++---------------------+----------------------------------------------+------+
+| ts                  | prom_predict_linear(ts_range,val,Float64(0)) | host |
++---------------------+----------------------------------------------+------+
+| 1970-01-01T00:01:00 | 7.0                                          | a    |
++---------------------+----------------------------------------------+------+
+
+tql eval (30, 30, '1s') predict_linear(subquery_offset_total[20s:10s] offset -30s, 0);
+
++---------------------+----------------------------------------------+------+
+| ts                  | prom_predict_linear(ts_range,val,Float64(0)) | host |
++---------------------+----------------------------------------------+------+
+| 1970-01-01T00:00:30 | 4.0                                          | a    |
++---------------------+----------------------------------------------+------+
+
+-- Offset results match the shifted evaluation while retaining outer timestamps.
+-- Verified against Prometheus v3.14.0.
+tql eval (30, 60, '30s') sum_over_time(subquery_offset_total[20s:10s] offset 30s);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:30 | 1.0                              | a    |
+| 1970-01-01T00:01:00 | 7.0                              | a    |
++---------------------+----------------------------------+------+
+
+tql eval (0, 30, '30s') sum_over_time(subquery_offset_total[20s:10s]);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:00 | 1.0                              | a    |
+| 1970-01-01T00:00:30 | 7.0                              | a    |
++---------------------+----------------------------------+------+
+
+drop table subquery_offset_total;
+
+Affected Rows: 0
+
+-- Off-grid samples expose absolute step anchoring.
+create table subquery_offset_offgrid (
+    ts timestamp time index,
+    host string primary key,
+    val double,
+);
+
+Affected Rows: 0
+
+insert into subquery_offset_offgrid values
+    (5000, 'a', 1),
+    (15000, 'a', 2),
+    (25000, 'a', 3),
+    (35000, 'a', 4),
+    (45000, 'a', 5),
+    (55000, 'a', 6);
+
+Affected Rows: 6
+
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_offgrid[20s:10s] offset 5s);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:30 | 3.0                              | a    |
++---------------------+----------------------------------+------+
+
+-- Offset moves the window without re-phasing its step points.
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_offgrid[20s:10s]);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:30 | 5.0                              | a    |
++---------------------+----------------------------------+------+
+
+-- The window starts before the first sample.
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_offgrid[20s:10s] offset 15s);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:30 | 1.0                              | a    |
++---------------------+----------------------------------+------+
+
+tql eval (15, 15, '1s') sum_over_time(subquery_offset_offgrid[20s:10s] offset -5s);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:15 | 3.0                              | a    |
++---------------------+----------------------------------+------+
+
+-- Multi-step evaluation uses the non-aligned parent timeline.
+tql eval (35, 65, '30s') sum_over_time(subquery_offset_offgrid[20s:10s]);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:35 | 5.0                              | a    |
+| 1970-01-01T00:01:05 | 11.0                             | a    |
++---------------------+----------------------------------+------+
+
+-- An evaluation instant whose window reaches no sample has no row (30s), unlike 60s -> 2 + 3
+tql eval (30, 60, '30s') sum_over_time(subquery_offset_offgrid[20s:10s] offset 30s);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:01:00 | 5.0                              | a    |
++---------------------+----------------------------------+------+
+
+-- No child point yields no row; the enclosing fallback still fires.
+tql eval (35, 44, '10s') sum_over_time(subquery_offset_offgrid[5s:10s]);
+
++----+----------------------------------+------+
+| ts | prom_sum_over_time(ts_range,val) | host |
++----+----------------------------------+------+
++----+----------------------------------+------+
+
+tql eval (35, 44, '10s') sum_over_time(subquery_offset_offgrid[5s:10s]) or vector(1);
+
++---------------------+------+----------------------------------+
+| ts                  | host | prom_sum_over_time(ts_range,val) |
++---------------------+------+----------------------------------+
+| 1970-01-01T00:00:35 |      | 1.0                              |
++---------------------+------+----------------------------------+
+
+-- A negative offset makes the short window reach a child point.
+tql eval (35, 44, '10s') sum_over_time(subquery_offset_offgrid[5s:10s] offset -5s);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:35 | 4.0                              | a    |
++---------------------+----------------------------------+------+
+
+-- An empty outer window suppresses inner results, but not an outer fallback.
+tql eval (35, 44, '10s') sum_over_time((sum_over_time(subquery_offset_offgrid[5s:10s]))[5s:10s]);
+
++----+---------------------------------------------------------------+------+
+| ts | prom_sum_over_time(ts_range,prom_sum_over_time(ts_range,val)) | host |
++----+---------------------------------------------------------------+------+
++----+---------------------------------------------------------------+------+
+
+tql eval (35, 44, '10s') sum_over_time((sum_over_time(subquery_offset_offgrid[5s:10s]))[5s:10s]) or vector(1);
+
++---------------------+------+---------------------------------------------------------------+
+| ts                  | host | prom_sum_over_time(ts_range,prom_sum_over_time(ts_range,val)) |
++---------------------+------+---------------------------------------------------------------+
+| 1970-01-01T00:00:35 |      | 1.0                                                           |
++---------------------+------+---------------------------------------------------------------+
+
+-- An aligned instant has a child point in the same short range.
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_offgrid[5s:10s]);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:30 | 3.0                              | a    |
++---------------------+----------------------------------+------+
+
+-- A longer range covers child steps on the off-grid parent timeline.
+tql eval (35, 65, '10s') sum_over_time(subquery_offset_offgrid[20s:10s]);
+
++---------------------+----------------------------------+------+
+| ts                  | prom_sum_over_time(ts_range,val) | host |
++---------------------+----------------------------------+------+
+| 1970-01-01T00:00:35 | 5.0                              | a    |
+| 1970-01-01T00:00:45 | 7.0                              | a    |
+| 1970-01-01T00:00:55 | 9.0                              | a    |
+| 1970-01-01T00:01:05 | 11.0                             | a    |
++---------------------+----------------------------------+------+
+
+-- Zero step parses here but is invalid for planning.
+tql eval (60, 60, '1s') sum_over_time(subquery_offset_offgrid[5s:0]);
+
+Error: 1004(InvalidArguments), Zero range in range selector
+
+tql eval (44, 35, '10s') sum_over_time(subquery_offset_offgrid[5s:10s]);
+
+Error: 1004(InvalidArguments), The end time must be greater than start time, start: 44000, end: 35000
+
+drop table subquery_offset_offgrid;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/promql/subquery.sql b/tests/cases/standalone/common/promql/subquery.sql
index 95215b8488b..c44e5163b8d 100644
--- a/tests/cases/standalone/common/promql/subquery.sql
+++ b/tests/cases/standalone/common/promql/subquery.sql
@@ -20,3 +20,112 @@ tql eval (10, 10, '1s') rate(metric_total[20s:10s]);
 tql eval (20, 20, '1s') rate(metric_total[20s:5s]);
 
 drop table metric_total;
+
+-- Offset on a subquery shifts the subquery's own evaluation window back by the offset.
+-- Reference: Prometheus `evaluator.subqueryTimeRange` (promql/engine.go).
+-- The offset cases stay on the subquery step grid so they match Prometheus directly.
+create table subquery_offset_total (
+    ts timestamp time index,
+    host string primary key,
+    val double,
+);
+
+insert into subquery_offset_total values
+    (0, 'a', 1),
+    (10000, 'a', 2),
+    (20000, 'a', 3),
+    (30000, 'a', 4),
+    (40000, 'a', 5),
+    (50000, 'a', 6),
+    (60000, 'a', 7);
+
+-- baseline: no offset at t=60 covers the 10s subquery points in (40s, 60s] -> 6 + 7
+tql eval (60, 60, '1s') sum_over_time(subquery_offset_total[20s:10s]);
+
+-- the same subquery evaluated at t=30 -> 3 + 4
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_total[20s:10s]);
+
+-- `offset 30s` at t=60 must equal the un-offset subquery at t=30
+tql eval (60, 60, '1s') sum_over_time(subquery_offset_total[20s:10s] offset 30s);
+
+-- a negative offset looks ahead of the evaluation time
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_total[20s:10s] offset -30s);
+
+-- an offset on the inner selector composes additively with the subquery offset: Prometheus
+-- `subqueryTimes` accumulates "the sum of offsets and ranges of all subqueries in the path",
+-- and the inner selector subtracts its own offset from the already shifted step timestamps.
+-- 20s + 10s therefore behaves like the un-offset subquery at t=30.
+tql eval (60, 60, '1s') sum_over_time((subquery_offset_total offset 10s)[20s:10s] offset 20s);
+
+-- ... and the inner offset alone accounts for the same total shift
+tql eval (60, 60, '1s') sum_over_time((subquery_offset_total offset 30s)[20s:10s]);
+
+-- `predict_linear` predicts from the evaluation time: 4 + 0.1 * 30 = 7 and 7 - 0.1 * 30 = 4
+tql eval (60, 60, '1s') predict_linear(subquery_offset_total[20s:10s] offset 30s, 0);
+
+tql eval (30, 30, '1s') predict_linear(subquery_offset_total[20s:10s] offset -30s, 0);
+
+-- Offset results match the shifted evaluation while retaining outer timestamps.
+-- Verified against Prometheus v3.14.0.
+tql eval (30, 60, '30s') sum_over_time(subquery_offset_total[20s:10s] offset 30s);
+
+tql eval (0, 30, '30s') sum_over_time(subquery_offset_total[20s:10s]);
+
+drop table subquery_offset_total;
+
+-- Off-grid samples expose absolute step anchoring.
+create table subquery_offset_offgrid (
+    ts timestamp time index,
+    host string primary key,
+    val double,
+);
+
+insert into subquery_offset_offgrid values
+    (5000, 'a', 1),
+    (15000, 'a', 2),
+    (25000, 'a', 3),
+    (35000, 'a', 4),
+    (45000, 'a', 5),
+    (55000, 'a', 6);
+
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_offgrid[20s:10s] offset 5s);
+
+-- Offset moves the window without re-phasing its step points.
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_offgrid[20s:10s]);
+
+-- The window starts before the first sample.
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_offgrid[20s:10s] offset 15s);
+
+tql eval (15, 15, '1s') sum_over_time(subquery_offset_offgrid[20s:10s] offset -5s);
+
+-- Multi-step evaluation uses the non-aligned parent timeline.
+tql eval (35, 65, '30s') sum_over_time(subquery_offset_offgrid[20s:10s]);
+
+-- An evaluation instant whose window reaches no sample has no row (30s), unlike 60s -> 2 + 3
+tql eval (30, 60, '30s') sum_over_time(subquery_offset_offgrid[20s:10s] offset 30s);
+
+-- No child point yields no row; the enclosing fallback still fires.
+tql eval (35, 44, '10s') sum_over_time(subquery_offset_offgrid[5s:10s]);
+
+tql eval (35, 44, '10s') sum_over_time(subquery_offset_offgrid[5s:10s]) or vector(1);
+
+-- A negative offset makes the short window reach a child point.
+tql eval (35, 44, '10s') sum_over_time(subquery_offset_offgrid[5s:10s] offset -5s);
+
+-- An empty outer window suppresses inner results, but not an outer fallback.
+tql eval (35, 44, '10s') sum_over_time((sum_over_time(subquery_offset_offgrid[5s:10s]))[5s:10s]);
+
+tql eval (35, 44, '10s') sum_over_time((sum_over_time(subquery_offset_offgrid[5s:10s]))[5s:10s]) or vector(1);
+
+-- An aligned instant has a child point in the same short range.
+tql eval (30, 30, '1s') sum_over_time(subquery_offset_offgrid[5s:10s]);
+
+-- A longer range covers child steps on the off-grid parent timeline.
+tql eval (35, 65, '10s') sum_over_time(subquery_offset_offgrid[20s:10s]);
+
+-- Zero step parses here but is invalid for planning.
+tql eval (60, 60, '1s') sum_over_time(subquery_offset_offgrid[5s:0]);
+
+tql eval (44, 35, '10s') sum_over_time(subquery_offset_offgrid[5s:10s]);
+
+drop table subquery_offset_offgrid;
diff --git a/tests/cases/standalone/common/promql/subquery_default_step.result b/tests/cases/standalone/common/promql/subquery_default_step.result
new file mode 100644
index 00000000000..47008660cad
--- /dev/null
+++ b/tests/cases/standalone/common/promql/subquery_default_step.result
@@ -0,0 +1,53 @@
+-- A subquery without a step uses the evaluation interval (one minute by
+-- default in Prometheus), not the query step. Expected results are from Prometheus 3.
+create table subquery_default_step (
+    ts timestamp time index,
+    val double,
+    host string primary key
+);
+
+Affected Rows: 0
+
+insert into subquery_default_step values
+    (0, 1.0, 'a'),
+    (60000, 1.0, 'a'),
+    (120000, 1.0, 'a'),
+    (180000, 1.0, 'a'),
+    (240000, 1.0, 'a'),
+    (300000, 1.0, 'a');
+
+Affected Rows: 6
+
+tql eval (300, 300, '1s') count_over_time(subquery_default_step[5m:]);
+
++---------------------+------------------------------------+------+
+| ts                  | prom_count_over_time(ts_range,val) | host |
++---------------------+------------------------------------+------+
+| 1970-01-01T00:05:00 | 5.0                                | a    |
++---------------------+------------------------------------+------+
+
+tql eval (300, 300, '1s') count_over_time(subquery_default_step[5m:30s]);
+
++---------------------+------------------------------------+------+
+| ts                  | prom_count_over_time(ts_range,val) | host |
++---------------------+------------------------------------+------+
+| 1970-01-01T00:05:00 | 10.0                               | a    |
++---------------------+------------------------------------+------+
+
+-- The outer range query keeps its own step around the subquery's default step.
+tql eval (300, 360, '15s') count_over_time(subquery_default_step[5m:]);
+
++---------------------+------------------------------------+------+
+| ts                  | prom_count_over_time(ts_range,val) | host |
++---------------------+------------------------------------+------+
+| 1970-01-01T00:05:00 | 5.0                                | a    |
+| 1970-01-01T00:05:15 | 5.0                                | a    |
+| 1970-01-01T00:05:30 | 5.0                                | a    |
+| 1970-01-01T00:05:45 | 5.0                                | a    |
+| 1970-01-01T00:06:00 | 5.0                                | a    |
++---------------------+------------------------------------+------+
+
+drop table subquery_default_step;
+
+Affected Rows: 0
+
diff --git a/tests/cases/standalone/common/promql/subquery_default_step.sql b/tests/cases/standalone/common/promql/subquery_default_step.sql
new file mode 100644
index 00000000000..fb1acb5f45b
--- /dev/null
+++ b/tests/cases/standalone/common/promql/subquery_default_step.sql
@@ -0,0 +1,25 @@
+-- A subquery without a step uses the evaluation interval (one minute by
+-- default in Prometheus), not the query step. Expected results are from Prometheus 3.
+
+create table subquery_default_step (
+    ts timestamp time index,
+    val double,
+    host string primary key
+);
+
+insert into subquery_default_step values
+    (0, 1.0, 'a'),
+    (60000, 1.0, 'a'),
+    (120000, 1.0, 'a'),
+    (180000, 1.0, 'a'),
+    (240000, 1.0, 'a'),
+    (300000, 1.0, 'a');
+
+tql eval (300, 300, '1s') count_over_time(subquery_default_step[5m:]);
+
+tql eval (300, 300, '1s') count_over_time(subquery_default_step[5m:30s]);
+
+-- The outer range query keeps its own step around the subquery's default step.
+tql eval (300, 360, '15s') count_over_time(subquery_default_step[5m:]);
+
+drop table subquery_default_step;
diff --git a/tests/cases/standalone/common/promql/time_fn.result b/tests/cases/standalone/common/promql/time_fn.result
index 25e0cd11030..f947f2fb726 100644
--- a/tests/cases/standalone/common/promql/time_fn.result
+++ b/tests/cases/standalone/common/promql/time_fn.result
@@ -150,7 +150,7 @@ tql eval (1, 2, '1s') time() == bool metrics;
 tql eval (1, 2, '1s') metrics + time();
 
 +---------------------+-------------------------------------+
-| time                | metrics.val + .time / Float64(1000) |
+| ts                  | metrics.val + .time / Float64(1000) |
 +---------------------+-------------------------------------+
 | 1970-01-01T00:00:01 | 2.0                                 |
 | 1970-01-01T00:00:02 | 4.0                                 |
@@ -170,7 +170,7 @@ tql eval (1, 2, '1s') metrics == time();
 tql eval (1, 2, '1s') metrics == bool time();
 
 +---------------------+-------------------------------------+
-| time                | metrics.val = .time / Float64(1000) |
+| ts                  | metrics.val = .time / Float64(1000) |
 +---------------------+-------------------------------------+
 | 1970-01-01T00:00:01 | 1.0                                 |
 | 1970-01-01T00:00:02 | 1.0                                 |
diff --git a/tests/cases/standalone/common/promql/timestamp_fn.result b/tests/cases/standalone/common/promql/timestamp_fn.result
index 1f5682649a4..32f5ba11cfb 100644
--- a/tests/cases/standalone/common/promql/timestamp_fn.result
+++ b/tests/cases/standalone/common/promql/timestamp_fn.result
@@ -95,7 +95,7 @@ tql eval (0, 60, '30s') timestamp(timestamp_test) > bool 30;
 tql eval (0, 60, '30s') timestamp(timestamp_test) - time();
 
 +---------------------+----------------------------------------------+
-| time                | timestamp_test.value - .time / Float64(1000) |
+| ts                  | timestamp_test.value - .time / Float64(1000) |
 +---------------------+----------------------------------------------+
 | 1970-01-01T00:00:00 | 0.0                                          |
 | 1970-01-01T00:00:30 | -29.0                                        |
@@ -113,17 +113,17 @@ tql eval (0, 60, '30s') abs(timestamp(timestamp_test) - avg(timestamp(timestamp_
 -- Test Issue 6707
 tql eval timestamp(demo_memory_usage_bytes * 1);
 
-+------+--------------------+
-| time | value * Float64(1) |
-+------+--------------------+
-+------+--------------------+
++------+-------+
+| time | value |
++------+-------+
++------+-------+
 
 tql eval timestamp(-demo_memory_usage_bytes);
 
-+------+-----------+
-| time | (- value) |
-+------+-----------+
-+------+-----------+
++------+-------+
+| time | value |
++------+-------+
++------+-------+
 
 tql eval (0, 60, '30s') timestamp(timestamp_test) == 60;
 
@@ -133,6 +133,79 @@ tql eval (0, 60, '30s') timestamp(timestamp_test) == 60;
 | 1970-01-01T00:01:00 | 60.0  |
 +---------------------+-------+
 
+-- timestamp() reports the timestamp of the selected sample, not the evaluation time
+tql eval (60, 60, '1s') timestamp(timestamp_test offset 30s);
+
++---------------------+-------+
+| ts                  | value |
++---------------------+-------+
+| 1970-01-01T00:01:00 | 1.0   |
++---------------------+-------+
+
+tql eval (60, 60, '1s') timestamp((timestamp_test offset 30s));
+
++---------------------+-------+
+| ts                  | value |
++---------------------+-------+
+| 1970-01-01T00:01:00 | 1.0   |
++---------------------+-------+
+
+-- The result of a function is sampled at the evaluation time
+tql eval (90, 90, '1s') timestamp(abs(timestamp_test));
+
++---------------------+-------+
+| ts                  | value |
++---------------------+-------+
+| 1970-01-01T00:01:30 | 90.0  |
++---------------------+-------+
+
+-- A row whose fields are all NULL holds no sample and gets no timestamp; a row with any
+-- non-NULL field does.
+create table timestamp_null (ts timestamp time index, host string primary key, a double, b double);
+
+Affected Rows: 0
+
+insert into timestamp_null values
+  (0, 'none', NULL, NULL),
+  (0, 'only_a', 1.0, NULL),
+  (0, 'only_b', NULL, 2.0);
+
+Affected Rows: 3
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') timestamp(timestamp_null);
+
++---------------------+-------+--------+
+| ts                  | value | host   |
++---------------------+-------+--------+
+| 1970-01-01T00:01:00 | 0.0   | only_a |
+| 1970-01-01T00:01:00 | 0.0   | only_b |
++---------------------+-------+--------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') timestamp(-timestamp_null);
+
++---------------------+-------+--------+
+| ts                  | value | host   |
++---------------------+-------+--------+
+| 1970-01-01T00:01:00 | 60.0  | only_a |
+| 1970-01-01T00:01:00 | 60.0  | only_b |
++---------------------+-------+--------+
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') timestamp(abs(timestamp_null));
+
++---------------------+-------+--------+
+| ts                  | value | host   |
++---------------------+-------+--------+
+| 1970-01-01T00:01:00 | 60.0  | only_a |
+| 1970-01-01T00:01:00 | 60.0  | only_b |
++---------------------+-------+--------+
+
+drop table timestamp_null;
+
+Affected Rows: 0
+
 -- Test timestamp() with multiple metrics
 create table timestamp_test2 (ts timestamp time index, val double);
 
diff --git a/tests/cases/standalone/common/promql/timestamp_fn.sql b/tests/cases/standalone/common/promql/timestamp_fn.sql
index 123bdeb5881..cc307007e4b 100644
--- a/tests/cases/standalone/common/promql/timestamp_fn.sql
+++ b/tests/cases/standalone/common/promql/timestamp_fn.sql
@@ -43,6 +43,34 @@ tql eval timestamp(-demo_memory_usage_bytes);
 
 tql eval (0, 60, '30s') timestamp(timestamp_test) == 60;
 
+-- timestamp() reports the timestamp of the selected sample, not the evaluation time
+tql eval (60, 60, '1s') timestamp(timestamp_test offset 30s);
+
+tql eval (60, 60, '1s') timestamp((timestamp_test offset 30s));
+
+-- The result of a function is sampled at the evaluation time
+tql eval (90, 90, '1s') timestamp(abs(timestamp_test));
+
+-- A row whose fields are all NULL holds no sample and gets no timestamp; a row with any
+-- non-NULL field does.
+create table timestamp_null (ts timestamp time index, host string primary key, a double, b double);
+
+insert into timestamp_null values
+  (0, 'none', NULL, NULL),
+  (0, 'only_a', 1.0, NULL),
+  (0, 'only_b', NULL, 2.0);
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') timestamp(timestamp_null);
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') timestamp(-timestamp_null);
+
+-- SQLNESS SORT_RESULT 3 1
+tql eval (60, 60, '1s') timestamp(abs(timestamp_null));
+
+drop table timestamp_null;
+
 -- Test timestamp() with multiple metrics
 create table timestamp_test2 (ts timestamp time index, val double);
 
diff --git a/tests/cases/standalone/common/promql/tsid_binary_join_regression.result b/tests/cases/standalone/common/promql/tsid_binary_join_regression.result
index fc4bc6f01c2..0288a045390 100644
--- a/tests/cases/standalone/common/promql/tsid_binary_join_regression.result
+++ b/tests/cases/standalone/common/promql/tsid_binary_join_regression.result
@@ -336,7 +336,7 @@ TQL ANALYZE (0, 5, '5s') tsid_binary_join_left > tsid_binary_join_right;
 +-+-+-+
 | stage | node | plan_|
 +-+-+-+
-| 0_| 0_|_HashJoinExec: mode=Partitioned, join_type=Inner, on=[(__tsid@3, __tsid@1), (ts@4, ts@2)], filter=greptime_value@1 < greptime_value@0, projection=[ts@4, greptime_value@0, host@1, job@2, __tsid@3], NullsEqual: true REDACTED
+| 0_| 0_|_HashJoinExec: mode=Partitioned, join_type=Inner, on=[(__tsid@3, __tsid@1), (ts@4, ts@2)], filter=prom_gt(greptime_value@0, greptime_value@1), projection=[ts@4, greptime_value@0, host@1, job@2, __tsid@3], NullsEqual: true REDACTED
 |_|_|_RepartitionExec: partitioning=Hash([__tsid@3, ts@4],REDACTED
 |_|_|_MergeScanExec: REDACTED
 |_|_|_RepartitionExec: partitioning=Hash([__tsid@1, ts@2],REDACTED
@@ -374,8 +374,8 @@ TQL ANALYZE (0, 5, '5s') tsid_binary_join_left > bool tsid_binary_join_right;
 +-+-+-+
 | stage | node | plan_|
 +-+-+-+
-| 0_| 0_|_ProjectionExec: expr=[host@0 as host, job@1 as job, ts@2 as ts, __tsid@3 as __tsid, CAST(greptime_value@4 < greptime_value@5 AS Float64) as tsid_binary_join_left.greptime_value > tsid_binary_join_right.greptime_value] REDACTED
-|_|_|_HashJoinExec: mode=CollectLeft, join_type=Inner, on=[(__tsid@1, __tsid@3), (ts@2, ts@4)], projection=[host@4, job@5, ts@7, __tsid@6, greptime_value@3, greptime_value@0], NullsEqual: true REDACTED
+| 0_| 0_|_ProjectionExec: expr=[host@0 as host, job@1 as job, ts@2 as ts, __tsid@3 as __tsid, CAST(prom_gt(greptime_value@4, greptime_value@5) AS Float64) as tsid_binary_join_left.greptime_value > tsid_binary_join_right.greptime_value] REDACTED
+|_|_|_HashJoinExec: mode=CollectLeft, join_type=Inner, on=[(__tsid@1, __tsid@3), (ts@2, ts@4)], projection=[host@4, job@5, ts@7, __tsid@6, greptime_value@0, greptime_value@3], NullsEqual: true REDACTED
 |_|_|_ProjectionExec: expr=[greptime_value@0 as greptime_value, __tsid@3 as __tsid, ts@4 as ts] REDACTED
 |_|_|_CooperativeExec REDACTED
 |_|_|_MergeScanExec: REDACTED
@@ -416,7 +416,7 @@ TQL ANALYZE (0, 5, '5s') ((tsid_binary_join_left > tsid_binary_join_right) / tsi
 | 0_| 0_|_ProjectionExec: expr=[host@0 as host, job@1 as job, ts@2 as ts, __tsid@3 as __tsid, greptime_value@4 / greptime_value@5 * 100 as .greptime_value / tsid_binary_join_left.greptime_value * Float64(100)] REDACTED
 |_|_|_HashJoinExec: mode=CollectLeft, join_type=Inner, on=[(__tsid@2, __tsid@3), (ts@0, ts@4)], projection=[host@4, job@5, ts@7, __tsid@6, greptime_value@1, greptime_value@3], NullsEqual: true REDACTED
 |_|_|_CoalescePartitionsExec REDACTED
-|_|_|_HashJoinExec: mode=Partitioned, join_type=Inner, on=[(__tsid@1, __tsid@1), (ts@2, ts@2)], filter=greptime_value@1 < greptime_value@0, projection=[ts@2, greptime_value@0, __tsid@1], NullsEqual: true REDACTED
+|_|_|_HashJoinExec: mode=Partitioned, join_type=Inner, on=[(__tsid@1, __tsid@1), (ts@2, ts@2)], filter=prom_gt(greptime_value@0, greptime_value@1), projection=[ts@2, greptime_value@0, __tsid@1], NullsEqual: true REDACTED
 |_|_|_RepartitionExec: partitioning=Hash([REDACTED
 |_|_|_ProjectionExec: expr=[greptime_value@0 as greptime_value, __tsid@3 as __tsid, ts@4 as ts] REDACTED
 |_|_|_MergeScanExec: REDACTED
@@ -467,8 +467,8 @@ TQL ANALYZE (0, 5, '5s') ((tsid_binary_join_left > bool tsid_binary_join_right)
 |_|_|_CoalescePartitionsExec REDACTED
 |_|_|_ProjectionExec: expr=[ts@0 as ts, __tsid@1 as __tsid, tsid_binary_join_left.greptime_value > tsid_binary_join_right.greptime_value@2 + greptime_value@3 as tsid_binary_join_right.tsid_binary_join_left.greptime_value > tsid_binary_join_right.greptime_value + tsid_binary_join_left.greptime_value] REDACTED
 |_|_|_HashJoinExec: mode=Partitioned, join_type=Inner, on=[(__tsid@1, __tsid@1), (ts@0, ts@2)], projection=[ts@5, __tsid@4, tsid_binary_join_left.greptime_value > tsid_binary_join_right.greptime_value@2, greptime_value@3], NullsEqual: true REDACTED
-|_|_|_ProjectionExec: expr=[ts@0 as ts, __tsid@1 as __tsid, CAST(greptime_value@2 < greptime_value@3 AS Float64) as tsid_binary_join_left.greptime_value > tsid_binary_join_right.greptime_value] REDACTED
-|_|_|_HashJoinExec: mode=Partitioned, join_type=Inner, on=[(__tsid@1, __tsid@1), (ts@2, ts@2)], projection=[ts@5, __tsid@4, greptime_value@3, greptime_value@0], NullsEqual: true REDACTED
+|_|_|_ProjectionExec: expr=[ts@0 as ts, __tsid@1 as __tsid, CAST(prom_gt(greptime_value@2, greptime_value@3) AS Float64) as tsid_binary_join_left.greptime_value > tsid_binary_join_right.greptime_value] REDACTED
+|_|_|_HashJoinExec: mode=Partitioned, join_type=Inner, on=[(__tsid@1, __tsid@1), (ts@2, ts@2)], projection=[ts@5, __tsid@4, greptime_value@0, greptime_value@3], NullsEqual: true REDACTED
 |_|_|_RepartitionExec: partitioning=Hash([REDACTED
 |_|_|_ProjectionExec: expr=[greptime_value@0 as greptime_value, __tsid@3 as __tsid, ts@4 as ts] REDACTED
 |_|_|_MergeScanExec: REDACTED
diff --git a/tests/cases/standalone/common/tql-explain-analyze/explain.result b/tests/cases/standalone/common/tql-explain-analyze/explain.result
index fed75f0448e..3184bb261cc 100644
--- a/tests/cases/standalone/common/tql-explain-analyze/explain.result
+++ b/tests/cases/standalone/common/tql-explain-analyze/explain.result
@@ -102,6 +102,7 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test;
 |_| ]]_|
 | logical_plan after JsonSchemaConcretizeRule_| SAME TEXT AS ABOVE_|
 | logical_plan after FixStateUdafOrderingAnalyzer_| SAME TEXT AS ABOVE_|
+| logical_plan after expr_depth_| SAME TEXT AS ABOVE_|
 | analyzed_logical_plan_| SAME TEXT AS ABOVE_|
 | logical_plan after rewrite_set_comparison_| SAME TEXT AS ABOVE_|
 | logical_plan after optimize_unions_| SAME TEXT AS ABOVE_|
@@ -121,6 +122,7 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test;
 | logical_plan after filter_null_join_keys_| SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_outer_join_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_limit_| SAME TEXT AS ABOVE_|
+| logical_plan after infer_aggregate_input_bounds_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_filter_| SAME TEXT AS ABOVE_|
 | logical_plan after single_distinct_aggregation_to_group_by | SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_group_by_constant_| SAME TEXT AS ABOVE_|
@@ -154,6 +156,7 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test;
 | logical_plan after filter_null_join_keys_| SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_outer_join_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_limit_| SAME TEXT AS ABOVE_|
+| logical_plan after infer_aggregate_input_bounds_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_filter_| SAME TEXT AS ABOVE_|
 | logical_plan after single_distinct_aggregation_to_group_by | SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_group_by_constant_| SAME TEXT AS ABOVE_|
@@ -184,7 +187,6 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test;
 | physical_plan after LimitedDistinctAggregation_| SAME TEXT AS ABOVE_|
 | physical_plan after FilterPushdown_| SAME TEXT AS ABOVE_|
 | physical_plan after parallelize_scan_| SAME TEXT AS ABOVE_|
-| physical_plan after PassDistributionRule_| SAME TEXT AS ABOVE_|
 | physical_plan after PromqlTsidNarrowJoin_| SAME TEXT AS ABOVE_|
 | physical_plan after EnforceSorting_| SAME TEXT AS ABOVE_|
 | physical_plan after WindowTopN_| SAME TEXT AS ABOVE_|
@@ -257,6 +259,7 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test AS series;
 |_| ]]_|
 | logical_plan after JsonSchemaConcretizeRule_| SAME TEXT AS ABOVE_|
 | logical_plan after FixStateUdafOrderingAnalyzer_| SAME TEXT AS ABOVE_|
+| logical_plan after expr_depth_| SAME TEXT AS ABOVE_|
 | analyzed_logical_plan_| SAME TEXT AS ABOVE_|
 | logical_plan after rewrite_set_comparison_| SAME TEXT AS ABOVE_|
 | logical_plan after optimize_unions_| SAME TEXT AS ABOVE_|
@@ -276,6 +279,7 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test AS series;
 | logical_plan after filter_null_join_keys_| SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_outer_join_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_limit_| SAME TEXT AS ABOVE_|
+| logical_plan after infer_aggregate_input_bounds_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_filter_| SAME TEXT AS ABOVE_|
 | logical_plan after single_distinct_aggregation_to_group_by | SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_group_by_constant_| SAME TEXT AS ABOVE_|
@@ -310,6 +314,7 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test AS series;
 | logical_plan after filter_null_join_keys_| SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_outer_join_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_limit_| SAME TEXT AS ABOVE_|
+| logical_plan after infer_aggregate_input_bounds_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_filter_| SAME TEXT AS ABOVE_|
 | logical_plan after single_distinct_aggregation_to_group_by | SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_group_by_constant_| SAME TEXT AS ABOVE_|
@@ -341,7 +346,6 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test AS series;
 | physical_plan after LimitedDistinctAggregation_| SAME TEXT AS ABOVE_|
 | physical_plan after FilterPushdown_| SAME TEXT AS ABOVE_|
 | physical_plan after parallelize_scan_| SAME TEXT AS ABOVE_|
-| physical_plan after PassDistributionRule_| SAME TEXT AS ABOVE_|
 | physical_plan after PromqlTsidNarrowJoin_| SAME TEXT AS ABOVE_|
 | physical_plan after EnforceSorting_| SAME TEXT AS ABOVE_|
 | physical_plan after WindowTopN_| SAME TEXT AS ABOVE_|
@@ -444,6 +448,7 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test_nano;
 |_| ]]_|
 | logical_plan after JsonSchemaConcretizeRule_| SAME TEXT AS ABOVE_|
 | logical_plan after FixStateUdafOrderingAnalyzer_| SAME TEXT AS ABOVE_|
+| logical_plan after expr_depth_| SAME TEXT AS ABOVE_|
 | analyzed_logical_plan_| SAME TEXT AS ABOVE_|
 | logical_plan after rewrite_set_comparison_| SAME TEXT AS ABOVE_|
 | logical_plan after optimize_unions_| SAME TEXT AS ABOVE_|
@@ -463,6 +468,7 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test_nano;
 | logical_plan after filter_null_join_keys_| SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_outer_join_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_limit_| SAME TEXT AS ABOVE_|
+| logical_plan after infer_aggregate_input_bounds_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_filter_| SAME TEXT AS ABOVE_|
 | logical_plan after single_distinct_aggregation_to_group_by | SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_group_by_constant_| SAME TEXT AS ABOVE_|
@@ -497,6 +503,7 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test_nano;
 | logical_plan after filter_null_join_keys_| SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_outer_join_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_limit_| SAME TEXT AS ABOVE_|
+| logical_plan after infer_aggregate_input_bounds_| SAME TEXT AS ABOVE_|
 | logical_plan after push_down_filter_| SAME TEXT AS ABOVE_|
 | logical_plan after single_distinct_aggregation_to_group_by | SAME TEXT AS ABOVE_|
 | logical_plan after eliminate_group_by_constant_| SAME TEXT AS ABOVE_|
@@ -528,7 +535,6 @@ TQL EXPLAIN VERBOSE (0, 10, '5s') test_nano;
 | physical_plan after LimitedDistinctAggregation_| SAME TEXT AS ABOVE_|
 | physical_plan after FilterPushdown_| SAME TEXT AS ABOVE_|
 | physical_plan after parallelize_scan_| SAME TEXT AS ABOVE_|
-| physical_plan after PassDistributionRule_| SAME TEXT AS ABOVE_|
 | physical_plan after PromqlTsidNarrowJoin_| SAME TEXT AS ABOVE_|
 | physical_plan after EnforceSorting_| SAME TEXT AS ABOVE_|
 | physical_plan after WindowTopN_| SAME TEXT AS ABOVE_|
diff --git a/tests/cases/standalone/common/tql/tql-cte.result b/tests/cases/standalone/common/tql/tql-cte.result
index 7fbc621319c..c2bc149e66c 100644
--- a/tests/cases/standalone/common/tql/tql-cte.result
+++ b/tests/cases/standalone/common/tql/tql-cte.result
@@ -596,7 +596,7 @@ SELECT 'host2' as source, ts, cpu FROM host2_data;
 |               |           Filter: labels.host = Utf8("host2") AND labels.ts >= TimestampMillisecond(-299999, None) AND labels.ts <= TimestampMillisecond(40000, None)                          |
 |               |             TableScan: labels, partial_filters=[labels.host = Utf8("host2"), labels.ts >= TimestampMillisecond(-299999, None), labels.ts <= TimestampMillisecond(40000, None)] |
 |               | ]]                                                                                                                                                                             |
-| physical_plan | InterleaveExec                                                                                                                                                                 |
+| physical_plan | UnionExec                                                                                                                                                                      |
 |               |   CooperativeExec                                                                                                                                                              |
 |               |     MergeScanExec: REDACTED
 |               |   CooperativeExec                                                                                                                                                              |
diff --git a/tests/cases/standalone/flow-tql/flow_tql.result b/tests/cases/standalone/flow-tql/flow_tql.result
index 13239bf4e1f..73321d040e1 100644
--- a/tests/cases/standalone/flow-tql/flow_tql.result
+++ b/tests/cases/standalone/flow-tql/flow_tql.result
@@ -155,7 +155,7 @@ Error: 2000(InvalidSyntax), Invalid TQL syntax: sql parser error: Expected expre
 CREATE FLOW calc_reqs SINK TO cnt_reqs EVAL INTERVAL '1m' AS
 TQL EVAL (now() - now(), now()-(now()+'15s'::interval), '5s') count_values("status_code", http_requests);
 
-Error: 3001(EngineExecuteQuery), Failed to convert float seconds to duration, raw: -15: cannot convert float seconds to Duration: value is negative
+Error: 3001(EngineExecuteQuery), The end time must be greater than start time, start: 0, end: -15000
 
 CREATE FLOW calc_reqs SINK TO cnt_reqs EVAL INTERVAL '1m' AS
 TQL EVAL (now() - now(), now()-now()+'15s'::interval, '5s') count_values("status_code", http_requests);
diff --git a/tests/compatibility/cases/downgrade_compatibility/setup.sql b/tests/compatibility/cases/downgrade_compatibility/setup.sql
index 267466f9dfe..d86ea21dfa5 100644
--- a/tests/compatibility/cases/downgrade_compatibility/setup.sql
+++ b/tests/compatibility/cases/downgrade_compatibility/setup.sql
@@ -47,3 +47,14 @@ INSERT INTO t_sst_float_field_encoding_downgrade VALUES
 ('2024-02-10 00:02:00+0000', 'host_c', NULL, NULL);
 
 ADMIN FLUSH_TABLE('t_sst_float_field_encoding_downgrade');
+
+CREATE TABLE t_fulltext_bloom_v2_downgrade (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'English', backend = 'bloom', case_sensitive = 'false')
+);
+
+INSERT INTO t_fulltext_bloom_v2_downgrade VALUES
+    (1, 'hello_world'),
+    (2, '错误error日志');
+
+ADMIN FLUSH_TABLE('t_fulltext_bloom_v2_downgrade');
diff --git a/tests/compatibility/cases/downgrade_compatibility/verify.result b/tests/compatibility/cases/downgrade_compatibility/verify.result
index c350288d19d..698403244a9 100644
--- a/tests/compatibility/cases/downgrade_compatibility/verify.result
+++ b/tests/compatibility/cases/downgrade_compatibility/verify.result
@@ -29,3 +29,21 @@ ORDER BY ts, host;
 | 2024-02-10T00:01:00 | host_b | -2.5 | 20.25 |
 | 2024-02-10T00:02:00 | host_c |      |       |
 +---------------------+--------+------+-------+
+
+-- Older binaries don't recognize the bloom blob written by the current one and must
+-- scan without pruning instead of probing it with their own tokens.
+SELECT ts, msg FROM t_fulltext_bloom_v2_downgrade WHERE msg @@ 'hello_world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM t_fulltext_bloom_v2_downgrade WHERE msg @@ '错误error日志' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.002 | 错误error日志 |
++-------------------------+---------------+
diff --git a/tests/compatibility/cases/downgrade_compatibility/verify.sql b/tests/compatibility/cases/downgrade_compatibility/verify.sql
index 6b73c886117..56d476c1557 100644
--- a/tests/compatibility/cases/downgrade_compatibility/verify.sql
+++ b/tests/compatibility/cases/downgrade_compatibility/verify.sql
@@ -5,3 +5,9 @@ SELECT ts, host, val FROM t_preserve_sequence_downgrade ORDER BY ts, host;
 SELECT ts, host, f, d
 FROM t_sst_float_field_encoding_downgrade
 ORDER BY ts, host;
+
+-- Older binaries don't recognize the bloom blob written by the current one and must
+-- scan without pruning instead of probing it with their own tokens.
+SELECT ts, msg FROM t_fulltext_bloom_v2_downgrade WHERE msg @@ 'hello_world' ORDER BY ts;
+
+SELECT ts, msg FROM t_fulltext_bloom_v2_downgrade WHERE msg @@ '错误error日志' ORDER BY ts;
diff --git a/tests/compatibility/cases/fulltext_bloom_tokens/case.toml b/tests/compatibility/cases/fulltext_bloom_tokens/case.toml
new file mode 100644
index 00000000000..d796adb51ef
--- /dev/null
+++ b/tests/compatibility/cases/fulltext_bloom_tokens/case.toml
@@ -0,0 +1,8 @@
+name = "fulltext_bloom_tokens"
+reason = "Verify matches_term and LIKE return every matching row from fulltext bloom SSTs written by older binaries, whose tokens don't follow matches_term boundaries, alone and mixed with SSTs written by the current binary."
+introduced_by = "fix: fulltext bloom index drops rows matched by matches_term"
+topologies = ["distributed", "standalone"]
+from_range = [">=v1.0.0"]
+to_range = ["*"]
+features = ["table", "sst", "fulltext"]
+owner = "storage"
diff --git a/tests/compatibility/cases/fulltext_bloom_tokens/setup.sql b/tests/compatibility/cases/fulltext_bloom_tokens/setup.sql
new file mode 100644
index 00000000000..8df3a002207
--- /dev/null
+++ b/tests/compatibility/cases/fulltext_bloom_tokens/setup.sql
@@ -0,0 +1,28 @@
+CREATE TABLE t_fulltext_bloom_tokens (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'English', backend = 'bloom', case_sensitive = 'false')
+);
+
+INSERT INTO t_fulltext_bloom_tokens VALUES
+    (1, 'hello_world'),
+    (2, '错误error日志'),
+    (3, '中国农业银行');
+
+ADMIN FLUSH_TABLE('t_fulltext_bloom_tokens');
+
+-- Two SSTs with old bloom blobs, left for compaction to rewrite.
+CREATE TABLE t_fulltext_bloom_compact (
+    ts TIMESTAMP TIME INDEX,
+    msg STRING FULLTEXT INDEX WITH(analyzer = 'English', backend = 'bloom', case_sensitive = 'false')
+);
+
+INSERT INTO t_fulltext_bloom_compact VALUES
+    (1, 'hello_world'),
+    (2, '错误error日志');
+
+ADMIN FLUSH_TABLE('t_fulltext_bloom_compact');
+
+INSERT INTO t_fulltext_bloom_compact VALUES
+    (3, '中国农业银行');
+
+ADMIN FLUSH_TABLE('t_fulltext_bloom_compact');
diff --git a/tests/compatibility/cases/fulltext_bloom_tokens/verify.result b/tests/compatibility/cases/fulltext_bloom_tokens/verify.result
new file mode 100644
index 00000000000..8d3c527bcdb
--- /dev/null
+++ b/tests/compatibility/cases/fulltext_bloom_tokens/verify.result
@@ -0,0 +1,197 @@
+-- Only the SST written by the old binary.
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ 'world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ 'error' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.002 | 错误error日志 |
++-------------------------+---------------+
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ '农业' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.003 | 中国农业银行 |
++-------------------------+--------------+
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg LIKE 'hello\_%' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+INSERT INTO t_fulltext_bloom_tokens VALUES
+    (4, 'hello_world again'),
+    (5, '农业 error');
+
+Affected Rows: 2
+
+ADMIN FLUSH_TABLE('t_fulltext_bloom_tokens');
+
++----------------------------------------------+
+| ADMIN FLUSH_TABLE('t_fulltext_bloom_tokens') |
++----------------------------------------------+
+| 0                                            |
++----------------------------------------------+
+
+-- Old and new SSTs: one bloom blob of each version.
+SELECT meta_json LIKE '%"bloom_version":2%' AS is_v2, count(*) AS ssts
+FROM information_schema.ssts_index_meta
+WHERE table_id = (SELECT table_id FROM information_schema.tables WHERE table_name = 't_fulltext_bloom_tokens')
+  AND index_type = 'fulltext_bloom'
+GROUP BY is_v2
+ORDER BY is_v2;
+
++-------+------+
+| is_v2 | ssts |
++-------+------+
+| false | 1    |
+| true  | 1    |
++-------+------+
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ 'world' ORDER BY ts;
+
++-------------------------+-------------------+
+| ts                      | msg               |
++-------------------------+-------------------+
+| 1970-01-01T00:00:00.001 | hello_world       |
+| 1970-01-01T00:00:00.004 | hello_world again |
++-------------------------+-------------------+
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ 'error' ORDER BY ts;
+
++-------------------------+---------------+
+| ts                      | msg           |
++-------------------------+---------------+
+| 1970-01-01T00:00:00.002 | 错误error日志 |
+| 1970-01-01T00:00:00.005 | 农业 error    |
++-------------------------+---------------+
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ '农业' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.003 | 中国农业银行 |
+| 1970-01-01T00:00:00.005 | 农业 error   |
++-------------------------+--------------+
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg LIKE 'hello\_%' ORDER BY ts;
+
++-------------------------+-------------------+
+| ts                      | msg               |
++-------------------------+-------------------+
+| 1970-01-01T00:00:00.001 | hello_world       |
+| 1970-01-01T00:00:00.004 | hello_world again |
++-------------------------+-------------------+
+
+-- Rebuilds the old SST's index with the current bloom version.
+ADMIN BUILD_INDEX('t_fulltext_bloom_tokens');
+
++----------------------------------------------+
+| ADMIN BUILD_INDEX('t_fulltext_bloom_tokens') |
++----------------------------------------------+
+| 0                                            |
++----------------------------------------------+
+
+-- SQLNESS SLEEP 2s
+SELECT meta_json LIKE '%"bloom_version":2%' AS is_v2, count(*) AS ssts
+FROM information_schema.ssts_index_meta
+WHERE table_id = (SELECT table_id FROM information_schema.tables WHERE table_name = 't_fulltext_bloom_tokens')
+  AND index_type = 'fulltext_bloom'
+GROUP BY is_v2
+ORDER BY is_v2;
+
++-------+------+
+| is_v2 | ssts |
++-------+------+
+| true  | 2    |
++-------+------+
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ 'world' ORDER BY ts;
+
++-------------------------+-------------------+
+| ts                      | msg               |
++-------------------------+-------------------+
+| 1970-01-01T00:00:00.001 | hello_world       |
+| 1970-01-01T00:00:00.004 | hello_world again |
++-------------------------+-------------------+
+
+DROP TABLE t_fulltext_bloom_tokens;
+
+Affected Rows: 0
+
+-- Two SSTs written by the old binary.
+SELECT meta_json LIKE '%"bloom_version":2%' AS is_v2, count(*) AS ssts
+FROM information_schema.ssts_index_meta
+WHERE table_id = (SELECT table_id FROM information_schema.tables WHERE table_name = 't_fulltext_bloom_compact')
+  AND index_type = 'fulltext_bloom'
+GROUP BY is_v2
+ORDER BY is_v2;
+
++-------+------+
+| is_v2 | ssts |
++-------+------+
+| false | 2    |
++-------+------+
+
+SELECT ts, msg FROM t_fulltext_bloom_compact WHERE msg @@ 'world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+-- Merges both SSTs into one with a current bloom blob.
+ADMIN COMPACT_TABLE('t_fulltext_bloom_compact', 'strict_window', 'window=3600');
+
++---------------------------------------------------------------------------------+
+| ADMIN COMPACT_TABLE('t_fulltext_bloom_compact', 'strict_window', 'window=3600') |
++---------------------------------------------------------------------------------+
+| 0                                                                               |
++---------------------------------------------------------------------------------+
+
+SELECT meta_json LIKE '%"bloom_version":2%' AS is_v2, count(*) AS ssts
+FROM information_schema.ssts_index_meta
+WHERE table_id = (SELECT table_id FROM information_schema.tables WHERE table_name = 't_fulltext_bloom_compact')
+  AND index_type = 'fulltext_bloom'
+GROUP BY is_v2
+ORDER BY is_v2;
+
++-------+------+
+| is_v2 | ssts |
++-------+------+
+| true  | 1    |
++-------+------+
+
+SELECT ts, msg FROM t_fulltext_bloom_compact WHERE msg @@ 'world' ORDER BY ts;
+
++-------------------------+-------------+
+| ts                      | msg         |
++-------------------------+-------------+
+| 1970-01-01T00:00:00.001 | hello_world |
++-------------------------+-------------+
+
+SELECT ts, msg FROM t_fulltext_bloom_compact WHERE msg @@ '农业' ORDER BY ts;
+
++-------------------------+--------------+
+| ts                      | msg          |
++-------------------------+--------------+
+| 1970-01-01T00:00:00.003 | 中国农业银行 |
++-------------------------+--------------+
+
+DROP TABLE t_fulltext_bloom_compact;
+
+Affected Rows: 0
diff --git a/tests/compatibility/cases/fulltext_bloom_tokens/verify.sql b/tests/compatibility/cases/fulltext_bloom_tokens/verify.sql
new file mode 100644
index 00000000000..a80a8f03043
--- /dev/null
+++ b/tests/compatibility/cases/fulltext_bloom_tokens/verify.sql
@@ -0,0 +1,71 @@
+-- Only the SST written by the old binary.
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ 'world' ORDER BY ts;
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ 'error' ORDER BY ts;
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ '农业' ORDER BY ts;
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg LIKE 'hello\_%' ORDER BY ts;
+
+INSERT INTO t_fulltext_bloom_tokens VALUES
+    (4, 'hello_world again'),
+    (5, '农业 error');
+
+ADMIN FLUSH_TABLE('t_fulltext_bloom_tokens');
+
+-- Old and new SSTs: one bloom blob of each version.
+SELECT meta_json LIKE '%"bloom_version":2%' AS is_v2, count(*) AS ssts
+FROM information_schema.ssts_index_meta
+WHERE table_id = (SELECT table_id FROM information_schema.tables WHERE table_name = 't_fulltext_bloom_tokens')
+  AND index_type = 'fulltext_bloom'
+GROUP BY is_v2
+ORDER BY is_v2;
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ 'world' ORDER BY ts;
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ 'error' ORDER BY ts;
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ '农业' ORDER BY ts;
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg LIKE 'hello\_%' ORDER BY ts;
+
+-- Rebuilds the old SST's index with the current bloom version.
+ADMIN BUILD_INDEX('t_fulltext_bloom_tokens');
+
+-- SQLNESS SLEEP 2s
+SELECT meta_json LIKE '%"bloom_version":2%' AS is_v2, count(*) AS ssts
+FROM information_schema.ssts_index_meta
+WHERE table_id = (SELECT table_id FROM information_schema.tables WHERE table_name = 't_fulltext_bloom_tokens')
+  AND index_type = 'fulltext_bloom'
+GROUP BY is_v2
+ORDER BY is_v2;
+
+SELECT ts, msg FROM t_fulltext_bloom_tokens WHERE msg @@ 'world' ORDER BY ts;
+
+DROP TABLE t_fulltext_bloom_tokens;
+
+-- Two SSTs written by the old binary.
+SELECT meta_json LIKE '%"bloom_version":2%' AS is_v2, count(*) AS ssts
+FROM information_schema.ssts_index_meta
+WHERE table_id = (SELECT table_id FROM information_schema.tables WHERE table_name = 't_fulltext_bloom_compact')
+  AND index_type = 'fulltext_bloom'
+GROUP BY is_v2
+ORDER BY is_v2;
+
+SELECT ts, msg FROM t_fulltext_bloom_compact WHERE msg @@ 'world' ORDER BY ts;
+
+-- Merges both SSTs into one with a current bloom blob.
+ADMIN COMPACT_TABLE('t_fulltext_bloom_compact', 'strict_window', 'window=3600');
+
+SELECT meta_json LIKE '%"bloom_version":2%' AS is_v2, count(*) AS ssts
+FROM information_schema.ssts_index_meta
+WHERE table_id = (SELECT table_id FROM information_schema.tables WHERE table_name = 't_fulltext_bloom_compact')
+  AND index_type = 'fulltext_bloom'
+GROUP BY is_v2
+ORDER BY is_v2;
+
+SELECT ts, msg FROM t_fulltext_bloom_compact WHERE msg @@ 'world' ORDER BY ts;
+
+SELECT ts, msg FROM t_fulltext_bloom_compact WHERE msg @@ '农业' ORDER BY ts;
+
+DROP TABLE t_fulltext_bloom_compact;
diff --git a/tests/perf/query_cases/mergescan_shuffle_9456/case.toml b/tests/perf/query_cases/mergescan_shuffle_9456/case.toml
new file mode 100644
index 00000000000..d96bdc9eb01
--- /dev/null
+++ b/tests/perf/query_cases/mergescan_shuffle_9456/case.toml
@@ -0,0 +1,152 @@
+# Opt-in comparison of Hash RepartitionExec cost on a multi-region PromQL join.
+# ANALYZE records plans and metrics; EVAL preserves complete results for comparison.
+
+[case]
+name = "mergescan_shuffle_9456"
+description = "Opt-in multi-region Partitioned PromQL shuffle cost measurement"
+issue = "https://github.com/GreptimeTeam/greptimedb/issues/9456"
+
+[scenario]
+kind = "prom_remote_write_then_query"
+
+[scenario.remote_write]
+database = "public"
+metric = "mergescan_shuffle_9456"
+physical_table = "mergescan_shuffle_phys"
+series_count = 4096
+samples_per_series = 120
+start_unix_millis = 1704067200000
+step_millis = 60000
+chunk_series_count = 128
+timeout_seconds = 300
+visibility_timeout_seconds = 300
+
+base_setup_sql = [
+  """
+CREATE TABLE mergescan_shuffle_phys (
+    greptime_timestamp TIMESTAMP(3) TIME INDEX,
+    host STRING,
+    instance STRING,
+    greptime_value DOUBLE,
+    PRIMARY KEY (host, instance)
+)
+PARTITION ON COLUMNS (instance) (
+    instance < 'instance000128',
+    instance >= 'instance000128' AND instance < 'instance000256',
+    instance >= 'instance000256' AND instance < 'instance000384',
+    instance >= 'instance000384' AND instance < 'instance000512',
+    instance >= 'instance000512' AND instance < 'instance000640',
+    instance >= 'instance000640' AND instance < 'instance000768',
+    instance >= 'instance000768' AND instance < 'instance000896',
+    instance >= 'instance000896' AND instance < 'instance001024',
+    instance >= 'instance001024' AND instance < 'instance001152',
+    instance >= 'instance001152' AND instance < 'instance001280',
+    instance >= 'instance001280' AND instance < 'instance001408',
+    instance >= 'instance001408' AND instance < 'instance001536',
+    instance >= 'instance001536' AND instance < 'instance001664',
+    instance >= 'instance001664' AND instance < 'instance001792',
+    instance >= 'instance001792' AND instance < 'instance001920',
+    instance >= 'instance001920' AND instance < 'instance002048',
+    instance >= 'instance002048' AND instance < 'instance002176',
+    instance >= 'instance002176' AND instance < 'instance002304',
+    instance >= 'instance002304' AND instance < 'instance002432',
+    instance >= 'instance002432' AND instance < 'instance002560',
+    instance >= 'instance002560' AND instance < 'instance002688',
+    instance >= 'instance002688' AND instance < 'instance002816',
+    instance >= 'instance002816' AND instance < 'instance002944',
+    instance >= 'instance002944' AND instance < 'instance003072',
+    instance >= 'instance003072' AND instance < 'instance003200',
+    instance >= 'instance003200' AND instance < 'instance003328',
+    instance >= 'instance003328' AND instance < 'instance003456',
+    instance >= 'instance003456' AND instance < 'instance003584',
+    instance >= 'instance003584' AND instance < 'instance003712',
+    instance >= 'instance003712' AND instance < 'instance003840',
+    instance >= 'instance003840' AND instance < 'instance003968',
+    instance >= 'instance003968'
+) ENGINE=metric WITH ('physical_metric_table'='true')
+""",
+  """
+CREATE TABLE mergescan_shuffle_9456 (
+    greptime_timestamp TIMESTAMP(3) TIME INDEX,
+    host STRING,
+    instance STRING,
+    greptime_value DOUBLE,
+    PRIMARY KEY (host, instance)
+) ENGINE=metric WITH ('on_physical_table'='mergescan_shuffle_phys')
+""",
+]
+candidate_setup_sql = [
+  """
+CREATE TABLE mergescan_shuffle_phys (
+    greptime_timestamp TIMESTAMP(3) TIME INDEX,
+    host STRING,
+    instance STRING,
+    greptime_value DOUBLE,
+    PRIMARY KEY (host, instance)
+)
+PARTITION ON COLUMNS (instance) (
+    instance < 'instance000128',
+    instance >= 'instance000128' AND instance < 'instance000256',
+    instance >= 'instance000256' AND instance < 'instance000384',
+    instance >= 'instance000384' AND instance < 'instance000512',
+    instance >= 'instance000512' AND instance < 'instance000640',
+    instance >= 'instance000640' AND instance < 'instance000768',
+    instance >= 'instance000768' AND instance < 'instance000896',
+    instance >= 'instance000896' AND instance < 'instance001024',
+    instance >= 'instance001024' AND instance < 'instance001152',
+    instance >= 'instance001152' AND instance < 'instance001280',
+    instance >= 'instance001280' AND instance < 'instance001408',
+    instance >= 'instance001408' AND instance < 'instance001536',
+    instance >= 'instance001536' AND instance < 'instance001664',
+    instance >= 'instance001664' AND instance < 'instance001792',
+    instance >= 'instance001792' AND instance < 'instance001920',
+    instance >= 'instance001920' AND instance < 'instance002048',
+    instance >= 'instance002048' AND instance < 'instance002176',
+    instance >= 'instance002176' AND instance < 'instance002304',
+    instance >= 'instance002304' AND instance < 'instance002432',
+    instance >= 'instance002432' AND instance < 'instance002560',
+    instance >= 'instance002560' AND instance < 'instance002688',
+    instance >= 'instance002688' AND instance < 'instance002816',
+    instance >= 'instance002816' AND instance < 'instance002944',
+    instance >= 'instance002944' AND instance < 'instance003072',
+    instance >= 'instance003072' AND instance < 'instance003200',
+    instance >= 'instance003200' AND instance < 'instance003328',
+    instance >= 'instance003328' AND instance < 'instance003456',
+    instance >= 'instance003456' AND instance < 'instance003584',
+    instance >= 'instance003584' AND instance < 'instance003712',
+    instance >= 'instance003712' AND instance < 'instance003840',
+    instance >= 'instance003840' AND instance < 'instance003968',
+    instance >= 'instance003968'
+) ENGINE=metric WITH ('physical_metric_table'='true')
+""",
+  """
+CREATE TABLE mergescan_shuffle_9456 (
+    greptime_timestamp TIMESTAMP(3) TIME INDEX,
+    host STRING,
+    instance STRING,
+    greptime_value DOUBLE,
+    PRIMARY KEY (host, instance)
+) ENGINE=metric WITH ('on_physical_table'='mergescan_shuffle_phys')
+""",
+]
+
+[[scenario.queries]]
+name = "partitioned_shuffle_cost"
+kind = "tql"
+query = "TQL ANALYZE VERBOSE (1704067200, 1704074340, '1m') rate(mergescan_shuffle_9456[5m]) / ignoring(host) rate(mergescan_shuffle_9456[5m])"
+warmup = 1
+iterations = 7
+
+[[scenario.queries]]
+name = "collect_left_control"
+kind = "tql"
+query = "TQL ANALYZE VERBOSE (1704067200, 1704074340, '1m') rate(mergescan_shuffle_9456[5m]) / rate(mergescan_shuffle_9456[5m])"
+warmup = 1
+iterations = 7
+
+[[scenario.queries]]
+name = "partitioned_complete_results"
+kind = "tql"
+query = "TQL EVAL (1704067200, 1704074340, '1m') rate(mergescan_shuffle_9456[5m]) / ignoring(host) rate(mergescan_shuffle_9456[5m])"
+warmup = 0
+iterations = 1
diff --git a/tests/perf/query_cases/promql_long_range_rate/case.toml b/tests/perf/query_cases/promql_long_range_rate/case.toml
new file mode 100644
index 00000000000..51dfe1f1a86
--- /dev/null
+++ b/tests/perf/query_cases/promql_long_range_rate/case.toml
@@ -0,0 +1,119 @@
+# PromQL long-window rate benchmark for issue #9070.
+#
+# 2048 series × 1440 samples at 15-second cadence = 2,949,120 rows spanning the
+# six hours from 2024-01-01T00:00:00Z to 2024-01-01T06:00:00Z. Evaluation covers
+# the last two hours of that data (04:00:00Z–06:00:00Z at a 15-second step, 481
+# evaluations), so every evaluation holds a full 240-sample one-hour window.
+# `rate_1h` is the primary regressed shape: it drives the RangeManipulate
+# timestamp payload and the cursor scan across a long, heavily overlapping
+# window set. `rate_5m` is the small-window control, `offset 1h` exercises the
+# shifted payload path, and the bare selector controls unrelated-path variance.
+#
+# The generator derives each tag value as `series % cardinality`, so the number
+# of distinct (host, instance) series is the least common multiple of the two
+# cardinalities. `instance` declares 2048 values so the host(16) × instance tag
+# shape still yields 2048 distinct series; a 128-value instance tag would cap
+# this fixture at 128 distinct series.
+#
+# The deterministic wave is not a true monotonic counter, so the rate queries
+# measure latency on the regular rate path rather than a numeric counter-rate
+# oracle.
+
+[case]
+name = "promql_long_range_rate"
+description = "PromQL long-window rate latency regression for #9070 over six hours of 15-second samples"
+issue = "https://github.com/GreptimeTeam/greptimedb/issues/9070"
+
+[scenario]
+kind = "direct_readable_sst"
+seed = 9070
+
+[[scenario.tables]]
+database = "public"
+name = "promql_long_range_rate"
+engine = "mito"
+append_mode = true
+sst_format = "flat"
+primary_key = ["host", "instance"]
+time_index = "ts"
+
+[[scenario.tables.columns]]
+name = "host"
+type = "STRING"
+semantic = "tag"
+distribution = { kind = "cardinality", values = 16, prefix = "host" }
+
+[[scenario.tables.columns]]
+name = "instance"
+type = "STRING"
+semantic = "tag"
+distribution = { kind = "cardinality", values = 2048, prefix = "instance" }
+
+[[scenario.tables.columns]]
+name = "value"
+type = "DOUBLE"
+semantic = "field"
+distribution = { kind = "deterministic_wave", min = 0.0, max = 1000.0 }
+
+[[scenario.tables.columns]]
+name = "ts"
+type = "TIMESTAMP(9)"
+semantic = "timestamp"
+
+# Eight 45-minute SSTs (180 timestamps each) tile the six-hour range.
+# A (03:00:00Z, 06:00:00Z] scan prunes to four of them; the offset query scans
+# the five SSTs covering [02:00:00Z, 05:00:00Z).
+[scenario.layout]
+regions = 1
+sst_count = 8
+rows_per_sst = 368640
+row_group_size = 36864
+series_count = 2048
+start_unix_nanos = 1704067200000000000
+step_nanos = 15000000000
+time_range_layout = "non_overlapping_per_sst"
+series_layout = "timestamp_major"
+
+# 240 samples per full window: the primary regressed shape.
+[[scenario.queries]]
+name = "rate_1h"
+kind = "tql"
+query = "TQL ANALYZE VERBOSE (1704081600, 1704088800, '15s') rate(promql_long_range_rate{host=~'host.*'}[1h])"
+warmup = 3
+iterations = 9
+
+[scenario.queries.thresholds]
+max_candidate_latency_regression_pct = 20
+
+# Twenty samples per full window: small-window control.
+[[scenario.queries]]
+name = "rate_5m"
+kind = "tql"
+query = "TQL ANALYZE VERBOSE (1704081600, 1704088800, '15s') rate(promql_long_range_rate{host=~'host.*'}[5m])"
+warmup = 3
+iterations = 9
+
+[scenario.queries.thresholds]
+max_candidate_latency_regression_pct = 20
+
+# The same long window shifted back an hour: non-zero-offset payload path.
+[[scenario.queries]]
+name = "rate_1h_offset_1h"
+kind = "tql"
+query = "TQL ANALYZE VERBOSE (1704081600, 1704088800, '15s') rate(promql_long_range_rate{host=~'host.*'}[1h] offset 1h)"
+warmup = 3
+iterations = 9
+
+[scenario.queries.thresholds]
+max_candidate_latency_regression_pct = 20
+
+# Bare selector over the same evaluation range: unrelated-path variance control.
+[[scenario.queries]]
+name = "plain_selector_control"
+kind = "tql"
+query = "TQL ANALYZE VERBOSE (1704081600, 1704088800, '15s') promql_long_range_rate{host=~'host.*'}"
+warmup = 3
+iterations = 9
+
+[scenario.queries.thresholds]
+max_candidate_latency_regression_pct = 20
diff --git a/tests/perf/test_agent_observability_summary.py b/tests/perf/test_agent_observability_summary.py
index 8223231c908..a6c1774ba0f 100644
--- a/tests/perf/test_agent_observability_summary.py
+++ b/tests/perf/test_agent_observability_summary.py
@@ -14,11 +14,13 @@
 
 import importlib.util
 import json
+import sys
 import tempfile
 import unittest
 from pathlib import Path
 
 SCRIPT = Path(__file__).parents[2] / '.github/scripts/agent-observability-summary.py'
+sys.path.insert(0, str(SCRIPT.parent))
 spec = importlib.util.spec_from_file_location('observability_summary', SCRIPT)
 summary = importlib.util.module_from_spec(spec)
 spec.loader.exec_module(summary)
diff --git a/tests/perf/test_benchmark_version_comparison.py b/tests/perf/test_benchmark_version_comparison.py
new file mode 100644
index 00000000000..56c2619e81c
--- /dev/null
+++ b/tests/perf/test_benchmark_version_comparison.py
@@ -0,0 +1,138 @@
+# 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 copy
+import importlib.util
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+SCRIPTS = Path(__file__).resolve().parents[2] / '.github/scripts'
+spec = importlib.util.spec_from_file_location('comparison', SCRIPTS / 'benchmark-version-comparison.py')
+comparison = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(comparison)
+
+
+def write(path, value):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value))
+
+
+class VersionComparison(unittest.TestCase):
+    def test_opt_in_validation(self):
+        comparison.validate({})
+        comparison.validate({'COMPARE_GREPTIMEDB': 'false', 'GREPTIMEDB_TAG': 'invalid\n'})
+        good = dict(COMPARE_GREPTIMEDB='true', RUN_GREPTIMEDB='true',
+                    BASELINE_GREPTIMEDB_TAG='v1.2.1', GREPTIMEDB_TAG='v1.3.0-beta.1')
+        comparison.validate(good)
+        for key, value in [('RUN_GREPTIMEDB', 'false'), ('BASELINE_GREPTIMEDB_TAG', ''),
+                           ('BASELINE_GREPTIMEDB_TAG', 'v1.3.0-beta.1'),
+                           ('BASELINE_GREPTIMEDB_TAG', 'a,image=other'), ('GREPTIMEDB_TAG', 'x\ny'),
+                           ('COMPARE_GREPTIMEDB', 'yes')]:
+            with self.subTest(key=key, value=value), self.assertRaises(ValueError):
+                comparison.validate(good | {key: value})
+
+    def test_improvement_direction(self):
+        self.assertAlmostEqual(comparison.improvement(100, 80), 20)
+        self.assertAlmostEqual(comparison.improvement(100, 120), -20)
+        self.assertAlmostEqual(comparison.improvement(100, 120, True), 20)
+        for old, new in [(0, 3), (None, 4), (1, -1), (1, float('nan')), (True, 2)]:
+            self.assertIsNone(comparison.improvement(old, new))
+
+    def test_agent_result_gates(self):
+        summary = dict(passed=True, contract_sha256='contract', data_profile='S', query_window=[1, 2],
+                       warmup_runs=1, measured_runs=5, per_query=[dict(query_id='Q01', result_fingerprint='answer',
+                       success=5, errors=0, timeouts=0, p50_ms=100, p95_ms=100, p99_ms=100)])
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            base = root / 'baseline/greptimedb-1/greptimedb-1/measured-summary.json'
+            candidate = root / 'greptimedb-1/greptimedb-1/measured-summary.json'
+            for r in (root / 'baseline', root):
+                (r / 'greptimedb-1').mkdir(parents=True, exist_ok=True)
+                (r / 'greptimedb-1/exit-code.txt').write_text('0\n')
+            write(base, summary)
+            changed = copy.deepcopy(summary); changed['per_query'][0]['p50_ms'] = 80
+            write(candidate, changed)
+            self.assertAlmostEqual(comparison.agent(root)[0]['improvement_percent'], 20)
+            for key, value in [('errors', 1), ('timeouts', 1), ('result_fingerprint', 'wrong'), ('success', 0)]:
+                broken = copy.deepcopy(changed); broken['per_query'][0][key] = value
+                write(candidate, broken)
+                self.assertTrue(all(r['improvement_percent'] is None for r in comparison.agent(root)))
+            (root / 'greptimedb-1/exit-code.txt').write_text('1\n')
+            write(candidate, changed)
+            self.assertTrue(all(r['improvement_percent'] is None for r in comparison.agent(root)))
+            (root / 'greptimedb-1/exit-code.txt').write_text('0\n')
+            changed['query_window'] = [2, 3]; write(candidate, changed)
+            self.assertTrue(all(r['improvement_percent'] is None for r in comparison.agent(root)))
+            candidate.unlink()
+            self.assertTrue(all(r['improvement_percent'] is None for r in comparison.agent(root)))
+
+    def test_traces_uses_measured_only_and_rejects_failed_query(self):
+        answer = dict(query_id='T01', outcome='passed', fingerprint='answer', row_count=1, elapsed_ms=100)
+        sample = dict(answer, phase='measured')
+        record = dict(success=True, expected={'contracts': {'T01': {'fingerprint': 'answer', 'row_count': 1}}},
+                      protocol={'runs': 5}, audit_expected={}, corpus='sanity',
+                      execution=dict(db_cpus='8', db_memory='16g', load_workers_requested=4, max_in_flight=8),
+                      correctness=[answer], samples=[dict(sample, phase='warmup', elapsed_ms=99999), sample, sample])
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp);base = root / 'baseline/runs/greptimedb/run.json'; candidate = root / 'runs/greptimedb/run.json'
+            write(base, record); changed = copy.deepcopy(record)
+            for s in changed['samples']:
+                if s['phase'] == 'measured': s['elapsed_ms'] = 80
+            write(candidate, changed)
+            self.assertAlmostEqual(comparison.traces(root)[0]['improvement_percent'], 20)
+            self.assertIsNone(comparison.traces(root)[1]['improvement_percent'])
+            for key, value in [('outcome', 'failed'), ('fingerprint', 'wrong'), ('row_count', 2)]:
+                broken = copy.deepcopy(changed); broken['samples'][1][key] = value; write(candidate, broken)
+                self.assertIsNone(comparison.traces(root)[0]['improvement_percent'])
+
+    def test_long_range_gates(self):
+        summary = dict(workload='vmbench-long-range', query_file_sha256='hash', start='start', end='end', step='30m',
+                       profile='small', data_duration='32d', scrape_interval='30s', cache_policy_effective='warm',
+                       mode='serial', connection_mode='force-close', request_timeout_seconds=120, tries=5, warmup_runs=1,
+                       errors=0, timeouts=0, per_query=[dict(query_index=1, query='up', series=1, points=2,
+                       success=5, errors=0, timeouts=0, p50_ms=100)])
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp); base = root/'greptimedb-baseline/results-vmbench-long-range/serial-summary.json'
+            candidate = root/'greptimedb/results-vmbench-long-range/serial-summary.json'
+            health = {phase: {target: {'state': 'Running=true ExitCode=0 OOMKilled=false'}
+                               for target in ('greptimedb-baseline', 'greptimedb')}
+                      for phase in ('post_load_results', 'post_query_results')}
+            health['post_load_results'] = {k: {'docker': v} for k, v in health['post_load_results'].items()}
+            write(root / 'run-manifest.json', health)
+            write(base, summary); write(candidate, summary)
+            self.assertEqual(comparison.long_range(root)[0]['improvement_percent'], 0)
+            for key, value in [('start','different'),('tries',1),('query_file_sha256','other'),('errors',1)]:
+                write(candidate, summary | {key:value})
+                self.assertIsNone(comparison.long_range(root)[0]['improvement_percent'])
+            write(candidate, summary)
+            broken=copy.deepcopy(health);broken['post_query_results']['greptimedb']['state']='Running=false ExitCode=137 OOMKilled=true'
+            write(root / 'run-manifest.json', broken)
+            self.assertIsNone(comparison.long_range(root)[0]['improvement_percent'])
+            write(root / 'run-manifest.json', health)
+            empty=copy.deepcopy(summary);empty['per_query'][0]['points']=0;write(candidate,empty)
+            self.assertIsNone(comparison.long_range(root)[0]['improvement_percent'])
+
+    def test_missing_results_and_rendering(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            for load in (comparison.agent, comparison.traces, comparison.long_range):
+                self.assertTrue(all(r['improvement_percent'] is None for r in load(Path(tmp))))
+        rendered = comparison.render(dict(baseline_tag='old', candidate_tag='<new|tag>', rows=[]))
+        self.assertIn('&lt;new&#124;tag&gt;', rendered)
+        self.assertIn('Results unavailable', rendered)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/perf/test_ci_runner_scripts.py b/tests/perf/test_ci_runner_scripts.py
index f9742079b49..c703e41c62b 100644
--- a/tests/perf/test_ci_runner_scripts.py
+++ b/tests/perf/test_ci_runner_scripts.py
@@ -16,6 +16,7 @@
 """Offline regression coverage for CI runner selection and lifecycle."""
 
 import importlib.util
+import json
 import os
 import re
 import subprocess
@@ -77,6 +78,67 @@ class ProviderConfigTest(unittest.TestCase):
             with self.subTest(provider=provider, requested=requested):
                 self.assertEqual(config.resolve_instance_type(provider, requested), expected)
 
+    def test_traces_workflow_runner_defaults_and_overrides(self):
+        workflow = (SCRIPTS.parent / "workflows/tracesbench.yml").read_text()
+        step = workflow.split("    - name: Resolve CI runner\n", 1)[1].split("    - name:", 1)[0]
+        command = textwrap.dedent(step.split("      run: |\n", 1)[1])
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / "greptimedb").symlink_to(SCRIPTS.parents[1], target_is_directory=True)
+            output = root / "output"
+            for provider, requested, expected in (
+                ("Aliyun", "auto", "ecs.g9i.2xlarge"),
+                ("AWS", "auto", "m7i.2xlarge"),
+                ("Aliyun", "ecs.c9i.4xlarge", "ecs.c9i.4xlarge"),
+                ("AWS", "c7i.4xlarge", "c7i.4xlarge"),
+                ("invalid", "auto", None),
+                ("AWS", "ecs.g9i.2xlarge", None),
+            ):
+                with self.subTest(provider=provider, requested=requested):
+                    output.write_text("")
+                    result = subprocess.run(
+                        ["bash", "-c", command], cwd=root, capture_output=True, text=True,
+                        env=dict(os.environ, PROVIDER=provider, REQUESTED_INSTANCE_TYPE=requested,
+                                 GITHUB_OUTPUT=str(output)), timeout=10,
+                    )
+                    if expected is None:
+                        self.assertNotEqual(result.returncode, 0)
+                        self.assertEqual(output.read_text(), "")
+                    else:
+                        self.assertEqual(result.returncode, 0, result.stderr)
+                        self.assertEqual(output.read_text(), f"instance_type={expected}\n")
+        self.assertRegex(workflow, r"(?s)db_cpus:.*?default: '8'")
+        self.assertRegex(workflow, r"(?s)db_memory:.*?default: 32g")
+
+    def test_traces_selected_targets_and_image_tag(self):
+        workflow = (SCRIPTS.parent / "workflows/tracesbench.yml").read_text()
+        step = workflow.split("    - name: Validate selected targets\n", 1)[1].split("    - name:", 1)[0]
+        command = textwrap.dedent(step.split("      run: |\n", 1)[1])
+        with tempfile.TemporaryDirectory() as directory:
+            output = Path(directory) / "output"
+            for enabled, tag, expected in (
+                (("true", "false", "false"), "latest", "greptimedb"),
+                (("false", "true", "false"), "", "victoriatraces"),
+                (("false", "false", "true"), "", "tempo"),
+                (("true", "true", "true"), "v1.3.0-beta.1", "greptimedb,victoriatraces,tempo"),
+                (("false", "false", "false"), "latest", None),
+                (("true", "false", "false"), "latest; touch /tmp/unexpected", None),
+                (("true", "false", "false"), "", None),
+                (("invalid", "false", "false"), "latest", None),
+            ):
+                with self.subTest(enabled=enabled, tag=tag):
+                    output.write_text("")
+                    env = dict(os.environ, GREPTIMEDB_TAG=tag, GITHUB_OUTPUT=str(output))
+                    env.update(zip(("greptimedb", "victoriatraces", "tempo"), enabled))
+                    result = subprocess.run(["bash", "-c", command], env=env,
+                                            capture_output=True, text=True, timeout=5)
+                    if expected is None:
+                        self.assertNotEqual(result.returncode, 0)
+                        self.assertNotIn("targets=", output.read_text())
+                    else:
+                        self.assertEqual(result.returncode, 0, result.stderr)
+                        self.assertIn(f"targets={expected}\n", output.read_text())
+
     def test_wrong_provider_and_shell_fragments_rejected(self):
         for provider, requested in (("ec2", "auto"), ("AWS", "ecs.c9i.2xlarge"),
                                     ("Aliyun", "c7i.2xlarge"), ("AWS", ""),
@@ -401,6 +463,154 @@ class AwsTeardownTest(unittest.TestCase):
             self.assertEqual(teardown.teardown(Mock(), "owner/repo", "token", run_id="123-2"), 1)
             self.assertEqual([c.args[1] for c in delete.call_args_list], ["i-a", "i-b"])
 
+class BenchmarkImagePullTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.root = Path(self.tmp.name)
+        self.env = dict(os.environ, PATH=f"{self.root}:{os.environ['PATH']}",
+                        PULL_TEST_ROOT=str(self.root))
+        self.tool("docker", '''
+            echo "$*" >> "$PULL_TEST_ROOT/docker.log"
+            count=$(wc -l < "$PULL_TEST_ROOT/docker.log")
+            codes=${PULL_TEST_CODES:-0}
+            code=$(printf '%s' "$codes" | cut -d, -f"$count")
+            exit "${code:-0}"
+        ''')
+        self.tool("timeout", '''
+            echo "$*" >> "$PULL_TEST_ROOT/timeout.log"
+            shift 2
+            if [[ ${PULL_TEST_TIMEOUT:-0} == 1 ]]; then exit 124; fi
+            exec "$@"
+        ''')
+        self.tool("sleep", 'echo "$*" >> "$PULL_TEST_ROOT/sleep.log"')
+
+    def tool(self, name, body):
+        p = self.root / name
+        p.write_text("#!/bin/bash\nset -eu\n" + textwrap.dedent(body))
+        p.chmod(0o755)
+
+    def lines(self, name):
+        p = self.root / (name + ".log")
+        return p.read_text().splitlines() if p.exists() else []
+
+    def pull(self, codes, *args):
+        self.env["PULL_TEST_CODES"] = codes
+        return subprocess.run(["bash", str(SCRIPTS / "pull-benchmark-image.sh"), *args],
+                              env=self.env, capture_output=True, text=True, timeout=5)
+
+    def test_success_does_not_retry(self):
+        result = self.pull("0", "registry/test@sha256:" + "a" * 64)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(len(self.lines("docker")), 1)
+        self.assertEqual(self.lines("sleep"), [])
+        self.assertTrue(self.lines("timeout")[0].startswith("--kill-after=10s 180s docker pull "))
+
+    def test_transient_failure_then_success(self):
+        result = self.pull("1,1,0", "registry/test:tag")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(self.lines("docker"), ["pull registry/test:tag"] * 3)
+        self.assertEqual(self.lines("sleep"), ["10", "20"])
+        self.assertIn("attempt 3/3", result.stderr)
+
+    def test_exhaustion_preserves_failure(self):
+        result = self.pull("1,1,7", "registry/test:tag")
+        self.assertEqual(result.returncode, 7)
+        self.assertEqual(len(self.lines("docker")), 3)
+        self.assertEqual(self.lines("sleep"), ["10", "20"])
+
+    def test_timeout_is_bounded_and_fatal(self):
+        self.env["PULL_TEST_TIMEOUT"] = "1"
+        result = self.pull("0", "registry/test:tag")
+        self.assertEqual(result.returncode, 124)
+        self.assertEqual(len(self.lines("timeout")), 3)
+        self.assertEqual(self.lines("sleep"), ["10", "20"])
+
+    def test_bad_arguments_do_not_call_docker(self):
+        for args in ([], [""], ["--help"], ["a", "b"]):
+            with self.subTest(args=args):
+                self.assertEqual(self.pull("0", *args).returncode, 2)
+        self.assertEqual(self.lines("docker"), [])
+
+    def test_traces_prefetch_executes_catalog_refs_and_stops_on_failure(self):
+        traces = (SCRIPTS.parent / 'workflows/tracesbench.yml').read_text()
+        start = traces.index('    - name: Pull database images before generating data')
+        end = traces.index('    - name: Generate selected dataset once')
+        command = textwrap.dedent(traces[start:end].split('      run: |\n', 1)[1])
+        helper = self.root / 'greptimedb/.github/scripts/pull-benchmark-image.sh'
+        helper.parent.mkdir(parents=True)
+        helper.write_text((SCRIPTS / helper.name).read_text())
+        catalogs = self.root / 'o11ybench/workloads/tracesbench/catalogs'
+        catalogs.mkdir(parents=True)
+        images = [f'registry/{name}@sha256:' + 'a' * 64
+                  for name in ('greptimedb', 'victoriatraces', 'tempo')]
+        for name, image in zip(('greptimedb', 'victoriatraces', 'tempo'), images):
+            (catalogs / f'{name}.json').write_text(json.dumps({'target_identity': {'image': image}}))
+        self.tool('docker', '''
+            echo "$*" >> "$PULL_TEST_ROOT/docker.log"
+            if [[ $1 == pull && $2 == ${PULL_FAIL_IMAGE:-} ]]; then exit 1; fi
+            if [[ $1 == image ]]; then printf '[{"RepoDigests":["greptime/greptimedb@sha256:%s"]}]\\n' "$(printf 'a%.0s' {1..64})"; fi
+        ''')
+        images[0] = 'greptime/greptimedb:v1.3.0-beta.1'
+        self.env.update(METADATA_ROOT=str(self.root), GREPTIMEDB_TAG='v1.3.0-beta.1',
+                        GITHUB_ENV=str(self.root / 'env'), BASELINE_GREPTIMEDB_TAG='v1.2.1')
+        for selected, compare in ((('greptimedb',), False), (('tempo',), False),
+                                  (('greptimedb', 'victoriatraces', 'tempo'), False),
+                                  (('greptimedb',), True), (('greptimedb', 'victoriatraces', 'tempo'), True)):
+            with self.subTest(selected=selected):
+                self.env['TARGETS'] = ','.join(selected)
+                self.env['COMPARE_GREPTIMEDB'] = str(compare).lower()
+                (self.root / 'env').write_text('')
+                (self.root / 'docker.log').unlink(missing_ok=True)
+                result = subprocess.run(['bash', '-c', command], cwd=self.root, env=self.env,
+                                        capture_output=True, text=True, timeout=5)
+                self.assertEqual(result.returncode, 0, result.stderr)
+                selected_images = [image for target, image in zip(('greptimedb', 'victoriatraces', 'tempo'), images)
+                                   if target in selected]
+                if compare:
+                    selected_images.append('greptime/greptimedb:v1.2.1')
+                self.assertEqual(self.lines('docker'),
+                                 [call for image in selected_images for call in (f'pull {image}', f'image inspect {image}')])
+                expected_env = 'GREPTIMEDB_IMAGE=greptime/greptimedb@sha256:' + 'a' * 64 + '\n'
+                expected_env = expected_env if 'greptimedb' in selected else ''
+                if compare:
+                    expected_env += 'BASELINE_GREPTIMEDB_IMAGE=greptime/greptimedb@sha256:' + 'a' * 64 + '\n'
+                self.assertEqual((self.root / 'env').read_text(), expected_env)
+        (self.root / 'docker.log').unlink()
+        self.env['PULL_FAIL_IMAGE'] = images[1]
+        result = subprocess.run(['bash', '-c', command], cwd=self.root, env=self.env,
+                                capture_output=True, text=True, timeout=5)
+        self.assertNotEqual(result.returncode, 0)
+        self.assertEqual(self.lines('docker'), [f'pull {images[0]}', f'image inspect {images[0]}']
+                         + [f'pull {images[1]}'] * 3)
+        self.assertNotIn(f'pull {images[2]}', self.lines('docker'))
+
+    def test_workflows_pull_before_generation(self):
+        workflows = SCRIPTS.parent / "workflows"
+        agent = (workflows / "agent-observability.yml").read_text()
+        traces = (workflows / "tracesbench.yml").read_text()
+        long_range = (workflows / "vmbench-long-range.yml").read_text()
+        for content in (agent, traces, long_range):
+            self.assertNotIn("docker pull ", content)
+        for reference in ("RUNTIME_IMAGE", "RESOLVED_RUNTIME_IMAGE", "reference"):
+            self.assertIn(f'pull-benchmark-image.sh "${reference}"', long_range)
+        self.assertLess(long_range.index('pull-benchmark-image.sh "$reference"'),
+                        long_range.index('- name: Warm serial and concurrent benchmarks'))
+        self.assertIn('pull-benchmark-image.sh "$reference"', agent)
+        self.assertLess(agent.index('resolve_image runtime'), agent.index('- name: Generate dataset once'))
+        self.assertIn('pull-benchmark-image.sh "$RUNTIME_IMAGE"', traces)
+        self.assertIn('pull-benchmark-image.sh "$RESOLVED_RUNTIME_IMAGE"', traces)
+        start = traces.index('    - name: Pull database images before generating data')
+        end = traces.index('    - name: Generate selected dataset once')
+        self.assertLess(start, end)
+        step = traces[start:end]
+        self.assertIn('IFS=, read -ra targets <<< "$TARGETS"', step)
+        self.assertIn('for target in "${targets[@]}"', step)
+        self.assertIn('o11ybench/workloads/tracesbench/catalogs/$target.json', step)
+        self.assertIn('pull-benchmark-image.sh "$image"', step)
+        self.assertIn('set -euo pipefail', step)
+        self.assertNotIn('continue-on-error', step)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/perf/test_oswal_s3_bench_scripts.py b/tests/perf/test_oswal_s3_bench_scripts.py
new file mode 100644
index 00000000000..dc81240f1ae
--- /dev/null
+++ b/tests/perf/test_oswal_s3_bench_scripts.py
@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+# 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.
+
+"""Offline tests of the object store WAL S3 benchmark plan and summary."""
+
+import importlib.util
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+SCRIPTS = Path(__file__).parents[2] / ".github/scripts"
+
+
+def load(name, filename):
+    spec = importlib.util.spec_from_file_location(name, SCRIPTS / filename)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+bench = load("oswal_s3_bench", "oswal-s3-bench.py")
+summary = load("oswal_s3_bench_summary", "oswal-s3-bench-summary.py")
+
+ACK_BUCKETS = """# TYPE greptime_logstore_object_store_wal_append_ack_seconds histogram
+greptime_logstore_object_store_wal_append_ack_seconds_bucket{le="0.064"} 0
+greptime_logstore_object_store_wal_append_ack_seconds_bucket{le="0.128"} 50
+greptime_logstore_object_store_wal_append_ack_seconds_bucket{le="0.256"} 100
+greptime_logstore_object_store_wal_append_ack_seconds_bucket{le="+Inf"} 100
+greptime_logstore_object_store_wal_append_ack_seconds_sum 12
+greptime_logstore_object_store_wal_append_ack_seconds_count 100
+greptime_logstore_object_store_wal_created_objects_total 120
+greptime_logstore_object_store_wal_stalled_appends_total 3
+greptime_logstore_object_store_wal_poisoned_total 0
+greptime_logstore_kafka_client_produce_elapsed_count 9
+"""
+
+
+class PlanTest(unittest.TestCase):
+    def test_default_plan_alternates_the_order_between_rounds(self):
+        plan = bench.build_plan("1,8", "2000000", "1000", "2", smoke=False)
+        self.assertEqual([c["id"] for c in plan["cells"]], [
+            "1-1-R", "1-1-D", "1-1-E", "1-8-R", "1-8-D", "1-8-E",
+            "2-1-E", "2-1-D", "2-1-R", "2-8-E", "2-8-D", "2-8-R"])
+        self.assertEqual(plan["generator_args"], ["--data-profile", "D"])
+        self.assertEqual((plan["rows"], plan["batch_rows"], plan["data_profile"]), (2_000_000, 1000, "D"))
+        self.assertEqual({c["config"]: c["wal"] for c in plan["cells"]}, {
+            "R": {"PROVIDER": "raft_engine", "SYNC_WRITE": "true", "DIR": "/wal"},
+            "D": {"PROVIDER": "experimental_object_store", "ACK_MODE": "durable"},
+            "E": {"PROVIDER": "experimental_object_store", "ACK_MODE": "enqueued"}})
+
+    def test_smoke_overrides_rows_and_rounds(self):
+        plan = bench.build_plan("8", "2000000", "1000", "2", smoke=True)
+        self.assertEqual((plan["rows"], plan["rounds"], plan["data_profile"]), (50_000, 1, "custom"))
+        self.assertEqual(plan["generator_args"], ["--line-count", "50000"])
+        self.assertEqual([c["id"] for c in plan["cells"]], ["1-8-R", "1-8-D", "1-8-E"])
+
+    def test_invalid_inputs_are_rejected(self):
+        for args in (("0", "10", "10", "1"), ("1,1", "10", "10", "1"), ("1", "abc", "10", "1"),
+                     ("1", "10", "10", "11"), ("1,", "10", "10", "1")):
+            with self.subTest(args=args), self.assertRaises(ValueError):
+                bench.build_plan(*args, smoke=False)
+
+    def test_nightly_tag_is_the_newest_by_date(self):
+        tags = ["latest", "v1.3.0-alpha.1-nightly-20260907", "v1.4.0-nightly-20261012",
+                "v1.4.0-nightly-20261005", "nightly-arm64"]
+        self.assertEqual(bench.newest_nightly(tags), "v1.4.0-nightly-20261012")
+        with self.assertRaises(ValueError):
+            bench.newest_nightly(["latest"])
+        self.assertEqual(bench.resolve_tag("v1.4.0-nightly-20261012"), "v1.4.0-nightly-20261012")
+        with self.assertRaises(ValueError):
+            bench.resolve_tag("bad tag")
+
+    def test_budgets_and_regions(self):
+        bench.validate_budgets("240", "8")
+        for timeout, ttl in (("360", "7"), ("0", "8"), ("361", "168"), ("240", "169")):
+            with self.subTest(timeout=timeout, ttl=ttl), self.assertRaises(ValueError):
+                bench.validate_budgets(timeout, ttl)
+        bench.check_regions("ap-southeast-1", "ap-southeast-1")
+        for bucket, runner in (("us-east-1", "ap-southeast-1"), ("", "")):
+            with self.subTest(bucket=bucket), self.assertRaisesRegex(ValueError, "cross-region"):
+                bench.check_regions(bucket, runner)
+
+    def test_manifest_takes_the_sha256_digest(self):
+        plan = bench.build_plan("1,8", "2000000", "1000", "2", smoke=False)
+        inspect = [{"RepoDigests": ["greptime/greptimedb@sha256:" + "a" * 64]}]
+        manifest = bench.build_manifest(plan, inspect, "runtime@sha256:" + "b" * 64, "c6id.2xlarge",
+                                        "ap-southeast-1", "oswal-bench/1-1")
+        self.assertEqual(manifest["greptimedb_image"], "greptime/greptimedb@sha256:" + "a" * 64)
+        self.assertEqual((manifest["rows"], manifest["rounds"], manifest["concurrency"]), (2_000_000, 2, [1, 8]))
+        with self.assertRaises(ValueError):
+            bench.build_manifest(plan, [{"RepoDigests": []}], "", "", "", "")
+
+
+class SummaryTest(unittest.TestCase):
+    def test_quantile_interpolates_like_prometheus(self):
+        buckets = summary.parse_metrics(ACK_BUCKETS)["buckets"]["append_ack_seconds"]
+        self.assertAlmostEqual(summary.quantile(0.5, buckets), 0.128)
+        self.assertAlmostEqual(summary.quantile(0.99, buckets), 0.128 + 0.128 * 49 / 50)
+        self.assertAlmostEqual(summary.quantile(0.25, buckets), 0.064 + 0.064 * 25 / 50)
+        self.assertIsNone(summary.quantile(0.5, []))
+        self.assertEqual(summary.quantile(0.99, [(0.1, 1.0), (float("inf"), 4.0)]), 0.1)
+        self.assertNotIn("kafka_client_produce_elapsed_count", summary.parse_metrics(ACK_BUCKETS)["samples"])
+
+    def write_cell(self, root, cell_id, rows_per_second, exit_code=0, metrics=""):
+        round_number, concurrency, config = cell_id.split("-")
+        path = root / "cells" / cell_id
+        (path / "greptimedb-1").mkdir(parents=True)
+        (path / "cell.json").write_text(json.dumps({
+            "id": cell_id, "round": int(round_number), "concurrency": int(concurrency), "config": config,
+            "wal": bench.WAL_CONFIGS[config], "metrics_scraped": True,
+            "exit_code": exit_code, "wal_device": "/dev/nvme1n1", "version": "1.4.0", "load_wall_seconds": 61.0}))
+        if exit_code == 0:
+            (path / "greptimedb-1" / "load-result.json").write_text(json.dumps({
+                "count_after": 6000, "load_seconds": 60.0, "rows_per_second": rows_per_second}))
+        (path / "metrics.prom").write_text(metrics)
+
+    def test_summary_reports_cells_and_geometric_mean_ratios(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            plan = bench.build_plan("8", "6000", "1000", "2", smoke=False)
+            (root / "plan.json").write_text(json.dumps(plan))
+            (root / "run.json").write_text(json.dumps({"rows": 6000, "batch_rows": 1000, "instance_type": "c6id.2xlarge"}))
+            speeds = {"1-8-R": 100.0, "1-8-D": 80.0, "1-8-E": 90.0, "2-8-E": 99.0, "2-8-D": 50.0, "2-8-R": 110.0}
+            for cell_id, speed in speeds.items():
+                self.write_cell(root, cell_id, speed, metrics=ACK_BUCKETS if cell_id.endswith("D") else "")
+            output = subprocess.run([sys.executable, str(SCRIPTS / "oswal-s3-bench-summary.py"), "--root", str(root)],
+                                    check=True, capture_output=True, text=True).stdout
+            result = json.loads((root / "summary.json").read_text())
+            self.assertEqual([c["id"] for c in result["cells"]], [c["id"] for c in plan["cells"]])
+            d_ratio = next(r for r in result["ratios"] if r["ratio"] == "D/R")
+            self.assertAlmostEqual(d_ratio["geomean"], (0.8 * (50 / 110)) ** 0.5)
+            self.assertAlmostEqual(next(r for r in result["ratios"] if r["ratio"] == "E/R")["geomean"], 0.9)
+            d_cell = next(c for c in result["cells"] if c["id"] == "1-8-D")
+            self.assertEqual(d_cell["creates_per_minute"], 120.0)
+            self.assertEqual(d_cell["stalled_appends_total"], 3)
+            self.assertIn("| 1-8-D | 80 | 60.0 | 61.0 | 6,000 | 128.0 | 253.4 | 120 | 120.0 | 3 | 0 | 0 | 0 |", output)
+            r_cell = next(c for c in result["cells"] if c["id"] == "1-8-R")
+            self.assertIsNone(r_cell["stalled_appends_total"])
+
+    def test_untouched_counters_are_zero_only_for_an_active_object_store_wal(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            created = "greptime_logstore_object_store_wal_created_objects_total 40\n"
+            self.write_cell(root, "1-8-E", 90.0, metrics=created)
+            self.write_cell(root, "1-8-D", 80.0, metrics="")
+            cell_e, cell_d = (summary.load_cell(root / "cells" / i) for i in ("1-8-E", "1-8-D"))
+            self.assertEqual([cell_e[c] for c in summary.COUNTERS], [40, 0, 0, 0, 0])
+            self.assertEqual([cell_d[c] for c in summary.COUNTERS], [None] * 5)
+            recorded = json.loads((root / "cells" / "1-8-E" / "cell.json").read_text())
+            (root / "cells" / "1-8-E" / "cell.json").write_text(json.dumps(recorded | {"metrics_scraped": False}))
+            unscraped = summary.load_cell(root / "cells" / "1-8-E")
+            self.assertIsNone(unscraped["stalled_appends_total"])
+
+    def test_a_planned_round_that_never_ran_leaves_the_ratio_undefined(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            plan = bench.build_plan("8", "6000", "1000", "2", smoke=False)
+            (root / "plan.json").write_text(json.dumps(plan))
+            for cell_id, speed in {"1-8-R": 100.0, "1-8-D": 80.0, "1-8-E": 90.0}.items():
+                self.write_cell(root, cell_id, speed)
+            output = subprocess.run([sys.executable, str(SCRIPTS / "oswal-s3-bench-summary.py"), "--root", str(root)],
+                                    check=True, capture_output=True, text=True).stdout
+            result = json.loads((root / "summary.json").read_text())
+            self.assertEqual(result["missing_cells"], ["2-8-E", "2-8-D", "2-8-R"])
+            self.assertEqual(result["planned_cells"], 6)
+            for ratio in result["ratios"]:
+                self.assertIsNone(ratio["geomean"])
+                self.assertIsNone(ratio["per_round"][1])
+            self.assertIn("2-8-D (not run)", output)
+
+    def test_a_failed_cell_leaves_its_ratio_undefined(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            self.write_cell(root, "1-1-R", 100.0)
+            self.write_cell(root, "1-1-D", 0.0, exit_code=1)
+            rows = [summary.load_cell(path) for path in sorted((root / "cells").iterdir())]
+            ratio = next(r for r in summary.ratios(rows) if r["ratio"] == "D/R")
+            self.assertEqual((ratio["per_round"], ratio["geomean"]), ([None], None))
+            self.assertIn("1-1-D (failed, exit 1)", summary.render({}, rows, summary.ratios(rows)))
+
+
+FAKE_DOCKER = r"""#!/usr/bin/env bash
+printf '%s\n' "docker $*" >> "$FAKE_LOG"
+case "$1" in
+    run)
+        for arg in "$@"; do [[ "$arg" != -d ]] || { echo "keys=${GREPTIMEDB_STANDALONE__STORAGE__ACCESS_KEY_ID:+set}${GREPTIMEDB_STANDALONE__STORAGE__SECRET_ACCESS_KEY:+set}" >> "$FAKE_LOG"; echo fakecid; exit 0; }; done
+        for arg in "$@"; do
+            case "$arg" in type=bind,src=*,dst=/results) results=${arg#type=bind,src=}; results=${results%,dst=/results} ;; esac
+        done
+        [[ "$FAKE_LOAD_RC" == 0 ]] || exit "$FAKE_LOAD_RC"
+        mkdir -p "$results/greptimedb-1"
+        echo "{\"count_before\": 0, \"count_after\": $FAKE_ROWS, \"load_seconds\": 2, \"rows_per_second\": 3000}" \
+            > "$results/greptimedb-1/load-result.json" ;;
+    inspect) echo true ;;
+    exec) echo 'version: 1.4.0-test' ;;
+    logs) echo 'server log' ;;
+esac
+"""
+FAKE_CURL = r"""#!/usr/bin/env bash
+printf '%s\n' "curl $*" >> "$FAKE_LOG"
+for arg in "$@"; do
+    [[ "$arg" != */metrics ]] || {
+        [[ "$FAKE_METRICS_RC" == 0 ]] || exit "$FAKE_METRICS_RC"
+        printf '%s\n' 'greptime_logstore_object_store_wal_poisoned_total 1' 'other_total 2'; exit 0;
+    }
+done
+"""
+
+
+class CellLifecycleTest(unittest.TestCase):  # the run script against fake docker and curl
+
+    def run_cells(self, root, load_rc, metrics_rc=0):
+        bin_dir = root / "bin"
+        bin_dir.mkdir()
+        for name, body in (("docker", FAKE_DOCKER), ("curl", FAKE_CURL)):
+            (bin_dir / name).write_text(body)
+            (bin_dir / name).chmod(0o755)
+        plan = bench.build_plan("8", "6000", "1000", "1", smoke=False)
+        plan["cells"] = [cell for cell in plan["cells"] if cell["config"] != "R"]
+        (root / "results").mkdir()
+        (root / "results" / "plan.json").write_text(json.dumps(plan))
+        env = os.environ | {
+            "PATH": f"{bin_dir}:{os.environ['PATH']}", "FAKE_LOG": str(root / "fake.log"),
+            "FAKE_LOAD_RC": str(load_rc), "FAKE_METRICS_RC": str(metrics_rc), "FAKE_ROWS": "6000", "PLAN": str(root / "results" / "plan.json"),
+            "RESULTS": str(root / "results"), "CORPUS_DIR": str(root / "corpus"), "OWNER": "o11ybench-oswal-1-1",
+            "RUNTIME_IMAGE": "runtime@sha256:" + "b" * 64, "GREPTIMEDB_IMAGE": "greptimedb@sha256:" + "a" * 64,
+            "RUN_PREFIX": "oswal-bench/1-1", "WAL_ROOT": str(root / "wal"), "S3_BUCKET": "bucket",
+            "S3_REGION": "ap-southeast-1", "AWS_ACCESS_KEY_ID": "AKIAFAKEKEY", "AWS_SECRET_ACCESS_KEY": "fake-secret-value",
+        }
+        script = str(SCRIPTS / "oswal-s3-bench-run.sh")
+        cells = subprocess.run(["bash", script, "cells"], env=env, capture_output=True, text=True, timeout=60)
+        scrub = subprocess.run(["bash", script, "scrub"], env=env, capture_output=True, text=True, timeout=60)
+        return cells, scrub, (root / "fake.log").read_text(), env
+
+    def test_a_failed_load_still_scrapes_metrics_and_removes_the_server(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            cells, scrub, log, _ = self.run_cells(root, load_rc=3)
+            self.assertNotEqual(cells.returncode, 0)
+            self.assertEqual(scrub.returncode, 0, scrub.stderr)
+            for cell_id in ("1-8-D", "1-8-E"):
+                cell = root / "results" / "cells" / cell_id
+                self.assertEqual(json.loads((cell / "cell.json").read_text())["exit_code"], 3)
+                self.assertEqual((cell / "metrics.prom").read_text(),
+                                 "greptime_logstore_object_store_wal_poisoned_total 1\n")
+                self.assertFalse((cell / "metrics.all").exists())
+                self.assertEqual((cell / "server.log").read_text(), "server log\n")
+            self.assertEqual(log.count("docker stop -t 120 fakecid"), 2)
+            self.assertEqual(log.count("docker rm -fv fakecid"), 2)
+
+    def test_an_ec2_run_without_an_instance_store_fails(self):
+        with tempfile.TemporaryDirectory() as directory:
+            (Path(directory) / "lsblk").write_text("#!/usr/bin/env bash\necho '/dev/nvme0n1 Amazon Elastic Block Store'\n")
+            (Path(directory) / "lsblk").chmod(0o755)
+            env = os.environ | {"PATH": f"{directory}:{os.environ['PATH']}", "SMOKE": "false", "RESULTS": directory}
+            done = subprocess.run(["bash", str(SCRIPTS / "oswal-s3-bench-run.sh"), "wal-disk", f"{directory}/wal"],
+                                  env=env, capture_output=True, text=True, timeout=60)
+            self.assertNotEqual(done.returncode, 0)
+            self.assertIn("No local NVMe instance store", done.stderr)
+
+    def test_a_failed_scrape_fails_a_successful_load(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            cells, _, log, _ = self.run_cells(root, load_rc=0, metrics_rc=22)
+            self.assertNotEqual(cells.returncode, 0)
+            for cell_id in ("1-8-D", "1-8-E"):
+                cell = root / "results" / "cells" / cell_id
+                recorded = json.loads((cell / "cell.json").read_text())
+                self.assertEqual((recorded["exit_code"], recorded["metrics_scraped"]), (4, False))
+                self.assertFalse((cell / "metrics.prom").exists())
+                self.assertFalse((cell / "metrics.all").exists())
+            self.assertEqual(log.count("docker rm -fv fakecid"), 2)
+
+    def test_a_cell_passes_the_keys_by_name_and_records_a_redacted_config(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            cells, scrub, log, env = self.run_cells(root, load_rc=0)
+            self.assertEqual(cells.returncode, 0, cells.stdout + cells.stderr)
+            self.assertEqual(scrub.returncode, 0, scrub.stderr)
+            self.assertNotIn("fake-secret-value", log)
+            self.assertNotIn("AKIAFAKEKEY", log)
+            self.assertEqual(log.count("keys=setset"), 2)
+            self.assertIn("-e GREPTIMEDB_STANDALONE__STORAGE__SECRET_ACCESS_KEY ", log)
+            cell = root / "results" / "cells" / "1-8-D"
+            config = (cell / "config.env").read_text().splitlines()
+            self.assertIn("GREPTIMEDB_STANDALONE__STORAGE__ROOT=oswal-bench/1-1/1-8-D", config)
+            self.assertIn("GREPTIMEDB_STANDALONE__WAL__ACK_MODE=durable", config)
+            self.assertIn("GREPTIMEDB_STANDALONE__STORAGE__SECRET_ACCESS_KEY=<redacted>", config)
+            recorded = json.loads((cell / "cell.json").read_text())
+            self.assertEqual((recorded["exit_code"], recorded["version"], recorded["metrics_scraped"]),
+                             (0, "1.4.0-test", True))
+            self.assertEqual(recorded["wal_device"], "s3://bucket/oswal-bench/1-1/1-8-D/wal")
+            # A leaked value makes scrub refuse the results.
+            (cell / "leak.txt").write_text("fake-secret-value")
+            leaked = subprocess.run(["bash", str(SCRIPTS / "oswal-s3-bench-run.sh"), "scrub"], env=env,
+                                    capture_output=True, text=True, timeout=60)
+            self.assertNotEqual(leaked.returncode, 0)
+            self.assertFalse((root / "results").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/perf/test_tracesbench_summary.py b/tests/perf/test_tracesbench_summary.py
new file mode 100644
index 00000000000..cb7c4d8e06e
--- /dev/null
+++ b/tests/perf/test_tracesbench_summary.py
@@ -0,0 +1,54 @@
+# 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 importlib.util
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+SCRIPT = Path(__file__).parents[2] / '.github/scripts/tracesbench-summary.py'
+sys.path.insert(0, str(SCRIPT.parent))
+spec = importlib.util.spec_from_file_location('tracesbench_summary', SCRIPT)
+summary = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(summary)
+
+
+class LifecycleTest(unittest.TestCase):
+    def test_ingestion_layouts(self):
+        metrics = {'wall_seconds': 0.121723417, 'successful_requests': 17, 'failed_requests': 0}
+        cases = [
+            (target, {'ingest': metrics}, ['121.7 ms', '17', '0'])
+            for target in summary.TARGETS
+        ] + [
+            ('tempo', {'transport': {'ingest': metrics}}, ['121.7 ms', '17', '0']),
+            ('tempo', {'ingest': {'wall_seconds': 0, 'successful_requests': 0, 'failed_requests': 0},
+                       'transport': {'ingest': metrics}}, ['0 µs', '0', '0']),
+            ('tempo', {'ingest': {}, 'transport': {'ingest': metrics}}, ['—', '—', '—']),
+            ('tempo', {'transport': {}}, ['—', '—', '—']),
+        ] + [(target, {}, ['—', '—', '—']) for target in summary.TARGETS] + [
+            (target, {'transport': {'ingest': metrics}}, ['—', '—', '—'])
+            for target in ('greptimedb', 'victoriatraces')
+        ]
+        with tempfile.TemporaryDirectory() as tmp:
+            for target, load, expected in cases:
+                with self.subTest(target=target, load=load):
+                    text = summary.lifecycle({}, [{'target': target, 'load': load}], Path(tmp), [target])
+                    row = next(line for line in text.splitlines() if line.startswith('| ' + target + ' |'))
+                    cells = [cell.strip() for cell in row.split('|')[1:-1]]
+                    self.assertEqual(cells[4:7], expected)
+
+
+if __name__ == '__main__':
+    unittest.main()