i SQLite

-> og ->> operatorer blev introduceret i SQLite version 3.38.0, som blev udgivet den 22. februar 2022. Begge operatorer bruges til at udtrække underkomponenter af JSON. Men der er en subtil forskel mellem dem.
 Forskellen
 
 Forskellen mellem disse operatører ser sådan ud:
  -> operatør returnerer altid en JSON repræsentation af den angivne underkomponent
 ->> operatør returnerer altid en SQL repræsentation af den angivne underkomponent
 
 Eksempel
 
 Her er et eksempel, der illustrerer forskellen mellem disse to operatører:
 SELECT 
    '{ "name" : "Wag", "type" : "Dog" }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : "Dog" }' ->> '$.type' AS "->>";
 
 Resultat:
 +-------+-----+
|  ->   | ->> |
+-------+-----+
| "Dog" | Dog |
+-------+-----+
 
 Vi kan se den -> returnerede værdien omsluttet af dobbelte anførselstegn, mens ->> gjorde det ikke.
 
 Det er fordi -> returnerede en JSON-repræsentation af værdien og ->> returnerede en SQL-repræsentation.
 Numre
 
 Her er et eksempel, der bruger tal:
 SELECT 
    '{ "age" : 10 }' -> '$.age' AS "->",
    '{ "age" : 10 }' ->> '$.age' AS "->>";
 
 Resultat:
 +----+-----+
| -> | ->> |
+----+-----+
| 10 | 10  |
+----+-----+
 
 Her er, hvad der sker, når vi bruger typeof() funktion for at få SQL-typen:
 SELECT 
    typeof('{ "age" : 10 }' -> '$.age') AS "->",
    typeof('{ "age" : 10 }' ->> '$.age') AS "->>";
 
 Resultat:
 +------+---------+
|  ->  |   ->>   |
+------+---------+
| text | integer |
+------+---------+
 
 Men hvis vi bruger json_type() , får vi JSON-typen:
 SELECT 
    json_type('{ "age" : 10 }' -> '$.age') AS "->",
    json_type('{ "age" : 10 }' ->> '$.age') AS "->>";
 
 Resultat:
 +---------+---------+
|   ->    |   ->>   |
+---------+---------+
| integer | integer |
+---------+---------+
 
 Her er et eksempel, der bruger et reelt tal:
 SELECT 
    typeof('{ "age" : 1.2 }' -> '$.age') AS "->",
    typeof('{ "age" : 1.2 }' ->> '$.age') AS "->>";
 
 Resultat:
 +------+------+
|  ->  | ->>  |
+------+------+
| text | real |
+------+------+
 
 Og med json_type() :
 SELECT 
    json_type('{ "age" : 1.2 }' -> '$.age') AS "->",
    json_type('{ "age" : 1.2 }' ->> '$.age') AS "->>";
 
 Resultat:
 +------+------+
|  ->  | ->>  |
+------+------+
| real | real |
+------+------+
 Nul-værdier
 
 Hvis JSON-dokumentet indeholder null , derefter -> returnerer JSON-repræsentationen af null og ->> vil blot returnere en nulværdi.
 
 Her er et eksempel for at demonstrere, hvad jeg mener:
 SELECT 
    '{ "name" : "Wag", "type" : null }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : null }' ->> '$.type' AS "->>";
 
 Resultat:
 +------+-----+
|  ->  | ->> |
+------+-----+
| null |     |
+------+-----+
 
 Som standard returnerer SQLite-kommandolinjegrænsefladen (CLI) den tomme streng, hver gang en null-værdi returneres. Så vi kan se fra vores eksempel, at -> returnerede den faktiske JSON-værdi null, hvorimod ->> returnerede en faktisk nulværdi.
 
 For yderligere at demonstrere dette kan vi indstille vores .nullvalue til noget andet end den tomme streng:
 .nullvalue n/a
 
 Lad os nu køre den forrige forespørgsel igen:
 SELECT 
    '{ "name" : "Wag", "type" : null }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : null }' ->> '$.type' AS "->>";
 
 Resultat:
 +------+-----+
|  ->  | ->> |
+------+-----+
| null | n/a |
+------+-----+
 
 Denne gang n/a blev udlæst for ->> operator i stedet for den tomme streng.
 
 Og her er, hvad der sker, når vi sender outputtet til typeof() og 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 |
+------+-----+
 Et alternativ:json_extract() 
 
 En anden måde at udtrække værdier fra et JSON-dokument i SQLite er at bruge json_extract() fungere. Denne funktion fungerer lidt anderledes end -> og ->> ved at returtypen afhænger af konteksten.
 
 json_extract() funktion returnerer kun JSON, hvis der er to eller flere sti-argumenter (fordi resultatet så er et JSON-array), eller hvis enkeltsti-argumentet refererer til et array eller objekt.
 
 Hvis der kun er ét sti-argument, og den sti refererer til en JSON-nul eller en streng eller en numerisk værdi, så json_extract() returnerer den tilsvarende SQL NULL-, TEXT-, INTEGER- eller REAL-værdi.