Dela via

Läs in data stegvis från Azure SQL Database till Azure Blob Storage med hjälp av information om ändringsspårning med hjälp av PowerShell

  • Artikel

GÄLLER FÖR: Azure Data Factory Azure Synapse Analytics

Dricks

Prova Data Factory i Microsoft Fabric, en allt-i-ett-analyslösning för företag. Microsoft Fabric omfattar allt från dataflytt till datavetenskap, realtidsanalys, business intelligence och rapportering. Lär dig hur du startar en ny utvärderingsversion kostnadsfritt!

I den här självstudien skapar du en Azure-datafabrik med en pipeline som läser in deltadata baserat på information om ändringsspårning i källdatabasen i Azure SQL Database till en Azure Blob Storage.

I de här självstudierna går du igenom följande steg:

  • Förbereda källdatalagret
  • Skapa en datafabrik.
  • Skapa länkade tjänster.
  • Skapa datamängder för källa, mottagare och spårning av ändringar.
  • Skapa, kör och övervaka den fullständiga kopieringspipelinen
  • Lägga till eller uppdatera data i källtabellen
  • Skapa, kör och övervaka den inkrementella kopieringspipelinen

Kommentar

Vi rekommenderar att du använder Azure Az PowerShell-modulen för att interagera med Azure. Information om hur du kommer igång finns i Installera Azure PowerShell. Information om hur du migrerar till Az PowerShell-modulen finns i artikeln om att migrera Azure PowerShell från AzureRM till Az.

Översikt

I en dataintegrationslösning är stegvis inläsning av data efter den första datainläsningen ett vanligt scenario. I vissa fall kan ändrade data inom en period i ditt källdatalager enkelt delas upp (till exempel LastModifyTime, CreationTime). I vissa fall finns det inget uttryckligt sätt att identifiera deltadata från förra gången du bearbetade data. Tekniken för Ändringsspårning som stöds av datakällor som Azure SQL Database och SQL Server kan användas för att identifiera deltadata. I den här självstudien beskrivs hur du använder Azure Data Factory med SQL-ändringsspårningstekniken för att inkrementellt läsa in deltadata från Azure SQL Database till Azure Blob Storage. Mer konkret information om SQL-ändringsspårningstekniken finns i Change tracking in SQL Server (Ändringsspårning i SQL Server).

Arbetsflödet slutpunkt till slutpunkt

Här följer de typiska arbetsflödesstegen från slutpunkt till slutpunkt för att stegvis läsa in data med ändringsspårningstekniken.

Kommentar

Både Azure SQL Database och SQL Server stöder ändringsspårningsteknik. I den här självstudien används Azure SQL Database som källdatalager. Du kan också använda en SQL Server-instans.

  1. Inledande inläsning av historiska data (körs en gång):
    1. Aktivera teknik för ändringsspårning i källdatabasen i Azure SQL Database.
    2. Hämta det ursprungliga värdet för SYS_CHANGE_VERSION i databasen som baslinje för att samla in ändrade data.
    3. Läs in fullständiga data från källdatabasen till en Azure-bloblagring.
  2. Inkrementell inläsning av deltadata enligt ett schema (körs regelbundet efter den första inläsningen av data):
    1. Hämta de gamla och nya SYS_CHANGE_VERSION-värdena.
    2. Läs in deltadata genom att ansluta till primärnycklarna för de ändrade raderna (mellan två SYS_CHANGE_VERSION-värden) från sys.change_tracking_tables med data i källtabellen och flytta sedan deltadata till målet.
    3. Uppdatera SYS_CHANGE_VERSION för deltainläsning nästa gång.

Lösning på hög nivå

