UQA Engine v0.6.3

Changed

• Document supported native and browser platforms and source builds, including direct Rust crate use and C/C++/Swift static-library integration on iOS and iPadOS.

Fixed

• Reuse row metadata values within projected aggregate batches, avoiding repeated temporary value construction while preserving requested document IDs, scores, table OIDs, stored columns with the same names and row diagnostics.
• Reduce memory required by large multi-row INSERT statements by compacting scalar planning storage, retiring obsolete logical plans and choosing command spill runs from retained decoded-row memory. The unchanged 20,000-row analytical fixture fits the default 64 MiB session retention allowance on memory, native SQLite, SQLite Key/Value and redb, preserving quota errors and savepoint recovery.
• Preserve the invoking scope and deadline for nested SQL cursors. Trigger transition relations bind their current values and column types instead of reusing ordinary-table analysis; nested batch and cursor planning releases preliminary logical plans while preserving valid outer analysis.
• Report native planning storage for EXPLAIN (MEMORY) in TEXT, JSON, XML and YAML before execution, including prepared and supported utility paths. Measure exposed executable and resident constant allocations, preserve option visibility and avoid reading spilled values; see the SQL contract. Retain the implemented join-search, constant, analysis-cache, statistics and scalar ownership corrections without claiming a complete planning-memory cap.
• Handle active catalog-refresh failures inside the statement transaction owner. SQL, Simple Query, cursor and prepared execution now abort the current frame or savepoint on refresh failure and retain the normal transaction recovery path.
• Count standard, whitespace and letter-tokenizer emissions before reserving their output arrays, avoiding simultaneous old and replacement arrays under a tight shared allowance. Token terms, source spans, positions, cancellation and analyzer identities are unchanged.
• Spill large transaction-private writable tiers before command snapshots or savepoints retain them, leaving workspace for later producers under the same session allowance. Frozen views preserve their revisions and values; rollback and failed capture preserve logical state. Immediate record reads use the current owner without sealing a retained root, preserving bounded mutation membership and node lookups.
• Bound native SQLite text mutation staging with encrypted spill records instead of retaining every changed posting row in memory. Consecutive projections coalesce before encoding; complete row encodings reserve once and release consumed projection buffers before capture. Each mutation shares decoded private blocks within its fixed read view and releases them before publication. Indexed replacements preserve prefix deletion, cancellation, atomic publication and the existing session memory limit.

Packages

Python wheels, a Python source distribution, the Node.js root npm package, @cognica-io native optional packages, standalone native addons, and the browser WASM package are attached to this release.

Standalone usql archives for Linux, macOS and Windows (x86_64 and ARM64), SHA-256 checksums, and install-usql.sh / install-usql.ps1 are also attached. The CLI includes Nori, Kuromoji, Arrow and DuckDB. Cargo users can install the binary without compilation using cargo binstall uqa-cli --strategies crate-meta-data.

C shared/static library packages for Linux and macOS (x86_64 and ARM64) and Windows x86_64 are attached with SHA-256 checksums, installed headers, CMake/pkg-config targets and per-target build/license inventories. Their C11/C++17 consumers run against all four storage providers before packaging.

crates.io status: Live publication of all public Rust workspace crates at version 0.6.3 completed by this workflow.

PyPI status: Published as uqa==0.6.3.
npm status: Published as @cognica-io/uqa@0.6.3 with native optional packages, and as @cognica-io/uqa-wasm@0.6.3.

Benchmarks

Release benchmark JSON and Markdown reports come from the successful package-build workflow and are attached separately. See the measurement status. Each report records its tag, commit, runner, build and workflow attempt. Shared-runner timing is informational and does not establish performance acceptance.

Licensing: Apache-2.0 for project code; third-party components retain their own licenses. See LICENSING.md from this release for its terms and any additional permissions.

UQA Engine v0.6.2

Added

• Add the embedded C ABI with uqa_* symbols, opaque handles, status returns and library-owned diagnostics. C11/C++17 applications can execute SQL messages, prepared statements, cursors and batches, bind typed values, register scalar/table/aggregate UDFs and use notices, notifications, backup and cancellation on memory, native SQLite, SQLite Key/Value and redb. Native shared/static packages provide installed headers, CMake and pkg-config targets on Linux x86_64/aarch64, macOS x86_64/arm64 and Windows x86_64. Host logging remains declaration-only. See the C API and installed-consumer guide.

Changed

• License project-owned code under Apache 2.0 beginning with 0.6.2. Replace the AGPL base license and optional FOSS/noncommercial application exceptions in future distributions, retain third-party licenses and attribution, and preserve the terms of already published releases.

• Update the maintained SQLite driver to uqa-rusqlite 0.39.3 and uqa-libsqlite3-sys 0.37.3, bundling SQLCipher 4.19.0 / SQLite 3.53.4 with the official extension callback correction and subsequent upstream fixes. Complete crypto initialization before concurrent connections can open and register export through SQLite's existing connection initialization hook. Retain the Rust wrapper API, plain SQLite bundle, connection-local cache reclamation and existing UQA format requirements.

• Preserve the full PostgreSQL timestamp range with native microseconds since 2000-01-01 and retain TIMETZ offsets in seconds. Readers convert predecessor encodings; SQLite record format 67 and redb record format 63 exclude incompatible writers. See the upgrade requirements.

• Share immutable named and anonymous composite metadata through SQL construction, controlled copies and result conversion. Rust RecordValue callers now use explicit positional values and borrowed field iteration instead of a mutable pair-vector dereference; see the Rust API migration. SQL observations and persistent formats are preserved.

• Move owned cursor and columnar output values into their result columns without copying exclusive strings or compound payloads. Preserve shared scan owners, duplicate output positions, fragment projections and zero-column row counts while avoiding unused payload copies.

• Custom Rust QueryPlan constructors initialize analyzed_output: None and analyzed_source: None. Executable plans share positional output and input descriptors from statement analysis; serialized definitions omit them and resolve their next catalog scope normally. Custom prune_query_outputs callers also pass optional selected-routine and volatility catalogs for UNION-member boundaries.

• Custom Rust correlation and subquery adapters now supply the invoking routine catalog so declared TABLE and composite results preserve the selected function identity and full output schema.

• Rust constructors for FromClause::Values, FromClause::Subquery, SourcePlan::Values and SourcePlan::Subquery now supply a lateral flag belonging to that range item. Existing serialized nodes without the field still decode; legacy right-side permission on Join::lateral remains supported. FromClause::Join and SourcePlan::Join also supply comma to distinguish source lists from explicit joins.

• Rust column and qualified-wildcard AST/IR names use ReferenceName, retaining transient source positions while keeping name equality, hashing and serialized strings unchanged. Custom routine constructors supply body_origin: None; protocol diagnostic constructors also expose internal query and position fields.

Fixed

• Decode PostgreSQL-epoch timestamps and second-resolution TIMETZ offsets in browser HTTP results. Preserve exact microseconds through epoch conversion at JavaScript's safe-integer boundaries and continue rejecting unsafe wire integers.

• Retain native parallel workers through Execution-owned pools shared by an engine family, honor the configured worker limit, and complete worker cleanup when the last external owner is dropped. Host callbacks retain their statement context, and nested work reuses the selected pool.

• Correct PostgreSQL 18.4 parser callback types and allocator cleanup through the maintained parser forks. Preserve the parser schema and public API while releasing thread-local caches on POSIX and Windows and supporting explicit parser exit followed by reuse.

