                 // at runtime: the implementation of storedDatabaseDictionary
                 // must be changed.
                 //
-                // I remember opening rdar://problem/10236982, based on a Core
-                // Data entity without any attribute. It was for testing
-                // purpose, and the test did not require any attribute, so the
-                // Core Data entity had no attribute. So let's choose option 3,
-                // and do nothing.
+                // 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: update() is supposed to throw
-                // RowNotFound when there is no matching row in the
-                // database. Consistency is important:
+                // 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))
-                guard row != nil else {
-                    throw DataMapperError.RowNotFound
-                }
-                return UpdateStatement.Changes(changedRowCount: 0, insertedRowID: nil)
+                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))
-            let changes = try updateStatement.execute(arguments: arguments)
-            
-            // Check is some row was actually changed
-            if changes.changedRowCount == 0 {
-                throw DataMapperError.RowNotFound
-            }
-            
-            return changes
+            return try updateStatement.execute(arguments: arguments)
         }
         
         /// DELETE
-        /// Returns whether a row was actually deleted
         func delete(db: Database) throws -> UpdateStatement.Changes {
             // Delete requires strongPrimaryKeyDictionary
             guard let primaryKeyDictionary = strongPrimaryKeyDictionary else {

    - throws: A DatabaseError is thrown whenever a SQLite error occurs.
    */
    public func delete(db: Database) throws -> DeletionResult {
        return try withDataMapper { dataMapper -> DeletionResult in
            let changes = try dataMapper.delete(db)
            
            // Future calls to update will throw RowModelNotFound. Make the user
            // a favor and make sure this error is thrown even if she checks the
            // edited flag:
            edited = true
            
            if changes.changedRowCount > 0 {
                return .RowDeleted
            } else {
                return .NoRowDeleted
            }
        }
    }
    

              updated.
    */
    public func update(db: Database) throws {
        let changes = try DataMapper(self).update(db)
        
        // if no row was updated, we have a problem.
        guard changes.changedRowCount > 0 else {
            throw RowModelError.RowModelNotFound(self)
        }
        
        edited = false
    }
    
    /**
