Esta página precisa de um navegador recente (com suporte a SharedArrayBuffer). Por favor, atualize Chrome, Edge, Firefox ou Safari para a versão mais recente.
Um banco de dados armazena dados em tabelas. Uma consulta lê dados com SELECT. SELECT * retorna todas as colunas; FROM nomeia a tabela.
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
SELECT * FROM student;
Una tabla almacena registros: cada fila es un registro, cada columna es un campo
Cada linha é um registro. Palavras-chave SQL são escritas em MAIÚSCULAS por convenção.
Una sentencia termina con punto y coma ;.
1.2
Elegir columnas
Liste as colunas desejadas, separadas por vírgulas. Use AS para renomear uma coluna no resultado (um apelido).
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
SELECT name, score AS mark FROM student;
Una columna seleccionada también puede ser un cálculo; combínela con AS para nombrar la nueva columna:
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
SELECT name, score + 5 AS bonus FROM student;
SELECT DISTINCT col elimina valores duplicados del resultado.
1.3
Filtrado con WHERE
WHERE mantém apenas as linhas que correspondem a uma condição. Compare com =, <> (diferente), <, >, <=, >=. Coloque texto entre aspas simples.
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71), (3, 'Ana', 95);
SELECT name, score FROM student WHERE score >= 80;
Leia as partes nesta ordem lógica: FROM → WHERE → SELECT. (O banco de dados pode executar o trabalho de forma diferente, mas o resultado é o mesmo.)
Erros comuns
Ponga valores de texto entre comillas simples: WHERE name = 'Ann'; los nombres de columna no llevan comillas.
SELECT * retorna todas as colunas — nomeie apenas as colunas que você precisa.
Combine condiciones con AND, OR, NOT. AND requiere que todos los lados sean verdaderos; OR requiere que cualquier lado sea verdadero; NOT invierte uno. Use paréntesis para establecer la precedencia 优先级.
CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
SELECT name FROM student WHERE form = '11A' AND score >= 90;
AND necesita todos verdaderos; OR necesita alguno; NOT invierte uno
2.2
LIKE, IN y BETWEEN
LIKE coincide con un patrón de texto 模式: % representa cualquier texto y _ representa un solo carácter; estos son comodines 通配符.
CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
SELECT name FROM student WHERE name LIKE 'M%'; -- starts with M
Patrón
Coincide con
'M%'
comienza con M
'%a'
termina con a
'%an%'
contiene "an"
'M_i'
M, luego exactamente un carácter, luego i
IN coincide con un conjunto 集合 de valores; BETWEEN coincide con un rango 范围 (ambos extremos incluidos).
CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
SELECT name, score FROM student
WHERE form IN ('11A', '11C') AND score BETWEEN 80 AND 100;
2.3
NULL
NULL marca um valor ausente 缺失值 — nada foi armazenado naquela célula. NULL não é 0 nem uma string vazia. Uma comparação com = ou <> nunca corresponde a ele; teste com IS NULL ou IS NOT NULL.
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', NULL), (3, 'Ana', 95);
SELECT name FROM student WHERE score IS NULL;
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', NULL), (3, 'Ana', 95);
SELECT name, score FROM student WHERE score IS NOT NULL;
WHERE score = NULL no devuelve ninguna fila — ni siquiera la fila de Sam.
Un NULL en aritmética da NULL: score + 5 permanece NULL para Sam.
Erros comuns
Pruebe un valor vacío con IS NULL, nunca = NULL.
En LIKE, % coincide con cualquier texto y _ coincide con un carácter: 'A%' significa "comienza con A".
IN (1, 2, 3) es más corto que muchos ORs; BETWEEN a AND b incluye ambos extremos.
ORDER BY ordena 排序 as linhas resultantes. Adicione DESC para descendente 降序 (alto para baixo); o padrão é ascendente 升序 (baixo para alto).
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei',88),(2,'Sam',71),(3,'Ana',95);
SELECT name, score FROM student ORDER BY score DESC;
Ordenar por más de una columna
Enumere varias columnas. Un empate 平局 en la primera columna se resuelve con la siguiente.
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei',88),(2,'Sam',88),(3,'Ana',95);
SELECT name, score FROM student ORDER BY score DESC, name ASC;
LIMIT (top-N)
LIMIT n conserva solo las primeras n filas — combínelo con ORDER BY para una lista top-N 前 N 名.
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei',88),(2,'Sam',71),(3,'Ana',95);
SELECT name, score FROM student ORDER BY score DESC LIMIT 2;
ORDER BY también puede ordenar por un alias o un cálculo: ORDER BY avg_score DESC.
El texto se ordena alfabéticamente: ORDER BY name ejecuta de A → Z.
Erros comuns
ORDER BY ordena ascendente por defecto; agregue DESC para descendente.
ORDER BY viene cerca del final, después de WHERE y GROUP BY.
LIMIT limita cuántas filas se devuelven, pero solo después del ordenamiento.
ORDER BY ordena; LIMIT conserva las primeras n después del ordenamiento
Uma função agregada transforma muitas linhas em um único valor resumido. Envolve uma média em ROUND(x, 2) para arredondá-la.
Función
Da
COUNT(*)
cuántas filas
SUM(col)
el total
AVG(col)
el promedio medio
MIN(col) / MAX(col)
el valor más pequeño / más grande
CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
SELECT COUNT(*), ROUND(AVG(score), 2), MAX(score) FROM student;
4.2
GROUP BY y HAVING
GROUP BY cria uma linha resumida por grupo. HAVING filtra esses grupos — é como WHERE, mas executa após o agrupamento.
CREATE TABLE student (id INTEGER, name TEXT, form TEXT, score INTEGER);
INSERT INTO student VALUES (1,'Mei','11A',88),(2,'Sam','11B',71),(3,'Ana','11A',95);
SELECT form, COUNT(*) AS n, ROUND(AVG(score), 2) AS avg_score
FROM student
GROUP BY form
HAVING COUNT(*) > 1;
GROUP BY agrupa filas en un solo cubo por valor; cada cubo se convierte en una fila resumen
Escreva cláusulas SQL na ordem sintática exigida. A tabela abaixo é um modelo lógico para raciocínio sobre uma consulta; o motor pode otimizar sua ordem de execução física:
Paso
Cláusula
1
FROM (y cualquier JOIN)
2
WHERE — filtrar filas
3
GROUP BY — formar grupos
4
HAVING — filtrar grupos
5
SELECT — calcular las columnas de salida
6
ORDER BY, luego LIMIT
Erros comuns
Para resultados agrupados previsíveis, agrupe cada coluna selecionada não-agregada (ou use uma dependência funcional conhecida suportada pelo banco de dados). O SQLite permite uma coluna solta fora de GROUP BY, mas ela pode vir de uma linha arbitrária no grupo; uma consulta bem-sucedida não garante o valor pretendido.
Filtre filas con WHERE (antes del agrupamiento) y filtre grupos con HAVING (después).
COUNT(*) cuenta filas; COUNT(col) omite NULLs en esa columna.
Uma chave primária nomeia unicamente cada linha em uma tabela. Uma chave estrangeira em uma tabela aponta para a chave primária de outra — isso estabelece uma relação entre elas.
CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', 2);
SELECT * FROM student;
5.2
INNER JOIN
Um join combina linhas de duas tabelas. INNER JOIN ... ON ... mantém linhas onde as chaves correspondem. Um alias curto (s, c) mantém a consulta legível.
CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', 2);
SELECT s.name, c.name AS class
FROM student s INNER JOIN class c ON s.class_id = c.id;
INNER JOIN hace coincidir cada clave foránea con una clave primaria y combina las filas coincidentes
5.3
Joining con grouping
Haga el join primero, luego GROUP BY para resumir a través de las filas unidas.
CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', 2), (3, 'Ana', 1);
SELECT c.name AS class, COUNT(*) AS n
FROM student s INNER JOIN class c ON s.class_id = c.id
GROUP BY c.id, c.name;
Agrupar pela chave c.id além do nome: duas classes que acidentalmente compartilham um nome seriam fundidas em uma única linha sem isso.
5.4
LEFT JOIN
Um INNER JOIN mantém apenas linhas correspondentes. Um LEFT JOIN mantém todas as linhas da tabela esquerda (primeira); onde não há correspondência, as colunas da tabela direita retornam como NULL.
CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT, class_id INTEGER REFERENCES class(id));
INSERT INTO class VALUES (1, 'Maths'), (2, 'Art');
INSERT INTO student VALUES (1, 'Mei', 1), (2, 'Sam', NULL);
SELECT s.name, c.name AS class
FROM student s LEFT JOIN class c ON s.class_id = c.id;
Sam no tiene clase, pero la fila aún aparece — con class como NULL.
Para encontrar solo las filas no coincidentes, agregue WHERE c.id IS NULL.
Erros comuns
Un join sin condición ON empareja cada fila con cada fila (un cross join).
Haga coincidir la clave foránea con la clave primaria: ON orders.customer_id = customers.id.
Un INNER JOIN elimina filas que no tienen coincidencia en el otro lado; use un LEFT JOIN para conservarlo.
INSERT INTO ... VALUES ... agrega nuevas filas 行. Nombre las columnas, luego dé los valores en el mismo orden. (Cada bloque abajo termina con un SELECT para que pueda ver el resultado.)
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student (id, name, score) VALUES (1, 'Mei', 88);
INSERT INTO student VALUES (2, 'Sam', 71);
SELECT * FROM student;
INSERT INTO t VALUES (...), (...); agrega varias filas en una sola sentencia.
INSERT agrega una nueva fila a una tabla
6.2
UPDATE
UPDATE ... SET ... WHERE ... cambia filas existentes. Siempre agregue WHERE, o cambiará cada fila.
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
UPDATE student SET score = 75 WHERE name = 'Sam';
SELECT * FROM student;
6.3
DELETE
DELETE FROM ... WHERE ... elimina filas. Sin WHERE vaciará toda la tabla 表.
CREATE TABLE student (id INTEGER, name TEXT, score INTEGER);
INSERT INTO student VALUES (1, 'Mei', 88), (2, 'Sam', 71);
DELETE FROM student WHERE score < 80;
SELECT * FROM student;
Erros comuns
UPDATE y DELETEsin un WHERE cambian cada fila — siempre agregue el WHERE.
En INSERT, los valores deben alinearse con la lista de columnas en orden y tipo.
Pruebe un DELETE riesgoso primero como un SELECT con el mismo WHERE.
CREATE TABLE define o esquema de uma tabela: os nomes das colunas e seus tipos de dados. Os principais tipos do SQLite são INTEGER, TEXT e REAL (um número de ponto flutuante: rápido, mas nem sempre exato, portanto 0.1 + 0.2 = 0.3 é falso).
CREATE TABLE student (id INTEGER, name TEXT, score REAL);
INSERT INTO student VALUES (1, 'Mei', 88.5);
SELECT * FROM student;
CREATE TABLE nomeia colunas e seus tipos
7.2
Chaves & restrições
Uma restrição é uma regra sobre uma coluna: PRIMARY KEY (um ID único), NOT NULL (deve ter um valor), UNIQUE e DEFAULT (um valor padrão).
CREATE TABLE student (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
score INTEGER DEFAULT 0
);
INSERT INTO student (id, name) VALUES (1, 'Mei');
SELECT * FROM student;
Declare a foreign key with REFERENCES. No SQLite, ative a aplicação para cada conexão com PRAGMA foreign_keys = ON; antes de iniciar uma transação. Uma declaração sozinha não garante aplicação.
PRAGMA foreign_keys = ON;
CREATE TABLE class (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE student (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
class_id INTEGER REFERENCES class(id)
);
INSERT INTO class VALUES (1, 'Maths');
INSERT INTO student VALUES (1, 'Mei', 1);
SELECT s.name, c.name AS class
FROM student s INNER JOIN class c ON s.class_id = c.id;
A forma longa é FOREIGN KEY (class_id) REFERENCES class(id) na sua própria linha.
7.3
ALTER TABLE
ALTER TABLE ... ADD COLUMN ... altera o esquema de uma tabela que já existe. Um DEFAULT preenche a nova coluna nas linhas antigas.
CREATE TABLE student (id INTEGER, name TEXT);
INSERT INTO student VALUES (1, 'Mei');
ALTER TABLE student ADD COLUMN score INTEGER DEFAULT 0;
SELECT * FROM student;
ALTER TABLE student RENAME TO pupil; renomeia toda a tabela.
DROP TABLE student; exclui a tabela completamente — estrutura e dados.
Erros comuns
Declare um tipo adequado para cada coluna. O SQLite permite nomes de tipo omitidos e geralmente usa tipagem flexível; uma declaração de tipo sozinha não valida todos os valores armazenados.
Projete uma chave primária que seja única e não nula. Em tabelas comuns do SQLite, algumas declarações de chave primária ainda permitem NULL; use NOT NULL explicitamente para uma chave de texto. INTEGER PRIMARY KEY tem comportamento especial de row-id: inserir NULL aloca um id inteiro.
Com a aplicação de chaves estrangeiras ativada, um valor de chave estrangeira não nulo deve corresponder a uma chave referenciada. NULL é permitido a menos que a coluna também tenha NOT NULL.
Tabelas se conectam através de relacionamentos. Um-para-muitos é o mais comum: uma classe tem muitos alunos. Muitos-para-muitos requer uma tabela de junção intermediária. Um diagrama entidade-relacionamento (diagrama ER) desenha cada entidade como um retângulo e cada relacionamento como uma linha.
Relação
Exemplo
one-to-one
uma pessoa e seu passaporte
one-to-many
uma turma e seus alunos
many-to-many
alunos e clubes
O lado "many" carrega a chave estrangeira; um link many-to-many precisa de uma tabela join
A tabela de junção contém uma linha por link, e cada uma de suas colunas é uma chave estrangeira. Sua chave primária é o par(student_id, club_id), uma chave composta, para que o mesmo aluno não possa entrar no mesmo clube duas vezes. Ambas as colunas são NOT NULL, assim cada filiação nomeia um aluno e um clube. Aqui Mei está em dois clubes, e Xadrez tem dois membros:
CREATE TABLE student (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE club (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE membership (
student_id INTEGER NOT NULL REFERENCES student(id),
club_id INTEGER NOT NULL REFERENCES club(id),
PRIMARY KEY (student_id, club_id)
);
INSERT INTO student VALUES (1, 'Mei'), (2, 'Sam');
INSERT INTO club VALUES (1, 'Chess'), (2, 'Art');
INSERT INTO membership VALUES (1, 1), (1, 2), (2, 1);
SELECT s.name, c.name AS club
FROM membership m
INNER JOIN student s ON m.student_id = s.id
INNER JOIN club c ON m.club_id = c.id;
8.2
Normalização
A normalização organiza tabelas para evitar redundância (mesmos dados repetidos) e os erros de atualização que ela causa. As três primeiras formas normais:
1FN: cada célula contém um valor atômico — nenhuma lista dentro de uma célula.
2FN: nenhuma coluna depende apenas de parte de uma chave composta.
3NF: nenhuma coluna depende de outra coluna que não seja de chave.
Não normalizado (ruim)
Normalizado (melhor)
student(name, club1, club2)
student(name) + membership(student, club)
Erros comuns
Dividir grupos repetitivos em sua própria tabela (normalização) em vez de muitas colunas semelhantes.
Cada tabela deve descrever UM tipo de coisa.
Conectar tabelas com uma chave estrangeira que aponta para a chave primária de outra tabela.