in SQLite

Der -> und ->> -Operatoren wurden in SQLite-Version 3.38.0 eingeführt, die am 22. Februar 2022 veröffentlicht wurde. Beide Operatoren werden zum Extrahieren von Unterkomponenten von JSON verwendet. Aber es gibt einen feinen Unterschied zwischen ihnen.

Der Unterschied

Der Unterschied zwischen diesen Operatoren sieht folgendermaßen aus:

• Der -> Operator gibt immer ein JSON zurück Darstellung der angegebenen Unterkomponente
• Der ->> Operator gibt immer ein SQL zurück Darstellung der angegebenen Unterkomponente

Beispiel

Hier ist ein Beispiel, das den Unterschied zwischen diesen beiden Operatoren veranschaulicht:

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

Ergebnis:

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

Wir können diesen -> sehen gab den in doppelte Anführungszeichen eingeschlossenen Wert zurück, während ->> nicht.

Das liegt daran, dass -> hat eine JSON-Darstellung des Werts und ->> zurückgegeben gab eine SQL-Darstellung zurück.

Zahlen

Hier ist ein Beispiel, das Zahlen verwendet:

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

Ergebnis:

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

Folgendes passiert, wenn wir typeof() verwenden Funktion, um den SQL-Typ zu erhalten:

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

Ergebnis:

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

Wenn wir jedoch json_type() verwenden , erhalten wir den JSON-Typ:

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

Ergebnis:

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

Hier ist ein Beispiel, das eine reelle Zahl verwendet:

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

Ergebnis:

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

Und mit json_type() :

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

Ergebnis:

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

Nullwerte

Wenn das JSON-Dokument null enthält , dann -> gibt die JSON-Darstellung von null und ->> zurück gibt einfach einen Nullwert zurück.

Hier ist ein Beispiel, um zu demonstrieren, was ich meine:

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

Ergebnis:

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

Standardmäßig gibt die SQLite-Befehlszeilenschnittstelle (CLI) die leere Zeichenfolge zurück, wenn ein Nullwert zurückgegeben wird. Wir können also in unserem Beispiel sehen, dass -> hat den tatsächlichen JSON-Wert null zurückgegeben, während ->> hat einen tatsächlichen Nullwert zurückgegeben.

Um dies weiter zu demonstrieren, können wir unseren .nullvalue setzen zu etwas anderem als dem leeren String:

.nullvalue n/a

Lassen Sie uns nun die vorherige Abfrage erneut ausführen:

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

Ergebnis:

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

Dieses Mal n/a wurde für ->> ausgegeben Operator anstelle des leeren Strings.

Und das passiert, wenn wir die Ausgabe an typeof() übergeben und json_type() Funktionen:

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

Ergebnis:

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

Eine Alternative:json_extract()

Eine andere Möglichkeit, Werte aus einem JSON-Dokument in SQLite zu extrahieren, ist die Verwendung von json_extract() Funktion. Diese Funktion funktioniert etwas anders als -> und ->> , dass der Rückgabetyp kontextabhängig ist.

Der json_extract() Die Funktion gibt nur JSON zurück, wenn zwei oder mehr Pfadargumente vorhanden sind (da das Ergebnis dann ein JSON-Array ist) oder wenn das einzelne Pfadargument auf ein Array oder Objekt verweist.

Wenn es nur ein Pfadargument gibt und dieser Pfad auf eine JSON-Null oder eine Zeichenfolge oder einen numerischen Wert verweist, dann json_extract() gibt den entsprechenden SQL-Wert NULL, TEXT, INTEGER oder REAL zurück.