In SQLite, il json_quote()
La funzione converte un numero o una stringa nella sua rappresentazione JSON corrispondente.
Forniamo il numero o la stringa come argomento quando chiamiamo la funzione e la funzione restituisce una rappresentazione JSON di quel valore.
Sintassi
La sintassi è questa:
json_quote(X)
Dove X
è un numero o una stringa.
Esempi
Ecco cosa succede quando passiamo una stringa alla funzione:
SELECT json_quote('Super');
Risultato:
"Super"
Ed ecco un numero:
SELECT json_quote(10.45);
Risultato:
10.45
Ecco una stringa che assomiglia a un array:
SELECT json_quote('[10.45]');
Risultato:
"[10.45]"
Ecco una stringa che assomiglia a un oggetto:
SELECT json_quote('{ "score" : 10.45 }');
Risultato:
"{ \"score\" : 10.45 }"
Ma se passiamo l'argomento nel json()
funzione, otteniamo questo:
SELECT json_quote(json('{ "score" : 10.45 }'));
Risultato:
{"score":10.45}
Valori Nulli
Passaggio null
restituisce null
:
SELECT json_quote( null );
Risultato:
null
Questo è in realtà il valore del testo SQL null
. Possiamo verificarlo passandolo a json_type()
funzione:
SELECT json_type(json_quote( null ));
Risultato:
null
Il json_type()
La funzione restituisce il tipo di valore di testo SQL del suo argomento. In questo caso ha restituito null
, che indica che il json_quote()
la funzione ha restituito null
quando abbiamo passato null
ad esso.
Nel caso sospettiamo che la nostra SQLite CLI restituisca null
a causa della restituzione di un valore nullo effettivo, possiamo fare quanto segue per escluderlo:
.nullvalue N/A
Questo dice alla nostra interfaccia a riga di comando di restituire N/A
ogni volta che viene restituito un valore nullo.
Dopo aver eseguito il comando precedente, eseguiamo nuovamente le istruzioni precedenti, oltre a un'operazione che effettivamente risulta in un valore nullo:
SELECT
json_quote( null ) AS json_quote,
json_type(json_quote( null )) AS json_type,
1 / 0 AS actual_null;
Risultato:
+------------+-----------+-------------+ | json_quote | json_type | actual_null | +------------+-----------+-------------+ | null | null | N/A | +------------+-----------+-------------+
In SQLite, dividendo un numero per zero si ottiene un valore nullo (molti altri DBMS generano un errore in questi casi). In questo esempio, avevo impostato valori null per restituire N/A
, e quindi possiamo vedere che c'è una differenza tra l'output delle due funzioni e il valore nullo effettivo. Cioè, l'unico valore nullo nell'output sopra è nell'ultima colonna.
Detto questo, un valore nullo può comunque risultare nel valore del testo SQL null
restituito quando si chiama json_quote()
. Forse un esempio lo illustra meglio di quanto io possa spiegarlo:
SELECT
json_quote( 1 / 0 ),
json_type(json_quote( 1 / 0 )),
json_type( 1 / 0 ),
1 / 0;
Risultato:
+---------------------+--------------------------------+--------------------+-------+ | json_quote( 1 / 0 ) | json_type(json_quote( 1 / 0 )) | json_type( 1 / 0 ) | 1 / 0 | +---------------------+--------------------------------+--------------------+-------+ | null | null | N/A | N/A | +---------------------+--------------------------------+--------------------+-------+
Possiamo vedere che le prime due colonne restituiscono null
Il valore del testo SQL e le altre due colonne restituiscono un valore nullo effettivo.
Booleani di passaggio
Ecco un esempio di passaggio di valori booleani come true
e false
:
SELECT
json_quote( true ) AS true,
json_quote( false ) AS false;
Risultato:
+------+-------+ | true | false | +------+-------+ | 1 | 0 | +------+-------+
Conteggio argomenti non valido
La chiamata della funzione senza passare un argomento genera un errore:
SELECT json_quote();
Risultato:
Parse error: wrong number of arguments to function json_quote() SELECT json_quote(); ^--- error here
E anche passare troppi argomenti provoca un errore:
SELECT json_quote( 1, 2 );
Risultato:
Parse error: wrong number of arguments to function json_quote() SELECT json_quote( 1, 2 ); ^--- error here