Mapowanie schematu i typu danych w działaniu kopiowania

DOTYCZY: Azure Data Factory Azure Synapse Analytics

W tym artykule opisano, w jaki sposób działanie kopiowania Azure Data Factory wykonuje mapowanie schematu i mapowanie typu danych ze źródła na dane ujścia.

Mapowanie schematu

Mapowanie domyślne

Domyślnie kopiowanie aktywności mapuje dane źródłowe do tzw. "sink" według nazw kolumn w sposób wrażliwy na wielka i wielka litera. Jeśli sink nie istnieje, na przykład podczas zapisu do plików, nazwy pól źródłowych stają się nazwami sinków. Jeśli ujście już istnieje, musi zawierać wszystkie kolumny kopiowane ze źródła. To domyślne mapowanie obsługuje elastyczne schematy oraz dryf schematu od źródła do sinku od wykonania do wykonania – wszystkie dane zwracane przez źródłowy magazyn danych mogą być kopiowane do "sink".

Jeśli twoim źródłem jest plik tekstowy bez linii nagłówka, musisz użyć mapowania jawnego , ponieważ źródło nie zawiera nazw kolumn.

Jawne mapowanie

Określ jawne mapowanie, aby dostosować mapowanie kolumn i pól od źródła do sink. Dzięki mapowaniu jawnemu możesz kopiować tylko część danych źródłowych do sinka, mapować dane źródłowe do sinku pod innymi nazwami lub przekształcać dane tabelaryczne lub hierarchiczne. Aktywność kopiowania:

1. Odczytuje dane ze źródła i określa schemat źródłowy.
2. Stosuje zdefiniowane mapowanie.
3. Zapisuje dane do zlewu.

Dowiedz się więcej o:

• Tabelaryczne źródło do ujścia tabelarycznego
• Hierarchiczne źródło do ujścia tabelarycznego
• Tabelaryczne/hierarchiczne źródło do ujścia hierarchicznego

Konfiguruj mapowanie w interfejsie Authoring, przechodząc do aktywności kopiowania i wybierając zakładkę mapowania . Albo programowo określić mapowanie w aktywności kopiowania, używając tej translator właściwości. Następujące właściwości są obsługiwane w translator -mappings> array -> objects ->source oraz sink, które wskazują na konkretną kolumnę lub pole do mapowania danych.

Następujące właściwości są obsługiwane pod translator dodatkowo do mappings:

Tabelaryczne źródło do tabelarycznego odbiornika

Na przykład aby skopiować dane z usługi Salesforce do Azure SQL Database i jawnie zamapować trzy kolumny:

1. W aktywności kopiowania wybierz zakładkę mapowania , a następnie wybierz Import schematy , aby zaimportować zarówno schematy źródłowe, jak i sink.

2. Przypisz potrzebne pola i wyklucz lub usuń pozostałe.

Mapowanie danych tabelarycznych na dane tabelaryczne

Konfiguruj to samo mapowanie w ładunku aktywności kopiowania (patrz 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" }
                }
            ]
        }
    },
    ...
}

Aby kopiować dane z oddzielonych plików tekstowych bez linii nagłówka, reprezentuj kolumny za pomocą liczby porządkowej zamiast nazw.

{
    "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" }
                }
            ]
        }
    },
    ...
}

Hierarchiczne źródło do tabelarycznego odbiornika

Gdy kopiujesz dane z źródła hierarchicznego do tabelarowego pochłaniacza, aktywność kopiowania obsługuje następujące możliwości:

• Wyodrębnianie danych z obiektów i tablic.
• Zastosuj funkcję "cross apply" do wielu obiektów według tego samego wzorca z tablicy, aby przekonwertować jeden obiekt JSON na wiele rekordów w wynikach tabelarycznych.

Aby uzyskać bardziej zaawansowaną transformację hierarchiczną w tabelarną, użyj Przepływ danych.

Na przykład, jeśli masz źródłowy dokument Azure DocumentDB lub MongoDB z następującą zawartością:

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

