Tutorial SQLite:Tudo o que você precisa saber

Se você já trabalhou com sistemas de banco de dados relacionais, provavelmente já ouviu falar de sistemas de banco de dados populares como MySQL, SQL Server ou PostgreSQL. SQLite é outro RDBMS extremamente útil que é muito simples de configurar e operar. Além disso, possui muitos recursos distintos em relação a outros bancos de dados relacionais. Este tutorial SQLite ensina conceitos básicos que você precisa saber com a ajuda de extensas práticas práticas.

Os tópicos discutidos neste artigo são:

• O que é SQLite?
  • Recursos do SQLite
• Instalando o SQLite no Windows
• Comandos SQLite
  • Comandos do banco de dados
  • Comandos de tabela
  • Operações CRUD
  • Cláusulas/condições SQLite
  • Junta-se no SQLite
• Desvantagens do SQLite

Tutorial SQLite:O que é SQLite?

Você pode considerar SQLite como um “isqueiro ” de outro RDBMS complexo (Oracle, SQL, etc.), onde seu mecanismo de banco de dados é configurado para processamento independente (biblioteca em processo) ou seja, um sem servidor, autônomo, de configuração zero e transacional . É conhecido por sua portabilidade, confiabilidade e forte desempenho, mesmo em ambientes com pouca memória. Além disso, o SQLite é uma escolha popular como um banco de dados incorporado para armazenamento local/cliente em programas ou aplicativos finais, ao contrário de outros RDBMS, onde o mecanismo de banco de dados cliente-servidor é configurado.

Recursos do SQLite

O SQLite oferece muitos recursos distintos, como:

• Sem servidor: A maioria dos bancos de dados SQL é implementada como um processo de servidor separado, mas o SQLite não possui um processo de servidor separado. É um mecanismo de banco de dados sem servidor. Ele lê e grava diretamente em arquivos de disco comuns.
• Configuração zero: Não requer configuração para executá-lo. Isso significa que não há nenhum processo do servidor que precise ser iniciado, interrompido ou configurado como em um sistema cliente/servidor.
• Digitação de manifesto: O SQLite usa a tipagem de manifesto, que permite o armazenamento de qualquer quantidade de qualquer tipo de dados em qualquer coluna, independentemente do tipo de dados declarado da coluna. Observe que há algumas exceções a essa regra.
• Leve: Como o nome indica, a biblioteca SQLite é muito leve. O problema é que, embora o espaço usado varie dependendo do sistema em que está instalado, pode ocupar menos de 600KiB de espaço.
• Portátil: Ao contrário de outros DBMS, um banco de dados SQLite inteiro é armazenado em um único arquivo. Este arquivo pode ser compartilhado via mídia removível ou protocolo de transferência de arquivos com muita facilidade.
• Escolha diversificada: Muitas linguagens de programação fornecem ligações para SQLite, incluindo C, C++, C#, Java, JavaScript, Ruby, Python e muito mais.
• Gratuito: SQLite é gratuito e de código aberto. Para trabalhar com SQLite não é necessária uma licença comercial.

Como listado acima, o SQLite é conhecido por sua configuração zero, o que significa que nenhuma configuração ou administração complexa é realmente necessária. Na próxima parte deste tutorial do SQLite, vamos ver como instalar o SQLite em seu sistema.

Tutorial do SQLite:Instalando o SQLite no Windows

• Núcleo SQLite :o núcleo SQLite contém o mecanismo de banco de dados real e a API pública.
• Ferramenta de linha de comando SQLite3 :o aplicativo sqlite3 é uma ferramenta de linha de comando construída sobre o núcleo SQLite.
• Extensão Tcl :Esta biblioteca é essencialmente uma cópia do núcleo SQLite com as ligações Tcl adicionadas.
• Ferramenta de análise SQLite :A ferramenta SQLite Analyzer é usada para analisar arquivos de banco de dados.

Etapa 3: Depois disso, iniciar a linha de comando SQLite é tão simples quanto clicar no aplicativo sqlite3, que fará a linha de comando aparecer.

Se você quiser testar mais, basta digitar .help comando de sqlite> prompt para ver todos os comandos disponíveis em sqlite3 como mostrado abaixo.

