         return sqliteStatement
     }
     
+    ///
+    /// Compiles a SQL string into a Statement, which can then be used to execute the SQL against the database.
+    /// Statement objects can be executed multiple times, and are more efficient when executing the same query or update
+    /// multiple times. See the Statement object for details, including providing parameters.
+    ///
+    /// :param:     sqlString   A SQL statement to compile.
+    /// :param:     error       An error pointer to set if an error occurs. May be `nil`.
+    /// :returns:               The compiled SQL as a Statement. This Statement must be closed when it is no longer
+    ///                         needed. On error, `nil` will be returned and an NSError object will be provided via the
+    ///                         `error` parameter.
+    ///
     public func prepareStatement(sqlString:String, error:NSErrorPointer) -> Statement? {
         let sqliteStatement = prepareSqliteStatement(sqlString, error:error)
         if sqliteStatement == nil {

    // -----------------------------------------------------------------------------------------------------------------
    // MARK:  Savepoints

    public func beginSavepoint(savepointName:String, error:NSErrorPointer = nil) -> Bool {
        return execute("SAVEPOINT " + escapeIdentifier(savepointName), error: error)
    }

    public func rollbackSavepoint(savepointName:String, error:NSErrorPointer = nil) -> Bool {
        return execute("ROLLBACK TO SAVEPOINT " + escapeIdentifier(savepointName),
                       error: error)
    }

    public func releaseSavepoint(savepointName:String, error:NSErrorPointer = nil) -> Bool {
        return execute("RELEASE " + escapeIdentifier(savepointName),
                       error: error)
    }

    public func savepoint(name:String, block:(db:Database)->TransactionResult) -> TransactionResult {
        var localError : NSError?
        var didBegin = beginSavepoint(name, error: &localError)

    // -----------------------------------------------------------------------------------------------------------------
    // MARK:  Path
    
    /// The location of the database on disk. Temporary databases will return an empty string, and in-memory databases
    /// return ':memory:'
    public let path : String
    
    /// :returns: `true` if the Database is stored in memory; `false` otherwise.
    public var isInMemoryDatabase : Bool {
        return path == ":memory:"
    }

    /// :returns: true if the Database is stored in a temporary location; false otherwise.
    public var isTemporaryDatabase : Bool {
        return path == ""
    }
    
    /// :returns: true if the Database is persistent -- not stored in memory or in a temporary location.
    public var isPersistentDatabase : Bool {
        return !(isInMemoryDatabase || isTemporaryDatabase)
    }
