Schema- och datatypsmappning i kopieringsaktivitet

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

Den här artikeln beskriver hur Azure Data Factory kopieringsaktivitet utför schemamappning och datatypmappning från källdata till mottagardata.

Schemakoppling

Standardinställning

Som standard mappar kopieringsaktiviteten källdata till kolumnens sänka på ett kasuskänsligt sätt. Om sänkan inte finns, till exempel vid skrivning till filer, blir källfältnamnen sänknamnen. Om databasen redan finns måste den innehålla alla kolumner som kopieras från källan. Denna standardmappning stödjer flexibla scheman och schemadrift från källa till sänka från exekvering till exekvering – all data som returneras av källdatalagret kan kopieras till sluken.

Om din källa är en textfil utan rubrikrad behöver du använda explicit mapping eftersom källkoden inte innehåller kolumnnamn.

Explicit kartläggning

Specificera explicit mapping för att anpassa kolumn- och fältmappningen från källa till sänka. Genom att använda explicit mappning kan du kopiera endast en del av källdatan till sänkan, mappa källdata till sluken med olika namn, eller omforma tabell- eller hierarkisk data. Kopieringsaktiviteten:

1. Läser data från källan och bestämmer källschemat.
2. Tillämpar din definierade mappning.
3. Skriver datan till diskbänken.

Läs mer om:

• Tabellkälla till tabellmottagare
• Hierarkisk källa till tabellbuffert
• Tabulär eller hierarkisk källa till hierarkisk mottagare

Konfigurera mappningen i Authoring UI genom att gå till kopieringsaktiviteten och välja fliken mappning . Eller, specificera mappningen programmässigt i kopieringsaktiviteten genom att använda egenskapen translator . Följande egenskaper stöds i translator -mappings> array -> objects ->source och sink, som pekar på den specifika kolumnen eller fältet för att mappa data.

Följande egenskaper stöds under translator utöver mappings:

Tabellkälla till tabellmottagare

Om du till exempel vill kopiera data från Salesforce till Azure SQL Database och uttryckligen mappa tre kolumner:

1. På kopieringsaktiviteten, välj fliken mappning och välj sedan Importera scheman för att importera både käll- och sänkscheman.

2. Mappa de nödvändiga fälten och uteslut eller ta bort resten.

Konfigurera samma mappning i kopieringsaktivitetspayloaden (se translator).

{
    "name": "CopyActivityTabularToTabular",
    "type": "Copy",
    "typeProperties": {
        "source": { "type": "SalesforceSource" },
        "sink": { "type": "SqlSink" },
        "translator": {
            "type": "TabularTranslator",
            "mappings": [
                {
                    "source": { "name": "Id" },
                    "sink": { "name": "CustomerID" }
                },
                {
                    "source": { "name": "Name" },
                    "sink": { "name": "LastName" }
                },
                {
                    "source": { "name": "LastModifiedDate" },
                    "sink": { "name": "ModifiedDate" }
                }
            ]
        }
    },
    ...
}

För att kopiera data från avgränsade textfiler utan rubrikrad, representera kolumnerna med ordningstal istället för namn.

{
    "name": "CopyActivityTabularToTabular",
    "type": "Copy",
    "typeProperties": {
        "source": { "type": "DelimitedTextSource" },
        "sink": { "type": "SqlSink" },
        "translator": {
            "type": "TabularTranslator",
            "mappings": [
                {
                    "source": { "ordinal": "1" },
                    "sink": { "name": "CustomerID" }
                }, 
                {
                    "source": { "ordinal": "2" },
                    "sink": { "name": "LastName" }
                }, 
                {
                    "source": { "ordinal": "3" },
                    "sink": { "name": "ModifiedDate" }
                }
            ]
        }
    },
    ...
}

Hierarkisk källa till tabulär slutpunkt

När du kopierar data från en hierarkisk källa till en tabellssänka stöder kopieringsaktiviteten följande funktioner:

• Extrahera data från objekt och matriser.
• Använd flera objekt med samma mönster från en array, där man konverterar ett JSON-objekt till flera poster i ett tabellresultat.

För mer avancerad hierarkisk till tabellomvandling, använd Data Flow.

Till exempel, om du har källdokumentet Azure DocumentDB eller MongoDB med följande innehåll:

{
    "id": {
        "$oid": "592e07800000000000000000"
    },
    "number": "01",
    "date": "20170122",
    "orders": [
        {
            "prod": "p1",
            "price": 23
        },
        {
            "prod": "p2",
            "price": 13
        },
        {
            "prod": "p3",
            "price": 231
        }
    ],
    "city": [ { "name": "Seattle" } ]
}

För att kopiera datan till en textfil, använd följande format med en rubrikrad. Platta ut datan inuti arrayerna (order_pd och order_price) och använd en korssammanfogning med den gemensamma rotinformationen (nummer, datum och stad):

