diff --git a/Cargo.lock b/Cargo.lock
index 7382d160..759df72a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1089,7 +1089,7 @@ dependencies = [
 
 [[package]]
 name = "kite_sql"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "bumpalo",
  "chrono",
diff --git a/Cargo.toml b/Cargo.toml
index dc7d94e6..61fb17c9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,7 @@
 
 [package]
 name          = "kite_sql"
-version       = "0.4.0"
+version       = "0.4.1"
 edition       = "2021"
 build         = "build.rs"
 authors       = ["Kould <kould2333@gmail.com>", "Xwg <loloxwg@gmail.com>"]
diff --git a/README.md b/README.md
index 845033d3..12f731dc 100755
--- a/README.md
+++ b/README.md
@@ -29,31 +29,16 @@
 </p>
 
 ## Introduction
-**KiteSQL** is a lightweight embedded relational database for Rust, inspired by **MyRocks** and **SQLite** and fully written in Rust. It is designed to work not only as a SQL engine, but also as a Rust-native data API that can be embedded directly into applications without relying on external services or heavyweight infrastructure.
+**KiteSQL** is a lightweight embedded relational database written in Rust, inspired by **MyRocks** and **SQLite**. It runs inside your application with no external service: execute SQL directly, or use typed ORM models, migrations, and builder-style queries.
 
-KiteSQL supports direct SQL execution, typed ORM models, schema migration, and builder-style queries, so you can combine relational power with an API surface that feels natural in Rust. On native targets, KiteSQL ships with both RocksDB-backed and LMDB-backed persistent storage builders, plus an in-memory builder for tests and temporary workloads.
+- Most of the SQL 2016 syntax
+- All metadata and data stored in KV storage (RocksDB, LMDB, or in-memory)
+- Typed ORM with schema migration (`orm` feature), see [`src/orm/README.md`](src/orm/README.md)
+- WebAssembly and Python bindings
 
-## Key Features
-- A lightweight embedded SQL database fully rewritten in Rust
-- A Rust-native relational API alongside direct SQL execution
-- Typed ORM models with migrations and a lightweight typed query/mutation builder
-- Higher write speed with an application-friendly embedding model
-- All metadata and actual data in KV storage, with no intermediate stateful service layer
-- Extensible storage integration for customized workloads
-- Supports most of the SQL 2016 syntax
-- Ships a WebAssembly build for JavaScript runtimes
+👉 [More features](docs/features.md)
 
-#### 👉[check more](docs/features.md)
-
-## ORM
-KiteSQL includes a built-in ORM behind the `orm` feature flag. With `#[derive(Model)]`, you can define typed models and get tuple mapping, schema creation, migration support, projections, set queries, and builder-style query/mutation workflows.
-
-### Schema Migration
-Model changes are part of the normal workflow. KiteSQL ORM can help evolve tables for common schema updates, including adding, dropping, renaming, and changing columns, so many migrations can stay close to the Rust model definition instead of being managed as hand-written SQL.
-
-For the full ORM guide, see [`src/orm/README.md`](src/orm/README.md).
-
-## Examples
+## Example
 
 ```rust
 use kite_sql::db::DataBaseBuilder;
@@ -63,13 +48,10 @@ use kite_sql::Model;
 
 #[derive(Default, Debug, PartialEq, Model)]
 #[model(table = "users")]
-#[model(index(name = "users_name_age_idx", columns = "name, age"))]
 struct User {
     #[model(primary_key)]
     id: i32,
-    #[model(unique, varchar = 128)]
-    email: String,
-    #[model(rename = "user_name", varchar = 64)]
+    #[model(varchar = 64)]
     name: String,
     #[model(default = "18", index)]
     age: Option<i32>,
@@ -77,142 +59,88 @@ struct User {
 
 fn main() -> Result<(), DatabaseError> {
     let mut database = DataBaseBuilder::path("./data").build_rocksdb()?;
-    // Or: let database = DataBaseBuilder::path("./data").build_lmdb()?;
-
     database.migrate::<User>()?;
 
     database.insert_many([
-        User {
-            id: 1,
-            email: "alice@example.com".to_string(),
-            name: "Alice".to_string(),
-            age: Some(18),
-        },
-        User {
-            id: 2,
-            email: "bob@example.com".to_string(),
-            name: "Bob".to_string(),
-            age: Some(24),
-        },
+        User { id: 1, name: "Alice".to_string(), age: Some(18) },
+        User { id: 2, name: "Bob".to_string(), age: Some(24) },
     ])?;
 
-    database
-        .bind(|ctx| {
-            ctx.mutate::<User>()?
-                .filter(|e| e.column(User::id())?.eq(1))?
-                .update(|u| u.set_value(User::age(), Some(19)))
-        })?
-        .done()?;
-
-    database
-        .bind(|ctx| {
-            ctx.mutate::<User>()?
-                .filter(|e| e.column(User::id())?.eq(2))?
-                .delete()
-        })?
-        .done()?;
-
     let users = database
         .bind(|ctx| {
             ctx.from::<User>()?
                 .filter(|e| e.column(User::age())?.gte(18))?
                 .project_scalars((User::id(), User::name()))?
                 .order_by(User::name())?
-                .limit(10)?
                 .finish()
         })?
         .project_tuple::<(i32, String)>();
-
     for user in users {
         println!("{:?}", user?);
     }
 
-    // For ad-hoc or more SQL-shaped workloads, `run(...)` is still available.
-
+    // Plain SQL works too.
+    database.run("select count(*) from users")?.done()?;
     Ok(())
 }
 ```
 
+More: [hello_world](examples/hello_world.rs), [transaction](examples/transaction.rs).
+
 ## Storage Backends
-- `build_rocksdb()` opens a persistent RocksDB-backed database.
-- `build_lmdb()` opens a persistent LMDB-backed database.
-- `build_in_memory()` opens an in-memory database for tests, examples, and temporary workloads.
-- `build_optimistic()` is available on native targets when you specifically want optimistic transactions on top of RocksDB.
-- `Database::checkpoint(path)` creates a local consistent snapshot when the selected storage backend supports it.
-- Transaction isolation is documented in [`docs/transaction-isolation.md`](docs/transaction-isolation.md).
-- Cargo features:
-  - `rocksdb` is enabled by default
-  - `parser` is enabled by default and provides the SQL parser frontend
-  - `spill` optionally enables spill-backed external sorting and aggregation
-  - `spill` and `wasm` are mutually exclusive
-  - `lmdb` is optional
-  - `unsafe_txdb_checkpoint` enables experimental checkpoint support for RocksDB `TransactionDB`
-  - `cargo check --no-default-features --features lmdb` builds an LMDB-only native configuration
-
-On native targets, `LMDB` shines when reads dominate, while `RocksDB` is usually the stronger choice when writes do.
-Checkpoint support and feature-gating details are documented in [docs/features.md](docs/features.md).
-
-## Shell
-- Run `cargo run --bin kitesql-shell` to open the local interactive shell.
-- Use `cargo run --bin kitesql-shell -- --path ./tmp/kitesql-shell-data` to point to a custom RocksDB directory.
-- Use `cargo run --bin kitesql-shell -- -e "select current_timestamp"` for a quick one-shot check.
-- In interactive mode, end SQL statements with `;`; an empty line also executes the buffered statement.
-- Supported metacommands include `.help`, `.quit`, `.tables`, `.views`, and `.schema <name>`.
-
-👉**more examples**
-- [hello_world](examples/hello_world.rs)
-- [transaction](examples/transaction.rs)
-
-
-## WebAssembly
-- Build: `wasm-pack build --release --target nodejs` (outputs to `./pkg`; use `--target web` or `--target bundler` for browser/bundler setups).
-- Usage:
+| Builder | Storage |
+| --- | --- |
+| `build_rocksdb()` | RocksDB (default feature `rocksdb`), stronger for write-heavy workloads |
+| `build_lmdb()` | LMDB (feature `lmdb`), stronger for read-heavy workloads |
+| `build_in_memory()` | In-memory, for tests and temporary data |
+| `build_optimistic()` | RocksDB with optimistic transactions |
+
+Feature flags, checkpoints, and transaction isolation: [docs/features.md](docs/features.md), [docs/transaction-isolation.md](docs/transaction-isolation.md).
+
+## Shell, WebAssembly, Python
+
+### Shell
+```bash
+cargo run --bin kitesql-shell
+cargo run --bin kitesql-shell -- -e "select 1"
+```
+Type `.help` for metacommands.
+
+### WebAssembly
+```bash
+wasm-pack build --release --target nodejs
+```
 ```js
 import { WasmDatabase } from "./pkg/kite_sql.js";
 
 const db = new WasmDatabase();
 await db.ddl("create table demo(id int primary key, v int)");
-await db.execute("insert into demo values (1, 2), (2, 4)");
-const rows = db.run("select * from demo").rows();
-console.log(rows.map((r) => r.values.map((v) => v.Int32 ?? v)));
+console.log(db.run("select * from demo").rows());
 ```
-- In Node.js, provide a small `localStorage` shim if you enable statistics-related features (see `examples/wasm_index_usage.test.mjs`).
 
-## Python (PyO3)
-- Enable bindings with Cargo feature `python`.
-- Constructor is explicit: `Database(path, backend="rocksdb")`; use `backend="lmdb"` to open LMDB. In-memory usage is `Database.in_memory()`.
-- Minimal usage:
+### Python
+Requires the `python` feature.
 ```python
 import kite_sql
 
-db = kite_sql.Database.in_memory()
+db = kite_sql.Database.in_memory()  # or Database(path, backend="lmdb")
 db.execute("create table demo(id int primary key, v int)")
-db.execute("insert into demo values (1, 2), (2, 4)")
-for row in db.run("select * from demo"):
-    print(row["values"])
+print(list(db.run("select * from demo")))
 ```
 
 ## TPC-C
-Run `make tpcc` (or `cargo run -p tpcc --release`) to execute the benchmark against the default KiteSQL storage. Use `--backend rocksdb` or `--backend lmdb` to compare the two persistent backends directly.  
-Run `make tpcc-dual` to mirror every TPCC statement to an in-memory SQLite database alongside KiteSQL and assert the two engines return identical results; this target runs for 60 seconds (`--measure-time 60`). Use `cargo run -p tpcc --release -- --backend dual --measure-time <secs>` for a custom duration.
+`make tpcc` runs the benchmark (`--backend rocksdb|lmdb`); `make tpcc-dual` cross-checks every statement against SQLite.
 
-- i9-13900HX
-- 32.0 GB
-- KIOXIA-EXCERIA PLUS G3 SSD
-- Tips: TPC-C currently only supports single thread
+720-second single-thread run on an i9-13900HX (32 GB, KIOXIA EXCERIA PLUS G3), every backend pinned to the same P-core. Latencies are p90 in µs, including commit.
 
-Recent stable-run 720-second local comparison on the machine above:
-
-| Backend | TpmC | New-Order p90 (µs) | Payment p90 (µs) | Order-Status p90 (µs) | Delivery p90 (µs) | Stock-Level p90 (µs) |
+| Backend | TpmC | New-Order | Payment | Order-Status | Delivery | Stock-Level |
 | --- | ---: | ---: | ---: | ---: | ---: | ---: |
-| KiteSQL LMDB | 134909 | 360 | 94 | 147 | 503 | 466 |
-| KiteSQL RocksDB | 43866 | 521 | 289 | 269 | 11711 | 902 |
-| SQLite balanced | 49200 | 304 | 74 | 53 | 375 | 518 |
-| SQLite practical | 43385 | 368 | 74 | 44 | 482 | 386 |
-
-These rows are from the local run on `2026-09-27`; latencies are in microseconds and include transaction commit.
+| KiteSQL LMDB | 159616 | 315 | 81 | 44 | 435 | 332 |
+| KiteSQL RocksDB | 48035 | 459 | 258 | 200 | 11055 | 704 |
+| SQLite balanced | 67102 | 283 | 67 | 48 | 338 | 473 |
+| SQLite practical | 67153 | 336 | 66 | 41 | 427 | 339 |
 
-#### 👉[check more](tpcc/README.md)
+👉 [Details and how to reproduce](tpcc/README.md)
 
 ## Roadmap
 - Get [SQL 2016](https://github.com/KipData/KiteSQL/issues/130) mostly supported
diff --git a/scripts/run_tpcc_stable.py b/scripts/run_tpcc_stable.py
index 09cf2f0b..d5b24431 100755
--- a/scripts/run_tpcc_stable.py
+++ b/scripts/run_tpcc_stable.py
@@ -64,13 +64,27 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--measure-time", type=int, default=None)
     parser.add_argument("--tpcc-max-retry", type=int, default=5)
     parser.add_argument("--duplicate-retry", type=int, default=1)
-    parser.add_argument("--cool-temp-c", type=float, default=65.0)
+    parser.add_argument("--cool-temp-c", type=float, default=70.0)
     parser.add_argument("--idle-cpu-percent", type=float, default=20.0)
     parser.add_argument("--min-cooldown-sec", type=int, default=300)
     parser.add_argument("--stable-samples", type=int, default=3)
     parser.add_argument("--sample-interval-sec", type=float, default=10.0)
     parser.add_argument("--max-wait-sec", type=int, default=7200)
     parser.add_argument("--skip-health-check", action="store_true")
+    parser.add_argument(
+        "--cpu",
+        type=int,
+        help="Pin TPCC to this CPU. Defaults to the core with the highest max frequency.",
+    )
+    parser.add_argument(
+        "--variants",
+        help="Comma-separated subset of variants to run (default: all).",
+    )
+    parser.add_argument(
+        "--no-cpu-pin",
+        action="store_true",
+        help="Let the scheduler place TPCC on any CPU.",
+    )
     parser.add_argument(
         "--build",
         action="store_true",
@@ -79,6 +93,56 @@ def parse_args() -> argparse.Namespace:
     return parser.parse_args()
 
 
+def parse_cpu_list(text: str) -> list[int]:
+    cpus: list[int] = []
+    for part in text.strip().split(","):
+        if not part:
+            continue
+        if "-" in part:
+            start, end = part.split("-", 1)
+            cpus.extend(range(int(start), int(end) + 1))
+        else:
+            cpus.append(int(part))
+    return cpus
+
+
+def read_cpu_list(path: str) -> list[int]:
+    try:
+        return parse_cpu_list(Path(path).read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return []
+
+
+def cpu_max_freq(cpu: int) -> int:
+    try:
+        return int(
+            Path(f"/sys/devices/system/cpu/cpu{cpu}/cpufreq/cpuinfo_max_freq").read_text(
+                encoding="utf-8"
+            )
+        )
+    except (OSError, ValueError):
+        return 0
+
+
+def default_pinned_cpu() -> int | None:
+    cpus = read_cpu_list("/sys/devices/system/cpu/online")
+    if not cpus:
+        return None
+    cpu0_siblings = set(
+        read_cpu_list("/sys/devices/system/cpu/cpu0/topology/thread_siblings_list")
+    ) or {0}
+    candidates = [cpu for cpu in cpus if cpu not in cpu0_siblings] or cpus
+    return max(candidates, key=lambda cpu: (cpu_max_freq(cpu), -cpu))
+
+
+def resolve_pinned_cpu(args: argparse.Namespace) -> int | None:
+    if args.no_cpu_pin:
+        return None
+    if args.cpu is not None:
+        return args.cpu
+    return default_pinned_cpu()
+
+
 def read_proc_stat() -> tuple[int, int] | None:
     try:
         line = Path("/proc/stat").read_text(encoding="utf-8").splitlines()[0]
@@ -371,8 +435,20 @@ def run_variant(
         append_line(log_file, f"$ {quote_cmd(cmd)}")
         append_line(log_file)
 
+        if args.pinned_cpu is not None:
+            append_line(log_file, f"[runner] pinned to cpu {args.pinned_cpu}")
+        pinned_cpu = args.pinned_cpu
+        preexec = (
+            (lambda: os.sched_setaffinity(0, {pinned_cpu})) if pinned_cpu is not None else None
+        )
         with log_file.open("a", encoding="utf-8", errors="replace") as file:
-            proc = subprocess.run(cmd, cwd=ROOT_DIR, stdout=file, stderr=subprocess.STDOUT)
+            proc = subprocess.run(
+                cmd,
+                cwd=ROOT_DIR,
+                stdout=file,
+                stderr=subprocess.STDOUT,
+                preexec_fn=preexec,
+            )
 
         if proc.returncode == 0:
             break
@@ -433,6 +509,11 @@ def write_summary_header(args: argparse.Namespace, summary_file: Path) -> None:
                 f"- Duplicate-key retries per variant: {args.duplicate_retry}",
                 f"- Measure time: {measure}",
                 f"- Binary: `{args.binary}`",
+                (
+                    f"- CPU pin: cpu {args.pinned_cpu}"
+                    if args.pinned_cpu is not None
+                    else "- CPU pin: none (scheduler placement)"
+                ),
                 (
                     "- Machine gates: "
                     f"temp<={args.cool_temp_c:.1f}C, "
@@ -455,6 +536,7 @@ def main() -> int:
     args = parse_args()
     args.binary = args.binary.resolve()
     args.tmp_dir = args.tmp_dir.resolve()
+    args.pinned_cpu = resolve_pinned_cpu(args)
     result_dir = (
         args.result_dir.resolve()
         if args.result_dir is not None
@@ -475,11 +557,20 @@ def main() -> int:
         )
         return 1
 
+    variants = VARIANTS
+    if args.variants:
+        names = {name.strip() for name in args.variants.split(",") if name.strip()}
+        unknown = sorted(names - {variant.name for variant in VARIANTS})
+        if unknown:
+            print(f"unknown variants: {', '.join(unknown)}", file=sys.stderr)
+            return 2
+        variants = [variant for variant in VARIANTS if variant.name in names]
+
     write_summary_header(args, summary_file)
 
     previous_finished_at: float | None = None
     try:
-        for variant in VARIANTS:
+        for variant in variants:
             previous_finished_at = run_variant(
                 args, variant, log_dir, summary_file, previous_finished_at
             )
diff --git a/src/binder/parser.rs b/src/binder/parser.rs
index b60da60a..610c33ee 100644
--- a/src/binder/parser.rs
+++ b/src/binder/parser.rs
@@ -226,7 +226,7 @@ impl<S: Storage> Database<S> {
                 let (plan, arena) = self
                     .state
                     .build_plan(&[], tx, |binder, arena| binder.bind(&statement, arena))?;
-                self.state.execute(tx, plan, arena)
+                self.state.execute(tx, plan.into(), arena)
             })() {
                 Ok(result) => result,
                 Err(err) => {
diff --git a/src/db.rs b/src/db.rs
index ff00d06e..24c10588 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -42,7 +42,7 @@ use crate::optimizer::rule::normalization::NormalizationRuleImpl;
 #[cfg(feature = "orm")]
 use crate::orm::FromQueryRow;
 use crate::planner::operator::Operator;
-use crate::planner::{LogicalPlan, MetaArena, PlanArena, TableArenaCell};
+use crate::planner::{LogicalPlan, MetaArena, PlanArena, PlanInput, PlanKeeper, TableArenaCell};
 #[cfg(all(not(target_arch = "wasm32"), feature = "lmdb"))]
 use crate::storage::lmdb::{LmdbConfig, LmdbStorage};
 use crate::storage::memory::MemoryStorage;
@@ -81,12 +81,12 @@ pub(crate) trait BindSource<'a> {
 
     type Storage: Storage;
 
-    fn execute<A: MetaArena + 'a, F>(self, build: F) -> Result<Self::Iter, DatabaseError>
+    fn execute<P: Into<PlanInput<'a>>, A: MetaArena + 'a, F>(
+        self,
+        build: F,
+    ) -> Result<Self::Iter, DatabaseError>
     where
-        F: FnOnce(
-            &'a State<Self::Storage>,
-            &Self::Transaction,
-        ) -> Result<(LogicalPlan, A), DatabaseError>;
+        F: FnOnce(&'a State<Self::Storage>, &Self::Transaction) -> Result<(P, A), DatabaseError>;
 
     #[cfg(feature = "orm")]
     fn explain<A, F>(self, params: A, build: F) -> Result<String, DatabaseError>
@@ -431,6 +431,27 @@ fn optimizer_pipeline() -> HepOptimizerPipeline {
         .build()
 }
 
+fn statement_stamp<T: Transaction>(
+    transaction: &mut T,
+    plan: &LogicalPlan,
+) -> Result<u64, DatabaseError> {
+    let scans_and_writes = match &plan.operator {
+        Operator::Insert(_) => !matches!(plan.childrens.only().operator, Operator::Values(_)),
+        Operator::Update(_)
+        | Operator::AddColumn(_)
+        | Operator::ChangeColumn(_)
+        | Operator::DropColumn(_)
+        | Operator::CreateIndex(_)
+        | Operator::Analyze(_) => true,
+        _ => false,
+    };
+    if scans_and_writes {
+        transaction.next_statement_stamp()
+    } else {
+        Ok(0)
+    }
+}
+
 pub(crate) struct State<S> {
     scala_functions: ScalaFunctions,
     table_functions: TableFunctions,
@@ -551,6 +572,7 @@ impl<S: Storage> State<S> {
                 op.histogram_buckets = self.histogram_buckets;
             }
         }
+        plan.populate_output_schema_recursive(&mut arena);
 
         Ok((plan, arena))
     }
@@ -558,14 +580,17 @@ impl<S: Storage> State<S> {
     pub(crate) fn execute<'a, 'txn, A: MetaArena + 'a>(
         &'a self,
         transaction: &'a mut S::TransactionType<'txn>,
-        mut plan: LogicalPlan,
+        plan: PlanInput<'a>,
         mut plan_arena: A,
     ) -> Result<(Schema, A, Executor<'a, S::TransactionType<'txn>>), DatabaseError>
     where
         S: 'txn,
     {
-        let schema = plan.take_schema(&mut plan_arena);
+        let keeper = PlanKeeper::new(plan);
+        let plan = keeper.plan();
+        let schema = plan.read_schema().clone();
         let mut arena = ExecArena::new();
+        arena.set_statement_stamp(statement_stamp(transaction, plan)?);
         let read_context = ExecutionContext::new(
             &self.table_cache,
             &self.view_cache,
@@ -574,7 +599,7 @@ impl<S: Storage> State<S> {
             &self.table_functions,
         );
         let root = build_write(&mut arena, &mut plan_arena, plan, read_context, transaction);
-        let executor = Executor::new(arena, root);
+        let executor = Executor::new(arena, root, keeper);
 
         Ok((schema, plan_arena, executor))
     }
@@ -636,8 +661,12 @@ impl<S: Storage> State<S> {
             }
         }
 
-        let schema = plan.take_schema(&mut plan_arena);
+        plan.populate_output_schema_recursive(&mut plan_arena);
+        let keeper = PlanKeeper::new(PlanInput::Owned(plan));
+        let plan = keeper.plan();
+        let schema = plan.read_schema().clone();
         let mut arena = ExecArena::new();
+        arena.set_statement_stamp(statement_stamp(transaction, plan)?);
         let cache = ExecutionContext::new(
             table_cache,
             view_cache,
@@ -646,7 +675,7 @@ impl<S: Storage> State<S> {
             table_functions,
         );
         let root = build_write(&mut arena, &mut plan_arena, plan, cache, transaction);
-        let executor = Executor::new(arena, root);
+        let executor = Executor::new(arena, root, keeper);
 
         Ok((schema, plan_arena, executor))
     }
@@ -871,9 +900,12 @@ impl<'a, S: Storage> BindSource<'a> for &'a Database<S> {
 
     type Storage = S;
 
-    fn execute<A: MetaArena + 'a, F>(self, build: F) -> Result<Self::Iter, DatabaseError>
+    fn execute<P: Into<PlanInput<'a>>, A: MetaArena + 'a, F>(
+        self,
+        build: F,
+    ) -> Result<Self::Iter, DatabaseError>
     where
-        F: FnOnce(&'a State<S>, &Self::Transaction) -> Result<(LogicalPlan, A), DatabaseError>,
+        F: FnOnce(&'a State<S>, &Self::Transaction) -> Result<(P, A), DatabaseError>,
     {
         let transaction = Box::into_raw(Box::new(
             self.storage
@@ -883,7 +915,7 @@ impl<'a, S: Storage> BindSource<'a> for &'a Database<S> {
             let transaction = unsafe { &mut *transaction };
             transaction.begin_statement_scope()?;
             let (plan, arena) = build(&self.state, transaction)?;
-            self.state.execute(transaction, plan, arena)
+            self.state.execute(transaction, plan.into(), arena)
         })();
         let (schema, arena, executor) = match result {
             Ok(result) => result,
@@ -1089,16 +1121,19 @@ impl<'a, 'txn, S: Storage> BindSource<'a> for &'a mut DBTransaction<'txn, S> {
 
     type Storage = S;
 
-    fn execute<A: MetaArena + 'a, F>(self, build: F) -> Result<Self::Iter, DatabaseError>
+    fn execute<P: Into<PlanInput<'a>>, A: MetaArena + 'a, F>(
+        self,
+        build: F,
+    ) -> Result<Self::Iter, DatabaseError>
     where
-        F: FnOnce(&'a State<S>, &Self::Transaction) -> Result<(LogicalPlan, A), DatabaseError>,
+        F: FnOnce(&'a State<S>, &Self::Transaction) -> Result<(P, A), DatabaseError>,
     {
         self.inner.begin_statement_scope()?;
         let (plan, arena) = build(self.state, &self.inner)?;
         let transaction = std::ptr::from_mut(&mut self.inner);
         let (schema, arena, executor) =
             self.state
-                .execute(unsafe { &mut *transaction }, plan, arena)?;
+                .execute(unsafe { &mut *transaction }, plan.into(), arena)?;
         Ok(TransactionIter::new(
             schema,
             Box::new(arena) as Box<dyn MetaArena + 'a>,
@@ -1774,7 +1809,7 @@ pub(crate) mod test {
             let plan = row.values[0].utf8().unwrap();
             assert_eq!(
                 plan,
-                "Projection [t1.a, t1.b, t1.a, t1.b, 9] [Project => (Sort Option: Follow)] LeftOuter Join Where (t1.a > 0) [NestLoopJoin => (Sort Option: None)] Projection [t1.a, t1.b] [Project => (Sort Option: Follow)] Filter (t1.b > 0), Is Having: false [Filter => (Sort Option: Follow)] TableScan t1 -> [t1.a, t1.b] [SeqScan => (Sort Option: None)] Projection [t1.a, t1.b] [Project => (Sort Option: Follow)] TableScan t1 -> [t1.a, t1.b] [IndexScan By pk_index => (1, +inf) => (Sort Option: OrderBy: (t1.a Asc Nulls Last) ignore_prefix_len: 0)]"
+                "Projection [t1.a, t1.b, t1.a, t1.b, 9] [Project => (Sort Option: Follow)] LeftOuter Join Where (t1.a > 0) [NestLoopJoin => (Sort Option: None)] Projection [t1.a, t1.b] [Project => (Sort Option: Follow)] Filter (t1.b > 0), Is Having: false [Filter => (Sort Option: Follow)] TableScan t1 -> [t1.a, t1.b] [SeqScan => (Sort Option: None)] Projection [t1.a, t1.b] [Project => (Sort Option: Follow)] TableScan t1 -> [t1.a, t1.b] [IndexScan By pk_index => ($3, +inf) => (Sort Option: OrderBy: (t1.a Asc Nulls Last) ignore_prefix_len: 0)]"
             );
         }
 
diff --git a/src/db/prepared.rs b/src/db/prepared.rs
index b217c580..4a4d0981 100644
--- a/src/db/prepared.rs
+++ b/src/db/prepared.rs
@@ -1,100 +1,11 @@
 use super::*;
-use crate::expression::range_detacher::{IndexRangeColumn, RangeDetacher};
-use crate::planner::operator::table_scan::TableScanOperator;
-use crate::planner::operator::visitor_mut::OperatorVisitorMut;
+#[cfg(test)]
 use crate::planner::operator::{PhysicalOption, PlanImpl, SortOption};
-use crate::planner::{ExprRef, MetaArena, ParamArena};
+use crate::planner::{ExprRef, ParamArena, PlanInput};
+#[cfg(test)]
 use crate::types::index::IndexLookup;
 use crate::types::LogicalType;
 
-struct ParameterBinder<'a> {
-    params: &'a [(usize, DataValue)],
-}
-
-impl ParameterBinder<'_> {
-    fn bind_index_infos(
-        &self,
-        index_infos: &mut [crate::types::index::IndexInfo],
-    ) -> Result<(), DatabaseError> {
-        for info in index_infos {
-            if let Some(lookup) = &mut info.lookup {
-                lookup.bind_parameters(self.params)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl<'plan> OperatorVisitorMut<'plan> for ParameterBinder<'_> {
-    fn visit_table_scan(
-        &mut self,
-        TableScanOperator { index_infos, .. }: &'plan mut TableScanOperator,
-    ) -> Result<(), DatabaseError> {
-        self.bind_index_infos(index_infos)
-    }
-
-    fn visit_physical_option(
-        &mut self,
-        physical_option: &'plan mut PhysicalOption,
-    ) -> Result<(), DatabaseError> {
-        if let PlanImpl::IndexScan(info) = &mut physical_option.plan {
-            self.bind_index_infos(std::slice::from_mut(info))?;
-        }
-        Ok(())
-    }
-}
-
-/// Extend the selected static index range using its bound residual predicate.
-struct SpecializeIndexRange<'a, A: MetaArena + ?Sized> {
-    arena: &'a mut A,
-}
-
-impl<'plan, A: MetaArena + ?Sized> OperatorVisitorMut<'plan> for SpecializeIndexRange<'_, A> {
-    fn visit_operator(
-        &mut self,
-        operator: &'plan mut Operator,
-        physical_option: Option<&'plan mut PhysicalOption>,
-    ) -> Result<(), DatabaseError> {
-        let Operator::TableScan(scan) = operator else {
-            return Ok(());
-        };
-        let Some(option) = physical_option else {
-            return Ok(());
-        };
-        let PlanImpl::IndexScan(index) = &mut option.plan else {
-            return Ok(());
-        };
-        let (Some(params_predicate), Some(IndexLookup::Static(original))) =
-            (index.residual_predicate, &index.lookup)
-        else {
-            return Ok(());
-        };
-        let SortOption::OrderBy {
-            ignore_prefix_len, ..
-        } = &index.sort_option
-        else {
-            return Ok(());
-        };
-        let Some(range) = RangeDetacher::<IndexRangeColumn, A>::specialize_range(
-            index.meta,
-            original,
-            params_predicate,
-            *ignore_prefix_len,
-            self.arena,
-        )?
-        else {
-            return Ok(());
-        };
-        index.lookup = Some(IndexLookup::Static(range));
-        for candidate in &mut scan.index_infos {
-            if candidate.meta == index.meta {
-                candidate.lookup = index.lookup.clone();
-            }
-        }
-        Ok(())
-    }
-}
-
 /// A bound and optimized reusable plan.
 #[derive(Clone)]
 pub struct PreparedPlan<'db> {
@@ -107,12 +18,8 @@ impl<'db> PreparedPlan<'db> {
     pub(crate) fn bind_parameters(
         &self,
         params: &[(usize, DataValue)],
-    ) -> Result<(LogicalPlan, ParamArena<'_>), DatabaseError> {
-        let mut arena = ParamArena::new(&self.arena, &self.parameter_expressions, params)?;
-        let mut plan = self.plan.clone();
-        ParameterBinder { params }.visit_plan(&mut plan)?;
-        SpecializeIndexRange { arena: &mut arena }.visit_plan(&mut plan)?;
-        Ok((plan, arena))
+    ) -> Result<ParamArena<'_>, DatabaseError> {
+        ParamArena::new(&self.arena, &self.parameter_expressions, params)
     }
 }
 
@@ -128,8 +35,10 @@ impl<S: Storage> Database<S> {
                 "plan belongs to another database".into(),
             ));
         }
-        let (plan, arena) = prepared.bind_parameters(params.as_ref())?;
-        BindSource::execute(self, |_, _| Ok((plan, arena)))
+        let arena = prepared.bind_parameters(params.as_ref())?;
+        BindSource::execute(self, |_, _| {
+            Ok((PlanInput::Borrowed(&prepared.plan), arena))
+        })
     }
 
     /// Prepare SQL with explicit positional parameter types.
@@ -160,8 +69,10 @@ impl<'db, S: Storage> DBTransaction<'db, S> {
                 "plan belongs to another database".into(),
             ));
         }
-        let (plan, arena) = prepared.bind_parameters(params.as_ref())?;
-        BindSource::execute(self, |_, _| Ok((plan, arena)))
+        let arena = prepared.bind_parameters(params.as_ref())?;
+        BindSource::execute(self, |_, _| {
+            Ok((PlanInput::Borrowed(&prepared.plan), arena))
+        })
     }
 
     #[cfg(feature = "parser")]
@@ -211,8 +122,7 @@ impl<S: Storage> State<S> {
             &mut PlanArena<'a>,
         ) -> Result<LogicalPlan, DatabaseError>,
     {
-        let (mut plan, mut arena) = self.build_plan(params, transaction, build)?;
-        plan.output_schema(&mut arena);
+        let (plan, mut arena) = self.build_plan(params, transaction, build)?;
         let parameter_expressions = arena.parameter_expressions();
         Ok(PreparedPlan {
             plan,
@@ -387,7 +297,7 @@ mod tests {
                 having: false,
                 is_optimized: true,
             };
-            let mut plan = LogicalPlan::new(
+            let plan = LogicalPlan::new(
                 Operator::Filter(filter.clone()),
                 Childrens::Only(Box::new(scan)),
             );
@@ -395,20 +305,50 @@ mod tests {
             if should_change {
                 expected_index.lookup = Some(IndexLookup::Static(expected.clone()));
             }
-            SpecializeIndexRange { arena: &mut arena }.visit_plan(&mut plan)?;
-            assert_eq!(plan.operator, Operator::Filter(filter));
-            let child = plan.childrens.pop_only();
-            let option = child.physical_option.unwrap();
-            assert_eq!(
-                option.plan,
-                PlanImpl::IndexScan(Box::new(expected_index.clone()))
-            );
-            assert_eq!(option.sort_option(), &sort);
-            let Operator::TableScan(scan) = child.operator else {
+            let Childrens::Only(scan) = plan.childrens.as_ref() else {
                 panic!("expected scan")
             };
-            assert_eq!(scan.index_infos[0], expected_index);
-            assert_eq!(scan.index_infos[1], other);
+            let Operator::TableScan(scan_op) = &scan.operator else {
+                panic!("expected table scan")
+            };
+            let Some(PhysicalOption {
+                plan: PlanImpl::IndexScan(info),
+                ..
+            }) = &scan.physical_option
+            else {
+                panic!("expected index scan")
+            };
+            if !matches!(info.lookup, Some(IndexLookup::Static(_))) {
+                continue;
+            }
+            let mut execution_arena = crate::execution::ExecArena::<
+                <crate::storage::memory::MemoryStorage as Storage>::TransactionType<'_>,
+            >::new();
+            let executor = crate::execution::dql::index_scan::IndexScan::new(
+                scan_op,
+                info,
+                info.lookup.as_ref().expect("lookup"),
+            );
+            let ranges = executor.ranges(&mut execution_arena, &mut arena)?;
+            let expected_range = match &expected_index.lookup {
+                Some(IndexLookup::Static(range)) => range,
+                _ => unreachable!(),
+            };
+            if let IndexLookup::Static(original) = index.lookup.as_ref().unwrap() {
+                let want = if should_change {
+                    expected_range
+                } else {
+                    original
+                };
+                let mut ranges = ranges;
+                assert_eq!(ranges.next(), Some(want));
+            }
+            assert_eq!(
+                scan.physical_option.as_ref().unwrap().plan,
+                PlanImpl::IndexScan(Box::new(index.clone()))
+            );
+            assert_eq!(scan.physical_option.as_ref().unwrap().sort_option(), &sort);
+            assert_eq!(plan.operator, Operator::Filter(filter));
             assert_eq!(
                 arena.expression(boundary),
                 &ScalarExpression::Binary {
@@ -588,13 +528,39 @@ mod tests {
                 (3, LogicalType::Integer),
             ],
         )?;
-        let (bound, _) = plan.bind_parameters(&[
+        let mut bound_arena = plan.bind_parameters(&[
             (1, DataValue::Int32(2)),
             (2, DataValue::Int32(5)),
             (3, DataValue::Int32(22)),
         ])?;
+        fn find_scan(plan: &LogicalPlan) -> Option<&LogicalPlan> {
+            matches!(plan.operator, Operator::TableScan(_))
+                .then_some(plan)
+                .or_else(|| plan.childrens.iter().find_map(find_scan))
+        }
+        let scan = find_scan(&plan.plan).expect("table scan");
+        let Operator::TableScan(scan_op) = &scan.operator else {
+            unreachable!()
+        };
+        let Some(PhysicalOption {
+            plan: PlanImpl::IndexScan(info),
+            ..
+        }) = &scan.physical_option
+        else {
+            panic!("expected index scan")
+        };
+        let mut execution_arena = crate::execution::ExecArena::<
+            <crate::storage::memory::MemoryStorage as Storage>::TransactionType<'_>,
+        >::new();
+        let ranges = crate::execution::dql::index_scan::IndexScan::new(
+            scan_op,
+            info,
+            info.lookup.as_ref().expect("lookup"),
+        )
+        .ranges(&mut execution_arena, &mut bound_arena)?;
+        let mut ranges = ranges;
         assert_eq!(
-            index_range(&bound),
+            ranges.next(),
             Some(&Range::Scope {
                 min: Bound::Included(DataValue::Tuple(vec![
                     DataValue::Int32(2),
diff --git a/src/execution/ddl/add_column.rs b/src/execution/ddl/add_column.rs
index 758025ee..3417db45 100644
--- a/src/execution/ddl/add_column.rs
+++ b/src/execution/ddl/add_column.rs
@@ -22,50 +22,38 @@ use crate::planner::operator::alter_table::add_column::AddColumnOperator;
 use crate::planner::MetaArena;
 use crate::storage::Transaction;
 use crate::types::index::{Index, IndexType};
-use crate::types::tuple_builder::TupleBuilder;
 use crate::types::value::DataValue;
 
-pub struct AddColumn {
-    op: Option<AddColumnOperator>,
+pub struct AddColumn<'a> {
+    op: &'a AddColumnOperator,
 }
 
-impl From<AddColumnOperator> for AddColumn {
-    fn from(op: AddColumnOperator) -> Self {
-        Self { op: Some(op) }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for AddColumn {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for AddColumn<'a> {
+    type Input = &'a AddColumnOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::AddColumn(executor))
+        arena.push(ExecNode::AddColumn(AddColumn { op }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for AddColumn {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for AddColumn<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
         let table_cache = arena.table_cache();
-        let Some(AddColumnOperator {
+        let AddColumnOperator {
             table_name,
             column,
             if_not_exists,
-        }) = self.op.take()
-        else {
-            arena.finish();
-            return Ok(());
-        };
+        } = self.op;
 
         let (old_schema, pk_ty, column_exists) = {
             let table_catalog = arena
@@ -79,9 +67,8 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for AddColumn {
             )
         };
         if column_exists {
-            if if_not_exists {
-                arena.produce_tuple(TupleBuilder::build_result("1".to_string()));
-                arena.resume();
+            if *if_not_exists {
+                arena.finish();
                 return Ok(());
             }
             return Err(DatabaseError::DuplicateColumn(column.name().to_string()));
@@ -94,9 +81,9 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for AddColumn {
             let (table, col_id) = transaction.add_column(
                 table_codec,
                 plan_arena,
-                &table_name,
-                &column,
-                if_not_exists,
+                table_name,
+                column,
+                *if_not_exists,
             )?;
             let unique_meta = if column.desc().is_unique() {
                 table
@@ -116,7 +103,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for AddColumn {
         rewrite_table_in_batches(
             transaction,
             table_codec,
-            &table_name,
+            table_name,
             &pk_ty,
             old_schema.len(),
             || {
@@ -149,14 +136,13 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for AddColumn {
                         std::slice::from_ref(value),
                         IndexType::Unique,
                     );
-                    transaction.add_index(table_codec, &table_name, index, tuple_id)?;
+                    transaction.add_index(table_codec, table_name, index, tuple_id)?;
                 }
                 Ok(())
             },
         )?;
 
-        arena.produce_tuple(TupleBuilder::build_result("1".to_string()));
-        arena.resume();
+        arena.finish();
         Ok(())
     }
 }
diff --git a/src/execution/ddl/change_column.rs b/src/execution/ddl/change_column.rs
index 350024f7..8bca2787 100644
--- a/src/execution/ddl/change_column.rs
+++ b/src/execution/ddl/change_column.rs
@@ -21,52 +21,40 @@ use crate::iter_ext::Itertools;
 use crate::planner::operator::alter_table::change_column::{ChangeColumnOperator, NotNullChange};
 use crate::planner::MetaArena;
 use crate::storage::Transaction;
-use crate::types::tuple_builder::TupleBuilder;
 
-pub struct ChangeColumn {
-    op: Option<ChangeColumnOperator>,
+pub struct ChangeColumn<'a> {
+    op: &'a ChangeColumnOperator,
 }
 
-impl From<ChangeColumnOperator> for ChangeColumn {
-    fn from(op: ChangeColumnOperator) -> Self {
-        Self { op: Some(op) }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for ChangeColumn {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for ChangeColumn<'a> {
+    type Input = &'a ChangeColumnOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::ChangeColumn(executor))
+        arena.push(ExecNode::ChangeColumn(ChangeColumn { op }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ChangeColumn {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ChangeColumn<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
         let table_cache = arena.table_cache();
-        let Some(ChangeColumnOperator {
+        let ChangeColumnOperator {
             table_name,
             old_column_name,
             new_column_name,
             data_type,
             default_change,
             not_null_change,
-        }) = self.op.take()
-        else {
-            arena.finish();
-            return Ok(());
-        };
+        } = self.op;
 
         let (old_schema, pk_ty, column_index, old_column_type, old_column_id, affected_index_name) = {
             let table_catalog = arena
@@ -98,7 +86,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ChangeColumn {
                 affected_index_name,
             )
         };
-        let needs_data_rewrite = old_column_type != data_type;
+        let needs_data_rewrite = &old_column_type != data_type;
         let needs_not_null_validation = matches!(not_null_change, NotNullChange::Set);
 
         if needs_data_rewrite {
@@ -121,7 +109,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ChangeColumn {
             rewrite_table_in_batches(
                 transaction,
                 table_codec,
-                &table_name,
+                table_name,
                 &pk_ty,
                 old_schema.len(),
                 || {
@@ -156,7 +144,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ChangeColumn {
             visit_table_in_batches(
                 transaction,
                 table_codec,
-                &table_name,
+                table_name,
                 &pk_ty,
                 old_schema.len(),
                 || {
@@ -178,19 +166,18 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ChangeColumn {
             let table = transaction.change_column(
                 table_codec,
                 plan_arena,
-                &table_name,
-                &old_column_name,
-                &new_column_name,
-                &data_type,
-                &default_change,
-                &not_null_change,
+                table_name,
+                old_column_name,
+                new_column_name,
+                data_type,
+                default_change,
+                not_null_change,
             )?;
             DDLApply::upsert_table(table, true)
         };
         arena.push_ddl_apply(apply);
 
-        arena.produce_tuple(TupleBuilder::build_result(format!("{table_name}")));
-        arena.resume();
+        arena.finish();
         Ok(())
     }
 }
diff --git a/src/execution/ddl/create_index.rs b/src/execution/ddl/create_index.rs
index 9ad43081..1c2ed39a 100644
--- a/src/execution/ddl/create_index.rs
+++ b/src/execution/ddl/create_index.rs
@@ -24,73 +24,53 @@ use crate::planner::MetaArena;
 use crate::storage::Transaction;
 use crate::types::index::Index;
 use crate::types::tuple::Schema;
-use crate::types::tuple_builder::TupleBuilder;
 use crate::types::ColumnId;
 
-pub struct CreateIndex {
-    op: Option<CreateIndexOperator>,
+pub struct CreateIndex<'a> {
+    op: &'a CreateIndexOperator,
     input_schema: Schema,
-    input_plan: LogicalPlan,
     input: ExecId,
 }
 
-impl From<(CreateIndexOperator, LogicalPlan)> for CreateIndex {
-    fn from((op, input): (CreateIndexOperator, LogicalPlan)) -> Self {
-        Self {
-            op: Some(op),
-            input_schema: Default::default(),
-            input_plan: input,
-            input: 0,
-        }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for CreateIndex {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for CreateIndex<'a> {
+    type Input = (&'a CreateIndexOperator, &'a LogicalPlan);
 
     fn into_executor(
-        input: Self::Input,
+        (op, input_plan): Self::Input,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
         cache: ExecutionContext<'_>,
         transaction: &T,
     ) -> ExecId {
-        let mut executor = input;
-        executor.input_schema = executor.input_plan.take_schema(plan_arena);
-        executor.input = build_read(
-            arena,
-            plan_arena,
-            executor.input_plan.take(),
-            cache,
-            transaction,
-        );
-        arena.push(ExecNode::CreateIndex(executor))
+        let input_schema = input_plan.read_schema().clone();
+        let input = build_read(arena, plan_arena, input_plan, cache, transaction);
+        arena.push(ExecNode::CreateIndex(CreateIndex {
+            op,
+            input_schema,
+            input,
+        }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CreateIndex {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CreateIndex<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        let Some(CreateIndexOperator {
+        let CreateIndexOperator {
             table_name,
             index_name,
             columns,
             if_not_exists,
             ty,
-        }) = self.op.take()
-        else {
-            arena.finish();
-            return Ok(());
-        };
+        } = self.op;
 
-        if if_not_exists
-            && arena.table_cache().get(&table_name).is_some_and(|table| {
+        if *if_not_exists
+            && arena.table_cache().get(table_name).is_some_and(|table| {
                 table
                     .indexes()
-                    .any(|index| plan_arena.index(*index).name == index_name)
+                    .any(|index| plan_arena.index(*index).name == *index_name)
             })
         {
             arena.finish();
@@ -98,7 +78,8 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CreateIndex {
         }
 
         let (column_ids, column_exprs): (Vec<ColumnId>, Vec<ScalarExpression>) = columns
-            .into_iter()
+            .iter()
+            .copied()
             .filter_map(|column| {
                 plan_arena.column(column).id().and_then(|id| {
                     self.input_schema
@@ -113,10 +94,10 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CreateIndex {
             let (table, index_id) = transaction.add_index_meta(
                 table_codec,
                 plan_arena,
-                &table_name,
-                index_name,
+                table_name,
+                index_name.clone(),
                 column_ids,
-                ty,
+                *ty,
             )?;
             arena.push_ddl_apply(DDLApply::upsert_table(table, false));
             Ok(index_id)
@@ -124,7 +105,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CreateIndex {
         let index_id = match index_id_result {
             Ok(index_id) => index_id,
             Err(DatabaseError::DuplicateIndex(index_name)) => {
-                if if_not_exists {
+                if *if_not_exists {
                     arena.finish();
                     return Ok(());
                 } else {
@@ -142,13 +123,12 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CreateIndex {
             {
                 let mut state = arena.local_state(plan_arena);
                 let (values, transaction, table_codec) = state.index_values_transaction_codec_mut();
-                let index = Index::new(index_id, values, ty);
+                let index = Index::new(index_id, values, *ty);
                 transaction.add_index(table_codec, table_name.as_ref(), index, &tuple_pk)?;
             }
         }
 
-        arena.produce_tuple(TupleBuilder::build_result("1".to_string()));
-        arena.resume();
+        arena.finish();
         Ok(())
     }
 }
diff --git a/src/execution/ddl/create_table.rs b/src/execution/ddl/create_table.rs
index b9cab332..7633693c 100644
--- a/src/execution/ddl/create_table.rs
+++ b/src/execution/ddl/create_table.rs
@@ -19,63 +19,50 @@ use crate::execution::{
 use crate::planner::operator::create_table::CreateTableOperator;
 use crate::planner::MetaArena;
 use crate::storage::Transaction;
-use crate::types::tuple_builder::TupleBuilder;
 
-pub struct CreateTable {
-    op: Option<CreateTableOperator>,
+pub struct CreateTable<'a> {
+    op: &'a CreateTableOperator,
 }
 
-impl From<CreateTableOperator> for CreateTable {
-    fn from(op: CreateTableOperator) -> Self {
-        CreateTable { op: Some(op) }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for CreateTable {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for CreateTable<'a> {
+    type Input = &'a CreateTableOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::CreateTable(executor))
+        arena.push(ExecNode::CreateTable(CreateTable { op }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CreateTable {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CreateTable<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        let Some(CreateTableOperator {
+        let CreateTableOperator {
             table_name,
             columns,
             if_not_exists,
-        }) = self.op.take()
-        else {
-            arena.finish();
-            return Ok(());
-        };
+        } = self.op;
 
         let (transaction, table_codec) = arena.transaction_codec_mut();
         let table = transaction.create_table(
             table_codec,
             plan_arena,
             table_name.clone(),
-            columns,
-            if_not_exists,
+            columns.clone(),
+            *if_not_exists,
         )?;
         if let Some(table) = table {
             arena.push_ddl_apply(DDLApply::upsert_table(table, false));
         }
 
-        arena.produce_tuple(TupleBuilder::build_result(format!("{table_name}")));
-        arena.resume();
+        arena.finish();
         Ok(())
     }
 }
diff --git a/src/execution/ddl/create_view.rs b/src/execution/ddl/create_view.rs
index 22c55f1f..8933d153 100644
--- a/src/execution/ddl/create_view.rs
+++ b/src/execution/ddl/create_view.rs
@@ -19,50 +19,37 @@ use crate::execution::{
 use crate::planner::operator::create_view::CreateViewOperator;
 use crate::planner::MetaArena;
 use crate::storage::Transaction;
-use crate::types::tuple_builder::TupleBuilder;
 
-pub struct CreateView {
-    op: Option<CreateViewOperator>,
+pub struct CreateView<'a> {
+    op: &'a CreateViewOperator,
 }
 
-impl From<CreateViewOperator> for CreateView {
-    fn from(op: CreateViewOperator) -> Self {
-        CreateView { op: Some(op) }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for CreateView {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for CreateView<'a> {
+    type Input = &'a CreateViewOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::CreateView(executor))
+        arena.push(ExecNode::CreateView(CreateView { op }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CreateView {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CreateView<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        let Some(CreateViewOperator { view, or_replace }) = self.op.take() else {
-            arena.finish();
-            return Ok(());
-        };
-        let view_name = view.name.to_string();
+        let CreateViewOperator { view, or_replace } = self.op;
         let (transaction, table_codec) = arena.transaction_codec_mut();
-        let view = transaction.create_view(table_codec, plan_arena, view, or_replace)?;
+        let view = transaction.create_view(table_codec, plan_arena, view.clone(), *or_replace)?;
         arena.push_ddl_apply(DDLApply::upsert_view(view));
 
-        arena.produce_tuple(TupleBuilder::build_result(view_name));
-        arena.resume();
+        arena.finish();
         Ok(())
     }
 }
diff --git a/src/execution/ddl/drop_column.rs b/src/execution/ddl/drop_column.rs
index e2b47cb7..31a981d3 100644
--- a/src/execution/ddl/drop_column.rs
+++ b/src/execution/ddl/drop_column.rs
@@ -21,49 +21,37 @@ use crate::iter_ext::Itertools;
 use crate::planner::operator::alter_table::drop_column::DropColumnOperator;
 use crate::planner::MetaArena;
 use crate::storage::Transaction;
-use crate::types::tuple_builder::TupleBuilder;
 
-pub struct DropColumn {
-    op: Option<DropColumnOperator>,
+pub struct DropColumn<'a> {
+    op: &'a DropColumnOperator,
 }
 
-impl From<DropColumnOperator> for DropColumn {
-    fn from(op: DropColumnOperator) -> Self {
-        Self { op: Some(op) }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for DropColumn {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for DropColumn<'a> {
+    type Input = &'a DropColumnOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::DropColumn(executor))
+        arena.push(ExecNode::DropColumn(DropColumn { op }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropColumn {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropColumn<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
         let table_cache = arena.table_cache();
-        let Some(DropColumnOperator {
+        let DropColumnOperator {
             table_name,
             column_name,
             if_exists,
-        }) = self.op.take()
-        else {
-            arena.finish();
-            return Ok(());
-        };
+        } = self.op;
 
         let (old_schema, pk_ty, column_info) = {
             let table_catalog = arena
@@ -96,7 +84,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropColumn {
                 rewrite_table_in_batches(
                     transaction,
                     table_codec,
-                    &table_name,
+                    table_name,
                     &pk_ty,
                     old_schema.len(),
                     || {
@@ -121,12 +109,11 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropColumn {
             {
                 let (transaction, table_codec) = arena.transaction_codec_mut();
                 let table =
-                    transaction.drop_column(table_codec, plan_arena, &table_name, &column_name)?;
+                    transaction.drop_column(table_codec, plan_arena, table_name, column_name)?;
                 arena.push_ddl_apply(DDLApply::upsert_table(table, true));
             }
 
-            arena.produce_tuple(TupleBuilder::build_result("1".to_string()));
-            arena.resume();
+            arena.finish();
             Ok(())
         } else if !if_exists {
             Err(DatabaseError::column_not_found(column_name))
diff --git a/src/execution/ddl/drop_index.rs b/src/execution/ddl/drop_index.rs
index 8f34aab5..683fb42e 100644
--- a/src/execution/ddl/drop_index.rs
+++ b/src/execution/ddl/drop_index.rs
@@ -19,48 +19,36 @@ use crate::execution::{
 use crate::planner::operator::drop_index::DropIndexOperator;
 use crate::planner::MetaArena;
 use crate::storage::Transaction;
-use crate::types::tuple_builder::TupleBuilder;
 
-pub struct DropIndex {
-    op: Option<DropIndexOperator>,
+pub struct DropIndex<'a> {
+    op: &'a DropIndexOperator,
 }
 
-impl From<DropIndexOperator> for DropIndex {
-    fn from(op: DropIndexOperator) -> Self {
-        Self { op: Some(op) }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for DropIndex {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for DropIndex<'a> {
+    type Input = &'a DropIndexOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::DropIndex(executor))
+        arena.push(ExecNode::DropIndex(DropIndex { op }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropIndex {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropIndex<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        let Some(DropIndexOperator {
+        let DropIndexOperator {
             table_name,
             index_name,
             if_exists,
-        }) = self.op.take()
-        else {
-            arena.finish();
-            return Ok(());
-        };
+        } = self.op;
 
         let dropped = {
             let (transaction, table_codec) = arena.transaction_codec_mut();
@@ -68,8 +56,8 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropIndex {
                 table_codec,
                 plan_arena,
                 table_name.clone(),
-                &index_name,
-                if_exists,
+                index_name,
+                *if_exists,
             )?
         };
         if let Some((table, index_id)) = dropped {
@@ -80,8 +68,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropIndex {
             });
         }
 
-        arena.produce_tuple(TupleBuilder::build_result(index_name.to_string()));
-        arena.resume();
+        arena.finish();
         Ok(())
     }
 }
diff --git a/src/execution/ddl/drop_table.rs b/src/execution/ddl/drop_table.rs
index b3470f54..9467418b 100644
--- a/src/execution/ddl/drop_table.rs
+++ b/src/execution/ddl/drop_table.rs
@@ -19,57 +19,44 @@ use crate::execution::{
 use crate::planner::operator::drop_table::DropTableOperator;
 use crate::planner::MetaArena;
 use crate::storage::Transaction;
-use crate::types::tuple_builder::TupleBuilder;
 
-pub struct DropTable {
-    op: Option<DropTableOperator>,
+pub struct DropTable<'a> {
+    op: &'a DropTableOperator,
 }
 
-impl From<DropTableOperator> for DropTable {
-    fn from(op: DropTableOperator) -> Self {
-        DropTable { op: Some(op) }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for DropTable {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for DropTable<'a> {
+    type Input = &'a DropTableOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::DropTable(executor))
+        arena.push(ExecNode::DropTable(DropTable { op }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropTable {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropTable<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        let Some(DropTableOperator {
+        let DropTableOperator {
             table_name,
             if_exists,
-        }) = self.op.take()
-        else {
-            arena.finish();
-            return Ok(());
-        };
+        } = self.op;
 
         let (transaction, table_codec) = arena.transaction_codec_mut();
-        if transaction.drop_table(table_codec, plan_arena, table_name.clone(), if_exists)? {
+        if transaction.drop_table(table_codec, plan_arena, table_name.clone(), *if_exists)? {
             arena.push_ddl_apply(DDLApply::DropTable {
                 name: table_name.clone(),
             });
         }
 
-        arena.produce_tuple(TupleBuilder::build_result(format!("{table_name}")));
-        arena.resume();
+        arena.finish();
         Ok(())
     }
 }
diff --git a/src/execution/ddl/drop_view.rs b/src/execution/ddl/drop_view.rs
index 891d31d8..30785ad6 100644
--- a/src/execution/ddl/drop_view.rs
+++ b/src/execution/ddl/drop_view.rs
@@ -19,57 +19,44 @@ use crate::execution::{
 use crate::planner::operator::drop_view::DropViewOperator;
 use crate::planner::MetaArena;
 use crate::storage::Transaction;
-use crate::types::tuple_builder::TupleBuilder;
 
-pub struct DropView {
-    op: Option<DropViewOperator>,
+pub struct DropView<'a> {
+    op: &'a DropViewOperator,
 }
 
-impl From<DropViewOperator> for DropView {
-    fn from(op: DropViewOperator) -> Self {
-        DropView { op: Some(op) }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for DropView {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for DropView<'a> {
+    type Input = &'a DropViewOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::DropView(executor))
+        arena.push(ExecNode::DropView(DropView { op }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropView {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for DropView<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         _: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        let Some(DropViewOperator {
+        let DropViewOperator {
             view_name,
             if_exists,
-        }) = self.op.take()
-        else {
-            arena.finish();
-            return Ok(());
-        };
+        } = self.op;
 
         let (transaction, table_codec) = arena.transaction_codec_mut();
-        if transaction.drop_view(table_codec, view_name.clone(), if_exists)? {
+        if transaction.drop_view(table_codec, view_name.clone(), *if_exists)? {
             arena.push_ddl_apply(DDLApply::DropView {
                 name: view_name.clone(),
             });
         }
 
-        arena.produce_tuple(TupleBuilder::build_result(format!("{view_name}")));
-        arena.resume();
+        arena.finish();
         Ok(())
     }
 }
diff --git a/src/execution/ddl/truncate.rs b/src/execution/ddl/truncate.rs
index 072b0b2e..32a5dc4c 100644
--- a/src/execution/ddl/truncate.rs
+++ b/src/execution/ddl/truncate.rs
@@ -19,49 +19,37 @@ use crate::execution::{
 use crate::planner::operator::truncate::TruncateOperator;
 use crate::planner::MetaArena;
 use crate::storage::Transaction;
-use crate::types::tuple_builder::TupleBuilder;
 
-pub struct Truncate {
-    op: Option<TruncateOperator>,
+pub struct Truncate<'a> {
+    op: &'a TruncateOperator,
 }
 
-impl From<TruncateOperator> for Truncate {
-    fn from(op: TruncateOperator) -> Self {
-        Truncate { op: Some(op) }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Truncate {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Truncate<'a> {
+    type Input = &'a TruncateOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::Truncate(executor))
+        arena.push(ExecNode::Truncate(Truncate { op }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Truncate {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Truncate<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        let Some(TruncateOperator { table_name }) = self.op.take() else {
-            arena.finish();
-            return Ok(());
-        };
+        let TruncateOperator { table_name } = self.op;
         let mut state = arena.local_state(plan_arena);
         let (transaction, table_codec) = state.transaction_codec_mut();
-        transaction.drop_data(table_codec, &table_name)?;
+        transaction.drop_data(table_codec, table_name)?;
 
-        arena.produce_tuple(TupleBuilder::build_result(format!("{table_name}")));
-        arena.resume();
+        arena.finish();
         Ok(())
     }
 }
diff --git a/src/execution/dml/analyze.rs b/src/execution/dml/analyze.rs
index 116f355f..f53fb017 100644
--- a/src/execution/dml/analyze.rs
+++ b/src/execution/dml/analyze.rs
@@ -33,57 +33,45 @@ use std::fmt::{self, Formatter};
 
 const DEFAULT_NUM_OF_BUCKETS: usize = 100;
 
-pub struct Analyze {
-    table_name: TableName,
-    input_plan: LogicalPlan,
+pub struct Analyze<'a> {
+    table_name: &'a TableName,
     input: Option<ExecId>,
     histogram_buckets: Option<usize>,
 }
 
-impl From<(AnalyzeOperator, LogicalPlan)> for Analyze {
-    fn from(
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Analyze<'a> {
+    type Input = (&'a AnalyzeOperator, &'a LogicalPlan);
+
+    fn into_executor(
         (
             AnalyzeOperator {
                 table_name,
-                index_metas,
                 histogram_buckets,
+                ..
             },
-            input,
-        ): (AnalyzeOperator, LogicalPlan),
-    ) -> Self {
-        let _ = index_metas;
-        Analyze {
-            table_name,
-            input_plan: input,
-            input: None,
-            histogram_buckets,
-        }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Analyze {
-    type Input = Self;
-
-    fn into_executor(
-        input: Self::Input,
+            input_plan,
+        ): Self::Input,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
         cache: ExecutionContext<'_>,
         transaction: &T,
     ) -> ExecId {
-        let mut executor = input;
-        executor.input = Some(build_read(
+        let input = Some(build_read(
             arena,
             plan_arena,
-            executor.input_plan.take(),
+            input_plan,
             cache,
             transaction,
         ));
-        arena.push(ExecNode::Analyze(executor))
+        arena.push(ExecNode::Analyze(Analyze {
+            table_name,
+            input,
+            histogram_buckets: *histogram_buckets,
+        }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Analyze {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Analyze<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -131,7 +119,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Analyze {
         let mut state = arena.local_state(plan_arena);
         let (transaction, table_codec, ddl_apply) = state.write_transaction_codec_ddl_apply_mut();
         let values = Self::persist_statistics_meta(
-            &self.table_name,
+            self.table_name,
             builders,
             ddl_apply,
             transaction,
@@ -151,7 +139,7 @@ struct State {
     histogram_buckets: Option<usize>,
 }
 
-impl Analyze {
+impl<'a> Analyze<'a> {
     fn persist_statistics_meta<U: Transaction>(
         table_name: &TableName,
         builders: Vec<State>,
diff --git a/src/execution/dml/copy_from_file.rs b/src/execution/dml/copy_from_file.rs
index 72684157..50f88dc6 100644
--- a/src/execution/dml/copy_from_file.rs
+++ b/src/execution/dml/copy_from_file.rs
@@ -25,41 +25,31 @@ use crate::types::tuple_builder::TupleBuilder;
 use std::fs::File;
 use std::io::BufReader;
 
-pub struct CopyFromFile {
-    op: Option<CopyFromFileOperator>,
+pub struct CopyFromFile<'a> {
+    op: &'a CopyFromFileOperator,
 }
 
-impl From<CopyFromFileOperator> for CopyFromFile {
-    fn from(op: CopyFromFileOperator) -> Self {
-        CopyFromFile { op: Some(op) }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for CopyFromFile {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for CopyFromFile<'a> {
+    type Input = &'a CopyFromFileOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::CopyFromFile(executor))
+        arena.push(ExecNode::CopyFromFile(CopyFromFile { op }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CopyFromFile {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CopyFromFile<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        let Some(op) = self.op.take() else {
-            arena.finish();
-            return Ok(());
-        };
+        let op = self.op;
         let column_types = op
             .schema_ref
             .iter()
@@ -76,25 +66,24 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CopyFromFile {
             .ok_or(DatabaseError::TableNotFound)?;
         let table_name = table.name().to_string();
 
-        let file = File::open(op.source.path)?;
+        let file = File::open(&op.source.path)?;
         let mut buf_reader = BufReader::new(file);
-        let mut reader = match op.source.format {
+        let mut reader = match &op.source.format {
             FileFormat::Csv {
                 delimiter,
                 quote,
                 escape,
                 header,
             } => csv::ReaderBuilder::new()
-                .delimiter(delimiter as u8)
-                .quote(quote as u8)
+                .delimiter(*delimiter as u8)
+                .quote(*quote as u8)
                 .escape(escape.map(|c| c as u8))
-                .has_headers(header)
+                .has_headers(*header)
                 .from_reader(&mut buf_reader),
         };
 
         let column_count = op.schema_ref.len();
         let tuple_builder = TupleBuilder::new(column_types, Some(table.primary_key_indices()));
-        let mut size = 0_usize;
 
         for record in reader.records() {
             let record = record?;
@@ -109,11 +98,9 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CopyFromFile {
             let mut state = arena.local_state(plan_arena);
             let (transaction, table_codec) = state.transaction_codec_mut();
             transaction.append_tuple(table_codec, &table_name, &chunk, &serializers, false)?;
-            size += 1;
         }
 
-        arena.produce_tuple(TupleBuilder::build_result(size.to_string()));
-        arena.resume();
+        arena.finish();
         Ok(())
     }
 }
@@ -126,7 +113,6 @@ mod tests {
     use crate::db::{CatalogKind, DataBaseBuilder};
     use crate::errors::DatabaseError;
     use crate::storage::Storage;
-    use crate::types::tuple::TupleLike;
     use crate::types::CharLengthUnits;
     use crate::types::LogicalType;
     use std::io::Write;
@@ -184,8 +170,8 @@ mod tests {
         };
 
         let transaction = db.storage.transaction()?;
-        let mut executor = crate::execution::execute_mut(
-            CopyFromFile::from(op),
+        let mut executor = crate::execution::execute_input_mut::<_, CopyFromFile>(
+            &op,
             crate::execution::test_utils::empty_context(
                 db.state.table_cache(),
                 db.state.view_cache(),
@@ -195,10 +181,16 @@ mod tests {
             &transaction,
         );
 
-        let result = executor
-            .next_tuple()?
-            .expect("copy from file should yield once");
-        assert_eq!(result.value_at(0).to_string(), "2");
+        assert!(executor.next_tuple()?.is_none());
+        drop(executor);
+        transaction.commit()?;
+
+        let mut iter = db.run("select count(*) from test_copy")?;
+        let count = iter
+            .next_tuple(|_, tuple| tuple.values[0].to_string())?
+            .expect("count row");
+        assert_eq!(count, "2");
+        iter.done()?;
 
         Ok(())
     }
diff --git a/src/execution/dml/copy_to_file.rs b/src/execution/dml/copy_to_file.rs
index d9402c7b..c4511c42 100644
--- a/src/execution/dml/copy_to_file.rs
+++ b/src/execution/dml/copy_to_file.rs
@@ -24,65 +24,55 @@ use crate::planner::MetaArena;
 use crate::storage::Transaction;
 use crate::types::tuple_builder::TupleBuilder;
 
-pub struct CopyToFile {
-    op: CopyToFileOperator,
-    input_plan: LogicalPlan,
+pub struct CopyToFile<'a> {
+    op: &'a CopyToFileOperator,
     column_names: Vec<String>,
     input: Option<ExecId>,
 }
 
-impl From<(CopyToFileOperator, LogicalPlan)> for CopyToFile {
-    fn from((op, input): (CopyToFileOperator, LogicalPlan)) -> Self {
-        CopyToFile {
-            op,
-            input_plan: input,
-            column_names: Default::default(),
-            input: None,
-        }
-    }
-}
-
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for CopyToFile {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for CopyToFile<'a> {
+    type Input = (&'a CopyToFileOperator, &'a LogicalPlan);
 
     fn into_executor(
-        input: Self::Input,
+        (op, input_plan): Self::Input,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
         cache: ExecutionContext<'_>,
         transaction: &T,
     ) -> ExecId {
-        let mut executor = input;
-        executor.column_names = executor
-            .input_plan
-            .take_schema(plan_arena)
-            .into_iter()
-            .map(|column| plan_arena.column(column).name().to_string())
+        let column_names = input_plan
+            .read_schema()
+            .iter()
+            .map(|column| plan_arena.column(*column).name().to_string())
             .collect_vec();
-        executor.input = Some(build_read(
+        let input = Some(build_read(
             arena,
             plan_arena,
-            executor.input_plan.take(),
+            input_plan,
             cache,
             transaction,
         ));
-        arena.push(ExecNode::CopyToFile(executor))
+        arena.push(ExecNode::CopyToFile(CopyToFile {
+            op,
+            column_names,
+            input,
+        }))
     }
 }
 
-impl CopyToFile {
+impl CopyToFile<'_> {
     fn create_writer(&self) -> Result<csv::Writer<std::fs::File>, DatabaseError> {
-        let mut writer = match self.op.target.format {
+        let mut writer = match &self.op.target.format {
             FileFormat::Csv {
                 delimiter,
                 quote,
                 header,
                 ..
             } => csv::WriterBuilder::new()
-                .delimiter(delimiter as u8)
-                .quote(quote as u8)
-                .has_headers(header)
-                .from_path(self.op.target.path.clone())?,
+                .delimiter(*delimiter as u8)
+                .quote(*quote as u8)
+                .has_headers(*header)
+                .from_path(&self.op.target.path)?,
         };
 
         if let FileFormat::Csv { header: true, .. } = self.op.target.format {
@@ -93,7 +83,7 @@ impl CopyToFile {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CopyToFile {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for CopyToFile<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -170,19 +160,11 @@ mod tests {
             .table(db.state.table_cache(), "t1".to_string().into())?
             .unwrap();
 
-        let executor = CopyToFile {
-            op: op.clone(),
-            input_plan: TableScanOperator::build(
-                "t1".to_string().into(),
-                table,
-                true,
-                &mut plan_arena,
-            )?,
-            column_names: Default::default(),
-            input: None,
-        };
-        let mut executor = crate::execution::execute(
-            executor,
+        let mut input_plan =
+            TableScanOperator::build("t1".to_string().into(), table, true, &mut plan_arena)?;
+        input_plan.populate_output_schema_recursive(&mut plan_arena);
+        let mut executor = crate::execution::execute_input::<_, CopyToFile>(
+            (&op, &input_plan),
             crate::execution::test_utils::empty_context(
                 db.state.table_cache(),
                 db.state.view_cache(),
diff --git a/src/execution/dml/delete.rs b/src/execution/dml/delete.rs
index e16680a6..3f25092b 100644
--- a/src/execution/dml/delete.rs
+++ b/src/execution/dml/delete.rs
@@ -24,45 +24,33 @@ use crate::storage::Transaction;
 use crate::types::index::Index;
 use crate::types::tuple_builder::TupleBuilder;
 
-pub struct Delete {
-    table_name: TableName,
-    input_plan: LogicalPlan,
+pub struct Delete<'a> {
+    table_name: &'a TableName,
     input: Option<ExecId>,
 }
 
-impl From<(DeleteOperator, LogicalPlan)> for Delete {
-    fn from((DeleteOperator { table_name, .. }, input): (DeleteOperator, LogicalPlan)) -> Self {
-        Delete {
-            table_name,
-            input_plan: input,
-            input: None,
-        }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Delete {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Delete<'a> {
+    type Input = (&'a DeleteOperator, &'a LogicalPlan);
 
     fn into_executor(
-        input: Self::Input,
+        (DeleteOperator { table_name, .. }, input_plan): Self::Input,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
         cache: ExecutionContext<'_>,
         transaction: &T,
     ) -> ExecId {
-        let mut executor = input;
-        executor.input = Some(build_read(
+        let input = Some(build_read(
             arena,
             plan_arena,
-            executor.input_plan.take(),
+            input_plan,
             cache,
             transaction,
         ));
-        arena.push(ExecNode::Delete(executor))
+        arena.push(ExecNode::Delete(Delete { table_name, input }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Delete {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Delete<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -105,12 +93,12 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Delete {
                 let mut state = arena.local_state(plan_arena);
                 let (values, transaction, table_codec) = state.index_values_transaction_codec_mut();
                 let index = Index::new(*index_id, values, *index_ty);
-                transaction.del_index(table_codec, &self.table_name, &index, &tuple_id)?;
+                transaction.del_index(table_codec, self.table_name, &index, &tuple_id)?;
             }
 
             let mut state = arena.local_state(plan_arena);
             let (transaction, table_codec) = state.transaction_codec_mut();
-            transaction.remove_tuple(table_codec, &self.table_name, &tuple_id)?;
+            transaction.remove_tuple(table_codec, self.table_name, &tuple_id)?;
             deleted_count += 1;
         }
 
diff --git a/src/execution/dml/insert.rs b/src/execution/dml/insert.rs
index 6b781d3a..9a40b8cb 100644
--- a/src/execution/dml/insert.rs
+++ b/src/execution/dml/insert.rs
@@ -29,57 +29,46 @@ use crate::types::value::DataValue;
 use crate::types::ColumnId;
 use std::collections::HashMap;
 
-pub struct Insert {
-    table_name: TableName,
+pub struct Insert<'a> {
+    table_name: &'a TableName,
     input_schema: Schema,
-    input_plan: LogicalPlan,
     input: Option<ExecId>,
     is_overwrite: bool,
     is_mapping_by_name: bool,
 }
 
-impl From<(InsertOperator, LogicalPlan)> for Insert {
-    fn from(
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Insert<'a> {
+    type Input = (&'a InsertOperator, &'a LogicalPlan);
+
+    fn into_executor(
         (
             InsertOperator {
                 table_name,
                 is_overwrite,
                 is_mapping_by_name,
             },
-            input,
-        ): (InsertOperator, LogicalPlan),
-    ) -> Self {
-        Insert {
-            table_name,
-            input_schema: Default::default(),
-            input_plan: input,
-            input: None,
-            is_overwrite,
-            is_mapping_by_name,
-        }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Insert {
-    type Input = Self;
-
-    fn into_executor(
-        input: Self::Input,
+            input_plan,
+        ): Self::Input,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
         cache: ExecutionContext<'_>,
         transaction: &T,
     ) -> ExecId {
-        let mut executor = input;
-        executor.input_schema = executor.input_plan.take_schema(plan_arena);
-        executor.input = Some(build_read(
+        let input_schema = input_plan.read_schema().clone();
+        let input = Some(build_read(
             arena,
             plan_arena,
-            executor.input_plan.take(),
+            input_plan,
             cache,
             transaction,
         ));
-        arena.push(ExecNode::Insert(executor))
+        arena.push(ExecNode::Insert(Insert {
+            table_name,
+            input_schema,
+            input,
+            is_overwrite: *is_overwrite,
+            is_mapping_by_name: *is_mapping_by_name,
+        }))
     }
 }
 
@@ -89,11 +78,11 @@ enum MappingKey<'a> {
     Id(Option<ColumnId>),
 }
 
-impl Insert {
-    fn column_key<'a>(
-        column: &'a crate::catalog::ColumnCatalog,
+impl Insert<'_> {
+    fn column_key<'c>(
+        column: &'c crate::catalog::ColumnCatalog,
         is_mapping_by_name: bool,
-    ) -> MappingKey<'a> {
+    ) -> MappingKey<'c> {
         if is_mapping_by_name {
             MappingKey::Name(column.name())
         } else {
@@ -102,7 +91,7 @@ impl Insert {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Insert {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Insert<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -173,13 +162,13 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Insert {
                     let (values, transaction, table_codec) =
                         state.index_values_transaction_codec_mut();
                     let index = Index::new(index_meta.id, values, index_meta.ty);
-                    transaction.add_index(table_codec, &self.table_name, index, tuple_id)?;
+                    transaction.add_index(table_codec, self.table_name, index, tuple_id)?;
                 }
                 let mut state = arena.local_state(plan_arena);
                 let (transaction, table_codec) = state.transaction_codec_mut();
                 transaction.append_tuple(
                     table_codec,
-                    &self.table_name,
+                    self.table_name,
                     &tuple,
                     &serializers,
                     self.is_overwrite,
diff --git a/src/execution/dml/update.rs b/src/execution/dml/update.rs
index af30cb12..b993ebd1 100644
--- a/src/execution/dml/update.rs
+++ b/src/execution/dml/update.rs
@@ -19,8 +19,9 @@ use crate::execution::{
 };
 use crate::iter_ext::Itertools;
 use crate::planner::operator::update::UpdateOperator;
+use crate::planner::ExprRef;
+use crate::planner::LogicalPlan;
 use crate::planner::MetaArena;
-use crate::planner::{ExprRef, LogicalPlan};
 use crate::storage::Transaction;
 use crate::types::index::{Index, IndexMeta, IndexType};
 use crate::types::tuple::{Schema, Tuple};
@@ -28,58 +29,47 @@ use crate::types::tuple_builder::TupleBuilder;
 use crate::types::ColumnId;
 use std::collections::{HashMap, HashSet};
 
-pub struct Update {
-    table_name: TableName,
-    value_exprs: Vec<(ColumnRef, ExprRef)>,
+pub struct Update<'a> {
+    table_name: &'a TableName,
+    value_exprs: &'a [(ColumnRef, ExprRef)],
     input_schema: Schema,
-    input_plan: LogicalPlan,
     input: Option<ExecId>,
 }
 
-impl From<(UpdateOperator, LogicalPlan)> for Update {
-    fn from(
+impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Update<'a> {
+    type Input = (&'a UpdateOperator, &'a LogicalPlan);
+
+    fn into_executor(
         (
             UpdateOperator {
                 table_name,
                 value_exprs,
             },
-            input,
-        ): (UpdateOperator, LogicalPlan),
-    ) -> Self {
-        Update {
-            table_name,
-            value_exprs,
-            input_schema: Default::default(),
-            input_plan: input,
-            input: None,
-        }
-    }
-}
-
-impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Update {
-    type Input = Self;
-
-    fn into_executor(
-        input: Self::Input,
+            input_plan,
+        ): Self::Input,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
         cache: ExecutionContext<'_>,
         transaction: &T,
     ) -> ExecId {
-        let mut executor = input;
-        executor.input_schema = executor.input_plan.take_schema(plan_arena);
-        executor.input = Some(build_read(
+        let input_schema = input_plan.read_schema().clone();
+        let input = Some(build_read(
             arena,
             plan_arena,
-            executor.input_plan.take(),
+            input_plan,
             cache,
             transaction,
         ));
-        arena.push(ExecNode::Update(executor))
+        arena.push(ExecNode::Update(Update {
+            table_name,
+            value_exprs,
+            input_schema,
+            input,
+        }))
     }
 }
 
-impl Update {
+impl Update<'_> {
     fn index_needs_update(
         index_meta: &IndexMeta,
         updated_column_ids: &HashSet<ColumnId>,
@@ -97,7 +87,7 @@ impl Update {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Update {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Update<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -110,7 +100,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Update {
 
         let mut exprs_map = HashMap::with_capacity(self.value_exprs.len());
         let mut updated_column_ids = HashSet::with_capacity(self.value_exprs.len());
-        for (column, expr) in self.value_exprs.drain(..) {
+        for &(column, expr) in self.value_exprs {
             let column = plan_arena.column(column);
             let column_id = column
                 .id()
@@ -186,7 +176,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Update {
                 if primary_key_changed {
                     let mut state = arena.local_state(plan_arena);
                     let (transaction, table_codec) = state.transaction_codec_mut();
-                    transaction.remove_tuple(table_codec, &self.table_name, &old_pk)?;
+                    transaction.remove_tuple(table_codec, self.table_name, &old_pk)?;
                     is_overwrite = false;
                 }
 
@@ -205,20 +195,23 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Update {
 
                     let old_index = Index::new(index_id, &old_value, index_ty);
                     let new_index = Index::new(index_id, values, index_ty);
-                    transaction.del_index(table_codec, &self.table_name, &old_index, &old_pk)?;
-                    transaction.add_index(table_codec, &self.table_name, new_index, &new_pk)?;
+                    transaction.del_index(table_codec, self.table_name, &old_index, &old_pk)?;
+                    transaction.add_index(table_codec, self.table_name, new_index, &new_pk)?;
                 }
 
                 tuple.pk = Some(new_pk);
                 let mut state = arena.local_state(plan_arena);
                 let (transaction, table_codec) = state.transaction_codec_mut();
-                transaction.append_tuple(
-                    table_codec,
-                    &self.table_name,
-                    &tuple,
-                    &serializers,
-                    is_overwrite,
-                )?;
+                let stamp = if is_overwrite { 0 } else { table_codec.stamp() };
+                table_codec.with_stamp(stamp, |table_codec| {
+                    transaction.append_tuple(
+                        table_codec,
+                        self.table_name,
+                        &tuple,
+                        &serializers,
+                        is_overwrite,
+                    )
+                })?;
                 updated_count += 1;
             }
 
diff --git a/src/execution/dql/aggregate/hash_agg.rs b/src/execution/dql/aggregate/hash_agg.rs
index cb66f900..7e338d41 100644
--- a/src/execution/dql/aggregate/hash_agg.rs
+++ b/src/execution/dql/aggregate/hash_agg.rs
@@ -20,8 +20,9 @@ use crate::execution::{
     build_read, ExecArena, ExecId, ExecNode, ExecutionContext, ExecutorNode, ReadExecutor,
 };
 use crate::planner::operator::aggregate::AggregateOperator;
+use crate::planner::ExprRef;
+use crate::planner::LogicalPlan;
 use crate::planner::MetaArena;
-use crate::planner::{ExprRef, LogicalPlan};
 use crate::storage::Transaction;
 use crate::types::value::DataValue;
 use std::collections::hash_map::IntoIter as HashMapIntoIter;
@@ -29,15 +30,15 @@ use std::collections::HashMap;
 
 type HashAggOutput = HashMapIntoIter<Vec<DataValue>, Vec<Box<dyn Accumulator>>>;
 
-pub struct HashAggExecutor {
-    agg_calls: Vec<ExprRef>,
-    groupby_exprs: Vec<ExprRef>,
+pub struct HashAggExecutor<'a> {
+    agg_calls: &'a [ExprRef],
+    groupby_exprs: &'a [ExprRef],
     input: ExecId,
     output: Option<HashAggOutput>,
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for HashAggExecutor {
-    type Input = (AggregateOperator, LogicalPlan);
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for HashAggExecutor<'a> {
+    type Input = (&'a AggregateOperator, &'a LogicalPlan);
 
     fn into_executor(
         (
@@ -63,7 +64,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for HashAggExecutor {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for HashAggExecutor {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for HashAggExecutor<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -77,7 +78,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for HashAggExecutor {
             while arena.next_tuple(self.input, plan_arena)? {
                 let tuple = arena.result_tuple();
                 group_keys.clear();
-                for expr in &self.groupby_exprs {
+                for expr in self.groupby_exprs {
                     group_keys.push(
                         plan_arena
                             .expression(*expr)
@@ -87,10 +88,10 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for HashAggExecutor {
                 }
 
                 if let Some(accs) = group_hash_accs.get_mut(group_keys.as_slice()) {
-                    update_accumulators(accs, &self.agg_calls, tuple, plan_arena)?;
+                    update_accumulators(accs, self.agg_calls, tuple, plan_arena)?;
                 } else {
-                    let mut accs = create_accumulators(&self.agg_calls, plan_arena)?;
-                    update_accumulators(&mut accs, &self.agg_calls, tuple, plan_arena)?;
+                    let mut accs = create_accumulators(self.agg_calls, plan_arena)?;
+                    update_accumulators(&mut accs, self.agg_calls, tuple, plan_arena)?;
                     group_hash_accs.insert(group_keys.clone(), accs);
                 }
             }
@@ -211,11 +212,11 @@ mod test {
             .instantiate(plan)
             .find_best(None, &mut plan_arena)?;
 
-        let Operator::Aggregate(op) = plan.operator else {
+        let Operator::Aggregate(op) = &plan.operator else {
             unreachable!()
         };
         let tuples = try_collect(execute_input::<_, HashAggExecutor>(
-            (op, plan.childrens.pop_only()),
+            (op, plan.childrens.iter().next().unwrap()),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
diff --git a/src/execution/dql/aggregate/simple_agg.rs b/src/execution/dql/aggregate/simple_agg.rs
index e07be3c8..7d0e889b 100644
--- a/src/execution/dql/aggregate/simple_agg.rs
+++ b/src/execution/dql/aggregate/simple_agg.rs
@@ -19,17 +19,18 @@ use crate::execution::{
 };
 use crate::expression::ScalarExpression;
 use crate::planner::operator::aggregate::AggregateOperator;
+use crate::planner::ExprRef;
+use crate::planner::LogicalPlan;
 use crate::planner::MetaArena;
-use crate::planner::{ExprRef, LogicalPlan};
 use crate::storage::Transaction;
-pub struct SimpleAggExecutor {
-    agg_calls: Vec<ExprRef>,
+pub struct SimpleAggExecutor<'a> {
+    agg_calls: &'a [ExprRef],
     input: ExecId,
     returned: bool,
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for SimpleAggExecutor {
-    type Input = (AggregateOperator, LogicalPlan);
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for SimpleAggExecutor<'a> {
+    type Input = (&'a AggregateOperator, &'a LogicalPlan);
 
     fn into_executor(
         (AggregateOperator { agg_calls, .. }, input): Self::Input,
@@ -47,7 +48,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for SimpleAggExecutor {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for SimpleAggExecutor {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for SimpleAggExecutor<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -58,7 +59,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for SimpleAggExecutor {
             return Ok(());
         }
 
-        let mut accs = create_accumulators(&self.agg_calls, plan_arena)?;
+        let mut accs = create_accumulators(self.agg_calls, plan_arena)?;
 
         while arena.next_tuple(self.input, plan_arena)? {
             let tuple = arena.result_tuple();
diff --git a/src/execution/dql/aggregate/stream_agg.rs b/src/execution/dql/aggregate/stream_agg.rs
index 2b8ebb7f..2f238578 100644
--- a/src/execution/dql/aggregate/stream_agg.rs
+++ b/src/execution/dql/aggregate/stream_agg.rs
@@ -20,23 +20,24 @@ use crate::execution::{
     build_read, ExecArena, ExecId, ExecNode, ExecutionContext, ExecutorNode, ReadExecutor,
 };
 use crate::planner::operator::aggregate::AggregateOperator;
+use crate::planner::ExprRef;
+use crate::planner::LogicalPlan;
 use crate::planner::MetaArena;
-use crate::planner::{ExprRef, LogicalPlan};
 use crate::storage::Transaction;
 use crate::types::value::DataValue;
 use std::mem;
 
 // The optimizer selects this executor only when equal group keys are contiguous in the input.
-pub struct StreamAggExecutor {
-    agg_calls: Vec<ExprRef>,
-    groupby_exprs: Vec<ExprRef>,
+pub struct StreamAggExecutor<'a> {
+    agg_calls: &'a [ExprRef],
+    groupby_exprs: &'a [ExprRef],
     group_keys: Option<Vec<DataValue>>,
     accs: Vec<Box<dyn Accumulator>>,
     input: ExecId,
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for StreamAggExecutor {
-    type Input = (AggregateOperator, LogicalPlan);
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for StreamAggExecutor<'a> {
+    type Input = (&'a AggregateOperator, &'a LogicalPlan);
 
     fn into_executor(
         (
@@ -63,7 +64,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for StreamAggExecutor {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for StreamAggExecutor {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for StreamAggExecutor<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -86,7 +87,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for StreamAggExecutor {
 
             let tuple = arena.result_tuple();
             let mut group_keys = Vec::with_capacity(self.groupby_exprs.len());
-            for expr in &self.groupby_exprs {
+            for expr in self.groupby_exprs {
                 group_keys.push(
                     plan_arena
                         .expression(*expr)
@@ -97,16 +98,16 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for StreamAggExecutor {
 
             match &mut self.group_keys {
                 None => {
-                    self.accs = create_accumulators(&self.agg_calls, plan_arena)?;
-                    update_accumulators(&mut self.accs, &self.agg_calls, tuple, plan_arena)?;
+                    self.accs = create_accumulators(self.agg_calls, plan_arena)?;
+                    update_accumulators(&mut self.accs, self.agg_calls, tuple, plan_arena)?;
                     self.group_keys = Some(group_keys);
                 }
                 Some(current_keys) if current_keys == &group_keys => {
-                    update_accumulators(&mut self.accs, &self.agg_calls, tuple, plan_arena)?;
+                    update_accumulators(&mut self.accs, self.agg_calls, tuple, plan_arena)?;
                 }
                 Some(current_keys) => {
-                    let mut next_accs = create_accumulators(&self.agg_calls, plan_arena)?;
-                    update_accumulators(&mut next_accs, &self.agg_calls, tuple, plan_arena)?;
+                    let mut next_accs = create_accumulators(self.agg_calls, plan_arena)?;
+                    update_accumulators(&mut next_accs, self.agg_calls, tuple, plan_arena)?;
                     mem::swap(current_keys, &mut group_keys);
                     let current_accs = mem::replace(&mut self.accs, next_accs);
                     write_aggregate_output(arena.result_tuple_mut(), current_accs, group_keys)?;
@@ -187,7 +188,7 @@ mod tests {
         let transaction = storage.transaction()?;
 
         let rows = try_collect(execute_input::<_, StreamAggExecutor>(
-            (operator, input),
+            (&operator, &input),
             empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -231,7 +232,7 @@ mod tests {
         let transaction = storage.transaction()?;
 
         let rows = try_collect(execute_input::<_, StreamAggExecutor>(
-            (operator, input),
+            (&operator, &input),
             empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
diff --git a/src/execution/dql/aggregate/stream_distinct.rs b/src/execution/dql/aggregate/stream_distinct.rs
index 0152418e..87aab16f 100644
--- a/src/execution/dql/aggregate/stream_distinct.rs
+++ b/src/execution/dql/aggregate/stream_distinct.rs
@@ -17,19 +17,20 @@ use crate::execution::{
     build_read, ExecArena, ExecId, ExecNode, ExecutionContext, ExecutorNode, ReadExecutor,
 };
 use crate::planner::operator::aggregate::AggregateOperator;
+use crate::planner::ExprRef;
+use crate::planner::LogicalPlan;
 use crate::planner::MetaArena;
-use crate::planner::{ExprRef, LogicalPlan};
 use crate::storage::Transaction;
 use crate::types::tuple::Tuple;
 
-pub struct StreamDistinctExecutor {
-    groupby_exprs: Vec<ExprRef>,
+pub struct StreamDistinctExecutor<'a> {
+    groupby_exprs: &'a [ExprRef],
     input: ExecId,
     last_keys: Option<Tuple>,
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for StreamDistinctExecutor {
-    type Input = (AggregateOperator, LogicalPlan);
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for StreamDistinctExecutor<'a> {
+    type Input = (&'a AggregateOperator, &'a LogicalPlan);
 
     fn into_executor(
         (op, input): Self::Input,
@@ -40,14 +41,14 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for StreamDistinctExecutor {
     ) -> ExecId {
         let input = build_read(arena, plan_arena, input, cache, transaction);
         arena.push(ExecNode::StreamDistinct(StreamDistinctExecutor {
-            groupby_exprs: op.groupby_exprs,
+            groupby_exprs: &op.groupby_exprs,
             input,
             last_keys: None,
         }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for StreamDistinctExecutor {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for StreamDistinctExecutor<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -63,7 +64,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for StreamDistinctExecutor {
                 }
                 return Ok(());
             }
-            arena.rewrite(&self.groupby_exprs, plan_arena, None)?;
+            arena.rewrite(self.groupby_exprs, plan_arena, None)?;
 
             if let Some(last_keys) = &mut self.last_keys {
                 if last_keys.values == arena.result_tuple().values {
@@ -168,14 +169,14 @@ mod tests {
         };
         let plan = LogicalPlan::new(Operator::Aggregate(agg), Childrens::Only(Box::new(input)));
         let plan = optimize_exprs(plan, &mut plan_arena)?;
-        let Operator::Aggregate(agg) = plan.operator else {
+        let Operator::Aggregate(agg) = &plan.operator else {
             unreachable!()
         };
 
         let (table_cache, view_cache, meta_cache, _temp_dir, storage) = build_test_storage()?;
         let transaction = storage.transaction()?;
         let tuples = try_collect(execute_input::<_, StreamDistinctExecutor>(
-            (agg, plan.childrens.pop_only()),
+            (agg, plan.childrens.iter().next().unwrap()),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -226,14 +227,14 @@ mod tests {
         };
         let plan = LogicalPlan::new(Operator::Aggregate(agg), Childrens::Only(Box::new(input)));
         let plan = optimize_exprs(plan, &mut plan_arena)?;
-        let Operator::Aggregate(agg) = plan.operator else {
+        let Operator::Aggregate(agg) = &plan.operator else {
             unreachable!()
         };
 
         let (table_cache, view_cache, meta_cache, _temp_dir, storage) = build_test_storage()?;
         let transaction = storage.transaction()?;
         let tuples = try_collect(execute_input::<_, StreamDistinctExecutor>(
-            (agg, plan.childrens.pop_only()),
+            (agg, plan.childrens.iter().next().unwrap()),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
diff --git a/src/execution/dql/describe.rs b/src/execution/dql/describe.rs
index 4aff2d41..23128b44 100644
--- a/src/execution/dql/describe.rs
+++ b/src/execution/dql/describe.rs
@@ -46,10 +46,10 @@ pub struct Describe {
     cursor: usize,
 }
 
-impl From<DescribeOperator> for Describe {
-    fn from(op: DescribeOperator) -> Self {
+impl From<&DescribeOperator> for Describe {
+    fn from(op: &DescribeOperator) -> Self {
         Describe {
-            table_name: op.table_name,
+            table_name: op.table_name.clone(),
             columns: None,
             cursor: 0,
         }
@@ -57,7 +57,7 @@ impl From<DescribeOperator> for Describe {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Describe {
-    type Input = Self;
+    type Input = &'a DescribeOperator;
 
     fn into_executor(
         input: Self::Input,
@@ -66,7 +66,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Describe {
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
+        let executor = Describe::from(input);
         arena.push(ExecNode::Describe(executor))
     }
 }
diff --git a/src/execution/dql/dummy.rs b/src/execution/dql/dummy.rs
index da3e2c73..ae0860ca 100644
--- a/src/execution/dql/dummy.rs
+++ b/src/execution/dql/dummy.rs
@@ -31,16 +31,16 @@ impl Default for Dummy {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Dummy {
-    type Input = Self;
+    type Input = ();
 
     fn into_executor(
-        input: Self::Input,
+        _: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
+        let executor = Dummy::default();
         arena.push(ExecNode::Dummy(executor))
     }
 }
diff --git a/src/execution/dql/explain.rs b/src/execution/dql/explain.rs
index a97bb8e5..05b113eb 100644
--- a/src/execution/dql/explain.rs
+++ b/src/execution/dql/explain.rs
@@ -20,22 +20,13 @@ use crate::storage::Transaction;
 use crate::types::value::{DataValue, Utf8Type};
 use crate::types::CharLengthUnits;
 
-pub struct Explain {
-    plan: LogicalPlan,
+pub struct Explain<'a> {
+    plan: &'a LogicalPlan,
     emitted: bool,
 }
 
-impl From<LogicalPlan> for Explain {
-    fn from(plan: LogicalPlan) -> Self {
-        Explain {
-            plan,
-            emitted: false,
-        }
-    }
-}
-
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Explain {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Explain<'a> {
+    type Input = &'a LogicalPlan;
 
     fn into_executor(
         input: Self::Input,
@@ -44,12 +35,14 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Explain {
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::Explain(executor))
+        arena.push(ExecNode::Explain(Explain {
+            plan: input,
+            emitted: false,
+        }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Explain {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Explain<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
diff --git a/src/execution/dql/external_sort.rs b/src/execution/dql/external_sort.rs
index 2e7fe6df..2a913426 100644
--- a/src/execution/dql/external_sort.rs
+++ b/src/execution/dql/external_sort.rs
@@ -43,14 +43,14 @@ impl Run {
     }
 }
 
-pub struct ExternalSort {
+pub struct ExternalSort<'a> {
     rows: Option<SpillReader<SortRow>>,
-    sort_fields: Vec<SortField>,
+    sort_fields: &'a [SortField],
     input: ExecId,
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for ExternalSort {
-    type Input = (SortOperator, LogicalPlan);
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for ExternalSort<'a> {
+    type Input = (&'a SortOperator, &'a LogicalPlan);
 
     fn into_executor(
         (SortOperator { sort_fields }, input): Self::Input,
@@ -68,7 +68,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for ExternalSort {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ExternalSort {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ExternalSort<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -89,7 +89,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ExternalSort {
             // cached sort values, which are evaluated once here and spilled through every merge
             // pass. By default R <= 1,024 and B is about 1 MiB; one oversized row makes this a
             // soft bound.
-            let sort_fields = &self.sort_fields;
+            let sort_fields = self.sort_fields;
             let mut rows = SpillVec::new().on_flush(move |rows| sort_segment(sort_fields, rows));
             let mut runs = Vec::new();
             while arena.next_tuple(self.input, plan_arena)? {
@@ -98,7 +98,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ExternalSort {
                     runs.push(Run::new(segment, 1));
                 }
             }
-            self.rows = Some(finish_sort(rows, runs, &self.sort_fields, MERGE_FAN_IN)?);
+            self.rows = Some(finish_sort(rows, runs, self.sort_fields, MERGE_FAN_IN)?);
         }
     }
 }
diff --git a/src/execution/dql/filter.rs b/src/execution/dql/filter.rs
index d1cd3c15..3d6c0e51 100644
--- a/src/execution/dql/filter.rs
+++ b/src/execution/dql/filter.rs
@@ -17,8 +17,9 @@ use crate::execution::{
     build_read, ExecArena, ExecId, ExecNode, ExecutionContext, ExecutorNode, ReadExecutor,
 };
 use crate::planner::operator::filter::FilterOperator;
+use crate::planner::ExprRef;
+use crate::planner::LogicalPlan;
 use crate::planner::MetaArena;
-use crate::planner::{ExprRef, LogicalPlan};
 use crate::storage::Transaction;
 pub struct Filter {
     predicate: ExprRef,
@@ -26,7 +27,7 @@ pub struct Filter {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Filter {
-    type Input = (FilterOperator, LogicalPlan);
+    type Input = (&'a FilterOperator, &'a LogicalPlan);
 
     fn into_executor(
         (FilterOperator { predicate, .. }, input): Self::Input,
@@ -36,7 +37,10 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Filter {
         transaction: &T,
     ) -> ExecId {
         let input = build_read(arena, plan_arena, input, cache, transaction);
-        arena.push(ExecNode::Filter(Filter { predicate, input }))
+        arena.push(ExecNode::Filter(Filter {
+            predicate: *predicate,
+            input,
+        }))
     }
 }
 
diff --git a/src/execution/dql/function_scan.rs b/src/execution/dql/function_scan.rs
index eb54d99c..e09455c3 100644
--- a/src/execution/dql/function_scan.rs
+++ b/src/execution/dql/function_scan.rs
@@ -20,22 +20,22 @@ use crate::planner::MetaArena;
 use crate::storage::Transaction;
 use crate::types::tuple::Tuple;
 
-pub struct FunctionScan {
-    table_function: TableFunction,
+pub struct FunctionScan<'a> {
+    table_function: &'a TableFunction,
     iter: Option<Box<dyn Iterator<Item = Result<Tuple, DatabaseError>>>>,
 }
 
-impl From<FunctionScanOperator> for FunctionScan {
-    fn from(op: FunctionScanOperator) -> Self {
+impl<'a> From<&'a FunctionScanOperator> for FunctionScan<'a> {
+    fn from(op: &'a FunctionScanOperator) -> Self {
         FunctionScan {
-            table_function: op.table_function,
+            table_function: &op.table_function,
             iter: None,
         }
     }
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for FunctionScan {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for FunctionScan<'a> {
+    type Input = &'a FunctionScanOperator;
 
     fn into_executor(
         input: Self::Input,
@@ -44,19 +44,19 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for FunctionScan {
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
+        let executor = FunctionScan::from(input);
         arena.push(ExecNode::FunctionScan(executor))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for FunctionScan {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for FunctionScan<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
         if self.iter.is_none() {
-            let TableFunction { args, catalog } = &self.table_function;
+            let TableFunction { args, catalog } = self.table_function;
             self.iter = Some(catalog.inner.eval(args, plan_arena)?);
         }
 
diff --git a/src/execution/dql/index_scan.rs b/src/execution/dql/index_scan.rs
index 488b6ed5..fcd38bd6 100644
--- a/src/execution/dql/index_scan.rs
+++ b/src/execution/dql/index_scan.rs
@@ -14,63 +14,87 @@
 
 use crate::errors::DatabaseError;
 use crate::execution::{ExecArena, ExecId, ExecNode, ExecutionContext, ExecutorNode, ReadExecutor};
-use crate::expression::range_detacher::Range;
+use crate::expression::range_detacher::{IndexRangeColumn, Range, RangeDetacher};
 use crate::planner::operator::table_scan::TableScanOperator;
+use crate::planner::operator::SortOption;
 use crate::planner::MetaArena;
 use crate::storage::{IndexIter, IndexRanges, Iter, Transaction};
-use crate::types::index::{IndexLookup, IndexMetaRef, RuntimeIndexProbe};
-use crate::types::serialize::TupleValueSerializableImpl;
+use crate::types::index::{IndexInfo, IndexLookup, RuntimeIndexProbe};
+use std::borrow::Cow;
 
 pub(crate) struct IndexScan<'a, T: Transaction + 'a> {
-    op: Option<TableScanOperator>,
-    index_by: IndexMetaRef,
-    lookup: Option<IndexLookup>,
-    covered_deserializers: Option<Vec<TupleValueSerializableImpl>>,
-    cover_mapping: Option<Vec<usize>>,
+    op: &'a TableScanOperator,
+    info: &'a IndexInfo,
+    lookup: &'a IndexLookup,
     iter: Option<IndexIter<'a, T>>,
 }
 
-impl<'a, T: Transaction + 'a>
-    From<(
-        TableScanOperator,
-        IndexMetaRef,
-        IndexLookup,
-        Option<Vec<TupleValueSerializableImpl>>,
-        Option<Vec<usize>>,
-    )> for IndexScan<'a, T>
-{
-    fn from(
-        (op, index_by, lookup, covered_deserializers, cover_mapping): (
-            TableScanOperator,
-            IndexMetaRef,
-            IndexLookup,
-            Option<Vec<TupleValueSerializableImpl>>,
-            Option<Vec<usize>>,
-        ),
+impl<'a, T: Transaction + 'a> IndexScan<'a, T> {
+    pub(crate) fn new(
+        op: &'a TableScanOperator,
+        info: &'a IndexInfo,
+        lookup: &'a IndexLookup,
     ) -> Self {
-        IndexScan {
-            op: Some(op),
-            index_by,
-            lookup: Some(lookup),
-            covered_deserializers,
-            cover_mapping,
+        Self {
+            op,
+            info,
+            lookup,
             iter: None,
         }
     }
+
+    pub(crate) fn ranges(
+        &self,
+        arena: &mut ExecArena<'a, T>,
+        plan_arena: &mut (dyn MetaArena + 'a),
+    ) -> Result<IndexRanges<'a>, DatabaseError> {
+        let info = self.info;
+        let mut range = match self.lookup {
+            IndexLookup::Static(range) => Cow::Borrowed(range),
+            IndexLookup::Probe => Cow::Owned(match arena.pop_runtime_probe() {
+                RuntimeIndexProbe::Eq(value) => Range::Eq(value),
+                RuntimeIndexProbe::Scope { min, max } => Range::Scope { min, max },
+            }),
+        };
+
+        if plan_arena.has_bound_params() && range.has_parameter() {
+            let plan_arena = &*plan_arena;
+            range
+                .to_mut()
+                .bind_parameters(&|id| plan_arena.bound_param(id))?;
+        }
+        if let (
+            Some(predicate),
+            SortOption::OrderBy {
+                ignore_prefix_len, ..
+            },
+        ) = (info.residual_predicate, &info.sort_option)
+        {
+            if let Some(specialized) = RangeDetacher::<IndexRangeColumn, _>::specialize_range(
+                info.meta,
+                &range,
+                predicate,
+                *ignore_prefix_len,
+                plan_arena,
+            )? {
+                range = Cow::Owned(specialized);
+            }
+        }
+        Ok(IndexRanges::from(range).reversed(info.is_reverse()))
+    }
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for IndexScan<'a, T> {
-    type Input = Self;
+    type Input = (&'a TableScanOperator, &'a IndexInfo, &'a IndexLookup);
 
     fn into_executor(
-        input: Self::Input,
+        (op, info, lookup): Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::IndexScan(executor))
+        arena.push(ExecNode::IndexScan(IndexScan::new(op, info, lookup)))
     }
 }
 
@@ -80,44 +104,35 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for IndexScan<'a, T> {
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        if self.iter.is_none() {
-            let Some(TableScanOperator {
-                table_name,
-                columns,
-                limit,
-                with_pk,
-                ..
-            }) = self.op.take()
-            else {
-                arena.finish();
-                return Ok(());
-            };
-            let ranges = Self::ranges_from_lookup(
-                self.lookup.take().expect("index scan lookup initialized"),
-                arena,
-            );
-            let state = arena.local_state(plan_arena);
-            self.iter = Some(state.transaction().read_by_index(
-                state.context.table_cache,
-                state.plan_arena,
-                table_name,
-                limit,
-                columns,
-                self.index_by,
-                ranges,
-                with_pk,
-                self.covered_deserializers.take(),
-                self.cover_mapping.take(),
-            )?);
-        }
+        let iter = match &mut self.iter {
+            Some(iter) => iter,
+            None => {
+                let ranges = self.ranges(arena, plan_arena)?;
+                let TableScanOperator {
+                    table_name,
+                    columns,
+                    limit,
+                    with_pk,
+                    ..
+                } = self.op;
+                let state = arena.local_state(plan_arena);
+                self.iter.insert(state.transaction().read_by_index(
+                    state.context.table_cache,
+                    state.plan_arena,
+                    table_name.clone(),
+                    *limit,
+                    columns,
+                    self.info.meta,
+                    ranges,
+                    *with_pk,
+                    self.info.covered_deserializers.as_deref(),
+                    self.info.cover_mapping.as_deref(),
+                )?)
+            }
+        };
 
         let state = arena.local_state(plan_arena);
-        if self
-            .iter
-            .as_mut()
-            .expect("index scan iterator initialized")
-            .next_tuple_into(state.table_codec, &mut state.result.tuple)?
-        {
+        if iter.next_tuple_into(state.table_codec, &mut state.result.tuple)? {
             arena.resume();
         } else {
             arena.finish();
@@ -125,16 +140,3 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for IndexScan<'a, T> {
         Ok(())
     }
 }
-
-impl<'a, T: Transaction + 'a> IndexScan<'a, T> {
-    fn ranges_from_lookup(lookup: IndexLookup, arena: &mut ExecArena<'a, T>) -> IndexRanges {
-        match lookup {
-            IndexLookup::Static(Range::SortedRanges(ranges)) => ranges.into(),
-            IndexLookup::Static(range) => range.into(),
-            IndexLookup::Probe => match arena.pop_runtime_probe() {
-                RuntimeIndexProbe::Eq(value) => Range::Eq(value).into(),
-                RuntimeIndexProbe::Scope { min, max } => Range::Scope { min, max }.into(),
-            },
-        }
-    }
-}
diff --git a/src/execution/dql/join/hash_join.rs b/src/execution/dql/join/hash_join.rs
index d44d1d37..222ffac8 100644
--- a/src/execution/dql/join/hash_join.rs
+++ b/src/execution/dql/join/hash_join.rs
@@ -26,8 +26,9 @@ use crate::execution::{
     build_read, ExecArena, ExecId, ExecNode, ExecutionContext, ExecutorNode, ReadExecutor,
 };
 use crate::planner::operator::join::{JoinCondition, JoinOperator, JoinType};
+use crate::planner::ExprRef;
+use crate::planner::LogicalPlan;
 use crate::planner::MetaArena;
-use crate::planner::{ExprRef, LogicalPlan};
 use crate::storage::Transaction;
 use crate::types::tuple::Tuple;
 use crate::types::value::DataValue;
@@ -43,8 +44,6 @@ pub struct HashJoin {
     filter: Option<ExprRef>,
     left_schema_len: usize,
     right_schema_len: usize,
-    left_input_plan: LogicalPlan,
-    right_input_plan: LogicalPlan,
     left_input: ExecId,
     right_input: ExecId,
     bump: Box<Bump>,
@@ -66,18 +65,19 @@ enum HashJoinState {
     End,
 }
 
-impl From<(JoinOperator, LogicalPlan, LogicalPlan)> for HashJoin {
-    fn from(
-        (JoinOperator { on, join_type, .. }, left_input, right_input): (
-            JoinOperator,
-            LogicalPlan,
-            LogicalPlan,
-        ),
+impl HashJoin {
+    fn new(
+        JoinOperator { on, join_type, .. }: &JoinOperator,
+        left_schema_len: usize,
+        right_schema_len: usize,
+        left_input: ExecId,
+        right_input: ExecId,
     ) -> Self {
         let ((on_left_keys, on_right_keys), filter_expr) = match on {
-            JoinCondition::On { on, filter } => (on.into_iter().unzip(), filter),
+            JoinCondition::On { on, filter } => (on.iter().copied().unzip(), *filter),
             JoinCondition::None => ((vec![], vec![]), None),
         };
+        let join_type = *join_type;
 
         let init_error = if join_type == JoinType::Cross {
             Some(DatabaseError::UnsupportedStmt(
@@ -97,12 +97,10 @@ impl From<(JoinOperator, LogicalPlan, LogicalPlan)> for HashJoin {
             on_left_keys,
             on_right_keys,
             filter: filter_expr,
-            left_schema_len: 0,
-            right_schema_len: 0,
-            left_input_plan: left_input,
-            right_input_plan: right_input,
-            left_input: 0,
-            right_input: 0,
+            left_schema_len,
+            right_schema_len,
+            left_input,
+            right_input,
             bump: Box::<Bump>::default(),
             init_error,
         }
@@ -230,33 +228,25 @@ pub(crate) struct BuildState {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for HashJoin {
-    type Input = Self;
+    type Input = (&'a JoinOperator, &'a LogicalPlan, &'a LogicalPlan);
 
     fn into_executor(
-        input: Self::Input,
+        (op, left_plan, right_plan): Self::Input,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
         cache: ExecutionContext<'_>,
         transaction: &T,
     ) -> ExecId {
-        let mut executor = input;
-        let left_schema_len = executor.left_input_plan.output_schema(plan_arena).len();
-        let right_schema_len = executor.right_input_plan.output_schema(plan_arena).len();
-        executor.left_schema_len = left_schema_len;
-        executor.right_schema_len = right_schema_len;
-        executor.left_input = build_read(
-            arena,
-            plan_arena,
-            executor.left_input_plan.take(),
-            cache,
-            transaction,
-        );
-        executor.right_input = build_read(
-            arena,
-            plan_arena,
-            executor.right_input_plan.take(),
-            cache,
-            transaction,
+        let left_schema_len = left_plan.read_schema().len();
+        let right_schema_len = right_plan.read_schema().len();
+        let left_input = build_read(arena, plan_arena, left_plan, cache, transaction);
+        let right_input = build_read(arena, plan_arena, right_plan, cache, transaction);
+        let executor = HashJoin::new(
+            op,
+            left_schema_len,
+            right_schema_len,
+            left_input,
+            right_input,
         );
         arena.push(ExecNode::HashJoin(executor))
     }
@@ -524,9 +514,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            HashJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, HashJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -582,11 +574,12 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
         {
-            let executor = HashJoin::from((op.clone(), left.clone(), right.clone()));
-            let tuples = try_collect(crate::execution::execute(
-                executor,
+            let tuples = try_collect(crate::execution::execute_input::<_, HashJoin>(
+                (&op, &left, &right),
                 crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
                 plan_arena,
                 &transaction,
@@ -646,9 +639,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            HashJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, HashJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -753,9 +748,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            HashJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, HashJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -806,9 +803,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            HashJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, HashJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
diff --git a/src/execution/dql/join/nested_loop_join.rs b/src/execution/dql/join/nested_loop_join.rs
index a0aa111a..5c9385a2 100644
--- a/src/execution/dql/join/nested_loop_join.rs
+++ b/src/execution/dql/join/nested_loop_join.rs
@@ -15,6 +15,7 @@
 //! Defines the nested loop join executor, it supports [`JoinType::Inner`], [`JoinType::LeftOuter`],
 //! [`JoinType::RightOuter`], [`JoinType::Cross`], [`JoinType::Full`].
 
+use crate::planner::LogicalPlan;
 use crate::planner::MetaArena;
 
 use crate::errors::DatabaseError;
@@ -24,7 +25,7 @@ use crate::execution::{
 };
 use crate::iter_ext::Itertools;
 use crate::planner::operator::join::{JoinCondition, JoinOperator, JoinType};
-use crate::planner::{ExprRef, LogicalPlan};
+use crate::planner::ExprRef;
 use crate::storage::Transaction;
 use crate::types::tuple::{SplitTupleRef, Tuple};
 use crate::types::value::DataValue;
@@ -74,9 +75,8 @@ impl EqualCondition {
 /// | Right/RightSemi/RightAnti/Full |    left        |      right     |
 /// |--------------------------------|----------------|----------------|
 /// | Full                           |    left        |      right     |
-pub struct NestedLoopJoin {
-    left_input_plan: LogicalPlan,
-    right_input_plan: LogicalPlan,
+pub struct NestedLoopJoin<'a> {
+    right_input_plan: &'a LogicalPlan,
     ty: JoinType,
     filter: Option<ExprRef>,
     eq_cond: EqualCondition,
@@ -109,81 +109,52 @@ struct ActiveLeftState {
     first_matches: Vec<usize>,
 }
 
-impl From<(JoinOperator, LogicalPlan, LogicalPlan)> for NestedLoopJoin {
-    fn from(
-        (JoinOperator { on, join_type, .. }, left_input, right_input): (
-            JoinOperator,
-            LogicalPlan,
-            LogicalPlan,
-        ),
-    ) -> Self {
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for NestedLoopJoin<'a> {
+    type Input = (&'a JoinOperator, &'a LogicalPlan, &'a LogicalPlan);
+
+    fn into_executor(
+        (JoinOperator { on, join_type, .. }, left_plan, right_plan): Self::Input,
+        arena: &mut ExecArena<'a, T>,
+        plan_arena: &mut (dyn MetaArena + 'a),
+        cache: ExecutionContext<'_>,
+        transaction: &T,
+    ) -> ExecId {
         let ((mut on_left_keys, mut on_right_keys), filter) = match on {
-            JoinCondition::On { on, filter } => (on.into_iter().unzip(), filter),
+            JoinCondition::On { on, filter } => (on.iter().copied().unzip(), *filter),
             JoinCondition::None => ((vec![], vec![]), None),
         };
+        let join_type = *join_type;
 
-        let (mut left_input, mut right_input) = (left_input, right_input);
+        let (mut left_plan, mut right_plan) = (left_plan, right_plan);
 
         if matches!(join_type, JoinType::RightOuter) {
-            std::mem::swap(&mut left_input, &mut right_input);
+            std::mem::swap(&mut left_plan, &mut right_plan);
             std::mem::swap(&mut on_left_keys, &mut on_right_keys);
         }
 
         let eq_cond = EqualCondition {
             on_left_keys,
             on_right_keys,
-            left_len: 0,
-            right_len: 0,
+            left_len: left_plan.read_schema().len(),
+            right_len: right_plan.read_schema().len(),
         };
 
-        NestedLoopJoin {
-            left_input_plan: left_input,
-            right_input_plan: right_input,
+        let left_input = build_read(arena, plan_arena, left_plan, cache, transaction);
+        let right_pos = arena.nodes.position();
+        build_read(arena, plan_arena, right_plan, cache, transaction);
+        arena.push(ExecNode::NestedLoopJoin(NestedLoopJoin {
+            right_input_plan: right_plan,
             ty: join_type,
             filter,
             eq_cond,
-            left_input: 0,
-            right_pos: 0,
+            left_input,
+            right_pos,
             state: NestedLoopJoinState::PullLeft { right_bitmap: None },
-        }
+        }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for NestedLoopJoin {
-    type Input = Self;
-
-    fn into_executor(
-        input: Self::Input,
-        arena: &mut ExecArena<'a, T>,
-        plan_arena: &mut (dyn MetaArena + 'a),
-        cache: ExecutionContext<'_>,
-        transaction: &T,
-    ) -> ExecId {
-        let mut executor = input;
-        let left_len = executor.left_input_plan.output_schema(plan_arena).len();
-        let right_len = executor.right_input_plan.output_schema(plan_arena).len();
-        executor.eq_cond.left_len = left_len;
-        executor.eq_cond.right_len = right_len;
-        executor.left_input = build_read(
-            arena,
-            plan_arena,
-            executor.left_input_plan.take(),
-            cache,
-            transaction,
-        );
-        executor.right_pos = arena.nodes.position();
-        build_read(
-            arena,
-            plan_arena,
-            executor.right_input_plan.clone(),
-            cache,
-            transaction,
-        );
-        arena.push(ExecNode::NestedLoopJoin(executor))
-    }
-}
-
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for NestedLoopJoin {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for NestedLoopJoin<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -396,8 +367,8 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for NestedLoopJoin {
     }
 }
 
-impl NestedLoopJoin {
-    fn build_right_input<'a, T: Transaction + 'a>(
+impl<'a> NestedLoopJoin<'a> {
+    fn build_right_input<T: Transaction + 'a>(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
@@ -406,13 +377,7 @@ impl NestedLoopJoin {
         let transaction = arena.transaction();
         // The same right-hand plan rebuilds the same slots, including nested joins.
         arena.nodes.seek(self.right_pos);
-        build_read(
-            arena,
-            plan_arena,
-            self.right_input_plan.clone(),
-            cache,
-            transaction,
-        )
+        build_read(arena, plan_arena, self.right_input_plan, cache, transaction)
     }
 
     /// Emit a tuple according to the join type.
@@ -475,7 +440,7 @@ mod test {
     use crate::planner::operator::values::ValuesOperator;
     use crate::planner::operator::Operator;
     use crate::planner::test::PlanArenaTestExt;
-    use crate::planner::Childrens;
+    use crate::planner::{Childrens, LogicalPlan};
     use crate::storage::rocksdb::RocksStorage;
     use crate::storage::Storage;
     use crate::types::evaluator::binary_create;
@@ -673,11 +638,12 @@ mod test {
                 },
             )
         };
-        let plan = cross(left.clone(), cross(left, right));
+        let mut plan = cross(left.clone(), cross(left, right));
+        plan.populate_output_schema_recursive(&mut plan_arena);
         let context = crate::execution::empty_context(&table_cache, &view_cache, &meta_cache);
         let mut arena = ExecArena::new();
         arena.init_context(context, &transaction);
-        let root = build_read(&mut arena, &mut plan_arena, plan, context, &transaction);
+        let root = build_read(&mut arena, &mut plan_arena, &plan, context, &transaction);
         let count = arena.nodes.items.len();
         let address = arena.nodes.items.as_ptr();
         assert_eq!(count, 5);
@@ -723,9 +689,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            NestedLoopJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, NestedLoopJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -776,9 +744,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            NestedLoopJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, NestedLoopJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -858,9 +828,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            NestedLoopJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, NestedLoopJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -911,9 +883,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            NestedLoopJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, NestedLoopJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -979,9 +953,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            NestedLoopJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, NestedLoopJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -1022,9 +998,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            NestedLoopJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, NestedLoopJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -1099,9 +1077,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            NestedLoopJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, NestedLoopJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -1256,9 +1236,11 @@ mod test {
         let Operator::Join(op) = plan.operator else {
             unreachable!()
         };
-        let (left, right) = plan.childrens.pop_twins();
-        let executor = crate::execution::execute(
-            NestedLoopJoin::from((op, left, right)),
+        let (mut left, mut right) = plan.childrens.pop_twins();
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
+        let executor = crate::execution::execute_input::<_, NestedLoopJoin>(
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
diff --git a/src/execution/dql/limit.rs b/src/execution/dql/limit.rs
index 5ab6a1b8..9c9f6874 100644
--- a/src/execution/dql/limit.rs
+++ b/src/execution/dql/limit.rs
@@ -29,7 +29,7 @@ pub struct Limit {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Limit {
-    type Input = (LimitOperator, LogicalPlan);
+    type Input = (&'a LimitOperator, &'a LogicalPlan);
 
     fn into_executor(
         (LimitOperator { offset, limit }, input): Self::Input,
@@ -40,8 +40,8 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Limit {
     ) -> ExecId {
         let input = build_read(arena, plan_arena, input, cache, transaction);
         arena.push(ExecNode::Limit(Limit {
-            offset,
-            limit,
+            offset: *offset,
+            limit: *limit,
             input,
             skipped: 0,
             emitted: 0,
diff --git a/src/execution/dql/mark_apply.rs b/src/execution/dql/mark_apply.rs
index 3670c9a5..6f11b25a 100644
--- a/src/execution/dql/mark_apply.rs
+++ b/src/execution/dql/mark_apply.rs
@@ -32,17 +32,17 @@ enum QuantifiedPredicateOutcome {
     Skip,
 }
 
-pub struct MarkApply {
-    op: MarkApplyOperator,
-    right_input_plan: LogicalPlan,
+pub struct MarkApply<'a> {
+    op: &'a MarkApplyOperator,
+    right_input_plan: &'a LogicalPlan,
     left_input: ExecId,
     right_pos: ExecId,
     // Retain a streaming inner input across next_tuple calls, not its result rows.
     join_input: Option<(ExecId, Tuple)>,
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for MarkApply {
-    type Input = (MarkApplyOperator, LogicalPlan, LogicalPlan);
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for MarkApply<'a> {
+    type Input = (&'a MarkApplyOperator, &'a LogicalPlan, &'a LogicalPlan);
 
     fn into_executor(
         (op, left_input, right_input): Self::Input,
@@ -53,7 +53,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for MarkApply {
     ) -> ExecId {
         let left_input = build_read(arena, plan_arena, left_input, cache, transaction);
         let right_pos = arena.nodes.position();
-        build_read(arena, plan_arena, right_input.clone(), cache, transaction);
+        build_read(arena, plan_arena, right_input, cache, transaction);
         arena.push(ExecNode::MarkApply(Self {
             op,
             right_input_plan: right_input,
@@ -64,7 +64,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for MarkApply {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for MarkApply {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for MarkApply<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -87,8 +87,8 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for MarkApply {
     }
 }
 
-impl MarkApply {
-    fn next_join_tuple<'a, T: Transaction + 'a>(
+impl<'a> MarkApply<'a> {
+    fn next_join_tuple<T: Transaction + 'a>(
         &mut self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
@@ -137,7 +137,7 @@ impl MarkApply {
         }
     }
 
-    fn build_right_input<'a, T: Transaction + 'a>(
+    fn build_right_input<T: Transaction + 'a>(
         &self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
@@ -150,7 +150,7 @@ impl MarkApply {
         build_read(
             arena,
             plan_arena,
-            self.right_input_plan.clone(),
+            self.right_input_plan,
             arena.context(),
             arena.transaction(),
         )
@@ -172,7 +172,7 @@ impl MarkApply {
             .transpose()
     }
 
-    fn mark_value<'a, T: Transaction + 'a>(
+    fn mark_value<T: Transaction + 'a>(
         &self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
@@ -253,7 +253,7 @@ impl MarkApply {
         }
     }
 
-    fn scan_quantified_right_input<'a, T: Transaction + 'a>(
+    fn scan_quantified_right_input<T: Transaction + 'a>(
         &self,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
@@ -319,7 +319,7 @@ impl MarkApply {
         right_tuple: &Tuple,
         plan_arena: &(dyn MetaArena + '_),
     ) -> Result<QuantifiedPredicateOutcome, DatabaseError> {
-        match self.eval_predicates(left_tuple, &right_tuple, plan_arena)? {
+        match self.eval_predicates(left_tuple, right_tuple, plan_arena)? {
             Some(DataValue::Boolean(true)) => Ok(QuantifiedPredicateOutcome::True),
             Some(DataValue::Boolean(false)) => Ok(QuantifiedPredicateOutcome::False),
             Some(DataValue::Null) => Ok(QuantifiedPredicateOutcome::Null),
@@ -510,7 +510,7 @@ mod tests {
         let mut arena = ExecArena::new();
         arena.init_context(cache, &transaction);
         let root = <MarkApply as ReadExecutor<_>>::into_executor(
-            (op, left, right),
+            (&op, &left, &right),
             &mut arena,
             &mut plan_arena,
             cache,
@@ -560,7 +560,7 @@ mod tests {
         let (table_cache, view_cache, meta_cache, _temp_dir, storage) = build_test_storage()?;
         let transaction = storage.transaction()?;
         let mut executor = execute_input::<_, MarkApply>(
-            (op, left, right),
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -591,6 +591,8 @@ mod tests {
         let right_column = right.output_schema(&mut plan_arena)[0];
 
         let predicate = build_equality_predicate(&mut plan_arena, left_column, 0, right_column, 1)?;
+        let op =
+            MarkApplyOperator::new_exists(build_marker_column(&mut plan_arena), vec![predicate]);
 
         let (table_cache, view_cache, meta_cache, _temp_dir, storage) = build_test_storage()?;
         let transaction = storage.transaction()?;
@@ -598,14 +600,7 @@ mod tests {
         let mut arena = ExecArena::new();
         arena.init_context(context, &transaction);
         let root = <MarkApply as ReadExecutor<_>>::into_executor(
-            (
-                MarkApplyOperator::new_exists(
-                    build_marker_column(&mut plan_arena),
-                    vec![predicate],
-                ),
-                left,
-                right,
-            ),
+            (&op, &left, &right),
             &mut arena,
             &mut plan_arena,
             context,
@@ -656,18 +651,13 @@ mod tests {
         let right_column = right.output_schema(&mut plan_arena)[0];
 
         let predicate = build_equality_predicate(&mut plan_arena, left_column, 0, right_column, 1)?;
+        let op =
+            MarkApplyOperator::new_exists(build_marker_column(&mut plan_arena), vec![predicate]);
 
         let (table_cache, view_cache, meta_cache, _temp_dir, storage) = build_test_storage()?;
         let transaction = storage.transaction()?;
         let tuples = try_collect(execute_input::<_, MarkApply>(
-            (
-                MarkApplyOperator::new_exists(
-                    build_marker_column(&mut plan_arena),
-                    vec![predicate],
-                ),
-                left,
-                right,
-            ),
+            (&op, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -741,8 +731,8 @@ mod tests {
         );
 
         let exec: MarkApply = MarkApply {
-            op,
-            right_input_plan: right,
+            op: &op,
+            right_input_plan: &right,
             left_input: 0,
             right_pos: arena.nodes.position(),
             join_input: None,
@@ -794,8 +784,8 @@ mod tests {
         );
 
         let exec: MarkApply = MarkApply {
-            op,
-            right_input_plan: right,
+            op: &op,
+            right_input_plan: &right,
             left_input: 0,
             right_pos: arena.nodes.position(),
             join_input: None,
@@ -847,8 +837,8 @@ mod tests {
         );
 
         let exec: MarkApply = MarkApply {
-            op,
-            right_input_plan: right,
+            op: &op,
+            right_input_plan: &right,
             left_input: 0,
             right_pos: arena.nodes.position(),
             join_input: None,
@@ -893,9 +883,9 @@ mod tests {
         let transaction = storage.transaction()?;
         let tuples = try_collect(execute_input::<_, MarkApply>(
             (
-                MarkApplyOperator::new_in(build_marker_column(&mut plan_arena), vec![predicate]),
-                left,
-                right,
+                &MarkApplyOperator::new_in(build_marker_column(&mut plan_arena), vec![predicate]),
+                &left,
+                &right,
             ),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
@@ -941,9 +931,9 @@ mod tests {
         let transaction = storage.transaction()?;
         let tuples = try_collect(execute_input::<_, MarkApply>(
             (
-                MarkApplyOperator::new_in(build_marker_column(&mut plan_arena), vec![predicate]),
-                left,
-                right,
+                &MarkApplyOperator::new_in(build_marker_column(&mut plan_arena), vec![predicate]),
+                &left,
+                &right,
             ),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
@@ -1009,12 +999,12 @@ mod tests {
         let transaction = storage.transaction()?;
         let tuples = try_collect(execute_input::<_, MarkApply>(
             (
-                MarkApplyOperator::new_in(
+                &MarkApplyOperator::new_in(
                     build_marker_column(&mut plan_arena),
                     vec![probe_predicate, correlated_predicate],
                 ),
-                left,
-                right,
+                &left,
+                &right,
             ),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
diff --git a/src/execution/dql/projection.rs b/src/execution/dql/projection.rs
index 7817dd88..8a98d768 100644
--- a/src/execution/dql/projection.rs
+++ b/src/execution/dql/projection.rs
@@ -17,17 +17,18 @@ use crate::execution::{
     build_read, ExecArena, ExecId, ExecNode, ExecutionContext, ExecutorNode, ReadExecutor,
 };
 use crate::planner::operator::project::ProjectOperator;
+use crate::planner::ExprRef;
+use crate::planner::LogicalPlan;
 use crate::planner::MetaArena;
-use crate::planner::{ExprRef, LogicalPlan};
 use crate::storage::Transaction;
 
-pub struct Projection {
-    exprs: Vec<ExprRef>,
+pub struct Projection<'a> {
+    exprs: &'a [ExprRef],
     input: ExecId,
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Projection {
-    type Input = (ProjectOperator, LogicalPlan);
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Projection<'a> {
+    type Input = (&'a ProjectOperator, &'a LogicalPlan);
 
     fn into_executor(
         (ProjectOperator { exprs }, input): Self::Input,
@@ -41,7 +42,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Projection {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Projection {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Projection<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -52,7 +53,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Projection {
             return Ok(());
         }
 
-        arena.rewrite(&self.exprs, plan_arena, None)?;
+        arena.rewrite(self.exprs, plan_arena, None)?;
         arena.resume();
         Ok(())
     }
diff --git a/src/execution/dql/recursive_cte.rs b/src/execution/dql/recursive_cte.rs
index 519075dd..a59441f1 100644
--- a/src/execution/dql/recursive_cte.rs
+++ b/src/execution/dql/recursive_cte.rs
@@ -175,7 +175,7 @@ enum RecursivePhase {
 }
 
 pub struct RecursiveCte<'a, T: Transaction + 'a> {
-    recursive_plan: LogicalPlan,
+    recursive_plan: &'a LogicalPlan,
     anchor_input: ExecId,
     recursive_arena: ExecArena<'a, T>,
     recursive_root: ExecId,
@@ -187,7 +187,7 @@ pub struct RecursiveCte<'a, T: Transaction + 'a> {
 impl<'a, T: Transaction + 'a> RecursiveCte<'a, T> {
     fn new(
         anchor_input: ExecId,
-        recursive_plan: LogicalPlan,
+        recursive_plan: &'a LogicalPlan,
         recursive_arena: ExecArena<'a, T>,
     ) -> Self {
         Self {
@@ -216,7 +216,7 @@ impl<'a, T: Transaction + 'a> RecursiveCte<'a, T> {
         self.recursive_root = build_read(
             &mut self.recursive_arena,
             plan_arena,
-            self.recursive_plan.clone(),
+            self.recursive_plan,
             cache,
             transaction,
         );
@@ -225,7 +225,7 @@ impl<'a, T: Transaction + 'a> RecursiveCte<'a, T> {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for RecursiveCte<'a, T> {
-    type Input = (LogicalPlan, LogicalPlan);
+    type Input = (&'a LogicalPlan, &'a LogicalPlan);
 
     fn into_executor(
         (anchor_plan, recursive_plan): Self::Input,
@@ -292,7 +292,7 @@ pub struct RecursiveScan {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for RecursiveScan {
-    type Input = RecursiveScanOperator;
+    type Input = &'a RecursiveScanOperator;
 
     fn into_executor(
         _input: Self::Input,
@@ -333,6 +333,7 @@ mod tests {
     use crate::planner::operator::Operator;
     use crate::planner::test::PlanArenaTestExt;
     use crate::planner::Childrens;
+    use crate::planner::LogicalPlan;
     use crate::storage::rocksdb::RocksStorage;
     use crate::storage::{StatisticsMetaCache, Storage, TableCache, ViewCache};
     use crate::types::evaluator::binary_create;
@@ -458,7 +459,7 @@ mod tests {
         let view_cache = ViewCache::default();
         let meta_cache = StatisticsMetaCache::default();
         let tuples = try_collect(execute_input::<_, RecursiveCte<'_, _>>(
-            (anchor, recursive),
+            (&anchor, &recursive),
             empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
diff --git a/src/execution/dql/scalar_apply.rs b/src/execution/dql/scalar_apply.rs
index 7589fe6a..f0c74c2e 100644
--- a/src/execution/dql/scalar_apply.rs
+++ b/src/execution/dql/scalar_apply.rs
@@ -29,7 +29,7 @@ pub struct ScalarApply {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for ScalarApply {
-    type Input = (ScalarApplyOperator, LogicalPlan, LogicalPlan);
+    type Input = (&'a ScalarApplyOperator, &'a LogicalPlan, &'a LogicalPlan);
 
     fn into_executor(
         (_, left_input, right_input): Self::Input,
@@ -54,12 +54,8 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ScalarApply {
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        Self::load_right_once(&mut self.cached_right, self.right_input, arena, plan_arena)?;
-
-        let right_tuple = self
-            .cached_right
-            .as_ref()
-            .expect("scalar apply right tuple initialized");
+        let right_tuple =
+            Self::load_right_once(&mut self.cached_right, self.right_input, arena, plan_arena)?;
         if !arena.next_tuple(self.left_input, plan_arena)? {
             arena.finish();
             return Ok(());
@@ -74,22 +70,23 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for ScalarApply {
 }
 
 impl ScalarApply {
-    fn load_right_once<'a, T: Transaction + 'a>(
-        cached_right: &mut Option<Tuple>,
+    fn load_right_once<'a, 'c, T: Transaction + 'a>(
+        cached_right: &'c mut Option<Tuple>,
         right_input: ExecId,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
-    ) -> Result<(), DatabaseError> {
-        if cached_right.is_none() {
-            if !arena.next_tuple(right_input, plan_arena)? {
-                return Err(DatabaseError::InvalidValue(
-                    "scalar apply right input returned no rows".to_string(),
-                ));
+    ) -> Result<&'c Tuple, DatabaseError> {
+        match cached_right {
+            Some(tuple) => Ok(tuple),
+            None => {
+                if !arena.next_tuple(right_input, plan_arena)? {
+                    return Err(DatabaseError::InvalidValue(
+                        "scalar apply right input returned no rows".to_string(),
+                    ));
+                }
+                Ok(cached_right.insert(arena.materialize_tuple()))
             }
-            *cached_right = Some(arena.materialize_tuple());
         }
-
-        Ok(())
     }
 }
 
@@ -151,7 +148,7 @@ mod tests {
     fn scalar_apply_repeats_scalar_result_for_each_left_row() -> Result<(), DatabaseError> {
         let table_arena = crate::planner::TableArenaCell::default();
         let mut plan_arena = crate::planner::PlanArena::new(&table_arena);
-        let left = build_values(
+        let mut left = build_values(
             &mut plan_arena,
             "left_c1",
             vec![
@@ -159,7 +156,7 @@ mod tests {
                 vec![crate::types::value::DataValue::Int32(2)],
             ],
         );
-        let right = ScalarSubqueryOperator::build(build_values(
+        let mut right = ScalarSubqueryOperator::build(build_values(
             &mut plan_arena,
             "right_c1",
             vec![vec![crate::types::value::DataValue::Int32(7)]],
@@ -167,8 +164,10 @@ mod tests {
 
         let (table_cache, view_cache, meta_cache, _temp_dir, storage) = build_test_storage()?;
         let transaction = storage.transaction()?;
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
         let tuples = try_collect(execute_input::<_, ScalarApply>(
-            (ScalarApplyOperator, left, right),
+            (&ScalarApplyOperator, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
@@ -195,12 +194,12 @@ mod tests {
     fn scalar_apply_repeats_null_scalar_result_for_each_left_row() -> Result<(), DatabaseError> {
         let table_arena = crate::planner::TableArenaCell::default();
         let mut plan_arena = crate::planner::PlanArena::new(&table_arena);
-        let left = build_values(
+        let mut left = build_values(
             &mut plan_arena,
             "left_c1",
             vec![vec![DataValue::Int32(1)], vec![DataValue::Int32(2)]],
         );
-        let right = ScalarSubqueryOperator::build(build_values(
+        let mut right = ScalarSubqueryOperator::build(build_values(
             &mut plan_arena,
             "right_c1",
             vec![vec![DataValue::Null]],
@@ -208,8 +207,10 @@ mod tests {
 
         let (table_cache, view_cache, meta_cache, _temp_dir, storage) = build_test_storage()?;
         let transaction = storage.transaction()?;
+        left.populate_output_schema_recursive(&mut plan_arena);
+        right.populate_output_schema_recursive(&mut plan_arena);
         let tuples = try_collect(execute_input::<_, ScalarApply>(
-            (ScalarApplyOperator, left, right),
+            (&ScalarApplyOperator, &left, &right),
             crate::execution::empty_context(&table_cache, &view_cache, &meta_cache),
             plan_arena,
             &transaction,
diff --git a/src/execution/dql/scalar_subquery.rs b/src/execution/dql/scalar_subquery.rs
index d53fdfc4..f59b5115 100644
--- a/src/execution/dql/scalar_subquery.rs
+++ b/src/execution/dql/scalar_subquery.rs
@@ -29,16 +29,16 @@ pub struct ScalarSubquery {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for ScalarSubquery {
-    type Input = (ScalarSubqueryOperator, LogicalPlan);
+    type Input = (&'a ScalarSubqueryOperator, &'a LogicalPlan);
 
     fn into_executor(
-        (_, mut input): Self::Input,
+        (_, input): Self::Input,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
         cache: ExecutionContext<'_>,
         transaction: &T,
     ) -> ExecId {
-        let value_count = input.output_schema(plan_arena).len();
+        let value_count = input.read_schema().len();
         let input = build_read(arena, plan_arena, input, cache, transaction);
         arena.push(ExecNode::ScalarSubquery(Self {
             input,
diff --git a/src/execution/dql/seq_scan.rs b/src/execution/dql/seq_scan.rs
index 91df1a59..6effc8e3 100644
--- a/src/execution/dql/seq_scan.rs
+++ b/src/execution/dql/seq_scan.rs
@@ -19,31 +19,21 @@ use crate::planner::MetaArena;
 use crate::storage::{Iter, Transaction, TupleIter};
 
 pub(crate) struct SeqScan<'a, T: Transaction + 'a> {
-    op: Option<TableScanOperator>,
+    op: &'a TableScanOperator,
     iter: Option<TupleIter<'a, T>>,
 }
 
-impl<'a, T: Transaction + 'a> From<TableScanOperator> for SeqScan<'a, T> {
-    fn from(op: TableScanOperator) -> Self {
-        SeqScan {
-            op: Some(op),
-            iter: None,
-        }
-    }
-}
-
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for SeqScan<'a, T> {
-    type Input = Self;
+    type Input = &'a TableScanOperator;
 
     fn into_executor(
-        input: Self::Input,
+        op: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _plan_arena: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
-        arena.push(ExecNode::SeqScan(executor))
+        arena.push(ExecNode::SeqScan(SeqScan { op, iter: None }))
     }
 }
 
@@ -53,37 +43,30 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for SeqScan<'a, T> {
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
     ) -> Result<(), DatabaseError> {
-        if self.iter.is_none() {
-            let Some(TableScanOperator {
-                table_name,
-                columns,
-                limit,
-                with_pk,
-                ..
-            }) = self.op.take()
-            else {
-                arena.finish();
-                return Ok(());
-            };
-            let state = arena.local_state(plan_arena);
-            self.iter = Some(state.transaction().read(
-                state.table_codec,
-                state.plan_arena,
-                state.context.table_cache,
-                table_name,
-                limit,
-                columns,
-                with_pk,
-            )?);
-        }
-
         let state = arena.local_state(plan_arena);
-        if self
-            .iter
-            .as_mut()
-            .expect("seq scan iterator initialized")
-            .next_tuple_into(state.table_codec, &mut state.result.tuple)?
-        {
+        let iter = match &mut self.iter {
+            Some(iter) => iter,
+            None => {
+                let TableScanOperator {
+                    table_name,
+                    columns,
+                    limit,
+                    with_pk,
+                    ..
+                } = self.op;
+                self.iter.insert(state.transaction().read(
+                    state.table_codec,
+                    state.plan_arena,
+                    state.context.table_cache,
+                    table_name.clone(),
+                    *limit,
+                    columns,
+                    *with_pk,
+                )?)
+            }
+        };
+
+        if iter.next_tuple_into(state.table_codec, &mut state.result.tuple)? {
             arena.resume();
         } else {
             arena.finish();
diff --git a/src/execution/dql/set_membership.rs b/src/execution/dql/set_membership.rs
index fb2b6c55..7f64f148 100644
--- a/src/execution/dql/set_membership.rs
+++ b/src/execution/dql/set_membership.rs
@@ -25,56 +25,31 @@ use std::collections::HashMap;
 
 pub struct SetMembership {
     kind: SetMembershipKind,
-    left_plan: LogicalPlan,
-    right_plan: LogicalPlan,
     left_input: ExecId,
     right_input: ExecId,
     right_counts: HashMap<Tuple, usize>,
     built: bool,
 }
 
-impl From<(SetMembershipKind, LogicalPlan, LogicalPlan)> for SetMembership {
-    fn from(
-        (kind, left_input, right_input): (SetMembershipKind, LogicalPlan, LogicalPlan),
-    ) -> Self {
-        SetMembership {
-            kind,
-            left_plan: left_input,
-            right_plan: right_input,
-            left_input: 0,
-            right_input: 0,
-            right_counts: HashMap::new(),
-            built: false,
-        }
-    }
-}
-
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for SetMembership {
-    type Input = Self;
+    type Input = (SetMembershipKind, &'a LogicalPlan, &'a LogicalPlan);
 
     fn into_executor(
-        input: Self::Input,
+        (kind, left_plan, right_plan): Self::Input,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
         cache: ExecutionContext<'_>,
         transaction: &T,
     ) -> ExecId {
-        let mut executor = input;
-        executor.left_input = build_read(
-            arena,
-            plan_arena,
-            executor.left_plan.take(),
-            cache,
-            transaction,
-        );
-        executor.right_input = build_read(
-            arena,
-            plan_arena,
-            executor.right_plan.take(),
-            cache,
-            transaction,
-        );
-        arena.push(ExecNode::SetMembership(executor))
+        let left_input = build_read(arena, plan_arena, left_plan, cache, transaction);
+        let right_input = build_read(arena, plan_arena, right_plan, cache, transaction);
+        arena.push(ExecNode::SetMembership(SetMembership {
+            kind,
+            left_input,
+            right_input,
+            right_counts: HashMap::new(),
+            built: false,
+        }))
     }
 }
 
diff --git a/src/execution/dql/show_table.rs b/src/execution/dql/show_table.rs
index e523df1c..9d0a2b60 100644
--- a/src/execution/dql/show_table.rs
+++ b/src/execution/dql/show_table.rs
@@ -24,16 +24,16 @@ pub struct ShowTables<'a, T: Transaction + 'a> {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for ShowTables<'a, T> {
-    type Input = Self;
+    type Input = ();
 
     fn into_executor(
-        input: Self::Input,
+        _: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        arena.push(ExecNode::ShowTables(input))
+        arena.push(ExecNode::ShowTables(ShowTables { metas: None }))
     }
 }
 
diff --git a/src/execution/dql/show_view.rs b/src/execution/dql/show_view.rs
index 9f6ca4a6..12f337a7 100644
--- a/src/execution/dql/show_view.rs
+++ b/src/execution/dql/show_view.rs
@@ -24,16 +24,16 @@ pub struct ShowViews<'a, T: Transaction + 'a> {
 }
 
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for ShowViews<'a, T> {
-    type Input = Self;
+    type Input = ();
 
     fn into_executor(
-        input: Self::Input,
+        _: Self::Input,
         arena: &mut ExecArena<'a, T>,
         _: &mut (dyn MetaArena + 'a),
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        arena.push(ExecNode::ShowViews(input))
+        arena.push(ExecNode::ShowViews(ShowViews { metas: None }))
     }
 }
 
diff --git a/src/execution/dql/sort.rs b/src/execution/dql/sort.rs
index 807a550f..569178f6 100644
--- a/src/execution/dql/sort.rs
+++ b/src/execution/dql/sort.rs
@@ -148,15 +148,15 @@ pub(crate) fn compare_sort_keys<'a>(
     Ordering::Equal
 }
 
-pub struct Sort {
+pub struct Sort<'a> {
     rows: NullableVec<'static, (usize, Tuple)>,
     _arena: Box<Bump>,
-    sort_fields: Vec<SortField>,
+    sort_fields: &'a [SortField],
     input: ExecId,
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Sort {
-    type Input = (SortOperator, LogicalPlan);
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Sort<'a> {
+    type Input = (&'a SortOperator, &'a LogicalPlan);
 
     fn into_executor(
         (SortOperator { sort_fields }, input): Self::Input,
@@ -181,7 +181,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Sort {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Sort {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Sort<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -200,7 +200,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Sort {
                 arena.finish();
                 return Ok(());
             }
-            sort_tuples(&self.sort_fields, &mut self.rows, plan_arena)?;
+            sort_tuples(self.sort_fields, &mut self.rows, plan_arena)?;
             self.rows.reverse();
         }
     }
diff --git a/src/execution/dql/top_k.rs b/src/execution/dql/top_k.rs
index 23f1040f..df4eef8a 100644
--- a/src/execution/dql/top_k.rs
+++ b/src/execution/dql/top_k.rs
@@ -93,17 +93,17 @@ fn top_sort<'a>(
     Ok(())
 }
 
-pub struct TopK {
+pub struct TopK<'a> {
     output: Option<std::iter::Skip<BTreeSetIntoIter<CmpItem<'static>>>>,
     arena: Box<Bump>,
-    sort_fields: Vec<SortField>,
+    sort_fields: &'a [SortField],
     limit: usize,
     offset: Option<usize>,
     input: ExecId,
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for TopK {
-    type Input = (TopKOperator, LogicalPlan);
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for TopK<'a> {
+    type Input = (&'a TopKOperator, &'a LogicalPlan);
 
     fn into_executor(
         (
@@ -124,14 +124,14 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for TopK {
             output: None,
             arena: Box::<Bump>::default(),
             sort_fields,
-            limit,
-            offset,
+            limit: *limit,
+            offset: *offset,
             input,
         }))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for TopK {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for TopK<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -145,7 +145,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for TopK {
             while arena.next_tuple(self.input, plan_arena)? {
                 top_sort(
                     &self.arena,
-                    &self.sort_fields,
+                    self.sort_fields,
                     &mut set,
                     arena.materialize_tuple(),
                     keep_count,
diff --git a/src/execution/dql/union.rs b/src/execution/dql/union.rs
index 75fa2365..12374e68 100644
--- a/src/execution/dql/union.rs
+++ b/src/execution/dql/union.rs
@@ -20,51 +20,28 @@ use crate::planner::LogicalPlan;
 use crate::planner::MetaArena;
 use crate::storage::Transaction;
 pub struct Union {
-    left_plan: LogicalPlan,
-    right_plan: LogicalPlan,
     left_input: ExecId,
     right_input: ExecId,
     reading_left: bool,
 }
 
-impl From<(LogicalPlan, LogicalPlan)> for Union {
-    fn from((left_input, right_input): (LogicalPlan, LogicalPlan)) -> Self {
-        Union {
-            left_plan: left_input,
-            right_plan: right_input,
-            left_input: 0,
-            right_input: 0,
-            reading_left: true,
-        }
-    }
-}
-
 impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Union {
-    type Input = Self;
+    type Input = (&'a LogicalPlan, &'a LogicalPlan);
 
     fn into_executor(
-        input: Self::Input,
+        (left_plan, right_plan): Self::Input,
         arena: &mut ExecArena<'a, T>,
         plan_arena: &mut (dyn MetaArena + 'a),
         cache: ExecutionContext<'_>,
         transaction: &T,
     ) -> ExecId {
-        let mut executor = input;
-        executor.left_input = build_read(
-            arena,
-            plan_arena,
-            executor.left_plan.take(),
-            cache,
-            transaction,
-        );
-        executor.right_input = build_read(
-            arena,
-            plan_arena,
-            executor.right_plan.take(),
-            cache,
-            transaction,
-        );
-        arena.push(ExecNode::Union(executor))
+        let left_input = build_read(arena, plan_arena, left_plan, cache, transaction);
+        let right_input = build_read(arena, plan_arena, right_plan, cache, transaction);
+        arena.push(ExecNode::Union(Union {
+            left_input,
+            right_input,
+            reading_left: true,
+        }))
     }
 }
 
diff --git a/src/execution/dql/values.rs b/src/execution/dql/values.rs
index df7d81b1..d76df905 100644
--- a/src/execution/dql/values.rs
+++ b/src/execution/dql/values.rs
@@ -20,30 +20,30 @@ use crate::planner::MetaArena;
 use crate::storage::Transaction;
 use crate::types::tuple::Schema;
 
-pub struct Values {
-    rows: std::vec::IntoIter<ExprRef>,
+pub struct Values<'a> {
+    rows: std::slice::Iter<'a, ExprRef>,
     remaining_rows: usize,
-    schema_ref: Schema,
+    schema_ref: &'a Schema,
 }
 
-impl From<ValuesOperator> for Values {
+impl<'a> From<&'a ValuesOperator> for Values<'a> {
     fn from(
         ValuesOperator {
             rows,
             row_count,
             schema_ref,
-        }: ValuesOperator,
+        }: &'a ValuesOperator,
     ) -> Self {
         Values {
-            rows: rows.into_iter(),
-            remaining_rows: row_count,
+            rows: rows.iter(),
+            remaining_rows: *row_count,
             schema_ref,
         }
     }
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Values {
-    type Input = Self;
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Values<'a> {
+    type Input = &'a ValuesOperator;
 
     fn into_executor(
         input: Self::Input,
@@ -52,12 +52,12 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Values {
         _: ExecutionContext<'_>,
         _: &T,
     ) -> ExecId {
-        let executor = input;
+        let executor = Values::from(input);
         arena.push(ExecNode::Values(executor))
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Values {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Values<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -77,7 +77,7 @@ impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Values {
             let ty = plan_arena.column(self.schema_ref[i]).datatype();
             output.values.push(
                 plan_arena
-                    .expression(expr)
+                    .expression(*expr)
                     .eval(plan_arena, None)?
                     .into_owned()
                     .cast(ty)?,
diff --git a/src/execution/dql/window.rs b/src/execution/dql/window.rs
index e31db988..a2011b26 100644
--- a/src/execution/dql/window.rs
+++ b/src/execution/dql/window.rs
@@ -66,18 +66,18 @@ impl WindowState {
     }
 }
 
-pub struct Window {
+pub struct Window<'a> {
     state: WindowState,
     retention: Retention,
-    sort_fields: Vec<SortField>,
+    sort_fields: &'a [SortField],
     partition_by_len: usize,
     functions: Vec<Box<dyn WindowFunction>>,
     input_exhausted: bool,
     input: ExecId,
 }
 
-impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Window {
-    type Input = (WindowOperator, LogicalPlan);
+impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Window<'a> {
+    type Input = (&'a WindowOperator, &'a LogicalPlan);
 
     fn into_executor(
         (operator, input): Self::Input,
@@ -98,20 +98,22 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Window {
             .any(|function| matches!(function.kind, WindowFunctionKind::Aggregate(_)));
         let retention = if !has_aggregate {
             Retention::Row
-        } else if sort_fields.len() == partition_by_len {
+        } else if sort_fields.len() == *partition_by_len {
             Retention::Partition
         } else {
             Retention::Peer
         };
         let functions = window_functions
-            .into_iter()
-            .map(|function| function::new(function.kind, function.args, function.ty))
+            .iter()
+            .map(|function| {
+                function::new(function.kind, function.args.clone(), function.ty.clone())
+            })
             .collect();
         arena.push(ExecNode::Window(Window {
             state: WindowState::default(),
             retention,
             sort_fields,
-            partition_by_len,
+            partition_by_len: *partition_by_len,
             functions,
             input_exhausted: false,
             input,
@@ -119,7 +121,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for Window {
     }
 }
 
-impl Window {
+impl<'a> Window<'a> {
     fn update_keys(
         &mut self,
         tuple: &Tuple,
@@ -217,7 +219,7 @@ impl Window {
     }
 }
 
-impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Window {
+impl<'a, T: Transaction + 'a> ExecutorNode<'a, T> for Window<'a> {
     fn next_tuple(
         &mut self,
         arena: &mut ExecArena<'a, T>,
@@ -269,12 +271,12 @@ mod tests {
         ))
     }
 
-    fn window(
+    fn window<'a>(
         retention: Retention,
-        sort_fields: Vec<SortField>,
+        sort_fields: &'a [SortField],
         partition_by_len: usize,
         functions: Vec<Box<dyn WindowFunction>>,
-    ) -> Window {
+    ) -> Window<'a> {
         Window {
             state: WindowState::default(),
             retention,
@@ -296,12 +298,13 @@ mod tests {
         let mut plan_arena = crate::planner::PlanArena::new(&table_arena);
         let partition = column(&mut plan_arena, 0);
         let order = column(&mut plan_arena, 1);
+        let sort_fields = [
+            SortField::from(partition).asc(),
+            SortField::from(order).asc(),
+        ];
         let mut window = window(
             Retention::Row,
-            vec![
-                SortField::from(partition).asc(),
-                SortField::from(order).asc(),
-            ],
+            &sort_fields,
             1,
             vec![
                 function::new(
@@ -326,12 +329,13 @@ mod tests {
         let mut plan_arena = crate::planner::PlanArena::new(&table_arena);
         let partition = column(&mut plan_arena, 0);
         let value = column(&mut plan_arena, 1);
+        let sort_fields = [
+            SortField::from(partition).asc(),
+            SortField::from(value).asc(),
+        ];
         let mut window = window(
             Retention::Peer,
-            vec![
-                SortField::from(partition).asc(),
-                SortField::from(value).asc(),
-            ],
+            &sort_fields,
             1,
             vec![function::new(
                 WindowFunctionKind::Aggregate(AggKind::Sum),
@@ -353,9 +357,10 @@ mod tests {
         let mut plan_arena = crate::planner::PlanArena::new(&table_arena);
         let partition = column(&mut plan_arena, 0);
         let value = column(&mut plan_arena, 1);
+        let sort_fields = [SortField::from(partition).asc()];
         let mut window = window(
             Retention::Partition,
-            vec![SortField::from(partition).asc()],
+            &sort_fields,
             1,
             vec![function::new(
                 WindowFunctionKind::Aggregate(AggKind::Sum),
diff --git a/src/execution/mod.rs b/src/execution/mod.rs
index dc339cf3..3176cfb8 100644
--- a/src/execution/mod.rs
+++ b/src/execution/mod.rs
@@ -76,7 +76,7 @@ use crate::expression::ScalarExpression;
 use crate::planner::operator::join::JoinCondition;
 use crate::planner::operator::{Operator, PhysicalOption, PlanImpl};
 use crate::planner::MetaArena;
-use crate::planner::{ExprRef, LogicalPlan};
+use crate::planner::{ExprRef, LogicalPlan, PlanKeeper};
 use crate::storage::table_codec::TableCodec;
 use crate::storage::{StatisticsMetaCache, TableCache, Transaction, ViewCache};
 use crate::types::index::RuntimeIndexProbe;
@@ -164,11 +164,19 @@ impl RewriteExpression for ScalarExpression {
 pub struct Executor<'a, T: Transaction + 'a> {
     arena: ExecArena<'a, T>,
     root: ExecId,
+    // Never read: it only keeps the plan that `arena` borrows from alive, and must stay
+    // declared after `arena` so the executors are dropped before the plan is freed.
+    #[allow(dead_code)]
+    keeper: PlanKeeper<'a>,
 }
 
 impl<'a, T: Transaction + 'a> Executor<'a, T> {
-    pub(crate) fn new(arena: ExecArena<'a, T>, root: ExecId) -> Self {
-        Self { arena, root }
+    pub(crate) fn new(arena: ExecArena<'a, T>, root: ExecId, keeper: PlanKeeper<'a>) -> Self {
+        Self {
+            arena,
+            root,
+            keeper,
+        }
     }
 
     pub(crate) fn next_tuple(
@@ -188,36 +196,36 @@ impl<'a, T: Transaction + 'a> Executor<'a, T> {
 
 #[allow(clippy::large_enum_variant)]
 pub(crate) enum ExecNode<'a, T: Transaction + 'a> {
-    AddColumn(AddColumn),
-    Analyze(Analyze),
-    ChangeColumn(ChangeColumn),
+    AddColumn(AddColumn<'a>),
+    Analyze(Analyze<'a>),
+    ChangeColumn(ChangeColumn<'a>),
     #[cfg(feature = "copy")]
-    CopyFromFile(CopyFromFile),
+    CopyFromFile(CopyFromFile<'a>),
     #[cfg(feature = "copy")]
-    CopyToFile(CopyToFile),
-    CreateIndex(CreateIndex),
-    CreateTable(CreateTable),
-    CreateView(CreateView),
-    Delete(Delete),
+    CopyToFile(CopyToFile<'a>),
+    CreateIndex(CreateIndex<'a>),
+    CreateTable(CreateTable<'a>),
+    CreateView(CreateView<'a>),
+    Delete(Delete<'a>),
     Describe(Describe),
-    DropColumn(DropColumn),
-    DropIndex(DropIndex),
-    DropTable(DropTable),
-    DropView(DropView),
+    DropColumn(DropColumn<'a>),
+    DropIndex(DropIndex<'a>),
+    DropTable(DropTable<'a>),
+    DropView(DropView<'a>),
     Dummy(Dummy),
-    Explain(Explain),
+    Explain(Explain<'a>),
     #[cfg(feature = "spill")]
-    ExternalSort(ExternalSort),
+    ExternalSort(ExternalSort<'a>),
     Filter(Filter),
-    FunctionScan(FunctionScan),
-    HashAgg(HashAggExecutor),
+    FunctionScan(FunctionScan<'a>),
+    HashAgg(HashAggExecutor<'a>),
     HashJoin(HashJoin),
     IndexScan(IndexScan<'a, T>),
-    Insert(Insert),
+    Insert(Insert<'a>),
     Limit(Limit),
-    MarkApply(MarkApply),
-    NestedLoopJoin(NestedLoopJoin),
-    Projection(Projection),
+    MarkApply(MarkApply<'a>),
+    NestedLoopJoin(NestedLoopJoin<'a>),
+    Projection(Projection<'a>),
     RecursiveCte(RecursiveCte<'a, T>),
     RecursiveScan(RecursiveScan),
     ScalarApply(ScalarApply),
@@ -226,16 +234,16 @@ pub(crate) enum ExecNode<'a, T: Transaction + 'a> {
     SeqScan(SeqScan<'a, T>),
     ShowTables(ShowTables<'a, T>),
     ShowViews(ShowViews<'a, T>),
-    SimpleAgg(SimpleAggExecutor),
-    Sort(Sort),
-    StreamAgg(StreamAggExecutor),
-    StreamDistinct(StreamDistinctExecutor),
-    TopK(TopK),
-    Truncate(Truncate),
+    SimpleAgg(SimpleAggExecutor<'a>),
+    Sort(Sort<'a>),
+    StreamAgg(StreamAggExecutor<'a>),
+    StreamDistinct(StreamDistinctExecutor<'a>),
+    TopK(TopK<'a>),
+    Truncate(Truncate<'a>),
     Union(Union),
-    Update(Update),
-    Values(Values),
-    Window(Window),
+    Update(Update<'a>),
+    Values(Values<'a>),
+    Window(Window<'a>),
 }
 
 pub(crate) trait ExecutorNode<'a, T: Transaction + 'a>: Sized {
@@ -301,20 +309,20 @@ impl<'a, T: Transaction + 'a> ExecNode<'a, T> {
                 <Dummy as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::Explain(exec) => {
-                <Explain as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <Explain<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             #[cfg(feature = "spill")]
             ExecNode::ExternalSort(exec) => {
-                <ExternalSort as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <ExternalSort<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::Filter(exec) => {
                 <Filter as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::FunctionScan(exec) => {
-                <FunctionScan as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <FunctionScan<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::HashAgg(exec) => {
-                <HashAggExecutor as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <HashAggExecutor<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::HashJoin(exec) => {
                 <HashJoin as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
@@ -329,13 +337,13 @@ impl<'a, T: Transaction + 'a> ExecNode<'a, T> {
                 <Limit as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::MarkApply(exec) => {
-                <MarkApply as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <MarkApply<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::NestedLoopJoin(exec) => {
-                <NestedLoopJoin as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <NestedLoopJoin<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::Projection(exec) => {
-                <Projection as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <Projection<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::RecursiveCte(exec) => {
                 <RecursiveCte<'a, T> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
@@ -362,19 +370,21 @@ impl<'a, T: Transaction + 'a> ExecNode<'a, T> {
                 <ShowViews<'a, T> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::SimpleAgg(exec) => {
-                <SimpleAggExecutor as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <SimpleAggExecutor<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::Sort(exec) => {
-                <Sort as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <Sort<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::StreamAgg(exec) => {
-                <StreamAggExecutor as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <StreamAggExecutor<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::StreamDistinct(exec) => {
-                <StreamDistinctExecutor as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <StreamDistinctExecutor<'a> as ExecutorNode<'a, T>>::next_tuple(
+                    exec, arena, plan_arena,
+                )
             }
             ExecNode::TopK(exec) => {
-                <TopK as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <TopK<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::Truncate(exec) => {
                 <Truncate as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
@@ -383,13 +393,13 @@ impl<'a, T: Transaction + 'a> ExecNode<'a, T> {
                 <Union as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::Update(exec) => {
-                <Update as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <Update<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::Values(exec) => {
-                <Values as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <Values<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
             ExecNode::Window(exec) => {
-                <Window as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
+                <Window<'a> as ExecutorNode<'a, T>>::next_tuple(exec, arena, plan_arena)
             }
         }
     }
@@ -489,6 +499,10 @@ impl<'b, 'a, T: Transaction + 'a> ExecArenaLocalState<'b, 'a, T> {
 }
 
 impl<'a, T: Transaction + 'a> ExecArena<'a, T> {
+    pub(crate) fn set_statement_stamp(&mut self, stamp: u64) {
+        self.table_codec.set_stamp(stamp);
+    }
+
     pub(crate) fn new() -> Self {
         Self {
             nodes: ExecNodes {
@@ -718,39 +732,33 @@ pub(crate) trait WriteExecutor<'a, T: Transaction + 'a>: Sized {
 pub(crate) fn build_read<'a, T>(
     arena: &mut ExecArena<'a, T>,
     plan_arena: &mut (dyn MetaArena + 'a),
-    plan: LogicalPlan,
+    plan: &'a LogicalPlan,
     cache: ExecutionContext<'_>,
     transaction: &T,
 ) -> ExecId
 where
     T: Transaction + 'a,
 {
-    let LogicalPlan {
-        operator,
-        childrens,
-        physical_option,
-        ..
-    } = plan;
-
-    match operator {
-        Operator::Dummy => <Dummy as ReadExecutor<'a, T>>::into_executor(
-            Dummy::default(),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
+    macro_rules! read {
+        ($executor:ty, $input:expr) => {
+            <$executor as ReadExecutor<'a, T>>::into_executor(
+                $input,
+                arena,
+                plan_arena,
+                cache,
+                transaction,
+            )
+        };
+    }
+
+    let physical_option = plan.physical_option.as_ref();
+    match &plan.operator {
+        Operator::Dummy => read!(Dummy, ()),
         Operator::Aggregate(op) => {
-            let input = childrens.pop_only();
+            let input = plan.childrens.only();
 
             if op.groupby_exprs.is_empty() {
-                <SimpleAggExecutor as ReadExecutor<'a, T>>::into_executor(
-                    (op, input),
-                    arena,
-                    plan_arena,
-                    cache,
-                    transaction,
-                )
+                read!(SimpleAggExecutor<'a>, (op, input))
             } else if op.is_distinct
                 && op.agg_calls.is_empty()
                 && matches!(
@@ -761,13 +769,7 @@ where
                     })
                 )
             {
-                <StreamDistinctExecutor as ReadExecutor<'a, T>>::into_executor(
-                    (op, input),
-                    arena,
-                    plan_arena,
-                    cache,
-                    transaction,
-                )
+                read!(StreamDistinctExecutor<'a>, (op, input))
             } else if matches!(
                 physical_option,
                 Some(PhysicalOption {
@@ -775,49 +777,19 @@ where
                     ..
                 })
             ) {
-                <StreamAggExecutor as ReadExecutor<'a, T>>::into_executor(
-                    (op, input),
-                    arena,
-                    plan_arena,
-                    cache,
-                    transaction,
-                )
+                read!(StreamAggExecutor<'a>, (op, input))
             } else {
-                <HashAggExecutor as ReadExecutor<'a, T>>::into_executor(
-                    (op, input),
-                    arena,
-                    plan_arena,
-                    cache,
-                    transaction,
-                )
+                read!(HashAggExecutor<'a>, (op, input))
             }
         }
-        Operator::Filter(op) => <Filter as ReadExecutor<'a, T>>::into_executor(
-            (op, childrens.pop_only()),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
+        Operator::Filter(op) => read!(Filter, (op, plan.childrens.only())),
         Operator::ScalarApply(op) => {
-            let (left, right) = childrens.pop_twins();
-            <ScalarApply as ReadExecutor<'a, T>>::into_executor(
-                (op, left, right),
-                arena,
-                plan_arena,
-                cache,
-                transaction,
-            )
+            let (left, right) = plan.childrens.twins();
+            read!(ScalarApply, (op, left, right))
         }
         Operator::MarkApply(op) => {
-            let (left, right) = childrens.pop_twins();
-            <MarkApply as ReadExecutor<'a, T>>::into_executor(
-                (op, left, right),
-                arena,
-                plan_arena,
-                cache,
-                transaction,
-            )
+            let (left, right) = plan.childrens.twins();
+            read!(MarkApply<'a>, (op, left, right))
         }
         Operator::Join(op) => {
             let use_hash_join = matches!(
@@ -830,186 +802,57 @@ where
                     ..
                 })
             );
-            let (left, right) = childrens.pop_twins();
+            let (left, right) = plan.childrens.twins();
 
             if use_hash_join {
-                <HashJoin as ReadExecutor<'a, T>>::into_executor(
-                    HashJoin::from((op, left, right)),
-                    arena,
-                    plan_arena,
-                    cache,
-                    transaction,
-                )
+                read!(HashJoin, (op, left, right))
             } else {
-                <NestedLoopJoin as ReadExecutor<'a, T>>::into_executor(
-                    NestedLoopJoin::from((op, left, right)),
-                    arena,
-                    plan_arena,
-                    cache,
-                    transaction,
-                )
+                read!(NestedLoopJoin<'a>, (op, left, right))
             }
         }
-        Operator::Project(op) => <Projection as ReadExecutor<'a, T>>::into_executor(
-            (op, childrens.pop_only()),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::ScalarSubquery(op) => <ScalarSubquery as ReadExecutor<'a, T>>::into_executor(
-            (op, childrens.pop_only()),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
+        Operator::Project(op) => read!(Projection<'a>, (op, plan.childrens.only())),
+        Operator::ScalarSubquery(op) => {
+            read!(ScalarSubquery, (op, plan.childrens.only()))
+        }
         Operator::TableScan(op) => {
             if let Some(PhysicalOption {
-                plan: PlanImpl::IndexScan(index_info),
+                plan: PlanImpl::IndexScan(info),
                 ..
             }) = physical_option
             {
-                if let Some(lookup) = index_info.lookup.clone() {
-                    return <IndexScan<'a, T> as ReadExecutor<'a, T>>::into_executor(
-                        IndexScan::from((
-                            op,
-                            index_info.meta,
-                            lookup,
-                            index_info.covered_deserializers.clone(),
-                            index_info.cover_mapping.clone(),
-                        )),
-                        arena,
-                        plan_arena,
-                        cache,
-                        transaction,
-                    );
+                if let Some(lookup) = &info.lookup {
+                    return read!(IndexScan<'a, T>, (op, info.as_ref(), lookup));
                 }
             }
-
-            <SeqScan<'a, T> as ReadExecutor<'a, T>>::into_executor(
-                SeqScan::from(op),
-                arena,
-                plan_arena,
-                cache,
-                transaction,
-            )
+            read!(SeqScan<'a, T>, op)
         }
-        Operator::FunctionScan(op) => <FunctionScan as ReadExecutor<'a, T>>::into_executor(
-            FunctionScan::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
+        Operator::FunctionScan(op) => read!(FunctionScan<'a>, op),
         Operator::Sort(op) => {
             #[cfg(feature = "spill")]
             {
-                <ExternalSort as ReadExecutor<'a, T>>::into_executor(
-                    (op, childrens.pop_only()),
-                    arena,
-                    plan_arena,
-                    cache,
-                    transaction,
-                )
+                read!(ExternalSort<'a>, (op, plan.childrens.only()))
             }
             #[cfg(not(feature = "spill"))]
             {
-                <Sort as ReadExecutor<'a, T>>::into_executor(
-                    (op, childrens.pop_only()),
-                    arena,
-                    plan_arena,
-                    cache,
-                    transaction,
-                )
+                read!(Sort<'a>, (op, plan.childrens.only()))
             }
         }
-        Operator::Limit(op) => <Limit as ReadExecutor<'a, T>>::into_executor(
-            (op, childrens.pop_only()),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::TopK(op) => <TopK as ReadExecutor<'a, T>>::into_executor(
-            (op, childrens.pop_only()),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::Values(op) => <Values as ReadExecutor<'a, T>>::into_executor(
-            Values::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::Window(op) => <Window as ReadExecutor<'a, T>>::into_executor(
-            (op, childrens.pop_only()),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::ShowTable => <ShowTables<'a, T> as ReadExecutor<'a, T>>::into_executor(
-            ShowTables { metas: None },
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::ShowView => <ShowViews<'a, T> as ReadExecutor<'a, T>>::into_executor(
-            ShowViews { metas: None },
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::Explain => <Explain as ReadExecutor<'a, T>>::into_executor(
-            Explain::from(childrens.pop_only()),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::Describe(op) => <Describe as ReadExecutor<'a, T>>::into_executor(
-            Describe::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::Union(_) => <Union as ReadExecutor<'a, T>>::into_executor(
-            Union::from(childrens.pop_twins()),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::RecursiveCte(_) => <RecursiveCte<'a, T> as ReadExecutor<'a, T>>::into_executor(
-            childrens.pop_twins(),
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
-        Operator::RecursiveScan(op) => <RecursiveScan as ReadExecutor<'a, T>>::into_executor(
-            op,
-            arena,
-            plan_arena,
-            cache,
-            transaction,
-        ),
+        Operator::Limit(op) => read!(Limit, (op, plan.childrens.only())),
+        Operator::TopK(op) => read!(TopK<'a>, (op, plan.childrens.only())),
+        Operator::Values(op) => read!(Values<'a>, op),
+        Operator::Window(op) => read!(Window<'a>, (op, plan.childrens.only())),
+        Operator::ShowTable => read!(ShowTables<'a, T>, ()),
+        Operator::ShowView => read!(ShowViews<'a, T>, ()),
+        Operator::Explain => read!(Explain<'a>, plan.childrens.only()),
+        Operator::Describe(op) => read!(Describe, op),
+        Operator::Union(_) => read!(Union, plan.childrens.twins()),
+        Operator::RecursiveCte(_) => {
+            read!(RecursiveCte<'a, T>, plan.childrens.twins())
+        }
+        Operator::RecursiveScan(op) => read!(RecursiveScan, op),
         Operator::SetMembership(op) => {
-            let (left, right) = childrens.pop_twins();
-            <SetMembership as ReadExecutor<'a, T>>::into_executor(
-                SetMembership::from((op.kind, left, right)),
-                arena,
-                plan_arena,
-                cache,
-                transaction,
-            )
+            let (left, right) = plan.childrens.twins();
+            read!(SetMembership, (op.kind, left, right))
         }
         _ => unreachable!(),
     }
@@ -1018,7 +861,7 @@ where
 pub(crate) fn build_write<'a, T>(
     arena: &mut ExecArena<'a, T>,
     plan_arena: &mut (dyn MetaArena + 'a),
-    plan: LogicalPlan,
+    plan: &'a LogicalPlan,
     cache: ExecutionContext<'a>,
     transaction: &'a mut T,
 ) -> ExecId
@@ -1027,157 +870,44 @@ where
 {
     arena.init_context(cache, transaction);
     let transaction_ref: &T = transaction;
-    let LogicalPlan {
-        operator,
-        childrens,
-        physical_option,
-        ..
-    } = plan;
-
-    match operator {
-        Operator::Insert(op) => {
-            let input = childrens.pop_only();
-
-            <Insert as WriteExecutor<'a, T>>::into_executor(
-                Insert::from((op, input)),
+    macro_rules! write {
+        ($executor:ty, $input:expr) => {
+            <$executor as WriteExecutor<'a, T>>::into_executor(
+                $input,
                 arena,
                 plan_arena,
                 cache,
                 transaction_ref,
             )
-        }
-        Operator::Update(op) => {
-            let input = childrens.pop_only();
-
-            <Update as WriteExecutor<'a, T>>::into_executor(
-                Update::from((op, input)),
-                arena,
-                plan_arena,
-                cache,
-                transaction_ref,
-            )
-        }
-        Operator::Delete(op) => {
-            let input = childrens.pop_only();
-
-            <Delete as WriteExecutor<'a, T>>::into_executor(
-                Delete::from((op, input)),
-                arena,
-                plan_arena,
-                cache,
-                transaction_ref,
-            )
-        }
-        Operator::AddColumn(op) => <AddColumn as WriteExecutor<'a, T>>::into_executor(
-            AddColumn::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction_ref,
-        ),
-        Operator::ChangeColumn(op) => <ChangeColumn as WriteExecutor<'a, T>>::into_executor(
-            ChangeColumn::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction_ref,
-        ),
-        Operator::DropColumn(op) => <DropColumn as WriteExecutor<'a, T>>::into_executor(
-            DropColumn::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction_ref,
-        ),
-        Operator::CreateTable(op) => <CreateTable as WriteExecutor<'a, T>>::into_executor(
-            CreateTable::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction_ref,
-        ),
-        Operator::CreateIndex(op) => {
-            let input = childrens.pop_only();
+        };
+    }
 
-            <CreateIndex as WriteExecutor<'a, T>>::into_executor(
-                CreateIndex::from((op, input)),
-                arena,
-                plan_arena,
-                cache,
-                transaction_ref,
-            )
-        }
-        Operator::CreateView(op) => <CreateView as WriteExecutor<'a, T>>::into_executor(
-            CreateView::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction_ref,
-        ),
-        Operator::DropTable(op) => <DropTable as WriteExecutor<'a, T>>::into_executor(
-            DropTable::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction_ref,
-        ),
-        Operator::DropView(op) => <DropView as WriteExecutor<'a, T>>::into_executor(
-            DropView::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction_ref,
-        ),
-        Operator::DropIndex(op) => <DropIndex as WriteExecutor<'a, T>>::into_executor(
-            DropIndex::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction_ref,
-        ),
-        Operator::Truncate(op) => <Truncate as WriteExecutor<'a, T>>::into_executor(
-            Truncate::from(op),
-            arena,
-            plan_arena,
-            cache,
-            transaction_ref,
-        ),
+    match &plan.operator {
+        Operator::Insert(op) => write!(Insert<'a>, (op, plan.childrens.only())),
+        Operator::Update(op) => write!(Update<'a>, (op, plan.childrens.only())),
+        Operator::Delete(op) => write!(Delete<'a>, (op, plan.childrens.only())),
+        Operator::AddColumn(op) => write!(AddColumn<'a>, op),
+        Operator::ChangeColumn(op) => write!(ChangeColumn<'a>, op),
+        Operator::DropColumn(op) => write!(DropColumn<'a>, op),
+        Operator::CreateTable(op) => write!(CreateTable<'a>, op),
+        Operator::CreateIndex(op) => write!(CreateIndex<'a>, (op, plan.childrens.only())),
+        Operator::CreateView(op) => write!(CreateView<'a>, op),
+        Operator::DropTable(op) => write!(DropTable<'a>, op),
+        Operator::DropView(op) => write!(DropView<'a>, op),
+        Operator::DropIndex(op) => write!(DropIndex<'a>, op),
+        Operator::Truncate(op) => write!(Truncate<'a>, op),
+        #[cfg(feature = "copy")]
+        Operator::CopyFromFile(op) => write!(CopyFromFile<'a>, op),
         #[cfg(feature = "copy")]
-        Operator::CopyFromFile(op) => <CopyFromFile as WriteExecutor<'a, T>>::into_executor(
-            CopyFromFile::from(op),
+        Operator::CopyToFile(op) => <CopyToFile<'a> as ReadExecutor<'a, T>>::into_executor(
+            (op, plan.childrens.only()),
             arena,
             plan_arena,
             cache,
             transaction_ref,
         ),
-        #[cfg(feature = "copy")]
-        Operator::CopyToFile(op) => {
-            let input = childrens.pop_only();
-
-            <CopyToFile as ReadExecutor<'a, T>>::into_executor(
-                CopyToFile::from((op, input)),
-                arena,
-                plan_arena,
-                cache,
-                transaction_ref,
-            )
-        }
-        Operator::Analyze(op) => {
-            let input = childrens.pop_only();
-
-            <Analyze as WriteExecutor<'a, T>>::into_executor(
-                Analyze::from((op, input)),
-                arena,
-                plan_arena,
-                cache,
-                transaction_ref,
-            )
-        }
-        operator => {
-            let mut plan = LogicalPlan::new(operator, *childrens);
-            plan.physical_option = physical_option;
-            build_read(arena, plan_arena, plan, cache, transaction_ref)
-        }
+        Operator::Analyze(op) => write!(Analyze<'a>, (op, plan.childrens.only())),
+        _ => build_read(arena, plan_arena, plan, cache, transaction_ref),
     }
 }
 
@@ -1215,56 +945,6 @@ mod test_utils {
         }
     }
 
-    pub(crate) fn execute<'a, T, E>(
-        executor: E,
-        cache: ExecutionContext<'a>,
-        mut plan_arena: PlanArena<'a>,
-        transaction: &'a T,
-    ) -> TestExecutor<'a, T>
-    where
-        T: Transaction + 'a,
-        E: ReadExecutor<'a, T, Input = E>,
-    {
-        let mut arena = ExecArena::new();
-        arena.init_context(cache, transaction);
-        let root = <E as ReadExecutor<'a, T>>::into_executor(
-            executor,
-            &mut arena,
-            &mut plan_arena,
-            cache,
-            transaction,
-        );
-        TestExecutor {
-            executor: Executor::new(arena, root),
-            plan_arena,
-        }
-    }
-
-    pub(crate) fn execute_mut<'a, T, E>(
-        executor: E,
-        cache: ExecutionContext<'a>,
-        mut plan_arena: PlanArena<'a>,
-        transaction: &'a T,
-    ) -> TestExecutor<'a, T>
-    where
-        T: Transaction + 'a,
-        E: WriteExecutor<'a, T, Input = E>,
-    {
-        let mut arena = ExecArena::new();
-        arena.init_context(cache, transaction);
-        let root = <E as WriteExecutor<'a, T>>::into_executor(
-            executor,
-            &mut arena,
-            &mut plan_arena,
-            cache,
-            transaction,
-        );
-        TestExecutor {
-            executor: Executor::new(arena, root),
-            plan_arena,
-        }
-    }
-
     pub(crate) fn execute_input<'a, T, E>(
         input: E::Input,
         cache: ExecutionContext<'a>,
@@ -1285,7 +965,7 @@ mod test_utils {
             transaction,
         );
         TestExecutor {
-            executor: Executor::new(arena, root),
+            executor: Executor::new(arena, root, PlanKeeper::empty()),
             plan_arena,
         }
     }
@@ -1311,7 +991,7 @@ mod test_utils {
             transaction,
         );
         TestExecutor {
-            executor: Executor::new(arena, root),
+            executor: Executor::new(arena, root, PlanKeeper::empty()),
             plan_arena,
         }
     }
@@ -1331,9 +1011,7 @@ mod test_utils {
 
 #[cfg(all(test, not(target_arch = "wasm32")))]
 #[allow(unused_imports)]
-pub(crate) use test_utils::{
-    empty_context, execute, execute_input, execute_input_mut, execute_mut, try_collect,
-};
+pub(crate) use test_utils::{empty_context, execute_input, execute_input_mut, try_collect};
 
 #[cfg(test)]
 mod test {
diff --git a/src/expression/range_detacher.rs b/src/expression/range_detacher.rs
index a679a602..6aa3b966 100644
--- a/src/expression/range_detacher.rs
+++ b/src/expression/range_detacher.rs
@@ -200,22 +200,22 @@ fn build_tree<'a, T: Borrow<DataValue> + 'a, I: EqRangeInput<T> + ?Sized>(
 }
 
 impl Range {
-    pub(crate) fn bind_parameters(
-        &mut self,
-        params: &[(usize, DataValue)],
-    ) -> Result<(), DatabaseError> {
+    pub(crate) fn bind_parameters<'p, F>(&mut self, get: &F) -> Result<(), DatabaseError>
+    where
+        F: Fn(usize) -> Option<&'p DataValue>,
+    {
         match self {
             Self::Scope { min, max } => {
                 for bound in [min, max] {
                     if let Bound::Included(value) | Bound::Excluded(value) = bound {
-                        value.bind_parameters(params)?;
+                        value.bind_parameters(get)?;
                     }
                 }
             }
-            Self::Eq(value) => value.bind_parameters(params)?,
+            Self::Eq(value) => value.bind_parameters(get)?,
             Self::SortedRanges(ranges) => {
                 for range in ranges {
-                    range.bind_parameters(params)?;
+                    range.bind_parameters(get)?;
                 }
             }
             Self::Dummy => {}
diff --git a/src/optimizer/rule/normalization/elimination.rs b/src/optimizer/rule/normalization/elimination.rs
index 045a0e45..18d0a6b2 100644
--- a/src/optimizer/rule/normalization/elimination.rs
+++ b/src/optimizer/rule/normalization/elimination.rs
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 use crate::errors::DatabaseError;
+use crate::expression::ScalarExpression;
 use crate::optimizer::core::rule::NormalizationRule;
 use crate::optimizer::plan_utils::{only_child_mut, replace_with_only_child, wrap_child_with};
 use crate::planner::operator::limit::LimitOperator;
@@ -44,7 +45,7 @@ impl NormalizationRule for EliminateRedundantSort {
             None => return Ok(false),
         };
         mark_sort_preserving_indexes(child, &sort_fields, arena)?;
-        let can_remove = ensure_order(child, &sort_fields, arena);
+        let can_remove = ensure_order(child, &sort_fields, true, arena);
 
         if !can_remove {
             return Ok(false);
@@ -188,7 +189,10 @@ pub(crate) fn apply_scan_order_hint(
         return Ok(());
     }
     for index_info in scan_op.index_infos.iter_mut() {
-        if hint_covers(required, &index_info.sort_option, arena) {
+        if hint_covers(required, &index_info.sort_option, arena)
+            || (matches!(hint, OrderHintKind::SortElimination)
+                && hint_covers_reversed(required, &index_info.sort_option, arena))
+        {
             let covered = hint_len(required);
             match hint {
                 OrderHintKind::SortElimination => {
@@ -233,6 +237,19 @@ fn hint_covers(
     }
 }
 
+fn hint_covers_reversed(
+    required: ScanOrderHint<'_>,
+    provided: &SortOption,
+    arena: &crate::planner::PlanArena,
+) -> bool {
+    match required {
+        ScanOrderHint::SortFields(fields) => covers(fields, provided, |required, provided| {
+            sort_field_matches_reversed(required, provided, arena)
+        }),
+        ScanOrderHint::GroupBy(_) => false,
+    }
+}
+
 pub(crate) fn groupby_sort_fields(groupby_exprs: &[ExprRef]) -> Vec<SortField> {
     groupby_exprs
         .iter()
@@ -275,7 +292,7 @@ impl NormalizationRule for UseStreamAggregate {
             Some(child) => child,
             None => return Ok(false),
         };
-        if !ensure_order(child, &required, arena) {
+        if !ensure_order(child, &required, false, arena) {
             return Ok(false);
         }
 
@@ -353,18 +370,34 @@ pub(crate) fn apply_annotated_post_rules(
 fn ensure_order(
     plan: &mut LogicalPlan,
     required: &[SortField],
+    allow_reverse: bool,
     arena: &crate::planner::PlanArena,
 ) -> bool {
     if let Some(PhysicalOption {
         plan: PlanImpl::IndexScan(index_info),
-        ..
-    }) = plan.physical_option.as_ref()
+        sort_option,
+    }) = plan.physical_option.as_mut()
     {
         if covers(required, &index_info.sort_option, |required, provided| {
             sort_field_matches(required, provided, arena)
         }) {
             return true;
         }
+        let scan_limited = matches!(
+            &plan.operator,
+            Operator::TableScan(scan) if scan.limit != (None, None)
+        );
+        if allow_reverse
+            && !scan_limited
+            && !index_info.is_reverse()
+            && covers(required, &index_info.sort_option, |required, provided| {
+                sort_field_matches_reversed(required, provided, arena)
+            })
+        {
+            index_info.reverse_order();
+            *sort_option = index_info.sort_option.clone();
+            return true;
+        }
     }
 
     if let Some(physical_option) = plan.physical_option.as_ref() {
@@ -377,8 +410,11 @@ fn ensure_order(
                 );
             }
             SortOption::Follow => {
+                // Limit keeps the first N rows in scan order. Reversing the scan below it
+                // would keep the last N rows instead, changing the result set.
+                let allow_reverse = allow_reverse && !matches!(plan.operator, Operator::Limit(_));
                 if let Childrens::Only(child) = plan.childrens.as_mut() {
-                    if ensure_order(child, required, arena) {
+                    if ensure_order(child, required, allow_reverse, arena) {
                         return true;
                     }
                 }
@@ -400,6 +436,23 @@ fn sort_field_matches(
         && required.expr.eq_ignore_colref_pos(provided.expr, arena)
 }
 
+fn sort_field_matches_reversed(
+    required: &SortField,
+    provided: &SortField,
+    arena: &crate::planner::PlanArena,
+) -> bool {
+    required.asc != provided.asc
+        && (required.nulls_first != provided.nulls_first || !expr_nullable(required.expr, arena))
+        && required.expr.eq_ignore_colref_pos(provided.expr, arena)
+}
+
+fn expr_nullable(expr: ExprRef, arena: &crate::planner::PlanArena) -> bool {
+    match arena.expression(expr) {
+        ScalarExpression::ColumnRef { column, .. } => arena.column(*column).nullable(),
+        _ => true,
+    }
+}
+
 pub(crate) fn covers<T>(
     required: &[T],
     provided: &SortOption,
@@ -449,6 +502,7 @@ mod tests {
     use crate::optimizer::core::rule::NormalizationRule;
     use crate::planner::operator::aggregate::AggregateOperator;
     use crate::planner::operator::filter::FilterOperator;
+    use crate::planner::operator::limit::LimitOperator;
     use crate::planner::operator::sort::{SortField, SortOperator};
     use crate::planner::operator::table_scan::TableScanOperator;
     use crate::planner::operator::top_k::TopKOperator;
@@ -764,6 +818,88 @@ mod tests {
         Ok(())
     }
 
+    fn desc_topk_plan(
+        arena: &mut crate::planner::PlanArena,
+        nullable: bool,
+    ) -> (LogicalPlan, SortField) {
+        let mut column = ColumnCatalog::new_dummy("c1".to_string());
+        column.set_nullable(nullable);
+        let column = arena.alloc_column(column);
+        let index_field = SortField::new(
+            arena.alloc_expression(ScalarExpression::column_expr(column, 0)),
+            true,
+            false,
+        );
+        let required = SortField::new(index_field.expr, false, false);
+        let mut plan = build_plan(arena, vec![required.clone()], vec![index_field], 0);
+        plan.operator = Operator::TopK(TopKOperator {
+            sort_fields: vec![required.clone()],
+            limit: 1,
+            offset: None,
+        });
+        (plan, required)
+    }
+
+    fn scan_is_reverse(plan: &LogicalPlan) -> bool {
+        let mut plan = plan;
+        loop {
+            if let Some(PhysicalOption {
+                plan: PlanImpl::IndexScan(info),
+                ..
+            }) = &plan.physical_option
+            {
+                return info.is_reverse();
+            }
+            match plan.childrens.as_ref() {
+                Childrens::Only(child) => plan = child,
+                _ => return false,
+            }
+        }
+    }
+
+    #[test]
+    fn remove_desc_topk_by_reversing_non_null_index() -> Result<(), DatabaseError> {
+        let table_arena = crate::planner::TableArenaCell::default();
+        let mut arena = crate::planner::PlanArena::new(&table_arena);
+        let (mut plan, _) = desc_topk_plan(&mut arena, false);
+
+        assert!(EliminateRedundantSort.apply(&mut plan, &mut arena)?);
+        assert!(matches!(plan.operator, Operator::Limit(_)));
+        assert!(scan_is_reverse(&plan));
+        Ok(())
+    }
+
+    #[test]
+    fn keep_desc_topk_on_nullable_index() -> Result<(), DatabaseError> {
+        let table_arena = crate::planner::TableArenaCell::default();
+        let mut arena = crate::planner::PlanArena::new(&table_arena);
+        let (mut plan, _) = desc_topk_plan(&mut arena, true);
+
+        assert!(!EliminateRedundantSort.apply(&mut plan, &mut arena)?);
+        assert!(matches!(plan.operator, Operator::TopK(_)));
+        assert!(!scan_is_reverse(&plan));
+        Ok(())
+    }
+
+    #[test]
+    fn keep_desc_topk_when_limit_is_below() -> Result<(), DatabaseError> {
+        let table_arena = crate::planner::TableArenaCell::default();
+        let mut arena = crate::planner::PlanArena::new(&table_arena);
+        let (mut plan, _) = desc_topk_plan(&mut arena, false);
+        let Childrens::Only(filter) = plan.childrens.as_mut() else {
+            unreachable!()
+        };
+        filter.operator = Operator::Limit(LimitOperator {
+            offset: None,
+            limit: Some(3),
+        });
+        filter.physical_option = Some(PhysicalOption::new(PlanImpl::Limit, SortOption::Follow));
+
+        assert!(!EliminateRedundantSort.apply(&mut plan, &mut arena)?);
+        assert!(!scan_is_reverse(&plan));
+        Ok(())
+    }
+
     #[test]
     fn remove_sort_when_prefix_can_be_ignored() -> Result<(), DatabaseError> {
         let table_arena = crate::planner::TableArenaCell::default();
diff --git a/src/planner/arena.rs b/src/planner/arena.rs
index b96bb8e2..21b66dbb 100644
--- a/src/planner/arena.rs
+++ b/src/planner/arena.rs
@@ -145,6 +145,14 @@ pub trait MetaArena {
         panic!("parent expressions are immutable")
     }
 
+    fn has_bound_params(&self) -> bool {
+        false
+    }
+
+    fn bound_param(&self, _id: usize) -> Option<&DataValue> {
+        None
+    }
+
     fn alloc_dummy(&mut self, name: &str) -> ColumnRef {
         self.table_arena_cell().borrow().alloc_dummy(name)
     }
@@ -192,6 +200,12 @@ impl<A: MetaArena + ?Sized> MetaArena for Box<A> {
     {
         (**self).table_arena_cell()
     }
+    fn has_bound_params(&self) -> bool {
+        (**self).has_bound_params()
+    }
+    fn bound_param(&self, id: usize) -> Option<&DataValue> {
+        (**self).bound_param(id)
+    }
     fn alloc_column(&mut self, column: ColumnCatalog) -> ColumnRef {
         (**self).alloc_column(column)
     }
@@ -562,7 +576,11 @@ impl<'a> PlanArena<'a> {
     ) -> Result<(), crate::errors::DatabaseError> {
         for expression in &mut self.expressions {
             if let ScalarExpression::Constant(value) = &mut *(ArenaExprMut { expr: expression }) {
-                value.bind_parameters(params)?;
+                value.bind_parameters(&|id| {
+                    params
+                        .iter()
+                        .find_map(|(candidate, value)| (*candidate == id).then_some(value))
+                })?;
             }
         }
         Ok(())
@@ -825,7 +843,7 @@ impl MetaArena for PlanArena<'_> {
 /// Execution-local parameter values and temporary expressions over an immutable plan arena.
 pub(crate) struct ParamArena<'a> {
     parent: &'a PlanArena<'a>,
-    expressions: Vec<ArenaExpr>,
+    expressions: Vec<(Option<usize>, ArenaExpr)>,
     parameter_count: usize,
     parent_end: usize,
 }
@@ -839,12 +857,19 @@ impl<'a> ParamArena<'a> {
         let mut expressions = Vec::with_capacity(parameter_expressions.len());
         for (slot, &expr_ref) in parameter_expressions.iter().enumerate() {
             debug_assert_eq!(parent.arena_expression(expr_ref).param, Some(slot));
-            let ScalarExpression::Constant(value) = parent.expression(expr_ref) else {
-                unreachable!("parameter expression must be a constant");
+            let ScalarExpression::Constant(value @ DataValue::Parameter { id, .. }) =
+                parent.expression(expr_ref)
+            else {
+                unreachable!("parameter expression must be a single parameter constant");
             };
+            let id = *id;
             let mut value = value.clone();
-            value.bind_parameters(params)?;
-            expressions.push(ArenaExpr::new(ScalarExpression::Constant(value)));
+            value.bind_parameters(&|id| {
+                params
+                    .iter()
+                    .find_map(|(candidate, value)| (*candidate == id).then_some(value))
+            })?;
+            expressions.push((Some(id), ArenaExpr::new(ScalarExpression::Constant(value))));
         }
         Ok(Self {
             parent,
@@ -862,6 +887,17 @@ impl MetaArena for ParamArena<'_> {
     {
         self.parent.table_arena_cell()
     }
+    fn has_bound_params(&self) -> bool {
+        true
+    }
+    fn bound_param(&self, id: usize) -> Option<&DataValue> {
+        self.expressions
+            .iter()
+            .find_map(|(slot, expr)| match (slot, &expr.expression) {
+                (Some(slot), ScalarExpression::Constant(value)) if *slot == id => Some(value),
+                _ => None,
+            })
+    }
     fn column(&self, column: ColumnRef) -> &ColumnCatalog {
         self.parent.column(column)
     }
@@ -878,14 +914,16 @@ impl MetaArena for ParamArena<'_> {
         if expr.pos() < self.parent_end {
             let parent = self.parent.arena_expression(expr);
             return match parent.param {
-                Some(slot) => &self.expressions[slot].expression,
+                Some(slot) => &self.expressions[slot].1.expression,
                 None => &parent.expression,
             };
         }
-        &self.expressions[self.parameter_count + expr.pos() - self.parent_end].expression
+        &self.expressions[self.parameter_count + expr.pos() - self.parent_end]
+            .1
+            .expression
     }
     fn expression_mut(&mut self, expr: ExprRef) -> ArenaExprMut<'_> {
-        let index = if expr.pos() < self.parent_end {
+        let expr = if expr.pos() < self.parent_end {
             self.parent
                 .arena_expression(expr)
                 .param
@@ -894,12 +932,12 @@ impl MetaArena for ParamArena<'_> {
             self.parameter_count + expr.pos() - self.parent_end
         };
         ArenaExprMut {
-            expr: &mut self.expressions[index],
+            expr: &mut self.expressions[expr].1,
         }
     }
     fn alloc_expression(&mut self, expression: ScalarExpression) -> ExprRef {
         let id = ExprRef::new(self.parent_end + self.expressions.len() - self.parameter_count);
-        self.expressions.push(ArenaExpr::new(expression));
+        self.expressions.push((None, ArenaExpr::new(expression)));
         id
     }
     fn alloc_column(&mut self, _: ColumnCatalog) -> ColumnRef {
@@ -951,11 +989,10 @@ mod tests {
         let mut parent = PlanArena::new(&root);
         let id = parent.alloc_expression(ScalarExpression::Constant(DataValue::Int32(1)));
         assert_eq!(parent.arena_expression(id).param, None);
-        *parent.expression_mut(id) =
-            ScalarExpression::Constant(DataValue::Tuple(vec![DataValue::Parameter {
-                id: 1,
-                ty: LogicalType::Integer,
-            }]));
+        *parent.expression_mut(id) = ScalarExpression::Constant(DataValue::Parameter {
+            id: 1,
+            ty: LogicalType::Integer,
+        });
         let parameter_expressions = parent.parameter_expressions();
         assert_eq!(parent.arena_expression(id).param, Some(0));
         {
@@ -963,7 +1000,7 @@ mod tests {
                 ParamArena::new(&parent, &parameter_expressions, &[(1, DataValue::Int32(7))])?;
             assert_eq!(
                 bound.expression(id),
-                &ScalarExpression::Constant(DataValue::Tuple(vec![DataValue::Int32(7)]))
+                &ScalarExpression::Constant(DataValue::Int32(7))
             );
         }
         *parent.expression_mut(id) = ScalarExpression::Constant(DataValue::Int32(2));
diff --git a/src/planner/mod.rs b/src/planner/mod.rs
index 2e95e613..484e5585 100644
--- a/src/planner/mod.rs
+++ b/src/planner/mod.rs
@@ -14,6 +14,7 @@
 
 mod arena;
 pub mod operator;
+mod plan_keeper;
 
 use crate::catalog::TableName;
 use crate::errors::DatabaseError;
@@ -30,6 +31,7 @@ use std::hash::{Hash, Hasher};
 
 pub use arena::{ExprRef, MetaArena, PlanArena, TableArena, TableArenaCell};
 pub(crate) use arena::{ParamArena, PlanRef};
+pub(crate) use plan_keeper::{PlanInput, PlanKeeper};
 
 pub(crate) trait Explain {
     fn fmt(&self, arena: &(dyn MetaArena + '_), f: &mut fmt::Formatter<'_>) -> fmt::Result;
@@ -86,6 +88,20 @@ impl Childrens {
         }
     }
 
+    pub(crate) fn only(&self) -> &LogicalPlan {
+        match self {
+            Childrens::Only(plan) => plan,
+            _ => unreachable!(),
+        }
+    }
+
+    pub(crate) fn twins(&self) -> (&LogicalPlan, &LogicalPlan) {
+        match self {
+            Childrens::Twins { left, right } => (left, right),
+            _ => unreachable!(),
+        }
+    }
+
     pub fn pop_only(self) -> LogicalPlan {
         match self {
             Childrens::Only(plan) => *plan,
@@ -213,18 +229,6 @@ impl LogicalPlan {
         output_schema.get_or_insert_with(|| Self::compute_output_schema(operator, childrens, arena))
     }
 
-    pub fn take_schema(&mut self, arena: &mut (dyn MetaArena + '_)) -> crate::types::tuple::Schema {
-        let LogicalPlan {
-            operator,
-            childrens,
-            output_schema,
-            ..
-        } = self;
-        output_schema
-            .take()
-            .unwrap_or_else(|| Self::compute_output_schema(operator, childrens, arena))
-    }
-
     fn compute_output_schema(
         operator: &mut Operator,
         childrens: &mut Childrens,
@@ -349,6 +353,24 @@ impl LogicalPlan {
             .collect()
     }
 
+    pub(crate) fn read_schema(&self) -> &crate::types::tuple::Schema {
+        self.output_schema
+            .as_ref()
+            .expect("output schema must be computed before it is read")
+    }
+
+    pub(crate) fn populate_output_schema_recursive(&mut self, arena: &mut (dyn MetaArena + '_)) {
+        match self.childrens.as_mut() {
+            Childrens::Only(child) => child.populate_output_schema_recursive(arena),
+            Childrens::Twins { left, right } => {
+                left.populate_output_schema_recursive(arena);
+                right.populate_output_schema_recursive(arena);
+            }
+            Childrens::None => (),
+        }
+        self.output_schema(arena);
+    }
+
     pub fn reset_output_schema_cache(&mut self) {
         self.output_schema = None;
     }
diff --git a/src/planner/operator/copy_from_file.rs b/src/planner/operator/copy_from_file.rs
index 5e00ca92..a6c3418d 100644
--- a/src/planner/operator/copy_from_file.rs
+++ b/src/planner/operator/copy_from_file.rs
@@ -15,7 +15,7 @@
 use crate::binder::copy::ExtSource;
 use crate::catalog::TableName;
 use crate::planner::MetaArena;
-use crate::planner::{fmt_explain_list, Explain, PlanArena};
+use crate::planner::{fmt_explain_list, Explain};
 use crate::types::tuple::Schema;
 use kite_sql_serde_macros::ReferenceSerialization;
 
diff --git a/src/planner/operator/mod.rs b/src/planner/operator/mod.rs
index 478947ac..c038066e 100644
--- a/src/planner/operator/mod.rs
+++ b/src/planner/operator/mod.rs
@@ -157,7 +157,7 @@ pub enum SortOption {
 #[derive(Debug, PartialEq, Eq, Clone, Hash, ReferenceSerialization)]
 pub struct PhysicalOption {
     pub plan: PlanImpl,
-    sort_option: SortOption,
+    pub(crate) sort_option: SortOption,
 }
 
 impl PhysicalOption {
diff --git a/src/planner/plan_keeper.rs b/src/planner/plan_keeper.rs
new file mode 100644
index 00000000..60e0dc2c
--- /dev/null
+++ b/src/planner/plan_keeper.rs
@@ -0,0 +1,73 @@
+// Copyright 2024 KipData/KiteSQL
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::planner::LogicalPlan;
+
+#[allow(clippy::large_enum_variant)]
+pub(crate) enum PlanInput<'p> {
+    Owned(LogicalPlan),
+    Borrowed(&'p LogicalPlan),
+}
+
+impl From<LogicalPlan> for PlanInput<'_> {
+    fn from(plan: LogicalPlan) -> Self {
+        PlanInput::Owned(plan)
+    }
+}
+
+pub(crate) struct PlanKeeper<'p> {
+    owned: *mut LogicalPlan,
+    borrowed: Option<&'p LogicalPlan>,
+}
+
+impl<'p> PlanKeeper<'p> {
+    #[cfg(all(test, not(target_arch = "wasm32")))]
+    pub(crate) fn empty() -> Self {
+        Self {
+            owned: std::ptr::null_mut(),
+            borrowed: None,
+        }
+    }
+
+    pub(crate) fn new(input: PlanInput<'p>) -> Self {
+        match input {
+            PlanInput::Owned(plan) => Self {
+                owned: Box::into_raw(Box::new(plan)),
+                borrowed: None,
+            },
+            PlanInput::Borrowed(plan) => Self {
+                owned: std::ptr::null_mut(),
+                borrowed: Some(plan),
+            },
+        }
+    }
+
+    pub(crate) fn plan(&self) -> &'p LogicalPlan {
+        match self.borrowed {
+            Some(plan) => plan,
+            // SAFETY: `owned` is a heap allocation freed only in `Drop`, and is
+            // never moved or mutated afterwards.
+            None => unsafe { &*self.owned },
+        }
+    }
+}
+
+impl Drop for PlanKeeper<'_> {
+    fn drop(&mut self) {
+        if !self.owned.is_null() {
+            // SAFETY: `owned` comes from `Box::into_raw` and is only freed here.
+            drop(unsafe { Box::from_raw(self.owned) });
+        }
+    }
+}
diff --git a/src/storage/lmdb.rs b/src/storage/lmdb.rs
index 39659355..6cfa872c 100644
--- a/src/storage/lmdb.rs
+++ b/src/storage/lmdb.rs
@@ -15,14 +15,13 @@
 use crate::errors::DatabaseError;
 use crate::storage::table_codec::Bytes;
 use crate::storage::{
-    bytes_bound_as_slice, owned_bound, reuse_bound_as_excluded, InnerIter, KeyValueRef, Storage,
+    bounds_contain, bytes_bound_as_slice, owned_bound, InnerIter, KeyValueRef, Storage,
     Transaction, TransactionIsolationLevel,
 };
 use lmdb::{
     Cursor, Database, DatabaseFlags, Environment, EnvironmentFlags, RoCursor, RwTransaction,
     Transaction as _, WriteFlags,
 };
-use std::cmp::Ordering;
 use std::collections::Bound;
 use std::fmt::{self, Display, Formatter};
 use std::fs;
@@ -133,7 +132,11 @@ impl Storage for LmdbStorage {
         self.validate_transaction_isolation(isolation)?;
         let tx = self.env.begin_rw_txn()?;
 
-        Ok(LmdbTransaction { tx, db: self.db })
+        Ok(LmdbTransaction {
+            tx,
+            db: self.db,
+            statements: 0,
+        })
     }
 
     fn default_transaction_isolation(&self) -> TransactionIsolationLevel {
@@ -161,45 +164,115 @@ impl Storage for LmdbStorage {
 pub struct LmdbTransaction<'env> {
     tx: RwTransaction<'env>,
     db: Database,
+    statements: u64,
 }
 
 pub struct LmdbIter<'txn> {
-    _cursor: RoCursor<'txn>,
-    iter: lmdb::Iter<'txn>,
-    pending: Option<(&'txn [u8], &'txn [u8])>,
-    max: Bound<Bytes>,
-    done: bool,
+    cursor: RoCursor<'txn>,
+    scan: Scan,
 }
 
-impl LmdbIter<'_> {
-    fn next_visible(&mut self) -> Option<(&[u8], &[u8])> {
-        if let Some(entry) = self.pending.take() {
-            if within_upper_bound(entry.0, bytes_bound_as_slice(&self.max)) {
-                return Some(entry);
-            }
-            self.done = true;
-            return None;
+struct Scan {
+    step: Step,
+    range: BytesRange,
+    reverse: bool,
+}
+
+enum Step {
+    Seek,
+    Last,
+    Move,
+    Done,
+}
+
+type BytesRange = (Bound<Bytes>, Bound<Bytes>);
+
+impl Scan {
+    fn new(min: Bound<&[u8]>, max: Bound<&[u8]>, reverse: bool) -> Self {
+        Self {
+            step: Step::Seek,
+            range: (owned_bound(min), owned_bound(max)),
+            reverse,
+        }
+    }
+
+    fn start(&self) -> Bound<&[u8]> {
+        if self.reverse {
+            bytes_bound_as_slice(&self.range.1)
+        } else {
+            bytes_bound_as_slice(&self.range.0)
         }
+    }
 
-        if let Some((key, value)) = self.iter.next() {
-            if !within_upper_bound(key, bytes_bound_as_slice(&self.max)) {
-                self.done = true;
-                return None;
-            }
-            return Some((key, value));
+    fn before_start(&self, key: &[u8]) -> bool {
+        if self.reverse {
+            !bounds_contain(Bound::Unbounded, self.start(), key)
+        } else {
+            !bounds_contain(self.start(), Bound::Unbounded, key)
         }
+    }
 
-        self.done = true;
-        None
+    fn contains(&self, key: &[u8]) -> bool {
+        bounds_contain(
+            bytes_bound_as_slice(&self.range.0),
+            bytes_bound_as_slice(&self.range.1),
+            key,
+        )
+    }
+
+    fn next<'txn, C: Cursor<'txn>>(
+        &mut self,
+        cursor: &C,
+    ) -> Result<Option<KeyValueRef<'txn>>, DatabaseError> {
+        loop {
+            let (key, op) = match self.step {
+                Step::Seek => match self.start() {
+                    Bound::Included(key) | Bound::Excluded(key) => {
+                        (Some(key), lmdb_sys::MDB_SET_RANGE)
+                    }
+                    Bound::Unbounded if self.reverse => (None, lmdb_sys::MDB_LAST),
+                    Bound::Unbounded => (None, lmdb_sys::MDB_FIRST),
+                },
+                Step::Last => (None, lmdb_sys::MDB_LAST),
+                Step::Move if self.reverse => (None, lmdb_sys::MDB_PREV),
+                Step::Move => (None, lmdb_sys::MDB_NEXT),
+                Step::Done => return Ok(None),
+            };
+            let positioning = !matches!(self.step, Step::Move);
+            let Some(entry) = cursor_get(cursor, key, op)? else {
+                self.step = if self.reverse && key.is_some() && matches!(self.step, Step::Seek) {
+                    Step::Last
+                } else {
+                    Step::Done
+                };
+                continue;
+            };
+            self.step = Step::Move;
+            if self.contains(entry.0) {
+                return Ok(Some(entry));
+            }
+            if !(positioning && self.before_start(entry.0)) {
+                self.step = Step::Done;
+            }
+        }
     }
 }
 
 impl InnerIter for LmdbIter<'_> {
     fn try_next(&mut self) -> Result<Option<KeyValueRef<'_>>, DatabaseError> {
-        if self.done {
-            return Ok(None);
-        }
-        Ok(self.next_visible())
+        self.scan.next(&self.cursor)
+    }
+}
+
+fn cursor_get<'txn, C: Cursor<'txn>>(
+    cursor: &C,
+    key: Option<&[u8]>,
+    op: lmdb_sys::MDB_cursor_op,
+) -> Result<Option<KeyValueRef<'txn>>, lmdb::Error> {
+    match cursor.get(key, None, op) {
+        Ok((key, value)) => Ok(Some((key.unwrap_or_default(), value))),
+        Err(lmdb::Error::NotFound) => Ok(None),
+        Err(err) => Err(err),
     }
 }
 
@@ -213,6 +286,24 @@ impl Transaction for LmdbTransaction<'_> {
         = LmdbIter<'a>
     where
         Self: 'a;
+
+    type RevIterType<'a>
+        = LmdbIter<'a>
+    where
+        Self: 'a;
+    fn next_statement_stamp(&mut self) -> Result<u64, DatabaseError> {
+        const STATEMENT_BITS: u32 = 20;
+        self.statements += 1;
+        // SAFETY: `self.tx` is a live transaction handle owned by this value.
+        let txn_id = unsafe { lmdb_sys::mdb_txn_id(self.tx.txn()) } as u64;
+        if self.statements >= 1 << STATEMENT_BITS || txn_id >= 1 << (u64::BITS - STATEMENT_BITS) {
+            return Err(DatabaseError::InvalidValue(
+                "statement stamps exhausted".into(),
+            ));
+        }
+        Ok((txn_id << STATEMENT_BITS) | self.statements)
+    }
+
     fn get_borrowed<'a>(
         &'a self,
         key: &[u8],
@@ -242,36 +333,30 @@ impl Transaction for LmdbTransaction<'_> {
         min: Bound<&'key [u8]>,
         max: Bound<&'key [u8]>,
     ) -> Result<Self::IterType<'txn>, DatabaseError> {
-        let mut cursor = self.tx.open_ro_cursor(self.db)?;
-        let (pending, done) = initial_entry(&mut cursor, &min)?;
-        let iter = cursor.iter();
+        Ok(LmdbIter {
+            cursor: self.tx.open_ro_cursor(self.db)?,
+            scan: Scan::new(min, max, false),
+        })
+    }
 
+    fn range_rev<'txn, 'key>(
+        &'txn self,
+        min: Bound<&'key [u8]>,
+        max: Bound<&'key [u8]>,
+    ) -> Result<Self::RevIterType<'txn>, DatabaseError> {
         Ok(LmdbIter {
-            _cursor: cursor,
-            iter,
-            pending,
-            max: owned_bound(max),
-            done,
+            cursor: self.tx.open_ro_cursor(self.db)?,
+            scan: Scan::new(min, max, true),
         })
     }
 
     fn remove_range(&mut self, min: Bound<&[u8]>, max: Bound<&[u8]>) -> Result<(), DatabaseError> {
         let mut cursor = self.tx.open_rw_cursor(self.db)?;
-        let mut lower = owned_bound(min);
-        let mut seek_key = Bytes::new();
-
-        loop {
-            let entry = cursor_seek(&mut cursor, &lower, &mut seek_key)?;
-            let Some((key, _)) = entry else {
-                return Ok(());
-            };
-            if !within_upper_bound(key, max) {
-                return Ok(());
-            }
-
-            reuse_bound_as_excluded(&mut lower, key);
+        let mut scan = Scan::new(min, max, false);
+        while scan.next(&cursor)?.is_some() {
             cursor.del(WriteFlags::empty())?;
         }
+        Ok(())
     }
 
     fn commit(self) -> Result<(), DatabaseError> {
@@ -280,71 +365,6 @@ impl Transaction for LmdbTransaction<'_> {
     }
 }
 
-fn initial_entry<'txn>(
-    cursor: &mut RoCursor<'txn>,
-    min: &Bound<&[u8]>,
-) -> Result<(Option<KeyValueRef<'txn>>, bool), lmdb::Error> {
-    match min {
-        Bound::Unbounded => Ok((None, false)),
-        Bound::Included(min) => match cursor.get(Some(*min), None, lmdb_sys::MDB_SET_RANGE) {
-            Ok((key, value)) => Ok((Some((key.unwrap_or_default(), value)), false)),
-            Err(lmdb::Error::NotFound) => Ok((None, true)),
-            Err(err) => Err(err),
-        },
-        Bound::Excluded(min) => match cursor.get(Some(*min), None, lmdb_sys::MDB_SET_RANGE) {
-            Ok((key, value)) => {
-                let key = key.unwrap_or_default();
-                if key == *min {
-                    Ok((None, false))
-                } else {
-                    Ok((Some((key, value)), false))
-                }
-            }
-            Err(lmdb::Error::NotFound) => Ok((None, true)),
-            Err(err) => Err(err),
-        },
-    }
-}
-
-fn cursor_seek<'txn>(
-    cursor: &mut lmdb::RwCursor<'txn>,
-    lower: &Bound<Bytes>,
-    seek_key: &mut Bytes,
-) -> Result<Option<KeyValueRef<'txn>>, lmdb::Error> {
-    match lower {
-        Bound::Unbounded => match cursor.get(None, None, lmdb_sys::MDB_FIRST) {
-            Ok((key, value)) => Ok(Some((key.unwrap_or_default(), value))),
-            Err(lmdb::Error::NotFound) => Ok(None),
-            Err(err) => Err(err),
-        },
-        Bound::Included(min) => {
-            match cursor.get(Some(min.as_slice()), None, lmdb_sys::MDB_SET_RANGE) {
-                Ok((key, value)) => Ok(Some((key.unwrap_or_default(), value))),
-                Err(lmdb::Error::NotFound) => Ok(None),
-                Err(err) => Err(err),
-            }
-        }
-        Bound::Excluded(min) => {
-            seek_key.clear();
-            seek_key.extend_from_slice(min.as_slice());
-            seek_key.push(0);
-            match cursor.get(Some(seek_key.as_slice()), None, lmdb_sys::MDB_SET_RANGE) {
-                Ok((key, value)) => Ok(Some((key.unwrap_or_default(), value))),
-                Err(lmdb::Error::NotFound) => Ok(None),
-                Err(err) => Err(err),
-            }
-        }
-    }
-}
-
-fn within_upper_bound(key: &[u8], max: Bound<&[u8]>) -> bool {
-    match max {
-        Bound::Included(max) => key.cmp(max) != Ordering::Greater,
-        Bound::Excluded(max) => key.cmp(max) == Ordering::Less,
-        Bound::Unbounded => true,
-    }
-}
-
 #[cfg(all(test, not(target_arch = "wasm32")))]
 mod tests {
     use super::{LmdbConfig, LmdbStorage};
@@ -376,6 +396,31 @@ mod tests {
         iter.done().unwrap();
     }
 
+    #[test]
+    fn lmdb_remove_range() {
+        use crate::storage::Storage;
+        let temp_dir = TempDir::new().expect("unable to create temporary working directory");
+        let storage = LmdbStorage::new(temp_dir.path().join("kite_sql.lmdb")).unwrap();
+        let mut transaction = storage.transaction().unwrap();
+        crate::storage::check_remove_range(&mut transaction).unwrap();
+    }
+
+    #[test]
+    fn lmdb_range_rev_matches_range() {
+        use crate::storage::Storage;
+        let temp_dir = TempDir::new().expect("unable to create temporary working directory");
+        let storage = LmdbStorage::new(temp_dir.path().join("kite_sql.lmdb")).unwrap();
+        let mut transaction = storage.transaction().unwrap();
+        crate::storage::check_range_rev_matches_range(&mut transaction).unwrap();
+    }
+
+    #[test]
+    fn explicit_transaction_does_not_rescan_own_writes() {
+        let temp_dir = TempDir::new().expect("unable to create temporary working directory");
+        let db = DataBaseBuilder::path(temp_dir.path()).build_lmdb().unwrap();
+        crate::storage::check_explicit_transaction_does_not_rescan_own_writes(db).unwrap();
+    }
+
     #[test]
     fn build_with_lmdb_storage() {
         let temp_dir = TempDir::new().expect("unable to create temporary working directory");
diff --git a/src/storage/memory.rs b/src/storage/memory.rs
index 36c802a1..ede8f0e0 100644
--- a/src/storage/memory.rs
+++ b/src/storage/memory.rs
@@ -15,15 +15,17 @@
 use crate::errors::DatabaseError;
 use crate::storage::table_codec::Bytes;
 use crate::storage::{
-    EmptyStorageMetrics, InnerIter, Storage, Transaction, TransactionIsolationLevel,
+    bytes_bound_as_slice, owned_bound, EmptyStorageMetrics, InnerIter, Storage, Transaction,
+    TransactionIsolationLevel,
 };
-use std::cell::{Ref, RefCell};
-use std::collections::{BTreeMap, Bound, VecDeque};
+use std::cell::{Cell, Ref, RefCell};
+use std::collections::{BTreeMap, Bound};
 use std::rc::Rc;
 
 #[derive(Clone, Default)]
 pub struct MemoryStorage {
     inner: Rc<RefCell<BTreeMap<Vec<u8>, Vec<u8>>>>,
+    statements: Rc<Cell<u64>>,
 }
 
 impl MemoryStorage {
@@ -47,6 +49,7 @@ impl Storage for MemoryStorage {
         self.validate_transaction_isolation(isolation)?;
         Ok(MemoryTransaction {
             inner: self.inner.clone(),
+            statements: self.statements.clone(),
         })
     }
 
@@ -57,11 +60,20 @@ impl Storage for MemoryStorage {
 
 pub struct MemoryTransaction {
     inner: Rc<RefCell<BTreeMap<Vec<u8>, Vec<u8>>>>,
+    statements: Rc<Cell<u64>>,
 }
 
-pub struct MemoryIter {
-    entries: VecDeque<(Bytes, Bytes)>,
-    current: Option<(Bytes, Bytes)>,
+pub struct MemoryIter<'txn> {
+    map: &'txn RefCell<BTreeMap<Vec<u8>, Vec<u8>>>,
+    position: Position,
+    range: (Bound<Bytes>, Bound<Bytes>),
+    reverse: bool,
+}
+
+enum Position {
+    Start,
+    After(Bytes),
+    Done,
 }
 
 pub struct MemoryValue<'a> {
@@ -74,14 +86,64 @@ impl AsRef<[u8]> for MemoryValue<'_> {
     }
 }
 
-impl InnerIter for MemoryIter {
+impl<'txn> MemoryIter<'txn> {
+    fn new(
+        map: &'txn RefCell<BTreeMap<Vec<u8>, Vec<u8>>>,
+        min: Bound<&[u8]>,
+        max: Bound<&[u8]>,
+        reverse: bool,
+    ) -> Self {
+        Self {
+            map,
+            position: Position::Start,
+            range: (owned_bound(min), owned_bound(max)),
+            reverse,
+        }
+    }
+}
+
+impl InnerIter for MemoryIter<'_> {
     fn try_next(&mut self) -> Result<Option<crate::storage::KeyValueRef<'_>>, DatabaseError> {
-        self.current = self.entries.pop_front();
+        let (mut min, mut max) = (
+            bytes_bound_as_slice(&self.range.0),
+            bytes_bound_as_slice(&self.range.1),
+        );
+        match &self.position {
+            Position::Start => {}
+            Position::After(key) if self.reverse => max = Bound::Excluded(key),
+            Position::After(key) => min = Bound::Excluded(key),
+            Position::Done => return Ok(None),
+        }
+
+        let map = self.map.borrow();
+        let mut range = map.range::<[u8], _>((min, max));
+        let entry = if self.reverse {
+            range.next_back()
+        } else {
+            range.next()
+        };
+        let Some((key, value)) = entry else {
+            self.position = Position::Done;
+            return Ok(None);
+        };
+        let value: *const [u8] = value.as_slice();
+        match &mut self.position {
+            Position::After(buf) => {
+                buf.clear();
+                buf.extend_from_slice(key);
+            }
+            position => *position = Position::After(key.clone()),
+        }
+        drop(map);
 
-        Ok(self
-            .current
-            .as_ref()
-            .map(|(key, value)| (key.as_slice(), value.as_slice())))
+        let Position::After(key) = &self.position else {
+            unreachable!()
+        };
+        // SAFETY: the value lives in its own heap allocation owned by the map entry. The map is
+        // only mutated through the same single-threaded transaction, and callers consume the
+        // returned slice before issuing the next write, so the allocation is still alive and
+        // unmodified for as long as the slice is used (the same contract as LMDB cursors).
+        Ok(Some((key.as_slice(), unsafe { &*value })))
     }
 }
 
@@ -92,9 +154,20 @@ impl Transaction for MemoryTransaction {
         Self: 'a;
 
     type IterType<'a>
-        = MemoryIter
+        = MemoryIter<'a>
+    where
+        Self: 'a;
+
+    type RevIterType<'a>
+        = MemoryIter<'a>
     where
         Self: 'a;
+    fn next_statement_stamp(&mut self) -> Result<u64, DatabaseError> {
+        let stamp = self.statements.get() + 1;
+        self.statements.set(stamp);
+        Ok(stamp)
+    }
+
     fn get_borrowed<'a>(
         &'a self,
         key: &[u8],
@@ -122,27 +195,15 @@ impl Transaction for MemoryTransaction {
         min: Bound<&'key [u8]>,
         max: Bound<&'key [u8]>,
     ) -> Result<Self::IterType<'txn>, DatabaseError> {
-        let map = self.inner.borrow();
-        let start = match &min {
-            Bound::Included(b) => Bound::Included(*b),
-            Bound::Excluded(b) => Bound::Excluded(*b),
-            Bound::Unbounded => Bound::Unbounded,
-        };
-        let end = match &max {
-            Bound::Included(b) => Bound::Included(*b),
-            Bound::Excluded(b) => Bound::Excluded(*b),
-            Bound::Unbounded => Bound::Unbounded,
-        };
-
-        let entries = map
-            .range::<[u8], _>((start, end))
-            .map(|(k, v)| (k.clone(), v.clone()))
-            .collect();
+        Ok(MemoryIter::new(&self.inner, min, max, false))
+    }
 
-        Ok(MemoryIter {
-            entries,
-            current: None,
-        })
+    fn range_rev<'txn, 'key>(
+        &'txn self,
+        min: Bound<&'key [u8]>,
+        max: Bound<&'key [u8]>,
+    ) -> Result<Self::RevIterType<'txn>, DatabaseError> {
+        Ok(MemoryIter::new(&self.inner, min, max, true))
     }
 
     fn commit(self) -> Result<(), DatabaseError> {
@@ -239,7 +300,7 @@ mod wasm_tests {
             &table_cache,
             "test".to_string().into(),
             (Some(1), Some(1)),
-            read_columns,
+            &read_columns,
             true,
         )?;
 
@@ -274,12 +335,12 @@ mod wasm_tests {
             &plan_arena,
             table_name,
             (Some(0), None),
-            table.columns().cloned().collect(),
+            &table.columns().cloned().collect::<Vec<_>>(),
             pk_index,
-            vec![Range::Scope {
+            &[Range::Scope {
                 min: Bound::Excluded(DataValue::Int32(0)),
                 max: Bound::Included(DataValue::Int32(2)),
-            }],
+            }][..],
             true,
             None,
             None,
@@ -309,6 +370,26 @@ mod native_tests {
     use crate::types::LogicalType;
     use std::collections::Bound;
 
+    #[test]
+    fn memory_explicit_transaction_does_not_rescan_own_writes() -> Result<(), DatabaseError> {
+        let db = crate::db::DataBaseBuilder::path(".").build_in_memory()?;
+        crate::storage::check_explicit_transaction_does_not_rescan_own_writes(db)
+    }
+
+    #[test]
+    fn memory_remove_range() -> Result<(), DatabaseError> {
+        let storage = MemoryStorage::new();
+        let mut transaction = storage.transaction()?;
+        crate::storage::check_remove_range(&mut transaction)
+    }
+
+    #[test]
+    fn memory_range_rev_matches_range() -> Result<(), DatabaseError> {
+        let storage = MemoryStorage::new();
+        let mut transaction = storage.transaction()?;
+        crate::storage::check_range_rev_matches_range(&mut transaction)
+    }
+
     #[test]
     fn memory_storage_roundtrip() -> Result<(), DatabaseError> {
         let storage = MemoryStorage::new();
@@ -384,7 +465,7 @@ mod native_tests {
             &table_cache,
             "test".to_string().into(),
             (Some(1), Some(1)),
-            read_columns,
+            &read_columns,
             true,
         )?;
 
@@ -419,12 +500,12 @@ mod native_tests {
             &plan_arena,
             table_name,
             (Some(0), None),
-            table.columns().cloned().collect(),
+            &table.columns().cloned().collect::<Vec<_>>(),
             pk_index,
-            vec![Range::Scope {
+            &[Range::Scope {
                 min: Bound::Excluded(DataValue::Int32(0)),
                 max: Bound::Included(DataValue::Int32(2)),
-            }],
+            }][..],
             true,
             None,
             None,
diff --git a/src/storage/mod.rs b/src/storage/mod.rs
index e9c31590..649d6ee2 100644
--- a/src/storage/mod.rs
+++ b/src/storage/mod.rs
@@ -162,6 +162,14 @@ pub trait Transaction: Sized {
     where
         Self: 'a;
 
+    type RevIterType<'a>: InnerIter
+    where
+        Self: 'a;
+
+    fn next_statement_stamp(&mut self) -> Result<u64, DatabaseError> {
+        Ok(0)
+    }
+
     fn begin_statement_scope(&mut self) -> Result<(), DatabaseError> {
         Ok(())
     }
@@ -181,13 +189,13 @@ pub trait Transaction: Sized {
         table_cache: &TableCache,
         table_name: TableName,
         bounds: Bounds,
-        columns: Vec<ColumnRef>,
+        columns: &[ColumnRef],
         with_pk: bool,
     ) -> Result<TupleIter<'a, Self>, DatabaseError> {
         let table = self
             .table(table_cache, table_name.clone())?
             .ok_or(DatabaseError::TableNotFound)?;
-        let deserializers = Self::create_deserializers(&columns, table, arena, with_pk);
+        let deserializers = Self::create_deserializers(columns, table, arena, with_pk);
         let pk_ty = with_pk.then(|| table.primary_keys_type().clone());
         let offset = bounds.0.unwrap_or(0);
 
@@ -211,15 +219,15 @@ pub trait Transaction: Sized {
         arena: &(dyn MetaArena + 'a),
         table_name: TableName,
         (offset_option, limit_option): Bounds,
-        columns: Vec<ColumnRef>,
+        columns: &[ColumnRef],
         index_meta: IndexMetaRef,
         ranges: R,
         with_pk: bool,
-        covered_deserializers: Option<Vec<TupleValueSerializableImpl>>,
-        cover_mapping_indices: Option<Vec<usize>>,
+        covered_deserializers: Option<&'a [TupleValueSerializableImpl]>,
+        cover_mapping_indices: Option<&[usize]>,
     ) -> Result<IndexIter<'a, Self>, DatabaseError>
     where
-        R: Into<IndexRanges>,
+        R: Into<IndexRanges<'a>>,
     {
         let index_meta_ref = index_meta;
         let index_meta = arena.index(index_meta_ref);
@@ -243,16 +251,21 @@ pub trait Transaction: Sized {
 
                 (
                     IndexImplEnum::Covered(CoveredIndexImpl),
-                    deserializers,
+                    Cow::Borrowed(deserializers),
                     cover_mapping,
                 )
             }
             _ => {
-                let deserializers = Self::create_deserializers(&columns, table, arena, with_pk);
-                (IndexImplEnum::instance(index_meta.ty), deserializers, None)
+                let deserializers = Self::create_deserializers(columns, table, arena, with_pk);
+                (
+                    IndexImplEnum::instance(index_meta.ty),
+                    Cow::Owned(deserializers),
+                    None,
+                )
             }
         };
         let total_len = table.columns_len();
+        let ranges = ranges.into();
 
         Ok(IndexIter {
             bounds: IterBounds::new(offset, limit_option),
@@ -265,9 +278,10 @@ pub trait Transaction: Sized {
                 tx: self,
                 cover_mapping,
                 with_pk,
+                reverse: ranges.reverse,
             },
             inner,
-            ranges: ranges.into(),
+            ranges,
             state: IndexIterState::Init,
             encode_min_buffer: Bytes::new(),
             encode_max_buffer: Bytes::new(),
@@ -355,7 +369,9 @@ pub trait Transaction: Sized {
         table_codec.with_index(table_name, &index, Some(tuple_id), |key, value| {
             if matches!(index.ty, IndexType::Unique) {
                 if let Some(bytes) = self.get_borrowed(key)? {
-                    return if bytes.as_ref() != value {
+                    return if TableCodec::strip_stamp(bytes.as_ref())?
+                        != TableCodec::strip_stamp(value)?
+                    {
                         Err(DatabaseError::DuplicateUniqueValue)
                     } else {
                         Ok(())
@@ -1154,13 +1170,18 @@ pub trait Transaction: Sized {
 
     fn remove(&mut self, key: &[u8]) -> Result<(), DatabaseError>;
 
-    // TODO: Support reverse range iteration (upper to lower bound) for descending index scans.
     fn range<'txn, 'key>(
         &'txn self,
         min: Bound<&'key [u8]>,
         max: Bound<&'key [u8]>,
     ) -> Result<Self::IterType<'txn>, DatabaseError>;
 
+    fn range_rev<'txn, 'key>(
+        &'txn self,
+        min: Bound<&'key [u8]>,
+        max: Bound<&'key [u8]>,
+    ) -> Result<Self::RevIterType<'txn>, DatabaseError>;
+
     fn remove_range(&mut self, min: Bound<&[u8]>, max: Bound<&[u8]>) -> Result<(), DatabaseError> {
         const DELETE_BATCH_SIZE: usize = 1024;
 
@@ -1219,6 +1240,10 @@ pub(crate) fn reuse_bound_as_excluded(bound: &mut Bound<Bytes>, key: &[u8]) {
     *bound = Bound::Excluded(bytes);
 }
 
+pub(crate) fn bounds_contain(min: Bound<&[u8]>, max: Bound<&[u8]>, key: &[u8]) -> bool {
+    std::ops::RangeBounds::<[u8]>::contains(&(min, max), key)
+}
+
 pub(crate) fn bytes_bound_as_slice(bound: &Bound<Bytes>) -> Bound<&[u8]> {
     match bound {
         Bound::Included(bytes) => Bound::Included(bytes.as_slice()),
@@ -1336,7 +1361,7 @@ struct TupleMapping {
 }
 
 impl TupleMapping {
-    fn new(scan_to_index: Vec<usize>, tuple_len: usize) -> Self {
+    fn new(scan_to_index: &[usize], tuple_len: usize) -> Self {
         let mut index_to_scan = vec![usize::MAX; tuple_len];
 
         for (scan_idx, index_idx) in scan_to_index.iter().enumerate() {
@@ -1357,11 +1382,12 @@ struct IndexImplParams<'a, T: Transaction> {
     index_meta: IndexMetaRef,
     meta_arena: &'a dyn MetaArena,
     table_name: TableName,
-    deserializers: Vec<TupleValueSerializableImpl>,
+    deserializers: Cow<'a, [TupleValueSerializableImpl]>,
     total_len: usize,
     tx: &'a T,
     cover_mapping: Option<TupleMapping>,
     with_pk: bool,
+    reverse: bool,
 }
 
 impl<T: Transaction> IndexImplParams<'_, T> {
@@ -1388,7 +1414,7 @@ impl<T: Transaction> IndexImplParams<'_, T> {
             };
             TableCodec::decode_tuple_into(
                 tuple,
-                &self.deserializers,
+                &self.deserializers[..],
                 Some(tuple_id.clone()),
                 bytes.as_ref(),
                 self.total_len,
@@ -1401,7 +1427,36 @@ impl<T: Transaction> IndexImplParams<'_, T> {
 enum IndexResult<'a, T: Transaction + 'a> {
     Hit,
     Miss,
-    Scope(T::IterType<'a>),
+    Scope(RangeIter<'a, T>),
+}
+
+pub enum RangeIter<'a, T: Transaction + 'a> {
+    Forward(T::IterType<'a>),
+    Reverse(T::RevIterType<'a>),
+}
+
+impl<'a, T: Transaction + 'a> RangeIter<'a, T> {
+    fn open(
+        tx: &'a T,
+        min: Bound<&[u8]>,
+        max: Bound<&[u8]>,
+        reverse: bool,
+    ) -> Result<Self, DatabaseError> {
+        Ok(if reverse {
+            RangeIter::Reverse(tx.range_rev(min, max)?)
+        } else {
+            RangeIter::Forward(tx.range(min, max)?)
+        })
+    }
+}
+
+impl<'a, T: Transaction + 'a> InnerIter for RangeIter<'a, T> {
+    fn try_next(&mut self) -> Result<Option<KeyValueRef<'_>>, DatabaseError> {
+        match self {
+            RangeIter::Forward(iter) => iter.try_next(),
+            RangeIter::Reverse(iter) => iter.try_next(),
+        }
+    }
 }
 
 impl<T: Transaction> IndexImpl<T> for IndexImplEnum {
@@ -1500,7 +1555,7 @@ impl<T: Transaction> IndexImpl<T> for PrimaryKeyIndexImpl {
         let tuple_id = TableCodec::decode_tuple_key(key, &params.index_meta().pk_ty)?;
         TableCodec::decode_tuple_into(
             tuple,
-            &params.deserializers,
+            &params.deserializers[..],
             Some(tuple_id),
             value,
             params.total_len,
@@ -1527,7 +1582,7 @@ impl<T: Transaction> IndexImpl<T> for PrimaryKeyIndexImpl {
                 };
                 TableCodec::decode_tuple_into(
                     tuple,
-                    &params.deserializers,
+                    &params.deserializers[..],
                     Some(tuple_id.clone()),
                     bytes.as_ref(),
                     params.total_len,
@@ -1819,9 +1874,11 @@ fn eq_to_res_scope<'a, T: Transaction + 'a>(
     index_impl.bound_key(table_codec, params, value, false, encode_min)?;
     index_impl.bound_key(table_codec, params, value, true, encode_max)?;
 
-    let iter = params.tx.range(
+    let iter = RangeIter::open(
+        params.tx,
         Bound::Included(encode_min.as_slice()),
         Bound::Included(encode_max.as_slice()),
+        params.reverse,
     )?;
     Ok(IndexResult::Scope(iter))
 }
@@ -1837,17 +1894,13 @@ pub struct TupleIter<'a, T: Transaction + 'a> {
 impl<'a, T: Transaction + 'a> Iter for TupleIter<'a, T> {
     fn next_tuple_into(
         &mut self,
-        _: &mut TableCodec,
+        table_codec: &mut TableCodec,
         tuple: &mut Tuple,
     ) -> Result<bool, DatabaseError> {
-        while self.bounds.consume_offset() {
-            if self.iter.try_next()?.is_none() {
-                return Ok(false);
-            }
-        }
-
-        #[allow(clippy::never_loop)]
         while let Some((key, value)) = self.iter.try_next()? {
+            if table_codec.is_own_write(value) || self.bounds.consume_offset() {
+                continue;
+            }
             if self.bounds.limit_reached() {
                 return Ok(false);
             }
@@ -1872,45 +1925,74 @@ impl<'a, T: Transaction + 'a> Iter for TupleIter<'a, T> {
     }
 }
 
-enum IndexRangesInner {
-    One(Range),
-    Many(Vec<Range>),
+enum RangeSource<'r> {
+    Borrowed(&'r [Range]),
+    Owned(Range),
 }
 
-pub struct IndexRanges {
-    inner: IndexRangesInner,
-    next_idx: usize,
+pub struct IndexRanges<'r> {
+    source: RangeSource<'r>,
+    next: usize,
+    reverse: bool,
 }
 
-impl IndexRanges {
-    fn next(&mut self) -> Option<&Range> {
-        let range = match &self.inner {
-            IndexRangesInner::One(range) => (self.next_idx == 0).then_some(range),
-            IndexRangesInner::Many(ranges) => ranges.get(self.next_idx),
+impl IndexRanges<'_> {
+    pub(crate) fn reversed(mut self, reverse: bool) -> Self {
+        self.reverse = reverse;
+        self
+    }
+
+    pub(crate) fn next(&mut self) -> Option<&Range> {
+        let ranges = match &self.source {
+            RangeSource::Borrowed(ranges) => ranges,
+            RangeSource::Owned(Range::SortedRanges(ranges)) => ranges.as_slice(),
+            RangeSource::Owned(range) => std::slice::from_ref(range),
+        };
+        let idx = if self.reverse {
+            ranges.len().checked_sub(self.next + 1)?
+        } else {
+            self.next
         };
+        let range = ranges.get(idx)?;
+        self.next += 1;
+        Some(range)
+    }
+}
 
-        if range.is_some() {
-            self.next_idx += 1;
+impl<'r> From<&'r [Range]> for IndexRanges<'r> {
+    fn from(ranges: &'r [Range]) -> Self {
+        IndexRanges {
+            source: RangeSource::Borrowed(ranges),
+            next: 0,
+            reverse: false,
         }
+    }
+}
 
-        range
+impl<'r> From<&'r Range> for IndexRanges<'r> {
+    fn from(range: &'r Range) -> Self {
+        match range {
+            Range::SortedRanges(ranges) => ranges.as_slice().into(),
+            range => std::slice::from_ref(range).into(),
+        }
     }
 }
 
-impl From<Vec<Range>> for IndexRanges {
-    fn from(value: Vec<Range>) -> Self {
-        Self {
-            inner: IndexRangesInner::Many(value),
-            next_idx: 0,
+impl From<Range> for IndexRanges<'_> {
+    fn from(range: Range) -> Self {
+        IndexRanges {
+            source: RangeSource::Owned(range),
+            next: 0,
+            reverse: false,
         }
     }
 }
 
-impl From<Range> for IndexRanges {
-    fn from(value: Range) -> Self {
-        Self {
-            inner: IndexRangesInner::One(value),
-            next_idx: 0,
+impl<'r> From<Cow<'r, Range>> for IndexRanges<'r> {
+    fn from(range: Cow<'r, Range>) -> Self {
+        match range {
+            Cow::Borrowed(range) => range.into(),
+            Cow::Owned(range) => range.into(),
         }
     }
 }
@@ -1950,7 +2032,7 @@ pub struct IndexIter<'a, T: Transaction> {
     bounds: IterBounds,
     params: IndexImplParams<'a, T>,
     inner: IndexImplEnum,
-    ranges: IndexRanges,
+    ranges: IndexRanges<'a>,
     state: IndexIterState<'a, T>,
     encode_min_buffer: Bytes,
     encode_max_buffer: Bytes,
@@ -1958,7 +2040,7 @@ pub struct IndexIter<'a, T: Transaction> {
 
 pub enum IndexIterState<'a, T: Transaction + 'a> {
     Init,
-    Range(T::IterType<'a>),
+    Range(RangeIter<'a, T>),
     Over,
 }
 
@@ -2003,10 +2085,13 @@ impl<T: Transaction> Iter for IndexIter<'_, T> {
                             )?;
 
                             let tx = self.params.tx;
+                            let reverse = self.params.reverse;
                             let open_iter = move |bound_min: &[u8], bound_max: &[u8]| {
-                                tx.range(
+                                RangeIter::open(
+                                    tx,
                                     fill_default_bound(encode_min, bound_min),
                                     fill_default_bound(encode_max, bound_max),
+                                    reverse,
                                 )
                             };
                             let iter = if matches!(index_meta.ty, IndexType::PrimaryKey { .. }) {
@@ -2047,7 +2132,7 @@ impl<T: Transaction> Iter for IndexIter<'_, T> {
                 }
                 IndexIterState::Range(iter) => {
                     while let Some((key, value)) = iter.try_next()? {
-                        if self.bounds.consume_offset() {
+                        if table_codec.is_own_write(value) || self.bounds.consume_offset() {
                             continue;
                         }
                         self.bounds.consume_limit();
@@ -2123,6 +2208,142 @@ impl<T: Transaction> ViewIter<'_, T> {
     }
 }
 
+#[cfg(test)]
+pub(crate) fn check_range_rev_matches_range<T: Transaction>(
+    tx: &mut T,
+) -> Result<(), DatabaseError> {
+    fn keys<I: InnerIter>(mut iter: I) -> Result<Vec<Vec<u8>>, DatabaseError> {
+        let mut keys = Vec::new();
+        while let Some((key, _)) = iter.try_next()? {
+            keys.push(key.to_vec());
+        }
+        Ok(keys)
+    }
+
+    let data: Vec<Vec<u8>> = [
+        &b"a"[..],
+        b"prefix0000\x01",
+        b"prefix0000\x03",
+        b"prefix0000\x03\x00",
+        b"prefix0000\x05",
+        b"prefix0001\x01",
+        b"z",
+    ]
+    .iter()
+    .map(|key| key.to_vec())
+    .collect();
+    for key in &data {
+        tx.set(key, b"v")?;
+    }
+    let probes: Vec<&[u8]> = vec![
+        b"a",
+        b"prefix0000\x00",
+        b"prefix0000\x01",
+        b"prefix0000\x02",
+        b"prefix0000\x03",
+        b"prefix0000\x05",
+        b"prefix0000\x06",
+        b"prefix0001\x01",
+        b"z",
+        b"zz",
+    ];
+    let mut bounds = vec![(None, Bound::Unbounded)];
+    for (rank, probe) in probes.iter().enumerate() {
+        bounds.push((Some(rank), Bound::Included(*probe)));
+        bounds.push((Some(rank), Bound::Excluded(*probe)));
+    }
+    for (min_rank, min) in &bounds {
+        for (max_rank, max) in &bounds {
+            let valid = match (min_rank, max_rank) {
+                (Some(lo), Some(hi)) => {
+                    lo < hi
+                        || (lo == hi
+                            && matches!((min, max), (Bound::Included(_), Bound::Included(_))))
+                }
+                _ => true,
+            };
+            if !valid {
+                continue;
+            }
+            let mut expected: Vec<Vec<u8>> = data
+                .iter()
+                .filter(|key| bounds_contain(*min, *max, key.as_slice()))
+                .cloned()
+                .collect();
+            assert_eq!(
+                keys(tx.range(*min, *max)?)?,
+                expected,
+                "min={min:?} max={max:?}"
+            );
+            expected.reverse();
+            let actual = keys(tx.range_rev(*min, *max)?)?;
+            assert_eq!(actual, expected, "min={min:?} max={max:?}");
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+pub(crate) fn check_explicit_transaction_does_not_rescan_own_writes<S: Storage>(
+    mut db: crate::db::Database<S>,
+) -> Result<(), DatabaseError> {
+    db.ddl("create table t (id int primary key, v int not null)")?;
+    let mut tx = db.new_transaction()?;
+    tx.run("insert into t values (1,1), (2,2), (3,3), (4,4), (5,5)")?
+        .done()?;
+    tx.run("update t set id = id + 1000 where id > 3 and id < 3000")?
+        .done()?;
+    tx.run("insert into t select id + 1000, v from t where id < 3000")?
+        .done()?;
+    let mut iter = tx.run("select id from t order by id")?;
+    let mut ids = Vec::new();
+    while let Some(id) = iter.next_tuple(|_, tuple| tuple.values[0].clone())? {
+        ids.push(id);
+    }
+    iter.done()?;
+    tx.commit()?;
+    let expected = [1, 2, 3, 1001, 1002, 1003, 1004, 1005, 2004, 2005]
+        .map(DataValue::Int32)
+        .to_vec();
+    assert_eq!(ids, expected);
+    Ok(())
+}
+
+#[cfg(test)]
+pub(crate) fn check_remove_range<T: Transaction>(tx: &mut T) -> Result<(), DatabaseError> {
+    let data: Vec<[u8; 4]> = (0u32..3000).map(u32::to_be_bytes).collect();
+    let [k0, k1, k10, k2500, k2999, k5000] = [0u32, 1, 10, 2500, 2999, 5000].map(u32::to_be_bytes);
+    type Case<'a> = (Bound<&'a [u8]>, Bound<&'a [u8]>);
+    let cases: [Case; 7] = [
+        (Bound::Unbounded, Bound::Unbounded),
+        (Bound::Included(&k10), Bound::Excluded(&k2500)),
+        (Bound::Excluded(&k10), Bound::Included(&k2500)),
+        (Bound::Included(&k0), Bound::Included(&k0)),
+        (Bound::Excluded(&k2999), Bound::Unbounded),
+        (Bound::Unbounded, Bound::Excluded(&k1)),
+        (Bound::Included(&k5000), Bound::Unbounded),
+    ];
+    for (min, max) in cases {
+        for key in &data {
+            tx.set(key, &[7; 64])?;
+        }
+        tx.remove_range(min, max)?;
+
+        let mut iter = tx.range(Bound::Unbounded, Bound::Unbounded)?;
+        let mut remaining = Vec::new();
+        while let Some((key, _)) = iter.try_next()? {
+            remaining.push(key.to_vec());
+        }
+        let expected: Vec<Vec<u8>> = data
+            .iter()
+            .filter(|key| !bounds_contain(min, max, key.as_slice()))
+            .map(|key| key.to_vec())
+            .collect();
+        assert_eq!(remaining, expected, "min={min:?} max={max:?}");
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 pub(crate) fn next_tuple_for_test<I: Iter>(iter: &mut I) -> Result<Option<Tuple>, DatabaseError> {
     let mut tuple = Tuple::default();
@@ -2333,7 +2554,7 @@ mod test {
                 &table_cache,
                 "t1".to_string().into(),
                 (None, None),
-                full_columns(&table_cache),
+                &full_columns(&table_cache),
                 true,
             )?;
 
@@ -2371,7 +2592,7 @@ mod test {
                 &table_cache,
                 "t1".to_string().into(),
                 (None, None),
-                full_columns(&table_cache),
+                &full_columns(&table_cache),
                 true,
             )?;
 
@@ -2559,12 +2780,12 @@ mod test {
                 plan_arena,
                 "t1".to_string().into(),
                 (None, None),
-                full_columns(table_cache),
+                &full_columns(table_cache),
                 index_meta,
-                vec![Range::Scope {
+                &[Range::Scope {
                     min: Bound::Unbounded,
                     max: Bound::Unbounded,
-                }],
+                }][..],
                 true,
                 None,
                 None,
diff --git a/src/storage/rocksdb.rs b/src/storage/rocksdb.rs
index afe6d24f..7be2dba1 100644
--- a/src/storage/rocksdb.rs
+++ b/src/storage/rocksdb.rs
@@ -446,6 +446,7 @@ impl Storage for OptimisticRocksStorage {
             isolation,
             current_snapshot: matches!(isolation, TransactionIsolationLevel::RepeatableRead)
                 .then(|| self.inner.snapshot()),
+            statements: 0,
         })
     }
 
@@ -493,6 +494,7 @@ impl Storage for RocksStorage {
             isolation,
             current_snapshot: matches!(isolation, TransactionIsolationLevel::RepeatableRead)
                 .then(|| self.inner.snapshot()),
+            statements: 0,
         })
     }
 
@@ -563,6 +565,7 @@ pub struct OptimisticRocksTransaction<'db> {
     tx: rocksdb::Transaction<'db, OptimisticTransactionDB>,
     isolation: TransactionIsolationLevel,
     current_snapshot: Option<SnapshotWithThreadMode<'db, OptimisticTransactionDB>>,
+    statements: u64,
 }
 
 pub struct RocksTransaction<'db> {
@@ -570,6 +573,32 @@ pub struct RocksTransaction<'db> {
     tx: rocksdb::Transaction<'db, TransactionDB<rocksdb::MultiThreaded>>,
     isolation: TransactionIsolationLevel,
     current_snapshot: Option<SnapshotWithThreadMode<'db, TransactionDB<rocksdb::MultiThreaded>>>,
+    statements: u64,
+}
+
+extern "C" {
+    fn rocksdb_snapshot_get_sequence_number(snapshot: *const std::ffi::c_void) -> u64;
+}
+
+fn statement_stamp<D: rocksdb::DBAccess>(
+    db: &D,
+    statements: &mut u64,
+) -> Result<u64, DatabaseError> {
+    const STATEMENT_BITS: u32 = 12;
+    *statements += 1;
+    // SAFETY: the snapshot is created on `db`, only read, and released before returning.
+    let sequence = unsafe {
+        let snapshot = db.create_snapshot();
+        let sequence = rocksdb_snapshot_get_sequence_number(snapshot.cast());
+        db.release_snapshot(snapshot);
+        sequence
+    };
+    if *statements >= 1 << STATEMENT_BITS || sequence >= 1 << (u64::BITS - STATEMENT_BITS) {
+        return Err(DatabaseError::InvalidValue(
+            "statement stamps exhausted".into(),
+        ));
+    }
+    Ok((sequence << STATEMENT_BITS) | *statements)
 }
 
 fn build_read_options<D: rocksdb::DBAccess>(
@@ -595,6 +624,15 @@ macro_rules! impl_transaction {
                 = $iter<'storage, 'iter>
             where
                 Self: 'iter;
+
+            type RevIterType<'iter>
+                = $iter<'storage, 'iter>
+            where
+                Self: 'iter;
+            fn next_statement_stamp(&mut self) -> Result<u64, DatabaseError> {
+                statement_stamp(self.db, &mut self.statements)
+            }
+
             fn begin_statement_scope(&mut self) -> Result<(), DatabaseError> {
                 if self.isolation == TransactionIsolationLevel::ReadCommitted {
                     self.current_snapshot = Some(self.db.snapshot());
@@ -640,20 +678,7 @@ macro_rules! impl_transaction {
                 max: Bound<&'key [u8]>,
             ) -> Result<Self::IterType<'a>, DatabaseError> {
                 let mut read_opts = build_read_options(self.current_snapshot.as_ref());
-                if let (
-                    Bound::Included(min_bytes) | Bound::Excluded(min_bytes),
-                    Bound::Included(max_bytes) | Bound::Excluded(max_bytes),
-                ) = (&min, &max)
-                {
-                    let len = min_bytes
-                        .iter()
-                        .zip(max_bytes.iter())
-                        .take_while(|(x, y)| x == y)
-                        .count();
-                    if len >= ROCKSDB_FIXED_PREFIX_LEN {
-                        read_opts.set_prefix_same_as_start(true);
-                    }
-                }
+                set_prefix_same_as_start(&mut read_opts, min, max);
                 set_iterate_upper_bound(&mut read_opts, max);
 
                 let mut iter = self.tx.raw_iterator_opt(read_opts);
@@ -670,8 +695,35 @@ macro_rules! impl_transaction {
 
                 Ok($iter {
                     iter,
-                    advanced: false,
-                    done: false,
+                    step: Step::Current(Direction::Forward),
+                })
+            }
+
+            #[inline]
+            fn range_rev<'a, 'key>(
+                &'a self,
+                min: Bound<&'key [u8]>,
+                max: Bound<&'key [u8]>,
+            ) -> Result<Self::RevIterType<'a>, DatabaseError> {
+                let mut read_opts = build_read_options(self.current_snapshot.as_ref());
+                set_prefix_same_as_start(&mut read_opts, min, max);
+                set_iterate_lower_bound(&mut read_opts, min);
+
+                let mut iter = self.tx.raw_iterator_opt(read_opts);
+                match &max {
+                    Bound::Included(bytes) => iter.seek_for_prev(*bytes),
+                    Bound::Excluded(bytes) => {
+                        iter.seek_for_prev(*bytes);
+                        if iter.key() == Some(*bytes) {
+                            iter.prev();
+                        }
+                    }
+                    Bound::Unbounded => iter.seek_to_last(),
+                }
+
+                Ok($iter {
+                    iter,
+                    step: Step::Current(Direction::Reverse),
                 })
             }
 
@@ -688,14 +740,13 @@ impl_transaction!(OptimisticRocksTransaction, OptimisticRocksIter);
 
 pub struct OptimisticRocksIter<'txn, 'iter> {
     iter: DBRawIteratorWithThreadMode<'iter, rocksdb::Transaction<'txn, OptimisticTransactionDB>>,
-    advanced: bool,
-    done: bool,
+    step: Step,
 }
 
 impl InnerIter for OptimisticRocksIter<'_, '_> {
     #[inline]
     fn try_next(&mut self) -> Result<Option<crate::storage::KeyValueRef<'_>>, DatabaseError> {
-        next(&mut self.iter, &mut self.advanced, &mut self.done)
+        next(&mut self.iter, &mut self.step)
     }
 }
 
@@ -704,14 +755,45 @@ pub struct RocksIter<'txn, 'iter> {
         'iter,
         rocksdb::Transaction<'txn, TransactionDB<rocksdb::MultiThreaded>>,
     >,
-    advanced: bool,
-    done: bool,
+    step: Step,
 }
 
 impl InnerIter for RocksIter<'_, '_> {
     #[inline]
     fn try_next(&mut self) -> Result<Option<crate::storage::KeyValueRef<'_>>, DatabaseError> {
-        next(&mut self.iter, &mut self.advanced, &mut self.done)
+        next(&mut self.iter, &mut self.step)
+    }
+}
+
+#[inline]
+fn set_prefix_same_as_start(read_opts: &mut ReadOptions, min: Bound<&[u8]>, max: Bound<&[u8]>) {
+    if let (
+        Bound::Included(min_bytes) | Bound::Excluded(min_bytes),
+        Bound::Included(max_bytes) | Bound::Excluded(max_bytes),
+    ) = (min, max)
+    {
+        let len = min_bytes
+            .iter()
+            .zip(max_bytes.iter())
+            .take_while(|(x, y)| x == y)
+            .count();
+        if len >= ROCKSDB_FIXED_PREFIX_LEN {
+            read_opts.set_prefix_same_as_start(true);
+        }
+    }
+}
+
+#[inline]
+fn set_iterate_lower_bound(read_opts: &mut ReadOptions, lower: Bound<&[u8]>) {
+    match lower {
+        Bound::Included(bytes) => read_opts.set_iterate_lower_bound(bytes),
+        Bound::Excluded(bytes) => {
+            let mut inclusive_lower = Vec::with_capacity(bytes.len() + 1);
+            inclusive_lower.extend_from_slice(bytes);
+            inclusive_lower.push(0);
+            read_opts.set_iterate_lower_bound(inclusive_lower);
+        }
+        Bound::Unbounded => {}
     }
 }
 
@@ -729,32 +811,47 @@ fn set_iterate_upper_bound(read_opts: &mut ReadOptions, upper: Bound<&[u8]>) {
     }
 }
 
+#[derive(Clone, Copy)]
+enum Step {
+    Current(Direction),
+    Advance(Direction),
+    Done,
+}
+
+#[derive(Clone, Copy)]
+enum Direction {
+    Forward,
+    Reverse,
+}
+
 #[inline]
 fn next<'a, D: rocksdb::DBAccess>(
     iter: &'a mut DBRawIteratorWithThreadMode<'_, D>,
-    advanced: &mut bool,
-    done: &mut bool,
+    step: &mut Step,
 ) -> Result<Option<crate::storage::KeyValueRef<'a>>, DatabaseError> {
-    if *done {
-        return Ok(None);
-    }
-    if *advanced {
-        iter.next();
-    }
-    if !iter.valid() {
-        *done = true;
-        iter.status()?;
-        return Ok(None);
-    }
-
-    let Some((key, value)) = iter.item() else {
-        *done = true;
-        iter.status()?;
-        return Ok(None);
+    let direction = match *step {
+        Step::Current(direction) => direction,
+        Step::Advance(Direction::Forward) => {
+            iter.next();
+            Direction::Forward
+        }
+        Step::Advance(Direction::Reverse) => {
+            iter.prev();
+            Direction::Reverse
+        }
+        Step::Done => return Ok(None),
     };
-
-    *advanced = true;
-    Ok(Some((key, value)))
+    match iter.item() {
+        Some(item) => {
+            *step = Step::Advance(direction);
+            Ok(Some(item))
+        }
+        None => {
+            *step = Step::Done;
+            iter.status()?;
+            Ok(None)
+        }
+    }
 }
 
 #[cfg(all(test, not(target_arch = "wasm32")))]
@@ -808,6 +905,40 @@ mod test {
         Ok(())
     }
 
+    #[test]
+    fn explicit_transaction_does_not_rescan_own_writes() -> Result<(), DatabaseError> {
+        let temp_dir = TempDir::new().expect("unable to create temporary working directory");
+        crate::storage::check_explicit_transaction_does_not_rescan_own_writes(
+            crate::db::DataBaseBuilder::path(temp_dir.path()).build_rocksdb()?,
+        )?;
+        let temp_dir = TempDir::new().expect("unable to create temporary working directory");
+        crate::storage::check_explicit_transaction_does_not_rescan_own_writes(
+            crate::db::DataBaseBuilder::path(temp_dir.path()).build_optimistic()?,
+        )
+    }
+
+    #[test]
+    fn test_rocksdb_remove_range() -> Result<(), DatabaseError> {
+        let temp_dir = TempDir::new().expect("unable to create temporary working directory");
+        let storage = RocksStorage::new(temp_dir.path())?;
+        let mut transaction = storage.transaction()?;
+        crate::storage::check_remove_range(&mut transaction)
+    }
+
+    #[test]
+    fn test_rocksdb_range_rev_matches_range() -> Result<(), DatabaseError> {
+        let temp_dir = TempDir::new().expect("unable to create temporary working directory");
+        let storage = RocksStorage::new(temp_dir.path().join("pessimistic"))?;
+        let mut transaction = storage.transaction()?;
+        crate::storage::check_range_rev_matches_range(&mut transaction)?;
+
+        let storage = crate::storage::rocksdb::OptimisticRocksStorage::new(
+            temp_dir.path().join("optimistic"),
+        )?;
+        let mut transaction = storage.transaction()?;
+        crate::storage::check_range_rev_matches_range(&mut transaction)
+    }
+
     #[test]
     fn test_rocksdb_range_uses_iterate_upper_bound() -> Result<(), DatabaseError> {
         let temp_dir = TempDir::new().expect("unable to create temporary working directory");
@@ -916,7 +1047,7 @@ mod test {
             &table_cache,
             "test".to_string().into(),
             (Some(1), Some(1)),
-            read_columns,
+            &read_columns,
             true,
         )?;
 
@@ -967,26 +1098,27 @@ mod test {
             .columns()
             .map(|column| plan_arena.column(*column).datatype().serializable())
             .collect_vec();
+        let ranges = [
+            Range::Eq(DataValue::Int32(0)),
+            Range::Scope {
+                min: Bound::Included(DataValue::Int32(2)),
+                max: Bound::Included(DataValue::Int32(4)),
+            },
+        ];
         let mut iter: IndexIter<'_, _> = IndexIter {
             bounds: IterBounds::new(0, None),
             params: IndexImplParams {
                 index_meta,
                 meta_arena: plan_arena.table_arena_cell().borrow(),
                 table_name: table.name.clone(),
-                deserializers,
+                deserializers: std::borrow::Cow::Owned(deserializers),
                 total_len: table.columns_len(),
                 tx: &transaction,
                 cover_mapping: None,
                 with_pk: true,
+                reverse: false,
             },
-            ranges: vec![
-                Range::Eq(DataValue::Int32(0)),
-                Range::Scope {
-                    min: Bound::Included(DataValue::Int32(2)),
-                    max: Bound::Included(DataValue::Int32(4)),
-                },
-            ]
-            .into(),
+            ranges: (&ranges[..]).into(),
             state: IndexIterState::Init,
             inner: IndexImplEnum::PrimaryKey(PrimaryKeyIndexImpl),
             encode_min_buffer: Vec::new(),
@@ -1026,12 +1158,12 @@ mod test {
                     &plan_arena,
                     "t1".to_string().into(),
                     (Some(0), Some(1)),
-                    table.columns().cloned().collect(),
+                    &table.columns().cloned().collect::<Vec<_>>(),
                     table.indexes[0],
-                    vec![Range::Scope {
+                    &[Range::Scope {
                         min: Bound::Excluded(DataValue::Int32(0)),
                         max: Bound::Unbounded,
-                    }],
+                    }][..],
                     true,
                     None,
                     None,
@@ -1054,12 +1186,12 @@ mod test {
                     &plan_arena,
                     "t1".to_string().into(),
                     (Some(0), Some(1)),
-                    columns,
+                    &columns,
                     table.indexes[0],
-                    vec![Range::Scope {
+                    &[Range::Scope {
                         min: Bound::Excluded(DataValue::Int32(3)),
                         max: Bound::Unbounded,
-                    }],
+                    }][..],
                     true,
                     None,
                     None,
@@ -1103,19 +1235,20 @@ mod test {
             .ok_or(DatabaseError::InvalidIndex)?;
         let c1_deserializer = vec![plan_arena.column(c1_column).datatype().serializable()];
 
+        let c1_ranges = [Range::Scope {
+            min: Bound::Excluded(DataValue::Int32(0)),
+            max: Bound::Excluded(DataValue::Int32(10)),
+        }];
         let mut iter = transaction.read_by_index(
             kite_sql.state.table_cache(),
             &plan_arena,
             "t1".to_string().into(),
             (None, None),
-            vec![c1_column],
+            &[c1_column],
             idx_c1,
-            vec![Range::Scope {
-                min: Bound::Excluded(DataValue::Int32(0)),
-                max: Bound::Excluded(DataValue::Int32(10)),
-            }],
+            &c1_ranges[..],
             false,
-            Some(c1_deserializer),
+            Some(&c1_deserializer),
             None,
         )?;
 
@@ -1208,15 +1341,15 @@ mod test {
             &plan_arena,
             "t1".to_string().into(),
             (None, None),
-            reordered_columns,
+            &reordered_columns,
             composite_index,
-            vec![Range::Scope {
+            &[Range::Scope {
                 min: Bound::Unbounded,
                 max: Bound::Unbounded,
-            }],
+            }][..],
             false,
-            Some(reordered_deserializers),
-            Some(cover_mapping),
+            Some(&reordered_deserializers),
+            Some(&cover_mapping),
         )?;
         let first_tuple = crate::storage::next_tuple_for_test(&mut iter)?.unwrap();
         assert_eq!(
@@ -1227,6 +1360,7 @@ mod test {
 
         let target_pk = DataValue::Int32(3);
         let covered_value = DataValue::Int32(4);
+        let covered_ranges = [Range::Eq(covered_value.clone())];
         let mut table_codec = TableCodec::default();
         transaction.remove_tuple(&mut table_codec, "t1", &target_pk)?;
 
@@ -1235,11 +1369,11 @@ mod test {
             &plan_arena,
             "t1".to_string().into(),
             (Some(0), Some(1)),
-            columns,
+            &columns,
             unique_index,
-            vec![Range::Eq(covered_value.clone())],
+            &covered_ranges[..],
             false,
-            Some(covered_deserializers),
+            Some(&covered_deserializers),
             None,
         )?;
 
@@ -1265,15 +1399,15 @@ mod test {
             &plan_arena,
             "t1".to_string().into(),
             (None, None),
-            pk_columns,
+            &pk_columns,
             pk_index,
-            vec![Range::Scope {
+            &[Range::Scope {
                 min: Bound::Unbounded,
                 max: Bound::Unbounded,
-            }],
+            }][..],
             false,
-            Some(pk_deserializers),
-            Some(vec![0]),
+            Some(&pk_deserializers),
+            Some(&[0]),
         )?;
         let mut row_count = 0;
         while let Some(tuple) = crate::storage::next_tuple_for_test(&mut iter)? {
diff --git a/src/storage/table_codec.rs b/src/storage/table_codec.rs
index d1d485d7..e956a0bf 100644
--- a/src/storage/table_codec.rs
+++ b/src/storage/table_codec.rs
@@ -44,6 +44,7 @@ const KEY_TYPE_TAG_LEN: usize = 1;
 const KEY_BOUND_LEN: usize = 1;
 const TUPLE_KEY_PREFIX_LEN: usize = TABLE_NAME_HASH_LEN + KEY_TYPE_TAG_LEN + KEY_BOUND_LEN;
 const STATISTICS_BUCKET_ORD_LEN: usize = 4;
+const STAMP_LEN: usize = 8;
 
 static ROOT_BYTES: LazyLock<Vec<u8>> = LazyLock::new(|| b"Root".to_vec());
 static VIEW_BYTES: LazyLock<Vec<u8>> = LazyLock::new(|| b"View".to_vec());
@@ -58,6 +59,7 @@ type TupleValueWriter<'a> = &'a mut dyn FnMut(&Tuple, &mut Bytes) -> Result<(),
 pub struct TableCodec {
     buffers: [Bytes; 2],
     reference_tables: ReferenceTables,
+    stamp: u64,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -123,6 +125,39 @@ impl StatisticsCodecType {
 }
 
 impl TableCodec {
+    pub(crate) fn set_stamp(&mut self, stamp: u64) {
+        self.stamp = stamp;
+    }
+
+    pub(crate) fn stamp(&self) -> u64 {
+        self.stamp
+    }
+
+    pub(crate) fn with_stamp<R>(&mut self, stamp: u64, f: impl FnOnce(&mut Self) -> R) -> R {
+        let prev = std::mem::replace(&mut self.stamp, stamp);
+        let result = f(self);
+        self.stamp = prev;
+        result
+    }
+
+    pub(crate) fn is_own_write(&self, value: &[u8]) -> bool {
+        self.stamp != 0
+            && value
+                .len()
+                .checked_sub(STAMP_LEN)
+                .is_some_and(|n| value[n..] == self.stamp.to_le_bytes())
+    }
+
+    pub(crate) fn strip_stamp(value: &[u8]) -> Result<&[u8], DatabaseError> {
+        value
+            .len()
+            .checked_sub(STAMP_LEN)
+            .map(|n| &value[..n])
+            .ok_or_else(|| {
+                DatabaseError::InvalidValue("value is missing its statement stamp".into())
+            })
+    }
+
     #[inline]
     fn clear_buffers(&mut self) {
         self.buffers[CodecSlot::S0.index()].clear();
@@ -270,6 +305,7 @@ impl TableCodec {
         f: impl FnOnce(&[u8], &[u8]) -> Result<R, DatabaseError>,
     ) -> Result<R, DatabaseError> {
         self.clear_buffers();
+        let stamp = self.stamp;
         self.with_table_hash_buffers(table_name, |lower, table_hash, value, _| {
             Self::write_key_prefix(lower, CodecType::Tuple, table_hash);
             lower.push(BOUND_MIN_TAG);
@@ -277,6 +313,7 @@ impl TableCodec {
 
             if let Some((tuple, serializers)) = tuple_value {
                 serializers(tuple, value)?;
+                value.extend_from_slice(&stamp.to_le_bytes());
             }
 
             f(lower.as_slice(), value.as_slice())
@@ -396,6 +433,7 @@ impl TableCodec {
         f: impl FnOnce(&[u8], &[u8]) -> Result<R, DatabaseError>,
     ) -> Result<R, DatabaseError> {
         self.clear_buffers();
+        let stamp = self.stamp;
         self.with_table_hash_buffers(table_name, |lower, table_hash, value, _| {
             Self::write_key_prefix(lower, CodecType::Index, table_hash);
             lower.push(BOUND_MIN_TAG);
@@ -413,6 +451,7 @@ impl TableCodec {
 
             if let Some(tuple_id) = tuple_id {
                 tuple_id.encode_reference_value(&mut *value)?;
+                value.extend_from_slice(&stamp.to_le_bytes());
             }
 
             f(lower.as_slice(), value.as_slice())
@@ -761,7 +800,7 @@ impl TableCodec {
         S: Borrow<TupleValueSerializableImpl>,
     {
         tuple.pk = tuple_id;
-        tuple.deserialize_from_into(deserializers, bytes, total_len)
+        tuple.deserialize_from_into(deserializers, Self::strip_stamp(bytes)?, total_len)
     }
 
     fn encode_index_meta_value_into(
@@ -808,7 +847,7 @@ impl TableCodec {
     }
 
     pub fn decode_index(bytes: &[u8]) -> Result<TupleId, DatabaseError> {
-        DataValue::decode_reference_value(&mut Cursor::new(bytes))
+        DataValue::decode_reference_value(&mut Cursor::new(Self::strip_stamp(bytes)?))
     }
 
     fn encode_column_value_into(
@@ -1070,13 +1109,17 @@ mod tests {
             Some(DataValue::Int32(0)),
             vec![DataValue::Int32(0), DataValue::Decimal(Decimal::new(1, 0))],
         );
-        let mut bytes = Vec::new();
-        expected.serialize_to(
-            &[
-                LogicalType::Integer.serializable(),
-                LogicalType::Decimal(None, None).serializable(),
-            ],
-            &mut bytes,
+        let serializers = [
+            LogicalType::Integer.serializable(),
+            LogicalType::Decimal(None, None).serializable(),
+        ];
+        let mut write_value =
+            |tuple: &Tuple, value: &mut Bytes| tuple.serialize_to(&serializers, value);
+        let bytes = TableCodec::default().with_tuple(
+            "t1",
+            &DataValue::Int32(0),
+            Some((&expected, &mut write_value)),
+            |_, value| Ok(value.to_vec()),
         )?;
         let deserializers = table_catalog
             .columns()
@@ -1276,8 +1319,10 @@ mod tests {
     #[test]
     fn test_table_codec_index() -> Result<(), DatabaseError> {
         let tuple_id = DataValue::Int32(0);
-        let mut bytes = Vec::new();
-        tuple_id.encode_reference_value(&mut bytes)?;
+        let index = Index::new(0, &[], IndexType::Unique);
+        let bytes =
+            TableCodec::default()
+                .with_index("t1", &index, Some(&tuple_id), |_, value| Ok(value.to_vec()))?;
 
         assert_eq!(TableCodec::decode_index(&bytes)?, tuple_id);
 
diff --git a/src/types/index.rs b/src/types/index.rs
index bb9bda18..7a0ff9c4 100644
--- a/src/types/index.rs
+++ b/src/types/index.rs
@@ -70,18 +70,6 @@ pub enum IndexLookup {
     Probe,
 }
 
-impl IndexLookup {
-    pub(crate) fn bind_parameters(
-        &mut self,
-        params: &[(usize, DataValue)],
-    ) -> Result<(), DatabaseError> {
-        if let Self::Static(range) = self {
-            range.bind_parameters(params)?;
-        }
-        Ok(())
-    }
-}
-
 #[derive(Debug, Clone, Eq, PartialEq, Hash, ReferenceSerialization)]
 pub struct IndexInfo {
     pub(crate) meta: IndexMetaRef,
@@ -155,6 +143,24 @@ impl<'a> Index<'a> {
     }
 }
 
+impl IndexInfo {
+    pub(crate) fn is_reverse(&self) -> bool {
+        matches!(
+            &self.sort_option,
+            SortOption::OrderBy { fields, .. } if fields.first().is_some_and(|field| !field.asc)
+        )
+    }
+
+    pub(crate) fn reverse_order(&mut self) {
+        if let SortOption::OrderBy { fields, .. } = &mut self.sort_option {
+            for field in fields {
+                field.asc = !field.asc;
+                field.nulls_first = !field.nulls_first;
+            }
+        }
+    }
+}
+
 impl Explain for IndexInfo {
     fn fmt(&self, arena: &dyn MetaArena, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{} => ", self.meta.explain(arena))?;
@@ -163,6 +169,9 @@ impl Explain for IndexInfo {
             Some(IndexLookup::Probe) => f.write_str("Probe ?")?,
             None => f.write_str("EMPTY")?,
         }
+        if self.is_reverse() {
+            f.write_str(" Reverse")?;
+        }
         if self.covered_deserializers.is_some() {
             f.write_str(" Covered")?;
         }
diff --git a/src/types/value.rs b/src/types/value.rs
index e279eec4..e4ed887c 100644
--- a/src/types/value.rs
+++ b/src/types/value.rs
@@ -667,24 +667,20 @@ impl DataValue {
         digits.parse().ok()
     }
 
-    pub(crate) fn bind_parameters(
-        &mut self,
-        params: &[(usize, DataValue)],
-    ) -> Result<(), DatabaseError> {
+    pub(crate) fn bind_parameters<'p, F>(&mut self, get: &F) -> Result<(), DatabaseError>
+    where
+        F: Fn(usize) -> Option<&'p DataValue>,
+    {
         match self {
             DataValue::Parameter { id, ty } => {
-                let input = params
-                    .iter()
-                    .find_map(|(candidate, value)| (candidate == id).then_some(value));
-                if let Some(input) = input {
-                    *self = input.clone().cast(ty)?;
-                } else {
+                let Some(input) = get(*id) else {
                     return Err(DatabaseError::parameter_not_found(format!("${id}")));
-                }
+                };
+                *self = input.clone().cast(ty)?;
             }
             DataValue::Tuple(values) => {
                 for value in values {
-                    value.bind_parameters(params)?;
+                    value.bind_parameters(get)?;
                 }
             }
             _ => {}
diff --git a/tests/slt/alter_table_large.slt b/tests/slt/alter_table_large.slt
index b1268f08..3b523dd2 100644
--- a/tests/slt/alter_table_large.slt
+++ b/tests/slt/alter_table_large.slt
@@ -1,10 +1,8 @@
 statement ok
 create table alter_large (id int primary key, v1 int, v2 int)
 
-query I
+statement ok
 copy alter_large from 'tests/data/row_20000.csv' ( DELIMITER '|' );
-----
-20000
 
 query I
 select count(*) from alter_large
diff --git a/tests/slt/copy.slt b/tests/slt/copy.slt
index 96ec43d9..d6366524 100644
--- a/tests/slt/copy.slt
+++ b/tests/slt/copy.slt
@@ -2,10 +2,8 @@ statement ok
 create table test_copy (a int primary key, b float, c varchar(10))
 
 # copy data from tbl file
-query I
+statement ok
 COPY test_copy FROM 'tests/data/copy.tbl' ( DELIMITER '|' );
-----
-2
 
 query I
 SELECT * FROM test_copy
@@ -26,10 +24,8 @@ Copy To ./copy_query.csv [a, c]
 statement ok
 create table test_copy_query (a int primary key, c varchar(10))
 
-query I
+statement ok
 COPY test_copy_query FROM './copy_query.csv' ( DELIMITER ',', HEADER true );
-----
-1
 
 query I
 SELECT * FROM test_copy_query
diff --git a/tests/slt/insert.slt b/tests/slt/insert.slt
index e6e88b71..1f7d2424 100644
--- a/tests/slt/insert.slt
+++ b/tests/slt/insert.slt
@@ -124,3 +124,25 @@ insert into t3_decimal (id, v1) values (2, -10);
 
 statement ok
 drop table t3_decimal;
+
+statement ok
+create table t_insert_self(id int primary key, v int not null)
+
+statement ok
+insert into t_insert_self values (1,1), (2,2), (3,3)
+
+statement ok
+insert into t_insert_self select id + 1000, v from t_insert_self where id < 3000
+
+query I
+select id from t_insert_self order by id
+----
+1
+2
+3
+1001
+1002
+1003
+
+statement ok
+drop table t_insert_self
diff --git a/tests/slt/update.slt b/tests/slt/update.slt
index 13fbcc53..a03f1a0c 100644
--- a/tests/slt/update.slt
+++ b/tests/slt/update.slt
@@ -101,3 +101,24 @@ select id, b, c from t_update_idx where b = 10
 
 statement ok
 drop table t_update_idx
+
+statement ok
+create table t_update_pk(id int primary key, v int not null)
+
+statement ok
+insert into t_update_pk values (1,1), (2,2), (3,3), (4,4), (5,5)
+
+statement ok
+update t_update_pk set id = id + 1000 where id > 3 and id < 3000
+
+query I
+select id from t_update_pk order by id
+----
+1
+2
+3
+1004
+1005
+
+statement ok
+drop table t_update_pk
diff --git a/tests/sqllogictest/Cargo.toml b/tests/sqllogictest/Cargo.toml
index a090bda6..cd51e384 100644
--- a/tests/sqllogictest/Cargo.toml
+++ b/tests/sqllogictest/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 clap            = { version = "4" }
-"kite_sql"      = { path = "../..", features = ["copy", "decimal", "orm", "spill"] }
+"kite_sql"      = { path = "../..", default-features = false, features = ["copy", "decimal", "lmdb", "macros", "orm", "parser", "spill", "time"] }
 glob            = { version = "0.3" }
 sqllogictest    = { version = "0.14" }
 tempfile        = { version = "3.10" }
diff --git a/tests/sqllogictest/src/lib.rs b/tests/sqllogictest/src/lib.rs
index 69ca8eda..72f681f7 100644
--- a/tests/sqllogictest/src/lib.rs
+++ b/tests/sqllogictest/src/lib.rs
@@ -15,12 +15,12 @@
 use kite_sql::binder::{command_type, CommandType};
 use kite_sql::db::{prepare_all, Database, DatabaseIter, Statement};
 use kite_sql::errors::DatabaseError;
-use kite_sql::storage::rocksdb::RocksStorage;
+use kite_sql::storage::lmdb::LmdbStorage;
 use sqllogictest::{DBOutput, DefaultColumnType, DB};
 use std::time::Instant;
 
 pub struct SQLBase {
-    pub db: Database<RocksStorage>,
+    pub db: Database<LmdbStorage>,
 }
 
 impl DB for SQLBase {
@@ -66,7 +66,7 @@ impl DB for SQLBase {
 }
 
 fn collect_output(
-    mut iter: DatabaseIter<'_, RocksStorage>,
+    mut iter: DatabaseIter<'_, LmdbStorage>,
 ) -> Result<DBOutput<DefaultColumnType>, DatabaseError> {
     let types = vec![DefaultColumnType::Any; iter.schema(|schema| schema.len())];
     let mut rows = Vec::new();
@@ -88,7 +88,7 @@ fn collect_output(
 }
 
 fn execute_analyze_statement(
-    db: &mut Database<RocksStorage>,
+    db: &mut Database<LmdbStorage>,
     statement: &Statement,
 ) -> Result<(), DatabaseError> {
     let Statement::Analyze(analyze) = statement else {
diff --git a/tests/sqllogictest/src/main.rs b/tests/sqllogictest/src/main.rs
index c956e8e7..cdb0d472 100644
--- a/tests/sqllogictest/src/main.rs
+++ b/tests/sqllogictest/src/main.rs
@@ -52,7 +52,7 @@ fn main() {
         );
 
         let db = DataBaseBuilder::path(temp_dir.path())
-            .build_rocksdb()
+            .build_lmdb()
             .expect("init db error");
         let mut tester = Runner::new(SQLBase { db });
 
diff --git a/tpcc/README.md b/tpcc/README.md
index 977f91c0..b60481d6 100644
--- a/tpcc/README.md
+++ b/tpcc/README.md
@@ -10,9 +10,13 @@ Use the Python runner for local performance comparisons:
 ./scripts/run_tpcc_stable.py --build
 ```
 
-It runs the same four variants, but waits before each variant until the machine has enough consecutive stable samples:
+It runs the same four variants, pins TPCC to one CPU, and waits before each variant until the machine has enough consecutive stable samples.
 
-- CPU temperature is at or below `--cool-temp-c` (default `65.0`).
+TPCC runs as a single worker, so its speed depends on the core it lands on. On hybrid CPUs (P-cores and E-cores) an unpinned run can differ by 30-60% depending on scheduler placement. The runner therefore pins every variant, including its background threads, to the strongest core by default: the one with the highest `cpuinfo_max_freq`, lowest id on ties, skipping the physical core of `cpu0`. On hybrid CPUs this is a P-core, and on CPUs with Turbo Boost Max 3.0 it is one of the favored P-cores. Use `--cpu <n>` to choose one or `--no-cpu-pin` to disable pinning. The chosen CPU is recorded in `summary.md`.
+
+The runner waits until:
+
+- CPU temperature is at or below `--cool-temp-c` (default `70.0`).
 - CPU usage is at or below `--idle-cpu-percent` (default `20.0`).
 - At least `--min-cooldown-sec` seconds have passed after the previous variant (default `300`).
 - The state remains stable for `--stable-samples` samples (default `3`, sampled every `10s`).
@@ -46,12 +50,13 @@ Local 720-second comparison on the machine above:
 
 | Backend | TpmC | New-Order p90 (µs) | Payment p90 (µs) | Order-Status p90 (µs) | Delivery p90 (µs) | Stock-Level p90 (µs) |
 | --- | ---: | ---: | ---: | ---: | ---: | ---: |
-| KiteSQL LMDB | 134909 | 360 | 94 | 147 | 503 | 466 |
-| KiteSQL RocksDB | 43866 | 521 | 289 | 269 | 11711 | 902 |
-| SQLite balanced | 49200 | 304 | 74 | 53 | 375 | 518 |
-| SQLite practical | 43385 | 368 | 74 | 44 | 482 | 386 |
+| KiteSQL LMDB | 159616 | 315 | 81 | 44 | 435 | 332 |
+| KiteSQL RocksDB | 48035 | 459 | 258 | 200 | 11055 | 704 |
+| SQLite balanced | 67102 | 283 | 67 | 48 | 338 | 473 |
+| SQLite practical | 67153 | 336 | 66 | 41 | 427 | 339 |
 
-- Run dates: `2026-09-27`; results: `2026-09-27_00-14-16`. Latency is measured in microseconds and includes commit.
+- Run dates: `2026-10-01`; results: `2026-10-01_17-12-31`. Latency is measured in microseconds and includes commit.
+- Every row is pinned to `cpu8`, the highest-frequency P-core on this machine (5.4 GHz).
 - All rows use `--num-ware 1`, `--max-retry 5`, and TPCC's default 720-second measure time.
 - SQLite rows use the `balanced` and `practical` profiles respectively.