ApexBase v1.29.0

2026-08-08

Compare with v1.28.0

• Introduce a streaming Row-Group rewrite engine for V4 storage: delta-file compaction, compressed-row-group deletes, and DROP COLUMN now merge/rewrite Row Group by Row Group via mmap into a temporary file followed by an atomic rename, so peak memory is O(largest Row Group + delta payloads) instead of the whole table — tables larger than physical memory can be compacted and restructured without OOM
• Make ALTER TABLE ADD COLUMN footer-only on mmap-only V4 tables: only the footer schema is updated, read paths synthesize all-NULL values for rows already on disk, and later compactions materialize the column; DROP COLUMN and ADD COLUMN materialize any pending delta first
• Chunk appends by row_group_size so a single large batch is split into multiple Row Groups, bounding per-RG buffers and preserving zone-map granularity regardless of batch size
• Upgrade in-memory String/Binary/StringDict column offsets from u32 to u64, eliminating silent truncation for columns larger than 4 GiB while keeping the on-disk format (u32 offsets per Row Group) unchanged and fully compatible with existing files
• Build store()/store_columnar() columns directly from borrowed Python buffers (&str / &[u8]) through a new write_typed_columns path, removing per-element String/Vec allocation and the typed intermediate copy; FTS string retention now happens only when FTS is enabled
• Fix _id leakage and missing-column padding in mmap read paths (RCIX extraction, indexed row reads, and filtered limit scans) that were exposed by footer-only ADD COLUMN, and align column projection on numeric-range filter fast paths
• Expand regression coverage with Rust and Python tests for streaming compaction across many row groups, footer-only ADD COLUMN, streaming DROP COLUMN, compressed deletes, append chunking, u64 offsets, and the borrowed-buffer write path, and refresh the storage architecture documentation
• Update the Rust crate and Python package version metadata to 1.29.0

ApexBase v1.28.0

2026-08-06

Compare with v1.27.0

• Fix create_table silently rebuilding an existing table: table names are now managed by a per-database metadata registry (binary .apex_tables catalog), so a fresh process calling create_table on an existing table raises Table already exists instead of wiping data; CREATE/DROP/ALTER and cross-process creation are serialized by an exclusive catalog lock
• Fix WHERE + ORDER BY ... DESC LIMIT returning rows only from the first matching row group: filtered scans now read the full matching set before global top-k sorting, and non-projected ORDER BY columns (including _id) are read so sorting is always applied
• Unify internal _id visibility: explicitly projecting _id returns it consistently before and after flush, independent of which cached read path handles the query
• Add a native batch numeric UPDATE path used by execute_batch for UPDATE ... SET <numeric col> = <literal> WHERE _id = N, reducing a 10,000-row backfill from roughly 28-40 seconds to about 0.1 seconds, and expose a projected mmap row-read API on the Rust crate
• Add general SQL parameter binding to the Python client: positional ?, named :name/@name/$name, IN-list expansion, string escaping, and arity/type validation, while keeping the TopK vector FFI fast path
• Introduce a binary, memory-mapped table catalog with per-entry CRC tamper detection, generation-based snapshot caching, and legacy *.apex backfill; the registry is the authoritative source of table names across processes
• Optimize core query routing: SQL classification results are cached in the core, and primary-key point/batch reads execute through a single combined FFI call on direct mmap readers, improving point lookups and projected ID batch reads
• Add cross-engine table-operation benchmarks (CREATE, DROP, CREATE+DROP, LIST, ALTER) and canary coverage, plus regression tests for the catalog, ORDER BY correctness, parameter binding, and batch updates
• Update the Rust crate and Python package version metadata to 1.28.0

ApexBase v1.27.0

2026-08-01

Compare with v1.26.0

• Optimize Arrow record batch processing for large, variable-length result sets, improving throughput for wide string and binary projections and reducing unnecessary materialization in Arrow conversion paths
• Add end-to-end support for large UTF-8 and binary values in Arrow-backed result batches, preserving correctness across to_arrow(), to_record_batches(), CREATE TABLE AS SELECT, and INSERT ... SELECT
• Improve JOIN and subquery execution so TopK-style lookups prune blob-heavy rows more effectively and keep qualified filters aligned with expected row semantics
• Introduce shared, mmap-backed table-epoch tracking so logical write invalidation is visible across processes and cached reads are invalidated more reliably after table mutations
• Strengthen on-demand storage projection and scan behavior for lazy column reads, including more precise pruning of unused columns and better handling of blob-aware reads
• Expand regression coverage for TopK parser/binding safety, join-filter behavior, blob projection, DML validation, and null/empty-value semantics
• Update the Rust crate and Python package version metadata to 1.27.0

