v SQLite

-> a ->> operátory byly představeny ve verzi SQLite 3.38.0, která byla vydána 22. února 2022. Oba operátory se používají pro extrahování dílčích komponent JSON. Ale je mezi nimi jemný rozdíl.

Rozdíl

Rozdíl mezi těmito operátory je následující:

• -> operátor vždy vrací JSON reprezentace zadané dílčí komponenty
• ->> operátor vždy vrací SQL reprezentace zadané dílčí komponenty

Příklad

Zde je příklad, který ilustruje rozdíl mezi těmito dvěma operátory:

SELECT 
    '{ "name" : "Wag", "type" : "Dog" }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : "Dog" }' ->> '$.type' AS "->>";

Výsledek:

+-------+-----+
|  ->   | ->> |
+-------+-----+
| "Dog" | Dog |
+-------+-----+

Vidíme, že -> vrátil hodnotu uzavřenou ve dvojitých uvozovkách, zatímco ->> ne.

To proto, že -> vrátil JSON reprezentaci hodnoty a ->> vrátil reprezentaci SQL.

Čísla

Zde je příklad použití čísel:

SELECT 
    '{ "age" : 10 }' -> '$.age' AS "->",
    '{ "age" : 10 }' ->> '$.age' AS "->>";

Výsledek:

+----+-----+
| -> | ->> |
+----+-----+
| 10 | 10  |
+----+-----+

Zde je to, co se stane, když použijeme typeof() funkce pro získání typu SQL:

SELECT 
    typeof('{ "age" : 10 }' -> '$.age') AS "->",
    typeof('{ "age" : 10 }' ->> '$.age') AS "->>";

Výsledek:

+------+---------+
|  ->  |   ->>   |
+------+---------+
| text | integer |
+------+---------+

Pokud však použijeme json_type() , získáme typ JSON:

SELECT 
    json_type('{ "age" : 10 }' -> '$.age') AS "->",
    json_type('{ "age" : 10 }' ->> '$.age') AS "->>";

Výsledek:

+---------+---------+
|   ->    |   ->>   |
+---------+---------+
| integer | integer |
+---------+---------+

Zde je příklad, který používá reálné číslo:

SELECT 
    typeof('{ "age" : 1.2 }' -> '$.age') AS "->",
    typeof('{ "age" : 1.2 }' ->> '$.age') AS "->>";

Výsledek:

+------+------+
|  ->  | ->>  |
+------+------+
| text | real |
+------+------+

A pomocí json_type() :

SELECT 
    json_type('{ "age" : 1.2 }' -> '$.age') AS "->",
    json_type('{ "age" : 1.2 }' ->> '$.age') AS "->>";

Výsledek:

+------+------+
|  ->  | ->>  |
+------+------+
| real | real |
+------+------+

Nulové hodnoty

Pokud dokument JSON obsahuje null a poté -> vrátí JSON reprezentaci null a ->> jednoduše vrátí hodnotu null.

Zde je příklad, který demonstruje, co tím myslím:

SELECT 
    '{ "name" : "Wag", "type" : null }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : null }' ->> '$.type' AS "->>";

Výsledek:

+------+-----+
|  ->  | ->> |
+------+-----+
| null |     |
+------+-----+

Ve výchozím nastavení rozhraní příkazového řádku SQLite (CLI) vrací prázdný řetězec vždy, když je vrácena hodnota null. Z našeho příkladu tedy vidíme, že -> vrátil skutečnou hodnotu JSON null, zatímco ->> vrátil skutečnou hodnotu null.

Abychom to dále demonstrovali, můžeme nastavit naši .nullvalue na něco jiného než prázdný řetězec:

.nullvalue n/a

Nyní spusťte znovu předchozí dotaz:

SELECT 
    '{ "name" : "Wag", "type" : null }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : null }' ->> '$.type' AS "->>";

Výsledek:

+------+-----+
|  ->  | ->> |
+------+-----+
| null | n/a |
+------+-----+

Tentokrát n/a byl výstup pro ->> operátor namísto prázdného řetězce.

A zde je to, co se stane, když předáme výstup do typeof() a json_type() funkce:

SELECT 
    typeof('{ "name" : "Wag", "type" : null }' -> '$.type') AS "->",
    typeof('{ "name" : "Wag", "type" : null }' ->> '$.type') AS "->>";

SELECT 
    json_type('{ "name" : "Wag", "type" : null }' -> '$.type') AS "->",
    json_type('{ "name" : "Wag", "type" : null }' ->> '$.type') AS "->>";

Výsledek:

+------+------+
|  ->  | ->>  |
+------+------+
| text | null |
+------+------+
+------+-----+
|  ->  | ->> |
+------+-----+
| null | n/a |
+------+-----+

Alternativa:json_extract()

Dalším způsobem, jak extrahovat hodnoty z dokumentu JSON v SQLite, je použít json_extract() funkce. Tato funkce funguje mírně odlišně od -> a ->> v tom, že návratový typ závisí na kontextu.

json_extract() funkce vrací JSON pouze v případě, že existují dva nebo více argumentů cesty (protože výsledkem je pak pole JSON) nebo pokud jediný argument cesty odkazuje na pole nebo objekt.

Pokud existuje pouze jeden argument cesty a tato cesta odkazuje na hodnotu JSON null nebo řetězec nebo číselnou hodnotu, pak json_extract() vrátí odpovídající hodnotu SQL NULL, TEXT, INTEGER nebo REAL.