Compilazione di applicazioni in cui viene utilizzato il rilevamento delle modifiche (SQL Server Compact)

A partire da SQL Server Compact 3.5 Service Pack 2 (SP2), in SQL Server Compact è disponibile un'interfaccia per l'infrastruttura di rilevamento delle modifiche. Dopo aver abilitato il rilevamento in una tabella di un database di SQL Server Compact, le modifiche apportate alla tabella, ovvero inserimenti, aggiornamenti ed eliminazioni, vengono rilevate da SQL Server Compact. Tale operazione è anche nota come rilevamento delle modifiche. I dati forniti dal rilevamento delle modifiche possono essere utilizzati per compilare diverse applicazioni potenti. Ad esempio, tali dati possono essere utilizzati per compilare applicazioni tramite cui vengono forniti servizi di sincronizzazione per i sistemi connessi occasionalmente (OCS, Occasionally Connected Systems) nei quali dispositivi o computer devono connettersi e sincronizzare i dati con un server o con altri peer di una rete.

In generale, SQL Server Compact implementa il rilevamento delle modifiche effettuando le operazioni seguenti:

• Aggiunta di tre colonne di sistema alle tabelle utente nelle quali è abilitato il rilevamento.

• Creazione di tre tabelle di sistema per l'archiviazione di metadati specifici del rilevamento.

• Archiviazione di metadati del rilevamento nelle colonne di sistema aggiunte a una tabella utente con rilevamento.

• Archiviazione di metadati del rilevamento nelle tabelle di sistema.

• Esposizione del controllo dell'infrastruttura di rilevamento allo sviluppatore tramite classi nuove e aggiunte alle classi esistenti nello spazio dei nomi System.Data.SqlServerCe.

Nelle sezioni restanti di questo argomento sono fornite informazioni utili per sviluppare applicazioni compilate per utilizzare il rilevamento delle modifiche.

Numeri di sequenza della transazione

In SQL Server Compact vengono utilizzati due numeri per identificare la sequenza di inizio e di commit delle transazioni (implicite o esplicite) che consentono di inserire, aggiornare o eliminare dati da una tabella o da un set di tabelle.

• Il numero di sequenza di inizio (BSN) è un contatore a incremento progressivo che identifica in modo univoco la sequenza di inizio delle transazioni nel database. Viene assegnato da SQL Server Compact all'inizio di una transazione e viene incrementato per l'inizio della transazione successiva.

• Il numero di sequenza del commit (CSN) è un contatore a incremento progressivo che identifica in modo univoco la sequenza di esecuzione del commit delle transazioni nel database. Viene assegnato dal database in occasione del commit di una transazione e incrementato per il commit della transazione successiva.

I numeri BSN e CSN identificano in modo univoco la sequenza di inizio e di commit di una transazione specifica rispetto alle altre transazioni in funzione nel database di SQL Server Compact.

