SQLConnection  - AS3

表示在最初创建当前数据库时是否启用自动压缩（为创建该数据库的 open() 或 openAsync() 调用中的 autoCompact 参数指定的值）。如果此属性为 true，则每次写入操作后从数据库文件中自动删除未使用的空间，使数据库文件保持更小。如果该属性为 false，则由删除的数据先前占用的空间保留在数据库文件中，需要时可重用。即使 autoCompact 为 false，也可以通过调用 compact() 方法强制数据库回收未使用的空间。

如果 connected 属性为 false，则此属性设置为 false。

相关 API 元素

提供对此连接的缓存大小的访问，缓存大小表示在内存中一次容纳的最大数据库磁盘页数。每个页面使用约 1.5 KB 内存（具体取决于为用于创建数据库的 open() 或 openAsync() 方法调用的 pageSize 参数指定的值）。默认缓存大小为 2000。如果某一应用程序正在执行更改数据库许多行的 UPDATE 或 DELETE 操作，则提高缓存大小可提高速度，但会以提高内存使用量为代价。

相关 API 元素

表示在 SELECT 语句结果中报告列名称的方式。

SQLColumnNameStyle 类中定义的常数表示此属性的可能值：

• SQLColumnNameStyle.LONG 表示以 [table-name]_[column-name] 格式返回列名称。
• SQLColumnNameStyle.SHORT 指定以 [column-name] 格式指定列名称。如果有多个同名的列，则只向结果对象中添加一个具有该名称的属性。
• SQLColumnNameStyle.DEFAULT 是默认值。使用此值时，结果列名称根据具有类似列名称的 SELECT 语句中的表数来设置格式。如果 SELECT 语句只包括一个表，则使用短名称格式 [column-name]；如果 SELECT 语句包括连接在一起的多个表，则在由于两个列名称相同而发生命名冲突时，将对名称相同的列使用长名称格式 [table-name]_[column-name]。

相关 API 元素

表示 SQLConnection 实例是否具有到数据库文件的打开连接。

相关 API 元素

表示事务中当前是否涉及此连接。

相关 API 元素

表示当前平台上是否支持 SQLConnection 类。

上次生成的行标识符（由 SQL INSERT 语句创建）。行标识符用于唯一标识数据库表中的行。该值通常由数据库生成。

如果未连接数据库或未执行 INSERT 语句，则该值为 0。

用于单个 SQL INSERT 语句执行的行标识符可以通过由 SQLStatement 对象的 getResult() 方法返回的 SQLResult 对象的 lastInsertRowID 属性获得（在 SQLStatement 调度其 result 事件后调用时）。

有关主键和生成的行标识符的详细信息，请参阅“本地数据库中的 SQL 支持”中的“CREATE TABLE”和“Expressions 等章节。

相关 API 元素

表示在最初创建当前数据库时指定的数据库页大小，以字节为单位（为创建该数据库的 open() 或 openAsync() 调用中的 pageSize 参数指定的值）。

如果 connected 属性为 false，则此属性的值为 0。

只有在数据库中创建第一个表后，才可以更改数据库的页大小（使用 open() 或 openAsync() 方法）。

相关 API 元素

包含在打开数据库连接后所做的数据更改的总数。除了跟踪由 INSERT、DELETE 和 UPDATE 语句所做的更改外，此值还包括由触发器导致的更改。

数据库连接关闭时，此值重置为 0。当 SQLConnection 实例未连接到数据库时，此值为 0。

相关 API 元素

创建 SQLConnection 实例。

使用 EventDispatcher 对象注册事件侦听器对象，以使侦听器能够接收事件通知。可以为特定类型的事件、阶段和优先级在显示列表中的所有节点上注册事件侦听器。

成功注册一个事件侦听器后，无法通过额外调用 addEventListener() 来更改其优先级。要更改侦听器的优先级，必须首先调用 removeListener()。然后，可以使用新的优先级再次注册该侦听器。

