Prise en charge des transactions locales dans SQL Server Native Client

S’applique à : SQL Server Azure SQL Database Azure SQL Managed Instance Azure Synapse Analytics Analytics Platform System (PDW)

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. Une fois que l'unité de travail a été exécutée avec succès, le travail est validé. En cas d'échec, tout travail commencé est annulé 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 de consommateur démarre une transaction, toutes les unités de travail de la session entre le point de départ de la transaction et les appels éventuels de la méthode Commit ou Abort 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 la rétention, la session revient au comportement parent du niveau de la transaction, soit le plus généralement le mode de validation automatique.

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 . La tentative d'un consommateur pour extraire une référence sur l'interface retourne E_NOINTERFACE.

L’exemple suivant 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 du niveau d’isolement de capture instantanée