Skip to content
CAI
Software that uses CAICheck a score

groue/GRDB.swift

64.0

Adequate · 14 November 2026

66.7k

lines of production code

Swift

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add SwiftLint configuration and helper scripts

The build process now includes a dedicated SwiftLint configuration (Scripts/swiftlint.yml) that disables numerous rules (such as force\_try, force\_cast, and file\_length) and enables specific opt-in and analyzer rules to enforce code style. A new shell script (Scripts/swiftlint.sh) integrates SwiftLint into the build, adding support for Homebrew installations on Apple Silicon and gracefully handling cases where SwiftLint is not installed. Additionally, a Ruby script (Scripts/destination.rb) was added to parse simulator device information from JSON input.

Scripts · high confidence

Added Associations playground demonstrating one-to-many and belongs-to relationships

A new playground has been added to the Documentation folder to demonstrate how to define and use database associations in GRDB. It shows how to set up a schema with \hasMany\ and \belongsTo\ relationships between \Author\ and \Book\ records, populate the database, and fetch data using both individual record requests and eager loading via \including(required:)\.

Documentation/Playgrounds/Associations.playground · high confidence

Added Xcode workspace configuration for Swift Package Manager

A new Xcode workspace file (contents.xcworkspacedata) has been added to the .swiftpm directory. This file configures the workspace to reference the local package, enabling Xcode to open and manage the Swift Package Manager project structure directly.

.swiftpm · high confidence

Association aggregates now support ABS, LENGTH, and TOTAL SQL functions

Users can now apply the ABS, LENGTH, and TOTAL SQL aggregate functions to association aggregates (e.g., \Team.players.total\). This extends the existing aggregate capabilities (such as count, average, min, and max) to include these additional functions, allowing for more flexible data analysis on associated records.

GRDB/QueryInterface/Request/Association · high confidence

Extracted GRDBCustom project for custom SQLite builds

The GRDBCustom.xcodeproj has been extracted from the main project to support building GRDB with a custom SQLite library (libsqlitecustom). This new project structure includes the necessary build configurations, bridging headers, and module maps to integrate the custom SQLite source, allowing users to customize the underlying database engine while maintaining the GRDB framework.

GRDBCustom.xcodeproj · high confidence

Foundation types now support direct database conversion

GRDB now supports storing and loading several Foundation types directly in the database without manual conversion. URL, UUID, and Date now adopt DatabaseValueConvertible, allowing them to be stored as text or blobs. Data and Decimal also adopt DatabaseValueConvertible and StatementColumnConvertible, enabling efficient storage of binary data and precise decimal numbers. Additionally, a new DatabaseDateComponents type provides structured handling of date and time components with specific formatting options.

GRDB/Core/Support/Foundation · high confidence

Introduce CommonTableExpression and refactor request architecture

Users can now define and use Common Table Expressions (CTEs) via the new CommonTableExpression struct, supporting creation from requests, SQL strings, and SQL literals. This change is part of a broader architectural refactor of the QueryInterfaceRequest system, which consolidates request protocols (such as SelectionRequest and FetchRequest) and reorganizes the internal SQL generation logic to support more complex query patterns like CTE associations and recursive queries.

GRDB/QueryInterface/Request · high confidence

Introduction of FTS3, FTS4, and FTS5 full-text search support

This update introduces comprehensive full-text search capabilities for SQLite virtual tables. Users can now create and query FTS3, FTS4, and FTS5 tables using the new \FTS3\, \FTS4\, and \FTS5\ module types, along with their respective table definition classes (\FTS3TableDefinition\, \FTS4TableDefinition\, \FTS5TableDefinition\). The library provides dedicated pattern types (\FTS3Pattern\, \FTS5Pattern\) for constructing safe search queries from user input, supporting features like prefix matching and phrase searches. Additionally, FTS5 supports custom tokenizers via the \FTS5CustomTokenizer\ protocol, allowing for advanced text processing, while FTS4 includes support for external content table synchronization.

GRDB/FTS · high confidence

Native Codable support for database values