I den här självstudien skapar du två pipelines som utför följande två åtgärder:

  1. Inledande inläsning: du skapar en pipeline med en kopieringsaktivitet som kopierar alla data från källdatalagret (Azure SQL Database) till måldatalagret (Azure Blob Storage).

    Fullständig inläsning av data

  2. Stegvis inläsning: du skapar en pipeline med följande aktiviteter och kör den med jämna mellanrum.

    1. Skapa två lookupaktiviteter för att hämta den nya och gamla SYS_CHANGE_VERSION från Azure SQL Database och skicka den till kopieringsaktiviteten.
    2. Skapa en kopieringsaktivitet för att kopiera de infogade/uppdaterade/borttagna data mellan de två SYS_CHANGE_VERSION-värdena från Azure SQL Database till Azure Blob Storage.
    3. Skapa en lagrad proceduraktivitet för att uppdatera värdet för SYS_CHANGE_VERSION för nästa pipelinekörning.

    Steg för att läsa in flödesdiagram

Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

Förutsättningar

  • Azure PowerShell. Installera de senaste Azure PowerShell-modulerna enligt instruktionerna i Installera och konfigurera Azure PowerShell.
  • Azure SQL Database. Du använder databasen som källa för datalagringen. Om du inte har någon databas i Azure SQL Database kan du läsa artikeln Skapa en databas i Azure SQL Database för steg för att skapa en.
  • Azure Storage-konto. Du kan använda blob-lagringen som mottagare för datalagringen. Om du inte har ett Azure Storage-konto finns det anvisningar om hur du skapar ett i artikeln Skapa ett lagringskonto . Skapa en container med namnet adftutorial.

Skapa en datakällatabell i databasen

  1. Starta SQL Server Management Studio och anslut till SQL Database.

  2. I Server Explorer högerklickar du på databasen och väljer Ny fråga.

  3. Kör följande SQL-kommando mot databasen för att skapa en tabell med namnet data_source_table datakällslager.

    create table data_source_table
(
    PersonID int NOT NULL,
    Name varchar(255),
    Age int
    PRIMARY KEY (PersonID)
);

INSERT INTO data_source_table
    (PersonID, Name, Age)
VALUES
    (1, 'aaaa', 21),
    (2, 'bbbb', 24),
    (3, 'cccc', 20),
    (4, 'dddd', 26),
    (5, 'eeee', 22);

  4. Aktivera mekanismen för ändringsspårning på din databas och källtabellen (data_source_table) genom att köra följande SQL-fråga:

    Kommentar

    • Ersätt <databasnamnet> med namnet på databasen som har data_source_table.
    • Ändrade data sparas i två dagar i det aktuella exemplet. Om du läser in ändrade data ungefär var tredje dag eller oftare inkluderas inte en del ändrade data. Du måste antingen ändra värdet för CHANGE_RETENTION till ett större antal. Du kan också se till att din period för att läsa in ändrade data är inom två dagar. Mer information finns i Enable change tracking for a database (Aktivera ändringsspårning för en databas)
    ALTER DATABASE <your database name>
SET CHANGE_TRACKING = ON  
(CHANGE_RETENTION = 2 DAYS, AUTO_CLEANUP = ON)  

ALTER TABLE data_source_table
ENABLE CHANGE_TRACKING  
WITH (TRACK_COLUMNS_UPDATED = ON)

  5. Skapa en ny tabell och lagra ChangeTracking_version med ett standardvärde genom att köra följande fråga:

    create table table_store_ChangeTracking_version
(
    TableName varchar(255),
    SYS_CHANGE_VERSION BIGINT,
);

DECLARE @ChangeTracking_version BIGINT
SET @ChangeTracking_version = CHANGE_TRACKING_CURRENT_VERSION();  

INSERT INTO table_store_ChangeTracking_version
VALUES ('data_source_table', @ChangeTracking_version)

    Kommentar

    Om data inte ändras när du har aktiverat spårning för SQL-databasen är värdet för ändringsspårningsversionen 0.

  6. Kör följande fråga för att skapa en lagrad procedur i databasen. Pipelinen anropar den här lagrade proceduren för att uppdatera ändringsspårningsversionen i tabellen som du skapade i föregående steg.

    CREATE PROCEDURE Update_ChangeTracking_Version @CurrentTrackingVersion BIGINT, @TableName varchar(50)
AS

BEGIN

UPDATE table_store_ChangeTracking_version
SET [SYS_CHANGE_VERSION] = @CurrentTrackingVersion
WHERE [TableName] = @TableName

