motedb-python 0.12.6__tar.gz

motedb_python-0.12.6/.cargo/config.toml

@@ -0,0 +1,8 @@
+# NOTE: `target-cpu=native` is intentionally NOT set globally. When placed in
+# [build] rustflags it would be inherited by:
+#   - downstream crates that depend on motedb (forcing their builds to a CPU
+#     they may not target),
+#   - cross-compilation (aarch64-linux etc.), producing non-portable binaries,
+#   - `cargo publish` consumers.
+# For local benchmarking that wants native CPU, build with:
+#   RUSTFLAGS="-C target-cpu=native" cargo build --release --example bench_300k

motedb_python-0.12.6/.devcontainer/devcontainer.json

@@ -0,0 +1,31 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/rust
+{
+	"name": "Rust",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+	"image": "mcr.microsoft.com/devcontainers/rust:2-1-trixie"
+
+	// Use 'mounts' to make the cargo cache persistent in a Docker Volume.
+	// "mounts": [
+	// 	{
+	// 		"source": "devcontainer-cargo-cache-${devcontainerId}",
+	// 		"target": "/usr/local/cargo",
+	// 		"type": "volume"
+	// 	}
+	// ]
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "rustc --version",
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

motedb_python-0.12.6/.github/workflows/ci.yml

@@ -0,0 +1,293 @@
+name: CI
+
+# Runs on every push to any branch and every pull request. This is the
+# fast-feedback gate that catches regressions BEFORE a release tag, unlike
+# publish.yml which only fires on `v*` tags.
+on:
+  push:
+    branches: ["**"]
+  pull_request:
+
+# Cancel superseded runs on the same ref so force-pushes don't queue up.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # ── Lint: strict fmt gate + clippy advisory ──────────────────────────────
+  # fmt is a hard gate (rustfmt is deterministic and the whole tree is now
+  # fmt-clean). clippy runs as advisory (exit code ignored) so the 14
+  # remaining style lints don't block merges while they're being cleaned up;
+  # the warnings are still surfaced in the run log.
+  lint:
+    name: fmt + clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+      - name: cargo fmt --check (strict)
+        run: cargo fmt --check
+      - name: cargo clippy (advisory — warnings do not fail the job)
+        run: cargo clippy --all-targets --all-features --no-deps
+        continue-on-error: true
+
+  # ── Supply-chain: vulnerability + license gate (cargo-deny) ──────────────
+  # Fails on any NEW RustSec advisory (vulnerability/unsound). Four known
+  # unmaintained-dep advisories are explicitly ignored in deny.toml with
+  # tracked reasons (bincode 1.x, and three via the optional jieba-rs). A new
+  # advisory with no ignore entry blocks the build until reviewed.
+  supply-chain:
+    name: cargo-deny (advisories + licenses)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Install cargo-deny
+        run: cargo install cargo-deny --locked
+      - name: cargo deny check
+        run: cargo deny check advisories licenses sources
+
+  # ── Unit tests (HARD gate, fast): library in-crate tests only ────────────
+  # `cargo test --lib` compiles a SINGLE binary (the lib's inline tests, 428
+  # of them) and runs in seconds — a fast, deterministic gate that catches
+  # the vast majority of regressions. Runs on both ubuntu and macOS so
+  # platform-specific compile/runtime issues surface here, not in the slow
+  # integration matrix.
+  unit-test:
+    name: unit (${{ matrix.os }})
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: ". -> target"
+      - name: cargo test --lib
+        env:
+          CI: "1"
+        run: cargo test --lib --all-features
+
+  # ── Native ARM64: unit tests on real aarch64 hardware ────────────────────
+  # The primary deployment target for embodied-intelligence edge devices is
+  # ARM (Jetson, RPi, RK3588). The cross-compile job below catches link/compile
+  # errors only; this job executes the actual unit-test suite on GitHub's free
+  # arm64 runners so runtime/atomic/memory-model issues surface before release.
+  arm64-test:
+    name: unit (arm64)
+    runs-on: ubuntu-24.04-arm
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: ". -> target"
+      - name: cargo test --lib
+        env:
+          CI: "1"
+        run: cargo test --lib --all-features
+
+  # ── Integration tests (HARD gate): the full tests/ matrix ────────────────
+  # `cargo test --workspace` compiles 64 test binaries (~40min cold) and runs
+  # them. 🔑 External production review (0.12.2 evaluation): this job was
+  # advisory (`continue-on-error`) — a failing integration suite did not
+  # block a release. It is now a hard gate: both retry attempts must pass.
+  # Hardware/timing-dependent tests stay excluded (resource/IO thresholds
+  # flap on shared runners; perf numbers are tracked in BENCHMARK.md).
+  integration-test:
+    name: integration (${{ matrix.os }})
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: ". -> target"
+      # 🔑 Release-blocker fix: macos arm64 shared runners flap (capacity
+      # notices + stale-artifact binary launch failures "exit 101, never
+      # executed" after cache restore). The suite itself passes locally on
+      # identical hardware (3956 passed / 0 failed). Retry once; the verdict
+      # step below fails the JOB when both attempts fail (hard gate).
+      - name: cargo test (workspace, hardware-threshold tests skipped) [attempt 1]
+        id: ci1
+        continue-on-error: true
+        env:
+          CI: "1"
+        # Debug build. Skip list excludes two categories of tests that can't
+        # reliably pass on shared runners:
+        #  1. Resource/IO-bound (RSS memory, disk usage) — thresholds depend on
+        #     the runner's hardware; flap on shared runners.
+        #  2. Performance/latency thresholds (µs/op, latency bounds) — assert
+        #     hardware-speed assumptions shared runners can't meet. Tracked in
+        #     BENCHMARK.md instead.
+        run: |
+          cargo test --workspace --all-features -- \
+            --test-threads=1 \
+            --skip bench_ --skip stress_ --skip perf_ \
+            --skip test_memory_linear \
+            --skip test_memory_leak \
+            --skip test_memory_does_not_grow_unbounded \
+            --skip test_disk_usage \
+            --skip test_no_bloat \
+            --skip test_perf_ \
+            --skip test_scan_latency_bounded \
+            --skip test_insert_latency_bounded \
+            --skip test_aggregate_latency_bounded \
+            --skip test_distinct_latency_bounded \
+            --skip test_where_latency_bounded \
+            --skip test_pk_select_latency_stable \
+            --skip test_latency_growth_sublinear \
+            --skip test_scalability_latency \
+            --skip test_scalability_memory \
+            --skip test_durability_large_dataset_checkpoint_recovery \
+            --skip test_performance_guarantees
+      - name: cargo test (workspace, hardware-threshold tests skipped) [attempt 2]
+        id: ci2
+        if: steps.ci1.outcome == 'failure'
+        env:
+          CI: "1"
+        run: |
+          cargo test --workspace --all-features -- \
+            --test-threads=1 \
+            --skip bench_ --skip stress_ --skip perf_ \
+            --skip test_memory_linear \
+            --skip test_memory_leak \
+            --skip test_memory_does_not_grow_unbounded \
+            --skip test_disk_usage \
+            --skip test_no_bloat \
+            --skip test_perf_ \
+            --skip test_scan_latency_bounded \
+            --skip test_insert_latency_bounded \
+            --skip test_aggregate_latency_bounded \
+            --skip test_distinct_latency_bounded \
+            --skip test_where_latency_bounded \
+            --skip test_pk_select_latency_stable \
+            --skip test_latency_growth_sublinear \
+            --skip test_scalability_latency \
+            --skip test_scalability_memory \
+            --skip test_durability_large_dataset_checkpoint_recovery \
+            --skip test_performance_guarantees
+      - name: verdict
+        if: always()
+        run: |
+          if [ "${{ steps.ci1.outcome }}" = "failure" ] && [ "${{ steps.ci2.outcome }}" = "failure" ]; then
+            echo "Both attempts failed — genuine integration regression"
+            exit 101
+          fi
+          echo "attempt 1 outcome=${{ steps.ci1.outcome }}, attempt 2 outcome=${{ steps.ci2.outcome }} — suite OK"
+      - name: diagnostics (per-binary pass → step summary + annotations)
+        if: failure()
+        run: |
+          # 🔑 K-debug: cargo 顶层一次跑时，crashing binary 会以 exit 101
+          # 中断整个套件且不留 FAILED 行。逐 bin 运行并把每个 bin 的退出码
+          # 通过 ::error:: annotations 上报（匿名可读）。
+          {
+            echo "### mac integration per-binary status"
+            BINS=$(cargo test --workspace --all-features -- --list 2>/dev/null \
+              | grep -E "^Running|^ " >/dev/null; cargo test --workspace \
+              --all-features --no-run 2>&1 | grep -oE "Executable tests/[a-z0-9_]+\.rs" \
+              | sed 's/Executable //;s/\.rs$//' | sort -u)
+            for t in $BINS; do
+              grep -qE "bench_|stress_" <<<"$t" && continue
+              cargo test --all-features --test "$t" -- --test-threads=1 \
+                --skip bench_ --skip stress_ --skip perf_ \
+                --skip test_memory_linear --skip test_memory_leak \
+                --skip test_memory_does_not_grow_unbounded \
+                --skip test_disk_usage --skip test_no_bloat --skip test_perf_ \
+                --skip test_scan_latency_bounded --skip test_insert_latency_bounded \
+                --skip test_aggregate_latency_bounded --skip test_distinct_latency_bounded \
+                --skip test_where_latency_bounded --skip test_pk_select_latency_stable \
+                --skip test_latency_growth_sublinear --skip test_scalability_latency \
+                --skip test_scalability_memory \
+                --skip test_durability_large_dataset_checkpoint_recovery \
+                --skip test_performance_guarantees --no-fail-fast \
+                > /tmp/one.log 2>&1
+              rc=$?
+              echo "::error title=mac-integration::$t exit=$rc"
+              if [ $rc -ne 0 ] && [ $rc -ne 101 ]; then
+                grep -E "panicked at|FAILED" /tmp/one.log | head -5 \
+                  | while read -r line; do echo "::error ::$line"; done
+              fi
+            done
+          } || echo "per-binary diagnostics done" >> "$GITHUB_STEP_SUMMARY"
+          } || echo "diagnostics pass done" >> "$GITHUB_STEP_SUMMARY"
+
+
+  # ── Cross-compile: aarch64-unknown-linux-gnu (build only) ────────────────
+  # Verifies the crate compiles for the primary edge/robotics target. We only
+  # build (no test run) since we don't have aarch64-linux hardware in the
+  # matrix; catching link/compile errors here is the main value.
+  cross-aarch64:
+    name: cross-compile aarch64-linux
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: aarch64-unknown-linux-gnu
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: ". -> target"
+          key: aarch64
+      - name: Install aarch64 cross linker
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
+      - name: cargo build (aarch64, default features)
+        env:
+          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
+        # Default features include jemalloc + tokenizer + rayon; verify they
+        # all cross-compile. We deliberately do NOT set target-cpu here (it is
+        # no longer in .cargo/config.toml).
+        run: cargo build --release --target aarch64-unknown-linux-gnu
+      - name: cargo build (aarch64, edge profile — no tokenizer/rayon)
+        env:
+          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
+        run: cargo build --release --target aarch64-unknown-linux-gnu --no-default-features --features jemalloc
+
+  # ── External-integration E2E: Python wheel + motedb-cli ──────────────────
+  # Catches the class of bug the in-process cargo tests structurally miss:
+  # packaging/linker (Linux `-undefined dynamic_lookup`), dlopen TLS
+  # (jemalloc initial-exec), flush-race visibility through the binding, and
+  # CLI/SQL entry-point drift (CHECKPOINT parsed in one client but not the
+  # other). Mirrors scripts/docker_e2e.sh without the container.
+  e2e:
+    name: e2e (${{ matrix.os }})
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 40
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: ". -> target"
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Build CLI binary
+        run: cargo build --release --bin motedb-cli
+      - name: Build + install Python wheel
+        uses: PyO3/maturin-action@v1
+        with:
+          working-directory: bindings/python
+          args: --release
+      - name: Install wheel
+        run: pip install bindings/python/target/wheels/*.whl
+      - name: Run E2E workload (11 suites)
+        env:
+          MOTE_CLI: ${{ github.workspace }}/target/release/motedb-cli
+        run: python bindings/python/e2e/e2e_workload.py --root /tmp/e2e

motedb_python-0.12.6/.github/workflows/fuzz.yml

@@ -0,0 +1,47 @@
+name: Fuzz
+
+# Daily short fuzzing campaign on both targets (SQL parser + WAL recovery).
+# 5 minutes each is enough to re-explore the existing corpus and push a few
+# million new inputs through the parser; crashes upload the artifact for
+# triage. Long campaigns remain a local/nightly concern.
+
+on:
+  schedule:
+    - cron: '0 19 * * *' # daily 19:00 UTC (03:00 +0800)
+  workflow_dispatch:
+
+jobs:
+  fuzz:
+    name: 5min x 2 targets
+    # ubuntu-22.04: the 24.04 kernel's ASLR mmap layout segfaults
+    # AddressSanitizer binaries at startup (even with vm.mmap_rnd_bits=28).
+    # 22.04's older kernel layout runs ASAN cleanly.
+    runs-on: ubuntu-22.04
+    timeout-minutes: 45
+    strategy:
+      fail-fast: false
+      matrix:
+        target: [fuzz_sql_parser, fuzz_wal_recover]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          override: true
+      - name: Install cargo-fuzz
+        run: cargo install cargo-fuzz --locked
+      - name: Lower ASLR entropy for ASAN
+        # ubuntu-24.04 runners default vm.mmap_rnd_bits=32, which makes any
+        # AddressSanitizer binary SIGSEGV at startup (silently, before
+        # libFuzzer prints its banner). 28 is the documented workaround.
+        run: sudo sysctl vm.mmap_rnd_bits=28
+      - name: Fuzz ${{ matrix.target }}
+        working-directory: fuzz
+        run: cargo fuzz run ${{ matrix.target }} -- -max_total_time=300 -rss_limit_mb=4096
+      - name: Upload crash artifacts
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: crash-${{ matrix.target }}
+          path: fuzz/artifacts/
+          if-no-files-found: ignore

motedb_python-0.12.6/.github/workflows/perf-gate.yml

@@ -0,0 +1,34 @@
+name: Perf Gate
+
+# Performance regression smoke gate.
+# Asserts core query-shape latencies against the full-scan baseline AS A
+# RATIO — machine-independent, so slower CI runners don't flake it. The
+# budgets carry ~2x headroom over measured ratios; they exist to catch
+# complexity-class regressions (e.g. the O(N²) text-eq path that shipped as
+# 568s vs 8ms — a 70,000x blowup), not few-percent noise.
+# Tool: examples/perf_smoke.rs
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  perf-smoke:
+    name: Query-shape ratio budgets
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: ". -> target"
+      - name: Build perf smoke (release)
+        run: cargo build --release --example perf_smoke
+      - name: Run perf smoke
+        run: ./target/release/examples/perf_smoke

motedb_python-0.12.6/.github/workflows/publish.yml

@@ -0,0 +1,95 @@
+name: Build and Publish to crates.io
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  # ── Hard gate: library unit tests (fast, deterministic) ──────────────────
+  # `cargo test --lib` compiles a SINGLE binary (429 in-crate tests) and runs
+  # in ~5s. Same strategy as ci.yml's hard gate: catches the vast majority of
+  # regressions deterministically. `publish` depends ONLY on this job.
+  #
+  # The full integration suite (`cargo test --workspace`) has an intermittent
+  # background-thread deadlock (~90 binaries run serially → index-builder /
+  # group-commit condvar permanent wait on CREATE INDEX + SELECT). Pre-existing
+  # concurrency issue, not a regression; does not reproduce in isolation. It is
+  # run as a separate advisory job below so its hang can never block a release
+  # (v0.7.2/v0.7.3/v0.7.4 all hit CI timeouts from this before the split).
+  unit-test:
+    name: Unit tests (hard gate)
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: ". -> target"
+      - run: cargo fetch
+      - name: cargo test --lib --all-features
+        env:
+          CI: "1"
+        run: cargo test --lib --all-features
+
+  # 注：integration 测试由 ci.yml 的 integration-test job 覆盖（advisory，
+  # 30min timeout）。publish.yml 不再重复跑 integration —— 全量 workspace 有
+  # 间歇并发 race（深层、概率性），即使 advisory 也会让 Actions 页面长时间
+  # 显示 in_progress。publish 仅依赖确定性的 unit-test（--lib，~5s）。
+
+  publish:
+    name: Publish to crates.io
+    needs: unit-test
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+
+      - name: Cache cargo registry and build artifacts
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: ". -> target"
+
+      - name: Install dependencies
+        run: cargo fetch
+
+      - name: Build (release)
+        run: cargo build --release
+
+      - name: Verify tag matches Cargo.toml version
+        if: startsWith(github.ref, 'refs/tags/')
+        run: |
+          TAG=${GITHUB_REF#refs/tags/}
+          echo "Tag: $TAG"
+          VERSION=$(grep '^version' Cargo.toml | head -n1 | sed -E 's/version\s*=\s*"(.*)"/\1/')
+          echo "Version from Cargo.toml: $VERSION"
+          if [ "v$VERSION" != "$TAG" ]; then
+            echo "Tag does not match version in Cargo.toml (v$VERSION expected). Aborting.";
+            exit 1;
+          fi
+
+      - name: Package check
+        # No --allow-dirty: the package must be clean so we never publish
+        # uncommitted changes or stray working files to crates.io.
+        run: cargo package
+
+      - name: Publish to crates.io
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_TOKEN }}
+        run: |
+          if [ -z "${CARGO_REGISTRY_TOKEN}" ]; then
+            echo "CARGO_TOKEN is not set in repository secrets. Aborting."; exit 1;
+          fi
+          cargo publish