The StandardLibrary now provides default implementations of \DatabaseValueConvertible\ for any type conforming to \Codable\. This allows Swift \Codable\ structs and enums to be stored directly in the database without manual mapping; simple scalar values are stored as native SQLite types, while complex types (arrays, dictionaries, nested objects) are automatically serialized to JSON strings. Additionally, \RawRepresentable\ types with a database-compatible raw value now automatically adopt \DatabaseValueConvertible\, and \Optional\ types are treated as first-class database values that correctly handle nulls.

GRDB/Core/Support/StandardLibrary · high confidence

New GRDB Tour playground added to Documentation

A new 'Tour' playground has been added to the Documentation folder, providing a quick-start guide for the GRDB library. The example demonstrates core database operations, including configuring a database queue with SQL tracing, executing raw SQL for table creation and data insertion, and fetching results. It also illustrates the modern record-based API by defining a \Place\ struct that conforms to \FetchableRecord\, \TableRecord\, and \MutablePersistableRecord\, showing how to insert, update, and query records using both SQL and the query interface. The playground configuration enables building under the active Xcode scheme.

Documentation/Playgrounds/Tour.playground · high confidence

New GRDB demo app for player management

The GRDBDemo application has been replaced with a new SwiftUI-based demo that showcases GRDB database integration. It features a \PlayerListModel\ that observes database changes to keep the UI in sync, allowing users to create, edit, and delete players. The app includes a persistent SQLite database stored in the Application Support directory, with support for sorting players by name or score, and provides utilities for refreshing data and testing via SwiftUI previews.

Documentation/DemoApps/GRDBDemo/GRDBDemo · high confidence

New GRDB playground example for database setup and basic operations

A new playground named MyPlayground has been added to the Documentation folder, providing a concrete example of how to initialize a GRDB database with SQL tracing, define a Codable record model, and perform basic create, read, and count operations. The playground is configured to build under Xcode 12 by setting the active scheme, allowing users to run and inspect the code directly in the IDE.

Documentation/Playgrounds/MyPlayground.playground · high confidence

New QueryInterface APIs for Full-Text Search, Associations, and SQL Interpolation

This update introduces new capabilities for the GRDB QueryInterface. Users can now perform full-text searches on FTS3 and FTS5 tables using the new \matching(\:)\ method on \TableRequest\ and \TableRecord\. Defining associations between tables is now more flexible with the introduction of the \ForeignKey\ struct, allowing explicit foreign key specification for \belongsTo\, \hasMany\, and \hasOne\ relationships when schema inference is ambiguous. Additionally, SQL string interpolation is significantly enhanced with new \appendInterpolation\ overloads for \TableRecord\, \Table\, \SQLSelectable\, \SQLOrderingTerm\, and \CodingKey\, enabling safer and more concise SQL construction (e.g., \SELECT \ FROM \\(Player.self)\).

GRDB/QueryInterface · high confidence

New Swift APIs for SQLite JSON operations

This release introduces a dedicated JSON support layer in GRDB, adding the \JSONColumn\ type and the \SQLJSONExpressible\ protocol to enable native access to JSON subcomponents via the \-\>\ and \-\>\>\ SQL operators. It also exposes a comprehensive suite of SQLite JSON functions (such as \jsonExtract\, \jsonInsert\, \jsonReplace\, and \jsonArray\) as static methods on \Database\, allowing users to build, query, and manipulate JSON data directly within their Swift queries.

GRDB/JSON · high confidence

New database association schema diagrams

Added new SVG illustrations in the Documentation/Images/Associations2 directory to visualize database relationship schemas. These diagrams cover ambiguous foreign keys, belongs-to, has-many, has-many-through, and has-one associations, providing clearer visual references for understanding entity relationships.

Documentation/Images · high confidence

New dump formats for debugging and data export

The GRDB dump API now includes several new output formats accessible via \db.dumpRequest\: \DebugDumpFormat\ (\.debug()\) for human-readable debugging with configurable headers and separators, \JSONDumpFormat\ (\.json()\) for exporting rows as JSON arrays with a customizable \JSONEncoder\, \LineDumpFormat\ (\.line()\) for key-value style output, \ListDumpFormat\ (\.list()\) for simple pipe-separated rows, and \QuoteDumpFormat\ (\.quote()\) for generating SQL literal strings. All formats are \Sendable\ and support options like headers, separators, and null-value representation.

GRDB/Dump/DumpFormats · high confidence

New experimental database dumping utilities

