A JSON használatának első lépései – Lekérdezési nyelv a Cosmos DB-ben (az Azure-ban és a Fabricben)

A következőre érvényes:: ✅ Azure Cosmos DB for NoSQL, ✅ Cosmos DB in Microsoft Fabric

A Lekérdezési nyelv középpontjában a JavaScript Object Notation (JSON) használata áll. Az elemek JSON-ként vannak tárolva, és minden lekérdezés, kifejezés és típus JSON-adatokkal való együttműködésre szolgál. Magára a JSON-ra vonatkozó további információkért lásd a hivatalos JSON-specifikációt.

Íme néhány fontos tudnivaló a JSON-ról ebben a kontextusban:

A JSON-objektumok mindig ezzel { kezdődnek és végződnek }.
A tulajdonságok egymásba ágyazhatók .
A tulajdonságértékek tömbök lehetnek.
A tulajdonságnevek megkülönböztetik a kis- és nagybetűket.
A tulajdonságnevek bármilyen sztringet tartalmazhatnak, szóközökkel vagy speciális karakterekkel is.

Beágyazott tulajdonságok

A beágyazott JSON-tulajdonságokat pont jelöléssel érheti el. Ez ugyanúgy működik, mint a legtöbb programozási nyelv tulajdonságainak elérése.

Íme egy példadokumentum beágyazott JSON-val:

[
  {
    "name": "Heatker Women's Jacket",
    "category": "apparel",
    "slug": "heatker-women-s-jacket",
    "sizes": [
      {
        "key": "s",
        "description": "Small"
      }
    ],
    "metadata": {
      "link": "https://www.adventure-works.com/heatker-women-s-jacket/68719520138.p"
    }
  }
]

Ezután ugyanazokat a beágyazott tulajdonságokat vetítheti ki a lekérdezésekben:

SELECT
  p.name,
  p.category,
  p.metadata.link
FROM
  products p
WHERE
  p.name = "Heatker Women's Jacket"

A várt kimenet pedig a következő lesz:

[
  {
    "name": "Heatker Women's Jacket",
    "category": "apparel",
    "link": "https://www.adventure-works.com/heatker-women-s-jacket/68719520138.p"
  }
]

Tömbök és készletek

A JSON támogatja a tömböket, és használhatja őket a lekérdezésekben. Egy adott elem eléréséhez használja a tömbben elfoglalt helyét.

Az előző szakasz példáját használva a tömb egy eleméhez hozzáférhetünk az indexével. Ha például a tömb első eleméhez 0 szeretnénk hozzáférni, akkor egy indexet használnánk, mivel ez egy nulla alapú indexrendszer a lekérdezési nyelv tömbjeihez:

SELECT
  p.name,
  p.sizes[0].description AS defaultSize
FROM
  products p
WHERE
  p.name = "Heatker Women's Jacket"

Ez a lekérdezés a következő JSON-objektumot eredményezi:

[
  {
    "name": "Heatker Women's Jacket",
    "defaultSize": "Small"
  }
]

Most tekintsünk egy nagyobb tömböt tartalmazó példát:

[
  {
    "name": "Vencon Kid's Coat",
    "category": "apparel",
    "slug": "vencon-kid-s-coat",
    "colors": [
      "cardinal",
      "disco"
    ],
    "sizes": [
      {
        "key": "m",
        "description": "Medium"
      },
      {
        "key": "l",
        "description": "Large"
      },
      {
        "key": "xl",
        "description": "Extra Large"
      }
    ]
  }
]

A tömbök összes elemével gyakran alkonyatokat vagy öncsatlakozásokat szeretne használni. Ha például az egyes színeket külön sorként szeretné lekérni:

SELECT
  p.name,
  c AS color
FROM
  products p
JOIN
  c IN p.colors
WHERE
  p.name = "Vencon Kid's Coat"

Ez a következőhöz hasonló JSON-tömböt eredményezne:

[
  {
    "name": "Vencon Kid's Coat",
    "color": "cardinal"
  },
  {
    "name": "Vencon Kid's Coat",
    "color": "disco"
  }
]