请记住，注册该侦听器后，如果继续调用具有不同 type 或 useCapture 值的 addEventListener()，则会创建单独的侦听器注册。例如，如果首先注册 useCapture 设置为 true 的侦听器，则该侦听器只在捕获阶段进行侦听。如果使用同一个侦听器对象再次调用 addEventListener()，并将 useCapture 设置为 false，那么便会拥有两个单独的侦听器：一个在捕获阶段进行侦听，另一个在目标和冒泡阶段进行侦听。

不能只为目标阶段或冒泡阶段注册事件侦听器。这些阶段在注册期间是成对出现的，因为冒泡阶段只适用于目标节点的祖代。

如果不再需要某个事件侦听器，可调用 removeEventListener() 删除它，否则会产生内存问题。事件侦听器不会自动从内存中删除，因为只要调度对象存在，垃圾回收器就不会删除侦听器（除非 useWeakReference 参数设置为 true）。

复制 EventDispatcher 实例时并不复制其中附加的事件侦听器。（如果新近创建的节点需要一个事件侦听器，必须在创建该节点后附加该侦听器。）但是，如果移动 EventDispatcher 实例，则其中附加的事件侦听器也会随之移动。

如果在正在处理事件的节点上注册事件侦听器，则不会在当前阶段触发事件侦听器，但会在事件流的稍后阶段触发，如冒泡阶段。

如果从正在处理事件的节点中删除事件侦听器，则该事件侦听器仍由当前操作触发。删除事件侦听器后，决不会再次调用该事件侦听器（除非再次注册以备将来处理）。

参数

function(evt:Event):void

收集有关数据库索引的统计信息，并将其存储在数据库中。查询优化程序（数据库引擎的一部分，用于确定执行每个语句的最有效方式）随后可以使用这些统计信息。在执行特定查询时，统计信息有助于查询优化程序针对要使用的索引做出更佳选择。

如果数据库定义了索引，但尚未调用 analyze() 方法，则运行时仍将使用这些索引执行语句。不过，在没有由 analyze() 方法生成的附加统计信息的情况下，运行时不能为特定查询选择最有效的索引。

当表的数据发生更改时（由于执行 INSERT、UPDATE 或 DELETE 语句），与该表相关联的索引也会更改。由 analyze() 生成的统计信息不会自动更新。因此，进行大量数据更改后，再次调用 analyze() 方法可能大有裨益。但是，再次调用 analyze() 所获得的益处将取决于多个因素，包括对表定义的索引数、表中已更改的行数和总行数之间的关系、表的索引数据有多大变化以及更改后的数据和更改前的数据之间的差异程度。

resourceName 参数表示是应该对所有附加的数据库的索引、特定数据库的索引，还是特定表的索引执行操作。

每次调用此方法时，均会清除以前创建的任何统计数据并为 resourceName 参数中指定的数据库或表（如果 resourceName 为 null，则为所有连接的数据库中的所有表）重新创建统计数据。数据库连接处于打开状态时，可以随时调用此方法。analyze() 操作和其统计数据不包括在事务中；不过，当数据库具有当前事务时（inTransaction 属性为 true），最好不要调用 analyze()。这是因为 analyze() 调用不会考虑已在事务中执行但尚未提交的任何数据、表架构或索引更改，并且事务一旦提交，analyze() 数据将会过期。

要删除用 analyze() 方法创建的统计数据，请使用 deanalyze() 方法。

参数

相关 API 元素

将另一个数据库添加到 SQLConnection 实例中，并将新数据库命名为指定的名称。附加数据库允许在对此 SQLConnection 实例执行的 SQL 语句中使用该数据库。

如果已使用指定的名称附加数据库，则调用 attach() 会导致错误。不过，同一个数据库可以使用唯一的名称附加多次。单个 SQLConnection 实例只能附加 10 个数据库。

