w SQLite

-> i ->> Operatory zostały wprowadzone w wersji SQLite 3.38.0, która została wydana 22 lutego 2022 r. Oba operatory służą do wyodrębniania podkomponentów JSON. Ale jest między nimi subtelna różnica.
 Różnica
 
 Różnica między tymi operatorami wygląda następująco:
  -> operator zawsze zwraca JSON reprezentacja określonego podkomponentu
 ->> operator zawsze zwraca SQL reprezentacja określonego podkomponentu
 
 Przykład
 
 Oto przykład ilustrujący różnicę między tymi dwoma operatorami:
 SELECT 
    '{ "name" : "Wag", "type" : "Dog" }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : "Dog" }' ->> '$.type' AS "->>";
 
 Wynik:
 +-------+-----+
|  ->   | ->> |
+-------+-----+
| "Dog" | Dog |
+-------+-----+
 
 Widzimy, że -> zwrócił wartość ujętą w podwójne cudzysłowy, podczas gdy ->> nie.
 
 To dlatego, że -> zwrócił reprezentację wartości w formacie JSON, a ->> zwrócił reprezentację SQL.
 Liczby
 
 Oto przykład wykorzystujący liczby:
 SELECT 
    '{ "age" : 10 }' -> '$.age' AS "->",
    '{ "age" : 10 }' ->> '$.age' AS "->>";
 
 Wynik:
 +----+-----+
| -> | ->> |
+----+-----+
| 10 | 10  |
+----+-----+
 
 Oto, co się dzieje, gdy używamy typeof() funkcja do pobrania typu SQL:
 SELECT 
    typeof('{ "age" : 10 }' -> '$.age') AS "->",
    typeof('{ "age" : 10 }' ->> '$.age') AS "->>";
 
 Wynik:
 +------+---------+
|  ->  |   ->>   |
+------+---------+
| text | integer |
+------+---------+
 
 Jeśli jednak użyjemy json_type() , otrzymamy typ JSON:
 SELECT 
    json_type('{ "age" : 10 }' -> '$.age') AS "->",
    json_type('{ "age" : 10 }' ->> '$.age') AS "->>";
 
 Wynik:
 +---------+---------+
|   ->    |   ->>   |
+---------+---------+
| integer | integer |
+---------+---------+
 
 Oto przykład, który używa liczby rzeczywistej:
 SELECT 
    typeof('{ "age" : 1.2 }' -> '$.age') AS "->",
    typeof('{ "age" : 1.2 }' ->> '$.age') AS "->>";
 
 Wynik:
 +------+------+
|  ->  | ->>  |
+------+------+
| text | real |
+------+------+
 
 I za pomocą json_type() :
 SELECT 
    json_type('{ "age" : 1.2 }' -> '$.age') AS "->",
    json_type('{ "age" : 1.2 }' ->> '$.age') AS "->>";
 
 Wynik:
 +------+------+
|  ->  | ->>  |
+------+------+
| real | real |
+------+------+
 Wartości puste
 
 Jeśli dokument JSON zawiera null , a następnie -> zwróci reprezentację JSON wartości null, a ->> po prostu zwróci wartość null.
 
 Oto przykład pokazujący, co mam na myśli:
 SELECT 
    '{ "name" : "Wag", "type" : null }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : null }' ->> '$.type' AS "->>";
 
 Wynik:
 +------+-----+
|  ->  | ->> |
+------+-----+
| null |     |
+------+-----+
 
 Domyślnie interfejs wiersza poleceń (CLI) SQLite zwraca pusty ciąg za każdym razem, gdy zwracana jest wartość null. Widzimy więc z naszego przykładu, że -> zwrócił rzeczywistą wartość JSON null, podczas gdy ->> zwrócił rzeczywistą wartość null.
 
 Aby dalej to zademonstrować, możemy ustawić naszą .nullvalue do czegoś innego niż pusty ciąg:
 .nullvalue n/a
 
 Teraz ponownie uruchom poprzednie zapytanie:
 SELECT 
    '{ "name" : "Wag", "type" : null }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : null }' ->> '$.type' AS "->>";
 
 Wynik:
 +------+-----+
|  ->  | ->> |
+------+-----+
| null | n/a |
+------+-----+
 
 Tym razem nie dotyczy został wypisany dla ->> operator zamiast pustego ciągu.
 
 A oto, co się dzieje, gdy przekazujemy dane wyjściowe do typeof() i json_type() funkcje:
 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 "->>";
 
 Wynik:
 +------+------+
|  ->  | ->>  |
+------+------+
| text | null |
+------+------+
+------+-----+
|  ->  | ->> |
+------+-----+
| null | n/a |
+------+-----+
 Alternatywa:json_extract() 
 
 Innym sposobem wyodrębnienia wartości z dokumentu JSON w SQLite jest użycie json_extract() funkcjonować. Ta funkcja działa nieco inaczej niż -> i ->> w tym sensie, że typ zwracany zależy od kontekstu.
 
 json_extract() funkcja zwraca JSON tylko wtedy, gdy istnieją dwa lub więcej argumentów ścieżki (ponieważ wynikiem jest wtedy tablica JSON) lub jeśli pojedynczy argument ścieżki odwołuje się do tablicy lub obiektu.
 
 Jeśli istnieje tylko jeden argument ścieżki i ta ścieżka odwołuje się do null JSON, ciągu lub wartości liczbowej, wówczas json_extract() zwraca odpowiednią wartość SQL NULL, TEXT, INTEGER lub REAL.