L'accès à une Base de données SQLite en Swift

Alors vous devriez probablement utiliser l'un des nombreux SQLite wrappers (je préfère FMDB, moi-même), si vous avez voulu savoir comment appeler la bibliothèque SQLite vous-même, vous:

1. Configurer votre Swift projet pour gérer SQLite C appels. Si l'utilisation de Xcode 9, vous pouvez tout simplement faire:

   import SQLite3

   Dans les précédentes versions de Xcode, vous pouvez:

   • Créer de transition fichier d'en-tête pour le projet. Voir la l'Importation d'Objective-C dans Swift section de la L'utilisation de Swift avec Cocoa et Objective-C. Cette passerelle en-tête doit importer sqlite3.h:

     #import <sqlite3.h>

   • Ajouter le libsqlite3.tbd (ou même pour les anciennes versions, la libsqlite3.dylib) à votre projet:

     

2. Créer ou ouvrir une base de données.

   let fileURL = try! FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
       .appendingPathComponent("test.sqlite")
   
   //open database
   
   var db: OpaquePointer?
   if sqlite3_open(fileURL.path, &db) != SQLITE_OK {
       print("error opening database")
   }

3. Utilisation sqlite3_exec pour exécuter SQL (par exemple create table).

   if sqlite3_exec(db, "create table if not exists test (id integer primary key autoincrement, name text)", nil, nil, nil) != SQLITE_OK {
       let errmsg = String(cString: sqlite3_errmsg(db)!)
       print("error creating table: \(errmsg)")
   }

4. Utilisation sqlite3_prepare_v2 préparer SQL avec ? espace réservé à laquelle nous allons lier valeur.

   var statement: OpaquePointer?
   
   if sqlite3_prepare_v2(db, "insert into test (name) values (?)", -1, &statement, nil) != SQLITE_OK {
       let errmsg = String(cString: sqlite3_errmsg(db)!)
       print("error preparing insert: \(errmsg)")
   }
   
   if sqlite3_bind_text(statement, 1, "foo", -1, SQLITE_TRANSIENT) != SQLITE_OK {
       let errmsg = String(cString: sqlite3_errmsg(db)!)
       print("failure binding foo: \(errmsg)")
   }
   
   if sqlite3_step(statement) != SQLITE_DONE {
       let errmsg = String(cString: sqlite3_errmsg(db)!)
       print("failure inserting foo: \(errmsg)")
   }

   Note, qui utilise le SQLITE_TRANSIENT constante qui peut être mis en œuvre comme suit:

   internal let SQLITE_STATIC = unsafeBitCast(0, to: sqlite3_destructor_type.self)
   internal let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self)

5. Réinitialiser SQL pour insérer une autre valeur. Dans cet exemple, je vais insérer un NULL valeur:

   if sqlite3_reset(statement) != SQLITE_OK {
       let errmsg = String(cString: sqlite3_errmsg(db)!)
       print("error resetting prepared statement: \(errmsg)")
   }
   
   if sqlite3_bind_null(statement, 1) != SQLITE_OK {
       let errmsg = String(cString: sqlite3_errmsg(db)!)
       print("failure binding null: \(errmsg)")
   }
   
   if sqlite3_step(statement) != SQLITE_DONE {
       let errmsg = String(cString: sqlite3_errmsg(db)!)
       print("failure inserting null: \(errmsg)")
   }

6. Finaliser l'instruction préparée pour récupérer de la mémoire associés à ce communiqué:

   if sqlite3_finalize(statement) != SQLITE_OK {
       let errmsg = String(cString: sqlite3_errmsg(db)!)
       print("error finalizing prepared statement: \(errmsg)")
   }
   
   statement = nil

7. Préparer la nouvelle instruction pour la sélection des valeurs du tableau et une boucle dans l'extraction de valeurs:

   if sqlite3_prepare_v2(db, "select id, name from test", -1, &statement, nil) != SQLITE_OK {
       let errmsg = String(cString: sqlite3_errmsg(db)!)
       print("error preparing select: \(errmsg)")
   }
   
   while sqlite3_step(statement) == SQLITE_ROW {
       let id = sqlite3_column_int64(statement, 0)
       print("id = \(id); ", terminator: "")
   
       if let cString = sqlite3_column_text(statement, 1) {
           let name = String(cString: cString)
           print("name = \(name)")
       } else {
           print("name not found")
       }
   }
   
   if sqlite3_finalize(statement) != SQLITE_OK {
       let errmsg = String(cString: sqlite3_errmsg(db)!)
       print("error finalizing prepared statement: \(errmsg)")
   }
   
   statement = nil

