tursodatabase/turso

This system is a high-performance, SQLite-compatible database engine written in Rust, designed to support local-first applications with bidirectional cloud synchronization. It provides a comprehensive suite of language-specific bindings for Rust, Python, JavaScript, Go, Java, .NET, and React Native, enabling developers to embed the database in diverse environments. The engine features advanced capabilities including MVCC concurrency control, local encryption, full-text search, vector similarity operations, and a PostgreSQL-compatible wire protocol server.

94 changes.

This period focused on implementing a core MVCC concurrency control module and a logical-log-based sync engine to replace the previous replication model. It simultaneously established a comprehensive multi-language SDK ecosystem, releasing initial bindings for Rust, Python, Java, Go, JavaScript, and .NET with features like cloud synchronization and local encryption. The work also expanded the database's feature set with JSON, vector, and extension support while introducing rigorous performance benchmarking and fuzz testing infrastructure.

101 changes.

This period focused on introducing a PostgreSQL-compatible execution layer, including a new parser, wire protocol server, and CLI tool, alongside extensive conformance testing against upstream PostgreSQL regression suites. Simultaneously, the project expanded its serverless capabilities by releasing native drivers for Rust, Python, and Go, while significantly broadening language support with new React Native, .NET, and Java bindings.

Users can now query CSV files as if they were database tables using the new \csv\ virtual table extension. This feature allows specifying input via a \filename\ or inline \data\, with options to control header parsing (\header=yes/no\) and define custom schemas or column counts. The extension is implemented in \extensions/csv/src/lib.rs\ and registers the \CsvVTabModule\ to handle these virtual table operations.

extensions/csv · high confidence

New example applications have been added to the Go examples directory to demonstrate key Turso Go SDK capabilities. The encryption example shows how to create and use a local database encrypted with the aegis256 cipher, including verification that data is not stored in plaintext on disk. The sync example demonstrates how to open a local database that synchronizes with a Turso Cloud remote, featuring background workers for periodic Push/Pull operations and WAL checkpointing.

examples/go · high confidence

A new Gradle-based example project has been added to the Java bindings, providing a runnable demonstration of connecting to a Turso database via JDBC. The example, located in the \tech.turso\ package, shows how to establish a connection, create a table, insert data, and query results, serving as a starting point for developers integrating with the library.

bindings/java/example · high confidence

The \postgres/frontend\ module introduces a new PostgreSQL-compatible execution layer. It registers a \PostgresDialect\ that routes SQL parsing through the \turso\_pg\_parser\ (with SQLite fallback), implements a virtual \pg\_catalog\ schema for introspection, and provides a suite of PostgreSQL-specific scalar functions (such as \now\, \version\, \pg\_get\_expr\, and \quote\_literal\). The frontend also includes a parser for the PostgreSQL \COPY\ text format and manages session state, including the \search\_path\ for unqualified table lookups.

postgres/frontend · high confidence

Introduces a new \postgres/parser\ crate that provides a complete SQL parser for PostgreSQL syntax. The crate includes a lexer and recursive-descent parser that build a PostgreSQL-specific AST (defined in \ast.rs\) and a translator module that converts PostgreSQL parse results from the \pg\_query\ library into the Turso/SQLite AST representation. This enables the system to parse and understand PostgreSQL-specific SQL constructs, including DDL, DML, and administrative commands, before translating them for execution.

postgres/parser · high confidence

The \extensions/regexp\ module introduces a new SQL extension providing five scalar functions for regular expression operations: \regexp\ (returns 1 if the pattern matches), \regexp\_like\ (matches pattern against string), \regexp\_substr\ (extracts the first match), \regexp\_replace\ (replaces matches with a replacement string), and \regexp\_capture\ (extracts a specific capture group). These functions are registered via the \turso\_ext\ API and rely on the \regex\ crate for pattern matching.

extensions/regexp · high confidence

Added formal TLA+ specifications and model-checking infrastructure for SQLite Write-Ahead Log (WAL) mode concurrency. This includes a new \multiprocess\ specification modeling Turso's multi-process WAL coordination (reader/writer/checkpoint interactions) and a \sqlite-tx\ specification modeling standard SQLite WAL transaction semantics (single-writer, multi-reader, snapshot isolation). Both specs include Makefiles to run the TLC model checker and generate PDF documentation, allowing verification of invariants like single-writer enforcement and snapshot validity.

tlaplus · high confidence

Introduces a new TPC-C benchmark suite in perf/tpc-c that allows users to build and run performance tests against both system SQLite3 and Turso (a SQLite-compatible database written in Rust). The harness includes C source files implementing the five standard TPC-C transactions (New-Order, Payment, Order-Status, Delivery, Stock-Level), SQL scripts for schema creation and indexing, and a Makefile that supports building binaries for either backend. A shell script (run\_bench.sh) automates the process by detecting or cloning the Turso repository, building both benchmarks, loading test data, running the workloads with configurable parameters (warehouses, connections, warmup, measurement time), and generating a side-by-side comparison report of throughput (TpmC) and response times.

perf/tpc-c · high confidence

New scripts have been added to the performance benchmarking suite to visualize and process TPC-H query results. The \results2csv.sh\ utility converts raw benchmark output logs into structured CSV files, while the \plot-tpch.py\ script generates publication-quality grouped bar charts (PNG, PDF, and TikZ) from these CSVs. The plots display query runtimes on a linear axis, using whiskers to indicate the range between the fastest and slowest runs across multiple executions, and highlight the fastest median runtime in bold within the accompanying data table.

perf/tpc-h/plot · high confidence

A new collection of Python scripts has been added to \scripts/corruption-debug-tools\ to help diagnose database corruption issues by analyzing Write-Ahead Log (WAL) files. The suite includes utilities to inspect WAL headers and commit frames (\wal\_info.py\, \wal\_commits.py\), perform binary searches to pinpoint the exact WAL frame that introduces corruption (\find\_corrupt\_frame.py\), and compare page states between frames to identify lost or gained rowids and keys (\page\_diff.py\, \page\_history.py\, \track\_rowid.py\). These tools rely on a shared library (\lib/\) for parsing SQLite WAL formats, page headers, and record payloads, enabling users to trace data integrity issues back to specific transaction boundaries.

scripts/corruption-debug-tools · high confidence

A new benchmark suite in perf/connection allows users to measure and compare the database connection open times of rusqlite and limbo across databases with varying table counts (10, 1,000, 5,000, and 10,000 tables). The change introduces a Python script to generate test databases, shell scripts to build and run the benchmarks for both libraries, and a visualization tool to plot the resulting latency percentiles (p50 through p99.999) as a log-scaled bar chart.

perf/connection · high confidence

A new \dbhash\ CLI tool has been added to compute a SHA1 hash of a SQLite database's logical content, ensuring that databases with identical data produce the same hash regardless of physical differences like page size or encoding. The tool excludes system tables, virtual tables, and statistics tables, and supports filtering tables via a SQL LIKE pattern. Users can choose to hash only the schema, only the content, or both, and can enable debug tracing to print hashed values to stderr. The implementation uses a type-prefixed encoding for values to ensure platform-independent hashing.

tools/dbhash · high confidence

The iOS directory for the TursoExample React Native application has been initialized with the standard project structure required to build and run the app on iOS devices. This includes the Xcode project file, workspace configuration, and scheme definitions, along with the native Swift AppDelegate that bootstraps the React Native runtime. The configuration enables the New Architecture (RCTNewArchEnabled) and includes the necessary Info.plist settings, such as allowing local networking for development, and a PrivacyInfo manifest to comply with Apple's data collection requirements.

examples/react-native/ios · high confidence

A new Python script, check\_elf\_dynsym\_exports.py, has been added to the bindings/dotnet/scripts directory to verify that specific symbols are correctly exported in Android native shared libraries (ELF files). This tool parses the dynamic symbol table (.dynsym) to ensure required exports are present, helping to prevent build-time or runtime linking errors for the .NET bindings on Android.

bindings/dotnet/scripts · high confidence

The Android side of the TursoExample React Native application has been initialized with the standard project structure. This includes the AndroidManifest.xml declaring internet access and the main launcher activity, Kotlin source files for the MainActivity and MainApplication (configured to use the React Native New Architecture/Fabric), and resource files for the app theme and string resources. Additionally, the Gradle build system is set up with the Gradle wrapper (including a bump to Gradle 9.0.0) and a default ProGuard rules file.

examples/react-native/android · high confidence

The perf/clickbench directory now includes a complete benchmark suite that compares Turso (formerly Limbo) against SQLite using the standard ClickBench dataset. This addition provides a modified benchmark script, SQL schema, and a comprehensive set of 45 queries covering aggregation, filtering, and pattern matching, enabling users to evaluate and compare the performance characteristics of the two database engines.

perf/clickbench · high confidence

The \perf/job\ directory now includes the schema, foreign-key indexes, and 113 analytical SQL queries from the Join Order Benchmark (JOB). These files are vendored from the upstream \gregrahn/join-order-benchmark\ repository and are used by the \core/benches/prepare\_benchmark.rs\ harness to measure statement preparation costs (parse, plan, and codegen) without requiring actual data loading.

perf/job, perf/tpc-ds · high confidence

A new multithreaded benchmark tool has been added to compare TRUNCATE (blocking) and PASSIVE (non-blocking) MVCC checkpoint modes. The tool measures per-operation latency, throughput, and file sizes under concurrent read/write loads, outputting time-series data in CSV and SVG formats to help visualize contention and checkpoint performance.

perf/checkpoint-bench · high confidence

A new benchmarking suite has been added to the \perf/mobibench\ directory to evaluate and compare the transaction throughput of SQLite against Turso. The suite includes a shell script (\run-eval.sh\) that executes Insert, Update, and Delete workloads under WAL journal mode with FULL synchronous settings, and a Python script (\plot/plot.py\) that generates a grouped bar chart visualizing the results. This allows users to assess performance differences between the two database engines using the Mobibench framework.

perf/mobibench · high confidence

