Dotazování na data variant

Článek
09/05/2024

Důležité

Tato funkce je ve verzi Public Preview.

Tento článek popisuje operátory SQL Databricks, které můžete použít k dotazování a transformaci částečně strukturovaných dat uložených jako VARIANT. Datový VARIANT typ je k dispozici v Databricks Runtime 15.3 a vyšší.

Databricks doporučuje používat VARIANT přes řetězce JSON. Pro uživatele, kteří aktuálně používají řetězce JSON, které chtějí migrovat, najdete v tématu Jak se varianta liší od řetězců JSON?.

Pokud chcete zobrazit příklady pro dotazování částečně strukturovaných dat uložených pomocí řetězců JSON, přečtěte si téma Dotazování řetězců JSON.

Vytvoření tabulky s variantovým sloupcem

Spuštěním následujícího dotazu vytvořte tabulku s vysoce vnořenými daty uloženými jako VARIANT. Všechny příklady v tomto článku odkazují na tuto tabulku.

CREATE TABLE store_data AS
SELECT parse_json(
  '{
    "store":{
        "fruit": [
          {"weight":8,"type":"apple"},
          {"weight":9,"type":"pear"}
        ],
        "basket":[
          [1,2,{"b":"y","a":"x"}],
          [3,4],
          [5,6]
        ],
        "book":[
          {
            "author":"Nigel Rees",
            "title":"Sayings of the Century",
            "category":"reference",
            "price":8.95
          },
          {
            "author":"Herman Melville",
            "title":"Moby Dick",
            "category":"fiction",
            "price":8.99,
            "isbn":"0-553-21311-3"
          },
          {
            "author":"J. R. R. Tolkien",
            "title":"The Lord of the Rings",
            "category":"fiction",
            "reader":[
              {"age":25,"name":"bob"},
              {"age":26,"name":"jack"}
            ],
            "price":22.99,
            "isbn":"0-395-19395-8"
          }
        ],
        "bicycle":{
          "price":19.95,
          "color":"red"
        }
      },
      "owner":"amy",
      "zip code":"94025",
      "fb:testid":"1234"
  }'
) as raw

Dotazování polí ve sloupci varianty

Syntaxe pro dotazování řetězců JSON a dalších složitých datových typů v Azure Databricks se vztahuje na VARIANT data, včetně následujících:

Slouží : k výběru polí nejvyšší úrovně.
Použijte . nebo [<key>] vyberte vnořená pole s pojmenovanými klíči.
Slouží [<index>] k výběru hodnot z polí.

Poznámka:

Pokud název pole obsahuje tečku (.), musíte ho utéct hranatými závorkami ([ ]). Například následující dotaz vybere pole s názvem zip.code:

SELECT raw:['zip.code'] FROM store_data

Extrahování pole variant nejvyšší úrovně

Pokud chcete extrahovat pole, zadejte název pole JSON v cestě pro extrakci. V názvech polí se vždy rozlišují malá a velká písmena.

SELECT raw:owner FROM store_data

+-------+
| owner |
+-------+
| "amy" |
+-------+

-- Use backticks to escape special characters.
SELECT raw:`zip code`, raw:`fb:testid` FROM store_data

+----------+-----------+
| zip code | fb:testid |
+----------+-----------+
| "94025"  | "1234"    |
+----------+-----------+

Pokud nelze najít cestu, je NULL výsledek typu VARIANT.

Extrahování vnořených polí variant

Zadáváte vnořená pole prostřednictvím zápisu tečky nebo pomocí hranatých závorek. V názvech polí se vždy rozlišují malá a velká písmena.

-- Use dot notation
SELECT raw:store.bicycle FROM store_data

+------------------+
| bicycle          |
+------------------+
| {                |
|   "color":"red", |
|   "price":19.95  |
| }                |
+------------------+

-- Use brackets
SELECT raw:store['bicycle'] FROM store_data

+------------------+
| bicycle          |
+------------------+
| {                |
|   "color":"red", |
|   "price":19.95  |
| }                |
+------------------+

Pokud nelze najít cestu, je NULL výsledek typu VARIANT.

Extrahování hodnot z variantových polí

