O SQLite é um dos sistemas de gerenciamento de banco de dados mais utilizados no mundo da programação. Sua simplicidade, portabilidade e无需 configuração o tornam perfeito para aplicações pequenas e médias, protótipos e até mesmo para aprendizado de SQL. Neste guia completo, você aprenderá como utilizar o SQLite com Python para criar, manipular e consultar bancos de dados de forma eficiente.

A biblioteca sqlite3 já vem incluída na biblioteca padrão do Python, o que significa que você não precisa instalar nada além do próprio Python para começar a trabalhar com bancos de dados SQLite. Isso torna o SQLite a escolha ideal para quem está começando no mundo dos bancos de dados relacionais.

🔧 O que é SQLite e por que usá-lo com Python?

O SQLite é um banco de dados relacional embedded, o que significa que ele não requer um servidor separado para funcionar. Ao contrário de bancos de dados como MySQL, PostgreSQL ou SQL Server, o SQLite armazena todo o banco de dados em um único arquivo no seu sistema de arquivos. Isso traz várias vantagens importantes:

Primeiramente, a simplicidade de configuração é um dos maiores trunfos do SQLite. Não há necessidade de instalar servidores, configurar usuários ou gerenciar permissões complexas. Você simplesmente cria um arquivo e começa a usar. Além disso, o SQLite é extremamente leve - a biblioteca completa tem apenas alguns megabytes, tornando-o ideal para aplicações móveis, programas desktop e até mesmo navegadores web.

Outra vantagem significativa é a portabilidade. Um arquivo de banco de dados SQLite pode ser movido entre diferentes sistemas operacionais sem qualquer modificação. Você pode criar o banco no Windows, movê-lo para Linux ou Mac e continuar trabalhando normalmente. Por fim, o SQLite oferece velocidade impressionante para operações de leitura e escrita, frequentemente superando bancos de dados cliente-servidor em cenários de uso local.

Para aprender mais sobre os fundamentos do SQLite, recomenda-se consultar a documentação oficial do SQLite.

📦 Conectando ao Banco de Dados SQLite

O primeiro passo para trabalhar com SQLite em Python é estabelecer uma conexão com o banco de dados. Para isso, usamos a biblioteca padrão sqlite3. Vamos ver como fazer isso de diferentes formas:

import sqlite3

Forma mais simples de conexão


conexao = sqlite3.connect('meu_banco.db')


Para bancos de dados em memória (útil para testes)


conexao_memoria = sqlite3.connect(':memory:')


Fechando a conexão quando não precisar mais


conexao.close()

Quando você chama sqlite3.connect(), o Python cria automaticamente o arquivo do banco de dados se ele não existir. Se o arquivo já existir, ele será aberto normalmente. É importante sempre fechar a conexão quando terminar de usar o banco de dados para evitar vazamentos de recursos e possíveis corrupções nos dados.

Uma prática muito importante é sempre usar o gerenciador de contexto (with) para garantir que as conexões sejam fechadas corretamente, mesmo se ocorrerem erros durante a execução:

import sqlite3

Usando gerenciador de contexto (recomendado)


with sqlite3.connect('meu_banco.db') as conexao:


Seu código aqui


pass


A conexão é fechada automaticamente ao sair do bloco

Para entender melhor como gerenciar conexões de banco de dados em Python, você pode consultar a documentação oficial do módulo sqlite3.

📋 Criando Tabelas e Estrutura do Banco de Dados

Agora que você sabe como se conectar ao banco de dados, o próximo passo é criar as tabelas que armazenarão seus dados. As tabelas são a estrutura fundamental de qualquer banco de dados relacional e definem como seus dados serão organizados.

Para criar tabelas, usamos o comando SQL CREATE TABLE. Vamos criar uma tabela de exemplo para armazenar informações de usuários:

import sqlite3

with sqlite3.connect('usuarios.db') as conexao:
cursor = conexao.cursor()


cursor.execute("""
    CREATE TABLE IF NOT EXISTS usuarios (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        nome TEXT NOT NULL,
        email TEXT UNIQUE NOT NULL,
        idade INTEGER,
        data_cadastro TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    )
""")

print("Tabela criada com sucesso!")</code></pre>