• Release the shared deadline timer when its last token or scheduled action ends, joining thread cleanup instead of leaving a detached process-lifetime worker. Reuse the timer across a session's successive deadlines and release captured actions outside the deadline queue lock.

• Apply the invoking allocation allowance and cancellation to the private native XML parser and domain base input. Retain constraint metadata before callbacks, borrow the admitted domain value during checks, release failed input allocations and preserve native transaction recovery. Private parser symbols and allocator state remain separate from a host application's XML library.

• Preserve analyzed OID and XID identities during assignment, including the full unsigned 32-bit range, without interpreting their carriers as signed SQL integers.

• Implement PostgreSQL integer bitwise AND, OR, XOR, complement and shifts with selected 16/32/64-bit widths, mixed-input coercions and strict NULL behavior; preserve smallint shift promotion, stored expression identities and PostgreSQL parentheses when nested numeric expressions are rendered and reparsed.

• Preserve PostgreSQL strict constant-NULL arithmetic and concatenation behavior, including selected result types, volatile operand effects, child constant errors and generic prepared parameters. Keep positional integer aggregation available through retained arithmetic result metadata without erasing casts or changing selected widths. Preserve analyzed GROUP BY DISTINCT multiplicity before folding without changing stored view syntax or correlated input visibility, and keep independent enclosing values available through aggregate finalization and empty local inputs.

• Eliminate statically empty function scans before initializing their routines or argument functions, matching PostgreSQL for folded false/NULL inputs and eligible UNION ALL branches. Preserve relation permissions, runtime-empty and LIMIT 0 initialization, aggregate rows, set-operation boundaries and outer-join NULL extension.

• Reuse bound routine identity and argument conversion metadata within an unchanged native scope, including SQL body/output descriptions, PL/pgSQL declaration/assignment/return metadata, bound table/set-projection result declarations and immutable correlated ROWS FROM call inputs. Prepared procedural parameters preserve their selected types directly. Preserve live defaults, domain checks, privileges, function replacement, changed record/output schemas, row delivery and rollback. Retired routine bodies are released without waiting for expression metadata to expire.

• Reuse successful catalog-sensitive cast descriptions within an immutable native expression scope, avoiding repeated qualified type lookup while preserving live values, domain checks, session settings, schema changes and mutable custom hooks.

• Reuse complete SELECT privilege coverage for unchanged direct derived sources under the same catalog, namespace and role incarnation, avoiding repeated lineage analysis while retaining column denials, view/routine authority and changed-scope checks.

• Reuse successfully bound scalar-query descriptions within one clause-validation call and transfer fresh derived-source metadata into physical assembly. Avoid repeated grouping-alias and nested source analysis while preserving complete scope descriptors, routine selection and the original diagnostics.

• Collect eligible complete SQL results directly from stable decoded memory fields, avoiding temporary shared-row ownership while preserving pure predicates, positional/duplicate output values, exact scan accounting, cancellation and cleanup. Computed, locking, metadata and fallible-provider paths retain ordinary physical row delivery.

• Encode fragmented physical rows for spill in linear traversal order, avoiding repeated fragment searches while preserving serialized values, NULL slots and row-lock metadata.

• Prepare immutable stored-scan projection decisions once, avoiding repeated column checks per page and slot checks per row while preserving generated columns, tuple metadata, locking and rechecks.

• Inspect ordinary public SQL result values once for deferred Datum and enum carriers, avoiding duplicate recursive walks while preserving payload ownership, nested metadata and output-error order.

• Move only selected physical values into named SQL results. Avoid copying discarded fragmented payloads, release row-local aliases before donation, and copy repeated selected values only when their public output requires it.

• Preserve native producer batches for complete SQL results when both the consumer and producer preserve evaluation order, avoiding one pipeline pull and batch allocation per row on eligible paths. Computed projections, early-stop, cardinality and directional consumers retain their original evaluation, side-effect and error boundaries.

• Update ctutils to restore constant-time cryptographic operations, Tokio to fix AsyncFd I/O safety, and clipboard-win to the maintained non-yanked patch release. Existing dependency audit and licensing policies remain enforced.

• Read externally shared scan rows directly into columnar output, avoiding per-row projection sorting and failed ownership transfers while retaining payload donation from the final exclusive owner.

• Index exact in-memory document la...

UQA Engine v0.6.1

Added

• Added a released-package TPC-H comparison that validates an installed usql and a local PostgreSQL 18 server against the checked-in PostgreSQL 18 results and times both in alternating rounds. The 0.6.0 measurement and the latency regression since the 2026-08-09 snapshot, tracked in #1108, are recorded in the TPC-H benchmark README.

Fixed

• Preserve private foreign-table definitions and ownership across concurrent catalog refresh, including creation, alteration, rename, deletion, recreation and transaction undo.

• Restore retained Unicode 17 analyzer descriptors with their original mappings, context properties and fingerprints alongside the pinned Unicode 16 profile, without rewriting existing indexes.

• Prepare immutable transaction records outside the statement-snapshot gate while preserving writer exclusion, conflict checks and atomic data/metadata publication.

• Avoid duplicate native commit verification payloads and redundant encrypted spill reads, and move file-pool WAL checkpoints to managed maintenance while retaining FULL commit synchronization.

• Merge stored and private row identities without repeatedly scanning replaced base rows, and avoid loading row payloads for identity-only projections. Private decoded blocks remain bounded and are released after their read batch.

• Avoid repeated read-ahead of mixed-width scan rows, repeated fragment searches during exact byte accounting and redundant compact text-group key work while preserving exact batch sizes, NULL distinctions and group identities.

• Remove redundant metadata from private transaction roots while preserving explicit spill thresholds across forks, savepoints and rollback.

• Reject distrusted emSign certificate chains by updating rustls-webpki and both bundled root-certificate packages to their patched releases.

• Bound complete text support in hybrid COPY with finite vector pools, preserving native calibration, exact score bits, selected generations and output-failure rollback.

• Share immutable memory-vector roots across read and rollback snapshots, retaining complete payload admission and independent writes without copying the vector corpus on capture.

• Bound exact retained-vector top-K selection by its requested candidate count while preserving tensor cosine scores, ties and the original read allowance.

• Bound complete text-search and relational-filter inputs before COPY output, including AND/OR/NOT, exact Bayesian text fusion, robust positive-evidence pooling, all-field scoring and inherited or partitioned tables. Preserve exact scores, table-local identities, NULL behavior, command visibility, statement snapshots, cancellation and committed tuple rechecks.

• Bound exact ANALYZE and cold memory-engine statistics collection with paged snapshots and spill-backed distribution input, preserving distinct/NULL counts, histogram boundaries, MCV frequencies and transaction publication.

• Bound scalar-filter index candidate capture and replay, preserving command masks, tuple rechecks, residual predicates and snapshot results without a complete posting or identity vector.

• Reuse fixed cast source metadata across physical rows while preserving live catalog resolution, routine execution, domain constraints and input schema changes.

• Reuse successful WHERE/HAVING subquery bindings within the same condition while preserving correlated scopes, declared types, collations, record metadata and PostgreSQL diagnostic order.

• Borrow unchanged execution query blocks instead of copying their complete expression and nested-plan payloads on every SELECT, derived-table or lateral invocation. Table-function identities, deferred DISTINCT slices and lateral grouping rewrites still use private mutable copies.