Added a new \GRDB/Dump\ module providing experimental methods to print database content and schema for debugging and testing. \Database\ and \DatabaseReader\ now expose \dumpSQL\, \dumpRequest\, \dumpTables\, \dumpContent\, and \dumpSchema\ to output data in various formats (debug, JSON, line, list, quote). The dump functionality explicitly excludes internal SQLite/GRDB schema objects and SQLite shadow tables (starting with SQLite 3.37+), and \dumpTables\ supports a \stableOrder\ option to ensure consistent row ordering for views, making output suitable for testing.

GRDB/Dump · high confidence

New playground demonstrating TransactionObserver usage

Added a new playground example that demonstrates how to use the \TransactionObserver\ protocol to track database changes. The example creates an in-memory database, defines migrations for 'person' and 'pet' tables (including a \belongsTo\ relationship), and registers an observer to print changed table names on commit or rollback. It also includes a playground configuration enabling builds under Xcode 12.

Documentation/Playgrounds/TransactionObserver.playground · high confidence

New utility infrastructure for concurrency, string handling, and data structures

This update introduces a suite of internal utility types to the GRDB/Utils module to support modern concurrency and data management. It adds a custom \Pool\ for managing database connections with both synchronous and asynchronous access, and replaces previous locking mechanisms with \Mutex\ and \ReadWriteLock\ wrappers for safer state management. To support Swift concurrency, it includes \OnDemandFuture\ and \ReceiveValuesOn\ publishers for precise Combine scheduling, and \CaseInsensitiveIdentifier\ for robust database identifier handling. Additionally, it provides \OrderedDictionary\ for key-ordered collections, \Refinable\ for immutable updates, and \Inflections\ for string pluralization and singularization.

GRDB/Utils · high confidence

Records now conform to Swift's standard Encodable and Decodable protocols

GRDB records can now be encoded to and decoded from database rows using the standard Swift \Encodable\ and \Decodable\ protocols. This change introduces \EncodableRecord\ and \FetchableRecord\ protocols that provide default implementations for \encode(to:)\ and \init(row:)\, allowing developers to leverage Swift's built-in coding mechanisms for persistence. The implementation supports customizing column encoding and decoding strategies (for Data, Date, UUID, and JSON) and allows passing custom \userInfo\ to the encoder and decoder, simplifying the integration of standard Swift types with the database.

GRDB/Record · high confidence

Support for CGFloat database conversion on non-Darwin platforms

Users can now store and retrieve CGFloat values in SQLite databases on non-Darwin platforms (such as Linux). A new extension implements the DatabaseValueConvertible protocol for CGFloat, allowing it to be seamlessly converted to and from REAL database values by leveraging the Foundation framework when CoreGraphics is unavailable.

GRDB/Core/Support/CoreGraphics · high confidence

Architecture

Refactored SQL generation into dedicated generators and context

The SQL generation logic for the Query Interface has been reorganized into specific generator components: SQLColumnGenerator, SQLIndexGenerator, SQLQueryGenerator, SQLTableGenerator, and SQLTableAlterationGenerator, all coordinated by a new SQLGenerationContext. This change introduces a structured approach to building SQL statements for table creation, alterations, and queries, while centralizing the management of database connections, argument sinks for SQL injection prevention, and table alias resolution.

GRDB/QueryInterface/SQLGeneration · high confidence

Xcode project reorganized with filesystem synchronization and new configuration files

The GRDB Xcode project has been updated to object version 70, enabling modern Xcode features like filesystem-synchronized groups. The project structure has been reorganized: the main source group is now a filesystem-synchronized root, and the test suite is split into a 'Crash' folder (containing specific crash tests for DatabasePool, Queue, Migration, Record, etc.) and a general 'Tests' folder. Supporting files have been moved to a 'Support' directory, and new .xcconfig files (GRDB.xcconfig, GRDBTests.xcconfig, GRDBDeploymentTarget.xcconfig) have been introduced to manage build settings. The public header phase now includes grdb\_config.h instead of fts3\_tokenizer.h, and the test target dependency has been updated to reference GRDBOSX.

GRDB.xcodeproj · high confidence

Behavioural changes

Custom SQLite build system restructured for Swift 6 and user customization