在使用可对主数据库（使用 open() 或 openAsync() 连接的数据库）执行的 attach() 连接的数据库上可以执行任何 SQL 语句。SQL 语句可以访问附加到该语句的关联 SQLConnection 实例的任何数据库中的表，包括在单个语句中访问多个数据库中的表。运行时在解析语句中的表名称时，它将按照数据库的附加顺序搜索 SQLConnection 实例的数据库，从使用 open() 或 openAsync() 方法连接的数据库开始搜索。在语句中使用该数据库名称（在 attach() 方法的 name 参数中指定）可以明确限定表名称。

要删除使用 attach() 方法附加的数据库，请使用 detach() 方法。在关闭 SQLConnection 实例（通过调用 close() 方法）时，会断开所有附加的数据库。

附加的数据库将使用与主数据库相同的执行模式（同步或异步），具体取决于主数据库是使用 open() 方法还是 openAsync() 方法连接。

参数

相关 API 元素

开始一个事务，其中将对针对连接的一个或多个数据库执行的所有 SQL 语句进行分组。

默认情况下，每个 SQL 语句都是在其自己的事务内执行的，语句的执行成功或失败时，事务将结束。使用 begin() 方法创建事务将导致创建新的手动事务。从此时开始，针对 SQLConnection 实例执行的所有 SQL 语句都在该事务内发生，并可以分组提交（永久保存）或回滚（撤消）这些语句所执行的任何动作或修改。

要结束事务，请调用 commit() 或 rollback() 方法，具体取决于是永久保存还是放弃由事务语句所做的更改。

忽略对 begin() 的嵌套调用。可通过调用 setSavepoint() 方法创建保存点，保存点类似于事务中的书签。然后可通过调用 releaseSavepoint() 或 rollbackToSavepoint() 方法部分提交或回滚 SQL 语句。但是，如果通过调用 begin() 启动事务，则直到调用 commit() 方法才会将更改永久提交到数据库中。

如果当前有事务打开时数据库连接关闭，则 AIR 会自动将该事务回滚。（注意：对于 AIR 1.1 和早期版本，连接关闭时将自动提交一个打开事务。）

一个事务不限于在单个数据库中执行语句；事务可以包括对附加的不同数据库执行的语句。

参数

相关 API 元素

