config

try services.register(SQLiteProvider())

custom config

// Configure a SQLite database
let sqlite = try SQLiteDatabase(storage: .file(path: "db.sqlite")) //文件存储
let sqlite = try SQLiteDatabase(storage: .memory) //内存中存储

/// Register the configured SQLite database to the database config.
var databases = DatabasesConfig()
databases.add(database: sqlite, as: .sqlite)
services.register(databases)

开启sql log

databaseConfig.enableLogging(on: DatabaseIdentifier<SQLiteDatabase>.sqlite)

准备导入库

import SQLite
import DatabaseKit

filter

Todo.query(on: req).filter(\.id, .greaterThan, 1).all()

let users = try User.query(on: conn)
    .filter(\.name, .equal, "Vapor")
    .all()

Quesry

   struct SQLiteVersion: Codable {
        let version: String
    }
    
    router.get("sql") { (req) -> EventLoopFuture<String> in
        let result =  req.withPooledConnection(to: DatabaseIdentifier<SQLiteDatabase>.sqlite, closure: { (conn:SQLiteConnection) -> EventLoopFuture<[SQLiteVersion]> in
            return   conn.select().column(GenericSQLExpression.function("sqlite_version"), as: GenericSQLIdentifier.init("version")).all(decoding:SQLiteVersion.self)
        })
        return   result.map({ (rows) -> String in
            return rows[0].version
        })
    }

【关于EventLoopFuture】
Functions that promise to do work asynchronously can return an EventLoopFuture<T>. The recipient of such an object can then observe it to be notified when the operation completes.
The provider of a EventLoopFuture<T> can create and return a placeholder object before the actual result is available. For example:

func getNetworkData(args) -> EventLoopFuture<NetworkResponse> {
    let promise: EventLoopPromise<NetworkResponse> = eventLoop.newPromise()
    queue.async {
        . . . do some work . . .
        promise.succeed(response)
        . . . if it fails, instead . . .
        promise.fail(error)
    }
    return promise.futureResult
}

Query Select Example

 struct User: SQLTable, Codable, Content {
        static let sqlTableIdentifierString: String = "users"
        let id: Int?
        let name: String
    }
    
    router.get("nsql") { (req) -> EventLoopFuture<Array<User>> in
        
    let result =    req.withPooledConnection(to: DatabaseIdentifier<SQLiteDatabase>.sqlite,
                                 closure: { (conn) -> EventLoopFuture<[User]> in
                                    let users =  conn.select()
                                        .all().from(User.self)
                                        .where(\User.name=="Vapor")
                                        .all(decoding: User.self)
                                    
                                    return users
        })
        return result
    }