Neste exemplo, criamos uma tabela com os seguintes campos: id como chave primária com autoincremento, nome como texto obrigatório, email como texto único e obrigatório, idade como número inteiro e data_cadastro que usa o valor padrão do SQLite com a data e hora atual.


Vamos adicionar mais uma tabela para exemplificar um relacionamento:


cursor.execute("""
    CREATE TABLE IF NOT EXISTS posts (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        usuario_id INTEGER NOT NULL,
        titulo TEXT NOT NULL,
        conteudo TEXT,
        data_publicacao TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
        FOREIGN KEY (usuario_id) REFERENCES usuarios (id)
    )
""")


Esta tabela posts tem uma chave estrangeira (FOREIGN KEY) que relaciona cada post a um usuário da tabela usuarios. Isso demonstra como criar relacionamentos entre tabelas em um banco de dados relacional.


A W3Schools oferece um excelente tutorial sobre SQL para quem está começando e deseja aprender mais sobre comandos SQL.


➕ Inserindo Dados (Operação CREATE)


Com as tabelas criadas, o próximo passo é aprender a inserir dados nelas. No SQLite com Python, usamos o comando SQL INSERT INTO para adicionar novos registros. Vamos ver diferentes formas de fazer isso:


import sqlite3

with sqlite3.connect('usuarios.db') as conexao:
cursor = conexao.cursor()


#Inserção simples de um registro
cursor.execute("""
    INSERT INTO usuarios (nome, email, idade)
    VALUES ('João Silva', '[email protected]', 28)
""")

#Inserção com parâmetros (mais seguro contra SQL injection)
nome = 'Maria Santos'
email = '[email protected]'
idade = 32

cursor.execute("""
    INSERT INTO usuarios (nome, email, idade)
    VALUES (?, ?, ?)
""", (nome, email, idade))

#Inserção múltipla de uma vez
usuarios = [
    ('Pedro Oliveira', '[email protected]', 25),
    ('Ana Costa', '[email protected]', 29),
    ('Carlos Souza', '[email protected]', 35)
]

cursor.executemany("""
    INSERT INTO usuarios (nome, email, idade)
    VALUES (?, ?, ?)
""", usuarios)

#Importante: confirmar as alterações
conexao.commit()

print("Dados inseridos com sucesso!")</code></pre>


É fundamental entender o conceito de commit. No SQLite, as operações de inserção, atualização e exclusão precisam ser confirmadas com conexao.commit() para que as alterações sejam salvas permanentemente no banco de dados. Se você não chamar commit(), as alterações serão perdidas ao fechar a conexão.


Uma observação muito importante é sempre usar parâmetros parametrizados (como ? ou :nome) em vez de interpolar strings diretamente nas suas queries. Isso previne ataques de SQL Injection, uma das vulnerabilidades mais comuns em aplicações que usam bancos de dados.


Para mais informações sobre segurança em bancos de dados, consulte a OWASP SQL Injection.


📖 Consultando Dados (Operação READ)


A recuperação de dados é uma das operações mais importantes em qualquer banco de dados. O SQLite oferece várias formas de consultar dados usando o comando SELECT. Vamos explorar as principais técnicas:


import sqlite3

with sqlite3.connect('usuarios.db') as conexao:
cursor = conexao.cursor()


#Consulta simples - buscar todos os registros
cursor.execute("SELECT * FROM usuarios")
resultados = cursor.fetchall()

for usuario in resultados:
    print(usuario)

print("\n" + "="*50 + "\n")

#Consulta com filtro WHERE
cursor.execute("SELECT * FROM usuarios WHERE idade > 30")
maiores = cursor.fetchall()

print("Usuários maiores de 30 anos:")
for usuario in maiores:
    print(f"  {usuario[1]} - {usuario[2]}")

print("\n" + "="*50 + "\n")

#Consulta retornando apenas algumas colunas
cursor.execute("SELECT nome, email FROM usuarios")
print("Nomes e emails:")
for usuario in cursor.fetchall():
    print(f"  {usuario[0]}: {usuario[1]}")

print("\n" + "="*50 + "\n")

