SQLite.swift

This fork is a port of SQLite.swift to Swift 3.0 2016-04-12-a + Swift Package Manager (SPM).

FTS4 module does not compile because of .m files which SPM doesn't support yet and is commented out.

Tests work on OS X, but don't work on Linux because 'swift test' doesn't accept -X flag.

How to build on Linux:

Install Swift 3.0 2016-04-12-a, for example by using swiftenv.

Build libdispatch:

git clone -b experimental/foundation https://github.com/apple/swift-corelibs-libdispatch.git
cd swift-corelibs-libdispatch
git submodule init
git submodule update
sh ./autogen.sh
./configure --with-swift-toolchain=<path-to-swift>/usr --prefix=<path-to-swift>/usr
make
make install

Replace <path-to-swift> with ~/.swiftenv/versions/DEVELOPMENT-SNAPSHOT-2016-04-12-a

Build the library:

swift build -Xcc -fblocks -Xlinker -ldispatch

How to build on OS X:

Install Swift 3.0 2016-04-12-a, set it as active toolchain in X-code. swift --version should show Apple Swift version 3.0-dev

Run swift build to build the library or swift test to run the tests.

To generate Xcode project, run:

swift build -X

Open the project and add Sources/CSQLite to Build Settings - Import Paths.

How to use the library in other projects

Add the following line to dependencies:

.Package(url: "https://github.com/zmeyc/SQLite.swift.git", majorVersion: 0)

Original README:

A type-safe, Swift-language layer over SQLite3.

SQLite.swift provides compile-time confidence in SQL statement syntax and intent.

Features

A pure-Swift interface
A type-safe, optional-aware SQL expression builder
A flexible, chainable, lazy-executing query layer
Automatically-typed data access
A lightweight, uncomplicated query and parameter binding interface
Developer-friendly error handling and debugging
Full-text search support
Well-documented
Extensively tested
Companion project has SQLCipher support
Active support at StackOverflow, and Gitter Chat Room (experimental)

Usage

import SQLite

let db = try Connection("path/to/db.sqlite3")

let users = Table("users")
let id = Expression<Int64>("id")
let name = Expression<String?>("name")
let email = Expression<String>("email")

try db.run(users.create { t in
    t.column(id, primaryKey: true)
    t.column(name)
    t.column(email, unique: true)
})
// CREATE TABLE "users" (
//     "id" INTEGER PRIMARY KEY NOT NULL,
//     "name" TEXT,
//     "email" TEXT NOT NULL UNIQUE
// )

let insert = users.insert(name <- "Alice", email <- "alice@mac.com")
let rowid = try db.run(insert)
// INSERT INTO "users" ("name", "email") VALUES ('Alice', 'alice@mac.com')

for user in try db.prepare(users) {
    print("id: \(user[id]), name: \(user[name]), email: \(user[email])")
    // id: 1, name: Optional("Alice"), email: alice@mac.com
}
// SELECT * FROM "users"

let alice = users.filter(id == rowid)

try db.run(alice.update(email <- email.replace("mac.com", with: "me.com")))
// UPDATE "users" SET "email" = replace("email", 'mac.com', 'me.com')
// WHERE ("id" = 1)

try db.run(alice.delete())
// DELETE FROM "users" WHERE ("id" = 1)

db.scalar(users.count) // 0
// SELECT count(*) FROM "users"

SQLite.swift also works as a lightweight, Swift-friendly wrapper over the C API.

let stmt = try db.prepare("INSERT INTO users (email) VALUES (?)")
for email in ["betty@icloud.com", "cathy@icloud.com"] {
    try stmt.run(email)
}

db.totalChanges    // 3
db.changes         // 1
db.lastInsertRowid // 3

for row in try db.prepare("SELECT id, email FROM users") {
    print("id: \(row[0]), email: \(row[1])")
    // id: Optional(2), email: Optional("betty@icloud.com")
    // id: Optional(3), email: Optional("cathy@icloud.com")
}

db.scalar("SELECT count(*) FROM users") // 2

Read the documentation or explore more, interactively, from the Xcode project’s playground.

For a more comprehensive example, see this article and the companion repository.

Installation

Note: SQLite.swift requires Swift 2 (and Xcode 7) or greater.

The following instructions apply to targets that support embedded Swift frameworks. To use SQLite.swift in iOS 7 or an OS X command line tool, please read the Frameworkless Targets section of the documentation.

Carthage

Carthage is a simple, decentralized dependency manager for Cocoa. To install SQLite.swift with Carthage:

Make sure Carthage is installed.

Update your Cartfile to include the following:

github "stephencelis/SQLite.swift" ~> 0.10.1

Run carthage update and add the appropriate framework.

CocoaPods

CocoaPods is a dependency manager for Cocoa projects. To install SQLite.swift with CocoaPods:

Make sure the latest CocoaPods beta is [installed]CocoaPods Installation. (SQLite.swift requires version 1.0.0.beta.6 or greater.)

# Using the default Ruby install will require you to use sudo when
# installing and updating gems.
sudo gem install --pre cocoapods

Update your Podfile to include the following:

use_frameworks!

pod 'SQLite.swift', '~> 0.10.1'

Run pod install.

Manual

To install SQLite.swift as an Xcode sub-project:

Drag the SQLite.xcodeproj file into your own project. (Submodule, clone, or download the project first.)
In your target’s General tab, click the + button under Linked Frameworks and Libraries.
Select the appropriate SQLite.framework for your platform.
Add.

Communication

See the planning document for a roadmap and existing feature requests.

Read the contributing guidelines. The TL;DR (but please; R):

Need help or have a general question? Ask on Stack Overflow (tag sqlite.swift).
Found a bug or have a feature request? Open an issue.
Want to contribute? Submit a pull request.