package
{
    import flash.data.SQLConnection;
    import flash.data.SQLResult;
    import flash.data.SQLStatement;
    import flash.display.Sprite;
    import flash.events.SQLErrorEvent;
    import flash.events.SQLEvent;
    import flash.filesystem.File;
    
    public class MultiInsertTransactionExample extends Sprite
    {
        private var conn:SQLConnection;
        private var insertEmployee:SQLStatement;
        private var insertPhoneNumber:SQLStatement;
        
        public function MultiInsertTransactionExample():void
        {
            // define where to find the database file
            var appStorage:File = File.applicationStorageDirectory;
            var dbFile:File = appStorage.resolvePath("ExampleDatabase.db");
            
            // open the database connection
            conn = new SQLConnection();
            conn.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            conn.addEventListener(SQLEvent.OPEN, openHandler);
            conn.openAsync(dbFile);
        }
        
        // Called when the database is connected
        private function openHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.OPEN, openHandler);
            
            // start a transaction
            conn.addEventListener(SQLEvent.BEGIN, beginHandler);
            conn.begin();
        }
        
        // Called when the transaction begins
        private function beginHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.BEGIN, beginHandler);
            
            // create and execute the first SQL statement:
            // insert an employee record
            insertEmployee = new SQLStatement();
            insertEmployee.sqlConnection = conn;
            insertEmployee.text = 
                "INSERT INTO employees (lastName, firstName, email) " + 
                "VALUES (:lastName, :firstName, :email, :birthday)";
            insertEmployee.parameters[":lastName"] = "Smith";
            insertEmployee.parameters[":firstName"] = "Bob";
            insertEmployee.parameters[":email"] = "bsmith@example.com";
            insertEmployee.parameters[":birthday"] = new Date(1971, 8, 12);
            
            insertEmployee.addEventListener(SQLEvent.RESULT, insertEmployeeHandler);
            insertEmployee.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            insertEmployee.execute();
        }
        
        // Called after the employee record is inserted
        private function insertEmployeeHandler(event:SQLEvent):void
        {
            insertEmployee.removeEventListener(SQLEvent.RESULT, insertEmployeeHandler);
            insertEmployee.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            // Get the employee id of the newly created employee row
            var result:SQLResult = insertEmployee.getResult();
            var employeeId:Number = result.lastInsertRowID;
            
            // Add a phone number to the related phoneNumbers table
            insertPhoneNumber = new SQLStatement();
            insertPhoneNumber.sqlConnection = conn;
            insertPhoneNumber.text =
                "INSERT INTO phoneNumbers (employeeId, type, number) " +
                "VALUES (:employeeId, :type, :number)";
            insertPhoneNumber.parameters[":employeeId"] = employeeId;
            insertPhoneNumber.parameters[":type"] = "Home";
            insertPhoneNumber.parameters[":number"] = "(555) 555-1234";
            
            insertPhoneNumber.addEventListener(SQLEvent.RESULT, insertPhoneNumberHandler);
            insertPhoneNumber.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            insertPhoneNumber.execute();
        }
        
        // Called after the phone number record is inserted
        private function insertPhoneNumberHandler(event:SQLEvent):void
        {
            insertPhoneNumber.removeEventListener(SQLEvent.RESULT, insertPhoneNumberHandler);
            insertPhoneNumber.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            // No errors so far, so commit the transaction
            conn.addEventListener(SQLEvent.COMMIT, commitHandler);
            conn.commit();
        }
        
        // Called after the transaction is committed
        private function commitHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.COMMIT, commitHandler);
            
            trace("Transaction complete");
        }
        
        // Called whenever an error occurs
        private function errorHandler(event:SQLErrorEvent):void
        {
            // If a transaction is happening, roll it back
            if (conn.inTransaction)
            {
                conn.addEventListener(SQLEvent.ROLLBACK, rollbackHandler);
                conn.rollback();
            }
            
            trace(event.error.message);
            trace(event.error.details);
        }
        
        // Called when the transaction is rolled back
        private function rollbackHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.ROLLBACK, rollbackHandler);
            
            // add additional error handling, close the database, etc.
        }
    }
}

package
{
    import flash.data.SQLConnection;
    import flash.data.SQLResult;
    import flash.data.SQLStatement;
    import flash.display.Sprite;
    import flash.events.SQLErrorEvent;
    import flash.events.SQLEvent;
    import flash.filesystem.File;
    
    public class MultiDeleteTransactionExample extends Sprite
    {
        private var conn:SQLConnection;
        private var deleteEmployee:SQLStatement;
        private var deletePhoneNumbers:SQLStatement;
        
        private var employeeIdToDelete:Number = 25;
        
        public function MultiDeleteTransactionExample():void
        {
            // define where to find the database file
            var appStorage:File = File.applicationStorageDirectory;
            var dbFile:File = appStorage.resolvePath("ExampleDatabase.db");
            
            // open the database connection
            conn = new SQLConnection();
            conn.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            conn.addEventListener(SQLEvent.OPEN, openHandler);
            conn.openAsync(dbFile);
        }
        
        // Called when the database is connected
        private function openHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.OPEN, openHandler);
            
            // start a transaction
            conn.addEventListener(SQLEvent.BEGIN, beginHandler);
            conn.begin();
        }
        
        // Called when the transaction begins
        private function beginHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.BEGIN, beginHandler);
            
            // Create and execute the first SQL statement:
            // Delete an employee's phone number records
            deletePhoneNumbers = new SQLStatement();
            deletePhoneNumbers.sqlConnection = conn;
            deletePhoneNumbers.text =
                "DELETE FROM phoneNumbers " +
                "WHERE employeeId = :employeeId";
            deletePhoneNumbers.parameters[":employeeId"] = employeeIdToDelete;
            
            deletePhoneNumbers.addEventListener(SQLEvent.RESULT, deletePhoneNumbersHandler);
            deletePhoneNumbers.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            deletePhoneNumbers.execute();
        }
        
        // Called after the phone number records are deleted
        private function deletePhoneNumbersHandler(event:SQLEvent):void
        {
            deletePhoneNumbers.removeEventListener(SQLEvent.RESULT, deletePhoneNumbersHandler);
            deletePhoneNumbers.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            deleteEmployee = new SQLStatement();
            deleteEmployee.sqlConnection = conn;
            deleteEmployee.text = 
                "DELETE FROM employees " + 
                "WHERE employeeId = :employeeId";
            deleteEmployee.parameters[":employeeId"] = employeeIdToDelete;
            
            deleteEmployee.addEventListener(SQLEvent.RESULT, deleteEmployeeHandler);
            deleteEmployee.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            deleteEmployee.execute();
        }
        
        // Called after the employee record is deleted
        private function deleteEmployeeHandler(event:SQLEvent):void
        {
            deleteEmployee.removeEventListener(SQLEvent.RESULT, deleteEmployeeHandler);
            deleteEmployee.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            // No errors so far, so commit the transaction
            conn.addEventListener(SQLEvent.COMMIT, commitHandler);
            conn.commit();
        }
        
        // Called after the transaction is committed
        private function commitHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.COMMIT, commitHandler);
            
            trace("Transaction complete");
        }
        
        // Called whenever an error occurs
        private function errorHandler(event:SQLErrorEvent):void
        {
            // If a transaction is happening, roll it back
            if (conn.inTransaction)
            {
                conn.addEventListener(SQLEvent.ROLLBACK, rollbackHandler);
                conn.rollback();
            }
            
            trace(event.error.message);
            trace(event.error.details);
        }
        
        // Called when the transaction is rolled back
        private function rollbackHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.ROLLBACK, rollbackHandler);
            
            // add additional error handling, close the database, etc.
        }
    }
}