The performance suite now includes the full set of TPC-H benchmark queries (1–22) in the \perf/tpc-h/queries\ directory. These SQL files have been adapted for the current engine by replacing non-standard date casting syntax (e.g., \cast({'month': 3} as interval)\) with standard string literals (e.g., \'1994-01-01'\) and replacing \date\_part\ calls with \substr\ where necessary. Some queries include skip markers for engines that cannot handle specific patterns (e.g., SQLite skip for decorrelation issues in Q20), indicating this change enables standardized performance testing across different database backends.

perf/tpc-h/queries · high confidence

A new benchmark tool has been added to the \perf/connection/limbo\ directory to measure the time required to open a database connection and prepare a statement. The tool accepts a database file path and an iteration count, runs the specified number of connection cycles, and outputs latency percentiles (p50 through p99.999) in CSV format to help track performance changes over time.

perf/connection/limbo · high confidence

New example files have been added to demonstrate local database encryption capabilities in the Java and .NET SDKs. The Java example (EncryptionExample.java) and the .NET example (Encryption.cs) show how to create encrypted databases, insert and query sensitive data, verify that data is encrypted on disk, and handle incorrect decryption keys. These examples support multiple ciphers including AES\_128\_GCM, AES\_256\_GCM, and various AEGIS variants.

bindings/java/src/main/java/examples, examples/dotnet, examples/java · high confidence

The perf/graph-queries location now includes a synthetic seed data generator and a suite of SQL benchmark queries designed to test graph performance with complex multijoins. The seed generator creates a university course catalog graph (nodes, edges, messages, conversations, journals) to populate a SQLite database. The benchmark suite includes queries for aggregate OR/IN operations, co-occurrence analysis, edge counting, IN-list unions, activity aggregation, and streak detection (current and longest), providing a comprehensive set of complex graph traversal and aggregation patterns for performance testing.

perf/graph-queries · high confidence

Added a new set of scripts under \scripts/antithesis\ to integrate Antithesis fuzzing into the CI pipeline. This includes \diff\_to\_targeted\_coverage.py\, which parses unified diffs to generate JSONL-formatted targeted coverage files focusing only on changed Rust source lines, and shell scripts (\launch.sh\, \publish-config.sh\, \publish-workload.sh\, \publish-docker.sh\) to build Docker images for the config and workload, authenticate with the Antithesis registry, and launch experiments with configurable durations and notification recipients. Tests for the diff parser are also included.

scripts/antithesis · high confidence

The .agents directory now includes a comprehensive setup script that automatically configures the development environment by installing required system packages, setting up the Rust, Python, Go, and Node.js toolchains, and fetching project dependencies. This change ensures that the agent's runtime environment is consistently prepared with the necessary tools and libraries before execution.

.agents · high confidence

The CLI now automatically detects whether your terminal uses a light or dark background theme and adjusts its table and syntax highlighting colors accordingly. This is handled by new configuration modules in \cli/config\ that detect the terminal theme via ANSI queries (on Unix and Windows) and apply optimized color palettes for \TableConfig\ and \HighlightConfig\. If detection fails or the output is not an interactive terminal, the CLI falls back to a no-color mode to ensure readability.

cli/config · high confidence

The Java binding now supports automatic discovery of the Turso JDBC driver. A new META-INF/services/java.sql.Driver file registers the driver class (tech.turso.JDBC), allowing applications to load the driver without explicit class loading. Additionally, a properties file provides metadata including the driver name and a placeholder version.

bindings/java/src/main/resources · high confidence

The Python SDK now exposes asynchronous and synchronous partial synchronization capabilities. Users can import \ConnectionSync\, \PartialSyncOpts\, \PartialSyncPrefixBootstrap\, and \PartialSyncQueryBootstrap\ from \turso.aio.sync\, along with a \connect\ function for establishing sync connections, enabling direct integration of partial sync features into Python applications.

bindings/python/turso/aio · high confidence

Added a curated subset of 103 upstream PostgreSQL regression tests (from tag REL\_18\_4) to the \postgres/conformance/upstream\ directory. This corpus, covering core SQL semantics such as aggregates, table alterations, arrays, bit types, and booleans, serves as the primary yardstick for measuring tursopg's PostgreSQL compatibility. The tests are executed via the \pgregress\ runner, with results tracked in a pass/fail status table to monitor regression and compatibility progress.

postgres/conformance/upstream · high confidence

This change introduces the Android-side native implementation for the Turso React Native library. It adds the CMake build configuration, a C++ JNI adapter, and the necessary Java classes (TursoModule, TursoBridge, TursoPackage) to register the native module with React Native. The build system is configured to link against the pre-built Rust shared library (.so) and includes specific linker options to ensure 16KB page alignment compatibility with Android 15+. This enables the JavaScript layer to communicate with the native Turso sync SDK on Android devices.

bindings/react-native/android · high confidence

This change introduces the initial Java Native Interface (JNI) bindings for the Turso database engine, exposing core database operations to Java applications. The Rust source files in \bindings/java/rs\_src\ implement the bridge, including \TursoDB\ for opening databases (with optional local encryption support via \openWithEncryptionUtf8\), \TursoConnection\ for managing connections and preparing SQL statements, and \TursoStatement\ for executing queries and binding parameters. The implementation maps internal error codes to Java exceptions and handles data type conversions between Rust and Java, establishing the foundational connectivity layer for the Java SDK.

_bindings/java/rs\src · high confidence

The \examples/react-native\ directory now contains a fully bootstrapped React Native application that serves as a functional testbed for the \@tursodatabase/sync-react-native\ bindings. The app includes a UI that displays results for database open time, query throughput, and various concurrency smoke tests (sequential reads, multi-connection parallelism, and prepared statement reuse). It also supports optional sync and encryption tests via environment variables and includes the necessary configuration files (Metro, Babel, ESLint, Prettier) to link against the local bindings and run on both Android and iOS.

examples/react-native · high confidence

This change introduces the initial set of .NET bindings for Turso, providing a SQLite-compatible ADO.NET facade (\Turso.Data.Sqlite\) that supports local embedded replicas, remote libSQL databases via Hrana, and connection-string-based replica pooling with automatic sync. The packages target .NET 8.0, 9.0, and 10.0, include native runtime assets for Windows, Linux, macOS, Android, and iOS, and support NativeAOT static linking. The release also adds an EF Core provider, batch execution support, and a complete build/packaging infrastructure for NuGet distribution.

bindings/dotnet · high confidence

This change introduces the initial Java bindings for Turso, providing a fully functional JDBC driver under the \tech.turso\ package. The implementation includes the core driver entry point (\JDBC\), a \DataSource\ for connection pooling, and a complete set of JDBC 4 interfaces (\JDBC4Connection\, \JDBC4Statement\, \JDBC4PreparedStatement\, \JDBC4ResultSet\, and \JDBC4DatabaseMetaData\). Key features supported in this release include transaction management (auto-commit, commit, rollback, isolation levels), prepared statement parameter binding, result set navigation, and local database encryption via AES-128-GCM, AES-256-GCM, and AEGIS ciphers. The driver automatically loads the required native library (\\_turso\_java\) for supported platforms (macOS ARM64/x86, Linux x86, Windows) and registers itself with the \DriverManager\.

bindings/java, bindings/java/src/main/java/tech · high confidence

Establishes the foundational project structure and development workflow by adding contributor guidelines (AGENTS.md), a project-wide .gitignore, Docker-specific exclusions (.dockerignore), and text normalization rules (.gitattributes). It also introduces a .github.json file to map GitHub usernames to contributor identities and sets the Python development version to 3.13.

(repo-wide) · high confidence

Adds the Turso.Serverless.Client package, a pure managed HTTP client for connecting to Turso Cloud databases over the SQL over HTTP protocol (Hrana 3). This driver supports executing single statements with positional or named arguments, running atomic batches in a single round trip, and performing interactive transactions with automatic rollback on disposal. It features streaming cursor support for large result sets, encrypted database connectivity via the x-turso-encryption-key header, and a single-stream concurrency model that requires multiple connections for parallelism.

bindings/dotnet/src/Turso.Serverless.Client · high confidence

This change introduces a new \@tursodatabase/sync\ npm package that enables JavaScript applications to sync local Turso databases with Turso Cloud. The package exposes a \connect()\ function that returns a database instance with \pull()\, \push()\, and \sync()\ methods. It supports configuration options for remote encryption (\remote\_encryption\_cipher\, \remote\_encryption\_key\), partial sync strategies (\partial\_sync\_opts\), and experimental features. The implementation bridges the Rust \turso\_sync\_engine\ to JavaScript via N-API, handling HTTP requests, file I/O, and data transformations through a custom protocol interface.

bindings/javascript/sync · high confidence

The sync/sdk-kit module now exposes a C-compatible interface (capi.rs) and corresponding Rust API (rsapi.rs) to manage synced databases. This includes functions to create, open, and connect to a synced database, as well as to push changes, wait for changes, apply incoming changes, and retrieve sync statistics. The bindings support configuration options such as remote URL, encryption keys, partial sync strategies, and pull/push thresholds, enabling external applications to integrate with the Turso sync engine via a stable C ABI.

sync/sdk-kit · high confidence

The core I/O layer now exposes a \Clock\ trait with \current\_time\_monotonic\ and \current\_time\_wall\_clock\ methods, allowing backends to provide time sources that can be controlled in simulations. This is implemented via new \MonotonicInstant\ and \WallClockInstant\ types in \core/io/clock.rs\, and all I/O backends (Generic, Unix, io\_uring, Memory, VFS) now implement this trait to supply time for timeouts, WAL timestamps, and deterministic testing.

core/io · high confidence

The incremental view engine now uses a DBSP-style circuit compiler to maintain materialized views. This change adds new core components in core/incremental, including an aggregate operator (supporting COUNT, SUM, AVG, MIN, MAX, and their DISTINCT variants), a filter operator, a join operator, and a merge operator for UNION/UNION ALL. The compiler translates SQL logical plans into these DBSP circuits, allowing the system to incrementally update view results based on underlying table changes rather than recomputing from scratch.

core/incremental · high confidence

