Dil

SQL Server'da Anlık Görüntü Yalıtımı

Anlık görüntü yalıtımı, OLTP uygulamaları için eşzamanlılığı artırır.

Anlık Görüntü İzolasyonunu ve Satır Sürümlemeyi Anlama

Anlık görüntü yalıtımı etkinleştirildikten sonra, her işlem için güncelleştirilmiş satır sürümleri korunmalıdır. SQL Server 2019'a kadar bu sürümler tempdb içinde depolanıyordu. SQL Server 2019, kendi satır sürümleri kümesini gerektiren Hızlandırılmış Veritabanı Kurtarma (ADR) adlı yeni bir özellik tanıtır. Bu nedenle, SQL Server 2019 itibarıyla ADR etkinleştirilmemişse, satır sürümleri her zaman olduğu gibi içinde tempdb tutulur. ADR etkinleştirilirse, hem anlık görüntü yalıtımı hem de ADR ile ilgili tüm satır sürümleri, kullanıcının belirttiği bir dosya grubundaki kullanıcı veritabanında bulunan ADR'nin Kalıcı Sürüm Deposu'nda (PVS) tutulur. Benzersiz bir işlem sırası numarası her işlemi tanımlar ve bu benzersiz sayılar her satır sürümü için kaydedilir. İşlem, işlemin sıra numarasından önceki sıra numarasına sahip en güncel satır sürümleriyle çalışır. İşlem başlatıldıktan sonra oluşturulan yeni satır sürümleri işlem tarafından yoksayılır.

"Anlık görüntü" terimi, işlemdeki tüm sorguların, işlemin başladığı anda veritabanının durumuna bağlı olarak veritabanının aynı sürümünü veya anlık görüntüsünü gördüğü gerçeğini yansıtır. Anlık görüntü işleminde temel alınan veri satırlarına veya veri sayfalarına kilit alınmaz ve bu da diğer işlemlerin daha önce tamamlanmamış bir işlem tarafından engellenmeden yürütülmesine izin verir. Verileri değiştiren işlemler, verileri okuyan işlemleri engellemez ve verileri okuyan işlemler, SQL Server’daki varsayılan READ COMMITTED yalıtım düzeyinde normalde olduğu gibi veri yazan işlemleri engellemez. Bu engelleyici olmayan davranış, karmaşık işlemler için kilitlenme olasılığını da önemli ölçüde azaltır.

Anlık görüntü yalıtımı iyimser bir eşzamanlılık modeli kullanır. Bir anlık görüntü işlemi, işlem başladıktan sonra değişen verilerde değişiklikler gerçekleştirmeye çalışırsa, işlem geri alınır ve bir hata oluşur. SELECT ipuçlarını, değiştirilecek verilere erişen UPDLOCK deyimler için kullanarak bunu önleyebilirsiniz. Daha fazla bilgi için bkz. İpuçları (Transact-SQL).

Anlık görüntü yalıtımı, işlemlerde kullanılmadan önce ALLOW_SNAPSHOT_ISOLATION ON veritabanı seçeneği ayarlanarak etkinleştirilmelidir. Bu, satır sürümlerini geçici veritabanında (tempdb) depolama mekanizmasını etkinleştirir. Transact-SQL ALTER DATABASE deyimiyle kullanan her veritabanında anlık görüntü yalıtımını etkinleştirmeniz gerekir. Bu açıdan anlık görüntü yalıtımı, yapılandırma gerektirmeyen REPEATABLE READ, SERIALIZABLE, READ UNCOMMITTED ve READ COMMITTED geleneksel yalıtım düzeylerinden farklıdır. Aşağıdaki ifadeler READ COMMITTED işlemleri ve satır sürümlü SNAPSHOT okumaları etkinleştirir:

ALTER DATABASE MyDatabase
SET ALLOW_SNAPSHOT_ISOLATION ON

ALTER DATABASE MyDatabase
SET READ_COMMITTED_SNAPSHOT ON

READ_COMMITTED_SNAPSHOT ON seçeneğinin ayarlanması, varsayılan READ COMMITTED yalıtım düzeyi altındaki sürümlenmiş satırlara erişim sağlar. READ_COMMITTED_SNAPSHOT seçeneği OFF olarak ayarlandıysa, sürüme alınan satırlara erişmek için her oturum için Anlık görüntü yalıtım düzeyini açıkça ayarlamanız gerekir.

Yalıtım Düzeyleriyle Eşzamanlılığı Yönetme

Bir Transact-SQL deyiminin yürütüleceği yalıtım düzeyi, kilitleme ve satır sürümleme davranışını belirler. Yalıtım düzeyi, bağlantı genelinde kapsama sahiptir ve deyimiyle SET TRANSACTION ISOLATION LEVEL bir bağlantı için ayarlandıktan sonra, bağlantı kapatılana veya başka bir yalıtım düzeyi ayarlanana kadar etkin kalır. Bir bağlantı kapatılıp havuza döndürülürse, son SET TRANSACTION ISOLATION LEVEL deyimdeki yalıtım düzeyi korunur. Havuza alınan bağlantıyı yeniden kullanan sonraki bağlantılar, bağlantı havuza alındığı sırada geçerli olan yalıtım düzeyini kullanır.