8. À proximité de la base de données:

   if sqlite3_close(db) != SQLITE_OK {
       print("error closing database")
   }
   
   db = nil

Pour Swift 2, voir de la révision précédente date de cette réponse.

OriginalL'auteur Rob

Je recherchais une certaine façon d'interagir avec SQLite de la même façon, j'avais l'habitude de le faire auparavant en Objective-C. Certes, à cause de C de compatibilité, j'ai simplement utilisé le droit de l'API C.

Que pas de wrapper existe actuellement pour SQLite rapide et la SQLiteDB code mentionné ci-dessus va un peu plus haut niveau et n'assume certaines utilisations, j'ai décidé de créer un wrapper et être un peu plus familier avec Swift dans le processus. Vous pouvez le trouver ici: https://github.com/chrismsimpson/SwiftSQLite.

var db = SQLiteDatabase();
db.open("/path/to/database.sqlite");

var statement = SQLiteStatement(database: db);

if ( statement.prepare("SELECT * FROM tableName WHERE Id = ?") != .Ok )
{
    /* handle error */
}

statement.bindInt(1, value: 123);

if ( statement.step() == .Row )
{
    /* do something with statement */
    var id:Int = statement.getIntAt(0)
    var stringValue:String? = statement.getStringAt(1)
    var boolValue:Bool = statement.getBoolAt(2)
    var dateValue:NSDate? = statement.getDateAt(3)
}

statement.finalizeStatement(); /* not called finalize() due to destructor/language keyword */

OriginalL'auteur Chris Simpson

Encore un autre SQLite wrapper pour Swift 2 et Swift 3: http://github.com/groue/GRDB.swift

Caractéristiques:

• Une API qui sera familier pour les utilisateurs de ccgus/fmdb

• Un bas niveau de l'API SQLite, qui tire parti de la Swift de la bibliothèque standard

• Une jolie Swift interface de requête de SQL-allergique développeurs

• De soutien pour l'SQLite WAL mode, et de la base de données simultanées d'accès pour plus de performance

• Un Record de classe qui encapsule des ensembles de résultats, mange tes requêtes SQL personnalisées pour le petit déjeuner, et fournit de base opérations CRUD

• Swift type de liberté: choisir la bonne Swift type qui s'adapte à vos données. Utilisation Int64 cas de besoin, ou s'en tenir à la pratique de l'Int. De stocker et de lire NSDate ou NSDateComponents. Déclarer Swift enums pour les types de données discrètes. Définir votre propre base de données-type convertible.

• Migrations De Base De Données

• Vitesse: https://github.com/groue/GRDB.swift/wiki/Performance

OriginalL'auteur Gwendal Roué

J'ai écrit un SQLite3 wrapper bibliothèque écrite en Swift.

