feat: improve normalization rules and add tpcc benchmark runner

Author: KKould

Makefile

@@ -6,8 +6,9 @@ PYO3_PYTHON ?= /usr/bin/python3.12
 TPCC_MEASURE_TIME ?= 15
 TPCC_NUM_WARE ?= 1
 TPCC_PPROF_OUTPUT ?= /tmp/tpcc_lmdb.svg
+TPCC_SQLITE_PROFILE ?= balanced
 
-.PHONY: test test-python test-wasm test-slt test-all wasm-build check tpcc tpcc-kitesql-rocksdb tpcc-kitesql-lmdb tpcc-lmdb-flamegraph tpcc-sqlite-practical tpcc-dual cargo-check build wasm-examples native-examples fmt clippy
+.PHONY: test test-python test-wasm test-slt test-all wasm-build check tpcc tpcc-kitesql-rocksdb tpcc-kitesql-lmdb tpcc-lmdb-flamegraph tpcc-sqlite tpcc-sqlite-practical tpcc-sqlite-balanced tpcc-dual cargo-check build wasm-examples native-examples fmt clippy
 
 ## Run default Rust tests in the current environment (non-WASM).
 test:
@@ -65,9 +66,17 @@ tpcc-kitesql-lmdb:
 tpcc-lmdb-flamegraph:
 	CARGO_PROFILE_RELEASE_DEBUG=true $(CARGO) run -p tpcc --release --features pprof -- --backend kitesql-lmdb --measure-time $(TPCC_MEASURE_TIME) --num-ware $(TPCC_NUM_WARE) --pprof-output $(TPCC_PPROF_OUTPUT)
 
+## Execute the TPCC workload on SQLite with the practical profile.
+tpcc-sqlite:
+	$(CARGO) run -p tpcc --release -- --backend sqlite --sqlite-profile $(TPCC_SQLITE_PROFILE) --path kite_sql_tpcc.sqlite
+
 ## Execute the TPCC workload on SQLite with the practical profile.
 tpcc-sqlite-practical:
-	$(CARGO) run -p tpcc --release -- --backend sqlite --sqlite-profile practical --path kite_sql_tpcc.sqlite
+	$(MAKE) tpcc-sqlite TPCC_SQLITE_PROFILE=practical
+
+## Execute the TPCC workload on SQLite with the balanced profile.
+tpcc-sqlite-balanced:
+	$(MAKE) tpcc-sqlite TPCC_SQLITE_PROFILE=balanced
 
 ## Execute TPCC while mirroring every statement to an in-memory SQLite instance for validation.
 tpcc-dual:

README.md

@@ -183,8 +183,10 @@ Recent 720-second local comparison on the machine above:
 
 | Backend | TpmC | New-Order p90 | Payment p90 | Order-Status p90 | Delivery p90 | Stock-Level p90 |
 | --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| KiteSQL LMDB | 53510 | 0.001s | 0.001s | 0.001s | 0.002s | 0.001s |
+| KiteSQL RocksDB | 32248 | 0.001s | 0.001s | 0.002s | 0.011s | 0.003s |
+| SQLite balanced | 36273 | 0.001s | 0.001s | 0.001s | 0.001s | 0.001s |
 | SQLite practical | 35516 | 0.001s | 0.001s | 0.001s | 0.001s | 0.001s |
-| KiteSQL LMDB | 29171 | 0.001s | 0.001s | 0.001s | 0.015s | 0.002s |
 
 The detailed raw outputs for both runs are recorded in [tpcc/README.md](tpcc/README.md).
 #### 👉[check more](tpcc/README.md)

scripts/run_tpcc_matrix.sh