• Reuse builtin temporal cast type selection across rows while preserving live DateStyle, TimeZone, IntervalStyle, callbacks, precision and cancellation.

• Bound cold value-index restoration, evaluated-key capture and repeatable probes; publish cache changes atomically while preserving stored expression keys, exact physical ordering, independent snapshots, cancellation and storage errors. Ordered construction reuses completed subtree metadata instead of rereading it.

• Reuse validated immutable scan schema sizes between batches, avoiding repeated column-type serialization while preserving exact spill and lock-origin accounting.

• Preserve declared fusion signal order during optimization, including exact score bits, positional pooling parameters and the first failing signal.

• Add bounded, searchable value-index ownership over encrypted private-record snapshots, preserving exact key order, atomic roots and storage errors.

• Bound fallible index-comparison identities before row reads, preserving exclusions, private changes and typed page errors.

• Visit stored B-tree keys through one retained provider boundary, preserving snapshot visibility and first consumer errors without collecting the complete population.

• Bound partial and expression unique-index candidate capture, preserving equality, NULL distinction, staged masking and original failure order.

• Bound MERGE target identities and locked successor images while preserving target lock order, exact refreshed-row actions and original failure precedence.

• Bound initial constraint-validation identity capture before row evaluation, preserving selected/live visibility and original failure order without a whole-table identity vector.

• Share immutable CTE and scalar-subquery plans across binding and execution scopes while preserving independent lexical maps, mutable execution ownership and scalar-cache identities.

• Bound expanded scalar-projection output before COPY and query consumers, preserving input-batch error order, row positions, cancellation and directional cursor behavior.

• Materialize public SQL rows as each input batch arrives, reusing schema conversion and final output capacity without intermediate result vectors. Release completed physical inputs before the next pull while preserving positional metadata, compatibility labels and statement evaluation order.

• Bound deferred foreign-key parent keys with exact spill-backed membership while preserving cross-type comparison, validation order, cancellation and rollback.

• Bound PERIOD foreign-key parent ranges and lock identities with the existing spill owners while preserving range coverage, parent lock order and transaction results.

• Spill external-sort run descriptors sequentially instead of retaining one buffer and file owner per run, preserving comparison order and stable merge results.

• Bound referential candidate capture across native index probes, command overlays and selected snapshot fallbacks.

• Stream native equality candidates under the original snapshot and read allowance without collecting all matching identities.

• Spill referential target identities and prepared cascade images while preserving selection, lock rechecks and writer admission.

• Bound joined UPDATE identity capture, physical lock membership and prepared publication without moving snapshot or trigger boundaries.

• Retain complete view mutation inputs and pending OLD/NEW images in bounded spill owners without changing rule, trigger or assignment evaluation order.

• Bound projected ordered scan batches by work memory while preserving source order, metadata and NULL slots.

• Collect complete SQL results incrementally without retaining a second population of physical batches or cloning each spilled batch before positional output. Avoid recursive-copy overhead for fixed-width scalar values while preserving owned payloads and retained type metadata.

• Bound UNION, INTERSECT and EXCEPT output batches by bytes while preserving row order and duplicate multiplicities across batch boundaries.

• Retain wide lazy rule inputs and VALUES constants once through shared immutable handles, preserving demand order and typed observations.

• Bound command and statement AFTER-trigger event retention with ordered spill replay, preserving transition-table visibility and reentrant cascades.

• Resolve scalar-subquery correlation against retained CTE and trigger transition relation descriptors, preserving local aliases and genuine outer dependencies.

• Bound UPDATE tuple-lock deduplication with exact spill-backed physical identities while preserving first-target selection, partition distinctions, cancellation and typed memory errors.

• Stream scalar UPDATE and DELETE filter candidates through bounded identity pages and per-row projection, preserving indexed access, command snapshots and late-error rollback.

• Capture UPDATE and DELETE candidate identities through bounded snapshot pages before row effects; preserve frozen visibility, hierarchy order, tuple rechecks and typed resource errors.

• Share bounded MVCC blocks across frozen snapshot point reads, avoiding repeated file reads during DELETE identity membership checks while preserving visibility, cancellation and cache admission.

• Preserve spill-backed physical row membership when query work memory is smaller than one key, keeping mandatory run metadata and I/O scratch separately admitted instead of rejecting ordinary DELETE work.

• Bound DELETE qualification and root-row identity sets with encrypted ordered spill, preserving trigger selection, savepoint recovery and deferred PERIOD exclusions without complete identity-set copies.

• Bound trigger transition-image capture and materialization by row bytes, preserving raw OLD/NEW values, late relation-type lookup, row order, named-column projection, absent images and repeatable reads.

• Bound rewrite-rule matching, original-row suppression, required columns and local-to-original ordinal maps with compact uniform states and spill-backed selections, preserving event order, duplicate ordinals, suppression unions, lazy OLD/NEW projection and cancellation.

• Rewrite-rule view INSERT retains completed input values and their as...

UQA Engine v0.6.0

Added

• Add the uqa-pg-regex crate, which builds PostgreSQL 18.4's Advanced Regular Expression engine from unchanged, checksummed PostgreSQL sources behind a safe Rust API with admitted memory, cancellation hooks, PostgreSQL's 2 MB stack budget on any thread and a call-frame bound in WebAssembly. It is distributed under the PostgreSQL, Spencer and Tcl licenses, whose notices ship with the Python, Node.js and browser WASM packages.

• Extend the Rust usql shell with query-buffer commands, variables and conditionals, script includes, native file COPY, printing formats, pager/editor integration, query cancellation and idle LISTEN notifications.

• Build standalone usql release archives for Linux, macOS and Windows on x86_64 and ARM64, with bundled Nori, Kuromoji, Arrow and DuckDB, SHA-256 checksums, user-directory installers and cargo binstall installation without compilation.

• Support PostgreSQL's six native range subtype-distance functions, preserving floating conversion order, temporal infinity values and numeric range diagnostics.

• Add a SQL-owned deterministic Unicode comparison primitive with admitted scratch and cancellation, preserving PostgreSQL's root collation options and byte tie-breaking for selected comparison consumers.

• Support transactional shell type declarations and completion as enums, domains or composite types while preserving OIDs, ownership, PostgreSQL diagnostics, savepoints and provider reopening.

• Store type and domain descriptions through COMMENT, obj_description and pg_description, preserving identity through type completion and lifecycle changes and removing descriptions of dropped types and their generated arrays.

• Support PostgreSQL BIT and BIT VARYING declarations, binary and hexadecimal literals, length-constrained assignment and casts, and exact comparison through arrays, composite fields, indexes and persistent storage. Packed values preserve leading zeroes, empty values and logical bit lengths across Rust, Python, Node.js and WASM consumers; see bit strings.

Changed

• Require Rust 1.95 or newer for CLI and Python source builds so usql can use the upstream terminal reader correction; embedded Rust crates retain Rust 1.90 support. Prebuilt binaries and language packages do not require Rust.

• Evaluate regular expressions, case mapping, LIKE and ILIKE in stored definitions with PostgreSQL's semantics after upgrading: the first open derives PostgreSQL's input collations for views, CHECK constraints, defaults, domain constraints, rules and trigger conditions stored before this release, moving the rule catalog to format 4; expression and partial indexes and stored generated columns keep the keys and values computed earlier, so drop and recreate those that use case mapping, LIKE, ILIKE or regular expressions, as UQA has no REINDEX; rows written earlier are not revalidated; and stored defaults, generated columns, index expressions, trigger and rule conditions, partition keys and parameter defaults that call regexp_matches report PostgreSQL's set-valued function error when evaluated; see Upgrading.

