Procedura: Interrogare dati annidati nei database replicati di Microsoft Fabric da Azure Cosmos DB

Usare il database con mirroring in Microsoft Fabric per eseguire query sui dati JSON annidati originati da Azure Cosmos DB per NoSQL.

Prerequisiti

Un account Azure Cosmos DB per NoSQL esistente.
- Se non si ha una sottoscrizione di Azure, provare gratuitamente Azure Cosmos DB per NoSQL.
- Se si ha una sottoscrizione di Azure esistente, creare un nuovo account Azure Cosmos DB per NoSQL.
Capacità di Infrastruttura esistente. Se non si ha una capacità esistente, avviare una versione di valutazione di Fabric.
L'account Azure Cosmos DB per NoSQL deve essere configurato per il mirroring dell'infrastruttura. Per altre informazioni, vedere Requisiti dell'account.

Suggerimento

È consigliabile usare una copia di test o sviluppo dei dati di Azure Cosmos DB esistenti che possono essere recuperati rapidamente da un backup.

Creare dati annidati all'interno del database di origine

Creare elementi JSON all'interno dell'account Azure Cosmos DB per NoSQL che contengono diversi livelli di dati JSON annidati.

Passare all'account Azure Cosmos DB nel portale di Azure.
Selezionare Esplora dati dal menu delle risorse.
Usare + Nuovo contenitore per creare un nuovo contenitore. Per questa guida assegnare al contenitore TestCil nome . Il nome del database corrispondente è arbitrario.

Usare l'opzione + Nuovo elemento più volte per creare e salvare questi cinque elementi JSON.

{
  "id": "123-abc-xyz",
  "name": "A 13",
  "country": "USA",
  "items": [
    {
      "purchased": "11/23/2022",
      "order_id": "3432-2333-2234-3434",
      "item_description": "item1"
    },
    {
      "purchased": "01/20/2023",
      "order_id": "3431-3454-1231-8080",
      "item_description": "item2"
    },
    {
      "purchased": "02/20/2023",
      "order_id": "2322-2435-4354-2324",
      "item_description": "item3"
    }
  ]
}

{
  "id": "343-abc-def",
  "name": "B 22",
  "country": "USA",
  "items": [
    {
      "purchased": "01/20/2023",
      "order_id": "2431-2322-1545-2322",
      "item_description": "book1"
    },
    {
      "purchased": "01/21/2023",
      "order_id": "3498-3433-2322-2320",
      "item_description": "book2"
    },
    {
      "purchased": "01/24/2023",
      "order_id": "9794-8858-7578-9899",
      "item_description": "book3"
    }
  ]
}

{
  "id": "232-abc-x43",
  "name": "C 13",
  "country": "USA",
  "items": [
    {
      "purchased": "04/03/2023",
      "order_id": "9982-2322-4545-3546",
      "item_description": "clothing1"
    },
    {
      "purchased": "05/20/2023",
      "order_id": "7989-9989-8688-3446",
      "item_description": "clothing2"
    },
    {
      "purchased": "05/27/2023",
      "order_id": "9898-2322-1134-2322",
      "item_description": "clothing3"
    }
  ]
}

{
  "id": "677-abc-yuu",
  "name": "D 78",
  "country": "USA"
}

{
  "id": "979-abc-dfd",
  "name": "E 45",
  "country": "USA"
}

Configurare il mirroring e i prerequisiti

Configurare il mirroring per il database NoSQL di Azure Cosmos DB. Se non si è certi di come configurare il mirroring, vedere l'esercitazione configurare il database con mirroring.

Passare al portale infrastruttura.
Creare una nuova connessione e un database con mirroring usando le credenziali dell'account Azure Cosmos DB.
Attendere che la replica finisca lo snapshot iniziale dei dati.

Eseguire query sui dati annidati di base

A questo punto, usare l'endpoint di analisi SQL per creare una query in grado di gestire semplici dati JSON annidati.

Passare al database con mirroring nel portale di Infrastruttura.
Passare da Azure Cosmos DB con mirroringall'endpoint di analisi SQL.
Aprire il menu di scelta rapida per la tabella di test e selezionare Nuova query SQL.
Eseguire questa query per espandere la items matrice con OPENJSON. Questa query usa per includere elementi aggiuntivi OUTER APPLY che potrebbero non avere una matrice di elementi.
```
SELECT 
    t.name, 
    t.id, 
    t.country, 
    P.purchased, 
    P.order_id, 
    P.item_description 
FROM OrdersDB_TestC AS t
OUTER APPLY OPENJSON(t.items) WITH
(
    purchased datetime '$.purchased',
    order_id varchar(100) '$.order_id',
    item_description varchar(200) '$.item_description'
) as P
```
Suggerimento

Quando si scelgono i tipi di dati in OPENJSON, l'uso varchar(max) di per i tipi stringa potrebbe peggiorare le prestazioni delle query. Usare invece varchar(n) wher n potrebbe essere qualsiasi numero. Più basso n è, più probabilmente si noteranno prestazioni migliori delle query.

Usare CROSS APPLY nella query successiva per visualizzare solo gli elementi con una items matrice.

SELECT
    t.name,
    t.id,
    t.country,
    P.purchased,
    P.order_id,
    P.item_description 
FROM
    OrdersDB_TestC as t CROSS APPLY OPENJSON(t.items) WITH (
        purchased datetime '$.purchased',
        order_id varchar(100) '$.order_id',
        item_description varchar(200) '$.item_description' 
    ) as P