Colonne aggiunte alle tabelle con rilevamento (metadati all'interno di righe)

Quando il rilevamento è abilitato in una tabella utente, SQL Server Compact consente di aggiungere 3 colonne alla tabella. Inoltre consente di archiviare i metadati sulle modifiche applicate a ogni riga in due di queste colonne; la terza colonna può essere utilizzata facoltativamente per archiviare le informazioni sul contesto specifiche dell'applicazione. Quando il rilevamento è disabilitato, le colonne vengono eliminate.

Nella tabella seguente vengono descritte le colonne aggiunte per mantenere questi metadati all'interno di righe.

In caso di eliminazioni, oltre a consentire di eliminare la riga dalla tabella, SQL Server Compact permette di aggiungere una riga contenente le informazioni sulla riga eliminata alla tabella tombstone.

Tabelle di sistema

Le tabelle di sistema seguenti vengono utilizzate nel rilevamento delle modifiche.

Tabella tombstone

Quando una riga viene eliminata da una tabella in cui è abilitato il rilevamento, viene creato un record nella tabella tombstone (__sysOCSDeletedRows). Nel database è disponibile una sola tabella tombstone contenente le informazioni sulle righe eliminate da una qualsiasi delle tabelle con rilevamento del database. Nella tabella seguente vengono descritte le colonne della tabella tombstone.

La chiave della riga può essere costituita da una singola colonna della tabella utente nel caso di una chiave primaria a colonna singola o della colonna ROWGUID oppure può contenere più colonne con tipi di dati diversi se la chiave primaria è costituita da più colonne. Per questo motivo, la chiave della riga viene archiviata in un formato serializzato nella tabella tombstone. È possibile utilizzare i metodi PackTombstoneKey e UnpackTombstoneKey per eseguire la conversione da e in questo formato serializzato. Il tipo di chiave viene impostato sulla tabella utente (chiave primaria o colonna ROWGUID) utilizzata dal sistema di rilevamento passando uno dei valori dell'enumerazione TrackingKeyType come parametro al metodo EnableTracking per abilitare il rilevamento nella tabella.

Nel tempo, le dimensioni della tabella tombstone possono diventare piuttosto grandi. Per eliminare righe dalla tabella, è possibile utilizzare il metodo PurgeTombstoneTableData. Le righe possono essere eliminate dalla tabella tombstone in base al numero di giorni trascorsi dalla relativa eliminazione dalla tabella utente (eliminazione basata sul tempo) oppure in base al CSN della transazione tramite cui sono state eliminate (eliminazione basata su CSN).

Tabella della sequenza di commit della transazione

Il commit delle transazioni può essere eseguito in ordine diverso rispetto a quello di inizio (commit non in sequenza). Nella tabella della sequenza di commit (__sysTxCommitSequence) si tiene traccia di queste transazioni non in sequenza. Una riga viene inserita in questa tabella durante il commit di una transazione qualora sia in corso un'operazione di commit non in sequenza da parte della transazione stessa. Nella tabella seguente vengono descritte le colonne della tabella della sequenza di commit della transazione.

Nell'esempio seguente viene mostrata la modalità di inserimento delle transazioni nella tabella della sequenza di commit della transazione.

Considerare cinque transazioni, ovvero T1, T2, T3, T4 e T5.

Per queste transazioni sono vere le condizioni seguenti:

La sequenza di inizio della transazione (ordine di avvio) è: T1, T2, T3, T4, T5.

La sequenza di commit della transazione (ordine di commit) è: T1, T3, T4, T2, T5.

Si presupponga che il CSN e il BSN per questo gruppo di transazioni inizino da 1. Nella tabella seguente vengono descritti i numeri CSN e BSN per ogni transazione e viene indicato se nella tabella della sequenza del commit della transazione viene inserita una voce per la transazione.

Nel tempo, le dimensioni della tabella della sequenza di commit della transazione possono diventare piuttosto grandi. Per eliminare righe da questa tabella di sistema, è possibile utilizzare il metodo PurgeTransactionSequenceData. Le righe possono essere eliminate dalla tabella in base al numero di giorni trascorsi dalla relativa aggiunta (eliminazione basata sul tempo) oppure in base al CSN della transazione (eliminazione basata sul CSN).

Enumerazione delle modifiche apportate a una tabella

Nelle query presenti in questa sezione vengono forniti esempi relativi alla modalità di enumerazione delle modifiche apportate a una tabella. Il nome della tabella per la quale enumerare le modifiche viene passato nel parametro {0} di ogni query.

Vengono definiti anche i parametri seguenti:

• EBSN: numero di sequenza di inizio dell'enumerazione, ovvero il BSN della transazione finalizzata poco prima dell'inizio dell'enumerazione delle modifiche da parte della sincronizzazione. Questo valore viene utilizzato per evitare di scegliere qualsiasi modifica apportata alla tabella durante l'enumerazione. 

• ECSN: numero di sequenza del commit dell'enumerazione, ovvero il CSN della transazione finalizzata poco prima dell'inizio dell'enumerazione delle modifiche da parte della sincronizzazione. Questo valore viene utilizzato per evitare di scegliere qualsiasi modifica apportata alla tabella durante l'enumerazione. 

• LBSN: numero di sequenza di inizio dell'ultima sincronizzazione, ovvero l'EBSN dell'ultima sincronizzazione riuscita.

• LCSN: numero di sequenza del commit dell'ultima sincronizzazione, ovvero l'ECSN dell'ultima sincronizzazione riuscita.

La query seguente consente di enumerare gli inserimenti:

        private const string cmdEnumerateInserts =
            " select ut.* from " + 
            "   (select ut0.* from {0} as ut0 where " + 
            "     ut0.__sysInsertTxBsn IS NOT NULL AND ut0.__sysChangeTxBsn IS NOT NULL AND ut0.__sysChangeTxBsn >= @LBSN " + 
            "   ) as ut " + 
            " LEFT OUTER JOIN " + 
            "   (select txcs0.* from __sysTxCommitSequence as txcs0) as txcs " + 
            " ON (ut.__sysInsertTxBsn = txcs.__sysTxBsn) WHERE " +
            "      (txcs.__sysTxBsn IS NOT NULL and txcs.__sysTxCsn >= @LCSN AND txcs.__sysTxCsn < @ECSN) OR  " + 
            "      (txcs.__sysTxBsn IS NULL AND ut.__sysInsertTxBsn >= @LCSN AND ut.__sysInsertTxBsn < @ECSN)";

La query seguente consente di enumerare gli aggiornamenti:

        private const string cmdEnumerateUpdates =
            " SELECT ut.* FROM " +  
            "   (select ut0.* from {0} as ut0 where " + 
            "     (ut0.__sysChangeTxBsn IS NOT NULL AND ut0.__sysChangeTxBsn >= @LBSN) " + 
            "   ) as ut " + 
            " LEFT OUTER JOIN" + 
            "   (select txcs0.* from __sysTxCommitSequence as txcs0) as txcs " + 
            " ON ut.__sysChangeTxBsn = txcs.__sysTxBsn OR txcs.__sysTxBsn IS NULL WHERE " + 
            "   (txcs.__sysTxBsn IS NOT NULL AND txcs.__sysTxCsn >= @LCSN AND txcs.__sysTxCsn < @ECSN) OR " + 
            "   (txcs.__sysTxBsn IS NULL AND ut.__sysChangeTxBsn >= @LCSN AND ut.__sysChangeTxBsn < @ECSN) ";

La query seguente consente di enumerare le eliminazioni:

        private const string cmdEnumerateDeletes =
            " SELECT ut.__sysRK  FROM " +
            "   (select ut0.* from __sysOcsDeletedRows as ut0 where " +
            "     (ut0.__sysInsertTxCsn IS NULL OR ut0.__sysInsertTxCsn < @LCSN) and " + // Filter INSERT + DELETE 
            "     ut0.__sysTName = \'{0}\'" + 
            "   ) AS ut " +
            " LEFT OUTER JOIN  " +
            "   (select txcs0.* from __sysTxCommitSequence as txcs0) as txcs " + 
            " ON ut.__sysDeleteTxBsn = txcs.__sysTxBsn OR txcs.__sysTxBsn IS NULL WHERE " + 
            "   (txcs.__sysTxBsn IS NOT NULL AND txcs.__sysTxCsn >= @LCSN AND txcs.__sysTxCsn < @ECSN) OR " + 
            "   (txcs.__sysTxBsn IS NULL AND ut.__sysDeleteTxBsn >= @LCSN AND ut.__sysDeleteTxBsn < @ECSN) ";

Controllo a livello di programmazione del rilevamento delle modifiche

È possibile utilizzare classi, metodi e proprietà nuovi aggiunti alle classi esistenti nello spazio dei nomi System.Data.SqlServerCe per configurare e controllare il rilevamento delle modifiche nei database di SQL Server Compact. Nella tabella seguente viene fornita una breve panoramica di questi nuovi elementi.

Vedere anche

Riferimento

System.Data.SqlServerCe

SqlCeChangeTracking