终止当前对连接到 SQLConnection 实例的数据库执行的所有 SQL 语句。此方法可用于停止长时间运行或失控的查询。

如果在调用 cancel() 方法时有些语句正在执行，则此方法会终止这些语句的操作，并回滚任何未完成的更新或事务。如果当前没有执行任何语句，则调用此方法会回滚已打开的事务，除此之外不执行任何操作。

参数

相关 API 元素

断开当前数据库连接。还会断开所有附加的数据库。

如果调用 close() 时存在打开的事务，则该事务将回滚。在将 SQLConnection 实例当作垃圾回收时，运行时会自动调用 close()，这包括在 SQLConnection 仍然连接到数据库时 AIR 应用程序已关闭的情况。

参数

提交一个现有事务，从而导致将该事务的语句执行的任何动作永久应用于数据库。

中间保存点类似于事务中的书签，可通过调用 setSavepoint() 方法进行创建。使用保存点，您可以通过调用 releaseSavepoint() 方法提交部分事务，或通过调用 rollbackToSavepoint() 方法回滚部分事务。但是，如果事务是使用 begin() 方法打开的，则直到通过调用 commit() 方法提交整个事务才会将更改永久保存到数据库中。

对于使用保存点的事务，当提交整个事务时不会提交任何使用 rollbackToSavepoint() 方法回滚的语句。使用 releaseSavepoint() 提交的语句，或其保存点未释放或未回滚的语句，将提交到数据库中。

参数

相关 API 元素

回收数据库中所有未使用的空间。从数据库中删除某一对象（表、索引或触发器）时，该对象会留下空白空间。这会使数据库文件比实际需要的文件更大，但可以加速 INSERT 操作。随着时间的推移，INSERT 和 DELETE 操作会使数据库文件结构出现碎块，从而降低数据库内容的磁盘访问速度。此方法可压缩数据库文件、消除空白页、调整表数据使其连续并清理数据库文件结构。

不能对附加的数据库文件执行 compact() 操作，只能对由 SQLConnection 实例打开的主（原始）数据库文件执行此操作。如果有活动的事务，则此操作将失败，此操作对内存中的数据库没有影响。

参数