Definiera denna mappning i Data Factorys authoring-gränssnitt:

1. Vid kopieringsaktivitet, gå till fliken Mapping och välj Importera scheman för att importera både käll- och sänkscheman. När tjänsten tar prov på de översta objekten vid import av schema, om något fält inte visas, lägg till det i rätt lager i hierarkin – håll muspekaren över ett befintligt fältnamn och välj att lägga till en nod, ett objekt eller en array.

2. Välj den matris som du vill iterera och extrahera data från. UI:t fyller automatiskt i Collection-referensen. Observera att denna operation endast stöder en enda array.

3. Mappa de nödvändiga fälten till mål. Tjänsten avgör automatiskt motsvarande JSON-sökvägar för den hierarkiska sidan.

Du kan också byta till avancerad redigerare. Du kan direkt se och redigera fältens JSON-vägar. Om du väljer att lägga till ny mappning i den här vyn anger du JSON-sökvägen.

Du kan konfigurera samma mappning i copy activity payload (se translator):

{
    "name": "CopyActivityHierarchicalToTabular",
    "type": "Copy",
    "typeProperties": {
        "source": { "type": "MongoDbV2Source" },
        "sink": { "type": "DelimitedTextSink" },
        "translator": {
            "type": "TabularTranslator",
            "mappings": [
                {
                    "source": { "path": "$['number']" },
                    "sink": { "name": "orderNumber" }
                },
                {
                    "source": { "path": "$['date']" },
                    "sink": { "name": "orderDate" }
                },
                {
                    "source": { "path": "['prod']" },
                    "sink": { "name": "order_pd" }
                },
                {
                    "source": { "path": "['price']" },
                    "sink": { "name": "order_price" }
                },
                {
                    "source": { "path": "$['city'][0]['name']" },
                    "sink": { "name": "city" }
                }
            ],
            "collectionReference": "$['orders']"
        }
    },
    ...
}

Tabell-/hierarkisk källa till hierarkisk mottagare

Användarupplevelsens flöde liknar hierarkisk källa till tabellmottagare.

När man kopierar data från en tabellkälla till en hierarkisk sänka stöder tjänsten inte skrivning till en array inuti ett objekt.

När du kopierar data från en hierarkisk källa till en hierarkisk sänka kan du bevara ett helt lagers hierarki genom att välja objektet eller arrayen och mappa till sink utan att röra de inre fälten.

För mer avancerad dataomformningstransformation, använd Data Flow.

Parameterisera kartläggning

För att skapa en mallatiserad pipeline som dynamiskt kopierar ett stort antal objekt, avgör först om du kan använda standardmappningen eller om du behöver definiera explicit mappning för varje objekt.

Om du behöver explicit mappning, följ dessa steg:

1. Definiera en parameter med en objekttyp på pipelinenivå, såsom mapping.

2. Parametrisera mappningen: Gå till mappningsfliken i kopieringsaktiviteten, välj att lägga till dynamiskt innehåll och välj den parameter du skapat. Aktivitetslasten är följande:

   {
       "name": "CopyActivityHierarchicalToTabular",
       "type": "Copy",
       "typeProperties": {
           "source": {...},
           "sink": {...},
           "translator": {
               "value": "@pipeline().parameters.mapping",
               "type": "Expression"
           },
           ...
       }
   }
   

3. Konstruera värdet som ska skickas till mappningsparametern. Det borde vara hela objektet för definitionen translator . För exempel, se avsnittet om explicit kartläggning . Till exempel, för kopiering från tabellkälla till tabellmottagare ska värdet vara {"type":"TabularTranslator","mappings":[{"source":{"name":"Id"},"sink":{"name":"CustomerID"}},{"source":{"name":"Name"},"sink":{"name":"LastName"}},{"source":{"name":"LastModifiedDate"},"sink":{"name":"ModifiedDate"}}]}.

Mappningar av datatyp

Copy activity mappar källtyper till sänktyper genom att använda följande flöde:

1. Konvertera från källbaserade datatyper till mellanliggande datatyper som används av Azure Data Factory- och Synapse-pipelines.
2. Konvertera automatiskt den interimistiska datatypen vid behov för att matcha motsvarande sänketyper. Detta steg gäller både standardmappning och explicit mappning.
3. Konvertera från mellanliggande datatyper till inbyggda datatyper.

Copy activity stöder för närvarande följande interimdatatyper: Boolesk, Byte, Byte-matris, Datetime, DatetimeOffset, Decimal, Double, GUID, Int16, Int32, Int64, SByte, Single, String, Timespan, UInt16, UInt32 och UInt64.

Följande datatypkonverteringar stöds mellan interimstyperna från källa till mottagare.