Bir bağlantı içinde verilen tek tek sorgular, tek bir deyim veya işlem için yalıtımı değiştiren ancak bağlantının yalıtım düzeyini etkilemeyen kilit ipuçları içerebilir. Saklı yordamlarda veya işlevlerde ayarlanan yalıtım düzeyleri veya kilit ipuçları, onları çağıran bağlantının yalıtım düzeyini değiştirmez ve yalnızca saklı yordam veya işlev çağrısı süresi boyunca etkindir.

SQL-92 standardında tanımlanan dört yalıtım düzeyi, SQL Server'ın ilk sürümlerinde destekleniyordu:

  • READ UNCOMMITTED diğer işlemler tarafından yerleştirilen kilitleri yoksaydığından en az kısıtlayıcı yalıtım düzeyidir. READ UNCOMMITTED altında yürütülen işlemler, diğer işlemler tarafından henüz commit edilmemiş değiştirilmiş veri değerlerini okuyabilir; bunlara "kirli" okumalar denir.

  • READ COMMITTED SQL Server için varsayılan yalıtım düzeyidir. İfadelerin, değiştirilmiş ancak henüz diğer işlemler tarafından onaylanmamış veri değerlerini okuyamayacağını belirterek kirli okumaları önler. Diğer işlemler yine de mevcut işlem sırasında tek tek ifadelerin yürütülmesi arasında verileri değiştirebilir, ekleyebilir veya silebilir ve bu da yinelenemeyen okumalar veya "hayalet" verilerle sonuçlanabilir.

  • REPEATABLE READ, READ COMMITTED'den daha kısıtlayıcı bir yalıtım düzeyidir. Bu işlem, READ COMMITTED kapsar ve ayrıca geçerli işlem kesinleştirilene kadar, geçerli işlem tarafından okunmuş verilerin başka hiçbir işlem tarafından değiştirilemeyeceğini veya silinemeyeceğini belirtir. Eşzamanlılık, okunan verilerdeki paylaşılan kilitler her deyimin sonunda serbest bırakılmak yerine işlem süresi boyunca tutulduğundan, READ COMMITTED için olandan daha düşüktür.

  • SERIALIZABLE Serializable en kısıtlayıcı yalıtım düzeyidir, çünkü tüm anahtar aralıklarını kilitler ve işlem tamamlanana kadar kilitleri tutar. REPEATABLE READ kapsar ve işlemin tamamlanmasına kadar diğer işlemlerin, işlem tarafından okunan aralıklara yeni satırlar ekleyememesi kısıtını da getirir.

Daha fazla bilgi için İşlem Kilitleme ve Satır Sürüm Oluşturma Kılavuzu'na bakın.

Anlık Görüntü Yalıtım Düzeyi Uzantıları

SQL Server, sql-92 yalıtım düzeyleri için yalıtım düzeyinin tanıtılması SNAPSHOT ve ek uygulaması ile uzantılar kullanıma sunulmuşturREAD COMMITTED.

  • SNAPSHOT izolasyon, bir işlem içinde okunan verilerin hiçbir zaman diğer eşzamanlı işlemler tarafından yapılan değişiklikleri yansıtmayacağını belirtir. İşlem, işlem başladığında var olan veri satırı sürümlerini kullanır. Veriler okunduğunda verilere hiçbir kilit uygulanmaz, bu nedenle SNAPSHOT işlemler diğer işlemlerin veri yazmasını engellemez. Veri yazan işlemler, anlık görüntü işlemlerinin verileri okumalarını engellemez. Bunu kullanmak için ALLOW_SNAPSHOT_ISOLATION veritabanı seçeneğini ayarlayarak anlık görüntü yalıtımını etkinleştirmeniz gerekir.

  • READ_COMMITTED_SNAPSHOT Veritabanı seçeneği, READ COMMITTED verileri nasıl okuduğunu denetler. Bu seçenekleOFF, SQL Server'da varsayılan olan Database Engine, okumaları korumak için paylaşılan kilitleri kullanır. Bu seçenekle ON, READ COMMITTED okumaları korumak için paylaşılan kilitler yerine ifade düzeyi satır sürümlerini kullanır.

Anlık Görüntü Yalıtımı ve Satır Sürümü Oluşturma Nasıl Çalışır?

