Aprendendo os Básicos: Como Usar JSON em SQLite

Neste guia, exploramos uma interseção fascinante entre duas tecnologias populares: JSON e SQLite. Saber como usar JSON com SQLite é importante na programação de software moderna, especialmente ao lidar com estruturas de dados complexas que podem não se encaixar completamente em uma estrutura tabulada. Seja você um desenvolvedor experiente ou um iniciante ansioso para expandir seus conhecimentos, este tutorial o ajudará a começar a aprender a usar JSON no banco de dados SQLite.

Vamos começar!

Potencializando a Gestão Moderna de Dados de Aplicações com SQLite

SQLite, como o mecanismo de banco de dados mais amplamente implantado e utilizado, é um banco de dados amigável que não requer nenhuma configuração complicada ou conexão com servidor. SQLite é simples e adaptável a diversas aplicações, o que o tornou uma escolha preferencial na programação de software. SQLite possui uma pequena pegada binária, geralmente menor que 1 MB, o que significa que é mais leve que outros bancos de dados. Além disso, o SQLite cumpre totalmente com os princípios ACID.

Outra característica única do SQLite é que é bem adequado para aplicativos individuais e dispositivos conectados à internet, como gadgets de casa inteligente, que fazem parte da Internet das Coisas (IoT). Além disso, apesar de sua simplicidade, o SQLite tem um forte domínio sobre a linguagem SQL padrão. Pode lidar com coisas como transações, sub-consultas e gatilhos. Portanto, o SQLite é simples de usar, mas ainda assim bastante poderoso.

A capacidade do SQLite estende-se além do simples armazenamento de dados. O SQLite é eficiente e amigável para o usuário, com recursos como pesquisa de texto completo e suporte a blob. O SQLite também fornece um mecanismo de extensão para funcionalidades adicionais, tornando-o uma ferramenta adaptável no ecossistema de software moderno.

Curiosidade: Você sabia que, enquanto muitas pessoas pronunciam SQLite como ‘S-Q-Lite’ (sequela-leve), seu criador, Richard Hipp, na verdade pretendia que fosse pronunciado como ‘S-Q-L-ite’ (es-que-el-ite) assim como um mineral, enfatizando sua natureza robusta, mas leve?

Por que o SQLite se destaca no universo de bancos de dados relacionais modernos

O SQLite é uma solução ideal para cenários em que bancos de dados cliente-servidor em escala total podem ser um exagero, pois é leve e sem servidor. Como o SQLite é autossuficiente, não depende de quaisquer dependências externas, tornando-o muito confiável. Os bancos de dados SQLite são portáteis em diferentes sistemas de arquivos e arquiteturas, facilitando a migração de dados no banco de dados SQLite.

Os casos de uso típicos do SQLite abrangem uma variedade de domínios, sendo o mecanismo de banco de dados mais amplamente implantado existente. Por exemplo, o SQLite é uma escolha padrão para persistência local em aplicativos, especialmente em aplicativos móveis. O SQLite também é amplamente utilizado para análise de dados e testes, onde sua clareza e poder são uma combinação vencedora. Por fim, o SQLite é uma escolha ideal para armazenamento de dados de sites, onde pode gerenciar dados de usuários, conteúdo do site e muito mais.

O desempenho do SQLite é impressionante, com velocidade muitas vezes superando outros bancos de dados famosos para a maioria das operações comuns operations.

Por que as capacidades de manipulação de JSON do SQLite tornam-no uma escolha excepcional para a gestão de dados modernos

Gerenciar dados não estruturados de forma eficiente é um desafio que muitos desenvolvedores enfrentam. É aí que entra o JSON. Como um formato de dados flexível e sem esquema, o JSON é útil para lidar com dados que não se encaixam perfeitamente em uma estrutura tabulada.

Ao armazenar dados JSON no SQLite, você pode aproveitar as poderosas capacidades de consulta do SQLite para extrair e manipular seus dados JSON de forma eficiente. A beleza desta combinação está no fato de que o SQLite vem com funções internas para gerenciar dados JSON com simplicidade. Além disso, a popularidade do JSON como formato de intercâmbio de dados e sua portabilidade significa que os dados JSON armazenados no SQLite podem ser facilmente compartilhados, migrados ou exportados para diferentes sistemas.

Suporte ao JSON no SQLite evoluiu ao longo do tempo. Foi introduzido pela primeira vez como uma extensão na versão 3.9.0, lançada em 2015, mas versões posteriores vieram com suporte interno para JSON. O SQLite permite salvar e buscar dados JSON usando uma coluna TEXT e um conjunto de funções JSON, como json(), json_extract(), json_object() e json_array().