• Connect retained declared range input to catalog-aware casts and arrays, preserving endpoint and canonical invocation order, routine identity, lazy binary coercion and controlled value ownership. SQL range declarations and generated constructors remain separate work.

• Let internal SQL equality-key consumers share physical decoding, normalization and output under one memory allowance and both cancellation scopes, while retaining existing exact, hash, spill and reservation bytes.

• Upgrade persistent databases to SQLite record format 65 and redb record format 61 for declared range definitions, shell type identities and transactional descriptions, including packed bit values and their type descriptors. Close all owners, retain a pre-upgrade backup and update every owner together; see the 0.6.0 upgrade guide.

Fixed

• Preserve non-ASCII identifiers in usql catalog-name patterns while folding ASCII as PostgreSQL psql does, so commands such as \dt keep finding the correct objects across compiler upgrades.

• Preserve Unicode 16 full lowercase, contextual sigma, whitespace tokenization and stored analyzer identities across compiler upgrades, including Rust 1.95, instead of mixing different Unicode versions in one analysis pipeline.

• Match browser WASM C exception handling to the active Rust compiler, preserving PostgreSQL parser and regular expression error recovery with both the Rust 1.90 and Rust 1.95 unwind ABIs.

• Consume complete buffered terminal input after LISTEN instead of stopping after the first character and waiting for more input, preserving asynchronous notification delivery and UTF-8 commands.

• Fix stack-depth errors for finite PL/pgSQL recursion in unoptimized builds by releasing query-construction scratch before row evaluation and keeping temporary SQL results off the common statement dispatcher, while preserving CONTEXT, cancellation and the existing frame-count and native stack limits.

• Preserve the declared retrieval score type during metadata-only query binding, so positive-evidence pooling and text/vector results compose through derived tables, joins, CTEs and UNION branches without an output descriptor mismatch.

• Reconstruct generated row DISTINCT comparisons and DISTINCT negation with PostgreSQL Boolean syntax and precedence in view, rule and trigger definitions, preserving ordinary quoted function calls.

• Share unchanged-snapshot reads for combined and split text occurrence records in native SQLite, SQLite Key/Value and redb, and retain ordered spill output for own-key replacements, removing per-cluster read admission and repeated spill rewrites during commit while preserving atomic snapshot publication.

• Evaluate ~, ~*, !~, !~*, SIMILAR TO, the regexp_* functions and the pattern forms of substring with PostgreSQL 18.4's own regular expression engine instead of translating patterns for the Rust regex crate. Match selection, back-references, lookahead and lookbehind constraints, word-boundary and class escapes, embedded options and directors, every flag including the basic syntax that e selects, character classes and case-insensitive matching under each input collation, regexp_replace escapes and PostgreSQL's error messages now agree with PostgreSQL 18. A compilation or search may use PostgreSQL's 2 MB stack budget and reports regular expression is too complex beyond it, its working memory is charged to the statement's allowance, and cancellation and statement_timeout interrupt it.

• Resolve the special date and time inputs now, today, tomorrow and yesterday in the UNION ALL branches of scroll cursors against the transaction start, as PostgreSQL and the rest of the statement do, instead of the wall clock.

• Return regexp_matches as PostgreSQL's set-returning function in FROM, LATERAL, ROWS FROM, WITH ORDINALITY and select lists, with one text[] row per match under g, PostgreSQL's advancement after empty matches, no rows for no match or a NULL argument, named arguments and its pg_proc identities, instead of one row holding the first match or NULL. regexp_match, regexp_like, regexp_count, regexp_instr and regexp_substr now validate every flag before rejecting g with PostgreSQL's global-option message, and regexp_match accepts its named arguments.

• Draw regexp_split_to_table pieces from the SQL regular-expression owner, so it accepts flags, rejects g with PostgreSQL's diagnostic and skips the degenerate empty matches PostgreSQL ignores, and add regexp_split_to_array, with named arguments and the pg_proc identities of both functions.

• Search the whole input from the start position in regexp_count, regexp_instr, regexp_substr and regexp_replace, advancing past each match as PostgreSQL does, so they find an empty match after a non-empty one and anchors see the text before the start. A pattern without subexpressions selects its whole match as subexpression 1, regexp_replace reports an invalid pattern before searching, and its four-argument text form gives PostgreSQL's hint for flags that begin with a digit.

• Resolve the regular-expression functions through their PostgreSQL 18 catalog signatures, so incompatible arguments report 42883 with PostgreSQL's signature, untyped parameters and named arguments follow the declared types and names, and CHECK constraints, defaults, generated columns, expression and partial indexes, domain constraints, regprocedure input and EXECUTE privileges accept the 23 scalar overloads on every provider. information_schema.routines derives result types and visibility as PostgreSQL does, reporting ARRAY for array results.

• Apply each call's input collation to lower, upper, initcap, casefold, LIKE, ILIKE and regular expressions as PostgreSQL 18 does: C, POSIX and ucs_basic map and classify ASCII letters only, pg_c_utf8 uses simple Unicode mappings, pg_unicode_fast and the database default use full mappings with PostgreSQL's final-sigma rule, and unicode uses ICU root mappings and word boundaries, instead of applying root Unicode mappings under every collation and starting initcap words only after whitespace. Explicit COLLATE clauses and column collations select the provider in queries, DML, views, rules, defaults, CHECK constraints, generated columns, index expressions, trigger conditions, routine bodies and prepared statements and persist across reopening, conflicting implicit collations report 42P22 with PostgreSQL's message and hint, and initcap gains its pg_proc identity.

• Follow PostgreSQL 18 for set-returning functions: report 0A000 for calls in UPDATE, RETURNING, DML WHERE, ON CONFLICT, MERGE, trigge...

UQA Engine v0.5.4

Changed

• Upgrade persistent databases to SQLite record format 62 and redb record format 58 for physical constraint catalog histories; native SQLite mapping 17 and coordination format 2 stay unchanged. Close all owners, retain a pre-upgrade backup and update every owner together. Custom versioned providers must forward committed-read boundaries and private changes; see the 0.5.4 upgrade guide.

• Make native foreign handlers independently opt-in through arrow and duckdb, both disabled by default. Keep the memory handler and its Rust APIs available in every build. Preserve foreign-table SQL declarations, catalog inspection, rollback and persistent reopening for omitted handlers; unavailable scans fail explicitly. Rust metadata inspection uses foreign_server_definition and foreign_table_definition independently of handler projections.

Fixed

• Match Node.js and browser HTTP temporal output to PostgreSQL and native clients, including infinite dates, BC and extended years, 24:00, whole-hour timezone offsets and mixed-sign intervals. Preserve exact Node.js timestamp/interval infinity carriers and browser safe-integer rejection.

• Preserve deferred foreign-key modes and pending events across physical constraint catalog publication, partition changes, renames, nested execution and savepoint rollback by retaining the independent enforcement identity.

• Publish inherited constraint counts and routine-dependent foreign-table changes atomically, repair physical constraint rows during legacy conversion and reject missing or unknown constraint formats when creating independent sessions.

• Reconstruct catalog expressions with the current IntervalStyle, PostgreSQL real-number precision and the selected array, JSONB, range and multirange containment operators. Preserve typed range-element CHECK constraints through persistent reopening.