Ha ellenőrizni szeretné, hogy létezik-e egy adott érték egy tömbben, használhatja a tömböt a szűrőben a WHERE kulcsszó után. Ez a példa egy alquery használatával szűri a tömb elemeit:

SELECT VALUE
  p.name
FROM
  products p
WHERE
  EXISTS(SELECT VALUE
    c
  FROM
    c IN p.sizes
  WHERE
    c.description LIKE "%Large")

Ez a lekérdezés sztringek egy sima JSON-tömbjéhez vezet, amely a példában szereplő elemet is tartalmazza:

[
  ...,
  "Vencon Kid's Coat"
  ...
]

Végül több tulajdonság kombinálásával tömböket is létrehozhat. Ebben a példában a rendszer több tulajdonságot kombinál egy tömb létrehozásához metadata :

SELECT
  p.name,
  [
    p.category,
    p.slug,
    p.metadata.link
  ] AS metadata
FROM
  products p
WHERE
  p.name = "Heatker Women's Jacket"

[
  {
    "name": "Heatker Women's Jacket",
    "metadata": [
      "apparel",
      "heatker-women-s-jacket",
      "https://www.adventure-works.com/heatker-women-s-jacket/68719520138.p"
    ]
  }
]

Iteration

A lekérdezési nyelv támogatja a JSON-tömbök iterációit a INFROM forrásban lévő kulcsszó használatával.

Tekintse meg ezt a példaadatkészletet:

[
  {
    "name": "Pila Swimsuit",
    "colors": [
      "regal-blue",
      "rose-bud-cherry"
    ],
    "sizes": [
      {
        "key": "m",
        "description": "Medium"
      },
      {
        "key": "l",
        "description": "Large"
      },
      {
        "key": "xl",
        "description": "Extra Large"
      }
    ]
  },
  {
    "name": "Makay Bikini",
    "colors": [
      "starship"
    ],
    "sizes": [
      {
        "key": "s",
        "description": "Small"
      },
      {
        "key": "m",
        "description": "Medium"
      },
      {
        "key": "l",
        "description": "Large"
      }
    ]
  }
]

Ez az első példa a IN kulcsszó használatával hajtja végre az iterációt az colors egyes termékek tulajdonságán:

SELECT
  *
FROM
  p IN p.colors

[
  "regal-blue",
  "rose-bud-cherry",
  "starship"
]

A tömb egyes bejegyzéseit a záradék használatával WHERE is szűrheti. Ebben a példában a sizes tulajdonság szűrve van:

SELECT
  p.key
FROM
  p IN p.sizes
WHERE
  p.description LIKE "%Large"

[
  {
    "key": "l"
  },
  {
    "key": "xl"
  },
  {
    "key": "l"
  }
]

Ugyanezzel a kulcsszóval IN összesítheti egy tömb iterációjának eredményét. Ebben a példában a lekérdezés a tároló összes elemében összegzett címkék számát adja vissza:

SELECT VALUE
  COUNT(1)
FROM
  p IN p.sizes

Megjegyzés:

Az iteráció kulcsszójának használatakor IN nem szűrhet és nem vethet ki tulajdonságokat a tömbön kívül. Ehelyett önillesztéseket használ.

Null és nem definiált értékek

Ha egy tulajdonság nem szerepel a dokumentumban, az értéke .undefined Ha egy tulajdonság jelen van, de be van állítva null, az egy explicit módon beállított érték. A lekérdezések közötti null különbségtétel és undefined egy fontos különbség, amely zavart okozhat a lekérdezésekben.

Ennek a JSON-objektumnak például a tulajdonság értéke undefined lehet, sku mert a tulajdonság soha nem lett definiálva:

[
  {
    "name": "Witalica helmet",
    "category": "gear",
  }
]

Ennek a JSON-objektumnak ugyanahhoz a tulajdonsághoz van értéke null , mert a tulajdonság még nincs megadva értékgel:

[
  {
    "name": "Witalica helmet",
    "category": "gear",
    "sku": null
  }
]

Az ilyen eseteket beépített függvények ellenőrzik:

IS_NULLellenőrzi, hogy egy tulajdonság .null
IS_DEFINED ellenőrzi, hogy létezik-e tulajdonság (nem undefined).