Observação: Por padrão, uma sessão SQLite usa o banco de dados na memória, portanto, todas as alterações desaparecerão quando a sessão terminar.

Simples o suficiente certo? Então, vamos começar com os comandos SQLite.

Tutorial SQLite:Comandos SQLite

Observação: Os comandos SQLite terminam com um ponto e vírgula (; ). Ele informa ao SQLite que seu comando está completo e deve ser executado. Além disso, você pode espalhar seu comando por várias linhas e usar o ponto e vírgula na última linha.

Comandos do banco de dados

• Criar banco de dados SQLite

O SQLite não usa a instrução CREATE DATABASE como em outros sistemas de gerenciamento de banco de dados relacional, como MySQL, SQL Server, etc. Para criar um novo banco de dados no SQLite, basta digitar sqlite3 seguido pelo nome do arquivo que você deseja usar para o banco de dados. O código a seguir cria um arquivo de banco de dados chamado StudentDetails.db:

Exemplo

sqlite3 StudentDetails.db;

sqlite> .databases 
main: D:sqliteStudentDetails.db;

• Banco de dados de anexação SQLite

Quando você tem vários bancos de dados, pode usar apenas um de cada vez. No SQLite, a instrução ATTACH DATABASE é usada para anexar um banco de dados específico à conexão atual. Após este comando, todas as instruções SQLite serão executadas no banco de dados anexado.

Exemplo

 sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department';

sqlite> .databases
main: D:sqliteStudentDetails.db;
Department: D:sqliteDepartmentDetails.db

• Anexar banco de dados SQLite

No SQLite, a instrução DETACH DATABASE é usada para desanexar o banco de dados com nome de alias de uma conexão de banco de dados que foi anexada anteriormente usando a instrução ATTACH. Se o mesmo arquivo de banco de dados tiver sido anexado com vários aliases, esse comando desconectará apenas o nome fornecido e o restante do anexo continuará existindo. Os bancos de dados dentro do banco de dados em memória ou temporário serão destruídos completamente e o conteúdo será perdido.

Exemplo

sqlite> .databases
main: D:sqliteStudentDetails.db;
Department: D:sqliteDepartmentDetails.db
Student: D:sqliteStudentDetails.db
DeptInformation: D:sqliteDepartmentDetails.db

sqlite> DETACH DATABASE 'Department';

sqlite> .databases
main: D:sqliteStudentDetails.db;
Student: D:sqliteStudentDetails.db
DeptInformation: D:sqliteDepartmentDetails.db

• Criar tabela SQL

No SQLite, a instrução CREATE TABLE é usada para criar uma nova tabela. Ao criar a tabela, você precisa nomear a tabela e definir sua coluna e os tipos de dados de cada coluna.

Sintaxe:

CREATE TABLE table_name(
         Column1 column_type [constraints]
         Column2 column_type [constraints]
         [.....]
          );

Exemplo

CREATE TABLE StudentInfo(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
DEPARTMENTID INTEGER NOT NULL,
PHONE TEXT DEFAULT 'UNKNOWN',
FOREIGN KEY(DEPARTMENTID) REFERENCES DepartmentInfo(DeptID)
); 

Você pode verificar se a tabela foi criada ou não usando .tables comando como mostrado abaixo. Observe que já criei uma tabela chamada DepartmentInfo onde DeptID é a chave primária. A tabela Departments tem uma restrição de chave estrangeira para a tabela Students.

 

sqlite> .tables
StudentInfo Contacts Emp_Master

• Tabela de descarte do SQLite

No SQLite, a instrução DROP TABLE permite remover ou excluir uma tabela do banco de dados SQLite. Depois que a tabela é eliminada, todos os dados que ela contém são removidos permanentemente do banco de dados. Quaisquer índices e gatilhos associados também são removidos. Se houver alguma restrição de chave estrangeira habilitada nessa tabela, isso será removido de forma equivalente para cada linha na tabela e quaisquer gatilhos associados à tabela também serão descartados.

Sintaxe

DROP TABLE [ IF EXISTS ] table_name;

Exemplo

 DROP TABLE Department;
Error: no such table: Department

DROP TABLE Company;
sqlite> .tables
StudentInfo

Além disso, há uma instrução SQLite Alter Table , que entenderemos nas próximas seções deste artigo. Agora que criamos uma tabela, vamos verificar como inserir, excluir e alterar os dados.