#Usando LIMIT e OFFSET para paginação
cursor.execute("SELECT * FROM usuarios LIMIT 2 OFFSET 1")
print("Registros 2 e 3:")
for usuario in cursor.fetchall():
    print(f"  ID: {usuario[0]}, Nome: {usuario[1]}")</code></pre>


O método fetchall() retorna todos os resultados da consulta como uma lista de tuplas. Para grandes volumes de dados, você pode usar fetchone() para obter um registro por vez, ou fetchmany(tamanho) para obter uma quantidade específica de registros.


Vamos ver agora como fazer consultas mais complexas com ordenação e condições:


#Ordenando resultados (ORDER BY)
cursor.execute("SELECT * FROM usuarios ORDER BY nome ASC")
for usuario in cursor.fetchall():
    print(usuario[1])

print("\n")


Usando LIKE para busca parcial


cursor.execute("SELECT * FROM usuarios WHERE nome LIKE '%Silva%'")
print("Busca por 'Silva':")
for usuario in cursor.fetchall():
print(f"  {usuario[1]}")


print("\n")


Usando BETWEEN para intervalos


cursor.execute("SELECT * FROM usuarios WHERE idade BETWEEN 25 AND 35")
print("Usuários entre 25 e 35 anos:")
for usuario in cursor.fetchall():
print(f"  {usuario[1]}: {usuario[3]} anos")


print("\n")


Usando IN para múltiplos valores


cursor.execute("SELECT * FROM usuarios WHERE id IN (1, 3, 5)")
print("Usuários com ID 1, 3 ou 5:")
for usuario in cursor.fetchall():
print(f"  {usuario[0]}: {usuario[1]}")


Para aprender mais sobre consultas SQL avançadas, o site GeeksforGeeks oferece tutoriais completos e detalhados.


✏️ Atualizando Dados (Operação UPDATE)


A atualização de dados existentes é outra operação fundamental. O comando UPDATE do SQL permite modificar registros já existentes no banco de dados. É crucial usar a cláusula WHERE para especificar quais registros devem ser atualizados, caso contrário você pode acabar modificando todos os registros da tabela acidentalmente.


import sqlite3

with sqlite3.connect('usuarios.db') as conexao:
cursor = conexao.cursor()


#Atualização simples
cursor.execute("""
    UPDATE usuarios
    SET idade = 30
    WHERE id = 1
""")

#Atualização com múltiplos campos
cursor.execute("""
    UPDATE usuarios
    SET nome = 'João Silva Santos', idade = 29
    WHERE email = '[email protected]'
""")

#Atualização com base em cálculos
cursor.execute("""
    UPDATE usuarios
    SET idade = idade + 1
    WHERE idade IS NOT NULL
""")

conexao.commit()

print("Dados atualizados com sucesso!")

#Verificando as alterações
cursor.execute("SELECT * FROM usuarios WHERE id = 1")
usuario = cursor.fetchone()
print(f"Usuário atualizado: {usuario}")</code></pre>


Sempre que possível, use a chave primária (id) ou campos únicos na cláusula WHERE para garantir que você está atualizando exatamente o registro desejado. Isso evita comportamentos inesperados e garante a integridade dos seus dados.


🗑️ Excluindo Dados (Operação DELETE)


A exclusão de dados deve ser feita com muito cuidado. O comando DELETE remove registros permanentemente do banco de dados, e uma operação mal executada pode resultar na perda de dados importantes. Semelhante ao UPDATE, a cláusula WHERE é essencial para especificar quais registros serão excluídos.


#Exclusão simples - deletar um registro específico
cursor.execute("DELETE FROM usuarios WHERE id = 5")

Exclusão com base em condição


cursor.execute("DELETE FROM usuarios WHERE idade < 18")


Exclusão de todos os registros (cuidado!)


cursor.execute("DELETE FROM usuarios")  # Isso deleta tudo!


conexao.commit()


print("Dados excluídos com sucesso!")


Uma prática de segurança muito importante é sempre fazer um SELECT antes de um DELETE para confirmar quais registros serão afetados. Isso ajuda a evitar exclusões acidentais de dados importantes.


Para operações de DELETE em larga escala, considere usar transactions ( transactions) para garantir a integridade dos dados. Você pode aprender mais sobre isso na documentação de transactions do SQLite.