Így ellenőrizheti mindkettőt:

SELECT
  IS_DEFINED(p.sku) AS isSkuDefined,
  IS_NULL(p.sku) AS isSkuDefinedButNull
FROM
  products p

Szögletes zárójel jelölése

Bár a legtöbb példa pont jelöléssel adja meg a tulajdonságokat, a zárójel jelölésével mindig ugyanazokat a tulajdonságokat adhatja meg.

Kezdjük egy egyszerű objektummal egy beágyazott objektummal a metadata tulajdonság értékeként:

[
  {
    "name": "Hikomo Sandals",
    "metadata": {
      "link": "https://www.adventure-works.com/hikomo-sandals/68719519305.p"
    }
  }
]

Ehhez az objektumhoz három különböző módon hivatkozhatunk a metadata.link tulajdonságra pont - és szögletes zárójeljelek kombinációjával:

SELECT
  p.metadata.link AS metadataLinkDotNotation,
  p["metadata"]["link"] AS metadataLinkBracketNotation,
  p.metadata["link"] AS metadataLinkMixedNotation
FROM
  products p
WHERE
  p.name = "Hikomo Sandals"

[
  {
    "metadataLinkDotNotation": "https://www.adventure-works.com/hikomo-sandals/68719519305.p",
    "metadataLinkBracketNotation": "https://www.adventure-works.com/hikomo-sandals/68719519305.p",
    "metadataLinkMixedNotation": "https://www.adventure-works.com/hikomo-sandals/68719519305.p"
  }
]

Jótanács

Ha egy tulajdonságnév szóközöket, speciális karaktereket tartalmaz, vagy egy fenntartott szónak felel meg, a tulajdonság megadásához szögletes zárójel jelölést kell használnia.

JSON-kifejezések

JSON-objektumokat közvetlenül a lekérdezés eredményei között hozhat létre. Kezdjük például ezzel a JSON-tömbdel:

[
  {
    "name": "Diannis Watch",
    "category": "apparel",
    "detailCategory": "apparel-accessories-watches",
    "slug": "diannis-watch",
    "sku": "64801",
    "price": 98,
    "quantity": 159
  },
  {
    "name": "Confira Watch",
    "category": "apparel",
    "detailCategory": "apparel-accessories-watches",
    "slug": "confira-watch",
    "sku": "64800",
    "price": 105,
    "quantity": 193
  }
]

A legegyszerűbb szintaxissal egy viszonylag lapos JSON-objektum tulajdonságneveit szögletes zárójelekkel ({/}) és a beágyazott JSON-szintaxissal befolyásolhatja egy NoSQL-lekérdezésben:

SELECT {
  "brandName": p.name,
  "department": p.category
}
FROM
  products p
WHERE
  p.detailCategory = "apparel-accessories-watches"

[
  {
    "$1": {
      "brandName": "Diannis Watch",
      "department": "apparel"
    }
  },
  {
    "$1": {
      "brandName": "Confira Watch",
      "department": "apparel"
    }
  }
]

Az előző példában az eredménynek kikövetkeztetett neve $1 volt, mert nem definiált explicit nevet. Ebben a következő példában az eredmény egy alias használatával definiált explicit névvel product rendelkezik:

SELECT {
  "brandName": p.name,
  "department": p.category
} AS product
FROM
  products p
WHERE
  p.detailCategory = "apparel-accessories-watches"

[
  {
    "product": {
      "brandName": "Diannis Watch",
      "department": "apparel"
    }
  },
  {
    "product": {
      "brandName": "Confira Watch",
      "department": "apparel"
    }
  }
]

Másik lehetőségként az eredmény összesimítható a VALUE kulcsszóval egy SELECT VALUE utasításban:

SELECT VALUE {
  "brandName": p.name,
  "department": p.category
}
FROM
  products p
WHERE
  p.detailCategory = "apparel-accessories-watches"

[
  {
    "brandName": "Diannis Watch",
    "department": "apparel"
  },
  {
    "brandName": "Confira Watch",
    "department": "apparel"
  }
]

