Pozyskiwanie przykładowych danych w formacie JSON do usługi Azure Data Explorer

W tym artykule pokazano, jak pozyskiwać dane sformatowane w formacie JSON do bazy danych usługi Azure Data Explorer. Zaczniesz od prostych przykładów nieprzetworzonych i zamapowanych danych JSON, będziesz nadal korzystać z wielowierszowego kodu JSON, a następnie zajmiesz się bardziej złożonymi schematami JSON zawierającymi tablice i słowniki. W przykładach szczegółowo omówiono proces pozyskiwania danych sformatowanych w formacie JSON przy użyciu języka język zapytań Kusto (KQL), C# lub Python.

Uwaga

Nie zalecamy używania .ingest poleceń zarządzania w scenariuszach produkcyjnych. Zamiast tego należy użyć łącznika danych lub programowego pozyskiwania danych przy użyciu jednej z bibliotek klienckich usługi Kusto.

Wymagania wstępne

• Konto Microsoft lub tożsamość użytkownika Microsoft Entra. Subskrypcja platformy Azure nie jest wymagana.
• Baza danych i klaster usługi Azure Data Explorer. Utwórz klaster i bazę danych.

Format JSON

Usługa Azure Data Explorer obsługuje dwa formaty plików JSON:

• json: Oddzielony wierszem kod JSON. Każdy wiersz w danych wejściowych ma dokładnie jeden rekord JSON. Ten format obsługuje analizowanie komentarzy i właściwości z pojedynczym cudzysłów. Aby uzyskać więcej informacji, zobacz Wiersze JSON.
• multijson: wielowierszowy kod JSON. Analizator ignoruje separatory wierszy i odczytuje rekord z poprzedniej pozycji na końcu prawidłowego kodu JSON.

Uwaga

Podczas pozyskiwania przy użyciu środowiska pobierania danych domyślny format to multijson. Format może obsługiwać wielowierszowe rekordy JSON i tablice rekordów JSON. Po napotkaniu błędu analizowania cały plik zostanie odrzucony. Aby zignorować nieprawidłowe rekordy JSON, wybierz opcję "Ignoruj błędy formatu danych". Spowoduje to przełączenie formatu na json (linie JSON).

Jeśli używasz formatu linii JSON (json), wiersze, które nie reprezentują prawidłowych rekordów JSON, są pomijane podczas analizowania.

Pozyskiwanie i mapowanie sformatowanych danych JSON

Pozyskiwanie danych sformatowanych w formacie JSON wymaga określenia formatu przy użyciu właściwości pozyskiwania. Pozyskiwanie danych JSON wymaga mapowania, które mapuje wpis źródłowy JSON na kolumnę docelową. Podczas pozyskiwania danych należy użyć IngestionMapping właściwości z właściwością ingestionMappingReference (dla wstępnie zdefiniowanego mapowania) pozyskiwania lub jej IngestionMappings właściwości. W tym artykule zostanie użyta właściwość pozyskiwania ingestionMappingReference , która jest wstępnie zdefiniowana w tabeli używanej do pozyskiwania. W poniższych przykładach zaczniemy od pozyskiwania rekordów JSON jako danych pierwotnych do tabeli z jedną kolumną. Następnie użyjemy mapowania, aby pozyskać każdą właściwość do jej zamapowanej kolumny.

Prosty przykład kodu JSON

Poniższy przykład to prosty kod JSON z płaską strukturą. Dane zawierają informacje o temperaturze i wilgotności zebrane przez kilka urządzeń. Każdy rekord jest oznaczony identyfikatorem i znacznikiem czasu.

{
    "timestamp": "2019-05-02 15:23:50.0369439",
    "deviceId": "2945c8aa-f13e-4c48-4473-b81440bb5ca2",
    "messageId": "7f316225-839a-4593-92b5-1812949279b3",
    "temperature": 31.0301639051317,
    "humidity": 62.0791099602725
}

Pozyskiwanie nieprzetworzonych rekordów JSON