Aby skopiować dane do pliku tekstowego, użyj poniższego formatu z linią nagłówka. Spłaszcz dane wewnątrz tablic (order_pd i order_price) i użyj krzyżowego połączenia z wspólną informacją o korzeniu (liczba, data i miasto):

Zdefiniuj to mapowanie w interfejsie autorstwa Data Factory:

1. Podczas kopiowania przejdź do zakładki Mapowanie i wybierz Import schematów , aby zaimportować zarówno schematy źródłowe, jak i sink. Gdy usługa pobiera próbki górnych obiektów podczas importu schematu, jeśli jakieś pole się nie pojawi, dodaj je do właściwej warstwy w hierarchii – najedź kursorem na istniejącą nazwę pola i wybierz dodanie węzła, obiektu lub tablicy.

2. Wybierz tablicę, z której chcesz iterować i wyodrębniać dane. Interfejs automatycznie wypełnia referencje Kolekcji. Należy zauważyć, że ta operacja obsługuje tylko jedną tablicę.

3. Zamapuj wymagane pola do ujścia. Usługa automatycznie określa odpowiednie ścieżki JSON dla strony hierarchicznej.

Możesz też przejść na Zaawansowany edytor. Możesz bezpośrednio zobaczyć i edytować ścieżki JSON pól. Jeśli zdecydujesz się dodać nowe mapowanie w tym widoku, określ ścieżkę JSON.

Możesz skonfigurować to samo mapowanie w payload aktywności kopiowania (patrz):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']"
        }
    },
    ...
}

Tabelaryczne/hierarchiczne źródło do hierarchicznego odbiornika

Proces doświadczenia użytkownika jest podobny do hierarchicznego źródła do ujścia tabelarycznego.

Podczas kopiowania danych ze źródła tabelarycznego do hierarchicznego pochłaniacza, usługa nie obsługuje zapisu do tablicy wewnątrz obiektu.

Kopiując dane ze źródła hierarchicznego do hierarchicznego zalewu, można zachować całą hierarchię warstwy, wybierając obiekt lub tablicę i mapując ją na sink bez dotykania pól wewnętrznych.

Aby uzyskać bardziej zaawansowane transformacje przekształcania danych, użyj Przepływ danych.

Parametryzowanie mapowania

Aby stworzyć templatyzowany potok, który dynamicznie kopiuje dużą liczbę obiektów, najpierw określ, czy możesz użyć domyślnego mapowania , czy też musisz zdefiniować jawne mapowanie dla każdego obiektu.

Jeśli potrzebujesz mapowania jawnego, postępuj zgodnie z tymi krokami:

1. Zdefiniuj parametr z typem obiektu na poziomie potoku, takim jak mapping.

2. Parametryzuj mapowanie: W aktywności kopiowania przejdź do zakładki mapowania, wybierz opcję dodania treści dynamicznej i wybierz utworzony parametr. Ładunek aktywności jest następujący:

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

3. Skonstruuj wartość, która ma być przekazywana do parametru mapowania. Powinna być całym celem translator definicji. Przykłady można znaleźć w sekcji o odwzorowaniu jawnym . Na przykład, dla kopiowania ze źródła tabelarycznego do docelowego miejsca tabelarycznego, wartość powinna wynosić {"type":"TabularTranslator","mappings":[{"source":{"name":"Id"},"sink":{"name":"CustomerID"}},{"source":{"name":"Name"},"sink":{"name":"LastName"}},{"source":{"name":"LastModifiedDate"},"sink":{"name":"ModifiedDate"}}]}.

Mapowanie typu danych

działanie Kopiuj mapuje typy źródeł na typy zlewów, korzystając z następującego przepływu:

1. Przekonwertuj z natywnych typów danych źródła na pośrednie typy danych używane przez potoki Azure Data Factory i Synapse.
2. Automatycznie konwertuj tymczasowy typ danych w razie potrzeby, aby dopasował odpowiadające mu typy pochłaniaczy. Ten krok dotyczy zarówno domyślnego mapowania , jak i jawnego mapowania.
3. Konwertowanie z typów danych tymczasowych na natywne typy danych ujścia.