SNAPSHOT Yalıtım düzeyi etkinleştirildiğinde, bir satır her güncelleştirildiğinde, SQL Server Database Engine özgün satırın bir kopyasını tempdb içinde depolar ve satıra bir işlem dizisi numarası ekler. Gerçekleşen olayların sırası aşağıdadır:

  • Yeni bir işlem başlatılır ve bir işlem sırası numarası atanır.

  • Veritabanı Motoru, işlem içindeki bir satırı okur ve sıra numarası işlem sıra numarasına en yakın ve daha düşük olan satır sürümünü tempdb'den alır.

  • Veritabanı Motoru, anlık görüntü işlemi başlatıldığında işlem sıra numarasının, kaydedilmemiş işlemlerin etkin işlem dizisi numaraları listesinde olmadığını denetler.

  • İşlem, işlemin başlangıcından itibaren geçerli olan satırın tempdb sürümünü okur. İşlem başlatıldıktan sonra eklenen yeni satırları görmez çünkü bu sıra numarası değerleri işlem dizisi numarasının değerinden daha yüksek olacaktır.

  • Geçerli işlem, içinde daha düşük bir sıra numarası değerine sahip bir satır sürümü tempdb olacağı için işlem başladıktan sonra silinen satırları görür.

Anlık görüntü yalıtımının net etkisi, işlemin temel alınan tablolara herhangi bir kilit eklemeden, işlemin başlangıcında mevcut olan tüm verileri görmesidir. Bu, çekişme olduğu durumlarda performans geliştirmelerine neden olabilir.

Anlık görüntü işlemi her zaman iyimser eşzamanlılık denetimi kullanır ve diğer işlemlerin satırları güncellemesini engelleyecek kilitleri kullanmaktan kaçınır. Anlık görüntü işlemi, işlem başladıktan sonra değiştirilen bir satıra güncelleştirme işlemeye çalışırsa, işlem geri alınır ve bir hata oluşur.

ADO.NET'da Anlık Görüntü Yalıtımı ile Çalışma

Anlık görüntü yalıtımıyla bir işlem başlatmak için veritabanı için ALLOW_SNAPSHOT_ISOLATION seçeneğini etkinleştirin ve Snapshot öğesine BeginTransaction geçirin. READ_COMMITTED_SNAPSHOT Veritabanı seçeneği, satır sürümlü okumaları read-committed yalıtım düzeyinde denetler; işlem için anlık görüntü yalıtımını seçmez. Aşağıdaki parça, connection öğesinin SqlConnection sınıfının açık bir örneği olduğunu varsayar.

Dim sqlTran As SqlTransaction = _
  connection.BeginTransaction(IsolationLevel.Snapshot)
SqlTransaction sqlTran =
  connection.BeginTransaction(IsolationLevel.Snapshot);

Örnek

Aşağıdaki örnek, kilitli verilere erişmeye çalışarak farklı yalıtım düzeylerinin nasıl davrandığını gösterir ve üretim kodunda kullanılması amaçlanmamıştır.

Kod, SQL Server'daki örnek veritabanına bağlanır AdventureWorks ve adlı TestSnapshot bir tablo oluşturur ve bir veri satırı ekler. Kod, veritabanı için anlık görüntü yalıtımını açmak üzere ALTER DATABASE Transact-SQL deyimini kullanır, ancak READ COMMITTED seçeneğini ayarlamaz ve varsayılan READ_COMMITTED_SNAPSHOT yalıtım düzeyi davranışını yürürlükte bırakır. Kod daha sonra aşağıdaki eylemleri gerçekleştirir:

  • sqlTransaction1 yalıtım düzeyini kullanarak bir güncelleştirme işlemi başlatan SERIALIZABLE ile başlar, ancak tamamlamaz. Bu, tabloyu kilitleme etkisine sahiptir.

  • İkinci bir bağlantı açar ve TestSnapshot tablosundaki verileri okumak için SNAPSHOT yalıtım düzeyini kullanarak ikinci bir işlem başlatır. Anlık görüntü yalıtımı etkinleştirildiğinden, bu işlem sqlTransaction1 başlamadan önce var olan verileri okuyabilir.

  • Üçüncü bir bağlantı açar ve tablodaki verileri okumaya çalışmak için READ COMMITTED yalıtım düzeyini kullanarak bir işlem başlatır. Bu durumda kod, ilk işlemde tablo üzerine yerleştirilen kilitlerin ötesini okuyamadığından verileri okuyamaz ve zaman aşımına uğrar. REPEATABLE READ ve SERIALIZABLE yalıtım düzeyleri kullanılsaydı da aynı sonuç ortaya çıkardı, çünkü bu yalıtım düzeyleri de ilk işlemde yerleştirilen kilitlerin ötesini okuyamaz.

  • Dördüncü bir bağlantı açar ve READ UNCOMMITTED yalıtım düzeyini kullanarak bir işlem başlatır; bu da sqlTransaction1 içindeki kaydedilmemiş değerin kirli bir okumasını gerçekleştirir. İlk işlem işlenmediyse bu değer veritabanında hiçbir zaman mevcut olmayabilir.

  • İlk işlemi geri alır ve TestSnapshot tablosunu silip AdventureWorks veritabanı için anlık görüntü izolasyonunu kapatarak temizler.