END

Azure PowerShell

Installera de senaste Azure PowerShell-modulerna enligt instruktionerna i Installera och konfigurera Azure PowerShell.

Skapa en datafabrik

  1. Definiera en variabel för resursgruppens namn som du kan använda senare i PowerShell-kommandon. Kopiera följande kommandotext till PowerShell, ange ett namn för Azure-resursgruppen, sätt dubbla citattecken omkring namnet och kör sedan kommandot. Exempel: "adfrg".

    $resourceGroupName = "ADFTutorialResourceGroup";

    Om resursgruppen redan finns behöver du kanske inte skriva över den. Ge variabeln $resourceGroupName ett annat värde och kör kommandot igen

  2. Definiera en variabel för datafabrikens plats:

    $location = "East US"

  3. Kör följande kommando för att skapa en Azure-resursgrupp:

    New-AzResourceGroup $resourceGroupName $location

    Om resursgruppen redan finns behöver du kanske inte skriva över den. Ge variabeln $resourceGroupName ett annat värde och kör kommandot igen.

  4. Definiera en variabel för datafabrikens namn.

    Viktigt!

    Uppdateringen av datafabrikens namn måste vara unikt globalt.

    $dataFactoryName = "IncCopyChgTrackingDF";

  5. Skapa datafabriken genom att köra följande Set-AzDataFactoryV2-cmdlet :

    Set-AzDataFactoryV2 -ResourceGroupName $resourceGroupName -Location $location -Name $dataFactoryName

Observera följande:

  • Namnet på Azure Data Factory måste vara globalt unikt. Om du får följande felmeddelande ändrar du namnet och försöker igen.

    The specified Data Factory name 'ADFIncCopyChangeTrackingTestFactory' is already in use. Data Factory names must be globally unique.

  • Om du vill skapa Data Factory-instanser måste det användarkonto du använder för att logga in på Azure vara medlem av rollerna deltagare eller ägare, eller vara administratör för Azure-prenumerationen.

  • Om du vill se en lista med Azure-regioner där Data Factory är tillgängligt för närvarande markerar du de regioner du är intresserad av på följande sida. Expandera sedan Analytics och leta rätt på Data Factory: Tillgängliga produkter per region. Datalagren (Azure Storage, Azure SQL Database osv.) och beräkningarna (HDInsight osv.) som används i Data Factory kan finnas i andra regioner.

Skapa länkade tjänster

Du kan skapa länkade tjänster i en datafabrik för att länka ditt datalager och beräkna datafabrik-tjänster. I det här avsnittet skapar du länkade tjänster till ditt Azure Storage-konto och din databas i Azure SQL Database.

Skapa en länkad Azure-lagringstjänst.

I det här steget länkar du ditt Azure-lagringskonto till datafabriken.

  1. Skapa en JSON-fil med namnet AzureStorageLinkedService.json i mappen C:\ADFTutorials\IncCopyChangeTrackingTutorial med följande innehåll: (Skapa mappen om den inte redan finns). Ersätt <accountName>, <accountKey> med namnet och nyckeln för ditt Azure Storage-konto innan du sparar filen.

    {
    "name": "AzureStorageLinkedService",
    "properties": {
        "type": "AzureStorage",
        "typeProperties": {
            "connectionString": "DefaultEndpointsProtocol=https;AccountName=<accountName>;AccountKey=<accountKey>"
        }
    }
}

  2. I Azure PowerShell växlar du till mappen C:\ADFTutorials\IncCopyChangeTrackingTutorial .

  3. Kör cmdleten Set-AzDataFactoryV2LinkedService för att skapa den länkade tjänsten: AzureStorageLinkedService. I följande exempel skickar du värden för parametrarna ResourceGroupName och DataFactoryName.

    Set-AzDataFactoryV2LinkedService -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -Name "AzureStorageLinkedService" -File ".\AzureStorageLinkedService.json"

    Här är exempel på utdata:

    LinkedServiceName : AzureStorageLinkedService
