Construindo Tabelas em SQLite: Guia Prático

Introdução

Neste laboratório, você aprenderá as habilidades fundamentais para criar e gerenciar tabelas em SQLite, um motor de banco de dados leve e sem servidor, perfeito para aplicações de pequena escala. Você explorará os tipos de dados do SQLite, criará tabelas com chaves primárias, aplicará restrições como NOT NULL e UNIQUE, inspecionará as estruturas das tabelas usando o comando .schema e removerá tabelas com segurança. Através de exercícios passo a passo no ambiente da máquina virtual (VM) do LabEx, você obterá experiência prática usando a ferramenta de linha de comando sqlite3 para construir e gerenciar tabelas de banco de dados. Este laboratório foi projetado para iniciantes, fornecendo um caminho claro para a compreensão do gerenciamento de tabelas SQLite.

Conecte-se ao SQLite e Crie uma Tabela de Contatos

Neste primeiro passo, você se conectará a um banco de dados SQLite e criará sua primeira tabela chamada contacts. SQLite é um motor de banco de dados leve que armazena dados em um único arquivo. Você usará a ferramenta de linha de comando sqlite3 para interagir com o banco de dados.

Abra um terminal no ambiente da máquina virtual (VM) do LabEx. Certifique-se de estar no diretório de trabalho padrão /home/labex/project.
Conecte-se a um banco de dados SQLite chamado test.db usando a ferramenta sqlite3. Este comando criará o arquivo do banco de dados se ele ainda não existir.
```
sqlite3 test.db
```
Este comando abre o shell do SQLite, e você verá um prompt como sqlite>, indicando que você está dentro do ambiente SQLite.
Crie uma tabela chamada contacts com colunas para id, name e phone. Insira o seguinte comando SQL no prompt sqlite>:
```
CREATE TABLE contacts (
    id INTEGER PRIMARY KEY,
    name TEXT,
    phone TEXT
);
```
Este comando cria uma tabela chamada contacts. A coluna id é um inteiro e é designada como a PRIMARY KEY (chave primária), o que significa que ela identificará exclusivamente cada linha na tabela. As colunas name e phone são ambas do tipo TEXT, que pode armazenar quaisquer dados de string.

Vamos detalhar o comando:
- CREATE TABLE contacts: Isso informa ao SQLite para criar uma nova tabela chamada contacts.
- id INTEGER PRIMARY KEY: Isso define uma coluna chamada id com o tipo de dados INTEGER. A restrição PRIMARY KEY garante que cada valor nesta coluna seja único e sirva como o identificador primário para cada linha.
- name TEXT: Isso define uma coluna chamada name com o tipo de dados TEXT, que pode armazenar quaisquer dados de string.
- phone TEXT: Isso define uma coluna chamada phone com o tipo de dados TEXT, que pode armazenar quaisquer dados de string.

Inserir Dados na Tabela de Contatos

Agora que você criou a tabela contacts, vamos inserir alguns dados nela. Você usará a instrução INSERT INTO para adicionar novas linhas à tabela.

Insira um novo contato na tabela contacts. Execute este comando no prompt sqlite>:
```
INSERT INTO contacts (name, phone) VALUES ('John Doe', '123-456-7890');
```
Este comando insere uma nova linha na tabela contacts com o nome 'John Doe' e o número de telefone '123-456-7890'. A coluna id receberá automaticamente um valor único porque é a chave primária.

Vamos detalhar o comando:
- INSERT INTO contacts: Isso informa ao SQLite para inserir dados na tabela contacts.
- (name, phone): Isso especifica as colunas nas quais você deseja inserir dados.
- VALUES ('John Doe', '123-456-7890'): Isso especifica os valores a serem inseridos nas colunas correspondentes.
Insira outro contato na tabela contacts:
```
INSERT INTO contacts (name, phone) VALUES ('Jane Smith', '987-654-3210');
```
Este comando insere outra linha na tabela contacts com o nome 'Jane Smith' e o número de telefone '987-654-3210'.

Recuperar Dados da Tabela de Contatos

Agora que você inseriu dados na tabela contacts, vamos recuperá-los. Você usará a instrução SELECT para consultar a tabela e exibir os dados.

Recupere todos os dados da tabela contacts. Execute este comando no prompt sqlite>:
```
SELECT * FROM contacts;
```
Este comando seleciona todas as colunas (*) da tabela contacts e exibe os resultados.

Saída Esperada:
```
1|John Doe|123-456-7890
2|Jane Smith|987-654-3210
```
A saída mostra os dois contatos que você inseriu, juntamente com seus valores de id atribuídos automaticamente.

Vamos detalhar o comando:
- SELECT *: Isso informa ao SQLite para selecionar todas as colunas da tabela.
- FROM contacts: Isso especifica a tabela da qual você deseja recuperar dados.
Recupere apenas as colunas name e phone da tabela contacts:
```
SELECT name, phone FROM contacts;
```
Este comando seleciona apenas as colunas name e phone da tabela contacts e exibe os resultados.