W tym przykładzie pozyskasz rekordy JSON jako nieprzetworzone dane do pojedynczej tabeli kolumn. Manipulowanie danymi przy użyciu zapytań i zasad aktualizacji odbywa się po pozyskiwaniu danych.

KQL

Użyj język zapytań Kusto do pozyskiwania danych w nieprzetworzonym formacie JSON.

1. Zaloguj się do https://dataexplorer.azure.com.

2. Wybierz pozycję Dodaj klaster.

3. W oknie dialogowym Dodawanie klastra wprowadź adres URL klastra w formularzu https://<ClusterName>.<Region>.kusto.windows.net/, a następnie wybierz pozycję Dodaj.

4. Wklej następujące polecenie i wybierz pozycję Uruchom , aby utworzyć tabelę.

   .create table RawEvents (Event: dynamic)
   

   To zapytanie tworzy tabelę z jedną Event kolumną dynamicznego typu danych.

5. Utwórz mapowanie JSON.

   .create table RawEvents ingestion json mapping 'RawEventMapping' '[{"column":"Event","Properties":{"path":"$"}}]'
   

   To polecenie tworzy mapowanie i mapuje ścieżkę $ JSON główną do kolumny Event .

6. Pozyskiwanie danych do RawEvents tabeli.

   .ingest into table RawEvents ('https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json') with '{"format":"json", "ingestionMappingReference":"RawEventMapping"}'
   

C#

Użyj języka C# do pozyskiwania danych w formacie nieprzetworzonym JSON.

1. Utwórz tabelę RawEvents .

   var kustoUri = "https://<clusterName>.<region>.kusto.windows.net/";
   var connectionStringBuilder = new KustoConnectionStringBuilder(kustoUri)
   {
       FederatedSecurity = true,
       UserID = userId,
       Password = password,
       Authority = tenantId,
       InitialCatalog = databaseName
   };
   using var kustoClient = KustoClientFactory.CreateCslAdminProvider(connectionStringBuilder);
   var tableName = "RawEvents";
   var command = CslCommandGenerator.GenerateTableCreateCommand(
       tableName,
       new[] { Tuple.Create("Events", "System.Object") }
   );
   await kustoClient.ExecuteControlCommandAsync(command);
   

2. Utwórz mapowanie JSON.

   var tableMappingName = "RawEventMapping";
   command = CslCommandGenerator.GenerateTableMappingCreateCommand(
       IngestionMappingKind.Json,
       tableName,
       tableMappingName,
       new ColumnMapping[]
       {
           new() { ColumnName = "Events", Properties = new Dictionary<string, string> { { "path", "$" } } }
       }
   );
   
   await kustoClient.ExecuteControlCommandAsync(command);
   

   To polecenie tworzy mapowanie i mapuje ścieżkę $ JSON główną do kolumny Event .

3. Pozyskiwanie danych do RawEvents tabeli.

   var ingestUri = "https://ingest-<clusterName>.<region>.kusto.windows.net/";
   
   var ingestConnectionStringBuilder = new KustoConnectionStringBuilder(ingestUri)
   {
       FederatedSecurity = true,
       UserID = userId,
       Password = password,
       Authority = tenantId,
       InitialCatalog = databaseName
   };
   using var ingestClient = KustoIngestFactory.CreateQueuedIngestClient(ingestConnectionStringBuilder);
   
   var blobPath = "https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json";
   var properties = new KustoQueuedIngestionProperties(databaseName, tableName)
   {
       Format = DataSourceFormat.json,
       IngestionMapping = new IngestionMapping { IngestionMappingReference = tableMappingName }
   };
   await ingestClient.IngestFromStorageAsync(blobPath, properties);
   

Uwaga

Dane są agregowane zgodnie z zasadami dzielenia na partie, co powoduje opóźnienie kilku minut.

Python

Użyj języka Python do pozyskiwania danych w formacie nieprzetworzonym JSON.