ApexBase v1.26.0

2026-07-29

Compare with v1.25.0

• Harden V4 .apex file validation at open time: verify header/footer offsets, schema column counts, visible row counts, and row-group bounds, returning a clean corruption error for truncated or malformed files instead of risking a Rust panic
• Strengthen SQL DDL/DML validation and read-your-write consistency across INSERT, UPDATE, DELETE, schema changes, cached reads, numeric range statistics, and zone maps, including clearer errors for invalid types, column arity, and unsafe schema mutations
• Preserve SQL null semantics across expressions, grouping, aggregates, Arrow/Pandas conversion, temporary CSV tables, and projected row reads
• Improve vector topk_distance execution by validating query vectors and dimensions, applying filters before distance computation, and avoiding unnecessary reads of wide or unused BLOB columns in TopK JOINs
• Add binary parameter binding for single-query topk_distance calls, eliminating vector text interpolation in the Python API
• Extend full-text search with Boolean AND/OR/NOT expressions, configurable fuzzy matching, safer index reconfiguration, and richer index status information
• Add ApexClient.execute_batch_parallel for independent read-only SQL statements while retaining ordered execute_batch semantics for scripts
• Improve BLOB projection, CREATE TABLE AS SELECT, INSERT ... SELECT, Lance vector/temporal round-trips, correlated text subqueries, and process-safe concurrent writes
• Expand regression and performance coverage for storage corruption handling, DML and null edge cases, FTS, TopK JOINs with BLOB data, parallel batch execution, and Arrow batch-result APIs
• Update the Rust crate and Python package version metadata to 1.26.0

ApexBase v1.25.0

2026-07-26

Compare with v1.24.0

• Fix REPLACE(...) parsing in general expressions while preserving SELECT * REPLACE (...) projection syntax
• Add SQL scientific-notation numeric literals and move single-query vector TopK parameters to binary FFI instead of text interpolation
• Execute expression equality JOIN keys with hash join instead of Cartesian materialization, avoiding Arrow offset overflow on large joins
• Add error, skip, and warn malformed-row policies to CSV table functions, COPY, and temporary-table registration
• Align metric="cosine" with documented cosine-distance semantics; older releases could return the least similar rows for this alias
• Fix DELETE performance after UPDATE and append-only .delta growth by reusing file-derived delta caches across table epoch changes and avoiding full .delta rescans on the DELETE path
• Introduce a Database / Session façade so Python, Embedded, Server, and Flight query orchestration share one architecture boundary
• Unify table epoch cache invalidation so each logical write bumps the epoch once at the outermost scope, with merged delta reads that do not compact on the read path
• Split aggregation, DML, mmap scan, and Python bindings into domain modules while keeping parent files as thin assembly layers under architecture contract tests
• Move performance acceptance to local same-machine base/current guards, including canary and full runners, pytest runtime checks, and architecture contract coverage

ApexBase v1.24.0

2026-07-17

Compare with v1.23.0

• Add streaming, fixed-size RecordBatch imports for CSV and Parquet temporary tables, preserving rows and schemas across batch boundaries while keeping large file materialization memory-efficient
• Add direct Parquet COUNT(*) execution and numeric range-filtered GROUP BY aggregate fast paths to avoid unnecessary row materialization on common analytical queries
• Improve mmap range scans, numeric range LIMIT caching, aggregate WAL handling, and on-demand read/write paths for lower allocation and faster repeated queries
• Compact medium-cardinality string dictionaries using capacity derived from expected unique values, reducing memory overhead during ingestion and temporary-table workloads
• Correct schema-only V4 table writes and strengthen Arrow conversion, DML, blob, and storage handling across empty and incrementally populated tables
• Add an out-of-core CSV/Parquet benchmark against DuckDB covering direct file analysis, disk-backed materialization, repeated queries, peak RSS, and storage size
• Refresh the public ApexBase/SQLite/DuckDB benchmark scoreboard and performance documentation, including updated OLAP, OLTP, and vector metric accounting
• Expand Python regression coverage for cross-batch CSV/Parquet imports, file table functions, temporary tables, numeric range caching, SQL execution, and benchmark profile consistency
• Update the Rust crate and Python package version metadata to 1.24.0

ApexBase v1.23.0

2026-07-15

Compare with v1.22.0