(1) Datum/Tid inkluderar DatumTid, DatumTidFörskjutning, Datum och Tid.

(2) Float-point innehåller enkel och dubbel.

(3) Heltal innefattar SByte, Byte, Int16, UInt16, Int32, UInt32, Int64 och UInt64.

Copy activity stöder följande egenskaper för datatypkonvertering (under translator avsnittet för programmatisk författarskap):

| Egendom | Beskrivning | Krävs | | -------------------------------- | ------------------------------------------------------------ | -------- | | typeConversion | Aktivera den nya datatypkonverteringsupplevelsen. Standardvärdet är falskt på grund av bakåtkompatibilitet.

För nya kopieringsaktiviteter skapade via Data Factorys authoring UI sedan slutet av juni 2020 är denna datatypkonvertering aktiverad som standard för bästa upplevelse. Du kan se följande typkonverteringsinställningar under fliken kopieringsaktivitet -> mappning för tillämpliga scenarier. Om du vill skapa pipeline programmatiskt måste du uttryckligen ange typeConversion egenskapen till true för att aktivera den. För befintliga kopieringsaktiviteter som skapats innan den här funktionen släpps visas inte alternativ för typkonvertering i redigeringsgränssnittet för bakåtkompatibilitet. | Nej | | typeConversionSettings | En grupp typkonverteringsinställningar. Använd när typeConversion är inställt på true. Följande egenskaper finns under den här gruppen. | Nej | | Under typeConversionSettings | | | | allowDataTruncation | Tillåt datatrunkering när källdata konverteras till sänka med olika typer under kopiering, till exempel från decimal till heltal, från DatetimeOffset till Datetime.
Standardvärdet är sant. | Nej | | treatBooleanAsNumber | Behandla boolean som tal, till exempel, sanna som 1.
Standardvärdet är "falsk". | Nej | | datumFormat | Formatera sträng vid konvertering mellan datum och strängar, såsom yyyy-MM-dd. Mer information finns i Anpassade datum- och tidsformatsträngar. | Nej | | datumTidsformat | Formatera sträng vid konvertering mellan datum utan tidszonsförskjutning och strängar, såsom yyyy-MM-dd HH:mm:ss.fff. Mer information finns i Anpassade datum- och tidsformatsträngar. | Nej | | datumTidsförskjutningFormat | Formatera sträng vid konvertering mellan datum med tidszonsförskjutning och strängar, såsom yyyy-MM-dd HH:mm:ss.fff zzz. Mer information finns i Anpassade datum- och tidsformatsträngar. | Nej | | timeSpanFormat | Formatera sträng vid konvertering mellan tidsperioder och strängar, såsom dd\.hh\:mm. Mer information finns i Anpassade TimeSpan-formatsträngar. | Nej | | timeFormat | Formatera sträng vid konvertering mellan tid och strängar, såsom HH:mm:ss.fff. Mer information finns i Anpassade datum- och tidsformatsträngar. | Nej | | Kultur | Kulturinformation att använda vid konvertering av typer, såsom en-us eller fr-fr. | Nej |

Exempel:

{
    "name": "CopyActivity",
    "type": "Copy",
    "typeProperties": {
        "source": {
        	"type": "ParquetSource"
        },
        "sink": {
            "type": "SqlSink"
        },
        "translator": {
            "type": "TabularTranslator",
            "typeConversion": true,
            "typeConversionSettings": {
                "allowDataTruncation": true,
                "treatBooleanAsNumber": true,
                "dateTimeFormat": "yyyy-MM-dd HH:mm:ss.fff",
                "dateTimeOffsetFormat": "yyyy-MM-dd HH:mm:ss.fff zzz",
                "timeSpanFormat": "dd\.hh\:mm",
                "culture": "en-gb"
            }
        }
	},
    ...
}

Äldre modeller

Alternativ kolumnmappning (äldre modell)

För att kartlägga mellan tabellformade data, ange copy activity -> translator -> columnMappings. I detta fall kräver både in- och utdataset struktursektionen . Kolumnmappning stödjer att mappa alla eller en delmängd av kolumner i källdatasetsstrukturen till alla kolumner i sink-datasetstrukturen. Följande felvillkor resulterar i ett undantag:

• Resultatet för källdatalagringsfrågan har inte det kolumnnamn du angav i avsnittet om indatasets struktur.
• Sink data store (om det har ett fördefinierat schema) har inte det kolumnnamn du specificerat i avsnittet om utdatasets struktur.
• Antingen färre kolumner eller fler kolumner i sänkdatasets struktur än vad som anges i mappningen.
• Duplicerad mappning.

I följande exempel har indatauppsättningen en struktur och pekar på en tabell i en lokal Oracle-databas.

