in SQLite

De -> en ->> operators zijn geïntroduceerd in SQLite versie 3.38.0, die is uitgebracht op 22 februari 2022. Beide operators worden gebruikt voor het extraheren van subcomponenten van JSON. Maar er is een subtiel verschil tussen hen.

Het verschil

Het verschil tussen deze operators gaat als volgt:

• De -> operator retourneert altijd een JSON weergave van de gespecificeerde subcomponent
• De ->> operator retourneert altijd een SQL weergave van de gespecificeerde subcomponent

Voorbeeld

Hier is een voorbeeld dat het verschil tussen deze twee operators illustreert:

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

Resultaat:

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

We kunnen zien dat -> retourneerde de waarde tussen dubbele aanhalingstekens terwijl ->> niet gedaan.

Dat komt omdat -> heeft een JSON-representatie van de waarde geretourneerd, en ->> een SQL-representatie geretourneerd.

Cijfers

Hier is een voorbeeld dat getallen gebruikt:

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

Resultaat:

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

Dit is wat er gebeurt als we de typeof() . gebruiken functie om het SQL-type te krijgen:

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

Resultaat:

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

Als we echter json_type() . gebruiken , krijgen we het JSON-type:

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

Resultaat:

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

Hier is een voorbeeld dat een reëel getal gebruikt:

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

Resultaat:

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

En met json_type() :

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

Resultaat:

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

Null-waarden

Als het JSON-document null . bevat , dan -> retourneert de JSON-representatie van null, en ->> retourneert gewoon een null-waarde.

Hier is een voorbeeld om te laten zien wat ik bedoel:

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

Resultaat:

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

Standaard retourneert de SQLite-opdrachtregelinterface (CLI) de lege tekenreeks wanneer een null-waarde wordt geretourneerd. Dus we kunnen aan ons voorbeeld zien dat -> retourneerde de werkelijke JSON-waarde null, terwijl ->> heeft een werkelijke null-waarde geretourneerd.

Om dit verder aan te tonen, kunnen we onze .nullvalue . instellen naar iets anders dan de lege string:

.nullvalue n/a

Laten we nu de vorige query opnieuw uitvoeren:

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

Resultaat:

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

Deze keer n/a werd uitgevoerd voor de ->> operator in plaats van de lege tekenreeks.

En dit is wat er gebeurt als we de uitvoer doorgeven aan de typeof() en json_type() functies:

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

Resultaat:

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

Een alternatief:json_extract()

Een andere manier om waarden uit een JSON-document in SQLite te extraheren, is door de json_extract() te gebruiken functie. Deze functie werkt iets anders dan de -> en ->> in die zin dat het retourtype afhangt van de context.

De json_extract() functie retourneert alleen JSON als er twee of meer padargumenten zijn (omdat het resultaat dan een JSON-array is) of als het enkele padargument verwijst naar een array of object.

Als er slechts één padargument is en dat pad verwijst naar een JSON-null of een tekenreeks of een numerieke waarde, dan json_extract() geeft de corresponderende SQL NULL, TEXT, INTEGER of REAL waarde terug.