Tutorial SQLite:Operações CRUD

• Consulta de inserção SQLite

Depois de criar a tabela, o comando SQLite Insert Into pode ser usado para criar novas linhas na tabela especificada. Existem duas formas significativas da instrução de inserção SQLite. O primeiro formulário usa uma cláusula VALUES para especificar uma lista de valores a serem inseridos.

Sintaxe

INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)]  
VALUES (value1, value2, value3,...valueN);

Exemplo

INSERT INTO StudentInfo ( ID, NAME, AGE, ADDRESS, DEPARTMENTID, PHONE)
VALUES (1,'Dean', 20, 'California', 2, '934*******');

Saída

SELECT *from StudentInfo;
ID          NAME        AGE         ADDRESS     DEPARTMENTID  PHONE
----------  ----------  ----------  ----------  ----------  ----------
1           Dean        20          California  2  934*******

Aqui, uma única nova linha é criada e cada valor é registrado em sua respectiva coluna. Observe que ambas as listas devem ter o mesmo número de ítens. Aqui, a lista das colunas é opcional. Também podemos inserir dados na tabela sem especificar a lista de colunas .

Exemplo

INSERT INTO StudentInfo 
VALUES ( 2, 'SAM', 22, 'Texas', 2, '976*******');

Saída

 SELECT *from StudentInfo;
ID          NAME        AGE         ADDRESS     DEPARTMENTID  PHONE
----------  ----------  ----------  ----------  ----------  ----------
1           Dean        20          California  2  934*******
2           SAM         22          Texas        2  976*******

Exemplo

INSERT INTO StudentInfo
VALUES (3,'John',23,'Norway',1,'923*******'),
(4,'Mitch',22,'Houston',3,'934*******');

Saída

 Select *from StudentInfo;
1|Dean|20|California|2|934*******
2|SAM|22|Texas|2|976*******
3|John|23|Norway|1|923*******
4|Mitch|22|Houston|3|934*******

Como você pode ver, o formato da saída não é muito semelhante ao anterior. Então, como você altera o formato de saída no SQLite? Vamos formatar a saída para que nossos resultados sejam um pouco mais fáceis de ler.

• Formatação

Você pode usar .mode para alterar o modo de saída. O exemplo acima usa .mode list, que exibe os resultados como uma lista. Além disso, você pode usar .headers para especificar se os cabeçalhos das colunas devem ou não ser exibidos. Depois de fazer as alterações, você pode visualizar a configuração usando .show comando.

Exemplo

 sqlite>.mode 'column'
sqlite> .headers on
sqlite> .show
echo: off
eqp: off
explain: auto
headers: on
mode: column
nullvalue: ""
output: stdout
colseparator: "|"
rowseparator: "n"
stats: off
width:
filename: StudentDetails.db

Saída

 SELECT *FROM StudentInfo;

ID NAME AGE ADDRESS DEPARTMENT PHONE
---------- ---------- ---------- ---------- ---------- ----------
1 Dean 20 California 2 934*******
2 SAM 22 Texas 2 976*******
3 John 23 Norway 1 923*******
4 Mitch 22 Houston 3 934*******

• Consulta de seleção SQLite

No SQLite, a instrução Select é usada para buscar dados de uma tabela, que retorna dados na forma de uma tabela de resultados. Essas tabelas de resultados também são chamadas de conjuntos de resultados. Usando a instrução SQLite select, podemos realizar cálculos simples ou várias expressões com base em nossos requisitos. Já usamos uma instrução SELECT anteriormente quando inserimos dados.

Sintaxe

SELECT [ALL | DISTINCT] result [FROM table-list]
[WHERE expr]

• DISTINTO – Quando usamos a palavra-chave distinct em uma instrução select, ela retorna apenas linhas distintas de dados.
• TODOS – Se usarmos a palavra-chave ALL em uma instrução select, ela retornará todas as linhas de dados, mesmo que esteja duplicada.
• DE lista de tabelas – É uma lista de tabelas das quais você deseja obter dados.
• expressão WHERE – A expressão WHERE é usada para definir nossas condições personalizadas para obter os dados necessários das tabelas.

Exemplo1

 SELECT ID, NAME FROM StudentInfo WHERE AGE < 21;