删除通过调用 analyze() 方法创建的所有统计信息。

由于由 analyze() 方法生成的统计信息占用数据库的空间，因此调用 deanalyze() 可以收回该空间，如在删除多个索引或表之后。

此操作不包括在活动事务中。

参数

相关 API 元素

断开另一个以前使用 attach() 方法连接到 SQLConnection 实例的数据库。可以使用不同名称多次附加同一个数据库，在断开一个连接时，其他连接保持不变。如果连接包含打开的事务（如果 inTransaction 属性为 true），则无法断开该数据库的连接。

参数

相关 API 元素

提供对 loadSchema() 方法调用结果的访问。getSchemaResult() 方法的行为与先进先出结果队列相同。每次 loadSchema() 方法调用完成时（每次在异步执行模式中调度 schema 事件时），都会向队列中添加一个新 SQLSchemaResult 对象。每次调用 getSchemaResult() 方法时，即会返回最早的结果（最先添加到队列中的结果）并从队列中删除该结果。当队列中不再有对象时，getSchemaResult() 将返回 null。

当数据库连接关闭时，此方法返回 null。

相关 API 元素

从连接的数据库或任何附加的数据库中加载架构信息。该架构表示数据库的表、列、索引和触发器的结构。

要访问已加载的架构，请使用 SQLConnection.getSchemaResult() 方法。

在异步执行模式中，如果操作成功，则调度 schema 事件；如果操作失败，则调度 error 事件。

type 和 name 参数值的组合确定由 loadSchema() 方法生成的架构数据的类型和随后生成的 SQLSchemaResult 实例的属性值。下表列出了有效的 type 和 name 对以及由此生成的架构数据：

如果 type 和 name 参数的组合不对应于指定的组合之一，则在异步执行模式中将调度 error 事件或在同步执行模式中引发异常。例如，如果 type 参数为 SQLViewSchema 且 name 参数为表的名称（而不是视图的名称），则将引发一个错误，表示数据库不包含具有指定名称且属于指定类型的对象。

如果数据库为空（不包含任何表、视图、触发器或索引），则调用 loadSchema() 方法将导致错误。

参数

相关 API 元素

打开在文件系统指定位置处的数据库文件的同步连接，或者在该位置创建并打开新的数据库文件，或者创建并打开内存数据库。在使用此方法打开数据库时，用于创建和打开该数据库的操作，以及使用此 SQLConnection 实例执行的所有其他操作（包括语句执行和通过与此 SQLConnection 实例相关联的 SQLStatement 实例执行的其他操作）都是同步 执行的。要异步执行这些操作，请改用 openAsync() 方法打开数据库连接。

连接数据库后，请使用 SQLStatement 实例执行 SQL 命令。数据库级操作是使用 SQLConnection 实例执行的，如开始或结束事务、加载架构信息以及其他操作等。

系统会自动为使用 open() 方法连接的数据库分配数据库名称“main”。该名称可使用 [database-name].[table-name] 格式明确限定 SQL 语句中的表名称。

参数

相关 API 元素

打开在文件系统指定位置处的数据库文件的异步连接，或者在该位置创建并打开新的数据库文件，或者创建并打开内存数据库。在使用此方法打开数据库时，用于创建和打开该数据库的操作，以及使用此 SQLConnection 实例执行的所有其他操作（包括语句执行和通过与此 SQLConnection 实例相关联的 SQLStatement 实例执行的其他操作）都是异步 执行的。要同步执行这些操作，请改用 open() 方法打开数据库连接。

连接数据库后，请使用 SQLStatement 实例执行 SQL 命令。数据库级操作是使用 SQLConnection 实例执行的，如开始或结束事务、加载架构信息以及其他操作等。

系统会自动为使用 openAsync() 方法连接的数据库分配数据库名称“main”；使用 [database-name].[table-name] 格式时，该名称可在 SQL 语句中用于明确限定表名称。

参数

相关 API 元素