1. Utwórz tabelę RawEvents .

   KUSTO_URI = "https://<ClusterName>.<Region>.kusto.windows.net/"
   KCSB_DATA = KustoConnectionStringBuilder.with_aad_device_authentication(KUSTO_URI, AAD_TENANT_ID)
   KUSTO_CLIENT = KustoClient(KCSB_DATA)
   TABLE = "RawEvents"
   
   CREATE_TABLE_COMMAND = ".create table " + TABLE + " (Events: dynamic)"
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_TABLE_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

2. Utwórz mapowanie JSON.

   MAPPING = "RawEventMapping"
   CREATE_MAPPING_COMMAND = ".create table " + TABLE + " ingestion json mapping '" + MAPPING + """' '[{"column":"Event","path":"$"}]'"""
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_MAPPING_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

3. Pozyskiwanie danych do RawEvents tabeli.

   INGEST_URI = "https://ingest-<ClusterName>.<Region>.kusto.windows.net/"
   KCSB_INGEST = KustoConnectionStringBuilder.with_aad_device_authentication(INGEST_URI, AAD_TENANT_ID)
   INGESTION_CLIENT = KustoIngestClient(KCSB_INGEST)
   BLOB_PATH = 'https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json'
   
   INGESTION_PROPERTIES = IngestionProperties(database=DATABASE, table=TABLE, dataFormat=DataFormat.JSON, ingestion_mapping_reference=MAPPING)
   BLOB_DESCRIPTOR = BlobDescriptor(BLOB_PATH, FILE_SIZE)
   INGESTION_CLIENT.ingest_from_blob(
       BLOB_DESCRIPTOR, ingestion_properties=INGESTION_PROPERTIES)
   

   Uwaga

   Dane są agregowane zgodnie z zasadami dzielenia na partie, co powoduje opóźnienie kilku minut.

Pozyskiwanie mapowanych rekordów JSON

W tym przykładzie pozyskasz dane rekordów JSON. Każda właściwość JSON jest mapowana na jedną kolumnę w tabeli.

KQL

1. Utwórz nową tabelę z podobnym schematem do danych wejściowych JSON. Użyjemy tej tabeli dla wszystkich poniższych przykładów i pozyskamy polecenia.

   .create table Events (Time: datetime, Device: string, MessageId: string, Temperature: double, Humidity: double)
   

2. Utwórz mapowanie JSON.

   .create table Events ingestion json mapping 'FlatEventMapping' '[{"column":"Time","Properties":{"path":"$.timestamp"}},{"column":"Device","Properties":{"path":"$.deviceId"}},{"column":"MessageId","Properties":{"path":"$.messageId"}},{"column":"Temperature","Properties":{"path":"$.temperature"}},{"column":"Humidity","Properties":{"path":"$.humidity"}}]'
   

   W tym mapowaniu, zgodnie ze schematem tabeli, timestamp wpisy zostaną pozyskane do kolumny Time jako datetime typy danych.

3. Pozyskiwanie danych do Events tabeli.

   .ingest into table Events ('https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json') with '{"format":"json", "ingestionMappingReference":"FlatEventMapping"}'
   

   Plik "simple.json" zawiera kilka rozdzielonych wierszami rekordów JSON. Format to json, a mapowanie używane w poleceniu pozyskiwania FlatEventMapping jest utworzone.

C#

1. Utwórz nową tabelę z podobnym schematem do danych wejściowych JSON. Użyjemy tej tabeli dla wszystkich poniższych przykładów i pozyskamy polecenia.

   var tableName = "Events";
   var command = CslCommandGenerator.GenerateTableCreateCommand(
      tableName,
      new[]
      {
          Tuple.Create("Time", "System.DateTime"),
          Tuple.Create("Device", "System.String"),
          Tuple.Create("MessageId", "System.String"),
          Tuple.Create("Temperature", "System.Double"),
          Tuple.Create("Humidity", "System.Double")
      }
   );
   await kustoClient.ExecuteControlCommandAsync(command);
   