The Go bindings package is now available, providing an embedded SQLite-compatible database driver and a remote sync driver. The embedded driver registers as the "turso" driver for the standard \database/sql\ interface, supporting in-memory and file-based databases with optional encryption and async I/O. The sync driver enables local databases to bootstrap from and synchronize with remote Turso instances via push/pull operations, supporting partial sync strategies and configurable busy timeouts.

bindings/go · high confidence

This change adds a complete JSON processing engine to the core, introducing a binary JSONB format for efficient storage and manipulation alongside standard JSON text. It implements a suite of SQLite-compatible scalar functions including json\_valid, json\_extract, json\_set, json\_insert, json\_replace, json\_remove, json\_patch, json\_array, json\_object, json\_array\_length, json\_type, json\_pretty, and json\_quote, as well as the json\_each and json\_tree virtual tables for traversing JSON structures. The implementation includes a JSON5 parser, a path resolution engine, and a caching layer to optimize repeated access to JSON values.

core/json · high confidence

Adds a new core/mvcc module implementing multiversion concurrency control (MVCC) for the database engine. This includes a mutex-guarded logical clock for atomic timestamp generation, a state-machine-driven cursor that coordinates between the MVCC index and the underlying B-tree, and a portable logical log for capturing schema changes to support cross-platform synchronization. The module also provides yield and failure injection hooks to enable robust testing of concurrent transaction behaviors.

core/mvcc · high confidence