更改加密数据库的加密密钥。此方法仅影响主数据库（使用 open() 或 openAsync() 方法连接的数据库）的加密密钥。对创建时即加密的数据库只能调用 reencrypt()。将数据库创建为加密数据库后，就无法将其解密。同样，以后也无法对创建时未加密的数据库进行加密。

重新加密操作在其自身的事务中运行。如果重新加密的过程被中断，则数据库会将事务回滚，且不更改加密密钥。

参数

相关 API 元素

此方法提交自最新保存点或命名的保存点（如果名称已指定）起执行的所有 SQL 操作。

请注意，在提交整个事务之前，任何更改都不会永久保存到数据库。如果事务是使用 begin() 方法启动的，则必须调用 commit() 方法来提交整个事务。如果事务是在 inTransaction 为 false 时通过调用 setSavepoint() 启动的，您可以通过调用 commit() 方法完成整个事务，也可以通过为事务的第一个保存点调用 releaseSavepoint() 或 rollbackToSavepoint() 实现此目的。

如果代码调用 rollback() 方法，则不管在回滚事务之前是否调用了 releaseSavepoint()，它将永久放弃事务中的所有更改。

如果此方法在调用时没有使用参数（或 name 参数为 null），它会提交自最新未命名保存点（通过调用不带任何 name 参数的 setSavepoint() 创建的最新保存点）以后的所有数据库更改。例如，如果已三次调用 setSavepoint() 方法，则会设置三个保存点。此时调用 releaseSavepoint() 将提交自第三个（最新）保存点以后执行的 SQL 操作。

如果为 name 参数提供了值，此方法将提交自使用指定名称的保存点以后执行的所有 SQL 操作。如果其他保存点的创建时间比指定保存点更晚，还将提交在这些保存点之后执行的操作。

保存点释放或回滚后，将删除该保存点和任何更新的保存点。如果代码在 releaseSavepoint() 或 rollbackToSavepoint() 调用删除保存点后执行其他 SQL 操作，则这些操作都属于最新的那个剩余保存点。（换言之，这些操作属于在删除的保存点之前最新创建的保存点。）如果没有剩余任何保存点，则这些操作属于主事务。

参数

相关 API 元素

从 EventDispatcher 对象中删除侦听器。如果没有向 EventDispatcher 对象注册任何匹配的侦听器，则对此方法的调用没有任何效果。

参数

回滚使用 begin() 方法创建的现有事务，这意味着放弃事务中的任何 SQL 语句所做的所有更改。

可通过调用 setSavepoint() 方法在事务中标记中间保存点。使用保存点，您可以通过调用 releaseSavepoint() 方法提交部分事务，或者通过调用 rollbackToSavepoint() 方法回滚部分事务。但是，调用 rollback() 方法将永久放弃事务中的所有更改，而不管在回滚事务之前是否释放（提交）了各保存点。

参数

相关 API 元素

回滚自最新保存点或命名的保存点（如果名称已指定）起的所有 SQL 操作。

请注意，如果整个事务是通过调用 commit() 方法提交的，则事务中尚未使用 rollbackToSavepoint() 方法回滚的任何更改将永久保存在数据库中。此外，调用 rollback() 方法将永久放弃所有更改，而不管在回滚事务之前是否释放（提交）或回滚了各保存点。

如果此方法在调用时没有使用参数（或 name 参数为 null），它将回滚自最新的未命名保存点（对 setSavepoint() 最近一次不使用任何 name 参数值的调用）之后的所有数据库更改。

如果已为 name 参数提供了值，此方法将回滚自使用指定名称的保存点之后执行的所有 SQL 操作。如果其他保存点的创建时间比指定保存点更晚，还将回滚自这些保存点之后执行的操作。

保存点释放或回滚后，将删除该保存点和任何更新的保存点。如果代码在 releaseSavepoint() 或 rollbackToSavepoint() 调用删除保存点后执行其他 SQL 操作，则这些操作都属于最新的那个剩余保存点。（换言之，这些操作属于在删除的保存点之前最新创建的保存点。）如果没有剩余任何保存点，则这些操作属于主事务。