C'est en fait un très haut niveau wrapper avec de très simple API, mais de toute façon, il a un faible niveau C inter-op de code, et je poste ici un (simplifié) partie montre la C inter-op.

    struct C
{
static let  NULL        =   COpaquePointer.null()
}
func open(filename:String, flags:OpenFlag)
{
let name2   =   filename.cStringUsingEncoding(NSUTF8StringEncoding)!
let r       =   sqlite3_open_v2(name2, &_rawptr, flags.value, UnsafePointer<Int8>.null())
checkNoErrorWith(resultCode: r)
}
func close()
{   
let r   =   sqlite3_close(_rawptr)
checkNoErrorWith(resultCode: r)
_rawptr =   C.NULL
}
func prepare(SQL:String) -> (statements:[Core.Statement], tail:String)
{
func once(zSql:UnsafePointer<Int8>, len:Int32, inout zTail:UnsafePointer<Int8>) -> Core.Statement?
{
var pStmt   =   C.NULL
let r       =   sqlite3_prepare_v2(_rawptr, zSql, len, &pStmt, &zTail)
checkNoErrorWith(resultCode: r)
if pStmt == C.NULL
{
return  nil
}
return  Core.Statement(database: self, pointerToRawCStatementObject: pStmt)
}
var stmts:[Core.Statement]  =   []
let sql2    =   SQL as NSString
var zSql    =   UnsafePointer<Int8>(sql2.UTF8String)
var zTail   =   UnsafePointer<Int8>.null()
var len1    =   sql2.lengthOfBytesUsingEncoding(NSUTF8StringEncoding);
var maxlen2 =   Int32(len1)+1
while let one = once(zSql, maxlen2, &zTail)
{
stmts.append(one)
zSql    =   zTail
}
let rest1   =   String.fromCString(zTail)
let rest2   =   rest1 == nil ? "" : rest1!
return  (stmts, rest2)
}
func step() -> Bool
{   
let rc1 =   sqlite3_step(_rawptr)
switch rc1
{   
case SQLITE_ROW:
return  true
case SQLITE_DONE:
return  false
default:
database.checkNoErrorWith(resultCode: rc1)
}
}
func columnText(at index:Int32) -> String
{
let bc  =   sqlite3_column_bytes(_rawptr, Int32(index))
let cs  =   sqlite3_column_text(_rawptr, Int32(index))
let s1  =   bc == 0 ? "" : String.fromCString(UnsafePointer<CChar>(cs))!
return  s1
}
func finalize()
{
let r   =   sqlite3_finalize(_rawptr)
database.checkNoErrorWith(resultCode: r)
_rawptr =   C.NULL
}

Si vous voulez un code source complet de ce faible niveau de wrapper, voir ces fichiers.

• https://github.com/Eonil/SQLite3/blob/master/Swift/Sources/Core.Statement.swift
• https://github.com/Eonil/SQLite3/blob/master/Swift/Sources/Core.Database.swift

OriginalL'auteur Eonil

Parfois, un Swift version de la "SQLite en 5 minutes ou moins" approche indiqué sur sqlite.org est suffisant.
Le "5 minutes ou moins" approche utilise sqlite3_exec() qui est une commodité wrapper pour sqlite3_prepare(), sqlite3_step(), sqlite3_column(), et sqlite3_finalize().

Swift 2.2 pouvez appuyer directement les sqlite3_exec() callback pointeur de fonction, soit un global, la non-occurrence de procédure func ou un non-capture littérale fermeture {}.

Lisible typealias

typealias sqlite3 = COpaquePointer
typealias CCharHandle = UnsafeMutablePointer<UnsafeMutablePointer<CChar>>
typealias CCharPointer = UnsafeMutablePointer<CChar>
typealias CVoidPointer = UnsafeMutablePointer<Void>

Rappel Approche

func callback(
resultVoidPointer: CVoidPointer, //void *NotUsed 
columnCount: CInt,               //int argc
values: CCharHandle,             //char **argv     
columns: CCharHandle             //char **azColName
) -> CInt {
for  i in 0 ..< Int(columnCount) {
guard let value = String.fromCString(values[i]) 
else { continue }
guard let column = String.fromCString(columns[i]) 
else { continue }
print("\(column) = \(value)")
}
return 0 //status ok
}
func sqlQueryCallbackBasic(argc: Int, argv: [String]) -> Int {
var db: sqlite3 = nil 
var zErrMsg:CCharPointer = nil
var rc: Int32 = 0 //result code
if argc != 3 {
print(String(format: "ERROR: Usage: %s DATABASE SQL-STATEMENT", argv[0]))
return 1
}
rc = sqlite3_open(argv[1], &db)
if  rc != 0 {
print("ERROR: sqlite3_open " + String.fromCString(sqlite3_errmsg(db))! ?? "" )
sqlite3_close(db)
return 1
}
rc = sqlite3_exec(db, argv[2], callback, nil, &zErrMsg)
if rc != SQLITE_OK {
print("ERROR: sqlite3_exec " + String.fromCString(zErrMsg)! ?? "")
sqlite3_free(zErrMsg)
}
sqlite3_close(db)
return 0
}