Saída Esperada:
```
John Doe|123-456-7890
Jane Smith|987-654-3210
```

Criar uma Tabela de Usuários com Restrições

Restrições (Constraints) são regras que impõem a integridade dos dados em uma tabela. Vamos adicionar as restrições NOT NULL e UNIQUE a uma nova tabela chamada users.

Crie uma tabela chamada users com restrições. Execute este comando no prompt sqlite>:
```
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    email TEXT NOT NULL,
    age INTEGER
);
```
Este comando cria uma tabela chamada users com as seguintes restrições:
- username não pode ser NULL e deve ser UNIQUE.
- email não pode ser NULL.
Vamos detalhar o comando:
- CREATE TABLE users: Isso informa ao SQLite para criar uma nova tabela chamada users.
- id INTEGER PRIMARY KEY: Isso define uma coluna chamada id com o tipo de dados INTEGER. A restrição PRIMARY KEY garante que cada valor nesta coluna seja único e sirva como o identificador primário para cada linha.
- username TEXT NOT NULL UNIQUE: Isso define uma coluna chamada username com o tipo de dados TEXT. A restrição NOT NULL garante que esta coluna não possa estar vazia, e a restrição UNIQUE garante que todos os valores nesta coluna sejam distintos.
- email TEXT NOT NULL: Isso define uma coluna chamada email com o tipo de dados TEXT. A restrição NOT NULL garante que esta coluna não possa estar vazia.
- age INTEGER: Isso define uma coluna chamada age com o tipo de dados INTEGER.
Agora, vamos tentar inserir alguns dados que violem essas restrições para ver como elas funcionam. Primeiro, tente inserir um usuário sem um nome de usuário:
```
INSERT INTO users (email, age) VALUES ('test@example.com', 25);
```
Você verá um erro porque a coluna username é definida como NOT NULL.

Saída Esperada:
```
Error: NOT NULL constraint failed: users.username
```
Este erro mostra que o SQLite impõe a restrição NOT NULL em username, impedindo a inserção.
Em seguida, tente inserir um usuário com um nome de usuário duplicado. Primeiro, insira um usuário válido:
```
INSERT INTO users (username, email, age) VALUES ('johndoe', 'john.doe@example.com', 30);
```
Em seguida, tente inserir outro usuário com o mesmo nome de usuário:
```
INSERT INTO users (username, email, age) VALUES ('johndoe', 'jane.doe@example.com', 25);
```
Você verá um erro porque a coluna username é definida como UNIQUE.

Saída Esperada:
```
Error: UNIQUE constraint failed: users.username
```
Este erro demonstra que o SQLite impõe a restrição UNIQUE em username, impedindo valores duplicados.

Inspecionar a Estrutura da Tabela com .schema

Você pode inspecionar a estrutura de uma tabela usando o comando .schema. Este comando exibe a instrução SQL usada para criar a tabela, incluindo nomes de colunas, tipos de dados e restrições.

Inspecione a estrutura da tabela users. Execute este comando no prompt sqlite>:
```
.schema users
```
Saída Esperada:
```
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    email TEXT NOT NULL,
    age INTEGER
);
```
A saída mostra a instrução CREATE TABLE para a tabela users, incluindo as restrições NOT NULL e UNIQUE na coluna username.

O comando .schema é uma ferramenta útil para entender a estrutura de suas tabelas e verificar se as restrições estão definidas corretamente.
Saia do shell SQLite:
```
.quit
```
Este comando sairá do shell SQLite e o retornará ao terminal Linux.

IMPORTANTE: Certifique-se de usar .quit antes de clicar no botão "Continuar". Caso contrário, a etapa não poderá ser verificada porque o histórico do sqlite não será registrado.

Excluir a Tabela de Contatos

Você pode remover uma tabela do banco de dados usando o comando DROP TABLE. Este comando exclui permanentemente a tabela e todos os seus dados, portanto, use-o com cautela.

Conecte-se ao banco de dados test.db:
```
sqlite3 test.db
```
Remova a tabela contacts. Execute este comando no prompt sqlite>:
```
DROP TABLE contacts;
```
Este comando exclui a tabela contacts e todos os seus dados do banco de dados.

Aviso: Esta ação é irreversível. Depois de remover uma tabela, você não poderá recuperá-la nem seus dados.
Verifique se a tabela contacts foi removida tentando selecionar dados dela:
```
SELECT * FROM contacts;
```
Você verá um erro porque a tabela contacts não existe mais.
Saia do shell SQLite:
```
.quit
```

Resumo

Neste laboratório, você aprendeu as habilidades fundamentais para construir e gerenciar tabelas no SQLite. Você explorou os tipos de dados do SQLite, criou tabelas com chaves primárias, aplicou restrições como NOT NULL e UNIQUE, inspecionou estruturas de tabelas usando o comando .schema e removeu tabelas com segurança. Essas habilidades são essenciais para trabalhar com bancos de dados SQLite e construir aplicações orientadas a dados.