参数

相关 API 元素

创建保存点，保存点类似于数据库事务内的书签。保存点表示事务中的点。可以使用 releaseSavepoint() 和 rollbackToSavepoint() 方法从其他操作单独提交或回滚在保存点之间执行的一组 SQL 操作。这样，您可以使用保存点将一组 SQL 操作视为嵌套事务。

当调用 setSavepoint() 方法时，如果尚未打开事务（通过调用 begin() 方法），调用此方法会开始事务并在事务的起始处创建保存点。如果已打开事务，调用 setSavepoint() 时将在事务中创建保存点。

请注意，在提交整个事务之前，任何更改都不会永久保存到数据库。如果事务是使用 begin() 方法启动的，则必须调用 commit() 方法来提交整个事务。如果事务是在 inTransaction 为 false 时通过调用 setSavepoint() 启动的，您也可以通过调用 commit() 方法完成整个事务。如果针对启动事务的保存点调用 releaseSavepoint() 或 rollbackToSavepoint()，事务也会自动完成。

可通过为 name 参数提供值来指定保存点的名称。这允许您回滚或提交自特定保存点以后进行的所有更改。如果没有指定任何名称（默认），则会创建未命名的保存点。

保存点释放或回滚后，将删除该保存点和任何更新的保存点。如果代码在 releaseSavepoint() 或 rollbackToSavepoint() 调用删除保存点后执行其他 SQL 操作，则这些操作都属于最新的那个剩余保存点。（换言之，这些操作属于在删除的保存点之前最新创建的保存点。）如果没有剩余任何保存点，则这些操作属于主事务。

参数

相关 API 元素

在 analyze() 操作成功完成时调度。

相关 API 元素

在 attach() 方法调用操作成功完成时调度。

相关 API 元素

在 begin() 方法调用操作成功完成时调度。

相关 API 元素

在 cancel() 方法调用操作成功完成时调度。

相关 API 元素

在 close() 方法调用操作成功完成时调度。

相关 API 元素

在 commit() 方法调用操作成功完成时调度。

相关 API 元素

在 compact() 方法调用操作成功完成时调度。

相关 API 元素

在 deanalyze() 方法调用操作成功完成时调度。

相关 API 元素

在任何连接的数据库的任何表中的数据由于 SQL DELETE 命令而发生更改时调度。数据更改可能是通过 SQLStatement 实例执行 DELETE 语句的直接结果，也可能是在响应语句执行时触发器触发所导致的间接结果。

相关 API 元素

在 detach() 方法调用操作成功完成时调度。

相关 API 元素

任何 SQLConnection 对象的异步操作导致错误时调度。作为事件对象调度的 SQLErrorEvent 实例具有一个 error 属性，该属性包含有关尝试的操作和失败原因的信息。

在任何连接的数据库的任何表中的数据由于 SQL INSERT 命令而发生更改时调度。数据更改可能是通过 SQLStatement 实例执行 INSERT 语句的直接结果，也可能是在响应语句执行时触发器触发所导致的间接结果。

相关 API 元素

在 openAsync() 方法调用操作成功完成时调度。

相关 API 元素

调用 reencrypt() 方法的操作成功完成时将调度此事件。

相关 API 元素

在成功完成 releaseSavepoint() 方法调用的操作时调度。

相关 API 元素

在 rollback() 方法调用操作成功完成时调度。

相关 API 元素

在成功完成 rollbackToSavepoint() 方法调用的操作时调度。

相关 API 元素

在 loadSchema() 方法调用操作成功完成并且架构结果准备就绪时调度。

相关 API 元素

在成功完成 setSavepoint() 方法调用的操作时调度。

相关 API 元素

在任何连接的数据库的任何表中的数据由于 SQL UPDATE 命令而发生更改时调度。数据更改可能是通过 SQLStatement 实例执行 UPDATE 语句的直接结果，也可能是在响应语句执行时触发器触发所导致的间接结果。

update 事件具有以下属性：

相关 API 元素