• Rebind live DiskANN handles after index renames while preserving stored generations, subsequent writes and savepoint undo.

• Allocate retained catalog transaction identities only when a reader captures a boundary, avoiding a heap allocation in ordinary MVCC indexing transactions while preserving transaction-lifetime checks and existing Nori resource limits.

• Update the locked TLS dependency to rustls 0.23.46, incorporating the fixes for RUSTSEC-2026-0346, RUSTSEC-2026-0347, RUSTSEC-2026-0348 and RUSTSEC-2026-0349 in native HTTP clients and published binaries.

• Publish typed CHECK catalog expressions and reconstruct constraint/default/index/routine expressions with retained type, operator, collation and value metadata. Preserve domain identities, foreign-key delete column subsets and privilege-sensitive constraint information views. Accept foreign-table CHECK and NOT NULL constraint deletion through the existing transactional dependency path.

• Retain physical constraint catalog rows across concurrent DDL, REPEATABLE READ, SERIALIZABLE, savepoint rollback and held cursors. Publish ordinary, foreign, domain and trigger constraints atomically, preserving independent partition catalog identities. Complete SQL table/index changes and direct schema/constraint API publication inside their owning transactions so unrelated writers and no-op declarations do not replay unfinished catalog work. The all-owner storage upgrade initializes existing definitions without rewriting user rows.

• Restore role definitions and validate OID claims without first copying all selected metadata payloads, preserving snapshot boundaries and callback errors.

• Preserve PostgreSQL result type modifiers across unknown CASE inputs, selected constant or column arms and retained collation metadata, without changing returned values.

• Preserve plain projected column names in view definitions when analyzed expressions retain collation metadata, while keeping explicit COLLATE and renamed outputs.

• Report PostgreSQL 42704 when a retained expression names a deleted type, preserving the original type OID in the diagnostic.

• Preserve private regular and materialized views when another session publishes catalog changes during a fixed-isolation transaction. Retain view creation, replacement, rename, deletion, materialized rows and original owner identities through catalog refresh, commit, rollback and reopening.

• Reuse a current catalog view across object-ID reservations while preserving collision checks after private DDL, lock waits and rollback, including memory and temporary tables.

• Retain session-maintained catalogs and unrelated table stores across successful DDL statements and commits, preserving refresh after peer changes and rollback. Avoid discarded physical-index build plans during post-lock rechecks and inspect partition membership once per table instead of once per index.

• Read bound table identities directly for mutation row images and RETURNING, avoiding whole-catalog captures per row while preserving retained, partition and foreign-table identities. Check document existence through storage metadata before prepared writes, avoiding unnecessary payload copies. Prepare joined UPDATE predicates once per unchanged statement schema while preserving per-row volatile evaluation, source selection and lock-wait rechecks.

• Retain byte-identical native SQLite B-tree postings and their equality projections during publication, avoiding physical rewrites while preserving MVCC history, write conflicts, retry receipts and changes to SQL-equal stored representations.

• Bind generated columns to their declared row scope outside search_path and preserve typed catalog nodes. Match PostgreSQL stored generated-column dependency selection during UPDATE, preserving unrelated values and using destination expressions when rows move between partitions. Reuse typed expression plans during generated-column rewrites, including PostgreSQL constant planning for empty relations.

• Open each persistent table store once and reuse immutable index preparation when creating independent sessions, preserving validated row counts, analyzer bindings, selected vector indexes and independent transaction state. Resolve relation, array, index and constraint names from selected metadata; avoid unrelated table copies during unrestricted builtin routine checks while preserving retained catalog authority.

• Preserve another session's committed UNIQUE index rename when publishing a constraint-index rename after a name-lock wait.

• Select exact builtin scalar operators directly from their catalog signatures, avoiding unrelated overload allocation and repeated type-declaration parsing while preserving unknown, domain and polymorphic resolution.

• Deduplicate equivalent retained NULL expressions in GROUP BY DISTINCT while preserving explicit collation clauses, selected types and conflicting collation metadata.

• Retain resolved JOIN USING keys through nested and FULL joins, preserving hash execution, implicit key types and access to original input columns.

• Preserve contextual types for untyped string parameters during output analysis, restoring JSON function calls while retaining errors for explicitly typed incompatible inputs.

• Preserve original scalar inputs beside RETURNING wildcards during preparation, retain MERGE source-before-target column order and avoid ambiguous target references or lost prepared constants.

• Retain merge_action() as a row-dependent MERGE expression through parsing, preparation and optimization. Enforce RETURNING clause ancestry with PostgreSQL diagnostics and preserve each action through nested and prepared subqueries, while keeping ordinary quoted or qualified functions distinct.

• Preserve the catalog-selected binding of CURRENT_SCHEMA syntax, restoring its declared result type and use in queries, stored routines and role contexts.

• Restore spilled rows with their retained SQL schema after validating all physical bindings, preserving named relation types and record descriptors through grouping, windows, stored column changes and cursor reads.

• Preserve the unlimited length of catalog-qualified bpchar, avoiding premature one-character truncation in character casts, enum and date input, stored values and analytical query results.

• Print CHECK definitions with PostgreSQL variadic-array calls, typed cast parentheses and session string escaping, preserving domain values, current names and durable definitions.

• Dropping an ordinary or foreign column preserves CHECK constraints that do not depend on that attribute, including constant predicates and checks of another surviving column, with their original identities, flags and enforcement after rollback or reopening.

• Analyze and enforce CHECK predicates in their declared row scope, with actual composite identity, physical tableoid, PostgreSQL diagnostics and ordered catalog dependencies. Whole-row checks follow current columns and ordinary or quoted table renames; omitted fields remain SQL NULL during writes and validation, including after persistent reopening.

• Make foreign-table relation and row/array identities visible while binding defaults, before the server association. Retain in-progress declarations across catalog refreshes and restore all foreign row descriptors before validating persisted expressions, preserving rollback, independent sessions and reopened composite defaults.

• Declare a table and its row/array types before binding defaults and constraints, so references to its own identity resolve with PostgreSQL search-path behavior. Preserve rollback, cross-session publication and persistent defaults. Inherit untyped partition column options before selecting collations, avoiding an unresolved-type panic.

• Retain named relation types and stable whole-row or system attribute identities in SQL catalog expression nodes. Preserve exact PostgreSQL nodes and reconstructed SQL through declared column changes, quoted names and relation renames.

• Reject external inp...

UQA Engine v0.5.3

Added

• Preserve bounded HTTP SQL diagnostics across Rust, Python and Node.js clients, retain parser character positions and expose the failing member through Engine::sql_batch_diagnosed without changing atomic batch execution or replaying statements.

• Add PostgreSQL get_byte(bytea, integer) with unsigned byte output, exact bounds diagnostics, strict NULL behavior and catalog identity.

• Change composite attribute types with PostgreSQL declaration order, recursive storage-use checks, dependent expression rebuilding, prepared field diagnostics, retained tuple interpretation with fixed by-reference fields, alignment and dropped slots, deferred variable-width reads, retained JSON/JSONB output and physical JSONB comparisons, physical array element identity, catalog-dependent enum/domain/composite array decoding and output, header-only array properties, domain base layouts/output, nested tuple and array formation, original enum label OIDs with deferred catalog output, OID-aware scalar and nested enum comparisons, membership, selection and support functions with expression and session-type ordering state, consistent enum hash-aggregation keys, original stored constants across commit and reopen, and atomic rollback.