Prvky indexujete v polích s hranatými závorkami. Indexy jsou založené na 0.

-- Index elements
SELECT raw:store.fruit[0], raw:store.fruit[1] FROM store_data

+-------------------+------------------+
| fruit             | fruit            |
+-------------------+------------------+
| {                 | {                |
|   "type":"apple", |   "type":"pear", |
|   "weight":8      |   "weight":9     |
| }                 | }                |
+-------------------+------------------+

Pokud cestu nelze najít nebo pokud je index pole mimo hranice, výsledek je NULL.

Zploštěné objekty a pole variant

Funkci generátoru variant_explode s hodnotami tabulky lze použít k zploštění VARIANT polí a objektů.

Protože variant_explode je funkce generátoru, použijete ji jako součást FROM klauzule, nikoli v SELECT seznamu, jako v následujících příkladech:

SELECT key, value
  FROM store_data,
  LATERAL variant_explode(store_data.raw:store);

+-------+--------------------+
|    key|               value|
+-------+--------------------+
| basket|[[1,2,{"a":"x","b...|
|bicycle|{"color":"red","p...|
|   book|[{"author":"Nigel...|
|  fruit|[{"type":"apple",...|
+-------+--------------------+

SELECT pos, value
  FROM store_data,
  LATERAL variant_explode(store_data.raw:store.basket[0]);

+---+-----------------+
|pos|            value|
+---+-----------------+
|  0|                1|
|  1|                2|
|  2|{"a":"x","b":"y"}|
+---+-----------------+

Pravidla přetypování variantního typu

Pole a skaláry můžete ukládat pomocí VARIANT typu. Při pokusu o přetypování variantních typů na jiné typy platí normální pravidla přetypování pro jednotlivé hodnoty a pole s následujícími dalšími pravidly.

Poznámka:

variant_get a try_variant_get použijte argumenty typu a postupujte podle těchto pravidel přetypování.

Source type	Chování
`VOID`	Výsledek je `NULL` typu `VARIANT`.
`ARRAY<elementType>`	Musí `elementType` být typ, na který lze přetypovat `VARIANT`.

Při odvození typu s schema_of_variant nebo schema_of_variant_aggse funkce vrátí k VARIANT typu, nikoli STRING k typu, pokud existují konfliktní typy, které nelze vyřešit.

Hodnoty můžete použít :: nebo cast přetypovat na podporované datové typy.

-- price is returned as a double, not a string
SELECT raw:store.bicycle.price::double FROM store_data

+------------------+
| price            |
+------------------+
| 19.95            |
+------------------+

-- cast into more complex types
SELECT cast(raw:store.bicycle AS STRUCT<price DOUBLE, color STRING>) bicycle FROM store_data;
-- `::` also supported
SELECT raw:store.bicycle::STRUCT<price DOUBLE, color STRING> bicycle FROM store_data;

+------------------+
| bicycle          |
+------------------+
| {                |
|   "price":19.95, |
|   "color":"red"  |
| }                |
+------------------+

Variantní pravidla null

Varianty můžou obsahovat dva druhy hodnot null:

SQL: SQL NULLNULLs indikuje, že hodnota chybí. Jsou to stejné NULLjako při práci se strukturovanými daty.
Varianta: Varianta NULLNULLs indikuje, že varianta explicitně obsahuje NULL hodnotu. Nejedná se o stejné hodnoty jako sql NULL, protože NULL hodnota je uložená v datech.

is_variant_null Pomocí funkce určete, zda je hodnota varianty variantou NULL.

SELECT
  is_variant_null(parse_json(NULL)) AS sql_null,
  is_variant_null(parse_json('null')) AS variant_null,
  is_variant_null(parse_json('{ "field_a": null }'):field_a) AS variant_null_value,
  is_variant_null(parse_json('{ "field_a": null }'):missing) AS missing_sql_value_null

+--------+------------+------------------+----------------------+
|sql_null|variant_null|variant_null_value|missing_sql_value_null|
+--------+------------+------------------+----------------------+
|   false|        true|              true|                 false|
+--------+------------+------------------+----------------------+

Sdílet prostřednictvím