ResourceGroupName : ADFTutorialResourceGroup
DataFactoryName   : IncCopyChgTrackingDF
Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureStorageLinkedService

Skapa länkad Azure SQL Database-tjänst.

I det här steget länkar du databasen till datafabriken.

  1. Skapa en JSON-fil med namnet AzureSQLDatabaseLinkedService.json i mappen C:\ADFTutorials\IncCopyChangeTrackingTutorial med följande innehåll: Ersätt <ditt servernamn> och <ditt databasnamn> med namnet på servern och databasen innan du sparar filen. Du måste också konfigurera Azure SQL Server för att bevilja åtkomst till datafabrikens hanterade identitet.

    {
"name": "AzureSqlDatabaseLinkedService",
"properties": {
        "type": "AzureSqlDatabase",
        "typeProperties": {
            "connectionString": "Server=tcp:<your-server-name>.database.windows.net,1433;Database=<your-database-name>;"
        },
        "authenticationType": "ManagedIdentity",
        "annotations": []
    }
}

  2. I Azure PowerShell kör du cmdleten Set-AzDataFactoryV2LinkedService för att skapa den länkade tjänsten: AzureSQLDatabaseLinkedService.

    Set-AzDataFactoryV2LinkedService -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -Name "AzureSQLDatabaseLinkedService" -File ".\AzureSQLDatabaseLinkedService.json"

    Här är exempel på utdata:

    LinkedServiceName : AzureSQLDatabaseLinkedService
ResourceGroupName : ADFTutorialResourceGroup
DataFactoryName   : IncCopyChgTrackingDF
Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureSqlDatabaseLinkedService

Skapa datauppsättningar

I det här steget skapar du datamängder för att representera datakälla, datamål och plats för att lagra SYS_CHANGE_VERSION.

Skapa en källdatauppsättning

I det här steget skapar du en datamängd för att representera källdata.

  1. Skapa en JSON-fil med namnet SourceDataset.json i samma mapp med följande innehåll:

    {
    "name": "SourceDataset",
    "properties": {
        "type": "AzureSqlTable",
        "typeProperties": {
            "tableName": "data_source_table"
        },
        "linkedServiceName": {
            "referenceName": "AzureSQLDatabaseLinkedService",
            "type": "LinkedServiceReference"
        }
    }
}

  2. Kör cmdleten Set-AzDataFactoryV2Dataset för att skapa datauppsättningen: SourceDataset

    Set-AzDataFactoryV2Dataset -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -Name "SourceDataset" -File ".\SourceDataset.json"

    Här är exempel på utdata från cmdleten:

    DatasetName       : SourceDataset
ResourceGroupName : ADFTutorialResourceGroup
DataFactoryName   : IncCopyChgTrackingDF
Structure         :
Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureSqlTableDataset

Skapa en källdatauppsättning

I det här steget skapar du en datamängd för att representera data som kopieras från källdatalagret.

  1. Skapa en JSON-fil med namnet SinkDataset.json i samma mapp med följande innehåll:

    {
    "name": "SinkDataset",
    "properties": {
        "type": "AzureBlob",
        "typeProperties": {
            "folderPath": "adftutorial/incchgtracking",
            "fileName": "@CONCAT('Incremental-', pipeline().RunId, '.txt')",
            "format": {
                "type": "TextFormat"
            }
        },
        "linkedServiceName": {
            "referenceName": "AzureStorageLinkedService",
            "type": "LinkedServiceReference"
        }
    }
}

    Du skapar containern adftutorial i din Azure Blob Storage som en del av förutsättningarna. Skapa containern om den inte finns (eller) ställ in den för namnet på en befintlig. I den här självstudien genereras utdatafilens namn dynamiskt med uttrycket " @CONCAT(Incremental-", pipeline(). RunId, ".txt").

  2. Kör cmdleten Set-AzDataFactoryV2Dataset för att skapa datauppsättningen: SinkDataset

    Set-AzDataFactoryV2Dataset -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -Name "SinkDataset" -File ".\SinkDataset.json"

    Här är exempel på utdata från cmdleten:

    DatasetName       : SinkDataset