Saída

ID NAME
---------- ----------
1 Dean

Exemplo2

Select NAME FROM StudentInfo WHERE DEPARTMENTID
= (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology');

Saída

//fetches people from department whose id is 2

NAME
----------
Dean
SAM

• Consulta de atualização do SQLite

No SQLite, a instrução UPDATE pode ser usada para modificar os registros existentes em uma tabela. A cláusula WHERE do SQLite pode ser usada para especificar exatamente quais linhas devem ser atualizadas. Você pode atualizar facilmente todas as linhas, algumas linhas ou nenhuma, dependendo das condições de filtragem aplicadas pela cláusula WHERE.

Sintaxe

UPDATE table_name  
SET column1 = value1, column2 = value2...., columnN = valueN  
WHERE [condition];

Exemplo

UPDATE StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2';

Saída

 SELECT *FROM StudentInfo;
ID          NAME        AGE         ADDRESS     DEPARTMENTID  PHONE
----------  ----------  ----------  ----------  ------------  ----------
1           Dean        20          California  2             934*******
2           SAM         22          Texas       4             976*******
3           John        23          Norway      1             923*******
4           Mitch       22          Houston     3             934*******

• Consulta de exclusão do SQLite

No SQLite, a instrução DELETE pode ser usada para excluir o registro da tabela. Você pode excluir facilmente todas as linhas, algumas linhas ou nenhuma, dependendo das condições de filtragem aplicadas pela cláusula WHERE.

Exemplo

 DELETE FROM DepartmentInfo WHERE DeptName = 'Science';

Saída

 SELECT *FROM DepartmentInfo;
DeptID DeptName
---------- -----------
1 Mathematics
2 Psychology
3 Sports
4 Music

Se você tentar excluir um registro referenciado por uma chave estrangeira, receberá um erro. Você precisará excluir os registros de chave estrangeira primeiro, antes de excluir o registro de chave primária. Vamos tentar excluir a ciência do departamento.

Exemplo

DELETE FROM DepartmentInfo WHERE DeptName = 'Music';
Error: FOREIGN KEY constraint failed

DELETE FROM StudentInfo WHERE DEPARTMENTID = 4;

sqlite> DELETE FROM DepartmentInfo WHERE DeptName = 'Music';

sqlite> SELECT *FROM DepartmentInfo;
DeptID      DeptName
----------  -----------
1           Mathematics
2           Psychology
3           Sports

 SELECT *FROM StudentInfo;
ID          NAME        AGE         ADDRESS     DEPARTMENTID  PHONE
----------  ----------  ----------  ----------  ------------  ----------
1           Dean        20          California  2             934*******
3           John        23          Norway      1             923*******
4           Mitch       22          Houston     3             934*******

Agora você sabe como editar os registros na tabela do Banco de Dados SQLite. Avançando neste blog de tutorial do SQLite, vamos discutir diferentes cláusulas e condições que você encontra no SQLite com mais frequência.

Cláusulas/condições SQLite

SELECT [ALL | DISTINCT] result [FROM table-list]
[WHERE expr]
[GROUP BY expr-list]
[HAVING expr]
[compound-op select]*
[ORDER BY sort-expr-list]
[LIMIT integer [(OFFSET|,) integer]]

//Student 
Table ID          NAME        AGE         ADDRESS     DEPARTMENTID  PHONE
----------  ----------  ----------  ----------  ------------  ----------
1           Dean        20          California  2             934*******
3           John        23          Norway      1             923*******
4           Mitch       22          Houston     3             934*******
2           SAM         22          Texas       4             976*******
5           Johny       23          Norway      2             945*******
6           Robin       23          Norway      2             UNKNOWN

//Department Details
DeptID      DeptName
----------  -----------
1           Mathematics
2           Psychology
3           Sports
4           Music
5           Science

• SQLite ONDE

No SQLite, a cláusula WHERE é usada para impor restrições à instrução SELECT, definindo uma ou mais condições para obter os dados necessários das tabelas do banco de dados. Se a condição especificada for satisfeita ou verdadeira, ela retornará o valor específico da tabela. Como você viu antes A cláusula WHERE não só é usada na instrução SELECT, mas também é usada na instrução UPDATE, DELETE, etc.

Exemplo

SELECT NAME FROM StudentInfo WHERE AGE = 23;NAME
----------
John
Johny
Robin

No SQLite, há vários operadores relacionais que podem ser usados ​​com a cláusula WHERE.

• SQLite GROUP BY

No SQLite, a cláusula GROUP BY é usada para agregar dados em uma única linha onde o valor de uma ou mais colunas especificadas é repetido. Esta cláusula é usada com a cláusula WHERE na instrução SELECT e precede a cláusula ORDER BY.

Sintaxe

SELECT result
FROM [table-list]
GROUP BY [expr-list]

SELECT NAME, ADDRESS FROM StudentInfo GROUP BY NAME;

NAME ADDRESS
---------- ----------
Dean California
John Norway
Johny Norway
Mitch Houston
Robin Norway
SAM Texas

Observe que o processo de agrupamento tem duas etapas. Primeiro, a expressão GROUP BY é usada para organizar as linhas da tabela em diferentes grupos. Depois que os grupos são definidos, a instrução SELECT define como esses grupos são reduzidos em uma única linha.

• SQLite ORDER BY

Geralmente, as tabelas SQLite armazenam dados em ordem não especificada e retornarão registros na mesma ordem não especificada ao buscar dados usando a instrução SQLite select. Nesses casos, você pode usar a cláusula ORDER BY para classificar os registros da coluna em ordem crescente ou decrescente. No exemplo abaixo, agrupei e ordenei 9 em ordem decrescente) os dados com base no endereço.