The GRDBCustomSQLite integration has been reorganized to support Swift 6.1 and simplified user configuration. The module has been renamed from GRDBCustomSQLite to GRDB, and deployment targets are now centralized in a dedicated xcconfig file (iOS 13+, macOS 10.15+, tvOS 13+, watchOS 7+). Users can now customize SQLite compilation flags via new USER example files (GRDBCustomSQLite-USER.h.example and GRDBCustomSQLite-USER.xcconfig.example) that preserve customizations across updates. A new grdb\_config.h header provides Swift-compatible wrappers for SQLite configuration functions like error logging and double-quoted string literal handling.

SQLiteCustom · high confidence

Extracted GRDBCustom workspace configuration

The GRDBCustom project has been extracted from the main GRDB workspace into its own independent workspace. This change creates a dedicated workspace structure for GRDBCustom, allowing it to be opened and built separately from the main GRDB project.

GRDBCustom.xcodeproj/project.xcworkspace · high confidence

GRDB 7.0.0 introduces breaking API changes and modernizes project structure

This update represents a major version jump to GRDB 7.0.0, introducing several breaking changes for users. The library no longer exposes the prepared statement via DatabaseCursor, and DatabaseRegionObservation now returns a cancellable object. Transaction handling has been updated to manage both commits and rollbacks, and the default transaction kind is now automatically managed, removing the need for explicit configuration. The API has been simplified by replacing selectID() with selectPrimaryKey(as:) and removing Record.copy(). Additionally, the library adds a privacy manifest file for App Store compliance, removes legacy build configuration files (GRDB.xcconfig, GRDB-Bridging.h, fts3\_tokenizer.h), and provides migration helpers in Fixits.swift to guide users through deprecated methods like concurrentRead.

GRDB · high confidence

GRDB Core Refactoring and Modernization

The GRDB/Core module has been significantly refactored to modernize the codebase and improve performance. This includes introducing a new \Configuration\ struct for centralized database settings, replacing the old \Cursor\ system with specialized \DatabaseCursor\ types (such as \RowCursor\ and \StatementCursor\), and enhancing the schema cache with \SchemaCache\ and \DatabaseSchemaID\ for better schema management. The update also brings improved error handling via a new \ResultCode\ system, adds support for database backups with \DatabaseBackupProgress\, and integrates \DatabaseCollation\ for custom string comparisons. These changes lay the groundwork for better concurrency support and more robust database interactions.

GRDB/Core · high confidence

GRDBDemo app updated for Xcode 26 and Swift 6.1

The GRDBDemo application project has been regenerated to support Xcode 26 (project file version 77) and requires a minimum Swift version of 6.1. This update ensures the demo app builds correctly with the latest toolchain and language standards.

Documentation/DemoApps/GRDBDemo/GRDBDemo.xcodeproj · high confidence

Project reorganization and Swift 6.1 upgrade

The project has been reorganized with support files moved to a dedicated Support directory, and the minimum Swift version has been bumped to 6.1. Deployment targets are now centralized in xcconfig files, requiring iOS 13+, macOS 10.15+, tvOS 13+, and watchOS 7+. The build configuration enables FTS5 and Snapshot features by default, and the module map now explicitly includes the grdb\_config.h header.

Support · high confidence

Redesigned schema definition API with new constraint builders and generated column support

The schema definition API has been refactored to use new dedicated types for defining database structures, including \ColumnDefinition\, \ForeignKeyDefinition\, and \IndexDefinition\. This change introduces support for generated columns (virtual and stored) and allows primary keys to be defined with an implicit NOT NULL constraint by default. Users can now also create virtual tables using the \VirtualTableModule\ protocol and configure table creation with new options such as \.strict\ and \.withoutRowID\. Additionally, table alterations now support renaming and dropping columns, and the API encourages using \SQL\ literals for safer, ergonomic SQL expression handling.

GRDB/QueryInterface/Schema · high confidence

Refactor ValueObservation reducers for Swift concurrency

The ValueObservation reducer system has been restructured to support Swift concurrency. The core ValueReducer protocol is no longer Sendable itself, but provides a Sendable Fetcher facet to allow database fetching from any queue, while thread safety is managed by ValueObservation. New reducer types have been introduced: Fetch for raw database fetches, Map for transforming observed values, RemoveDuplicates for filtering identical consecutive values, and Trace for handling observation events. These changes enable safer concurrent access and provide new tools for observing and transforming database values.

