Prise en charge des transactions locales

Une session délimite l’étendue de transaction d’une transaction locale du fournisseur OLE DB SQL Server Native Client. Lorsque, dans la direction d’un consommateur, le fournisseur OLE DB SQL Server Native Client envoie une demande à une instance connectée de SQL Server, la demande constitue une unité de travail pour le fournisseur OLE DB SQL Server Native Client. Les transactions locales encapsulent toujours une ou plusieurs unités de travail sur une session de fournisseur OLE DB SQL Server Native Client unique.

À l’aide du mode de validation automatique du fournisseur OLE DB SQL Server Native Client par défaut, une seule unité de travail est traitée comme l’étendue d’une transaction locale. Une seule unité participe à la transaction locale. Lorsqu’une session est créée, le fournisseur OLE DB SQL Server Native Client commence une transaction pour la session. À la fin d’une unité de travail, le travail est validé. En cas d’échec, tout travail commencé est restauré et l’erreur est signalée au consommateur. Dans les deux cas, le fournisseur OLE DB SQL Server Native Client commence une nouvelle transaction locale pour la session afin que tout le travail soit effectué dans une transaction.

Le consommateur du fournisseur OLE DB SQL Server Native Client peut diriger un contrôle plus précis sur l’étendue de transaction locale à l’aide de l’interface ITransactionLocal . Lorsqu’une session consommateur lance une transaction, toutes les unités de travail de session entre le point de départ de la transaction et les appels de méthode Commit ou Abort éventuels sont traités comme une unité atomique. Le fournisseur OLE DB SQL Server Native Client commence implicitement une transaction lorsqu’il est dirigé vers le consommateur. Si le consommateur ne demande pas de rétention, la session revient au comportement de niveau transactionnel parent, le mode de validation automatique le plus souvent.

Le fournisseur OLE DB SQL Server Native Client prend en charge les paramètres ITransactionLocal ::StartTransaction comme suit.

Pour les transactions locales, le fournisseur OLE DB SQL Server Native Client implémente les paramètres ITransaction ::Abort comme suit.

Pour les transactions locales, le fournisseur OLE DB SQL Server Native Client implémente les paramètres ITransaction ::Commit comme suit.

Les ensembles de lignes du fournisseur OLE DB SQL Server Native Client sur la session sont conservés sur une opération de validation ou d’abandon locale en fonction des valeurs des propriétés de l’ensemble de lignes DBPROP_ABORTPRESERVE et DBPROP_COMMITPRESERVE. Par défaut, ces propriétés sont à la fois VARIANT_FALSE et tous les ensembles de lignes du fournisseur OLE DB SQL Server Native Client sur la session sont perdus après une opération d’abandon ou de validation.

Le fournisseur OLE DB SQL Server Native Client n’implémente pas l’interface ITransactionObject . Une tentative de récupération d’une référence sur l’interface retourne E_NOINTERFACE.

Cet exemple utilise 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.  

Voir aussi

Transactions
Utilisation de l’isolation des instantanés