Sintaxe

SELECT expressions
FROM tables-list
[WHERE conditions]
ORDER BY column1, column2,... [ ASC | DESC ];

Exemplo

SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS ORDER BY ADDRESS DESC;
ADDRESS COUNT(ADDRESS)
---------- --------------
Texas 1
Norway 3
Houston 1
California 1

• SQLite TENDO POR

No SQLite, o HAVING cláusula é idêntica a WHERE cláusula. A cláusula HAVING é uma condição adicional aplicada após a agregação ocorrer junto com o group by na instrução select. Geralmente em SQLite, WHERE cláusula é usada para aplicar uma condição a elementos individuais em uma tabela e a cláusula HAVING A cláusula é usada para adicionar condições de filtro com base nos grupos criados pela cláusula Group By.

Exemplo

SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo 
GROUP BY ADDRESS 
HAVING COUNT(*)>1;

ADDRESS     COUNT(ADDRESS)
----------  --------------
Norway      3

• Cláusula de limite SQLite

Sintaxe

SELECT expressions
FROM tables-list
[WHERE conditions]
LIMIT number_rows OFFSET offset_value;

Exemplo

SELECT NAME, ADDRESS FROM StudentInfo LIMIT 4 OFFSET 2;
NAME        ADDRESS
----------  ----------
Mitch       Houston
SAM         Texas
Johny       Norway
Robin       Norway 

• SQLite AND &OR

No SQLite, os operadores AND &OR são usados ​​para executar várias condições em instruções de seleção, inserção, atualização e exclusão com base em nossos requisitos. O operador SQLite AND retornará linhas ou registros que satisfaçam as condições definidas usando o operador AND.

Exemplo1

SELECT NAME FROM StudentInfo WHERE AGE = 22 AND ADDRESS = 'Texas';
NAME
----------
SAM

Exemplo2

SELECT NAME FROM StudentInfo WHERE (AGE = 22 AND ADDRESS = 'Norway') OR ADDRESS = 'Norway';
NAME
----------
John
Johny
Robin

• Operador SQLite GLOB

No SQLite, o operador GLOB é usado para verificar se o valor da string determinada corresponde a um padrão específico ou não. Caso o valor da string corresponda ao valor do padrão, ele retornará true e é semelhante ao operador LIKE. Além disso, o GLOB diferencia maiúsculas de minúsculas.

Sintaxe

SELECT * FROM table_name
WHERE column_name GLOB 'search-expression'

Exemplo

SELECT *FROM StudentInfo WHERE NAME GLOB 'Joh*';
ID NAME AGE ADDRESS DEPARTMENTID PHONE
---------- ---------- ---------- ---------- ------------ ----------
3 John 23 Norway 1 923*******
5 Johny 23 Norway 2 945*******