ResourceGroupName : ADFTutorialResourceGroup
DataFactoryName   : IncCopyChgTrackingDF
Structure         :
Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureBlobDataset

Skapa en datamängd för ändringsspårning

I det här steget skapar du en datauppsättning för att lagra ändringsspårningsversionen.

  1. Skapa en JSON-fil med namnet ChangeTrackingDataset.json i samma mapp med följande innehåll:

    {
    "name": " ChangeTrackingDataset",
    "properties": {
        "type": "AzureSqlTable",
        "typeProperties": {
            "tableName": "table_store_ChangeTracking_version"
        },
        "linkedServiceName": {
            "referenceName": "AzureSQLDatabaseLinkedService",
            "type": "LinkedServiceReference"
        }
    }
}

    Du kan skapa tabellen table_store_ChangeTracking_version som en del av förutsättningarna.

  2. Kör cmdleten Set-AzDataFactoryV2Dataset för att skapa datauppsättningen: ChangeTrackingDataset

    Set-AzDataFactoryV2Dataset -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -Name "ChangeTrackingDataset" -File ".\ChangeTrackingDataset.json"

    Här är exempel på utdata från cmdleten:

    DatasetName       : ChangeTrackingDataset
ResourceGroupName : ADFTutorialResourceGroup
DataFactoryName   : IncCopyChgTrackingDF
Structure         :
Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureSqlTableDataset

Skapa en pipeline för hela kopian

I det här steget skapar du en pipeline med en kopieringsaktivitet som kopierar alla data från källdatalagret (Azure SQL Database) till måldatalagret (Azure Blob Storage).

  1. Skapa en JSON-fil med namnet FullCopyPipeline.json i samma mapp med följande innehåll:

    {
    "name": "FullCopyPipeline",
    "properties": {
        "activities": [{
            "name": "FullCopyActivity",
            "type": "Copy",
            "typeProperties": {
                "source": {
                    "type": "SqlSource"
                },
                "sink": {
                    "type": "BlobSink"
                }
            },

            "inputs": [{
                "referenceName": "SourceDataset",
                "type": "DatasetReference"
            }],
            "outputs": [{
                "referenceName": "SinkDataset",
                "type": "DatasetReference"
            }]
        }]
    }
}

  2. Kör cmdleten Set-AzDataFactoryV2Pipeline för att skapa pipelinen: FullCopyPipeline.

     Set-AzDataFactoryV2Pipeline -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -Name "FullCopyPipeline" -File ".\FullCopyPipeline.json"

    Här är exempel på utdata:

     PipelineName      : FullCopyPipeline
 ResourceGroupName : ADFTutorialResourceGroup
 DataFactoryName   : IncCopyChgTrackingDF
 Activities        : {FullCopyActivity}
 Parameters        :

Kör den fullständiga kopieringspipelinen

Kör pipelinen: FullCopyPipeline med hjälp av cmdleten Invoke-AzDataFactoryV2Pipeline .

Invoke-AzDataFactoryV2Pipeline -PipelineName "FullCopyPipeline" -ResourceGroup $resourceGroupName -dataFactoryName $dataFactoryName

Övervaka den fullständiga kopieringspipelinen

  1. Logga in på Azure-portalen.

  2. Klicka på Alla tjänster, sök med nyckelordet data factories och välj Datafabriker.

    Menyn Datafabriker

  3. Sök efter din datafabrik i listan med datafabriker och välj den så att du öppnar sidan Datafabrik.

    Sök efter din datafabrik

  4. På sidan Datafabrik klickar du på panelen Övervaka och hantera.

    Ikonen Övervaka och hantera

  5. Dataintegreringsprogrammet startas på en separat flik. Du kan se alla pipelinekörningar och deras statusar. Lägg i följande exempel märke till att statusen för pipelinekörningen är Lyckades. Du kan kontrollera parametrarna som skickats till pipelinen genom att klicka på länken i kolumnen Parametrar. Om det uppstod ett fel ser du en länk i kolumnen Fel. Klicka på länken i kolumnen Åtgärder.

    Skärmbild som visar pipelinekörningar för en datafabrik.

  6. När du klickar på länken i kolumnen Åtgärder ser du följande sida som visar alla aktivitetskörningar för pipelinen.

    Skärmbild som visar aktivitetskörningar för en datafabrik med länken Pipelines framhävd.

  7. Om du vill växla tillbaka till vyn med pipelinekörningar klickar du på Pipelines enligt bilden.

