             let db = unsafeBitCast(dbPointer, Database.self)
             
             // Notify change event
-            let event = DatabaseEvent(
-                kind: DatabaseEvent.Kind(rawValue: updateKind)!,
-                databaseName: String.fromCString(databaseName)!,
-                tableName: String.fromCString(tableName)!,
-                rowID: rowID)
-            db.propagateDatabaseDidChangeWithEvent(event)
+            if !db.transactionObservers.isEmpty {
+                db.didChangeWithEvent(DatabaseEvent(
+                    kind: DatabaseEvent.Kind(rawValue: updateKind)!,
+                    databaseName: String.fromCString(databaseName)!,
+                    tableName: String.fromCString(tableName)!,
+                    rowID: rowID))
+            }
             }, dbPointer)
         
         
         sqlite3_commit_hook(sqliteConnection, { dbPointer in
             let db = unsafeBitCast(dbPointer, Database.self)
+            
             do {
-                try db.propagateDatabaseWillCommit()
+                try db.willCommit()
+                db.statementCompletion = .TransactionCommit
                 // Next step: updateStatementDidExecute()
-                db.statementCompletion = .TransactionCommit
                 return 0
             } catch {
+                db.statementCompletion = .TransactionErrorRollback(error)
                 // Next step: sqlite3_rollback_hook callback
-                db.statementCompletion = .TransactionErrorRollback(error)
                 return 1
             }
             }, dbPointer)

            
            switch db.statementCompletion {
            case .TransactionErrorRollback:
                // The transactionObserver has rollbacked the transaction.
                // Don't lose this information.
                // Next step: updateStatementDidFail()
                break
            default:
                // Next step: updateStatementDidExecute()
                db.statementCompletion = .TransactionRollback
            }
            }, dbPointer)
    }

        try execute("COMMIT TRANSACTION")
    }
    
    public func addTransactionObserver(transactionObserver: TransactionObserverType) {
        preconditionValidQueue()
        transactionObservers.append(transactionObserver)
    }
    
    public func removeTransactionObserver(transactionObserver: TransactionObserverType) {
        preconditionValidQueue()
        if let index = transactionObservers.indexOf({ observer in observer === transactionObserver}) {
            transactionObservers.removeAtIndex(index)
        }
    }
    
    func updateStatementDidFail() throws {
        // Reset statementCompletion before didRollback eventually executes
        // other statements.
        let statementCompletion = self.statementCompletion
        self.statementCompletion = .Regular
        