Entendendo as Poderosas Funções do SQLite para Consulta de JSON

O SQLite gerencia e manipula dados JSON usando funções JSON. Aqui estão as 10 principais funções JSON no SQLite, listadas como referência, e o caso de uso de cada uma será exemplificado usando uma consulta SQL simples na seção a seguir.

1. json(): Essa função verifica se uma string é um JSON válido. Se for, a função retorna o mesmo JSON. Se não for, retorna NULL.
2. json_extract(): Essa função extrai um objeto de uma string JSON usando um caminho.
3. json_array(): Essa função cria uma matriz JSON.
4. json_array_length(): Essa função retorna o comprimento da matriz JSON.
5. json_insert(): Essa função insere um valor JSON em uma string JSON.
6. json_object(): Essa função cria um objeto JSON.
7. json_remove(): Essa função remove uma propriedade da string JSON.
8. json_replace(): Essa função substitui um valor em uma string JSON.
9. json_type(): Essa função retorna o tipo do valor JSON (como INTEGER, REAL, NULL, TRUE, FALSE, TEXT e BLOB).
10. json_valid(): Essa função verifica se uma string é um JSON válido.

Série Prática de Exemplos para Entender Funções de Codificação e Decodificação JSON no SQLite

Nesta seção, fornecemos exemplos mínimos e uma breve explicação para cada uma das funções JSON que listamos na seção anterior. Utilizamos um exemplo de dados JSON do gerador de JSON Dadroit. Aqui está o JSON original para fornecer contexto.

A Função json() no SQLite

Esta consulta converte o texto JSON em um objeto JSON.

SELECT
    json ( '{"ID":1,"Name":"Forgotten in the Planet","Year":1970}' ) AS json_object;

O resultado desta consulta seria assim:

A Função json_extract() no SQLite

Esta consulta extrai o valor Name do objeto JSON usando-o como um caminho.

SELECT json_extract('{"ID":1,"Name":"Forgotten in the Planet","Year":1970}', '$.Name') AS movie_name;

O resultado desta consulta seria assim:

A Função json_array() no SQLite

Esta consulta cria um novo array JSON a partir das entradas fornecidas.

SELECT
    json_array ( 1, 2, 3 ) AS array_result;

O resultado seria assim:

A Função json_type() no SQLite

Esta consulta recupera o tipo de dados do valor Year do objeto JSON.

SELECT
    json_type ( '{"ID":1,"Name":"Forgotten in the Planet","Year":1970}', '$.Year' ) AS property_type;

O resultado seria assim:

A Função json_array_length() no SQLite

Esta consulta conta o número de elementos no array Cast no objeto JSON.

SELECT
    json_array_length ( '{"Genre":["Comedy","Crime"],"Cast":["Adrian Gratianna","Tani O''Hara","Tessie Delisle"]}', '$.Cast' ) AS array_length;

O resultado seria assim:

A Função json_object() no SQLite

Esta consulta cria um objeto JSON com os pares chave-valor ID e Name.

SELECT
    json_object ( 'ID', 1, 'Name', 'Forgotten in the Planet' ) AS result;

O resultado seria assim:

A Função json_insert() em SQLite

Esta consulta insere a propriedade chave-valor Director no objeto JSON.

SELECT
    json_insert ( '{"ID":1,"Name":"Forgotten in the Planet","Year":1970}', '$.Director', 'Henrie Randell Githens' ) AS insert_movie;

O resultado seria assim:

A Função json_remove() em SQLite

Esta consulta remove o par chave-valor Director do objeto JSON.

SELECT
    json_remove ( '{"ID":1,"Name":"Forgotten in the Planet","Year":1970,"Director":"Henrie Randell Githens"}', '$.Director' ) AS result_of_remove;

O resultado seria assim:

A Função json_replace() em SQLite

Esta consulta substitui o Year no objeto JSON pelo novo valor 1971.

SELECT
     json_replace ( '{"ID":1,"Name":"Forgotten in the Planet","Year":1970,"Director":"Henrie Randell Githens"}', '$.Year', 1971 ) AS result_of_replace;

O resultado seria assim:

A Função json_valid() em SQLite

Esta consulta verifica se a string fornecida tem a sintaxe e a estrutura corretas necessárias para um JSON válido, e retorna 1 se estiver e 0 caso contrário.

SELECT
     json_valid ( '{"ID":1,"Name":"Forgotten in the Planet","Year":1970,"Director":"Henrie Randell Githens"}' ) AS result_of_valid;