Granska resultaten

Du ser en fil som heter incremental-<GUID>.txt i mappen incchgtracking i containern adftutorial.

Utdatafil från fullständig kopia

Filen ska ha data från databasen:

1,aaaa,21
2,bbbb,24
3,cccc,20
4,dddd,26
5,eeee,22

Lägga till mer data i källtabellen

Kör följande fråga mot databasen för att lägga till en rad och uppdatera en rad.

INSERT INTO data_source_table
(PersonID, Name, Age)
VALUES
(6, 'new','50');


UPDATE data_source_table
SET [Age] = '10', [name]='update' where [PersonID] = 1

Skapa en pipeline för deltakopian

I det här steget skapar du en pipeline med följande aktiviteter och kör den med jämna mellanrum. Lookupaktiviteterna hämtar den nya och gamla SYS_CHANGE_VERSION från Azure SQL Database och skickar den till kopieringsaktiviteten. Kopieringsaktiviteten kopierar infogade/uppdaterade/borttagna data mellan de två SYS_CHANGE_VERSION-värdena från Azure SQL Database till Azure Blob Storage. Den lagrade proceduraktivitetsuppdateringarna uppdaterar värdet för SYS_CHANGE_VERSION för nästa pipelinekörning.

  1. Skapa en JSON-fil med namnet IncrementalCopyPipeline.json i samma mapp med följande innehåll:

    {
    "name": "IncrementalCopyPipeline",
    "properties": {
        "activities": [
            {
                "name": "LookupLastChangeTrackingVersionActivity",
                "type": "Lookup",
                "typeProperties": {
                    "source": {
                        "type": "SqlSource",
                        "sqlReaderQuery": "select * from table_store_ChangeTracking_version"
                    },
                    "dataset": {
                        "referenceName": "ChangeTrackingDataset",
                        "type": "DatasetReference"
                    }
                }
            },
            {
                "name": "LookupCurrentChangeTrackingVersionActivity",
                "type": "Lookup",
                "typeProperties": {
                    "source": {
                        "type": "SqlSource",
                        "sqlReaderQuery": "SELECT CHANGE_TRACKING_CURRENT_VERSION() as CurrentChangeTrackingVersion"
                    },
                    "dataset": {
                        "referenceName": "SourceDataset",
                        "type": "DatasetReference"
                    }
                }
            },
            {
                "name": "IncrementalCopyActivity",
                "type": "Copy",
                "typeProperties": {
                    "source": {
                        "type": "SqlSource",
                        "sqlReaderQuery": "select data_source_table.PersonID,data_source_table.Name,data_source_table.Age, CT.SYS_CHANGE_VERSION, SYS_CHANGE_OPERATION from data_source_table RIGHT OUTER JOIN CHANGETABLE(CHANGES data_source_table, @{activity('LookupLastChangeTrackingVersionActivity').output.firstRow.SYS_CHANGE_VERSION}) as CT on data_source_table.PersonID = CT.PersonID where CT.SYS_CHANGE_VERSION <= @{activity('LookupCurrentChangeTrackingVersionActivity').output.firstRow.CurrentChangeTrackingVersion}"
                    },
                    "sink": {
                        "type": "BlobSink"
                    }
                },
                "dependsOn": [
                    {
                        "activity": "LookupLastChangeTrackingVersionActivity",
                        "dependencyConditions": [
                            "Succeeded"
                        ]
                    },
                    {
                        "activity": "LookupCurrentChangeTrackingVersionActivity",
                        "dependencyConditions": [
                            "Succeeded"
                        ]
                    }
                ],
                "inputs": [
                    {
                        "referenceName": "SourceDataset",
                        "type": "DatasetReference"
                    }
                ],
                "outputs": [
                    {
                        "referenceName": "SinkDataset",
                        "type": "DatasetReference"
                    }
                ]
            },
            {
                "name": "StoredProceduretoUpdateChangeTrackingActivity",
                "type": "SqlServerStoredProcedure",
                "typeProperties": {
                    "storedProcedureName": "Update_ChangeTracking_Version",
                    "storedProcedureParameters": {
                        "CurrentTrackingVersion": {
                            "value": "@{activity('LookupCurrentChangeTrackingVersionActivity').output.firstRow.CurrentChangeTrackingVersion}",
                            "type": "INT64"
                        },
                        "TableName": {
                            "value": "@{activity('LookupLastChangeTrackingVersionActivity').output.firstRow.TableName}",
                            "type": "String"
                        }
                    }
                },
                "linkedServiceName": {
                    "referenceName": "AzureSQLDatabaseLinkedService",
                    "type": "LinkedServiceReference"
                },
                "dependsOn": [
                    {
                        "activity": "IncrementalCopyActivity",
                        "dependencyConditions": [
                            "Succeeded"
                        ]
                    }
                ]
            }
        ]
    }
}

  2. Kör cmdleten Set-AzDataFactoryV2Pipeline för att skapa pipelinen: FullCopyPipeline.

     Set-AzDataFactoryV2Pipeline -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -Name "IncrementalCopyPipeline" -File ".\IncrementalCopyPipeline.json"

    Här är exempel på utdata:

     PipelineName      : IncrementalCopyPipeline
 ResourceGroupName : ADFTutorialResourceGroup
 DataFactoryName   : IncCopyChgTrackingDF
 Activities        : {LookupLastChangeTrackingVersionActivity, LookupCurrentChangeTrackingVersionActivity, IncrementalCopyActivity, StoredProceduretoUpdateChangeTrackingActivity}
 Parameters        :