@@ -0,0 +1,177 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT_DIR"
+
+NUM_WARE="${TPCC_NUM_WARE:-1}"
+MAX_DUPLICATE_RETRY="${TPCC_DUPLICATE_RETRY:-1}"
+MAIN_MEASURE_TIME="${TPCC_MAIN_MEASURE_TIME:-}"
+STAMP="${TPCC_RESULT_STAMP:-$(date +%Y-%m-%d_%H-%M-%S)}"
+RESULT_DIR="${TPCC_RESULT_DIR:-$ROOT_DIR/tpcc/results/$STAMP}"
+LOG_DIR="$RESULT_DIR/logs"
+TMP_DIR="$ROOT_DIR/target/tpcc-run-data"
+BINARY="$ROOT_DIR/target/release/tpcc"
+SUMMARY_FILE="$RESULT_DIR/summary.md"
+
+mkdir -p "$LOG_DIR" "$TMP_DIR"
+
+if [[ ! -x "$BINARY" ]]; then
+    echo "missing binary: $BINARY" >&2
+    echo "build it first with: cargo build -p tpcc --release" >&2
+    exit 1
+fi
+
+extract_tpmc() {
+    local log_file="$1"
+    awk '/<TpmC>/{getline; print $1; exit}' "$log_file"
+}
+
+extract_p90() {
+    local log_file="$1"
+    local label="$2"
+    awk -v label="$label" '
+        /<90th Percentile RT \(MaxRT\)>/ { in_block = 1; next }
+        in_block && index($0, label) {
+            gsub(/^[[:space:]]+/, "", $0)
+            print $3
+            exit
+        }
+    ' "$log_file"
+}
+
+should_retry_duplicate() {
+    local log_file="$1"
+    rg -q "UNIQUE constraint failed|duplicate key|primary key|Duplicate" "$log_file"
+}
+
+run_variant() {
+    local name="$1"
+    local measure_label="$2"
+    local db_path="$3"
+    shift 3
+    local -a cmd=("$@")
+    local log_file="$LOG_DIR/$name.log"
+    local status="ok"
+    local notes="-"
+    local attempts=0
+    local max_attempts=$((MAX_DUPLICATE_RETRY + 1))
+
+    : > "$log_file"
+
+    while (( attempts < max_attempts )); do
+        attempts=$((attempts + 1))
+        rm -rf "$db_path"
+
+        {
+            printf '## Attempt %s\n' "$attempts"
+            printf '$'
+            printf ' %q' "${cmd[@]}"
+            printf '\n\n'
+        } >> "$log_file"
+
+        set +e
+        "${cmd[@]}" >> "$log_file" 2>&1
+        local cmd_status=$?
+        set -e
+
+        if [[ "$cmd_status" -eq 0 ]]; then
+            break
+        fi
+
+        if (( attempts < max_attempts )) && should_retry_duplicate "$log_file"; then
+            notes="retry after duplicate-key failure"
+            printf '\n[runner] duplicate-key style failure detected, retrying %s from scratch\n\n' "$name" >> "$log_file"
+            continue
+        fi
+
+        status="failed"
+        notes="$(tail -n 5 "$log_file" | tr '\n' ' ' | sed 's/[[:space:]]\\+/ /g; s/^ //; s/ $//')"
+        break
+    done
+
+    local tpmc="-"
+    local new_order="-"
+    local payment="-"
+    local order_status="-"
+    local delivery="-"
+    local stock_level="-"
+
+    if [[ "$status" == "ok" ]]; then
+        tpmc="$(extract_tpmc "$log_file" || echo -)"
+        new_order="$(extract_p90 "$log_file" "New-Order" || echo -)"
+        payment="$(extract_p90 "$log_file" "Payment" || echo -)"
+        order_status="$(extract_p90 "$log_file" "Order-Status" || echo -)"
+        delivery="$(extract_p90 "$log_file" "Delivery" || echo -)"
+        stock_level="$(extract_p90 "$log_file" "Stock-Level" || echo -)"
+    fi
+
+    printf '| %s | %s | %s | %s | %s | %s | %s | %s | %s | %s | %s | [%s](./logs/%s.log) |\n' \
+        "$name" \
+        "$status" \
+        "$attempts" \
+        "$measure_label" \
+        "$tpmc" \
+        "$new_order" \
+        "$payment" \
+        "$order_status" \
+        "$delivery" \
+        "$stock_level" \
+        "$notes" \
+        "$name" \
+        "$name" \
+        >> "$SUMMARY_FILE"
+
+    rm -rf "$db_path"
+
+    cat "$log_file"
+}
+
+cat > "$SUMMARY_FILE" <<EOF
+# TPCC Run Summary
+
+- Timestamp: $STAMP
+- Warehouses: ${NUM_WARE}
+- Duplicate-key retries per variant: ${MAX_DUPLICATE_RETRY}
+- Main variants measure time: ${MAIN_MEASURE_TIME:-tpcc default (720s)}
+- Binary: \`$BINARY\`
+
+| Variant | Status | Attempts | Measure Time | TpmC | New-Order p90 | Payment p90 | Order-Status p90 | Delivery p90 | Stock-Level p90 | Notes | Raw Log |
+| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | --- |
+EOF
+
+main_measure_args=()
+main_measure_label="tpcc default (720s)"
+if [[ -n "$MAIN_MEASURE_TIME" ]]; then
+    main_measure_args=(--measure-time "$MAIN_MEASURE_TIME")
+    main_measure_label="${MAIN_MEASURE_TIME}s"
+fi
+
+run_variant \
+    "kitesql-lmdb" \
+    "$main_measure_label" \
+    "$TMP_DIR/kitesql-lmdb" \
+    "$BINARY" --backend kitesql-lmdb "${main_measure_args[@]}" --num-ware "$NUM_WARE" --path "$TMP_DIR/kitesql-lmdb"
+
+run_variant \
+    "kitesql-rocksdb" \
+    "$main_measure_label" \
+    "$TMP_DIR/kitesql-rocksdb" \
+    "$BINARY" --backend kitesql-rocksdb "${main_measure_args[@]}" --num-ware "$NUM_WARE" --path "$TMP_DIR/kitesql-rocksdb"
+
+run_variant \
+    "sqlite-balanced" \
+    "$main_measure_label" \
+    "$TMP_DIR/sqlite-balanced.sqlite" \
+    "$BINARY" --backend sqlite --sqlite-profile balanced "${main_measure_args[@]}" --num-ware "$NUM_WARE" --path "$TMP_DIR/sqlite-balanced.sqlite"
+
+run_variant \
+    "sqlite-practical" \
+    "$main_measure_label" \
+    "$TMP_DIR/sqlite-practical.sqlite" \
+    "$BINARY" --backend sqlite --sqlite-profile practical "${main_measure_args[@]}" --num-ware "$NUM_WARE" --path "$TMP_DIR/sqlite-practical.sqlite"
+
+rm -rf "$TMP_DIR"
+
+printf '\nGenerated summary: %s\n' "$SUMMARY_FILE"

src/binder/select.rs

@@ -93,13 +93,13 @@ impl VisitorMut<'_> for SplitScopePositionRebinder<'_> {
         if let Some(left_position) = self
             .left_schema
             .iter()
-            .position(|candidate| candidate.summary() == column.summary())
+            .position(|candidate| candidate.same_column(column))
         {
             *position = left_position;
         } else if let Some(right_position) = self
             .right_schema
             .iter()
-            .position(|candidate| candidate.summary() == column.summary())
+            .position(|candidate| candidate.same_column(column))
         {
             *position = right_position;
         }

src/catalog/column.rs

@@ -66,6 +66,10 @@ pub struct ColumnSummary {
 }
 
 impl ColumnRef {
+    pub(crate) fn same_column(&self, other: &ColumnRef) -> bool {
+        self.summary() == other.summary()
+    }
+
     pub(crate) fn nullable_for_join(&self, nullable: bool) -> Option<ColumnRef> {
         if self.nullable == nullable {
             return None;
@@ -201,6 +205,39 @@ impl ColumnCatalog {
     }
 }
 
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod tests {
+    use super::{ColumnCatalog, ColumnDesc, ColumnRef};
+    use crate::errors::DatabaseError;
+    use crate::types::LogicalType;
+
+    #[test]
+    fn test_same_column_ignores_nullable_and_desc() -> Result<(), DatabaseError> {
+        let mut left = ColumnCatalog::new(
+            "c1".to_string(),
+            false,
+            ColumnDesc::new(LogicalType::Integer, None, false, None)?,
+        );
+        let mut right = ColumnCatalog::new(
+            "c1".to_string(),
+            true,
+            ColumnDesc::new(LogicalType::Bigint, None, false, None)?,
+        );
+        let left_ref = ColumnRef::from(left.clone());
+        let right_ref = ColumnRef::from(right.clone());
+
+        assert_ne!(left_ref, right_ref);
+        assert!(left_ref.same_column(&right_ref));
+
+        left.set_name("c2".to_string());
+        right.set_name("c3".to_string());
+        let left_ref = ColumnRef::from(left);
+        let right_ref = ColumnRef::from(right);
+        assert!(!left_ref.same_column(&right_ref));
+        Ok(())
+    }
+}
+
 /// The descriptor of a column.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, ReferenceSerialization)]
 pub struct ColumnDesc {

src/expression/mod.rs

@@ -240,6 +240,20 @@ impl ScalarExpression {
         ScalarExpression::ColumnRef { column, position }
     }
 
+    pub(crate) fn eq_ignore_colref_pos(&self, other: &ScalarExpression) -> bool {
+        match (self.unpack_alias_ref(), other.unpack_alias_ref()) {
+            (
+                ScalarExpression::ColumnRef {
+                    column: lhs_column, ..
+                },
+                ScalarExpression::ColumnRef {
+                    column: rhs_column, ..
+                },
+            ) => lhs_column.same_column(rhs_column),
+            (lhs, rhs) => lhs == rhs,
+        }
+    }
+
     pub fn unpack_alias(self) -> ScalarExpression {
         if let ScalarExpression::Alias {
             alias: AliasType::Expr(expr),
@@ -809,6 +823,38 @@ mod test {
     use std::sync::Arc;
     use tempfile::TempDir;
 
+    #[test]
+    fn test_eq_ignore_colref_pos() -> Result<(), DatabaseError> {
+        let left = ScalarExpression::column_expr(
+            ColumnRef::from(ColumnCatalog::new(
+                "c1".to_string(),
+                false,
+                ColumnDesc::new(LogicalType::Integer, None, false, None)?,
+            )),
+            0,
+        );
+        let right = ScalarExpression::column_expr(
+            ColumnRef::from(ColumnCatalog::new(
+                "c1".to_string(),
+                true,
+                ColumnDesc::new(LogicalType::Bigint, None, false, None)?,
+            )),
+            2,
+        );
+        let different = ScalarExpression::column_expr(
+            ColumnRef::from(ColumnCatalog::new(
+                "c2".to_string(),
+                false,
+                ColumnDesc::new(LogicalType::Integer, None, false, None)?,
+            )),
+            0,
+        );
+
+        assert!(left.eq_ignore_colref_pos(&right));
+        assert!(!left.eq_ignore_colref_pos(&different));
+        Ok(())
+    }
+
     #[test]
     fn test_serialization() -> Result<(), DatabaseError> {
         fn fn_assert(