Tovább haladva a JSON szintaxissal "átformázhatja" az eredmény JSON-objektumát, hogy olyan tömböket, alobjektumokat és egyéb JSON-szerkezeteket tartalmazzon, amelyek esetleg nem explicit módon vannak definiálva az eredeti elemben. Ez a technika akkor hasznos, ha az ügyfélalkalmazás olyan adott sémában vár adatokat, amelyek nem egyeznek a mögöttes adatokkal.

Fontolja meg ezt a JSON-sémát, például:

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "required": [
    "id",
    "category",
    "financial"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "category": {
      "type": "object",
      "properties": {
        "department": {
          "type": "string"
        },
        "section": {
          "type": "string"
        }
      },
      "required": [
        "department"
      ]
    },
    "inventory": {
      "type": "object",
      "properties": {
        "stock": {
          "type": "number"
        }
      }
    },
    "financial": {
      "type": "object",
      "properties": {
        "listPrice": {
          "type": "number"
        }
      },
      "required": [
        "listPrice"
      ]
    }
  }
}

Ez a séma lehetővé tenné egy ilyen formátumban strukturált JSON-objektumot:

[
  {
    "id": "[string]",
    "name": "[string]",
    "category": {
      "department": "[string]",
      "section": "[string]"
    },
    "inventory": {
      "stock": [number]
    },
    "financial": {
      "listPrice": [number]
    }
  }
]

Ez a NoSQL-lekérdezés újraképzi az eredeti objektumot[s], hogy megfeleljen az új sémának:

SELECT VALUE {
  "id": p.sku,
  "name": p.name,
  "category": {
    "department": p.category,
    "section": p.detailCategory
  },
  "inventory": {
    "stock": p.quantity
  },
  "financial": {
    "listPrice": p.price
  }
}
FROM
  products p
WHERE
  p.detailCategory = "apparel-accessories-watches"

[
  {
    "id": "64801",
    "name": "Diannis Watch",
    "category": {
      "department": "apparel",
      "section": "apparel-accessories-watches"
    },
    "inventory": {
      "stock": 159
    },
    "financial": {
      "listPrice": 98
    }
  },
  {
    "id": "64800",
    "name": "Confira Watch",
    "category": {
      "department": "apparel",
      "section": "apparel-accessories-watches"
    },
    "inventory": {
      "stock": 193
    },
    "financial": {
      "listPrice": 105
    }
  }
]

Tároló aliasai

Alapértelmezés szerint a FROM kulcsszó után használt kifejezés arra a tárolóra hivatkozik, amely a lekérdezés célja. Maga a kifejezés NEM szükséges a tároló nevével való egyeztetéshez.

Ha például a tároló neve el van nevezve products, a lekérdezések bármelyike megfelelően működik, és mind a products tárolóra hivatkozik, feltéve, hogy ez a tároló a lekérdezés célja :

SELECT
  products.id
FROM
  products

SELECT
  p.id
FROM
  p

SELECT
  items.id
FROM
  items

SELECT
  targetContainer.id
FROM
  targetContainer

Ha tömörebbé szeretné tenni a NoSQL-lekérdezést, gyakran előfordul, hogy a tároló nevét rövidebb névvel aliasozza. Az aliasolás a AS következő kulcsszóval végezhető el:

SELECT
  p.id
FROM
  products AS p

A lekérdezési nyelv rövidített szintaxissal is rendelkezik, ahol az alias közvetlenül a céltároló hivatkozása után definiálható kulcsszó AS nélkül. Ez a rövidítés funkcionálisan egyenértékű a AS kulcsszó használatával:

SELECT
  p.id
FROM
  products p

Tulajdonság aliasai

Az eredmények mezőit az azonos AS kulcsszóval definiált aliasok használatával is átnevezheti. A következő néhány példában tekintse át ezt a mintaadatokat:

[
  {
    "name": "Oceabelle Scarf",
    "detailCategory": "apparel-accessories-scarfs-and-socks",
    "metadata": {
      "link": "https://www.adventure-works.com/oceabelle-scarf/68719522190.p"
    }
  },
  {
    "name": "Shinity Socks",
    "detailCategory": "apparel-accessories-scarfs-and-socks",
    "metadata": {
      "link": "https://www.adventure-works.com/shinity-socks/68719522161.p"
    }
  },
  {
    "name": "Horric Socks",
    "detailCategory": "apparel-accessories-scarfs-and-socks",
    "metadata": {
      "link": "https://www.adventure-works.com/horric-socks/68719522177.p"
    }
  }
]

