Anvisningar: Fråga efter kapslade data i Microsoft Fabric-speglade databaser från Azure Cosmos DB (förhandsversion)

2025-08-22

Använd den speglade databasen i Microsoft Fabric för att fråga kapslade JSON-data från Azure Cosmos DB för NoSQL.

Viktigt!

Spegling för Azure Cosmos DB är för närvarande i förhandsversion. Produktionsarbetsbelastningar stöds inte under förhandsversionen. För närvarande stöds endast Azure Cosmos DB för NoSQL-konton.

Förutsättningar

Ett befintligt Azure Cosmos DB för NoSQL-konto.
- Om du inte har en Azure-prenumeration kan du prova Azure Cosmos DB utan kostnad för NoSQL.
- Om du har en befintlig Azure-prenumeration skapar du ett nytt Azure Cosmos DB för NoSQL-konto.
En befintlig Fabrickapacitet. Om du inte har någon befintlig kapacitet, starta en Fabric-utvärderingsversion.
Azure Cosmos DB för NoSQL-kontot måste konfigureras för Fabric-spegeling. Mer information finns i kontokrav.

Tips/Råd

Under den offentliga förhandsversionen rekommenderar vi att du använder en test- eller utvecklingskopia av dina befintliga Azure Cosmos DB-data som kan återställas snabbt från en säkerhetskopia.

Skapa kapslade data i källdatabasen

Skapa JSON-objekt i ditt Azure Cosmos DB for NoSQL-konto som innehåller olika nivåer av kapslade JSON-data.

Gå till ditt Azure Cosmos DB-konto i Azure-portalen.
Välj Datautforskaren på resursmenyn.
Använd + Ny container för att skapa en ny container. I den här guiden namnger du containern TestC. Motsvarande databasnamn är godtyckligt.

Använd alternativet + Nytt objekt flera gånger för att skapa och spara dessa fem JSON-objekt.

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

Konfigurera spegling och förutsättningar

Konfigurera spegling för Azure Cosmos DB för NoSQL-databasen. Om du är osäker på hur du konfigurerar spegling, kan du läsa i handledningen för att konfigurera en speglad databas.

Gå till Fabricportalen.
Skapa en ny anslutning och speglad databas med autentiseringsuppgifterna för ditt Azure Cosmos DB-konto.
Vänta tills replikeringen har slutfört den första ögonblicksbilden av data.

Fråga efter grundläggande kapslade data

Använd nu SQL-analysslutpunkten för att skapa en fråga som kan hantera enkla kapslade JSON-data.

Navigera till den speglade databasen i Fabric-portalen.
Växla från Speglad Azure Cosmos DB till SQL-analysslutpunkt.
Öppna snabbmenyn för testtabellen och välj Ny SQL-fråga.
Kör den här frågan för att expandera matrisen items med OPENJSON. Den här frågan används OUTER APPLY för att inkludera extra objekt som kanske inte har en objektmatris.
```
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
```
Tips/Råd

När du väljer datatyperna i OPENJSONkan användning för varchar(max) strängtyper försämra frågeprestanda. Använd istället varchar(n) där n kan vara valfritt tal. Ju lägre n är, desto mer sannolikt ser du bättre frågeprestanda.

Använd CROSS APPLY i nästa fråga om du bara vill visa objekt med en items matris.

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

Köra frågor mot grundläggande kapslade data med automatisk schemainferens

Följ steg 1–3 i föregående exempel. Med samma datauppsättning kan vi skapa en fråga för att platta ut data utan att uttryckligen behöva definiera schemat.

Kör den här frågan om du vill expandera matrisen items med OPENJSON utan att definiera schemat. Detta förenklar objektmatrisen en nivå genom att avgränsa varje kapslat objekt till en ny rad.
```
SELECT
    t.name,
    t.id,
    t.country,
    p.*
FROM OrdersDB_TestC as t 
CROSS APPLY OPENJSON(t.items) p
```
Kör den här frågan för att ytterligare expandera matrisen items med OPENJSON utan att definiera schemat. Detta jämnar ut objektmatrisen med två nivåer genom att avgränsa varje egenskap inom varje kapslat objekt till en ny rad.
```
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
```

Skapa djupt kapslade data

Om du vill bygga vidare på det här kapslade dataexemplet ska vi lägga till ett djupt kapslat dataexempel.

Gå till ditt Azure Cosmos DB-konto i Azure-portalen.
Välj Datautforskaren på resursmenyn.
Använd + Ny container för att skapa en ny container. I den här guiden namnger du containern TestD. Motsvarande databasnamn är godtyckligt.

Använd alternativet + Nytt objekt flera gånger för att skapa och spara det här JSON-objektet.

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

Fråga efter djupt kapslade data

Skapa slutligen en T-SQL-fråga som kan hitta data djupt kapslade i en JSON-sträng.

Öppna snabbmenyn för TestD tabellen och välj Ny SQL-fråga igen.

Kör den här frågan för att expandera alla nivåer av kapslade data med hjälp av OUTER APPLY sändning.

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

Anmärkning

När packages expanderas, representeras items som JSON, vilket kan väljas att expandera. Egenskapen items har underegenskaper som JSOn som också kan expanderas.

Kör slutligen en fråga som väljer när specifika kapslingsnivåer ska expanderas.

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

Anmärkning

Egenskapsgränser för kapslade nivåer tillämpas inte i den här T-SQL-frågeupplevelsen.

Feedback

Var den här sidan till hjälp?