O resultado seria assim:

Exemplos Práticos de Consultas para Melhorar a Consulta SQL Usando Funções JSON em SQLite

Agora que você aprendeu sobre os fundamentos do JSON em SQLite, aqui são apresentados alguns exemplos de um fluxo de trabalho prático com dados JSON no banco de dados SQLite, usando as funções JSON mencionadas anteriormente, e os dados JSON mencionados anteriormente como entrada.

Armazenando Dados JSON em SQLite com Consultas de Inserção

Primeiramente, você precisa inserir o JSON em um banco de dados SQLite. Vamos criar uma tabela chamada movies com um campo chamado data como um campo de texto, já que você pode armazenar JSON em SQLite em um campo de texto. Você usará este campo data para armazenar e recuperar os valores JSON:

CREATE TABLE movies ( data TEXT );

Em seguida, vamos inserir nosso JSON no campo data da tabela movies:

INSERT INTO movies ( data )
 VALUES
     ( '{"ID":1,"Name":"Forgotten in the Planet","Year":1970,"Genre":["Comedy","Crime"],"Director":"Henrie Randell Githens","Cast":["Adrian Gratianna","Tani OHara","Tessie Delisle"],"Runtime":90,"Rate":7.0}' );

Para editar (substituir, inserir, remover, etc.) JSON em SQLite, você pode usar as funções json_replace(), json_insert() e json_remove().

A seguinte consulta substitui o nome do filme pelo novo valor onde o ID é 1:

UPDATE movies
 SET data = json_replace ( data, '$.Name', 'Found in the Universe' )
 WHERE
     json_extract ( data, '$.ID' ) = 1;

A seguinte consulta insere uma nova propriedade como um novo campo no JSON armazenado anteriormente na linha:

UPDATE movies
 SET data = json_insert ( data, '$.Country', 'USA' )
 WHERE
     json_extract ( data, '$.ID' ) = 1;

A seguinte consulta remove a propriedade Runtime do JSON armazenado anteriormente na linha:

UPDATE movies
 SET data = json_remove ( data, '$.Runtime' )
 WHERE
     json_extract ( data, '$.ID' ) = 1;

Extrair Dados JSON do SQLite

Para recuperar dados JSON do SQLite, você pode usar a função json_extract() ou o operador abreviado ->:

Selecione o nome do filme:

SELECT
     json_extract ( data, '$.Name' )
 FROM
     movies
 WHERE
     json_extract ( data, '$.ID' ) = 1;

Ou usando o operador abreviado ->:

SELECT
     data -> '$.Name'
 FROM
     movies
 WHERE
     data -> '$.ID' = 1;

Recupere a lista de gêneros:

SELECT
     json_extract ( data, '$.Genre' )
 FROM
     movies
 WHERE
     json_extract ( data, '$.ID' ) = 1;

Recupere o primeiro ator da lista Cast:

SELECT
     json_extract ( data, '$.Cast[0]' )
 FROM
     movies
 WHERE
     json_extract ( data, '$.ID' ) = 1;

Extraia o Year e Rate:

SELECT
     json_extract ( data, '$.Year' ) AS Year,
     json_extract ( data, '$.Rate' ) AS Rate
 FROM
     movies
 WHERE
     json_extract ( data, '$.ID' ) = 1;

Considerações Finais

Parabéns por completar essa jornada! Você aprendeu como o tipo de dados JSON e o banco de dados SQLite podem trabalhar juntos. O SQLite é uma ferramenta útil para ter em seu conjunto de habilidades. É simples, mas poderoso e fácil de usar. Mesmo sendo pequeno, está repleto de recursos úteis.

Simplificando, o SQLite nos permite salvar e buscar dados JSON usando uma coluna de texto e algumas funções JSON. Essas funções nos permitem explorar, analisar e alterar os dados JSON em nosso banco de dados SQLite. O SQLite oferece muitas ferramentas para gerenciar dados JSON, desde adicionar e alterar dados JSON até buscá-los para vários propósitos. Cobrimos dez funções JSON principais no SQLite que facilitam o manuseio de dados JSON. Então, analisamos mais alguns exemplos de consultas SQL usando essas funções JSON no SQLite.

Lembre-se: dominar o uso de JSON com SQLite é uma habilidade que precisa ser praticada mais a fundo. Então, não seja tímido – mergulhe, experimente e aprenda. No final, se você achou este guia útil, sinta-se à vontade para compartilhá-lo. Divirta-se em sua jornada de codificação!