działanie Kopiuj obecnie obsługuje następujące przejściowe typy danych: Boolean, Byte, Byte array, Datetime, DatetimeOffset, Decimal, Double, GUID, Int16, Int32, Int64, SByte, Single, String, Timespan, UInt16, UInt32 i UInt64.

Następujące konwersje typów danych są obsługiwane między typami tymczasowymi ze źródła do ujścia.

(1) Data/Godzina obejmuje DateTime, DateTimeOffset, Date oraz Time.

(2) Typy zmiennoprzecinkowe obejmują Single i Double.

(3) Liczba całkowita obejmuje SByte, Byte, Int16, UInt16, Int32, UInt32, Int64 i UInt64.

działanie Kopiuj obsługuje następujące właściwości konwersji typów danych (w translator sekcji o autorstwie programatycznej):

| Własność | Opis | Wymagane | | -------------------------------- | ------------------------------------------------------------ | -------- | | typeConversion | Włącz nowe doświadczenie konwersji typów danych. Wartość domyślna jest fałszywa ze względu na zgodność z poprzednimi wersjami.

Dla nowych aktywności kopiowania tworzonych przez Data Factory authoring UI od końca czerwca 2020 roku, konwersja typów danych jest domyślnie włączona dla najlepszego doświadczenia. Możesz zobaczyć następujące ustawienia konwersji typów w aktywności kopiowania –> zakładka mapowania dla odpowiednich scenariuszy. Aby programowo utworzyć potok, należy jawnie ustawić właściwość typeConversion na wartość true, aby ją włączyć. W przypadku istniejących działań kopiowania utworzonych przed wydaniem tej funkcji, opcje konwersji typów nie będą widoczne w interfejsie użytkownika podczas edycji, aby zachować zgodność z wcześniejszymi wersjami. | Nie | | typeConversionSettings | Grupa ustawień konwersji czcionek. Zastosuj, gdy typeConversion jest ustawiony na true. Wszystkie poniższe właściwości znajdują się w tej grupie. | Nie | | Pod typeConversionSettings | | | | allowDataTruncation | Pozwól na obcięcie danych podczas konwersji danych źródłowych na sink o innym typie podczas kopiowania, na przykład z dziesiętnego na całkowitoliczbowy, z DatetimeOffset na Datetime.
Domyślna wartość to "true". | Nie | | treatBooleanAsNumber | Traktuj booleany jako liczby, na przykład true jako 1.
Wartość domyślna to false. | Nie | | dateFormat | Formatuj ciąg podczas konwersji między datami i ciągami, na przykład .yyyy-MM-dd Aby uzyskać szczegółowe informacje, zobacz Niestandardowe ciągi formatu daty i godziny . | Nie | | dateTimeFormat | Formatuj ciąg tekstów podczas konwersji między datami bez przesunięcia stref czasowych i łańcuchów, takich jak yyyy-MM-dd HH:mm:ss.fff. Aby uzyskać szczegółowe informacje, zobacz Niestandardowe ciągi formatu daty i godziny . | Nie | | dateTimeOffsetFormat | Formatuj ciąg podczas konwersji między datami z przesunięciem stref czasowych i ciągami znaków, takich jak yyyy-MM-dd HH:mm:ss.fff zzz. Aby uzyskać szczegółowe informacje, zobacz Niestandardowe ciągi formatu daty i godziny . | Nie | | timeSpanFormat | Formatuj ciąg podczas konwersji między okresami czasowymi i ciągami, takimi jak dd\.hh\:mm. Szczegółowe informacje można znaleźć w Custom TimeSpan Format Strings (Niestandardowe ciągi formatu TimeSpan). | Nie | | timeFormat | Formatuj ciąg podczas konwersji między czasem a ciągami, na przykład .HH:mm:ss.fff Aby uzyskać szczegółowe informacje, zobacz Niestandardowe ciągi formatu daty i godziny . | Nie | | Kultura | Informacje o kulturze do wykorzystania przy konwersji typów, takich jak en-us lub fr-fr. | Nie |

Example:

{
    "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"
            }
        }
	},
    ...
}