This change introduces the \pyturso\ Python package, providing a SQLite-compatible database driver built on the Turso SDK kit. The bindings expose a standard DB-API 2.0 interface for local in-memory or file-based databases, along with full \asyncio\ support for non-blocking operations. A key addition is the synchronization driver (\turso.sync\), which allows local databases to bootstrap from and sync bidirectionally with remote Turso/libsql servers, including support for partial sync strategies and remote encryption. The package also includes a SQLAlchemy dialect (\sqlite+turso://\) for easy integration with existing Python ORM workflows.

bindings/python · high confidence

This change adds the \sync/sdk-kit\ component, which exposes the sync engine's functionality through a C API (\turso\_sync.h\) and a \bindgen.sh\ script to generate Rust bindings. This enables external applications to integrate Turso Sync capabilities, including database configuration, connection management, and async operations, into their own codebases.

sync · high confidence

Added a new \sql\_generation/model\ module containing data structures (\Table\, \Column\, \Index\, \JoinedTable\) and traits (\TableContext\) that represent the schema and data state for SQL generation. This includes support for column constraints (UNIQUE, PRIMARY KEY, Generated), index definitions, and join types, providing the foundational model for generating SQL queries from simulated data.

_sql\generation/model · high confidence

Adds a new \Turso.Data.Sqlite\ package that provides a \System.Data.Common\-compatible SQLite API for interacting with Turso databases. The implementation includes core ADO.NET components such as \SqliteConnection\, \SqliteCommand\, \SqliteBatch\, and \SqliteBlob\, along with support for custom scalar functions, aggregate functions, and collations. It routes SQLite operations through managed backends and exposes a \ServerVersion\ of 3.50.4.

bindings/dotnet/src/Turso.Data.Sqlite · high confidence

Added a new TPC-H benchmark harness in the perf/tpc-h directory that enables performance comparison between Turso and SQLite. The suite includes scripts to run queries with cache dropping, measure execution times using EPOCHREALTIME, and generate visual plots of results. It supports manual regression testing via a comparison script that benchmarks two different binaries, and includes a README documenting the setup and usage for evaluating query performance.

perf/tpc-h · high confidence

The CLI application has been renamed to Turso and rebuilt from the ground up using Clap for argument parsing and Rustyline for the interactive shell. This release introduces built-in SQL syntax highlighting via a generated syntect syntax set, configurable via a TOML config file. New operational modes include an MCP server (--mcp) for AI tool integration and a sync server (--sync-server) for remote database access. The shell now supports dot commands with robust path tokenization, history persistence, and various experimental features gated behind flags such as MVCC, encryption, and custom types.

cli · high confidence

This change adds the Turso Entity Framework Core provider for SQLite, enabling applications to connect to Turso's remote and replica backends. The provider replaces standard EF Core SQLite services with Turso-specific implementations, including a custom query SQL generator that handles decimal collation and optimizes JSON array checks, and a database creator that manages local WAL mode and remote existence checks. It also registers custom SQL functions (such as regex, modulo, and arithmetic operations) and aggregates (avg, max, min, sum) to support Turso's specific capabilities, while ensuring proper connection handling for both direct remote and replica modes.

bindings/dotnet/src/Turso.EntityFrameworkCore.Sqlite · high confidence

The sdk-kit module is introduced as a low-level, SQLite-compatible API designed to facilitate the creation of language bindings for Turso. It exposes the core Rust logic through a portable C ABI (turso.h) and a Rust API (rsapi), allowing developers to generate bindings for other languages without reimplementing database semantics. Key features include explicit ownership models, clear status codes (e.g., Done, Row, Io, Error), and optional caller-driven async I/O. The kit also supports external page codecs for legacy encryption compatibility and includes a build script to generate Windows version resources. This module is distinct from the high-level \turso\ Rust crate and is intended for SDK authors.

sdk-kit · high confidence

The Python bindings now include a new async driver (lib\_aio) and a sync driver (lib\_sync) alongside the existing synchronous API. The async driver provides non-blocking database connections and operations, while the sync driver adds support for local-first synchronization with remote servers, including pull, push, and checkpoint capabilities. This enables users to build applications that require asynchronous I/O or offline-first data synchronization directly from Python.

bindings/python/turso · high confidence

The \extensions/core\ module now provides the foundational public API for building database extensions, introducing support for Virtual Tables (vtab), Virtual File Systems (VFS), and custom scalar/aggregate functions. Developers can now register custom SQL functions via the \ScalarFunc\ and \AggFunc\ traits, implement file system operations through the \VfsExtension\ trait (feature-gated for WASM compatibility), and define virtual table modules using the \VTabModule\ trait with full query planner integration via \xBestIndex\. The API exposes standardized types like \Value\, \ResultCode\, and \Connection\ to ensure safe, cross-language interoperability for extension authors.

extensions/core · high confidence

The core module now includes a new vector subsystem that defines support for multiple vector data formats, including dense Float32, dense Float64, sparse Float32, quantized Float8, and binary Float1Bit vectors. This change adds the underlying data structures and parsing logic for these types, along with execution functions for computing vector distances using cosine, L2 (Euclidean), dot product, and Jaccard similarity metrics, as well as functions for concatenating vectors and extracting vector data.

core/vector · high confidence

The core now exposes an \IndexMethod\ trait that allows custom index implementations to register with the database engine. This change introduces a pluggable architecture where index methods can define their own backing storage schemas (managed via \BackingStore\ and \BackingBtree\) and declare their MVCC capabilities (e.g., \TransactionalBackingStore\). Specifically, this location adds the foundational infrastructure for Full-Text Search (FTS) using Tantivy and a toy sparse vector inverted index (\toy\_vector\_sparse\_ivf\), including the necessary traits, configuration structures, and MVCC-aware cursor handling to support these new index types.

_core/index\method · high confidence

The core now supports loading external shared libraries (extensions) at runtime via a new \Connection::load\_extension\ method, which registers scalar functions, aggregate functions, and virtual table modules exposed by the library. This change introduces the \turso\_ext\ crate (renamed from \limbo\_ext\) as the standard interface for extensions, enabling features like virtual table execution through \xConnect\ callbacks and dynamic VFS module registration. The implementation uses thread-safe \Arc\ and \Mutex\ structures to manage extension state and ensures that schema parsing is re-triggered after extension loading to reflect new tables or functions.

core/ext · high confidence

The Turso.Data package now provides a managed ADO.NET implementation, allowing applications to connect to Turso databases using standard .NET data access patterns via TursoConnection, TursoCommand, and TursoDataReader. This release adds support for executing SQL batches through TursoBatch, enabling multiple statements to be sent in a single round-trip for both remote and embedded replica connections. It also introduces automatic background synchronization via TursoAutomaticSyncCoordinator, which periodically pulls changes from the primary and exposes status events, while connection options now support advanced replica configuration, partial sync, and remote encryption settings.

bindings/dotnet/src/Turso.Data · high confidence

The \@tursodatabase/sync\ package for Node.js is now available, providing a native embedded database with bidirectional sync capabilities. This release introduces experimental remote writes, allowing changes to be pushed directly to the remote database without an explicit push call, and partial sync with prefix and query-based bootstrap strategies to optimize data transfer. The package also supports remote encryption, configurable long-poll timeouts, and includes full TypeScript definitions and comprehensive test coverage for these new synchronization features.

bindings/javascript/sync/packages/native · high confidence

The new \@tursodatabase/database-wasm\ package provides an embedded SQLite database for JavaScript in the browser, featuring an async-first API where \connect()\ returns a Promise and \Database.prepare()\ returns a Promise. It uses a Web Worker for I/O completion and includes specific entry points (\index-bundle\, \index-default\, \index-turbopack-hack\, \index-vite-dev-hack\) to handle WASM loading quirks in different build environments like Vite and Turbopack. The package also includes comprehensive tests for large schemas, vector operations, and OPFS file handling.

bindings/javascript/packages/wasm · high confidence

The sync engine has been restructured into a new \sync/engine\ module that replaces the previous page-stream replication model with a Multi-Version Concurrency Control (MVCC) approach. This change introduces a portable logical log format (using \LogicalOp\ and \LogicalTxnData\ structures) to replicate row-level changes (upserts, deletes) and schema operations (create, drop, alter) rather than raw database pages. The engine now supports auto-detection of the remote pull protocol (MVCC logical log vs. page streams), allows for partial sync via configurable page thresholds, and includes a new \DatabaseReplayGenerator\ to safely apply these logical changes to the local database. This provides a more robust and efficient synchronization mechanism, particularly for large databases or sparse updates.

sync/engine · high confidence

Users can now install and run the Turso CLI via npm (\npx turso\ or \npm install -g turso\), which automatically resolves and executes the correct native binary for the current platform. This package supports macOS (ARM64, x64), Linux (ARM64, x64), and Windows (ARM64, x64), enabling consistent CLI access across all supported architectures without manual binary management.

packages/turso-cli · high confidence

Adds a new \turso\_serverless\ Python package that provides a DB-API 2.0 compliant interface to Turso databases over HTTP, eliminating the need for Rust FFI dependencies. The implementation uses the standard library's \urllib.request\ to handle the SQL over HTTP protocol, supporting parameterized queries, batch execution with configurable isolation modes, and server-side encryption key transmission. Users can now connect to remote Turso instances using standard Python database patterns without external binary drivers.

_serverless/python/turso\serverless · high confidence

This change adds the \Turso.Raw\ public API surface in the .NET bindings, providing low-level access to database operations. Users can now open SQLite databases with optional local encryption (supporting AES-128/256-GCM and AEGIS ciphers), prepare and execute statements, and register custom scalar/aggregate functions or collations. Additionally, the bindings expose a synchronous API for Turso database synchronization, allowing developers to configure, create, connect, push, and pull changes from remote replicas using a state-machine-driven operation model.

bindings/dotnet/src/Turso.Raw/Public · high confidence

The sdk-kit module is now available, providing a unified SDK layer that exposes both a C API (capi.rs) and a Rust API (rsapi.rs) for interacting with the database. This includes generated bindings (bindings.rs) for C interoperability, an IoBackend enum for selecting I/O backends (memory, syscall, io\_uring, experimental Windows IOCP), and concurrency guards to prevent concurrent access issues. The C API exposes functions for database setup, opening, connection management, and statement execution, while the Rust API provides idiomatic wrappers and internal synchronization mechanisms like SyncBusyGate.

sdk-kit/src · high confidence

The JavaScript SDK now includes a new \@tursodatabase/database-common\ package that provides shared utilities and base implementations for both Node and Browser (WASM) builds. This change introduces a promise-based \Database\ API where \prepare()\ returns a Promise, enabling async execution and per-statement query timeouts. Users can now execute multiple statements at once using the new \Database.batch()\ method, which supports various locking modes (write, read, deferred, immediate, exclusive, concurrent) and returns per-statement result details. The SDK also adds support for local database encryption via \EncryptionOpts\, allows enabling experimental features (such as views, triggers, and without\_rowid) through \DatabaseOpts\, and improves transaction safety with an \AsyncLock\ to prevent race conditions during concurrent execution within a transaction.

bindings/javascript/packages/common · high confidence

The \@tursodatabase/sync-common\ package is now available as a shared library for the Node and Browser sync builds. It introduces \RemoteWriter\ and \RemoteWriteStatement\ to support an experimental remote-write mode where write statements execute on the remote server and are followed by a pull for read-your-writes consistency. The package also provides \retryFetch\ for resilient HTTP transport with configurable backoff, and exposes configuration options in \DatabaseOpts\ such as \remoteWritesExperimental\, \pullBytesThreshold\ for bootstrap size limits, \pushOperationsThreshold\ for batching, and \partialSyncExperimental\ for loading subsets of data.

bindings/javascript/sync/packages/common · high confidence

A new sql\_generation crate has been added to the project, establishing the initial module structure with public exports for generation and model components. This change organizes SQL generation logic into a dedicated library, separating it from the simulator codebase while providing the foundational module layout for future implementation.

_sql\generation · high confidence

The Rust bindings are now available as the \turso\ crate (version 0.4.3), providing a high-performance, SQLite-compatible interface with native async/await support. Users can create local in-memory or file-based databases using the \Builder\ API and execute parameterized queries via \Connection\. The SDK includes a \sync\ feature that enables bidirectional cloud synchronization with Turso Cloud, allowing applications to push local changes and pull remote updates. The release also introduces parameterized batch execution for running multiple statements efficiently and supports custom I/O backends for advanced integration scenarios.

bindings/rust · high confidence

The \postgres/cli\ directory now provides the \tursopg\ command-line interface, an in-process PostgreSQL-compatible micro database that translates SQL directly to Turso's bytecode pipeline. Key capabilities include live materialized views that update incrementally without manual refresh, automatic attachment of persisted schema files (matching \turso-postgres-schema-\*.db\) on startup, and support for \CREATE TABLE AS\ and \SELECT INTO\ syntax. The CLI also accepts \COMMENT ON\ as a no-op for compatibility and preserves platform paths in dot commands.

postgres/cli · high confidence

The \core/alloc\ module now provides a unified allocation infrastructure that allows the database to use a custom, process-wide memory backend (configurable via \set\_allocator\) and routes allocations through distinct subsystem-specific allocators (MVStore, FTS, B-tree, etc.) defined in \DatabaseAllocators\. This change introduces \TryClone\ and fallible collection helpers (e.g., \try\_clone\, \try\_push\) to handle allocation failures gracefully instead of panicking, and adds an \AllocationSite\ tracking system to instrument and inject faults into specific memory operations for testing and observability.

core/alloc · high confidence

This change adds a new \core/alloc/collections\ module that provides fallible (result-returning) variants for standard Rust collections, including \Vec\, \HashMap\, \HashSet\, \BinaryHeap\, \VecDeque\, \Box\, \Arc\, and \Rc\. It introduces a suite of traits (such as \TursoFromIterator\, \TryClone\, and \TursoVecExt\) and their implementations, enabling operations like \try\_push\, \try\_insert\, \try\_clone\, and \try\_collect\ to handle allocation failures gracefully instead of panicking. This allows users to build systems that can recover from memory pressure rather than crashing.

core/alloc/collections · high confidence

The new Turso.Raw package exposes the underlying native SDK runtime (turso\_sdk\_kit) to .NET applications via P/Invoke, providing direct access to database lifecycle, connection management, statement execution, and sync-specific operations. This includes support for local encryption, custom scalar and aggregate functions, collations, and extension loading, along with a native library resolver to handle platform-specific loading (e.g., iOS frameworks). Application projects should reference higher-level provider packages like Turso.Data.Sqlite.Provider rather than this raw binding directly.

bindings/dotnet/src/Turso.Raw · high confidence

The \@tursodatabase/serverless\ package is now available, providing a native, fetch()-based SQL driver for Turso Cloud optimized for serverless and edge environments like Cloudflare Workers and Vercel. This new driver introduces a Connection/Statement pattern with native streaming support via \iterate()\, batch execution with per-statement statistics, and configurable request headers. It also includes a libSQL compatibility layer (\@tursodatabase/serverless/compat\) for drop-in replacement with existing applications, supporting features like remote encryption keys and interactive transactions.

serverless/javascript · high confidence

The Java bindings build system has been updated to facilitate publishing to Maven Central. A new \publish.gradle.kts\ script configures Maven publication metadata, enforces GPG signing (supporting both local GPG and CI-based in-memory keys via environment variables), and generates MD5/SHA1 checksums. It also includes a task to bundle the JAR, sources, javadoc, POM, and signatures into a zip file ready for upload, while explicitly blocking SNAPSHOT versions. The Gradle wrapper has been updated to version 8.10.

bindings/java/gradle · high confidence

The MVCC persistent storage layer now includes a new logical log format (v3) that supports optional encryption. When enabled, transaction payloads are split into fixed-size chunks and encrypted using AEAD, with the log header, transaction headers, and trailers remaining in plaintext. The log format includes a defined recovery process that validates frames using chained CRC32C checksums and replays only committed transactions that have not yet been checkpointed, ensuring durability and consistency after a crash. A regression test ensures that aborted deferred writes correctly clear staged CRC state to prevent corruption.

_core/mvcc/persistent\storage · high confidence

The \@tursodatabase/database\ native package for Node.js now includes local database encryption, allowing users to open encrypted files by passing an \encryption\ option with a cipher (such as \aegis256\) and a hex-encoded key. The SDK also introduces an asynchronous API via the \connect()\ function and \db.transactionAsync()\, enabling non-blocking database operations and concurrent transaction handling. Additionally, the package now supports the \REINDEX\ statement, handles \INSERT ... RETURNING\ correctly, and provides a compatibility layer that collapses duplicate column names in expanded rows to match \better-sqlite3\ behavior.

bindings/javascript/packages/native · high confidence

A new native Tcl extension (libturso\_tcl) replaces the previous subprocess-based shim, enabling the SQLite conformance test suite to run in-process. This change provides accurate engine error codes, real DML change counters, in-process Tcl function registration, multi-statement result accumulation, ATTACH/DETACH support, Tcl variable binding, and transaction handling directly within the Tcl environment.

bindings/tcl · high confidence

Added the Turso.Platform.Client package, a pure managed HTTP client for managing Turso platform resources such as databases, groups, auth tokens, organizations, members, and invites. The client is generated via NSwag from the official OpenAPI specification and includes a custom tool (OpenApiTitler) to improve generated type names. It provides methods like CreateDatabaseAsync, CreateDatabaseTokenAsync, and ListDatabasesAsync, and includes a hand-written Extensions class to handle the API's group-extension union serialization.

bindings/dotnet/src/Turso.Platform.Client · high confidence

Added a new \perf/memory\ benchmark suite to profile Full-Text Search (FTS) query memory usage. This includes a Rust binary (\fts-memory\) that runs FTS workloads under the \dhat\ heap profiler, supporting configurations for different query types, connection counts, and MVCC/WAL modes. A Python script (\analyze-dhat.py\) is also provided to parse the resulting allocation data into human-readable reports. This tool allows users to investigate memory allocation patterns and regressions specific to FTS operations.

perf/memory · high confidence

Added a new performance benchmarking suite in \perf/fts\ to measure Full-Text Search (FTS) latency and throughput for SQLite FTS5/WAL, Turso/WAL, and Turso/MVCC. The suite includes scripts to run search latency (measuring p50/p95/p99 per-query times) and throughput (completed searches per second) benchmarks, along with a memory peak heap measurement tool. It also introduces optional CPU flamegraph profiling via the \pprof\ crate and the external \inferno\ renderer, allowing developers to analyze CPU usage during search operations. Results are automatically plotted using a new Python script that generates comparison charts and speedup ratios.

perf/fts · high confidence

Introduces a new Go package (turso.tech/database/tursogo-serverless) that implements the database/sql interface for Turso Cloud via the SQL over HTTP protocol. Designed for serverless and edge environments, it avoids persistent connections and native dependencies. The driver supports authentication via auth tokens, customer-managed remote encryption keys (sent via the x-turso-encryption-key header), and interactive transactions spanning multiple HTTP requests. It includes a Connector API to keep credentials out of connection strings and provides conformance tests to ensure compatibility with the Turso protocol.

serverless/go · high confidence

The new ipaddr extension adds five scalar functions to SQLite for working with IP addresses and CIDR networks: ip\_contains checks if an IP is within a network, ip\_family returns 4 or 6, ip\_host extracts the IP from a CIDR, ip\_masklen returns the prefix length, and ip\_network returns the full CIDR string.

extensions/ipaddr · high confidence

Added a suite of new examples in the \examples/javascript\ directory demonstrating the Turso JavaScript SDK across different environments. The \database-node\ example shows basic local database usage in Node.js, while \database-wasm-vite\ provides a browser-based guestbook using the WASM build with Vite, including configuration for required COOP/COEP headers. New \encryption\ and \sync-encryption\ examples demonstrate local database encryption (using ciphers like Aegis256) and remote sync with optional encryption support. Additionally, \concurrent-writes\ illustrates handling MVCC conflicts with retry logic, and \sync-node\ and \sync-wasm-vite\ showcase bidirectional synchronization between local and remote databases.

examples/javascript · high confidence

The examples directory now includes a new JavaScript example demonstrating MVCC concurrent writes using \BEGIN CONCURRENT\, alongside existing Node.js and browser-based examples. The examples README has been updated to document these JavaScript samples, and a .gitignore file has been added to exclude database artifacts and node\_modules. Additionally, the Rust examples are now accessible via a symlink to the bindings directory.

examples · high confidence

Added four new example scripts in the Python examples directory: \basic.py\ demonstrates local embedded database usage; \concurrent\_writes.py\ shows how to handle MVCC mode with conflict retries for concurrent writers; \encryption.py\ illustrates local database encryption using various ciphers like aegis256; and \sync\_example.py\ demonstrates syncing with Turso Cloud, including optional remote encryption support.

examples/python · high confidence

This change introduces a new set of C++ JSI HostObjects in the React Native bindings, providing a thin 1:1 mapping of the Turso C API to JavaScript. The new files include \TursoHostObject\ (the entry point for installing the module), \TursoDatabaseHostObject\ (for opening and connecting to local databases), \TursoConnectionHostObject\ (for executing SQL statements and managing connections), \TursoStatementHostObject\ (for binding parameters and fetching results), and several sync-related objects (\TursoSyncDatabaseHostObject\, \TursoSyncOperationHostObject\, \TursoSyncIoItemHostObject\, \TursoSyncChangesHostObject\) to handle remote synchronization operations. These bindings expose methods like \prepareSingle\, \prepareFirst\, \getAllRows\, \pushChanges\, and \applyChanges\ directly to the JS runtime, enabling React Native apps to interact with Turso's local and sync capabilities.

bindings/react-native/cpp · high confidence

The \bindings/rust/examples\ directory now includes a set of runnable examples demonstrating key Turso SDK capabilities. The \example\ and \example\_struct\ files show basic database operations, including prepared statements, FTS indexing, and mapping query results to Rust structs within transactions. The \concurrent\_writes\ example illustrates MVCC mode using \BEGIN CONCURRENT\ to handle multiple simultaneous writers with conflict resolution. Additionally, \sync\_example\ demonstrates syncing a local database to Turso Cloud, including optional remote encryption configuration and network statistics reporting.

bindings/rust/examples · high confidence

The \sql\_generation/generation\ module has been replaced with a new, standalone SQL generation engine that creates random SQL schemas and queries. This engine introduces a \GenerationContext\ trait and \Arbitrary\ traits to drive the creation of tables, columns, and expressions. It supports generating virtual generated columns with type-safe expressions, configurable table sizes (including large tables), and various query structures like SELECT with joins and ORDER BY. The generation behavior is controlled via \Opts\ structs, allowing users to adjust probabilities for features like generated columns, large tables, and compound selects.

_sql\generation/generation · high confidence

Users can now connect to Turso databases using SQLAlchemy via three new dialects: \sqlite+turso://\ for local connections, \sqlite+aioturso://\ for async operations, and \sqlite+turso\_sync://\ for sync-enabled connections with remote support. The dialect requires SQLAlchemy \>= 2.0.45 to ensure compatibility with async adaptation and constraint reflection. It handles Turso-specific behaviors such as unsupported temporary tables, isolation level management at connect time, and remote synchronization via a helper function.

bindings/python/turso/sqlalchemy · high confidence

The \sqlite/parser\ directory now contains a complete SQL parser implementation, including the lexer, AST definitions, and parsing logic. This module introduces support for SQLite-specific syntax features such as \NULLS FIRST/LAST\ ordering, \::\ and \(...)\ parameter name suffixes, \EXPLAIN QUERY PLAN FORMAT=JSON\, and generated column constraints. It also enforces specific error behaviors like rejecting \LIMIT\/\ORDER BY\ on \DELETE\/\UPDATE\ and bounding expression depth to prevent stack overflows. Benchmarks are included to measure parser and lexer performance.

sqlite/parser · high confidence

This change introduces a new Rust-based implementation of the SQLite3 C API in the \bindings/c\ directory, acting as a compatibility layer that allows existing applications using SQLite to work with Turso without modification. The implementation includes the full C header definitions, a build script handling variadic C entry points and MSVC dependencies, and a comprehensive Rust source file exposing standard SQLite functions (such as \sqlite3\_open\, \sqlite3\_prepare\_v2\, and \sqlite3\_step\) alongside advanced features like authorizers, database configuration, and printf utilities. It also provides a dual-testing strategy with C and Rust test suites to ensure behavioral parity with the official SQLite library.

bindings/c · high confidence

The \@tursodatabase/database-wasm\ package is now available, providing an embedded SQLite database that runs directly in the browser via WebAssembly. This new package supports in-memory and file-based databases, includes full TypeScript definitions, and enables bidirectional sync with Turso Cloud through the \SyncEngine\. It introduces experimental features such as partial sync (with prefix and query bootstrap strategies), remote writes, and configurable pull thresholds, while also providing specific build entry points to handle WASM loading quirks in bundlers like Vite and Turbopack.

bindings/javascript/sync/packages/wasm · high confidence

Introduces the \turso\_serverless\ crate, a Rust driver for Turso Cloud that communicates via the SQL over HTTP protocol, designed for serverless and edge environments without persistent connections. The driver provides a \Connection\ API that mirrors the embedded \turso\ driver, supporting parameterized queries, prepared statements, and interactive transactions. It includes support for parameterized statement batches (\Connection::batch\ and \transactional\_batch\) to execute multiple statements in a single HTTP request, and allows for rotating authentication tokens via \Builder::with\_auth\_token\_fn\. The release also includes conformance tests that validate the driver's public API and the underlying wire protocol against a live Turso Cloud instance.

serverless/rust · high confidence

A new benchmark harness (\txn-throughput\) has been added to the \perf/throughput\ directory to measure and compare the concurrent write throughput of SQLite and Turso. The tool runs small, back-to-back write transactions across multiple connections (1 to 64) in a closed-loop fashion, reporting transactions per second alongside CPU utilization and service time percentiles. It supports comparing SQLite's WAL mode with Turso's MVCC mode, including configurable checkpointing strategies and IO backends (io\_uring on Linux, syscall elsewhere). The benchmark includes a Python plotting script to visualize results and shell scripts to automate runs with controlled drive state and caching.

perf/throughput · high confidence

The new \extensions/crypto\ module introduces a set of SQL scalar functions for cryptographic operations. Users can now compute SHA-256, SHA-512, SHA-384, SHA-1, MD5, and Blake3 hashes via \crypto\_sha256\, \crypto\_sha512\, \crypto\_sha384\, \crypto\_sha1\, \crypto\_md5\, and \crypto\_blake3\. Additionally, data encoding and decoding are supported for Base32, Base64, Hex, Base85, and URL formats through \crypto\_encode\ and \crypto\_decode\.

extensions/crypto · high confidence

The repository now includes a comprehensive suite of new scripts to support development, testing, and release workflows. These include \scripts/cargo-target-dir\ to resolve the Cargo build directory, \scripts/clone\_test\_db.sh\ to create writable test database clones, and \scripts/clean\_interactions.sh\ to extract SQL statements from simulator logs. For benchmarking, \scripts/compare-divan-std-turso.py\ compares standard library performance against Turso, while \scripts/nightly-bench.sh\ manages nightly Criterion benchmarks with memory caps and timeouts. Debugging is aided by \scripts/diff.sh\ for quick output comparisons, \scripts/corruption\_bisecter.py\ to find minimal failing SQL prefixes, and \scripts/run-sqlancer.sh\ for fuzzing. Release and CI automation is provided by \scripts/merge-pr.py\ (GitHub PR merging), \scripts/gen-changelog.py\ (changelog generation), \scripts/publish-crates.sh\ (Rust crate publishing), \scripts/pypi-cleanup\ (PyPI RC cleanup), and \scripts/release-status.py\ (milestone status reporting). Additional utilities include \scripts/install-sqlite3.sh\ for portable SQLite installation and \scripts/run-sim\ for running the simulator.

scripts · high confidence

Added a new \encryption-throughput\ benchmark tool in the \perf/encryption\ directory to measure database performance with and without encryption. The tool allows users to configure thread count, batch size, iterations, read/write ratios, and specific encryption ciphers (defaulting to aegis-256) to evaluate throughput and latency impacts of enabling database encryption.

perf/encryption · high confidence

The fuzzy extension now includes several new SQL scalar functions for string similarity and phonetic matching. Users can calculate edit distances using \fuzzy\_editdist\ (based on the sqlean algorithm), \fuzzy\_leven\ (Levenshtein), and \fuzzy\_damlev\ (Damerau-Levenshtein). Additionally, new phonetic hashing functions are available: \fuzzy\_soundex\ and \fuzzy\_rsoundex\ for Soundex variants, \fuzzy\_phonetic\ for a custom phonetic hash, \fuzzy\_caver\ for the Caverphone algorithm, and \fuzzy\_translit\ for transliterating Unicode characters to ASCII. These functions enable more robust fuzzy searching and name matching capabilities directly within SQL queries.

extensions/fuzzy · high confidence

Added new internal modules (asyncOperation.ts and ioProcessor.ts) that drive sync operations to completion and handle I/O requests using React Native's standard APIs (fetch, file system). This enables network requests to be visible in the React Native debugger, allows customization of fetch (e.g., proxies, custom headers), and supports dynamic auth tokens and base URLs via functions.

bindings/react-native/src/internal · high confidence

Added a new \turso-join-benchmark\ tool in the \perf/join-benchmark\ directory that measures query execution performance without printing result rows. The tool outputs JSON records containing elapsed time and detailed work counters, including split B-tree seek metrics (total, table, index, and deferred seeks) and in-memory hash probe calls. It supports running against specific query directories, filtering queries, setting timeouts, and printing query plans in JSON format, enabling users to analyze join execution efficiency using release builds.

perf/join-benchmark · high confidence

The macros crate now provides a suite of new procedural macros: \turso\_assert!\ and related variants that integrate with the Antithesis SDK for autonomous testing (behaving as standard assertions when the \antithesis\ feature is disabled), an \AtomicEnum\ derive macro for generating lock-free atomic wrappers for enums with unit or single-field variants, a \trace\_stack\ attribute for scoped tracing spans, and test-harness helpers like \run\_test\ for configuring database options (MVCC, encryption, init SQL).

macros/src · high confidence

The \macros/src/ext\ module now provides a suite of procedural macros to simplify the creation of Turso extensions. The \register\_extension!\ macro allows developers to declaratively list scalar functions, aggregate functions, virtual tables, and VFS modules for automatic registration. Additionally, \\#\[scalar\]\ and \\#\[derive\_scalar\]\ macros generate the necessary C-ABI glue code for scalar functions (including stateful ones), \\#\[derive\_agg\_func\]\ handles aggregate function registration, \\#\[derive\_vtab\_module\]\ implements the virtual table interface, and \\#\[derive\_vfs\_module\]\ generates the VFS implementation. A \match\_ignore\_ascii\_case\ macro is also included to optimize case-insensitive string matching.

macros/src/ext · high confidence

The core functions module now includes new SQL scalar functions: \gcd\ and \lcm\ for greatest common divisor and least common multiple calculations (with overflow handling), \repeat\, \lpad\, and \rpad\ for string padding and repetition, and a comprehensive \printf\ implementation supporting SQLite-compatible format specifiers (including \%c\, \%e\, \%E\, \%f\, \%i\, \%o\, \%u\, \%x\, \%X\). These additions expand the database's capability for mathematical operations, text manipulation, and formatted string output.

core/functions · high confidence

Developers now have a pre-configured development container that includes Go, Rust, and Python toolchains, along with VS Code extensions for language server support. The environment is secured by a Squid proxy and a strict iptables firewall that restricts outbound network access to a specific allowlist of domains (such as GitHub, package registries, and Anthropic services), ensuring that development work remains isolated and safe.

.devcontainer · high confidence

A new proc-macro attribute \signature\ has been added to the \sdk-kit-macros\ crate. This macro ensures that the signature of a Rust function matches the signature of a corresponding C API function (extern "C") by generating a compile-time check. This helps prevent mismatches between the internal Rust API and the exported C bindings, improving reliability for users integrating with the SDK's C interface.

sdk-kit-macros · high confidence

Added a new benchmark tool in the \perf/latency\ directory that measures write transaction latency distributions for SQLite and Turso. The harness runs both engines under identical, fixed-schedule arrival loads (Poisson or fixed) across varying connection counts (1, 8, 16, 32) to expose contention and queuing effects that standard benchmarks might hide. It outputs raw latency samples, checkpoint timings, and system metrics, which are then plotted as empirical cumulative distribution functions (eCDFs) showing percentiles like p50, p90, and p99.9. The benchmark supports configurable modes (SQLite WAL with \BEGIN IMMEDIATE\ vs. Turso MVCC with \BEGIN CONCURRENT\), passive checkpointing, and detailed restart counting to accurately reflect real-world stall behavior.

perf/latency · high confidence

The \core/vector/operations\ module now provides a comprehensive set of vector manipulation functions. Users can concatenate vectors of the same type (excluding Float1Bit and Float8), convert between dense (f32/f64), sparse, 1-bit, and 8-bit quantized formats, and slice vectors. Additionally, new distance metrics are available: L2 (Euclidean), Cosine, Dot product, and Jaccard, all supporting dense, sparse, 1-bit, and 8-bit vector types where applicable. The Cosine distance now returns NaN for zero vectors instead of an error, and the implementation uses \simsimd\ for optimized performance on supported platforms, with Rust fallbacks for WASM and Windows AArch64.

core/vector/operations · high confidence

A new test infrastructure has been added to validate the Turso PostgreSQL server's compatibility with the upstream PostgreSQL regression suite. This includes a minimal synchronous wire-protocol client (\postgres/client/lib.rs\) for driving the server, a Python-based runner (\postgres/conformance/run.py\) that manages the test lifecycle and gates results against a pass/fail status table, and a Rust-based regression runner (\postgres/regress/\) that executes the upstream SQL corpus and emulates psql meta-commands (such as \ackslash\ describe commands) to produce byte-comparable transcripts. This allows users to verify server behavior against a comprehensive, real-world test corpus.

postgres/conformance · high confidence

A new PostgreSQL-compatible server implementation has been added to the \postgres/server\ module, enabling clients to connect via the standard pgwire protocol. This change introduces a new \TursoPgServer\ that listens for TCP connections and routes queries through a handler which splits multi-statement queries and executes them against the underlying database connection. The implementation includes basic schema management logic, specifically cleaning up associated database files when a schema is dropped, and supports the simple query protocol for executing SQL statements.

postgres/server · high confidence

A new \completion\ virtual table extension has been added to the \extensions/completion\ crate, enabling SQL keyword autocompletion. The extension registers a \CompletionVTabModule\ that exposes a virtual table with columns for completion candidates, prefixes, and the full query line. It leverages the \turso\_ext\ crate (renamed from \limbo\_ext\) to implement the virtual table API, including \best\_index\ for query planning and cursor filtering to match input against a static list of 147 SQL keywords defined in \keywords.rs\.

extensions/completion · high confidence

The core module now includes a vendored, lock-free concurrent skip list implementation (SkipMap and SkipSet) that supports safe concurrent access across multiple threads. This change introduces a parameterized allocator interface, allowing the data structures to use a custom \SkiplistAllocator\ (such as \TursoAllocator\) instead of relying on a process-wide default, which improves memory management flexibility and isolation. The implementation includes comprehensive test coverage for insertion, removal, iteration, and concurrent edge cases.

core/skiplist · high confidence

The storage layer now encrypts database pages and WAL frames using AES-256-GCM. Users can configure the cipher algorithm via the \PRAGMA cipher\ command and set the encryption key through connection methods. The pager and WAL modules handle encryption and decryption transparently during read and write operations, and the database header is also encrypted to prevent reading unencrypted data on corrupted or improperly initialized files.

core/storage · high confidence

The engine now routes initial statement preparation, re-preparation, and schema loading through a new \Dialect\ trait, allowing dialect-specific SQL parsing and function resolution to be decoupled from the core engine mechanics. This change centralizes how SQL text is interpreted (e.g., parsing \CREATE TABLE\ statements) and how functions are resolved, enabling future support for non-SQLite dialects while maintaining SQLite compatibility via the \SqliteDialect\ implementation. Users benefit from a more modular architecture that ensures dialect-specific behaviors are correctly isolated and extensible.

core/dialect · high confidence

The MVCC checkpoint state machine and group commit coordinator have been relocated into the core/mvcc/database module. This change consolidates the checkpoint logic (including row collection, pager transactions, WAL truncation, and garbage collection) and the group commit batching mechanism into a single, dedicated location, improving code organization and maintainability without altering the external behavior of MVCC transactions.

core/mvcc/database · high confidence

The core SQL bytecode emitter has been reorganized from a single monolithic module into distinct, focused submodules: delete, select, update, and gencol. This structural change improves code maintainability and readability by separating the logic for different SQL operations (DELETE, SELECT, UPDATE) and generated column handling into their own files, while the main mod.rs now acts as the central coordinator for these specialized emitters.

core/translate/emitter · high confidence

The query translation logic in core/translate has been restructured to improve modularity and reduce stack usage. INSERT translation now uses a dedicated InsertEmitCtx, and the main Plan struct has been split into distinct Select and Delete variants. To handle the increased complexity of these plans without exhausting the call stack, large structures like ProgramBuilder, Plan variants, and TranslateCtx are now heap-allocated (boxed). Additionally, the module has been reorganized by splitting the monolithic emitter.rs into smaller, focused sub-modules.

core/translate · high confidence

The main loop translation logic in core/translate/main\_loop has been restructured from a monolithic implementation into distinct modules (body, close, conditions, hash, in\_seek, init, multi\_index, open, seek). This refactoring improves code maintainability and clarity by separating concerns such as loop initialization, cursor management, condition evaluation, hash join handling, and multi-index scan logic, while preserving the existing query execution behavior.

_core/translate/main\loop · high confidence

The debugging skill now includes specific instructions for handling database corruption, directing users to the corruption debug tools located in the scripts directory and the detailed usage guide in the references folder.

.claude/skills/debugging · high confidence

A new Node.js script (inline-wasm-base64.js) has been added to the JavaScript bindings to address build system issues in Vite and Next.js. This script reads a WebAssembly file, converts it to a base64 data URL, and injects it into a JavaScript file by replacing a placeholder, effectively inlining the WASM binary to bypass specific bundler limitations.

bindings/javascript/scripts · high confidence

The CLI command parser has been rewritten to use the Clap library, introducing structured argument definitions and subcommands for existing and new features. Users can now use the .clone command (renamed from .copy) to duplicate the database, .parameter to manage SQL statement bindings, .read to execute SQL from files, and .indexes to list table indexes. The .import command now validates that the target table exists before importing data and supports path completion for input files. Additionally, new commands include .headers to toggle column headers, .stats for database statistics, .timer for performance metrics, .dbconfig for database configuration, .manual for help pages, and .echo to repeat commands. The .exit command now accepts an exit code, and aliases like .q for .quit are supported.

cli/commands · high confidence

The .codex/skills path is now a symbolic link pointing to ../.claude/skills, meaning any skills configured for the Claude environment are automatically available to Codex as well.

.codex · high confidence

The \bindings/python/turso/sync\ package now explicitly exports the \ConnectionSync\ class and the \connect\_sync\ function (aliased as \connect\), along with partial sync configuration options (\PartialSyncOpts\, \PartialSyncPrefixBootstrap\, \PartialSyncQueryBootstrap\) and encryption cipher types. Additionally, the module exposes required DB-API 2.0 module-level attributes such as \apilevel\, \paramstyle\, \threadsafety\, and SQLite version information, enabling compatibility with libraries like SQLAlchemy that rely on these standard interface markers.

bindings/python/turso/sync · high confidence

The expression translation logic in core/translate/expr has been reorganized into dedicated modules (affinity, arrays, binary, binding, columns, condition, custom\_types, emission, functions) to improve maintainability and correctness. This change introduces precise column affinity resolution for expressions, ensuring that data types are correctly preserved during comparisons, row-value operations, and IN-list evaluations. It also adds support for custom type encoding/decoding in array operations, improves handling of virtual generated columns by computing them inline during column reads, and refactors binary expression emission to properly manage collation contexts and row-value arity checks. Users benefit from more accurate type handling in complex queries, better support for custom data types, and corrected behavior for virtual columns and array transformations.

core/translate/expr · high confidence

The time extension functions have been moved to the core module, consolidating the implementation. Additionally, a fix addresses a potential multiplication overflow in the \time\_date\ function, ensuring that date construction handles large integer inputs safely without panicking or producing incorrect results.

core/time · medium confidence

The FTS index method has been rewritten to store segment data in a new on-disk format (v2) backed by a central B-tree registry instead of a file-based directory. This change enables multiple concurrent transactions to write to the same FTS index safely by using MVCC for the segment registry and document identity-based tombstones, ensuring that deletes and merges commute without conflict. The implementation introduces in-memory directory abstractions for Tantivy, explicit merge phases, and stricter validation for field weights and query inputs.

_core/index\method/fts · high confidence

The core numeric system now supports a new \numeric(precision, scale)\ type that stores values as arbitrary-precision blobs using the \BigDecimal\ library, allowing for exact decimal arithmetic beyond standard floating-point limits. This change introduces a new \Numeric\ enum variant within the \Value\ type to hold these high-precision numbers alongside integers and floats, and implements custom serialization/deserialization logic to ensure data integrity and prevent crashes from malformed inputs. Additionally, the system now uses a \NonNan\ wrapper for float operations to prevent NaN-related panics and ensures consistent comparison behavior compatible with SQLite, while also fixing rounding behavior in the \round()\ function to break ties away from zero.

core/numeric · high confidence

The React Native bindings now serialize database operations using a new AsyncLock mechanism to prevent concurrent access to the native SQLite connection, ensuring thread safety during query execution. Additionally, the public API surface has been simplified to expose only the \paths.database\ property for automatic path resolution, and the \connect\ function now supports passing the remote URL as a function for dynamic authentication scenarios.

bindings/react-native/src · high confidence

The \sql\_generation/model/query\ module has been refactored to introduce a comprehensive, structured model for generating SQL statements. This change adds dedicated data structures and serialization support for \CREATE\, \ALTER TABLE\ (including column and table renaming, adding/dropping columns), \DROP TABLE\, \CREATE INDEX\, and \DROP INDEX\ operations. It also expands \INSERT\ handling to support \ON CONFLICT\ (upsert) logic and \INSERT ... SELECT\ patterns, while introducing a new \Predicate\ model that wraps the parser's AST to enable evaluation against table rows. Additionally, the module now supports generating \PRAGMA\ statements (such as \wal\_checkpoint\ and \foreign\_key\_list\) and defines explicit models for transaction control (\BEGIN\, \COMMIT\, \ROLLBACK\).

_sql\generation/model/query · high confidence

The query optimizer has been restructured into a dedicated module (\core/translate/optimizer\) with separate files for access methods, constraints, cost estimation, join ordering, and common subexpression lifting. This introduces a new cost-based planning system that supports hash joins, multi-index scans, and expression-based index seeks. The cost model is now configurable via a JSON file loaded from the \TURSO\_OPTIMIZER\_PARAMS\ environment variable, allowing tuning of selectivity fallbacks, cache reuse factors, and CPU/IO weights for specific workloads.

core/translate/optimizer · high confidence

The SQL predicate generator in \sql\_generation/generation/predicate\ has been refactored to support \IS\ comparisons (treating NULLs as equal, similar to \=\) and to correctly generate \GTValue\ and \LTValue\ expressions that accommodate NULL values. This change ensures that generated predicates are valid and deterministic even when table rows contain NULL data, improving the reliability of the deterministic simulator's fuzzing and query generation capabilities.

_sql\generation/generation/predicate · high confidence

The value generation logic in the SQL simulator has been reorganized into dedicated modules (cmp.rs, pattern.rs) to support more robust random data creation. This change introduces specific generators for less-than (LTValue) and greater-than (GTValue) comparisons, ensuring correct handling of edge cases such as integer overflow, float ranges, and NULL values (where NULL is treated as less than any other value). It also adds a LikeValue generator for creating pattern-matching strings with wildcards. These updates improve the accuracy and coverage of simulated SQL queries by aligning value generation with SQL semantics for comparisons and text patterns.

_sql\generation/generation/value · high confidence

The core module has replaced the \log\ crate with the \tracing\ framework for all internal logging. This change standardizes the logging infrastructure, allowing for more structured and performant log output across the database engine.

core · high confidence

The Turso Sync SDK Kit framework included in the React Native templates has been renamed from \turso\_sync\_sdk\_kit\ to \turso-sync-sdk-kit\. This change updates the bundle identifiers, executable names, and framework paths within the XCFramework metadata to use hyphens instead of underscores, ensuring consistency with the new naming convention for iOS builds.

bindings/react-native/templates · high confidence

The conformance test snapshots for correlated subqueries, CTEs, and materialized orders have been refreshed to reflect new optimizer and bytecode-generation behaviors. Correlated subqueries now utilize ephemeral subquery indexes for efficient probing, and CTEs with explicit materialization correctly preserve or discard sort orders depending on whether the outer query's sort direction matches, reuses, or conflicts with the CTE's ordering. These snapshot updates document the resulting query plans and bytecode for these specific subquery and CTE patterns.

_sqlite/conformance/sqlite-sqltests/snapshot\tests/subqueries · high confidence

The VDBE (Virtual Database Engine) core has been optimized for performance and stability. Key changes include inlining the dispatch loop and comparison opcodes to reduce overhead, reusing registers and cursor states to minimize allocations, and fixing several correctness bugs related to affinity handling, MVCC transaction states, and error propagation. These updates improve query execution speed and reliability.

core/vdbe · high confidence

The React Native iOS binding for Turso has been updated to implement the RCTInvalidating protocol, allowing the module to properly clean up resources when the bridge is destroyed. Additionally, the module now exports iOS-specific document and library paths, and respects the Turso\_AppGroup Info.plist key to store database files in shared app group containers, enabling data sharing between the app and its extensions.

bindings/react-native/ios · high confidence

The build scripts for all extensions (completion, core, crypto, csv, fuzzy, ipaddr, regexp) now conditionally link the Windows \advapi32\ library only when the target OS is Windows, rather than linking it unconditionally. This ensures that extensions build correctly on non-Windows platforms where \advapi32\ is not available, fixing previous build failures or unnecessary dependencies on those systems.

extensions · high confidence

Add Antithesis testing suite for multiprocess WAL and stress-composer workloads; Add CodSpeed memory benchmarks for FTS queries and workload profiles; Add PostgreSQL conformance test corpus for SQL behavior; Add snapshot tests for SQL set operations; Added .NET benchmark suite for Turso and SQLite providers; Added .NET test suite for Turso bindings; Added C API test suite and randomized differential oracle; Added CLI test coverage for sync isolation, exit codes, parameter bindings, and VDBE tracing; Added SQL conformance test suite for math functions; Added SQL function benchmarks for datetime, LIKE, numeric, and value operations; Added SQLite conformance test suites for SQL functions and query clauses; Added SQLite test extension for KV store compatibility verification; Added benchmark to compare Turso and SQLite query batch performance; Added compatibility tests for the C bindings API; Added comprehensive test suite for Turso Java JDBC bindings; Added conformance test suites for SELECT operations; Added conformance tests for GROUP BY behavior; Added integration and regression tests for Rust bindings; Added integration test infrastructure for the PostgreSQL frontend; Added integration tests for PostgreSQL dialect support; Added integration tests for SQLite dbhash compatibility; Added integration tests for the JavaScript serverless driver; Added integration tests for the Turso Serverless Python driver; Added integration tests for the tursopg CLI; Added memory profiling tests for FTS queries and concurrent transactions; Added micro-benchmarks for Turso and better-sqlite3 performance comparison; Added property-based tests for encryption headers and driver parity; Added sample applications to validate NuGet package and NativeAOT integration; Added serverless driver test suite for encryption headers and API parity; Added snapshot tests for ANALYZE statement behavior; Added snapshot tests for SQL aggregation query plans; Added sqltest framework with multi-backend SQL conformance testing; Added test coverage for the PostgreSQL parser; Added test extension for validating virtual table and VFS behaviors; Aggregate function conformance tests added; Comprehensive conformance test suite for SQLite window functions; Comprehensive test suite for Python bindings; Conformance tests added for SQLite PRAGMAs; Conformance tests for OFFSET behavior with joins and type casting; Expanded SQL conformance test coverage for Turso SQLite; Expanded conformance tests for SQLite integrity\_check and quick\_check pragmas; Expanded join conformance test coverage; Import upstream SQLite TCL conformance test suite; JSON conformance test suite for SQLite compatibility; New SQL generation test oracle with coverage tracking and capability restrictions; New comprehensive benchmark suite for Turso core performance; New conformance tests for index usage patterns and query plans; New conformance tests for subquery and CTE behaviors; New fuzz testing infrastructure for CTEs, custom types, expression indexes, and FTS; New fuzz testing targets for schema, expressions, and scalar functions; Rust serverless differential testing harness for encryption and API parity; Snapshot tests for SQL join strategies and query plans; Snapshot tests for data modification query plans; Snapshot tests for multi-index, CTE, and foreign-key bytecode behavior; TPC-H snapshot tests updated to reflect new optimizer and bytecode behavior; Updated bytecode snapshots for window function tests.

This change introduces the initial commit for the Turso 0.8.0-pre.13 workspace, establishing the foundational dependency graph and project structure. It adds the \Cargo.lock\ file and root \Cargo.toml\, defining workspace members for core database components, CLI, and bindings across Rust, JavaScript, Python, Java, and .NET. The dependency manifest pins key libraries including \rusqlite\ 0.37.0, \mimalloc\ 0.1.47, \clap\ 4.5.47, and \tracing\ 0.1.41, while also adding Python test dependencies (\faker\ 26.0.0) and .NET sample projects for NativeAOT and mobile targets.

(dependencies) · high confidence

The JavaScript bindings directory has been updated to use Yarn 4.9.2 as the package manager, replacing the previous version. This change includes the addition of a Yarn 4.9.2 release file and updated configuration files (such as .gitignore and .npmignore) to support the new tooling, ensuring consistent dependency resolution and installation for the JavaScript SDK.

bindings/javascript · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 38 → 46 (+8.1)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 63 → 65 (+3.0)
• Architecture 73 → 75 (+2.2)
• Maturity 74 → 74 (+0.2)
• Readiness 37 → 71 (+33.5)
• Security 22 → 19 (-2.4)
• Event-Driven 80 (new)
• Event Sourcing 100 (new)
• Performance 69 → 69 (+0.3)

• BarePragmaDisable (bindings/dotnet/src/Turso.Serverless.Client/TursoSession.cs)
• Bounded contexts not declared
• Change coupling: index.d.ts ↔ index.js (bindings/javascript/packages/native/index.d.ts)
• Change coupling: index.ts ↔ index.js (bindings/javascript/sync/packages/common/index.ts)
• Change coupling: index.ts ↔ promise.ts (bindings/javascript/packages/common/index.ts)
• Change coupling: index.ts ↔ promise.ts (bindings/javascript/sync/packages/common/index.ts)
• Change coupling: promise-bundle.ts ↔ promise-default.ts (bindings/javascript/sync/packages/wasm/promise-bundle.ts)
• Change coupling: promise-bundle.ts ↔ promise-turbopack-hack.ts (bindings/javascript/sync/packages/wasm/promise-bundle.ts)
• Change coupling: promise-bundle.ts ↔ promise-vite-dev-hack.ts (bindings/javascript/sync/packages/wasm/promise-bundle.ts)
• Change coupling: promise-default.ts ↔ promise-turbopack-hack.ts (bindings/javascript/sync/packages/wasm/promise-default.ts)
• Change coupling: promise-default.ts ↔ promise-vite-dev-hack.ts (bindings/javascript/sync/packages/wasm/promise-default.ts)
• Change coupling: promise-turbopack-hack.ts ↔ promise-vite-dev-hack.ts (bindings/javascript/sync/packages/wasm/promise-turbopack-hack.ts)
• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (serverless/javascript/package-lock.json)
• Critical CVE: [GHSA redacted] (bindings/javascript/package-lock.json)
• Critical CVE: [GHSA redacted] (bindings/javascript/package-lock.json)
• Critical CVE: [GHSA redacted] (bindings/javascript/package-lock.json)
• Critical IaC: DS-0010 (.devcontainer/Dockerfile)
• Duplicated block (11 lines × 2) (bindings/dotnet/src/Turso.Data.Sqlite/SqliteDataReader.cs)
• Duplicated block (13 lines × 2) (bindings/dotnet/src/Turso.EntityFrameworkCore.Sqlite/Query/Internal/TursoSqliteQueryableMethodTranslatingExpressionVisitor.cs)
• …and 104 more

• AggregateEvalState::process_delta (cognitive 35) (core/incremental/aggregate_operator.rs)
• AggregateFunction::from_values (cognitive 22) (core/incremental/aggregate_operator.rs)
• AggregateFunction::from_values (cyclomatic 16) (core/incremental/aggregate_operator.rs)
• AggregateOperator::commit (cognitive 36) (core/incremental/aggregate_operator.rs)
• AggregateOperator::commit (cyclomatic 17) (core/incremental/aggregate_operator.rs)
• AggregateOperator::extract_distinct_deltas (cognitive 16) (core/incremental/aggregate_operator.rs)
• AggregateOperator::merge_delta_with_existing (cognitive 45) (core/incremental/aggregate_operator.rs)
• AggregateOperator::merge_delta_with_existing (cyclomatic 19) (core/incremental/aggregate_operator.rs)
• AggregateState::apply_delta (cognitive 44) (core/incremental/aggregate_operator.rs)
• AggregateState::apply_delta (cyclomatic 23) (core/incremental/aggregate_operator.rs)
• AggregateState::from_value_vector (cognitive 52) (core/incremental/aggregate_operator.rs)
• AggregateState::from_value_vector (cyclomatic 23) (core/incremental/aggregate_operator.rs)
• AggregateState::to_values (cognitive 16) (core/incremental/aggregate_operator.rs)
• AlterTable::shadow (cognitive 18) (testing/simulator/model/mod.rs)
• AlterTable::shadow (cyclomatic 16) (testing/simulator/model/mod.rs)
• Ambiguous intent between data modification and synchronization. ExecuteNonQuery is standard ADO.NET terminology for running SQL commands (INSERT/UPDATE/DELETE). However, Sync and SyncAsync are also present on the Connection object. In a sync-enabled database library, 'Sync' usually implies pushing/pulling local changes to a remote server, whereas 'ExecuteNonQuery' implies executing a specific SQL statement. If Sync is intended to be a high-level operation distinct from SQL execution, the naming is clear. However, if Sync is meant to trigger a background sync process while ExecuteNonQuery runs SQL, the distinction is good. The potential inconsistency lies in whether Sync could be confused with a manual trigger for the automatic sync state machine, or if it performs a specific SQL operation. Given the presence of TursoSyncDatabase with explicit Pull/Push methods, Connection.Sync likely triggers a full sync cycle. This is distinct from ExecuteNonQuery. No true redundancy found, but the naming Sync on a Connection is slightly overloaded compared to the explicit Pull/Push on TursoSyncDatabase. However, this is a design choice (convenience vs explicitness) rather than a strict API inconsistency.
• BTreeCursor::balance (cognitive 39) (core/storage/btree.rs)
• BTreeCursor::balance (cyclomatic 18) (core/storage/btree.rs)
• BTreeCursor::balance_non_root (cognitive 311) (core/storage/btree.rs)
• BTreeCursor::balance_non_root (cyclomatic 87) (core/storage/btree.rs)
• …and 3572 more

• 300 commits — 291 feature/other, 9 fixes

• (repo) — 108 commits
• core/translate — 40 commits
• sqlite/conformance — 19 commits
• .github/workflows — 14 commits
• core/mvcc — 14 commits
• core/storage — 13 commits
• core/vdbe — 13 commits
• core/index_method — 9 commits
• bindings/javascript — 7 commits
• core/types.rs — 6 commits
• (root) — 5 commits
• core/benches — 5 commits
• core/schema.rs — 5 commits
• testing/stress — 5 commits
• tests/integration — 5 commits
• core/database.rs — 3 commits
• perf/fts — 3 commits
• testing/antithesis — 3 commits
• bindings/react-native — 2 commits
• core/Cargo.toml — 2 commits

• fix: Merge 'core/io: Fix completion group memory leak' from Pedro Muniz
• fix: Merge 'core/schema: Fix ALTER TABLE ADD/DROP COLUMN dropping column type size parameters' from Sergei Iarymov
• fix: Merge 'core/vdbe: fix wrong schema_version after VACUUM INTO on an MVCC database' from roboturso
• fix: Merge 'optimizer: integrate hash joins better into cost model and fix hash-join associated bugs' from Jussi Saurio
• fix: core/io: fix completion group leak caused by self-reference Arc cycle
• fix: core/vdbe: fix wrong schema_version after VACUUM INTO on an MVCC database
• fix: fix cargo fmt error
• fix: fix js backend missing experimental vacuum flag
• fix: fix the space
• change: Merge 'Add rule on helper functions' from Mikaël Francoeur
• change: Merge 'Reduce Nyrkio runtime' from Pekka Enberg
• change: Merge 'Refactor hash join selection' from Mikaël Francoeur
• change: Merge 'Refactoring' from Mikaël Francoeur
• change: Merge 'Reuse buffers when decoding record TEXT' from Jussi Saurio
• change: Merge 'Use fast paths for common record values' from Jussi Saurio
• change: Merge 'bindings/dotnet: let native code own function callback handles' from Pekka Enberg
• change: Merge 'bindings/javascript: stop the sync loops in the concurrent-updates test' from Pekka Enberg
• change: Merge 'bindings/javascript: update vitest to 4.1.11' from Pekka Enberg
• change: Merge 'bindings/js: enable experimental vacuum flag in sqltest runner' from Sergei Iarymov
• change: Merge 'build(deps): bump baseline-browser-mapping from 2.10.16 to 2.11.24 in /examples/react-native' from app/dependabot
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

tursodatabase/turso was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.