Supporto delle transazioni locali

Una sessione delimita l'ambito della transazione per una transazione locale del provider OLE DB di SQL Server Native Client. Quando, nella direzione di un consumer, il provider OLE DB di SQL Server Native Client invia una richiesta a un'istanza connessa di SQL Server, la richiesta costituisce un'unità di lavoro per il provider OLE DB di SQL Server Native Client. Le transazioni locali eseguono sempre il wrapping di una o più unità di lavoro in una singola sessione del provider OLE DB di SQL Server Native Client.

Usando la modalità di commit automatica del provider OLE DB di SQL Server Native Client predefinita, una singola unità di lavoro viene considerata come ambito di una transazione locale. Una sola unità partecipa alla transazione locale. Quando viene creata una sessione, il provider OLE DB di SQL Server Native Client avvia una transazione per la sessione. Al completamento di un'unità di lavoro, viene eseguito il commit del lavoro. In caso di errore, viene eseguito il rollback di qualsiasi lavoro avviato e l'errore viene segnalato al consumer. In entrambi i casi, il provider OLE DB di SQL Server Native Client avvia una nuova transazione locale per la sessione in modo che tutto il lavoro venga eseguito all'interno di una transazione.

Il consumer del provider OLE DB di SQL Server Native Client può indirizzare un controllo più preciso sull'ambito delle transazioni locali tramite l'interfaccia ITransactionLocal . Quando una sessione consumer avvia una transazione, tutte le unità di lavoro della sessione tra il punto di inizio della transazione e le chiamate al metodo Commit o Abort finale vengono considerate come un'unità atomica. Il provider OLE DB di SQL Server Native Client avvia in modo implicito una transazione quando viene indirizzata a tale operazione dal consumer. Se il consumer non richiede la conservazione, la sessione ripristina il comportamento a livello di transazione padre, in genere la modalità autocommit.

Il provider OLE DB di SQL Server Native Client supporta i parametri ITransactionLocal::StartTransaction come indicato di seguito.

Per le transazioni locali, il provider OLE DB di SQL Server Native Client implementa i parametri ITransaction::Abort come indicato di seguito.

Per le transazioni locali, il provider OLE DB di SQL Server Native Client implementa i parametri ITransaction::Commit come indicato di seguito.

I set di righe del provider OLE DB di SQL Server Native Client nella sessione vengono mantenuti in un'operazione di commit o interruzione locale in base ai valori delle proprietà del set di righe DBPROP_ABORTPRESERVE e DBPROP_COMMITPRESERVE. Per impostazione predefinita, queste proprietà sono entrambe VARIANT_FALSE e tutti i set di righe del provider OLE DB di SQL Server Native Client nella sessione vengono persi dopo un'operazione di interruzione o commit.

Il provider OLE DB di SQL Server Native Client non implementa l'interfaccia ITransactionObject . Un tentativo di recupero di un riferimento nell'interfaccia restituisce E_NOINTERFACE.

Questo esempio usa 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.  

Vedere anche

Transazioni
Uso dell'isolamento dello snapshot