Because shared locks are held to the end of a transaction instead of being released at the end of each statement, concurrency is lower than the default READ COMMITTED isolation level. If the current transaction then retries the statement it will retrieve the new rows, which results in phantom reads. Other transactions can insert new rows that match the search conditions of statements issued by the current transaction. This prevents other transactions from modifying any rows that have been read by the current transaction. Shared locks are placed on all data read by each statement in the transaction and are held until the transaction completes. Specifies that statements cannot read data that has been modified but not yet committed by other transactions and that no other transactions can modify data that has been read by the current transaction until the current transaction completes. The database does not have to be in single-user mode. There must be no other open connection in the database until ALTER DATABASE is complete.
When you set the READ_COMMITTED_SNAPSHOT option, only the connection executing the ALTER DATABASE command is allowed in the database. Locks are not used to protect the data from updates by other transactions. If READ_COMMITTED_SNAPSHOT is set to ON (the default on Azure SQL Database), the Database Engine uses row versioning to present each statement with a transactionally consistent snapshot of the data as it existed at the start of the statement. Page locks are released when the next page is read, and table locks are released when the statement finishes. Row locks are released before the next row is processed. The shared lock type determines when it will be released. The shared locks also block the statement from reading rows modified by other transactions until the other transaction is completed.
If READ_COMMITTED_SNAPSHOT is set to OFF (the default on SQL Server), the Database Engine uses shared locks to prevent other transactions from modifying rows while the current transaction is running a read operation. The behavior of READ COMMITTED depends on the setting of the READ_COMMITTED_SNAPSHOT database option: Data can be changed by other transactions between individual statements within the current transaction, resulting in nonrepeatable reads or phantom data. Specifies that statements cannot read data that has been modified but not committed by other transactions. For more information about snapshot isolation, see Snapshot Isolation in SQL Server. The READ COMMITTED isolation level with the READ_COMMITTED_SNAPSHOT database option set to ON.
In SQL Server, you can also minimize locking contention while protecting transactions from dirty reads of uncommitted data modifications using either: This is the least restrictive of the isolation levels. This option has the same effect as setting NOLOCK on all tables in all SELECT statements in a transaction. Values in the data can be changed and rows can appear or disappear in the data set before the end of the transaction. When this option is set, it is possible to read uncommitted modifications, which are called dirty reads. READ UNCOMMITTED transactions are also not blocked by exclusive locks that would prevent the current transaction from reading rows that have been modified but not committed by other transactions.
Transactions running at the READ UNCOMMITTED level do not issue shared locks to prevent other transactions from modifying data read by the current transaction. Specifies that statements can read rows that have been modified by other transactions but not yet committed. To view Transact-SQL syntax for SQL Server 2014 and earlier, see Previous versions documentation.
0 kommentar(er)