Fermeture Approche

func sqlQueryClosureBasic(argc argc: Int, argv: [String]) -> Int {
var db: sqlite3 = nil 
var zErrMsg:CCharPointer = nil
var rc: Int32 = 0
if argc != 3 {
print(String(format: "ERROR: Usage: %s DATABASE SQL-STATEMENT", argv[0]))
return 1
}
rc = sqlite3_open(argv[1], &db)
if  rc != 0 {
print("ERROR: sqlite3_open " + String.fromCString(sqlite3_errmsg(db))! ?? "" )
sqlite3_close(db)
return 1
}
rc = sqlite3_exec(
db,      //database 
argv[2], //statement
{        //callback: non-capturing closure
resultVoidPointer, columnCount, values, columns in
for i in 0 ..< Int(columnCount) {
guard let value = String.fromCString(values[i]) 
else { continue }
guard let column = String.fromCString(columns[i]) 
else { continue }
print("\(column) = \(value)")
}
return 0
}, 
nil, 
&zErrMsg
)
if rc != SQLITE_OK {
let errorMsg = String.fromCString(zErrMsg)! ?? ""
print("ERROR: sqlite3_exec \(errorMsg)")
sqlite3_free(zErrMsg)
}
sqlite3_close(db)
return 0
}

De préparer un projet Xcode pour appeler une bibliothèque C comme SQLite, on a besoin de (1) ajouter un pont-d'en-Tête.h fichier de référence C-têtes comme #import "sqlite3.h", (2) ajouter des Transition en-Tête.h à Objective-C de Transition de l'en-Tête dans les paramètres du projet, et (3) d'ajouter libsqlite3.tbd à Lien Binaire Avec la Bibliothèque les paramètres de la cible.

La sqlite.org's "SQLite en 5 minutes ou moins" exemple est mis en œuvre dans un Swift Xcode7 projet ici.

OriginalL'auteur l --marc l

Vous pouvez utiliser cette bibliothèque dans Swift pour SQLite
https://github.com/pmurphyjam/SQLiteDemo

SQLiteDemo

SQLite de Démonstration de l'utilisation de Swift avec SQLDataAccess classe écrite en Swift

De les ajouter à Votre Projet

Vous avez seulement besoin de trois fichiers à ajouter à votre projet
* SQLDataAccess.swift
* DataConstants.swift
* Combler L'En-Tête.h
Transition-d'en-Tête doit être réglé dans votre Xcode du projet 'Objective-C de Transition de l'en-Tête' de la rubrique 'Swift Compilateur Général"

Exemples d'Utilisation des

Il suffit de suivre le code de la ViewController.swift pour voir comment écrire de simples SQL avec SQLDataAccess.swift
Vous devez d'abord ouvrir la Base de données SQLite votre affaire avec

```swift
let db = SQLDataAccess.shared
db.setDBName(name:"SQLite.db")
let opened = db.openConnection(copyFile:true)
```

Si openConnection réussi, maintenant vous pouvez faire une simple insertion dans la Table AppInfo

```swift
//Insert into Table AppInfo
let status = db.executeStatement("insert into AppInfo (name,value,descrip,date) values(?,?,?,?)",
”SQLiteDemo","1.0.2","unencrypted",Date())
if(status)
{
//Read Table AppInfo into an Array of Dictionaries
let results = db.getRecordsForQuery("select * from AppInfo ")
NSLog("Results = \(results)")
}
```

Voir comment simple qui a été!

Le premier terme dans la db.executeStatement est votre SQL as String, tous les termes qui suivent sont une variadic de la liste d'arguments de type Aucun, et vos paramètres dans un Tableau. Tous ces termes sont séparés par des virgules dans votre liste de SQL arguments. Vous pouvez saisir des Chaînes de caractères, Entiers, la Date, et les Blobs juste après la suite de la déclaration puisque toutes ces conditions sont considérées comme des paramètres pour la suite. Les variadic tableau d'arguments tout à fait commode pour saisir toutes vos suite en seulement une executeStatement ou getRecordsForQuery appel. Si vous n'avez pas tous les paramètres, de ne pas entrer quoi que ce soit après votre SQL.