🔄 Transações e Controle de Dados


As transações são um conceito fundamental em bancos de dados relacionais que permitem agrupar múltiplas operações em uma única unidade lógica de trabalho. O SQLite suporta transações ACID (Atomicidade, Consistência, Isolamento, Durabilidade), garantindo que suas operações sejam executadas de forma segura.


import sqlite3
from sqlite3 import Error

def criar_conexao(db_file):
try:
conexao = sqlite3.connect(db_file)
return conexao
except Error as e:
print(f"Erro ao conectar: {e}")
return None


def executar_transacao(conexao):
try:
cursor = conexao.cursor()


    #Iniciar transação explicitamente (opcional no SQLite)
    # conexao.isolation_level = None  #Modo autocommit

    #Inserir novo usuário
    cursor.execute("""
        INSERT INTO usuarios (nome, email, idade)
        VALUES ('Novo Usuário', '[email protected]', 25)
    """)

    #Inserir posts para esse usuário
    usuario_id = cursor.lastrowid
    cursor.executemany("""
        INSERT INTO posts (usuario_id, titulo, conteudo)
        VALUES (?, ?, ?)
    """, [
        (usuario_id, 'Primeiro Post', 'Conteúdo do primeiro post'),
        (usuario_id, 'Segundo Post', 'Conteúdo do segundo post')
    ])

    #Confirmar a transação
    conexao.commit()
    print("Transação concluída com sucesso!")

except Error as e:
    #Em caso de erro, desfazer todas as operações
    conexao.rollback()
    print(f"Erro na transação: {e}")


Usando savepoint para transações parciais


with sqlite3.connect('usuarios.db') as conexao:
cursor = conexao.cursor()


cursor.execute("SAVEPOINT inicio")

try:
    cursor.execute("DELETE FROM usuarios WHERE id = 1")
    #Se algo der errado aqui, podemos voltar ao savepoint
    # cursor.execute("ROLLBACK TO SAVEPOINT inicio")
    conexao.commit()
except Error as e:
    cursor.execute("ROLLBACK TO SAVEPOINT inicio")
    conexao.commit()</code></pre>


O uso de commit() confirma todas as operações dentro da transação, enquanto rollback() desfaz todas as alterações se algo der errado. O SQLite também suporta SAVEPOINT para criar pontos de recuperação dentro de uma transação maior.


📊 Funções de Agregação e Group By


O SQLite oferece várias funções de agregação que permitem realizar cálculos em conjuntos de dados. Essas funções são extremamente úteis para análises e relatórios. Vamos explorar as principais:


#Contagem de registros
cursor.execute("SELECT COUNT(*) FROM usuarios")
total = cursor.fetchone()[0]
print(f"Total de usuários: {total}")

Soma de valores


cursor.execute("SELECT SUM(idade) FROM usuarios")
soma_idades = cursor.fetchone()[0]
print(f"Soma das idades: {soma_idades}")


Média


cursor.execute("SELECT AVG(idade) FROM usuarios")
media_idade = cursor.fetchone()[0]
print(f"Média de idade: {media_idade:.2f}")


Menor e maior valor


cursor.execute("SELECT MIN(idade), MAX(idade) FROM usuarios")
min_max = cursor.fetchone()
print(f"Menor idade: {min_max[0]}, Maior idade: {min_max[1]}")


Agrupando resultados com GROUP BY


cursor.execute("""
SELECT idade, COUNT(*) as total
FROM usuarios
WHERE idade IS NOT NULL
GROUP BY idade
ORDER BY total DESC
""")


print("\nUsuários por idade:")
for row in cursor.fetchall():
print(f"  Idade {row[0]}: {row[1]} usuário(s)")


Filtrando grupos com HAVING


cursor.execute("""
SELECT idade, COUNT() as total
FROM usuarios
GROUP BY idade
HAVING COUNT() > 1
""")


print("\nIdades com mais de 1 usuário:")
for row in cursor.fetchall():
print(f"  Idade {row[0]}: {row[1]} usuários")


As funções GROUP BY e HAVING são ferramentas poderosas para análise de dados. Enquanto o WHERE filtra linhas antes da agregação, o HAVING filtra grupos após a agregação. Isso permite criar relatórios complexos e resumidos.


