dalam SQLite

-> dan ->> operator diperkenalkan di SQLite versi 3.38.0, yang dirilis pada 22 Februari 2022. Kedua operator digunakan untuk mengekstrak subkomponen JSON. Tapi ada perbedaan tipis di antara mereka.

Perbedaan

Perbedaan antara operator ini seperti ini:

• -> operator selalu mengembalikan JSON representasi dari subkomponen yang ditentukan
• ->> operator selalu mengembalikan SQL representasi dari subkomponen yang ditentukan

Contoh

Berikut adalah contoh yang menggambarkan perbedaan antara kedua operator ini:

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

Hasil:

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

Kita dapat melihat bahwa -> mengembalikan nilai yang diapit oleh tanda kutip ganda sedangkan ->> tidak.

Itu karena -> mengembalikan representasi nilai JSON, dan ->> mengembalikan representasi SQL.

Angka

Berikut ini contoh yang menggunakan angka:

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

Hasil:

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

Inilah yang terjadi ketika kita menggunakan typeof() fungsi untuk mendapatkan tipe SQL:

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

Hasil:

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

Namun, jika kita menggunakan json_type() , kita akan mendapatkan tipe JSON:

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

Hasil:

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

Berikut ini contoh yang menggunakan bilangan real:

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

Hasil:

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

Dan dengan json_type() :

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

Hasil:

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

Nilai Null

Jika dokumen JSON berisi null , lalu -> akan mengembalikan representasi JSON dari null, dan ->> hanya akan mengembalikan nilai nol.

Berikut ini contoh untuk menunjukkan apa yang saya maksud:

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

Hasil:

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

Secara default, antarmuka baris perintah SQLite (CLI) mengembalikan string kosong setiap kali nilai null dikembalikan. Jadi kita dapat melihat dari contoh kita bahwa -> mengembalikan nilai JSON yang sebenarnya null, sedangkan ->> mengembalikan nilai nol yang sebenarnya.

Untuk mendemonstrasikan ini lebih lanjut, kita dapat mengatur .nullvalue ke sesuatu selain string kosong:

.nullvalue n/a

Sekarang mari kita jalankan lagi kueri sebelumnya:

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

Hasil:

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

Kali ini n/a adalah output untuk ->> operator alih-alih string kosong.

Dan inilah yang terjadi ketika kita meneruskan output ke typeof() dan json_type() fungsi:

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

Hasil:

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

Alternatif:json_extract()

Cara lain untuk mengekstrak nilai dari dokumen JSON di SQLite adalah dengan menggunakan json_extract() fungsi. Fungsi ini bekerja sedikit berbeda dengan -> dan ->> karena tipe pengembalian bergantung pada konteksnya.

json_extract() fungsi hanya mengembalikan JSON jika ada dua atau lebih argumen jalur (karena hasilnya adalah larik JSON) atau jika argumen jalur tunggal mereferensikan larik atau objek.

Jika hanya ada satu argumen jalur dan jalur tersebut mereferensikan null JSON atau string atau nilai numerik, maka json_extract() mengembalikan nilai SQL NULL, TEXT, INTEGER, atau REAL yang sesuai.