     */
     public func insert(db: Database) throws {
         let dataMapper = DataMapper(self)
-        let changes = try dataMapper.insert(db)
+        let changes = try dataMapper.insertStatement(db).execute()
         
         // Update RowID column if needed
         if let primaryKey = self.dynamicType.databaseTable?.primaryKey, case .RowID(let rowIDColumn) = primaryKey {

            
            // We need something to update.
            guard updatedDictionary.count > 0 else {
                // The RowModel is made of a primary key, without any other
                // column: we can't update anything.
                //
                // Three options:
                //
                // 1. throw some RowModelError, assuming this error is
                //    recoverable.
                // 2. fatalError, assuming it is a programmer error to "forget"
                //    keys from storedDatabaseDictionary.
                // 3. do nothing.
                //
                // Option 1 is not OK, because this error couldn't be recovered
                // at runtime: the implementation of storedDatabaseDictionary
                // must be changed.
                //
                // I remember opening rdar://problem/10236982 because CoreData
                // was crashing with entities without any attribute. So let's
                // choose option 3, and do nothing.
                //
                // But that's not quite ended. RowModel throws
                // RowModelError.RowModelNotFound when the row does not exist.
                // We need to return a consistent Changes result:
                
                let existsStatement = DataMapper.existsStatement(db, tableName: databaseTable.name, conditionColumns: Array(primaryKeyDictionary.keys))
                let row = existsStatement.fetchOneRow(arguments: QueryArguments(primaryKeyDictionary.values))
                return UpdateStatement.Changes(changedRowCount: (row == nil) ? 0 : 1, insertedRowID: nil)
            }
            
            // Update
            let updateStatement = try DataMapper.updateStatement(db, tableName: databaseTable.name, updatedColumns: Array(updatedDictionary.keys), conditionColumns: Array(primaryKeyDictionary.keys))
            let arguments = QueryArguments(Array(updatedDictionary.values) + Array(primaryKeyDictionary.values))
            return try updateStatement.execute(arguments: arguments)
        }
        
        /// DELETE
        func delete(db: Database) throws -> UpdateStatement.Changes {
            // Delete requires strongPrimaryKeyDictionary
            guard let primaryKeyDictionary = strongPrimaryKeyDictionary else {
                fatalError("Invalid primary key in \(rowModel)")

    - throws: A DatabaseError is thrown whenever a SQLite error occurs.
    */
    public func delete(db: Database) throws -> DeletionResult {
        let changes = try DataMapper(self).deleteStatement(db).execute()
        
        // Future calls to update will throw RowModelNotFound. Make the user
        // a favor and make sure this error is thrown even if she checks the