{
    "name": "OracleDataset",
    "properties": {
        "structure":
         [
            { "name": "UserId"},
            { "name": "Name"},
            { "name": "Group"}
         ],
        "type": "OracleTable",
        "linkedServiceName": {
            "referenceName": "OracleLinkedService",
            "type": "LinkedServiceReference"
        },
        "typeProperties": {
            "tableName": "SourceTable"
        }
    }
}

I det här exemplet har utdatauppsättningen en struktur och pekar på en tabell i Salesforce.

{
    "name": "SalesforceDataset",
    "properties": {
        "structure":
        [
            { "name": "MyUserId"},
            { "name": "MyName" },
            { "name": "MyGroup"}
        ],
        "type": "SalesforceObject",
        "linkedServiceName": {
            "referenceName": "SalesforceLinkedService",
            "type": "LinkedServiceReference"
        },
        "typeProperties": {
            "tableName": "SinkTable"
        }
    }
}

Följande JSON definierar en kopieringsaktivitet i en pipeline. Kolumnerna från källkoden mappas till kolumnerna i sink genom att använda egenskapen ->columnMappings.

{
    "name": "CopyActivity",
    "type": "Copy",
    "inputs": [
        {
            "referenceName": "OracleDataset",
            "type": "DatasetReference"
        }
    ],
    "outputs": [
        {
            "referenceName": "SalesforceDataset",
            "type": "DatasetReference"
        }
    ],
    "typeProperties":    {
        "source": { "type": "OracleSource" },
        "sink": { "type": "SalesforceSink" },
        "translator":
        {
            "type": "TabularTranslator",
            "columnMappings":
            {
                "UserId": "MyUserId",
                "Group": "MyGroup",
                "Name": "MyName"
            }
        }
    }
}

Om du använder syntaxen "columnMappings": "UserId: MyUserId, Group: MyGroup, Name: MyName" för att specificera kolumnmappning stöds det fortfarande as-is.

Alternativ schemamappning (äldre modell)

Du kan specificera kopieringsaktivitet –>translator för>schemaMapping att mappa mellan hierarkiskt formade data och tabellformat data. Till exempel kan du kopiera från MongoDB eller REST till en textfil, och kopiera från Oracle till Azure Cosmos DB för MongoDB eller Azure DocumentDB (med MongoDB-kompatibilitet). Avsnittet för kopieringsaktivitet translator stöder följande egenskaper:

• Nyckel: representerar källan. För tabellkällkod, ange kolumnnamnet som definierat i datasetsstrukturen. För hierarkisk källa, ange JSON-väguttrycket för varje fält att extrahera och mappa.
• Värde: representerar sänka. För tabulär sink, ange kolumnnamnet som definierat i datasetsstrukturen. För hierarkisk sänka, ange JSON-vägsuttrycket för varje fält att extrahera och avbilda. När det gäller hierarkiska data, för fält under rotobjekt, börjar JSON-sökvägen med roten $; för fält i matrisen som valts av collectionReference egenskapen startar JSON-sökvägen från matriselementet. | Ja | | samlingReferens | Om du vill iterera och extrahera data från objekten i ett arrayfält med samma mönster och konvertera till per rad per objekt, specificera JSON-banan för den arrayen för att göra cross-apply. Den här egenskapen stöds endast när hierarkiska data är källa. | Nej |

Exempel: kopiera från MongoDB till Oracle:

Till exempel, om du har ett MongoDB-dokument med följande innehåll:

{
    "id": {
        "$oid": "592e07800000000000000000"
    },
    "number": "01",
    "date": "20170122",
    "orders": [
        {
            "prod": "p1",
            "price": 23
        },
        {
            "prod": "p2",
            "price": 13
        },
        {
            "prod": "p3",
            "price": 231
        }
    ],
    "city": [ { "name": "Seattle" } ]
}

och du vill kopiera den till en Azure SQL tabell i följande format genom att platta ut datan inuti arrayen (order_pd och order_price) och korsansluta med den gemensamma rotinformationen (nummer, datum och stad):

Konfigurera schemamappningsregeln som följande kopiaaktivitets-JSON-exempel:

{
    "name": "CopyFromMongoDBToOracle",
    "type": "Copy",
    "typeProperties": {
        "source": {
            "type": "MongoDbV2Source"
        },
        "sink": {
            "type": "OracleSink"
        },
        "translator": {
            "type": "TabularTranslator",
            "schemaMapping": {
                "$.number": "orderNumber",
                "$.date": "orderDate",
                "prod": "order_pd",
                "price": "order_price",
                "$.city[0].name": "city"
            },
            "collectionReference":  "$.orders"
        }
    }
}

Relaterat innehåll

Se de andra artiklarna om kopieringsaktivitet:

• Översikt över kopieringsaktivitet