• Replace the external nanofts crate with ApexFTS, an in-repo Rust full-text engine using .afts snapshots and checksummed .afts.wal
• Split ApexFTS into analyzer, engine, index, query, and storage modules while preserving Arrow zero-copy indexing paths such as add_documents_arrow_str
• Own the process allocator via mimalloc instead of inheriting one from the former FTS dependency
• Rebuild FTS from .apex table data when only legacy .nfts files remain; quarantine corrupt ApexFTS snapshots instead of opening them as valid data
• Improve query DDL/DML/select execution, SQL parsing, Python bindings, and FTS documentation and regression coverage
• Update the Rust crate and Python package version metadata to 1.23.0

ApexBase v1.22.0

2026-07-14

Compare with v1.21.0

• Add Lance dataset import/export helpers: ApexClient.from_lance, ApexClient.to_lance, and ResultView.to_lance
• Route Lance interoperability through Arrow tables for a lean in-process handoff while preserving ApexBase and Lance on-disk formats
• Add cost-based SELECT planning with executable candidate details, cardinality feedback, residual-predicate preservation, bounded join planning, and richer EXPLAIN timing and cost visibility
• Strengthen index and statistics correctness with generation-aware sidecars, typed composite keys, composite-prefix and range access, AND intersection, OR union, covering-index costs, Zone Map costs, and controlled row-id materialization
• Expand Hive-style user behavior benchmark coverage with 360-degree, complex, most-complex, and syntax-torture workloads plus DuckDB and SQLite equivalents
• Improve aggregation, DML, expression, join, window, mmap, and embedded execution paths for complex SQL and indexed workloads, with broader regression coverage for edge cases
• Refine memory-efficient public APIs and add Python and Rust memory benchmarks for internal and embedded access paths
• Expand the public benchmark scoreboard with 18 common OLTP microbenchmarks covering direct row counts, point reads, missing-row lookups, small projected reads, single-row writes, update/delete-by-id paths, and read-your-write checks
• Expand the public OLAP benchmark scoreboard with category/grouped ordering, HAVING, ascending TopK, distinct-count, JSON group-by, and filtered city aggregation metrics
• Reuse global string dictionary caches for filtered string aggregations so predicates such as city = 'Beijing' can aggregate numeric columns without reparsing the filter column
• Refresh README branding and performance snapshot documentation
• Update the Rust crate and Python package version metadata to 1.22.0

ApexBase v1.21.0

2026-07-09

Compare with v1.20.1

• Add Lance-like BLOB / LARGE_BINARY column support with descriptor-backed storage for inline, packed sidecar, and dedicated sidecar payloads
• Keep blob payloads lazy by storing compact descriptors in .apex column data and materializing Arrow LargeBinary values only when blob columns are projected
• Add Python helpers for single and batch payload access: read_blob, read_blobs, read_blob_range, read_blob_ranges, read_blob_descriptor, read_blob_info, and read_blob_infos
• Extend the Rust engine, SQL parser, Arrow conversion layer, Python bindings, WAL path, mmap path, and on-demand storage pipeline to handle Blob values end to end
• Add blob-focused performance coverage with benchmarks/bench_blob_lance.py, comparing ApexBase blob write/read/projection behavior against Lance Blob API
• Update the Rust crate and Python package version metadata to 1.21.0

ApexBase v1.20.1

2026-06-30

Compare with v1.20.0

• Add dynamic time-based column defaults in CREATE TABLE, including DEFAULT CURRENT_DATE, DEFAULT CURRENT_TIMESTAMP, DEFAULT NOW, and DEFAULT UNIX_TIMESTAMP()
• Add row-independent DEFAULT expressions, including arithmetic such as DEFAULT (60 * 60), scalar functions such as DEFAULT LOWER('ACTIVE'), and typed casts such as DEFAULT CAST('2026-01-02' AS DATE)
• Add INSERT DEFAULT VALUES and VALUES(DEFAULT, ...) support so rows can explicitly use declared column defaults
• Apply defaults during INSERT for omitted columns and explicit DEFAULT values, with type-aware output for DATE, TIMESTAMP, string, integer, and floating-point columns
• Persist literal, expression-folded, and dynamic default definitions in on-demand table schemas so constraints survive save/reopen cycles
• Store SQL DATE and TIMESTAMP expression values through table and incremental storage paths by mapping them to their numeric backing representation
• Reject DEFAULT expressions that reference table columns or subqueries, keeping defaults row-independent and deterministic except for the supported time functions
• Add Rust and Python regression coverage for dynamic DEFAULT functions, constant-expression folding, cast defaults, INSERT DEFAULT VALUES, VALUES(DEFAULT, ...), and invalid column-reference defaults
• Update Rust crate and Python package version metadata to 1.20.1

Changed files by module

Module	Files changed
Project Config	2
Documentation	1
Python Package	1
Query Engine	4
Storage Engine	2
Tests	1