i SQLite

Skillnaden

Skillnaden mellan dessa operatörer ser ut så här:

• -> operatören returnerar alltid en JSON representation av den angivna underkomponenten
• ->> operatorn returnerar alltid en SQL representation av den angivna underkomponenten

Exempel

Här är ett exempel som illustrerar skillnaden mellan dessa två operatörer:

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

Resultat:

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

Vi kan se den -> returnerade värdet inom dubbla citattecken medan ->> gjorde det inte.

Det beror på att -> returnerade en JSON-representation av värdet och ->> returnerade en SQL-representation.

Siffror

Här är ett exempel som använder siffror:

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

Resultat:

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

Här är vad som händer när vi använder typeof() funktion för att få SQL-typen:

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

Resultat:

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

Men om vi använder json_type() , får vi JSON-typen:

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

Resultat:

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

Här är ett exempel som använder ett reellt tal:

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

Resultat:

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

Och med json_type() :

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

Resultat:

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

Nullvärden

Om JSON-dokumentet innehåller null , sedan -> returnerar JSON-representationen av null och ->> returnerar helt enkelt ett nollvärde.

Här är ett exempel för att visa vad jag menar:

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

Resultat:

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

Som standard returnerar SQLite kommandoradsgränssnitt (CLI) den tomma strängen när ett nullvärde returneras. Så vi kan se från vårt exempel att -> returnerade det faktiska JSON-värdet null, medan ->> returnerade ett verkligt nollvärde.

För att ytterligare demonstrera detta kan vi ställa in vårt .nullvärde till något annat än den tomma strängen:

.nullvalue n/a

Låt oss nu köra den föregående frågan igen:

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

Resultat:

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

Den här gången n/a matades ut för ->> operator istället för den tomma strängen.

Och här är vad som händer när vi skickar utdata till typeof() och json_type() funktioner:

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 "->>";

Resultat:

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

Ett alternativ:json_extract()

Ett annat sätt att extrahera värden från ett JSON-dokument i SQLite är att använda json_extract() fungera. Denna funktion fungerar något annorlunda än -> och ->> genom att returtypen beror på sammanhanget.