Kör den inkrementella kopieringspipelinen

Kör pipelinen: IncrementalCopyPipeline med hjälp av cmdleten Invoke-AzDataFactoryV2Pipeline .

Invoke-AzDataFactoryV2Pipeline -PipelineName "IncrementalCopyPipeline" -ResourceGroup $resourceGroupName -dataFactoryName $dataFactoryName

Övervaka den inkrementella kopieringspipelinen

  1. I dataintegrationsprogrammet uppdaterar du vyn för pipelinekörningar. Kontrollera att du ser IncrementalCopyPipeline i listan. Klicka på länken i kolumnen Åtgärder.

    Skärmbild som visar pipelinekörningar för en datafabrik, inklusive din pipeline.

  2. När du klickar på länken i kolumnen Åtgärder ser du följande sida som visar alla aktivitetskörningar för pipelinen.

    Skärmbild som visar pipelinekörningar för en datafabrik med flera markerade som lyckades.

  3. Om du vill växla tillbaka till vyn med pipelinekörningar klickar du på Pipelines enligt bilden.

Granska resultaten

Du ser den andra filen i mappen incchgtracking i containern adftutorial.

Utdatafil från inkrementell säkerhetskopia

Filen ska bara ha deltadata från databasen. Posten med U är den uppdaterade raden i databasen och I är den tillagda raden.

1,update,10,2,U
6,new,50,1,I

De första tre kolumnerna är ändrade data från data_source_table. De sista två kolumnerna är metadata från tabellen med ändringsspårningssystem. Den fjärde kolumnen är SYS_CHANGE_VERSION för varje ändrad rad. Den femte kolumnen är åtgärden: U = uppdatera, I = infoga. Mer information om ändringsspårningsinformation finns i CHANGETABLE.

==================================================================
PersonID Name    Age    SYS_CHANGE_VERSION    SYS_CHANGE_OPERATION
==================================================================
1        update  10            2                                 U
6        new     50            1                                 I

Relaterat innehåll

Fortsätt till följande självstudie och lär dig mer om hur du kopierar nya och ändrade filer endast baserat på deras LastModifiedDate:

Kopiera nya filer genom lastmodifieddate