Starsze modele

Alternatywne mapowanie kolumn (starszy model)

Aby odwzorować dane o kształcie tablicowym, określmy copy activity -> translator -> columnMappings. W tym przypadku zarówno zbiory danych wejściowych, jak i wyjściowych wymagają sekcji struktury . Mapowanie kolumn umożliwia mapowanie całej lub podzbioru kolumn w strukturze zbioru danych źródłowego na wszystkie kolumny w strukturze zbioru danych sink. Następujące warunki błędu skutkują wyjątkiem:

• Wynik zapytania do magazynu danych źródłowych nie ma nazwy kolumny, którą określiłeś w sekcji struktury zbioru danych wejściowych.
• Sink data store (jeśli ma predefiniowany schemat) nie ma nazwy kolumny, którą określiłeś w sekcji struktury zbioru danych wyjściowych.
• Albo mniej kolumn, albo więcej kolumn w strukturze zbioru danych sink niż określono w mapowaniu.
• Zduplikowane mapowanie.

W poniższym przykładzie wejściowy zestaw danych ma strukturę i wskazuje tabelę w lokalnej bazie danych Oracle.

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

W tym przykładzie wyjściowy zestaw danych ma strukturę i wskazuje tabelę w usłudze Salesforce.

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

Poniższy kod JSON definiuje działanie kopiowania w potoku. Kolumny z źródła mapują się na kolumny w sink, korzystając z właściwości tłumacza ->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"
            }
        }
    }
}

Jeśli użyjesz składni "columnMappings": "UserId: MyUserId, Group: MyGroup, Name: MyName" do określenia mapowania kolumn, nadal jest ona wspierana as-is.

Alternatywne mapowanie schematów (model dziedziczny)

Możesz określić aktywność kopiowania –>translator>schemaMapping aby mapować dane o kształcie hierarchicznym a dane w kształcie tablicy. Na przykład możesz skopiować z MongoDB lub REST do pliku tekstowego, a następnie z Oracle do Azure Cosmos DB dla MongoDB lub Azure DocumentDB (z kompatybilnością z MongoDB). Sekcja aktywności translator kopiowania wspiera następujące właściwości:

• Klucz: reprezentuje źródło. Dla źródła tabelarycznego określ nazwę kolumny zdefiniowaną w strukturze zbioru danych. Dla źródła hierarchicznego określ wyrażenie ścieżki JSON dla każdego pola do wyodrębnienia i mapowania.
• Wartość: oznacza pochłanianie. Dla tabliczkowego sinka określ nazwę kolumny zdefiniowaną w strukturze zbioru danych. Dla hierarchicznego pochłaniania określmy wyrażenie ścieżki JSON dla każdego pola do wyodrębnienia i mapowania. W przypadku danych hierarchicznych, dla pól w obiekcie głównym, ścieżka JSON zaczyna się od root $; dla pól wewnątrz tablicy wybranej przez właściwość collectionReference, ścieżka JSON rozpoczyna się od elementu tej tablicy. | Tak | | kolekcjaOdniesienie | Jeśli chcesz iterować i wyodrębniać dane z obiektów wewnątrz pola tablicy o tym samym wzorcu i konwertować na wiersz na obiekt, określ ścieżkę JSON tej tablicy, aby wykonać cross-apply. Ta właściwość jest obsługiwana tylko wtedy, gdy dane hierarchiczne są źródłem. | Nie |

Przykład: kopiowanie z bazy danych MongoDB do bazy danych Oracle:

Na przykład, jeśli masz dokument MongoDB z następującą zawartością:

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

Chcesz je skopiować do tabeli Azure SQL w następującym formacie, spłaszczając dane wewnątrz tablicy (order_pd i order_price) i łącząc je z informacjami o wspólnym korzeniu (liczba, data i miasto):

Skonfiguruj regułę mapowania schematu jako następujący przykład kopiowania aktywności JSON:

{
    "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"
        }
    }
}

Treści powiązane

Zobacz inne artykuły dotyczące działania kopiowania:

• Omówienie działania kopiowania