GRDB/ValueObservation/Reducers · high confidence

Refactored Query Interface SQL generation with new core types

The SQL generation layer for the Query Interface has been restructured around new foundational types: \Column\ and \ColumnExpression\ for representing table columns, \SQLExpression\ for building SQL expressions, \SQLRelation\ for defining query structures (including joins and filters), and \DatabasePromise\ for lazy resolution of schema-dependent values. This change introduces support for detached columns, qualified selections, and more robust association handling via \\_SQLAssociation\ and \SQLForeignKeyRequest\, while ensuring key types like \SQLExpression\ and \SQLRelation\ conform to \Sendable\ for thread safety.

GRDB/QueryInterface/SQL · high confidence

Refactored ValueObservation observers for improved concurrency and stability

The internal observers for ValueObservation (ValueConcurrentObserver and ValueWriteOnlyObserver) have been rewritten to improve thread safety and performance. The concurrent observer now performs fetches on a dedicated dispatch queue to avoid blocking the database writer, while ensuring that notifications are ordered to match transaction commits. The implementation also addresses specific concurrency issues, such as preventing notifications after cancellation and handling WAL snapshot failures gracefully by falling back to plain reads.

GRDB/ValueObservation/Observers · medium confidence

Refined foreign key enforcement and migration merging in DatabaseMigrator

The migration system now supports merging previous migrations via a new \merging\ parameter in \registerMigration\, allowing multiple migration identifiers to be recorded as a single logical step. Foreign key handling has been made more precise: the \disablingDeferredForeignKeyChecks\ method now explicitly disables foreign key checks for newly registered migrations, and the \ForeignKeyChecks\ enum distinguishes between deferred, immediate, and disabled states. Migrations run with deferred checks now explicitly verify integrity via \checkForeignKeys\ before committing, ensuring that schema alterations do not violate constraints even when foreign keys are temporarily disabled during the transaction.

GRDB/Migration · high confidence

Rename CSQLite to GRDBSQLite and add SQLCipher support

The library has been renamed from CSQLite to GRDBSQLite, requiring users to update their import statements and module references. Additionally, a new GRDBSQLCipher target has been introduced to support encrypted databases via SQLCipher, providing configuration wrappers for error logging and double-quoted string literal handling that bridge Swift and the underlying C APIs.

Sources · high confidence

ValueObservation refactoring and SharedValueObservation introduction

The ValueObservation system has been refactored to support region recording by default, allowing observations to track varying database regions inferred from fetch results. A new SharedValueObservation type is introduced, enabling multiple subscriptions to share a single underlying database observation, with configurable extent (observationLifetime or whileObserved) to control when the database observation stops. The cancellation model is updated with a new DatabaseCancellable protocol and AnyDatabaseCancellable implementation. Scheduling is now handled via a ValueObservationScheduler protocol with built-in schedulers for async queues, main actor, and immediate notification. The API requires Swift 5.6+ for concurrency support and has been updated to use modern Swift patterns including Sendable conformance and preconcurrency markers.

GRDB/ValueObservation · high confidence

Workspace reorganized to include new demo apps and playgrounds

The GRDB workspace has been restructured to integrate the new GRDBDemo app and GRDBProfiling project, while also adding references to several playgrounds (Tour, TransactionObserver, Associations, MyPlayground) and documentation files. This change updates the development environment to reflect the latest project organization and demo applications.

GRDB.xcworkspace · high confidence

Xcode 26 upgrade and test configuration updates

The project scheme has been upgraded to Xcode 26 (LastUpgradeVersion 2600) and renamed from SQLite to GRDB. Test execution is now parallelizable, and code coverage is enabled for tests. Additionally, the scheme no longer builds the library for running during tests, and the launch action now uses the internal debug service extension.

GRDB.xcodeproj/xcshareddata · high confidence

Xcode scheme configured for parallel builds and testing

The project scheme for GRDBCustom has been updated to enable parallelization for both the build and test actions. This allows the GRDB framework and its associated tests to be built and executed concurrently, which can reduce build times and improve developer feedback loops.

GRDBCustom.xcodeproj/xcshareddata · high confidence

Test coverage

