Ondersteuning van lokale transacties in de native client van SQL Server

Van toepassing op:SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse Analytics

Een sessie begrenst de transactiescope voor een lokale transactie van een SQL Server Native Client OLE DB-provider. Wanneer de SQL Server Native Client OLE DB-provider op aanwijzing van een consument een verzoek indient bij een verbonden instantie van SQL Server, vormt het verzoek een werkunit voor de SQL Server Native Client OLE DB-provider. Lokale transacties verpakken altijd één of meer eenheden van werk op één SQL Server Native Client OLE DB provider-sessie.

Met de standaard autocommit-modus van SQL Server Native Client OLE DB provider wordt één eenheid werk behandeld als de scope van een lokale transactie. Slechts één eenheid neemt deel aan de lokale transactie. Wanneer een sessie wordt aangemaakt, start de SQL Server Native Client OLE DB-provider een transactie voor de sessie. Na succesvolle voltooiing van een werkunit wordt het werk uitgevoerd. Bij een storing wordt elk begonnen werk teruggedraaid en wordt de fout aan de consument gemeld. In beide gevallen start de SQL Server Native Client OLE DB-provider een nieuwe lokale transactie voor de sessie, zodat al het werk binnen een transactie wordt uitgevoerd.

De consument van de SQL Server Native Client OLE DB-provider kan nauwkeuriger controle uitoefenen over de lokale transactiescope door gebruik te maken van de ITransactionLocal-interface. Wanneer een consumentensessie een transactie initieert, worden alle sessiewerkunits tussen het transactiestartpunt en de uiteindelijke commit- of abort-methodeaanroepen behandeld als een atomaire eenheid. De SQL Server Native Client OLE DB-provider start impliciet een transactie wanneer de consument daartoe wordt opgedragen. Als de consument geen retentie aanvraagt, keert de sessie terug naar ouderlijk transactieniveau, meestal autocommit-modus.

De SQL Server Native Client OLE DB-provider ondersteunt ITransactionLocal::StartTransaction-parameters als volgt.

Voor lokale transacties implementeert de SQL Server Native Client OLE DB-provider de parameters ITransaction:::Abort als volgt.

Voor lokale transacties implementeert de SQL Server Native Client OLE DB-provider de parameters ITransaction:::Commit als volgt.

De SQL Server Native Client OLE DB-provider-rijsets op de sessie worden bewaard tijdens een lokale commit- of abort-operatie op basis van de waarden van de rijset-eigenschappen DBPROP_ABORTPRESERVE en DBPROP_COMMITPRESERVE. Standaard zijn deze eigenschappen beide VARIANT_FALSE en gaan alle rijsets SQL Server Native Client OLE DB-provider in de sessie verloren na een abort- of commit-operatie.

De SQL Server Native Client OLE DB-provider implementeert de ITransactionObject-interface niet. Een poging van de consument om een referentie op de interface op te halen levert E_NOINTERFACE op.

Dit voorbeeld gebruikt ITransactionLocal.

// Interfaces used in the example.  
IDBCreateSession*   pIDBCreateSession   = NULL;  
ITransaction*       pITransaction       = NULL;  
IDBCreateCommand*   pIDBCreateCommand   = NULL;  
IRowset*            pIRowset            = NULL;  
  
HRESULT             hr;  
  
// Get the command creation and local transaction interfaces for the  
// session.  
if (FAILED(hr = pIDBCreateSession->CreateSession(NULL,  
     IID_IDBCreateCommand, (IUnknown**) &pIDBCreateCommand)))  
    {  
    // Process error from session creation. Release any references and  
    // return.  
    }  
  
if (FAILED(hr = pIDBCreateCommand->QueryInterface(IID_ITransactionLocal,  
    (void**) &pITransaction)))  
    {  
    // Process error. Release any references and return.  
    }  
  
// Start the local transaction.  
if (FAILED(hr = ((ITransactionLocal*) pITransaction)->StartTransaction(  
    ISOLATIONLEVEL_REPEATABLEREAD, 0, NULL, NULL)))  
    {  
    // Process error from StartTransaction. Release any references and  
    // return.  
    }  
  
// Get data into a rowset, then update the data. Functions are not  
// illustrated in this example.  
if (FAILED(hr = ExecuteCommand(pIDBCreateCommand, &pIRowset)))  
    {  
    // Release any references and return.  
    }  
  
// If rowset data update fails, then terminate the transaction, else  
// commit. The example doesn't retain the rowset.  
if (FAILED(hr = UpdateDataInRowset(pIRowset, bDelayedUpdate)))  
    {  
    // Get error from update, then terminate.  
    pITransaction->Abort(NULL, FALSE, FALSE);  
    }  
else  
    {  
    if (FAILED(hr = pITransaction->Commit(FALSE, XACTTC_SYNC, 0)))  
        {  
        // Get error from failed commit.  
        }  
    }  
  
if (FAILED(hr))  
    {  
    // Update of data or commit failed. Release any references and  
    // return.  
    }  
  
// Release any references and continue.  

Verwante onderwerpen

• Transacties in SQL Server Native Client
• Werken met Snapshot Isolation in SQL Server Native Client