Eseguire query sui dati annidati di base con inferenza automatica dello schema

Seguire i passaggi da 1 a 3 nell'esempio precedente. Con lo stesso set di dati, è possibile creare una query per rendere flat i dati senza dover definire in modo esplicito lo schema.

Eseguire questa query per espandere la items matrice con senza OPENJSON definire lo schema. In questo modo la matrice di elementi viene appiattita di un livello impostando ogni oggetto annidato in una nuova riga.
```
SELECT
    t.name,
    t.id,
    t.country,
    p.*
FROM OrdersDB_TestC as t 
CROSS APPLY OPENJSON(t.items) p
```
Eseguire questa query per espandere ulteriormente la items matrice con senza OPENJSON definire lo schema. In questo modo la matrice di elementi viene appiattita di due livelli seperando ogni proprietà all'interno di ogni oggetto annidato in una nuova riga.
```
SELECT
    t.name,
    t.id,
    t.country,
    q.*
FROM OrdersDB_TestC as t 
CROSS APPLY OPENJSON(t.items) q
OUTER APPLY OPENJSON(t.items) p
```

Creare dati annidati in modo approfondito

Per creare questo esempio di dati annidati, aggiungere un esempio di dati annidati in modo approfondito.

Passare all'account Azure Cosmos DB nel portale di Azure.
Selezionare Esplora dati dal menu delle risorse.
Usare + Nuovo contenitore per creare un nuovo contenitore. Per questa guida assegnare al contenitore TestDil nome . Il nome del database corrispondente è arbitrario.

Usare l'opzione + Nuovo elemento più volte per creare e salvare questo elemento JSON.

{
  "id": "eadca09b-e618-4090-a25d-b424a26c2361",
  "entityType": "Package",
  "packages": [
    {
      "packageid": "fiwewsb-f342-jofd-a231-c2321",
      "storageTemperature": "69",
      "highValue": true,
      "items": [
        {
          "id": "1",
          "name": "Item1",
          "properties": {
            "weight": "2",
            "isFragile": "no"
          }
        },
        {
          "id": "2",
          "name": "Item2",
          "properties": {
            "weight": "4",
            "isFragile": "yes"
          }
        }
      ]
    },
    {
      "packageid": "d24343-dfdw-retd-x414-f34345",
      "storageTemperature": "78",
      "highValue": false,
      "items": [
        {
          "id": "3",
          "name": "Item3",
          "properties": {
            "weight": "12",
            "isFragile": "no"
          }
        },
        {
          "id": "4",
          "name": "Item4",
          "properties": {
            "weight": "12",
            "isFragile": "no"
          }
        }
      ]
    }
  ],
  "consignment": {
    "consignmentId": "ae21ebc2-8cfc-4566-bf07-b71cdfb37fb2",
    "customer": "Humongous Insurance",
    "deliveryDueDate": "2020-11-08T23:38:50.875258Z"
  }
}

Eseguire query sui dati annidati in modo approfondito

Creare infine una query T-SQL in grado di trovare i dati annidati in modo approfondito in una stringa JSON.

Aprire il menu di scelta rapida per la TestD tabella e selezionare di nuovo Nuova query SQL .

Eseguire questa query per espandere tutti i livelli di dati annidati usando OUTER APPLY con vettura.

SELECT
    P.id,
    R.packageId,
    R.storageTemperature,
    R.highValue,
    G.id,
    G.name,
    H.weight,
    H.isFragile,
    Q.consignmentId,
    Q.customer,
    Q.deliveryDueDate 
FROM
    OrdersDB_TestD as P CROSS APPLY OPENJSON(P.packages) WITH ( packageId varchar(100) '$.packageid',
    storageTemperature INT '$.storageTemperature',
    highValue varchar(100) '$.highValue',
    items nvarchar(MAX) AS JSON ) as R 
OUTER APPLY OPENJSON (R.items) WITH (
    id varchar(100) '$.id',
    name varchar(100) '$.name',
    properties nvarchar(MAX) as JSON 
) as G OUTER APPLY OPENJSON(G.properties) WITH  (
    weight INT '$.weight',
    isFragile varchar(100) '$.isFragile'
) as H OUTER APPLY OPENJSON(P.consignment) WITH  (
    consignmentId varchar(200) '$.consignmentId',
    customer varchar(100) '$.customer',
    deliveryDueDate Date '$.deliveryDueDate'
) as Q

Annotazioni

Quando si espande packages, items è rappresentato come JSON, che può facoltativamente espandersi. La items proprietà dispone di sottoproprietà come JSOn, che può anche essere espansa facoltativamente.

Eseguire infine una query che sceglie quando espandere livelli specifici di annidamento.

SELECT
    P.id,
    R.packageId,
    R.storageTemperature,
    R.highValue,
    R.items,
    Q.consignmentId,
    Q.customer,
    Q.deliveryDueDate 
FROM
    OrdersDB_TestD as P CROSS APPLY OPENJSON(P.packages) WITH (
        packageId varchar(100) '$.packageid',
        storageTemperature INT '$.storageTemperature',
        highValue varchar(100) '$.highValue',
        items nvarchar(MAX) AS JSON
    ) as R 
OUTER APPLY OPENJSON(P.consignment) WITH  (
    consignmentId varchar(200) '$.consignmentId',
    customer varchar(100) '$.customer',
    deliveryDueDate Date '$.deliveryDueDate'
) as Q

Annotazioni

I limiti delle proprietà per i livelli annidati non vengono applicati in questa esperienza di query T-SQL.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-08-22