• Rename composite attributes while preserving field identities, nested values, stored SQL references, prepared selectors and transaction rollback.

• Remove composite attributes with PostgreSQL DROP ATTRIBUTE semantics, including mixed ADD/DROP order, stable surviving field identities, retained constructor effects, nested stored values and atomic rollback across all storage providers.

Fixed

• Bound full-text occurrence commit spill reads with independent ordered-cursor and point-read caches, and reuse validated immutable commit metadata within the selected snapshots. Preserve encrypted spill, conflict checks and the original memory allowance.

• Restore legacy catalogs whose derived relation, row-type or RULE OIDs fall below the modern user range only when the complete identity tuple matches its original derivation. Preserve collision checks, recorded identities and migration rollback across persistent providers.

• Reuse HNSW candidate vectors between scoring and diversity selection, and retain exact query distances across hierarchy levels within bounded portions of the original memory allowance. Preserve floating-point bits, graph construction order, candidate ties and uncached results.

• Stream ordered HNSW vector restoration and vector-effect restaging into bulk spill files, assign generated write kinds directly, and reuse decoded selected vectors within the original allowance during diversity selection. Read private mutation conditions once and share authenticated entry blocks within an evaluated batch. Preserve unordered restoration, exact graph/search results, conflict preconditions, undo and failure atomicity.

• Preserve transaction-local document counts across unrelated maintenance commits by checking each table's last committed change against the observed snapshot, while retaining peer-row refresh, rollback and read-free own-commit adoption.

• Avoid unchanged HNSW adjacency writes and tentative connect/prune publications; skip vector comparisons when all validated neighbors fit, preserving final topology, reciprocal removals and canonical search results.

• Build unpublished spill maps with one charged block buffer and avoid rewriting already-pending HNSW identities, preserving atomic publication, complete persistence deltas and retained graphs.

• Reuse authenticated spill-map block prefixes, including partially populated tails, within the original memory allowance, and avoid decoding values for membership checks. Track each cached extent, refresh it only when a read reaches newly appended bytes, preserve immutable readers and clear cached blocks before failed append addresses can be reused.

• Retain certified IVF mutation candidates in Key/Value and native SQLite, derive ranked posting lists only on demand, and update only changed native assignments when centroids are unchanged. Read native vector revision summaries by field, stream unclassified revision scans, restage sorted spilled transaction writes without repeated merging, and append encrypted spill-map paths in one bounded write. Preserve undo, peer-write refresh, canonical results, encrypted spill and the original allowance.

• Separate spilled HNSW topology from canonical and normalized vector pages so validation and edge restoration do not decode or rewrite dense vectors, while preserving graph integrity, canonical scores, encrypted spill and the original allowance.

• Restrict unindexed scalar filters in retrieval intersections to selected candidate documents without changing KNN boundaries, payload merge order, column validation or error precedence.

• Seek cold native SQLite scalar and composite equality indexes directly across session refreshes instead of hydrating complete value indexes for constraint checks and result projection. Preserve complete index support, private writes, savepoints, fixed snapshots, typed comparisons and serializable observations; upgrade the physical equality projection and population certificates atomically through native mapping 17. Store canonical equality keys in an ordinary indexed provider table so integrity checks, VACUUM, REINDEX, backups and SQLCipher exports do not require connection-local UQA functions.

• Preserve represented composite fields when a later field extends beyond the retained tuple, and reject actual out-of-bounds reads with XX001 while preserving lazy evaluation, rollback and reopening. Keep already-folded prepared view constants across representation-only descriptor projection, while retaining invalidation for actual definition changes.

• Reject DISTINCT, grouping, ordering and window keys whose declared types lack the required PostgreSQL comparison operators before optimization or execution, including output-column ordinals, empty inputs and unused window definitions. Preserve ordinary void/JSON outputs and UNION ALL, and include PostgreSQL's ordering-error hint.

• Reduce scalar filter overhead for same-type integer, floating-point and Boolean comparisons by resolving enum call state only when needed, preserving PostgreSQL coercions, NULLs, evaluation order, retained enum state and cancellation. Restore adjacent inclusive ranges in compiled projected predicates after PostgreSQL BETWEEN expansion, reading each needed range field once.

• Avoid discarded catalog captures during DDL and unnecessary snapshot copies during index-name restoration and partition key preparation, while preserving validation, identities, rollback and post-lock freshness.

• Preserve lazy OLD/NEW view expressions in RULE conditions, including CASE, COALESCE and nested scalar subqueries, without discarding required volatile projection effects or live whole-row fields. Retain analyzed constants and coercions in stored RULE conditions so enum definitions follow label renames and rollback.

• Reuse catalog inputs for scoped builtin permissions, scalar metadata, routine signatures and read-only view analysis; retain relation type descriptors, reuse validated index, constraint and trigger definitions for OID/name inquiries, borrow domain CHECK, RULE/view and routine definitions through retained addresses, and share dependency derivation across catalog aliases and object descriptions, with one concurrent cold initialization. Share stored-expression output metadata across deparsers while preserving caller-specific name visibility, skip unrequested column, generation, domain and routine-default expression output, and apply safe name predicates before unrelated column rows or stored defaults are reconstructed. Borrow selected view/foreign metadata and owned sequence definitions without complete collections. Preserve private DDL, role changes, rollback, portal generations and fresh dependency checks after DDL locks. OID-based constraint and trigger definitions no longer incorrectly require schema USAGE; rendered names retain invoking-role visibility. Include existing routine pseudo types in catalog output so trigger function definitions print their return type correctly.

• Check type OID collisions directly from retained identities instead of building every pg_type row, while preserving builtin and user-type reservations and fresh checks after catalog lock waits.

• Preserve a named record's actual tuple type through copying, storage and spill. Record output and field selection use that descriptor, and equality and ordering validate each reached field's type with PostgreSQL's NULL and short-circuit rules. Composite-to-record identity casts leave retained bytes unread.

• Preserve resolved text types when propagating NULL and string constants from derived SELECT, VALUES and view outputs; keep bare untyped pg_typeof arguments unknown.

• Preserve retained enum comparison semantics through external sorting, Top-K, DISTINCT and FETCH WITH TIES, including disk-spilled keys. UNION, INTERSECT and EXCEPT group enum identities without reading labels, preserving NULLs and ALL multiplicities. Window partition and peer boundaries use the same identity equality, preserving ranks and peer frames. Aggregate MIN/MAX, ordered and DISTINCT inputs, mode and discrete percentile retain enum catalog and comparison state across groups, window frames and spill merging. Recognize matching array and row constructors in DISTINCT ON ordering.

• Preserve enum catalog and comparison state in budgeted built-in calls, admitting selected values and enum ranges before allocation and releasing partial results on quota failure or cancellation.

• Preserve PostgreSQL BETWEEN operand coercions, strict-NULL folding and volatile/subquery evaluation counts, while keeping simple inclusive ranges on their existing access path. Normalize predecessor view and stored schema expressions during initial restoration and opti...

UQA Engine v0.5.2

Fixed

• Apply the selected SQL operand casts consistently to index candidate selection and residual predicates, preserving mixed numeric comparisons across scans, indexes, column aliases, parameters and persistent reopening.

• Resolve partitioned INSERT conflict arbiters from the target relation, preserving named parent constraints, child-only unique indexes for targetless DO NOTHING and physical row identity across partitions.