2. Utwórz mapowanie JSON.

   var tableMappingName = "FlatEventMapping";
   command = CslCommandGenerator.GenerateTableMappingCreateCommand(
       IngestionMappingKind.Json,
       tableName,
       tableMappingName,
       new ColumnMapping[]
       {
           new() { ColumnName = "Time", Properties = new Dictionary<string, string> { { MappingConsts.Path, "$.timestamp" } } },
           new() { ColumnName = "Device", Properties = new Dictionary<string, string> { { MappingConsts.Path, "$.deviceId" } } },
           new() { ColumnName = "MessageId", Properties = new Dictionary<string, string> { { MappingConsts.Path, "$.messageId" } } },
           new() { ColumnName = "Temperature", Properties = new Dictionary<string, string> { { MappingConsts.Path, "$.temperature" } } },
           new() { ColumnName = "Humidity", Properties = new Dictionary<string, string> { { MappingConsts.Path, "$.humidity" } } }
       }
   );
   await kustoClient.ExecuteControlCommandAsync(command);
   

   W tym mapowaniu, zgodnie ze schematem tabeli, timestamp wpisy zostaną pozyskane do kolumny Time jako datetime typy danych.

3. Pozyskiwanie danych do Events tabeli.

   var blobPath = "https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json";
   var properties = new KustoQueuedIngestionProperties(databaseName, tableName)
   {
       Format = DataSourceFormat.json,
       IngestionMapping = new IngestionMapping { IngestionMappingReference = tableMappingName }
   };
   await ingestClient.IngestFromStorageAsync(blobPath, properties).ConfigureAwait(false);
   

   Plik "simple.json" zawiera kilka rozdzielonych wierszami rekordów JSON. Format to json, a mapowanie używane w poleceniu pozyskiwania FlatEventMapping jest utworzone.

Python

1. Utwórz nową tabelę z podobnym schematem do danych wejściowych JSON. Użyjemy tej tabeli dla wszystkich poniższych przykładów i pozyskamy polecenia.

   TABLE = "Events"
   CREATE_TABLE_COMMAND = ".create table " + TABLE + " (Time: datetime, Device: string, MessageId: string, Temperature: double, Humidity: double)"
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_TABLE_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

2. Utwórz mapowanie JSON.

   MAPPING = "FlatEventMapping"
   CREATE_MAPPING_COMMAND = ".create table Events ingestion json mapping '" + MAPPING + """' '[{"column":"Time","Properties":{"path":"$.timestamp"}},{"column":"Device","Properties":{"path":"$.deviceId"}},{"column":"MessageId","Properties":{"path":"$.messageId"}},{"column":"Temperature","Properties":{"path":"$.temperature"}},{"column":"Humidity","Properties":{"path":"$.humidity"}}]'"""
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_MAPPING_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

3. Pozyskiwanie danych do Events tabeli.

   BLOB_PATH = 'https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json'
   
   INGESTION_PROPERTIES = IngestionProperties(database=DATABASE, table=TABLE, dataFormat=DataFormat.JSON, ingestion_mapping_reference=MAPPING)
   BLOB_DESCRIPTOR = BlobDescriptor(BLOB_PATH, FILE_SIZE)
   INGESTION_CLIENT.ingest_from_blob(
       BLOB_DESCRIPTOR, ingestion_properties=INGESTION_PROPERTIES)
   

   Plik "simple.json" zawiera kilka wierszy rozdzielonych rekordami JSON. Format to json, a mapowanie używane w poleceniu pozyskiwania FlatEventMapping jest utworzone.

Pozyskiwanie wielowierszowych rekordów JSON

W tym przykładzie pozyskasz wielowierszowe rekordy JSON. Każda właściwość JSON jest mapowana na jedną kolumnę w tabeli. Plik "multilined.json" ma kilka wcięć rekordów JSON. Format multijson wskazuje odczytywanie rekordów przez strukturę JSON.

KQL

Pozyskiwanie danych do Events tabeli.

.ingest into table Events ('https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/multilined.json') with '{"format":"multijson", "ingestionMappingReference":"FlatEventMapping"}'

C#

Pozyskiwanie danych do Events tabeli.