Added CocoaPods integration tests for framework and static library builds; Added GRDBPerformance test suite for benchmarking database operations; Added GRDBProfiling performance test project; Added SPM integration test for SQLite version detection and string handling; Added SPM integration test project for GRDB; Added SQLCipher 3 test suite; Added SQLCipher 4 test project; Added SQLCipher3 test bundle configuration; Added Swift 6 migration test app with concurrency mode configurations; Added Xcode scheme for GRDBProfiling test target; Added Xcode schemes for GRDB performance tests; Added Xcode test schemes for SQLCipher4 GRDB tests; Added crash tests for GRDB database operations; Added iOS and macOS SPM test apps; Added iOS dynamic framework test project; Added macOS performance profiling application; Added macOS test app for custom SQLite installation; Added manual install test app; Added performance test reporting infrastructure; Added test project for custom SQLite builds; Added test suite for GRDB cursor types and compilation checks; Added test suite for SQLCipher4 integration; Added test workspaces for CocoaPods integration; Added test workspaces for SQLCipher 3 and 4 integration; Added unit tests for database operations and player list model; Extract performance tests to a dedicated Xcode project.

Dependencies

GRDB.swift v7.11.1 requires Swift 6.1 and updates minimum platform versions

The CocoaPods podspec and Swift Package Manager manifest have been updated to require Swift 6.1, raising the minimum deployment targets to iOS 13, macOS 10.15, tvOS 13, and watchOS 7. The package now enables FTS5 and SQLite snapshot support by default, and the GRDBSQLite system library is explicitly exposed as a dependency for the main GRDB target.

(dependencies) · high confidence

Housekeeping

Added IDE workspace check configuration

The project now includes an IDEWorkspaceChecks.plist file to manage Xcode workspace settings, specifically tracking whether the 32-bit architecture warning has been computed. This ensures consistent workspace configuration across development environments.

GRDB.xcworkspace/xcshareddata · high confidence

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

How this codebase got here

Score

  • CAI 63 → 64 (+0.8)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 61 → 76 (+14.8)
  • Architecture 91 → 91 (+0.1)
  • Maturity 61 → 62 (+1.7)
  • Readiness 61 → 57 (-4.2)
  • Security 96 → 92 (-4.0)
  • Domain Modelling 70 → 70 (+0.0)
  • Performance 72 → 85 (+13.1)

Resolved (24)

  • Duplicated block (10 lines × 2) (GRDB/FTS/FTS3.swift)
  • Duplicated block (10 lines × 4) (GRDB/Dump/DumpFormats/DebugDumpFormat.swift)
  • Duplicated block (11 lines × 2) (GRDB/Record/FetchableRecord+Decodable.swift)
  • Duplicated block (11 lines × 2) (GRDB/ValueObservation/Observers/ValueConcurrentObserver.swift)
  • Duplicated block (14 lines × 2) (GRDB/QueryInterface/SQLGeneration/SQLColumnGenerator.swift)
  • Duplicated block (15 lines × 2) (GRDB/Core/DatabaseFunction.swift)
  • Duplicated block (18 lines × 2) (GRDB/ValueObservation/Observers/ValueConcurrentObserver.swift)
  • Duplicated block (20–22 lines × 2) (GRDB/QueryInterface/SQLGeneration/SQLTableGenerator.swift)
  • Duplicated block (23 lines × 2) (GRDB/QueryInterface/SQLGeneration/SQLQueryGenerator.swift)
  • Duplicated block (24 lines × 2) (GRDB/Core/DatabaseSnapshotPool.swift)
  • Duplicated block (6 lines × 2) (GRDB/Core/TransactionObserver.swift)
  • Duplicated block (7 lines × 2) (GRDB/Core/DatabaseError.swift)
  • Duplicated block (7 lines × 2) (GRDB/FTS/FTS4.swift)
  • Duplicated block (7 lines × 2) (GRDB/QueryInterface/SQLGeneration/SQLTableGenerator.swift)
  • Duplicated block (7 lines × 2) (GRDB/ValueObservation/Observers/ValueConcurrentObserver.swift)
  • Duplicated block (7 lines × 3) (GRDB/QueryInterface/Request/Association/AssociationAggregate.swift)
  • Duplicated block (8 lines × 2) (GRDB/QueryInterface/SQLGeneration/SQLQueryGenerator.swift)
  • Duplicated block (8 lines × 2) (GRDB/ValueObservation/Observers/ValueConcurrentObserver.swift)
  • Duplicated block (9 lines × 2) (GRDB/Dump/DumpFormats/DebugDumpFormat.swift)
  • Edited copy of a member (24 corresponding lines) (GRDB/Core/Row.swift)
  • …and 4 more