Uyarı

Aşağıdaki örneklerde, bağlantı havuzu kapalıyken aynı bağlantı dizesi kullanılır. Bir bağlantı havuza alındıysa, yalıtım düzeyi sıfırlandığında sunucudaki yalıtım düzeyi de sıfırlanmaz. Sonuç olarak, aynı havuzdaki iç bağlantıyı kullanan sonraki bağlantılar, izolasyon seviyeleri havuz bağlantısının seviyesine ayarlanmış olarak başlar. Bağlantı havuzunu kapatmanın bir alternatifi, her bağlantı için yalıtım düzeyini açıkça ayarlamaktır.

// Assumes GetConnectionString returns a valid connection string
// where pooling is turned off by setting Pooling=False;.
var connectionString = GetConnectionString();
using (SqlConnection connection1 = new(connectionString))
{
    // Drop the TestSnapshot table if it exists
    connection1.Open();
    SqlCommand command1 = connection1.CreateCommand();
    command1.CommandText = "IF EXISTS "
        + "(SELECT * FROM sys.tables WHERE name=N'TestSnapshot') "
        + "DROP TABLE TestSnapshot";
    try
    {
        command1.ExecuteNonQuery();
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
    // Enable Snapshot isolation
    command1.CommandText =
        "ALTER DATABASE AdventureWorks SET ALLOW_SNAPSHOT_ISOLATION ON";
    command1.ExecuteNonQuery();

    // Create a table named TestSnapshot and insert one row of data
    command1.CommandText =
        "CREATE TABLE TestSnapshot (ID int primary key, valueCol int)";
    command1.ExecuteNonQuery();
    command1.CommandText =
        "INSERT INTO TestSnapshot VALUES (1,1)";
    command1.ExecuteNonQuery();

    // Begin, but do not complete, a transaction to update the data
    // with the Serializable isolation level, which locks the table
    // pending the commit or rollback of the update. The original
    // value in valueCol was 1, the proposed new value is 22.
    SqlTransaction transaction1 =
        connection1.BeginTransaction(IsolationLevel.Serializable);
    command1.Transaction = transaction1;
    command1.CommandText =
        "UPDATE TestSnapshot SET valueCol=22 WHERE ID=1";
    command1.ExecuteNonQuery();

    // Open a second connection to AdventureWorks
    using (SqlConnection connection2 = new(connectionString))
    {
        connection2.Open();
        // Initiate a second transaction to read from TestSnapshot
        // using Snapshot isolation. This will read the original
        // value of 1 since transaction1 has not yet committed.
        SqlCommand command2 = connection2.CreateCommand();
        SqlTransaction transaction2 =
            connection2.BeginTransaction(IsolationLevel.Snapshot);
        command2.Transaction = transaction2;
        command2.CommandText =
            "SELECT ID, valueCol FROM TestSnapshot";
        using (SqlDataReader reader2 = command2.ExecuteReader())
        {
            while (reader2.Read())
            {
                Console.WriteLine("Expected 1,1 Actual "
                    + reader2.GetValue(0)
                    + "," + reader2.GetValue(1));
            }
        }
        transaction2.Commit();
    }

    // Open a third connection to AdventureWorks and
    // initiate a third transaction to read from TestSnapshot
    // using ReadCommitted isolation level. This transaction
    // will not be able to view the data because of
    // the locks placed on the table in transaction1
    // and will time out after 4 seconds.
    // You would see the same behavior with the
    // RepeatableRead or Serializable isolation levels.
    using (SqlConnection connection3 = new(connectionString))
    {
        connection3.Open();
        SqlCommand command3 = connection3.CreateCommand();
        SqlTransaction transaction3 =
            connection3.BeginTransaction(IsolationLevel.ReadCommitted);
        command3.Transaction = transaction3;
        command3.CommandText =
            "SELECT ID, valueCol FROM TestSnapshot";
        command3.CommandTimeout = 4;
        try
        {
            using (SqlDataReader sqldatareader3 = command3.ExecuteReader())
            {
                while (sqldatareader3.Read())
                {
                    Console.WriteLine("You should never hit this.");
                }
            }
            transaction3.Commit();
        }
        catch (Exception ex)
        {
            Console.WriteLine("Expected timeout expired exception: "
                + ex.Message);
            transaction3.Rollback();
        }
    }

    // Open a fourth connection to AdventureWorks and
    // initiate a fourth transaction to read from TestSnapshot
    // using the ReadUncommitted isolation level. ReadUncommitted
    // will not hit the table lock, and will allow a dirty read
    // of the proposed new value 22 for valueCol. If the first
    // transaction rolls back, this value will never actually have
    // existed in the database.
    using (SqlConnection connection4 = new(connectionString))
    {
        connection4.Open();
        SqlCommand command4 = connection4.CreateCommand();
        SqlTransaction transaction4 =
            connection4.BeginTransaction(IsolationLevel.ReadUncommitted);
        command4.Transaction = transaction4;
        command4.CommandText =
            "SELECT ID, valueCol FROM TestSnapshot";
        using (SqlDataReader reader4 = command4.ExecuteReader())
        {
            while (reader4.Read())
            {
                Console.WriteLine("Expected 1,22 Actual "
                    + reader4.GetValue(0)
                    + "," + reader4.GetValue(1));
            }
        }

        transaction4.Commit();
    }

    // Roll back the first transaction
    transaction1.Rollback();
}

// CLEANUP
// Delete the TestSnapshot table and set
// ALLOW_SNAPSHOT_ISOLATION OFF
using (SqlConnection connection5 = new(connectionString))
{
    connection5.Open();
    SqlCommand command5 = connection5.CreateCommand();
    command5.CommandText = "DROP TABLE TestSnapshot";
    SqlCommand command6 = connection5.CreateCommand();
    command6.CommandText =
        "ALTER DATABASE AdventureWorks SET ALLOW_SNAPSHOT_ISOLATION OFF";
    try
    {
        command5.ExecuteNonQuery();
        command6.ExecuteNonQuery();
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}
Console.WriteLine("Done!");
' Assumes GetConnectionString returns a valid connection string
' where pooling is turned off by setting Pooling=False;.
Dim connectionString As String = GetConnectionString()

Using connection1 As New SqlConnection(connectionString)
    ' Drop the TestSnapshot table if it exists
    connection1.Open()
    Dim command1 As SqlCommand = connection1.CreateCommand
    command1.CommandText = "IF EXISTS " & _
    "(SELECT * FROM sys.tables WHERE name=N'TestSnapshot') " _
      & "DROP TABLE TestSnapshot"
    Try
        command1.ExecuteNonQuery()
    Catch ex As Exception
        Console.WriteLine(ex.Message)
    End Try

    ' Enable SNAPSHOT isolation
    command1.CommandText = _
    "ALTER DATABASE AdventureWorks SET ALLOW_SNAPSHOT_ISOLATION ON"
    command1.ExecuteNonQuery()

    ' Create a table named TestSnapshot and insert one row of data
    command1.CommandText = _
    "CREATE TABLE TestSnapshot (ID int primary key, valueCol int)"
    command1.ExecuteNonQuery()
    command1.CommandText = _
      "INSERT INTO TestSnapshot VALUES (1,1)"
    command1.ExecuteNonQuery()

    ' Begin, but do not complete, a transaction to update the data
    ' with the Serializable isolation level, which locks the table
    ' pending the commit or rollback of the update. The original
    ' value in valueCol was 1, the proposed new value is 22.
    Dim transaction1 As SqlTransaction = _
      connection1.BeginTransaction(IsolationLevel.Serializable)
    command1.Transaction = transaction1
    command1.CommandText = _
     "UPDATE TestSnapshot SET valueCol=22 WHERE ID=1"
    command1.ExecuteNonQuery()

    ' Open a second connection to AdventureWorks
    Dim connection2 As SqlConnection = New SqlConnection(connectionString)
    Using connection2
        connection2.Open()

        ' Initiate a second transaction to read from TestSnapshot
        ' using Snapshot isolation. This will read the original
        ' value of 1 since transaction1 has not yet committed.
        Dim command2 As SqlCommand = connection2.CreateCommand()
        Dim transaction2 As SqlTransaction = _
          connection2.BeginTransaction(IsolationLevel.Snapshot)
        command2.Transaction = transaction2
        command2.CommandText = _
            "SELECT ID, valueCol FROM TestSnapshot"
        Using reader2 As SqlDataReader = command2.ExecuteReader()
            While reader2.Read()
                Console.WriteLine("Expected 1,1 Actual " _
                  & reader2.GetValue(0).ToString() + "," _
                  & reader2.GetValue(1).ToString())
            End While
        End Using
        transaction2.Commit()
    End Using

    ' Open a third connection to AdventureWorks and
    ' initiate a third transaction to read from TestSnapshot
    ' using the ReadCommitted isolation level. This transaction
    ' will not be able to view the data because of
    ' the locks placed on the table in transaction1
    ' and will time out after 4 seconds.
    ' You would see the same behavior with the
    ' RepeatableRead or Serializable isolation levels.
    Dim connection3 As SqlConnection = New SqlConnection(connectionString)
    Using connection3
        connection3.Open()
        Dim command3 As SqlCommand = connection3.CreateCommand()
        Dim transaction3 As SqlTransaction = _
            connection3.BeginTransaction(IsolationLevel.ReadCommitted)
        command3.Transaction = transaction3
        command3.CommandText = _
            "SELECT ID, valueCol FROM TestSnapshot"
        command3.CommandTimeout = 4

        Try
            Using reader3 As SqlDataReader = command3.ExecuteReader()
                While reader3.Read()
                    Console.WriteLine("You should never hit this.")
                End While
            End Using
            transaction3.Commit()
        Catch ex As Exception
            Console.WriteLine("Expected timeout expired exception: " _
              & ex.Message)
            transaction3.Rollback()
        End Try
    End Using

    ' Open a fourth connection to AdventureWorks and
    ' initiate a fourth transaction to read from TestSnapshot
    ' using the ReadUncommitted isolation level. ReadUncommitted
    ' will not hit the table lock, and will allow a dirty read
    ' of the proposed new value 22. If the first transaction
    ' transaction rolls back, this value will never actually have
    ' existed in the database.
    Dim connection4 As SqlConnection = New SqlConnection(connectionString)
    Using connection4
        connection4.Open()
        Dim command4 As SqlCommand = connection4.CreateCommand()
        Dim transaction4 As SqlTransaction = _
          connection4.BeginTransaction(IsolationLevel.ReadUncommitted)
        command4.Transaction = transaction4
        command4.CommandText = _
            "SELECT ID, valueCol FROM TestSnapshot"
        Using reader4 As SqlDataReader = command4.ExecuteReader()
            While reader4.Read()
                Console.WriteLine("Expected 1,22 Actual " _
                  & reader4.GetValue(0).ToString() _
                  & "," + reader4.GetValue(1).ToString())
            End While
        End Using
        transaction4.Commit()

        ' Rollback transaction1
        transaction1.Rollback()
    End Using
End Using

' CLEANUP
' Drop TestSnapshot table and set
' ALLOW_SNAPSHOT_ISOLATION OFF for AdventureWorks
Dim connection5 As New SqlConnection(connectionString)
Using connection5
    connection5.Open()
    Dim command5 As SqlCommand = connection5.CreateCommand()
    command5.CommandText = "DROP TABLE TestSnapshot"
    Dim command6 As SqlCommand = connection5.CreateCommand()
    command6.CommandText = _
   "ALTER DATABASE AdventureWorks SET ALLOW_SNAPSHOT_ISOLATION OFF"
    Try
        command5.ExecuteNonQuery()
        command6.ExecuteNonQuery()
    Catch ex As Exception
        Console.WriteLine(ex.Message)
    End Try
End Using

Örnek

Aşağıdaki örnek, veriler değiştirilirken anlık görüntü yalıtımının davranışını gösterir. Kod aşağıdaki eylemleri gerçekleştirir:

  • Örnek veritabanına AdventureWorks bağlanır ve SNAPSHOT yalıtımı etkinleştirir.

  • adlı TestSnapshotUpdate bir tablo oluşturur ve üç satır örnek veri ekler.

  • sqlTransaction1 yalıtımı kullanılarak SNAPSHOT başlatılır, ancak tamamlanmaz. İşlemde üç veri satırı seçilir.

  • İkinci bir AdventureWorks ile SqlConnection oluşturur ve sqlTransaction1 yalıtım düzeyini kullanarak, READ COMMITTED içinde seçilen satırlardan birindeki bir değeri güncelleştiren ikinci bir işlem oluşturur.

  • Commit'ler sqlTransaction2.

  • sqlTransaction1 konumuna döner ve sqlTransaction1 tarafından zaten kaydedilmiş olan aynı satırı güncelleştirmeye çalışır. Hata 3960 oluşur ve sqlTransaction1 otomatik olarak geri alınır. SqlException.Number ve SqlException.Message, Konsol penceresinde görüntülenir.

  • AdventureWorks içinde anlık görüntü yalıtımını kapatmak ve TestSnapshotUpdate tablosunu silmek için temizleme kodunu yürütür.

// Assumes GetConnectionString returns a valid connection string
// where pooling is turned off by setting Pooling=False;.
var connectionString = GetConnectionString();
using (SqlConnection connection1 = new(connectionString))
{
    connection1.Open();
    SqlCommand command1 = connection1.CreateCommand();

    // Enable Snapshot isolation in AdventureWorks
    command1.CommandText =
        "ALTER DATABASE AdventureWorks SET ALLOW_SNAPSHOT_ISOLATION ON";
    try
    {
        command1.ExecuteNonQuery();
        Console.WriteLine(
            "Snapshot Isolation turned on in AdventureWorks.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"ALLOW_SNAPSHOT_ISOLATION ON failed: {ex.Message}");
    }
    // Create a table
    command1.CommandText =
        "IF EXISTS "
        + "(SELECT * FROM sys.tables "
        + "WHERE name=N'TestSnapshotUpdate')"
        + " DROP TABLE TestSnapshotUpdate";
    command1.ExecuteNonQuery();
    command1.CommandText =
        "CREATE TABLE TestSnapshotUpdate "
        + "(ID int primary key, CharCol nvarchar(100));";
    try
    {
        command1.ExecuteNonQuery();
        Console.WriteLine("TestSnapshotUpdate table created.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"CREATE TABLE failed: {ex.Message}");
    }
    // Insert some data
    command1.CommandText =
        "INSERT INTO TestSnapshotUpdate VALUES (1,N'abcdefg');"
        + "INSERT INTO TestSnapshotUpdate VALUES (2,N'hijklmn');"
        + "INSERT INTO TestSnapshotUpdate VALUES (3,N'opqrstuv');";
    try
    {
        command1.ExecuteNonQuery();
        Console.WriteLine("Data inserted TestSnapshotUpdate table.");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }

    // Begin, but do not complete, a transaction
    // using the Snapshot isolation level.
    SqlTransaction transaction1 = default!;
    try
    {
        transaction1 = connection1.BeginTransaction(IsolationLevel.Snapshot);
        command1.CommandText =
            "SELECT * FROM TestSnapshotUpdate WHERE ID BETWEEN 1 AND 3";
        command1.Transaction = transaction1;
        command1.ExecuteNonQuery();
        Console.WriteLine("Snapshot transaction1 started.");

        // Open a second Connection/Transaction to update data
        // using ReadCommitted. This transaction should succeed.
        using (SqlConnection connection2 = new(connectionString))
        {
            connection2.Open();
            SqlCommand command2 = connection2.CreateCommand();
            command2.CommandText = "UPDATE TestSnapshotUpdate SET CharCol="
                + "N'New value from Connection2' WHERE ID=1";
            SqlTransaction transaction2 =
                connection2.BeginTransaction(IsolationLevel.ReadCommitted);
            command2.Transaction = transaction2;
            try
            {
                command2.ExecuteNonQuery();
                transaction2.Commit();
                Console.WriteLine(
                    "transaction2 has modified data and committed.");
            }
            catch (SqlException ex)
            {
                Console.WriteLine(ex.Message);
                transaction2.Rollback();
            }
            finally
            {
                transaction2.Dispose();
            }
        }

        // Now try to update a row in Connection1/Transaction1.
        // This transaction should fail because Transaction2
        // succeeded in modifying the data.
        command1.CommandText =
            "UPDATE TestSnapshotUpdate SET CharCol="
            + "N'New value from Connection1' WHERE ID=1";
        command1.Transaction = transaction1;
        command1.ExecuteNonQuery();
        transaction1.Commit();
        Console.WriteLine("You should never see this.");
    }
    catch (SqlException ex)
    {
        Console.WriteLine("Expected failure for transaction1:");
        Console.WriteLine($"  {ex.Number}: {ex.Message}");
    }
    finally
    {
        transaction1.Dispose();
    }
}

// CLEANUP:
// Turn off Snapshot isolation and delete the table
using (SqlConnection connection3 = new(connectionString))
{
    connection3.Open();
    SqlCommand command3 = connection3.CreateCommand();
    command3.CommandText =
        "ALTER DATABASE AdventureWorks SET ALLOW_SNAPSHOT_ISOLATION OFF";
    try
    {
        command3.ExecuteNonQuery();
        Console.WriteLine(
            "CLEANUP: Snapshot isolation turned off in AdventureWorks.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"CLEANUP FAILED: {ex.Message}");
    }
    command3.CommandText = "DROP TABLE TestSnapshotUpdate";
    try
    {
        command3.ExecuteNonQuery();
        Console.WriteLine("CLEANUP: TestSnapshotUpdate table deleted.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"CLEANUP FAILED: {ex.Message}");
    }
}
' Assumes GetConnectionString returns a valid connection string
' where pooling is turned off by setting Pooling=False;.
Dim connectionString As String = GetConnectionString()

Using connection1 As New SqlConnection(connectionString)
    ' Enable Snapshot isolation in AdventureWorks
    connection1.Open()
    Dim command1 As SqlCommand = connection1.CreateCommand
    command1.CommandText = _
   "ALTER DATABASE AdventureWorks SET ALLOW_SNAPSHOT_ISOLATION ON;"
    Try
        command1.ExecuteNonQuery()
        Console.WriteLine( _
         "Snapshot Isolation turned on in AdventureWorks.")
    Catch ex As Exception
        Console.WriteLine("ALLOW_SNAPSHOT_ISOLATION failed: {0}", ex.Message)
    End Try

    ' Create a table
    command1.CommandText = _
      "IF EXISTS (SELECT * FROM sys.databases " _
      & "WHERE name=N'TestSnapshotUpdate') " _
      & "DROP TABLE TestSnapshotUpdate"
    command1.ExecuteNonQuery()
    command1.CommandText = _
      "CREATE TABLE TestSnapshotUpdate (ID int primary key, " _
      & "CharCol nvarchar(100));"
    Try
        command1.ExecuteNonQuery()
        Console.WriteLine("TestSnapshotUpdate table created.")
    Catch ex As Exception
        Console.WriteLine("CREATE TABLE failed: {0}", ex.Message)
    End Try

    ' Insert some data
    command1.CommandText = _
      "INSERT INTO TestSnapshotUpdate VALUES (1,N'abcdefg');" _
      & "INSERT INTO TestSnapshotUpdate VALUES (2,N'hijklmn');" _
      & "INSERT INTO TestSnapshotUpdate VALUES (3,N'opqrstuv');"
    Try
        command1.ExecuteNonQuery()
        Console.WriteLine("Data inserted TestSnapshotUpdate table.")
    Catch ex As Exception
        Console.WriteLine(ex.Message)
    End Try

    ' Begin, but do not complete, a transaction
    ' using the Snapshot isolation level
    Dim transaction1 As SqlTransaction = Nothing
    Try
        transaction1 = connection1.BeginTransaction(IsolationLevel.Snapshot)
        command1.CommandText = _
          "SELECT * FROM TestSnapshotUpdate WHERE ID " _
          & "BETWEEN 1 AND 3"
        command1.Transaction = transaction1
        command1.ExecuteNonQuery()
        Console.WriteLine("Snapshot transaction1 started.")

        ' Open a second Connection/Transaction to update data
        ' using ReadCommitted. This transaction should succeed.
        Dim connection2 As SqlConnection = New SqlConnection(connectionString)
        Using connection2
            connection2.Open()
            Dim command2 As SqlCommand = connection2.CreateCommand()
            command2.CommandText = "UPDATE TestSnapshotUpdate SET " _
              & "CharCol=N'New value from Connection2' WHERE ID=1"
            Dim transaction2 As SqlTransaction = _
              connection2.BeginTransaction(IsolationLevel.ReadCommitted)
            command2.Transaction = transaction2
            Try
                command2.ExecuteNonQuery()
                transaction2.Commit()
                Console.WriteLine( _
                  "transaction2 has modified data and committed.")
            Catch ex As SqlException
                Console.WriteLine(ex.Message)
                transaction2.Rollback()
            Finally
                transaction2.Dispose()
            End Try
        End Using

        ' Now try to update a row in Connection1/Transaction1.
        ' This transaction should fail because Transaction2
        ' succeeded in modifying the data.
        command1.CommandText = _
          "UPDATE TestSnapshotUpdate SET CharCol=" _
            & "N'New value from Connection1' WHERE ID=1"
        command1.Transaction = transaction1
        command1.ExecuteNonQuery()
        transaction1.Commit()
        Console.WriteLine("You should never see this.")

    Catch ex As SqlException
        Console.WriteLine("Expected failure for transaction1:")
        Console.WriteLine("  {0}: {1}", ex.Number, ex.Message)
    Finally
        transaction1.Dispose()
    End Try
End Using

' CLEANUP:
' Turn off Snapshot isolation and delete the table
Dim connection3 As New SqlConnection(connectionString)
Using connection3
    connection3.Open()
    Dim command3 As SqlCommand = connection3.CreateCommand()
    command3.CommandText = _
  "ALTER DATABASE AdventureWorks SET ALLOW_SNAPSHOT_ISOLATION OFF"
    Try
        command3.ExecuteNonQuery()
        Console.WriteLine( _
         "Snapshot isolation turned off in AdventureWorks.")
    Catch ex As Exception
        Console.WriteLine("CLEANUP FAILED: {0}", ex.Message)
    End Try

    command3.CommandText = "DROP TABLE TestSnapshotUpdate"
    Try
        command3.ExecuteNonQuery()
        Console.WriteLine("TestSnapshotUpdate table deleted.")
    Catch ex As Exception
        Console.WriteLine("CLEANUP FAILED: {0}", ex.Message)
    End Try
End Using

Anlık Görüntü Yalıtımı ile Kilitleme İpuçlarını Kullanma

Önceki örnekte, ilk işlem verileri seçer ve ikinci bir işlem ilk işlem tamamlanmadan önce verileri güncelleştirir ve ilk işlem aynı satırı güncelleştirmeye çalıştığında güncelleştirme çakışmasına neden olur. İşlemin başında kilit ipuçları sağlayarak uzun süre çalışan anlık görüntü işlemlerinde güncelleştirme çakışmaları olasılığını azaltabilirsiniz. Aşağıdaki SELECT deyim, seçili satırları kilitlemek için UPDLOCK ipucunu kullanır:

SELECT * FROM TestSnapshotUpdate WITH (UPDLOCK)
  WHERE PriKey BETWEEN 1 AND 3

UPDLOCK kilit ipucunun kullanılması, ilk işlemin tamamlanmasından önce bu satırları güncellemeye çalışan tüm satırları engeller. Bu, seçilen satırların işlemde daha sonra güncelleştirildiğinde çakışma olmamasını garanti eder. Daha fazla bilgi için bkz. İpuçları (Transact-SQL).

Uygulamanızın birçok çakışması varsa, anlık görüntü yalıtımı en iyi seçenek olmayabilir. İpuçları yalnızca gerçekten gerektiğinde kullanılmalıdır. Uygulamanız, işlemi için sürekli kilit ipuçlarına dayalı olacak şekilde tasarlanmamalıdır.

Ayrıca bkz.