• Initialize the user catalog OID counter independently of reserved bootstrap namespaces while retaining persisted user-object claims and creation order.

• Preserve enum label identities when storing IN-list conditions, including trigger definitions after label renames, and accept peer-only RANGE window frames for types without offset arithmetic.

• Allow borrowed record scans without additional cursor workspace when a transaction has no private changes, preserving exhausted read allowances and cancellation.

• Preserve computed integer ordering keys as values after constant folding, including custom plans in SQL routines, instead of reinterpreting them as output-column positions.

• Restore separately persisted HNSW edges with one bounded source-node buffer, avoiding per-edge rewrites of spilled vectors while preserving topology validation and memory limits.

• Retain HNSW indexes for SQL replacements whose canonical vector bits and ordinals are unchanged, while preserving ordinary row publication and actual vector changes.

• Exclude native vector field conflict guards from catalog registry invalidation, including private transaction views and upgrades of existing cache triggers.

• Preserve statically selected graph dependencies after SQL literal coercion, so cursor snapshots do not decode unrelated graph entities.

• Preserve the recorded OIDs of private sequences when a callback refreshes committed catalog state, so bound nextval calls continue resolving the same sequence under REPEATABLE READ and SERIALIZABLE.

• Synchronize native SQLite WAL sequence-value logs at the consuming transaction boundary, including values obtained from another session's cache, instead of forcing FULL synchronization for each logged block. Preserve autonomous visibility, rollback, exact retry, generation lifetimes and sequence allocation; retain FULL publication on other storage paths. SQLite record format 60 adds the durable-prefix certificate and atomically upgrades predecessor metadata.

• SQLite managed transaction completion validates its exact durable receipt without a second physical acknowledgement commit. Ordinary writes retain FULL publication, retry ownership, manual acknowledgement and SSI recovery semantics.

• Reclaim SQL key-reservation identities after requests, waiters and held grants finish instead of retaining every historical digest for the database lifetime. Preserve native release, savepoint ownership and existing permanent table/key identifiers.

• Reject incompatible live SQLite storage owners before record initialization and retain owner admission through native catalog restoration, preventing upgrades from bypassing pre-table row locks. Current owners remain compatible, and process death releases admission through the existing owner leases.

• Compare complete cross-process row and key identities, including wait edges, instead of conflating hash collisions. Retain native pins by relation and keep temporary dependency admission separate from relation-registry lifetime locks.

• Retain successfully staged HNSW graphs across own writes on memory, SQLite and redb instead of reconstructing every generation. Certify private and uncontended autocommit boundaries, while preserving refresh after concurrent commits, undo, canonical validation and the original memory allowance.

• Batch already evaluated UNIQUE and PRIMARY KEY reservations under one shared claim-table arbitration per bounded group. Keep single-key acquisition, contention order, snapshot refresh and savepoint release semantics.

• Reuse ordinary statement analysis across data-only commits when the selected snapshot, definitions and parameter types still permit it. Re-optimize against current data on every invocation, preserving fresh parameter values, temporal input lifetimes, rollback and schema diagnostics.

• Reuse completed data-commit receipts for session cache adoption on native SQLite, SQLite Key/Value and redb, avoiding an extra read transaction and catalog-generation scan after a data-only commit. Preserve refresh after intervening commits, definition changes, rollback and uncertain completion.

• Store SQLite MVCC version payloads by stable physical address, with keyed metadata for historical reads and reclamation, reducing WAL write amplification when a commit changes several record families. Initial open atomically converts SQLite record format 58 and earlier to the addressed layout now retained by format 60 while preserving histories, receipts, snapshots and FULL synchronization.

• Retain parsed SQL and structural plans across data-only changes while invalidating executable access paths. Persistent and explicit-transaction statements still lower and optimize under their selected snapshot, preserving live data, rollback and schema checks.

• Share SQLite managed transaction allocation commits through a bounded reserve of already durable receipts, preserving receipt quotas, per-call memory and cancellation checks, process-loss recovery and SERIALIZABLE publication ordering.

• Publish automatic ANALYZE samples while concurrent row writes continue, retaining changes after the sample for the next refresh. Reject obsolete samples after a newer ANALYZE, column changes or relation replacement across native SQLite, SQLite Key/Value and redb.

• Reuse custom/generic executable plans inside SQL-language and PL/pgSQL routine bodies, including static cursor sources, with the existing plan_cache_mode policy. Preserve per-call arguments, live data, input-constant lifetimes, catalog invalidation and result checks without repeating analysis and optimization of a reusable plan.

• Retain PL/pgSQL record-field parameter types across executions. Report PostgreSQL’s 42804 diagnostic when an evaluated field changes type, preserve unevaluated CASE branches and compatible typmod changes, and accept fresh types after plan invalidation.

Packages

Python wheels, a Python source distribution, the Node.js root npm package, @cognica-io native optional packages, standalone native addons, and the browser WASM package are attached to this release.

crates.io status: Live publication of all public Rust workspace crates at version 0.5.2 completed by this workflow.

PyPI status: Published as uqa==0.5.2.
npm status: Published as @cognica-io/uqa@0.5.2 with native optional packages, and as @cognica-io/uqa-wasm@0.5.2.

Benchmarks

Release benchmark JSON and Markdown reports come from the successful package-build workflow and are attached separately. See the measurement status. Each report records its tag, commit, runner, build and workflow attempt. Shared-runner timing is informational and does not establish performance acceptance.

Licensing: AGPL-3.0-only with optional FOSS and noncommercial application exceptions. See LICENSING.md.

UQA Engine v0.5.1

Fixed

• Initialize CREATE TABLE AS column identities and attribute slots through ordinary schema publication, preserving valid catalogs after relation-name waits, across sessions and on persistent reopen.
• Probe complete composite UNIQUE tuples during mutation checks instead of reading all rows sharing the leading key. Preserve partial predicates, NULL semantics, command-local changes and rollback; initial open repairs missing tuple postings atomically, and SQLite record format 58 and redb record format 56 exclude older writers.
• Prepare operator-join predicates in each input relation’s own scope, restoring unified-search examples across language bindings while retaining constant-error ordering and namespace checks.
• Reduce nested routine execution stack frames so shallow recursion succeeds in development builds without weakening the native stack guard or recursive-error recovery.
• Preserve legacy key constraint names when initial analyzer restoration saves a table before its owned index registry is converted. Databases combining predecessor column keys and full-text fields now reopen with their constraints, documents and search index intact; converted catalogs continue to store key names only on owned indexes.

Packages

Python wheels, a Python source distribution, the Node.js root npm package, @cognica-io native optional packages, standalone native addons, and the browser WASM package are attached to this release.

crates.io status: Live publication of all public Rust workspace crates at version 0.5.1 completed by this workflow.

PyPI status: Published as uqa==0.5.1.
npm status: Published as @cognica-io/uqa@0.5.1 with native optional packages, and as @cognica-io/uqa-wasm@0.5.1.

Benchmarks

Release benchmark JSON and Markdown reports are attached separately after measurement, without delaying package publication. See the measurement status. Each report records its tag, commit, runner, build and workflow attempt. Shared-runner timing is informational and does not establish performance acceptance.

Licensing: AGPL-3.0-only with optional FOSS and noncommercial application exceptions. See LICENSING.md.

UQA Engine v0.4.9