var tableMappingName = "FlatEventMapping";
var blobPath = "https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/multilined.json";
var properties = new KustoQueuedIngestionProperties(databaseName, tableName)
{
    Format = DataSourceFormat.multijson,
    IngestionMapping = new IngestionMapping { IngestionMappingReference = tableMappingName }
};
await ingestClient.IngestFromStorageAsync(blobPath, properties).ConfigureAwait(false);

Python

Pozyskiwanie danych do Events tabeli.

MAPPING = "FlatEventMapping"
BLOB_PATH = 'https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/multilined.json'
INGESTION_PROPERTIES = IngestionProperties(database=DATABASE, table=TABLE, dataFormat=DataFormat.MULTIJSON, ingestion_mapping_reference=MAPPING)
BLOB_DESCRIPTOR = BlobDescriptor(BLOB_PATH, FILE_SIZE)
INGESTION_CLIENT.ingest_from_blob(
    BLOB_DESCRIPTOR, ingestion_properties=INGESTION_PROPERTIES)

Pozyskiwanie rekordów JSON zawierających tablice

Typy danych tablicy to uporządkowana kolekcja wartości. Pozyskiwanie tablicy JSON odbywa się za pomocą zasad aktualizacji. Kod JSON jest pozyskiwany zgodnie z tabelą pośrednią. Zasady aktualizacji uruchamia wstępnie zdefiniowaną funkcję w RawEvents tabeli, ponownie pozyskając wyniki do tabeli docelowej. Pozyskamy dane z następującą strukturą:

{
    "records":
    [
        {
            "timestamp": "2019-05-02 15:23:50.0000000",
            "deviceId": "ddbc1bf5-096f-42c0-a771-bc3dca77ac71",
            "messageId": "7f316225-839a-4593-92b5-1812949279b3",
            "temperature": 31.0301639051317,
            "humidity": 62.0791099602725
        },
        {
            "timestamp": "2019-05-02 15:23:51.0000000",
            "deviceId": "ddbc1bf5-096f-42c0-a771-bc3dca77ac71",
            "messageId": "57de2821-7581-40e4-861e-ea3bde102364",
            "temperature": 33.7529423105311,
            "humidity": 75.4787976739364
        }
    ]
}

KQL

1. update policy Utwórz funkcję, która rozszerza kolekcjęrecords, tak aby każda wartość w kolekcji odbierała oddzielny wiersz przy użyciu mv-expand operatora . Użyjemy tabeli RawEvents jako tabeli źródłowej i Events jako tabeli docelowej.

   .create function EventRecordsExpand() {
       RawEvents
       | mv-expand records = Event.records
       | project
           Time = todatetime(records["timestamp"]),
           Device = tostring(records["deviceId"]),
           MessageId = tostring(records["messageId"]),
           Temperature = todouble(records["temperature"]),
           Humidity = todouble(records["humidity"])
   }
   

2. Schemat odebrany przez funkcję musi być zgodny ze schematem tabeli docelowej. Użyj getschema operatora , aby przejrzeć schemat.

   EventRecordsExpand() | getschema
   

3. Dodaj zasady aktualizacji do tabeli docelowej. Te zasady automatycznie uruchamiają zapytanie dotyczące wszystkich nowo pozyskanych danych w tabeli pośredniej RawEvents i pozyskują wyniki w Events tabeli. Zdefiniuj zasady zerowego przechowywania, aby uniknąć utrwalania tabeli pośredniej.

   .alter table Events policy update @'[{"Source": "RawEvents", "Query": "EventRecordsExpand()", "IsEnabled": "True"}]'
   

4. Pozyskiwanie danych do RawEvents tabeli.

   .ingest into table RawEvents ('https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/array.json') with '{"format":"multijson", "ingestionMappingReference":"RawEventMapping"}'
   

5. Przejrzyj dane w Events tabeli.

   Events
   

C#

