Documentação de SQLite
Referência concisa e baseada em exemplos de SQLite. Leia o conceito, veja o código e pratique em uma jornada da Coddy.
Inicie uma jornada guiada de SQLitePrimeiros passos
- O que é SQLiteSQLite é um banco de dados SQL sem servidor que roda dentro da sua aplicação e guarda tudo em um único arquivo. Veja o que ele é de verdade, como se diferencia de um servidor de banco e quando faz sentido usar.
- SQLite vs MySQLEntenda na prática as diferenças entre SQLite e MySQL: arquitetura, concorrência, tipos de dados e em que tipo de projeto cada um se sai melhor.
- SQLite vs PostgresAs diferenças reais entre SQLite e PostgreSQL: arquitetura, concorrência, tipos e em que tipo de projeto cada um se sai melhor.
- Quando usar SQLiteUm guia direto para entender quando o SQLite é a escolha certa — e quando vale mais a pena ir de Postgres ou MySQL.
- Instalar SQLitePasso a passo para instalar o SQLite no Windows, macOS e Linux: baixar a ferramenta de linha de comando, configurar o PATH e conferir se está tudo funcionando.
- SQLite CLIAprenda a usar o shell sqlite3 na linha de comando: abrir bancos, rodar queries, dot commands e importar ou exportar dados sem sair do terminal.
- Ferramentas GUIUm passeio prático pelas ferramentas gráficas para abrir, navegar e editar arquivos SQLite — DB Browser for SQLite, SQLiteStudio e visualizadores online.
- Criar Banco de DadosComo criar um banco SQLite na prática: o modelo baseado em arquivo, o comando `sqlite3` e por que não existe `CREATE DATABASE` por aqui.
- Banco In-MemoryComo funciona o banco de dados em memória do SQLite, quando vale a pena usar `:memory:` e o que muda em relação a um banco salvo em arquivo.
Tabelas e tipos
- CREATE TABLEComo criar tabelas no SQLite: definição de colunas, constraints, IF NOT EXISTS, tabelas temporárias e CREATE TABLE AS SELECT na prática.
- Tipos de DadosComo o SQLite armazena valores na prática: as cinco storage classes, por que a tipagem é dinâmica e as pegadinhas que assustam quem vem do Postgres ou MySQL.
- Type AffinityEntenda como funciona o type affinity do SQLite: as cinco afinidades, as regras que escolhem uma a partir da declaração da coluna e por que uma coluna INTEGER pode guardar uma string.
- Tabelas STRICTVeja como as tabelas STRICT do SQLite desligam o armazenamento flexível, rejeitam valores de tipo errado e finalmente entregam a checagem de tipos que você esperava desde o começo.
- Chaves PrimáriasComo funcionam as chaves primárias no SQLite: o famoso INTEGER PRIMARY KEY, chaves compostas, AUTOINCREMENT e as armadilhas que pegam quem está começando.
- ROWIDEntenda o que é o ROWID no SQLite, quando INTEGER PRIMARY KEY vira apelido dele e por que existem tabelas WITHOUT ROWID.
- NOT NULL e DEFAULTComo NOT NULL e DEFAULT funcionam no SQLite: o que cada um realmente garante, o truque do CURRENT_TIMESTAMP e as pegadinhas ao adicionar essas restrições em tabelas que já existem.
- CHECK ConstraintsAprenda a usar CHECK constraints no SQLite para validar valores em colunas — checagens simples, em múltiplas colunas, constraints nomeadas e os detalhes que pegam todo mundo.
- UNIQUE no SQLiteComo a constraint UNIQUE funciona no SQLite: em colunas únicas, em chaves compostas, o detalhe do NULL e o que fazer quando ela falha.
- DROP e ALTER TABLEComo apagar, renomear e alterar tabelas no SQLite — o que o ALTER TABLE consegue fazer, o que ele não faz e o truque do rebuild para os casos que não dá.
Inserir e modificar dados
- INSERTComo o INSERT funciona no SQLite na prática: linha única, inserts em lote, INSERT...SELECT, valores padrão e os modificadores OR IGNORE e OR REPLACE.
- UPDATEComo alterar linhas existentes no SQLite: sintaxe do UPDATE, a cláusula WHERE que evita estragos, atualização de várias colunas e UPDATE ... FROM entre tabelas.
- DELETEVeja como o DELETE funciona no SQLite: escrever um WHERE seguro, apagar todas as linhas, fazer cascade em tabelas relacionadas e recuperar o que foi apagado com RETURNING.
- UPSERTComo funciona o UPSERT no SQLite: a cláusula ON CONFLICT, a tabela excluded, DO NOTHING vs DO UPDATE e por que ele é melhor que INSERT OR REPLACE.
- Cláusula RETURNINGComo usar a cláusula RETURNING no SQLite para recuperar as linhas afetadas por um INSERT, UPDATE ou DELETE sem precisar de uma segunda consulta.
- Importar CSVAprenda a importar arquivos CSV no SQLite usando o comando .import — com cabeçalho, tabela existente, separadores diferentes e os erros mais comuns.
- Exportar DadosComo tirar dados do SQLite — CSV com cabeçalho, JSON, dump SQL completo e backup de tabela única usando o shell sqlite3 na linha de comando.
Consultar dados
- SELECT no SQLiteComo o comando SELECT funciona no SQLite — escolhendo colunas, calculando expressões, criando aliases com AS e o modelo mental por trás de toda consulta SQL.
- Cláusula WHEREEntenda como a cláusula WHERE filtra linhas no SQLite: operadores de comparação, AND/OR, LIKE, IN, BETWEEN e a famosa pegadinha do NULL.
- Operadores e NULLEntenda por que `=` e `<>` não funcionam com NULL no SQLite e aprenda a usar IS NULL, IS NOT NULL, COALESCE e IFNULL do jeito certo.
- ORDER BYEntenda como o ORDER BY funciona no SQLite: ordenação crescente e decrescente, desempate por múltiplas colunas, posição dos NULLs e ordenação sem diferenciar maiúsculas.
- LIMIT e OFFSETEntenda como LIMIT e OFFSET funcionam no SQLite: limitar linhas, pular registros, paginar com segurança e evitar o gargalo de performance em tabelas grandes.
- DISTINCTComo o SELECT DISTINCT funciona no SQLite — em uma coluna, em várias colunas, com NULL, no COUNT(DISTINCT) e quando é melhor usar GROUP BY.
- Expressão CASEComo o CASE funciona no SQLite — formas simples e pesquisada, uso em SELECT, ORDER BY e WHERE, e quando vale mais usar IIF.
Funções e agregados
- Funções de StringGuia prático das funções de string do SQLite: concatenação, SUBSTR, INSTR, REPLACE, TRIM e os truques para limpar e manipular texto direto nas suas queries.
- Funções NuméricasComo fazer contas no SQLite — ROUND, ABS, CEIL, FLOOR, MOD, POWER, SQRT e RANDOM — e aquela pegadinha da divisão inteira que pega todo mundo pelo menos uma vez.
- Datas e HorasComo o SQLite armazena e manipula datas — as cinco funções de data, formatos, modificadores e as escolhas de armazenamento que mantêm suas queries rápidas.
- Funções de AgregaçãoEntenda como as funções de agregação do SQLite reduzem várias linhas a um único valor — COUNT, SUM, AVG, MIN, MAX, GROUP_CONCAT, além de DISTINCT, FILTER e o comportamento com NULL.
- GROUP BY e HAVINGEntenda como o GROUP BY agrupa linhas em SQLite e como o HAVING filtra esses grupos depois da agregação — com a diferença entre WHERE e HAVING explicada na prática.
Relacionamentos e joins
- Chaves EstrangeirasEntenda como as chaves estrangeiras funcionam no SQLite: como declarar com REFERENCES, ativar a verificação via PRAGMA e escolher o ON DELETE certo.
- INNER JOINEntenda como o INNER JOIN funciona no SQLite: o modelo mental, a cláusula ON, junção de três tabelas e o atalho USING.
- LEFT JOINEntenda como o LEFT JOIN funciona no SQLite: linhas sem correspondência, valores NULL, filtros corretos com WHERE e ON, e junções com várias tabelas.
- Self JoinEntenda como funciona o SELF JOIN no SQLite: pareando linhas da mesma tabela com aliases, com exemplos práticos de funcionário/gerente e dados hierárquicos.
- SubqueriesAprenda a aninhar um SELECT dentro de outro no SQLite: subqueries escalares, IN, EXISTS, tabelas derivadas, subqueries correlacionadas e quando vale mais usar JOIN.
- CTEsEntenda como funcionam as Common Table Expressions no SQLite — usando WITH para nomear subqueries, encadear vários CTEs e escrever consultas que se leem de cima para baixo.
- CTEs RecursivasComo funcionam as CTEs recursivas no SQLite: a estrutura âncora/recursiva, percorrer árvores pai-filho, gerar séries numéricas e evitar loops infinitos.
Índices e performance
- ÍndicesComo os índices funcionam no SQLite, quando eles ajudam de verdade, quando atrapalham e como saber se o planner está usando o índice que você criou.
- Índice CompostoComo funcionam os índices de múltiplas colunas no SQLite, por que a ordem das colunas faz toda diferença e quando vale a pena criar um índice composto.
- Índices ParciaisVeja como funcionam os índices parciais no SQLite — indexar apenas as linhas que você realmente consulta — e os padrões (soft delete, unicidade parcial, subconjuntos quentes) onde eles realmente compensam.
- EXPLAIN QUERY PLANAprenda a usar o EXPLAIN QUERY PLAN no SQLite para descobrir se sua consulta usa índice, entender SCAN e SEARCH e identificar gargalos em joins.
- VACUUM e ANALYZEComo `VACUUM` e `ANALYZE` mantêm um banco SQLite rápido e enxuto — o que cada um faz de fato, quando rodar e as variantes que vale a pena conhecer.
Recursos avançados
- TransaçõesComo funcionam as transações no SQLite: BEGIN, COMMIT, ROLLBACK, modo autocommit e a diferença entre DEFERRED, IMMEDIATE e EXCLUSIVE na hora de travar o banco.
- SavepointsComo funcionam os savepoints no SQLite: marcadores nomeados dentro de uma transação que você pode desfazer sem perder tudo o que foi feito antes.
- ViewsComo funcionam as views no SQLite: salvando consultas como tabelas virtuais, quando criar views temporárias e por que elas são read-only por padrão.
- TriggersComo funcionam os triggers no SQLite: BEFORE, AFTER, INSTEAD OF em views, as referências OLD e NEW, e quando faz sentido usá-los.
- JSON no SQLiteComo o SQLite armazena e consulta JSON: extrair campos, atualizar valores, percorrer arrays com json_each e indexar caminhos JSON para ganhar performance.
- Busca Full-TextComo implementar busca full-text no SQLite com FTS5: criação de tabelas virtuais, operador MATCH, ranqueamento BM25 e como manter o índice sincronizado com seus dados.
- Window FunctionsEntenda como as window functions funcionam no SQLite: OVER, PARTITION BY, ranking, LAG/LEAD e cláusulas de frame para totais acumulados.
- Generated ColumnsComo funcionam as generated columns no SQLite: como declarar, quando usar VIRTUAL ou STORED e como indexar para acelerar suas consultas.
- ATTACH DATABASEVeja como o ATTACH DATABASE permite abrir vários arquivos SQLite na mesma conexão, consultar entre eles usando prefixos de schema e desconectar quando terminar.
Segurança e integração com aplicações
- Prepared StatementsEntenda o que são prepared statements no SQLite, por que eles existem e o ciclo prepare/bind/step/finalize que todo driver usa por baixo dos panos.
- Bind de ParâmetrosComo funciona o bind de parâmetros no SQLite — placeholders posicionais, parâmetros nomeados e as regras para passar valores com segurança a partir da sua aplicação.
- SQL InjectionPor que concatenar strings em SQL é furada, como um ataque de SQL injection funciona na prática e como queries parametrizadas no SQLite resolvem o problema de vez.
- Conexão à AplicaçãoComo aplicações abrem e usam um banco SQLite — caminho do arquivo, strings de conexão, drivers em cada linguagem e os ajustes que vale a pena acertar logo no início.
- MigrationsAprenda a evoluir o schema do SQLite com segurança usando PRAGMA user_version, scripts de migration ordenados e transações para manter tudo reversível.
- Modo WALComo o write-ahead logging do SQLite muda o jogo da concorrência — leitores e escritores deixam de se bloquear, e o que os arquivos -wal e -shm realmente fazem.
Produção e operações
- Backup e RestoreComo fazer backup e restaurar um banco SQLite com segurança — comando .backup, VACUUM INTO, API de backup online e por que copiar o arquivo direto é furada.
- PRAGMA no SQLiteOs PRAGMAs que realmente fazem diferença — journal_mode, synchronous, foreign_keys, busy_timeout e cache_size — com os valores certos para usar em produção.
- Erros ComunsOs erros do SQLite que você realmente vai encontrar em produção — database is locked, readonly database, disk image malformed e falhas de constraint — e como resolver cada um.