This release bounds HNSW and transaction retention with encrypted temporary storage and corrects PostgreSQL 18 sequence, foreign-key, transaction and diagnostic behavior. Native SQLite mapping advances from 13 to 14, and persistent sequence definitions and values are stored separately. Stop every database owner, retain a closed pre-upgrade backup and update all owners together. Rust persistence and HNSW adapters and consumers of Rust/Python notices need API updates; see the 0.4.9 upgrade guide.

Changed

• Store sequence values independently of catalog definitions, avoiding catalog refreshes when reserved values are published. Native SQLite migrates retained sequence revisions to mapping format 14; SQLite Key/Value and redb migrate sequence definitions and value records on open. Earlier binaries cannot consume the upgraded sequence representation.
• Preserve PostgreSQL notice levels, SQLSTATEs, messages, details and hints through Rust, Python, Node.js, WASM, the PostgreSQL server and usql. Rust returns SQLNotice values and Python returns dictionaries instead of pairs; Node.js and WASM notice objects gain the diagnostic fields.

Fixed

• Spill private transaction changes and prepared publication records to encrypted temporary files under the existing session allowance. Preserve savepoints and conflict preconditions, stream SQLite/redb publication and release decoded run caches when reading ends.
• Keep HNSW graph construction, restoration, mutation generations, publication and search workspaces bounded by their retention allowance using encrypted temporary storage across memory, native SQLite, standalone SQLite, SQLite Key/Value and redb. Preserve graph topology, canonical scores, retained snapshots and transaction rollback while streaming provider inputs and persistence deltas; see the Rust API changes.
• Keep committed sequence allocation outside transactions that change sequence names, ownership or privileges, preventing duplicate values, allocation conflicts and rollback to values already issued by another session. Preserve transactional allocation for newly created or restarted sequence generations.
• Match PostgreSQL foreign-key behavior across ordinary inheritance and partitioned tables: restrict referential actions to the declaring relation, propagate and validate partition constraints, preserve derived constraint identities and deferrability, and reject dropping, truncating or detaching referenced partitions when required.
• Validate table rewrites against the affected rows and validated constraints, including referencing foreign keys. Check unique keys across the complete rewritten result so values moved by USING do not conflict with rows being replaced, and preserve PostgreSQL index-build diagnostics.
• Treat a repeated SQL BEGIN as a warning without opening another transaction frame; the first COMMIT commits the block. Report PostgreSQL warnings for SET LOCAL and SET TRANSACTION outside transaction blocks while preserving explicit Rust nested frames.
• Keep error details and hints separate from primary messages, preserve referenced-side diagnostics for deferred foreign-key failures, and follow PostgreSQL partition-attachment validation order.

Packages

Python wheels, a Python source distribution, the Node.js root npm package, @cognica-io native optional packages, standalone native addons, and the browser WASM package are attached to this release.

crates.io status: Live publication of all public Rust workspace crates at version 0.4.9 completed by this workflow.

PyPI status: Published as uqa==0.4.9.
npm status: Published as @cognica-io/uqa@0.4.9 with native optional packages, and as @cognica-io/uqa-wasm@0.4.9.

Licensing: AGPL-3.0-only with optional FOSS and noncommercial application exceptions. See LICENSING.md.

UQA Engine v0.4.8

This release improves embedded reads and writes and corrects PostgreSQL 18 identity, input and diagnostic behavior. SQLite databases advance to record format 55, and cooperating processes use new row-lock and sequence sidecars. Stop all database owners, retain a closed pre-upgrade backup and update every owner together; see the 0.4.8 upgrade guide.

Added

• Answer eligible relational queries from B-tree key and included-column postings without fetching documents, controlled by enable_indexonlyscan. Support INCLUDE on PRIMARY KEY and UNIQUE constraints with PostgreSQL column validation, naming, catalog output and rename/drop dependencies.
• Honor identity sequence declarations and ALTER COLUMN identity actions, including sequence options, generated mode, restart and removal. Adding serial or identity columns creates the sequence and populates existing rows.

Changed

• Reduce embedded query work with projected native reads, retained decoded scalar columns, shared graph scans, bounded top-K and window storage, HNSW visited bitmaps and generation-checked exact-vector reuse. Reduce repeated snapshot, catalog, index, trigger and commit preparation during writes while retaining transaction visibility and resource ownership.
• Advance SQLite main records from format 54 to 55 with atomic, validated migration of version metadata; native SQLite mapping 13, redb main records 53 and SQL catalog 49 remain unchanged. Older SQLite binaries reject the new record format.
• Coordinate row claims through .uqa-row-claims and sequence positions through .uqa-sequences beside the database. Update all cooperating processes together; orderly close retains exact sequence continuation, while an unclean final close may skip reserved values.
• Coalesce statistics maintenance counts between durable refresh thresholds. Stored change counts can be a lower bound between publications; the existing stale-age limit still schedules refreshes. SQLite commit connections use a temporary page-cache allowance bounded at 256 MiB and release it after commit.

Fixed

• Match PostgreSQL 18 identity writes for OVERRIDING SYSTEM VALUE, OVERRIDING USER VALUE, explicit NULL, DEFAULT, COPY and GENERATED ALWAYS diagnostics. Reject non-DEFAULT writes to generated columns before row execution, including empty sources.
• Preserve distinct rows when a serial or identity column is not the primary key, and handle negative or large integer keys without colliding with generated document identities. Repair legacy key mappings on open and evaluate _doc_id and _meta.doc_id filters against the correct row identity.
• Keep the statement's row-trigger definitions stable across trigger creation or deletion inside a trigger, while applying the replication role at each firing.
• Match PostgreSQL integer text prefixes, underscores and range errors; parse BYTEA assignment and COPY input through the binary input rules and preserve PostgreSQL hex, escape and base64 behavior in encode and decode.
• Match PostgreSQL NOT NULL, CHECK and partition violation messages, constraint ordering and permission-filtered row details. Keep their row details and COPY diagnostic hints separate from the primary message.
• Preserve private row/count/index visibility and rollback state while reusing committed caches; reject stale automatic-statistics publication and retain committed notification outcomes when background delivery fails.
• Avoid repeated operand-tree type inference during non-integer scalar arithmetic and comparisons while preserving exact NUMERIC results, REAL precision, integer overflow checks and SQL NULL behavior.
• Avoid full native document scans for maximum-ID lookups, repeated catalog restoration for unchanged committed/private command views, per-key SQLite metadata statements and unchanged maintenance metadata reads. Preserve pinned visibility, savepoint undo, serializable observations, resource limits and existing maintenance deadlines.
• Restore named analyzer bindings on document tables without requiring declared SQL columns. Declared SQL tables retain TEXT-column and physical FTS validation, and missing field bindings remain rejected.
• Release notification test resources on the supported Node.js 16 runtime, including assertion failures and cancellation, so the HTTP compatibility suite completes without requiring newer test-context hooks.

Packages

Python wheels, a Python source distribution, the Node.js root npm package, @cognica-io native optional packages, standalone native addons, and the browser WASM package are attached to this release.

crates.io status: Live publication of all public Rust workspace crates at version 0.4.8 completed by this workflow.

PyPI status: Published as uqa==0.4.8.
npm status: Published as @cognica-io/uqa@0.4.8 with native optional packages, and as @cognica-io/uqa-wasm@0.4.8.

Licensing: AGPL-3.0-only with optional FOSS and noncommercial application exceptions. See LICENSING.md.