Les résultats de tableau est un tableau de Dictionnaire est là que la " clé "est vos tables nom de la colonne, et la "valeur" est vos données obtenues à partir de SQLite. Vous pouvez facilement parcourir ce tableau avec une boucle for ou l'imprimer directement ou céder ces Dictionnaire des éléments de données personnalisées des Classes d'objets que vous utilisez, à votre avis, les Contrôleurs pour le modèle de consommation.

```swift
for dic in results as! [[String:AnyObject]] {
print(“result = \(dic)”)
}
```

SQLDataAccess permettra de stocker, de texte, double, float, blob, la Date, le type integer et long long entiers.
Pour les objets Blob, vous pouvez stocker binary, varbinary, blob.

Pour le Texte que vous pouvez stocker char, le caractère, clob, national variant de caractère, natif de caractère, nchar, nvarchar, varchar, variante, variant de caractère, texte.

Pour les Dates, vous pouvez stocker datetime, time, timestamp, date.

Pour les Entiers, vous pouvez stocker bigint, bits, boolean, boolean, int2, int8, entier, mediumint, smallint, tinyint, int.

Pour les Doubles, vous pouvez stocker virgule, double précision, float, numérique, real, double. Double a le plus de précision.

Vous pouvez même stocker les valeurs Null de type Null.

Dans ViewController.swift un exemple plus complexe est fait montrer comment insérer un Dictionnaire comme un "Blob". En outre SQLDataAccess
comprend natif Swift Date() de sorte que vous pouvez insérer ces objets avec la conversion, et il va les convertir en texte et de les stocker,
et lorsqu'elles sont récupérées à convertir de texte à ce Jour.

Bien sûr, la véritable puissance de SQLite est-il de la capacité de Transaction. Ici vous pouvez littéralement file d'attente jusqu'à 400 instructions SQL avec des paramètres
et insérez-les tous à la fois, ce qui est vraiment puissant puisqu'il est si rapide. ViewController.swift également vous montre un exemple de comment faire cela.
Tout ce que vous êtes vraiment en train de faire est de créer un Tableau de Dictionnaires appelé "sqlAndParams", dans ce Tableau de votre stockage de Dictionnaires avec deux clés
'SQL' pour la Chaîne de suite instruction ou de la requête, et 'PARAMS' qui est juste un Tableau d'objets natifs SQLite comprend pour cette requête.
Chaque "sqlParams" qui est un particulier Dictionnaire de la suite de la requête, plus les paramètres sont ensuite stockées dans le " sqlAndParams le Tableau.
Une fois que vous avez créé ce tableau, il vous suffit d'appeler.

```swift
let status = db.executeTransaction(sqlAndParams)
if(status)
{
//Read Table AppInfo into an Array of Dictionaries for the above Transactions
let results = db.getRecordsForQuery("select * from AppInfo ")
NSLog("Results = \(results)")
}
```

En outre, tous les executeStatement et getRecordsForQuery méthodes peut être fait avec une simple Chaîne de requête SQL et un Tableau pour les paramètres nécessaires par la requête.

```swift
let sql : String = "insert into AppInfo (name,value,descrip) values(?,?,?)"
let params : Array = ["SQLiteDemo","1.0.0","unencrypted"]
let status = db.executeStatement(sql, withParameters: params)
if(status)
{
//Read Table AppInfo into an Array of Dictionaries for the above Transactions
let results = db.getRecordsForQuery("select * from AppInfo ")
NSLog("Results = \(results)")
}
```

Objective-C version existe aussi et est appelé le même SQLDataAccess, alors maintenant vous pouvez choisir de rédiger votre suite en Objective-C ou Swift.
En outre SQLDataAccess travaillera également avec SQLCipher, le présent code n'est pas d'installation mais de travailler avec elle, mais c'est assez facile à faire, et
un exemple de la façon de le faire est en fait dans l'Objective-C est la version de SQLDataAccess.

SQLDataAccess est très rapide et efficace de la classe, et peut être utilisé à la place de CoreData qui utilise SQLite comme c'est sous-jacente des données
magasin sans tous les CoreData de base de l'intégrité des données faute accidents qui viennent avec CoreData.

OriginalL'auteur Frost