New (167)

  • Duplicated block (10 lines × 2) (GRDB/FTS/FTS3.swift)
  • Duplicated block (10 lines × 4) (GRDB/Dump/DumpFormats/DebugDumpFormat.swift)
  • Duplicated block (11 lines × 2) (GRDB/Record/FetchableRecord+Decodable.swift)
  • Duplicated block (11 lines × 2) (GRDB/ValueObservation/Observers/ValueConcurrentObserver.swift)
  • Duplicated block (14 lines × 2) (GRDB/QueryInterface/SQLGeneration/SQLColumnGenerator.swift)
  • Duplicated block (15–16 lines × 3) (GRDB/ValueObservation/Observers/ValueConcurrentObserver.swift)
  • Duplicated block (17 lines × 2) (GRDB/Core/DatabaseFunction.swift)
  • Duplicated block (20–22 lines × 2) (GRDB/QueryInterface/SQLGeneration/SQLTableGenerator.swift)
  • Duplicated block (23 lines × 2) (GRDB/QueryInterface/SQLGeneration/SQLQueryGenerator.swift)
  • Duplicated block (24 lines × 2) (GRDB/Core/DatabaseSnapshotPool.swift)
  • Duplicated block (7 lines × 2) (GRDB/FTS/FTS4.swift)
  • Duplicated block (7 lines × 2) (GRDB/ValueObservation/Observers/ValueConcurrentObserver.swift)
  • Duplicated block (8 lines × 2) (GRDB/QueryInterface/SQLGeneration/SQLQueryGenerator.swift)
  • Duplicated block (8 lines × 2) (GRDB/ValueObservation/Observers/ValueConcurrentObserver.swift)
  • Duplicated block (8 lines × 3) (GRDB/QueryInterface/Request/Association/AssociationAggregate.swift)
  • Duplicated block (9 lines × 2) (GRDB/Core/TransactionObserver.swift)
  • Duplicated block (9 lines × 2) (GRDB/Dump/DumpFormats/DebugDumpFormat.swift)
  • Duplicated block (9 lines × 2) (GRDB/QueryInterface/SQLGeneration/SQLTableGenerator.swift)
  • Edited copies of one member (3 members, 10+ corresponding lines) (GRDB/Core/Row.swift)
  • Edited copies of one member (3 members, 11+ corresponding lines) (GRDB/Core/StatementColumnConvertible.swift)
  • …and 147 more

Changes since last survey

  • 18 commits — 17 feature/other, 1 fixes

By area

  • GRDB/Core — 5 commits
  • Tests/GRDBTests — 5 commits
  • (repo) — 4 commits
  • (root) — 1 commit
  • Documentation/DemoApps — 1 commit
  • GRDB/QueryInterface — 1 commit
  • GRDB/ValueObservation — 1 commit

Notable commits

  • fix: Fix SharedValueObservation
  • change: Failing test for SQLRequest on a recompiled statement
  • change: Failing test for the Row column cache of a recompiled statement
  • change: Failing test for the column cache of a recompiled statement
  • change: Failing tests: SharedValueObservation deadlocks when a client is cancelled during a notification
  • change: Fix more typos in public documentation
  • change: Fix more typos in public documentation
  • change: Fix typos in code samples
  • change: Fix typos in public documentation
  • change: Fix typos in the demo app
  • change: Invalidate Statement column cache after recompilation
  • change: Merge branch 'development'
  • change: Merge pull request #1889 from builtbysharath/open-error-message
  • change: Merge pull request #1893 from groue/dev/support-statement-recompilation
  • change: Merge pull request #1894 from groue/dev/issue-1888
  • change: More failing SharedValueObservation tests
  • change: Row fetched from a statement do not cache statement column in order to support statement recompilation
  • change: v7.12.0

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

Survey your own repository

groue/GRDB.swift 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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 98c58f4eef16b30e2ac695076938300cda49fa79 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.