SQLite JSON_QUOTE()

No SQLite, o json_quote() A função converte um número ou string em sua representação JSON correspondente.

Fornecemos o número ou a string como um argumento quando chamamos a função e a função retorna uma representação JSON desse valor.

Sintaxe

A sintaxe fica assim:

json_quote(X)

Onde X é um número ou string.

Exemplos

Aqui está o que acontece quando passamos uma string para a função:

SELECT json_quote('Super');

Resultado:

"Super"

E aqui está um número:

SELECT json_quote(10.45);

Resultado:

10.45

Aqui está uma string que se parece com um array:

SELECT json_quote('[10.45]');

Resultado:

"[10.45]"

Aqui está uma string que se parece com um objeto:

SELECT json_quote('{ "score" : 10.45 }');

Resultado:

"{ \"score\" : 10.45 }"

Mas se passarmos o argumento no json() função, obtemos isso:

SELECT json_quote(json('{ "score" : 10.45 }'));

Resultado:

{"score":10.45}

Valores nulos

Passando null retorna null :

SELECT json_quote( null );

Resultado:

null

Este é realmente o valor do texto SQL null . Podemos verificar isso passando para o json_type() função:

SELECT json_type(json_quote( null ));

Resultado:

null

O json_type() A função retorna o tipo de valor de texto SQL de seu argumento. Neste caso retornou null , que indica que o json_quote() função retornou null quando passamos null para isso.

Caso suspeitemos que nossa CLI SQLite está retornando null devido a um valor nulo real sendo retornado, podemos fazer o seguinte para descartar isso:

.nullvalue N/A

Isso diz à nossa interface de linha de comando para retornar N/A sempre que um valor nulo é retornado.

Tendo executado o comando acima, vamos executar as instruções anteriores novamente, bem como uma operação que realmente resulta em um valor nulo:

SELECT 
    json_quote( null ) AS json_quote,
    json_type(json_quote( null )) AS json_type,
    1 / 0 AS actual_null;

Resultado:

+------------+-----------+-------------+
| json_quote | json_type | actual_null |
+------------+-----------+-------------+
| null       | null      | N/A         |
+------------+-----------+-------------+

No SQLite, dividir um número por zero resulta em um valor nulo (muitos outros DBMSs geram um erro nesses casos). Neste exemplo, eu configurei valores nulos para retornar N/A , e assim podemos ver que há uma diferença entre a saída das duas funções e o valor nulo real. Ou seja, o único valor nulo na saída acima está na última coluna.

Dito tudo isso, um valor nulo ainda pode resultar no valor de texto SQL null sendo retornado ao chamar json_quote() . Talvez um exemplo ilustre isso melhor do que eu possa explicar:

SELECT 
    json_quote( 1 / 0 ),
    json_type(json_quote( 1 / 0 )),
    json_type( 1 / 0 ),
    1 / 0;

Resultado:

+---------------------+--------------------------------+--------------------+-------+
| json_quote( 1 / 0 ) | json_type(json_quote( 1 / 0 )) | json_type( 1 / 0 ) | 1 / 0 |
+---------------------+--------------------------------+--------------------+-------+
| null                | null                           | N/A                | N/A   |
+---------------------+--------------------------------+--------------------+-------+

Podemos ver que as duas primeiras colunas retornam o null Valor de texto SQL e as outras duas colunas retornam um valor nulo real.

Passando booleanos

Aqui está um exemplo de passagem de booleanos como true e false :

SELECT 
    json_quote( true ) AS true,
    json_quote( false ) AS false;

Resultado:

+------+-------+
| true | false |
+------+-------+
| 1    | 0     |
+------+-------+

Contagem de argumentos inválida

Chamar a função sem passar um argumento resulta em um erro:

SELECT json_quote();

Resultado:

Parse error: wrong number of arguments to function json_quote()
  SELECT json_quote();
         ^--- error here

E passar muitos argumentos também resulta em um erro:

SELECT json_quote( 1, 2 );

Resultado:

Parse error: wrong number of arguments to function json_quote()
  SELECT json_quote( 1, 2 );
         ^--- error here