• SQLite distinto

No SQLite, a palavra-chave DISTINCT examinará o conjunto de resultados da instrução SELECT e eliminará quaisquer linhas duplicadas. Além disso, os valores NULL são considerados duplicados, portanto, se usarmos a cláusula DISTINCT com uma coluna que possui valores NULL, ela manterá apenas uma linha de um valor NULL. Quando você aplica DISTINCT para várias colunas, a instrução retorna cada combinação exclusiva de coulnm1 e coluna2.

Exemplo

SELECT DISTINCT AGE FROM StudentInfo;
AGE
----------
20
23
22

• Operador SQLite IN

Exemplo

SELECT NAME FROM StudentInfo WHERE ADDRESS IN ('Texas', 'Houston');
NAME
----------
Mitch
SAM

• SQLite UNION &UNION ALL

No SQLite, o operador UNION é usado para combinar os conjuntos de resultados de 2 ou mais instruções SELECT e remove linhas duplicadas entre as várias instruções SELECT. Lembre-se de que as instruções SELECT que usamos com o operador UNION devem ter o mesmo número de campos nos conjuntos de resultados com tipos de dados semelhantes.

Sintaxe

SELECT expression1, expression2,... expression_n
FROM tables
[WHERE conditions]

UNION / UNION ALL

SELECT expression1, expression2,... expression_n
FROM tables
[WHERE conditions];

Exemplo

 SELECT DEPARTMENTID FROM StudentInfo 
UNION
SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC;

DEPARTMENTID
------------
1
2
3
4
5

Exemplo

SELECT DEPARTMENTID FROM StudentInfo UNION ALL SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC;
DEPARTMENTID
------------
1
1
2
2
2
2
3
3
4
4
5

Com isso, cobrimos os comandos mais básicos que você pode ter que usar ao trabalhar com SQLite. Avançando com este tutorial do SQLite, vamos verificar a instrução join no SQLite.

Junta-se no SQLite

• Inner Join – INNER JOIN é usado para combinar e retornar apenas registros correspondentes de várias tabelas com base nas condições definidas nas instruções SQLite.
• União externa – SQLite Outer Join selecionará linhas correspondentes de várias tabelas da mesma forma que Inner Join e algumas outras linhas fora do relacionamento. Em termos simples, podemos dizer que SQLite OUTER JOIN é uma adição de INNER JOIN. Geralmente, temos três tipos de Outer Joins no padrão SQL:LEFT, RIGHT e FULL Outer Joins, mas o SQLite suporta apenas LEFT OUTER JOIN.
• Cross Join – É usado para obter o produto cartesiano de linhas, combinando cada linha da primeira tabela com cada linha da segunda tabela.
• Autojunção – É usado para unir a mesma tabela consigo mesma. Para usar o Self Join, precisamos criar nomes de alias diferentes para a mesma tabela para realizar operações com base em nossos requisitos.

Com isso, cobrimos os comandos básicos do SQLite. Conceitos avançados não são abordados aqui. Portanto, fique atento a outro artigo sobre conceitos avançados de SQLite. Mesmo com todos os bons recursos que o SQLite tem a oferecer, ele também apresenta algumas desvantagens.

Tutorial do SQLite:Desvantagens do SQLite

• Não funciona bem na arquitetura cliente/servidor.
• O tamanho de um banco de dados SQLite é limitado a 2 GB na maioria dos casos.
• SQLite não implementou RIGHT OUTER JOIN e FULL OUTER JOIN. Com o SQLite, só podemos implementar LEFT OUTER JOIN.
• As visualizações no SQLite são somente leitura. Não podemos usar instruções DML (Inserir, Atualizar e Excluir) com visualizações.
• Não podemos usar instruções GRANT e REVOKE com SQLite.

Com isso, encerramos este Tutorial SQLite.

Se você deseja aprender mais sobre o MySQL e conhecer esse banco de dados relacional de código aberto, confira nosso Treinamento de certificação de DBA MySQL que vem com treinamento ao vivo conduzido por instrutor e experiência de projeto na vida real. Este treinamento ajudará você a entender o MySQL em profundidade e a dominar o assunto.

Tem alguma pergunta para nós? Por favor, mencione-o na seção de comentários deste Tutorial SQLite e eu entrarei em contato com você.