Ebben az első példában az metadataLink aliast használja a metadata.link tulajdonság értéke:

SELECT
  p.name,
  p.metadata.link AS metadataLink
FROM
  products p

[
  {
    "name": "Oceabelle Scarf",
    "metadataLink": "https://www.adventure-works.com/oceabelle-scarf/68719522190.p"
  },
  {
    "name": "Shinity Socks",
    "metadataLink": "https://www.adventure-works.com/shinity-socks/68719522161.p"
  },
  {
    "name": "Horric Socks",
    "metadataLink": "https://www.adventure-works.com/horric-socks/68719522177.p"
  }
]

Fontos

Az aliasolással nem vetíthet ki értéket tulajdonságnévként szóközzel, speciális karakterrel vagy fenntartott szóval. Ha egy érték előrejelzését például szóközzel rendelkező tulajdonságnévre szeretné módosítani, JSON-kifejezést kell használnia.

Például

SELECT VALUE {
  "product name": p.name,
  "from": p.metadata.link,
  "detail/category": p.detailCategory
}
FROM
  products p
WHERE
  p.detailCategory = "apparel-accessories-scarfs-and-socks"

[
  {
    "product name": "Oceabelle Scarf",
    "from": "https://www.adventure-works.com/oceabelle-scarf/68719522190.p",
    "detail/category": "apparel-accessories-scarfs-and-socks"
  },
  {
    "product name": "Shinity Socks",
    "from": "https://www.adventure-works.com/shinity-socks/68719522161.p",
    "detail/category": "apparel-accessories-scarfs-and-socks"
  },
  {
    "product name": "Horric Socks",
    "from": "https://www.adventure-works.com/horric-socks/68719522177.p",
    "detail/category": "apparel-accessories-scarfs-and-socks"
  }
]

Ha egy NoSQL-lekérdezés két azonos nevű tulajdonsággal rendelkezik, aliasok használatával nevezze át a tulajdonságok egyikét vagy mindkettőt, hogy azok egyértelműek legyenek a tervezett eredményben.

Vegye figyelembe a mintaadatokat:

[
  {
    "name": "Oceabelle Scarf",
    "detailCategory": "apparel-accessories-scarfs-and-socks",
    "sizes": [
      {
        "key": "s"
      },
      ...
    ],
    "tags": [
      ...
    ]
  },
  {
    "name": "Shinity Socks",
    "detailCategory": "apparel-accessories-scarfs-and-socks",
    "sizes": [
      ...
      {
        "key": "10"
      },
      ...
    ],
    "tags": [
      ...
      {
        "key": "length"
      }
    ]
  },
  {
    "name": "Horric Socks",
    "detailCategory": "apparel-accessories-scarfs-and-socks",
    "sizes": [
      ...
      {
        "key": "7"
      },
      ...
    ],
    "tags": [
      {
        "key": "fabric"
      },
      ...
    ]
  }
]

Megjegyzés:

Ebben a mintaadatokban és a lekérdezés eredményében több tulajdonság és érték is el lett távolítva a rövidség kedvéért.

Ez a NoSQL-lekérdezés a p.sizes[].keyp.tags[].key termékközi eredményben szereplő tulajdonságokat adja vissza, de az ütközések elkerülése érdekében az egyes key tulajdonságokat aliasként fogja megadni:

SELECT
  p.name,
  s.key AS sizeKey,
  t.key AS tagKey
FROM
  products p
JOIN
  s IN p.sizes
JOIN
  t in p.tags
WHERE
  p.detailCategory = "apparel-accessories-scarfs-and-socks"

[
  {
    "name": "Oceabelle Scarf",
    "sizeKey": "s",
    "tagKey": "fabric"
  },
  ...
  {
    "name": "Shinity Socks",
    "sizeKey": "10",
    "tagKey": "length"
  },
  ...
  {
    "name": "Horric Socks",
    "sizeKey": "7",
    "tagKey": "fabric"
  }
]

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-11-19