1. Utwórz funkcję aktualizacji, która rozszerza kolekcję records , tak aby każda wartość w kolekcji odbierała oddzielny wiersz przy użyciu mv-expand operatora . Użyjemy tabeli RawEvents jako tabeli źródłowej i Events jako tabeli docelowej.

   var command = CslCommandGenerator.GenerateCreateFunctionCommand(
       "EventRecordsExpand",
       "UpdateFunctions",
       string.Empty,
       null,
       @"RawEvents
       | mv-expand records = Event
       | project
           Time = todatetime(records['timestamp']),
           Device = tostring(records['deviceId']),
           MessageId = tostring(records['messageId']),
           Temperature = todouble(records['temperature']),
           Humidity = todouble(records['humidity'])",
       ifNotExists: false
   );
   await kustoClient.ExecuteControlCommandAsync(command);
   

   Uwaga

   Schemat odebrany przez funkcję musi być zgodny ze schematem tabeli docelowej.

2. Dodaj zasady aktualizacji do tabeli docelowej. Te zasady automatycznie uruchamiają zapytanie dotyczące wszystkich nowo pozyskanych danych w tabeli pośredniej RawEvents i pozyskują wyniki w Events tabeli. Zdefiniuj zasady zerowego przechowywania, aby uniknąć utrwalania tabeli pośredniej.

   command = ".alter table Events policy update @'[{'Source': 'RawEvents', 'Query': 'EventRecordsExpand()', 'IsEnabled': 'True'}]";
   await kustoClient.ExecuteControlCommandAsync(command);
   

3. Pozyskiwanie danych do RawEvents tabeli.

   var blobPath = "https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/array.json";
   var tableName = "RawEvents";
   var tableMappingName = "RawEventMapping";
   var properties = new KustoQueuedIngestionProperties(databaseName, tableName)
   {
       Format = DataSourceFormat.multijson,
       IngestionMapping = new IngestionMapping { IngestionMappingReference = tableMappingName }
   };
   await ingestClient.IngestFromStorageAsync(blobPath, properties);
   

4. Przejrzyj dane w Events tabeli.

Python

1. Utwórz funkcję aktualizacji, która rozszerza kolekcję records , tak aby każda wartość w kolekcji odbierała oddzielny wiersz przy użyciu mv-expand operatora . Użyjemy tabeli RawEvents jako tabeli źródłowej i Events jako tabeli docelowej.

   CREATE_FUNCTION_COMMAND =
       '''.create function EventRecordsExpand() {
           RawEvents
           | mv-expand records = Event
           | project
               Time = todatetime(records["timestamp"]),
               Device = tostring(records["deviceId"]),
               MessageId = tostring(records["messageId"]),
               Temperature = todouble(records["temperature"]),
               Humidity = todouble(records["humidity"])
           }'''
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_FUNCTION_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

   Uwaga

   Schemat odebrany przez funkcję musi być zgodny ze schematem tabeli docelowej.

2. Dodaj zasady aktualizacji do tabeli docelowej. Te zasady automatycznie uruchamiają zapytanie dotyczące wszystkich nowo pozyskanych danych w tabeli pośredniej RawEvents i pozyskują wyniki w Events tabeli. Zdefiniuj zasady zerowego przechowywania, aby uniknąć utrwalania tabeli pośredniej.

   CREATE_UPDATE_POLICY_COMMAND =
       """.alter table Events policy update @'[{'Source': 'RawEvents', 'Query': 'EventRecordsExpand()', 'IsEnabled': 'True'}]"""
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_UPDATE_POLICY_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

3. Pozyskiwanie danych do RawEvents tabeli.

   TABLE = "RawEvents"
   MAPPING = "RawEventMapping"
   BLOB_PATH = 'https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/array.json'
   INGESTION_PROPERTIES = IngestionProperties(database=DATABASE, table=TABLE, dataFormat=DataFormat.MULTIJSON, ingestion_mapping_reference=MAPPING)
   BLOB_DESCRIPTOR = BlobDescriptor(BLOB_PATH, FILE_SIZE)
   INGESTION_CLIENT.ingest_from_blob(
       BLOB_DESCRIPTOR, ingestion_properties=INGESTION_PROPERTIES)
   

4. Przejrzyj dane w Events tabeli.

Powiązana zawartość

• Omówienie pozyskiwania danych
• Pisanie zapytań