Para mais detalhes sobre funções de agregação, visite a documentação oficial do SQLite sobre funções de agregação.


🔗 Consultas com JOIN


Uma das funcionalidades mais poderosas dos bancos de dados relacionais é a capacidade de combinar dados de múltiplas tabelas usando JOIN. Vamos ver como fazer isso com SQLite e Python:


#INNER JOIN - retorna apenas registros com correspondência em ambas as tabelas
cursor.execute("""
    SELECT 
        u.nome,
        u.email,
        p.titulo,
        p.data_publicacao
    FROM usuarios u
    INNER JOIN posts p ON u.id = p.usuario_id
""")

print("Posts com informações do autor:")
for row in cursor.fetchall():
print(f"  {row[0]} ({row[1]}): {row[2]} - {row[3]}")


LEFT JOIN - retorna todos os registros da tabela esquerda


cursor.execute("""
SELECT 
u.nome,
COUNT(p.id) as total_posts
FROM usuarios u
LEFT JOIN posts p ON u.id = p.usuario_id
GROUP BY u.id, u.nome
""")


print("\nQuantidade de posts por usuário:")
for row in cursor.fetchall():
print(f"  {row[0]}: {row[1]} post(s)")


JOIN com múltiplas condições


cursor.execute("""
SELECT 
u.nome,
p.titulo
FROM usuarios u
JOIN posts p ON u.id = p.usuario_id
WHERE u.idade > 25
ORDER BY p.data_publicacao DESC
""")


print("\nPosts de usuários maiores de 25 anos:")
for row in cursor.fetchall():
print(f"  {row[0]}: {row[1]}")


O INNER JOIN retorna apenas registros que existem em ambas as tabelas relacionadas. O LEFT JOIN retorna todos os registros da tabela esquerda, mesmo que não tenham correspondência na tabela direita. Escolher o tipo certo de JOIN depende da sua necessidade específica de negócio.


Para aprofundar seus conhecimentos em JOINs, o tutorial da DigitalOcean sobre JOINs é uma excelente fonte.


⚠️ Tratamento de Erros e Boas Práticas


Ao trabalhar com bancos de dados, é essencial implementar um tratamento de erros robusto para garantir a integridade dos dados e a estabilidade da aplicação. Vamos ver como fazer isso corretamente:


import sqlite3
from sqlite3 import Error

def criar_tabela_com_erros(conexao, sql):
try:
cursor = conexao.cursor()
cursor.execute(sql)
print("Tabela criada com sucesso!")
except Error as e:
print(f"Erro ao criar tabela: {e}")


def inserir_usuario_seguro(conexao, nome, email, idade):
try:
cursor = conexao.cursor()
cursor.execute("""
INSERT INTO usuarios (nome, email, idade)
VALUES (?, ?, ?)
""", (nome, email, idade))
conexao.commit()
return cursor.lastrowid
except Error as e:
conexao.rollback()
print(f"Erro ao inserir usuário: {e}")
return None


Tratamento com verificação de dados


def inserir_usuario_validado(conexao, nome, email, idade):


Validação de dados antes da inserção


if not nome or not email:
    print("Erro: Nome e email são obrigatórios!")
    return None

if idade is not None and (idade < 0 or idade > 150):
    print("Erro: Idade inválida!")
    return None

return inserir_usuario_seguro(conexao, nome, email, idade)


Exemplo de uso com tratamento de erros


try:
with sqlite3.connect('usuarios.db') as conexao:
usuario_id = inserir_usuario_validado(conexao, "Teste", "[email protected]", 25)
if usuario_id:
print(f"Usuário inserido com ID: {usuario_id}")
except Error as e:
print(f"Erro de banco de dados: {e}")


Sempre use tratamento de erros para capturar e tratar exceções que podem ocorrer durante operações de banco de dados. Use try/except para capturar erros específicos e implementar rollback() quando uma operação falhar para evitar dados parcialmente inseridos ou corrompidos.


🛠️ Criando Classes de Acesso a Dados (DAO)


Para aplicações maiores, é uma boa prática criar uma camada de abstração para operações de banco de dados. Isso facilita a manutenção, testing e reutilização de código. Vamos criar uma classe DAO simples:


import sqlite3
from sqlite3 import Error
from typing import List, Optional, Tuple

class UsuarioDAO:
def init(self, db_path: str):
self.db_path = db_path


def _conectar(self) -> sqlite3.Connection:
    return sqlite3.connect(self.db_path)

def criar_tabela(self):
    with self._conectar() as conexao:
        cursor = conexao.cursor()
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS usuarios (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                nome TEXT NOT NULL,
                email TEXT UNIQUE NOT NULL,
                idade INTEGER
            )
        """)
        conexao.commit()

def inserir(self, nome: str, email: str, idade: Optional[int] = None) -> Optional[int]:
    try:
        with self._conectar() as conexao:
            cursor = conexao.cursor()
            cursor.execute("""
                INSERT INTO usuarios (nome, email, idade)
                VALUES (?, ?, ?)
            """, (nome, email, idade))
            conexao.commit()
            return cursor.lastrowid
    except Error as e:
        print(f"Erro ao inserir: {e}")
        return None

def buscar_por_id(self, id: int) -> Optional[Tuple]:
    with self._conectar() as conexao:
        cursor = conexao.cursor()
        cursor.execute("SELECT * FROM usuarios WHERE id = ?", (id,))
        return cursor.fetchone()

def buscar_todos(self) -> List[Tuple]:
    with self._conectar() as conexao:
        cursor = conexao.cursor()
        cursor.execute("SELECT * FROM usuarios ORDER BY nome")
        return cursor.fetchall()

def atualizar(self, id: int, nome: str, email: str, idade: Optional[int]) -> bool:
    try:
        with self._conectar() as conexao:
            cursor = conexao.cursor()
            cursor.execute("""
                UPDATE usuarios
                SET nome = ?, email = ?, idade = ?
                WHERE id = ?
            """, (nome, email, idade, id))
            conexao.commit()
            return cursor.rowcount > 0
    except Error as e:
        print(f"Erro ao atualizar: {e}")
        return False

def excluir(self, id: int) -> bool:
    try:
        with self._conectar() as conexao:
            cursor = conexao.cursor()
            cursor.execute("DELETE FROM usuarios WHERE id = ?", (id,))
            conexao.commit()
            return cursor.rowcount > 0
    except Error as e:
        print(f"Erro ao excluir: {e}")
        return False


Exemplo de uso


dao = UsuarioDAO('usuarios.db')
dao.criar_tabela()


Inserir


id = dao.inserir('João', '[email protected]', 28)
print(f"Inserido usuário ID: {id}")


Buscar todos


usuarios = dao.buscar_todos()
for u in usuarios:
print(f"ID: {u[0]}, Nome: {u[1]}, Email: {u[2]}, Idade: {u[3]}")


Atualizar


dao.atualizar(id, 'João Silva', '[email protected]', 29)


Excluir


dao.excluir(id)


Esta estrutura de DAO (Data Access Object) é muito utilizada em aplicações Python para separar a lógica de acesso a dados da lógica de negócio. Isso torna o código mais modular, testável e fácil de manter.


🚀 Conclusão e Próximos Passos


Neste guia completo, você aprendeu desde os conceitos básicos do SQLite até técnicas mais avançadas como transações, JOINs e criação de classes de acesso a dados. O SQLite com Python é uma combinação poderosa para desenvolvimento de aplicações que precisam de um banco de dados leve e eficiente.


Agora que você domina o básico, recomenda-se explorar tópicos avançados como: migrações de banco de dados usando ferramentas como Alembic, ORMs como SQLAlchemy para abstrair completamente o SQL, e consultasassíncronas com libraries como aiosqlite para aplicações que precisam de alto desempenho.


Lembre-se sempre de seguir boas práticas de segurança, como usar parâmetros parametrizados para prevenir SQL injection, fazer backup regular dos seus bancos de dados e implementar tratamento de erros adequado em todas as operações de banco de dados.


Para continuar aprendendo, você pode explorar outros artigos do nosso blog sobre Python, como Python Requests: Guia Completo de Requisições HTTP que ensina como fazer requisições HTTP, ou Python DateTime: Manipulação de Datas para trabalhar com datas e horários.