Banco de Dados Relacionais com Python e SQLite

Neste artigo, vamos abordar os conceitos fundamentais de bancos de dados relacionais e como podemos interagir com eles usando a Python DB API. Este conteúdo é essencial para qualquer programador que deseja trabalhar com bancos de dados, principalmente em aplicações desenvolvidas em Python.

1. Introdução aos Bancos de Dados

O que é um Banco de Dados?

Os bancos de dados são coleções organizadas de dados, geralmente armazenados e acessados eletronicamente a partir de um sistema de computador. Eles são essenciais para armazenar, gerenciar e recuperar informações de forma eficiente e segura.

Tipos de Bancos de Dados

Existem vários tipos de bancos de dados, incluindo:

• Relacionais: Organizam os dados em tabelas.
• Não Relacionais: Incluem bancos de dados de documentos, chave-valor, colunares e gráficos.
• Orientados a Objetos: Armazenam dados na forma de objetos.

O tipo mais comum é o banco de dados relacional, que utiliza tabelas para organizar os dados.

O Papel do SGBD

Os Sistemas de Gerenciamento de Banco de Dados (SGBD) são softwares que interagem com o usuário, outras aplicações e o próprio banco de dados para capturar e analisar os dados. Exemplos populares incluem MySQL, PostgreSQL, SQLite, Oracle Database, Microsoft SQL Server e MariaDB.

2. Introdução aos Bancos de Dados Relacionais

Estrutura das Tabelas

Um banco de dados relacional organiza os dados em tabelas, cada uma composta de linhas (registros) e colunas (campos). Por exemplo, uma tabela 'Clientes' pode ter os campos 'ID', 'nome', 'email' e 'telefone'.

Chaves Primárias e Estrangeiras

• Chave Primária: Uma coluna (ou conjunto de colunas) cujo valor é único para cada registro, garantindo a identificação única dos registros.
• Chave Estrangeira: Um campo em uma tabela que corresponde à chave primária de outra tabela, estabelecendo relações entre as tabelas.

Relacionamentos entre Tabelas

Os bancos de dados relacionais permitem criar relações 'um para um', 'um para muitos' e 'muitos para muitos', facilitando consultas complexas que unem dados de várias tabelas.

3. SQL (Structured Query Language)

O SQL é a linguagem usada para interagir com bancos de dados relacionais. Com SQL, podemos:

• Criar tabelas
• Inserir, atualizar e deletar registros
• Executar consultas para buscar dados

4. Python DB API

Conectando-se a um Banco de Dados

A primeira etapa para trabalhar com um banco de dados em Python é estabelecer uma conexão usando a Python DB API. Por exemplo:

import sqlite3
conn = sqlite3.connect('example.db')

Inserindo Registros

Para inserir registros, usamos a operação INSERT do SQL. Exemplo:

cursor = conn.cursor()
cursor.execute("INSERT INTO Clientes (nome, email) VALUES ('João', 'joao@example.com')")
conn.commit()

Atualizando Registros

A operação UPDATE é usada para modificar registros existentes. Exemplo:

cursor.execute("UPDATE Clientes SET email = 'joao_novo@example.com' WHERE nome = 'João'")
conn.commit()

Deletando Registros

A operação DELETE remove registros. Exemplo:

cursor.execute("DELETE FROM Clientes WHERE nome = 'João'")
conn.commit()

Operações em Lote

Para inserir muitos registros de uma vez, usamos o método executemany():

data = [('Maria', 'maria@example.com'), ('Carlos', 'carlos@example.com')]
cursor.executemany("INSERT INTO Clientes (nome, email) VALUES (?, ?)", data)
conn.commit()

Consultas com Resultados

• Único Resultado: Utilizamos o método fetchone() para recuperar um único registro.

cursor.execute("SELECT * FROM Clientes WHERE nome = 'Maria'")
result = cursor.fetchone()

• Múltiplos Resultados: Utilizamos o método fetchall() para recuperar todos os registros.

cursor.execute("SELECT * FROM Clientes")
results = cursor.fetchall()

Trabalhando com Resultados de Consulta

Os resultados são retornados como tuplas por padrão, mas podemos usar a classe sqlite3.Row ou uma row_factory customizada para melhor adequação.

5. Boas Práticas em Consultas SQL

Segurança e Eficiência

Ao escrever consultas SQL em Python, devemos:

• Evitar a concatenação de strings nas consultas
• Usar consultas parametrizadas para prevenir ataques de injeção SQL

Exemplo de Consulta Parametrizada

cursor.execute("SELECT * FROM Clientes WHERE nome = ?", ('Maria',))

6. Gerenciando Transações

A Python DB API permite gerenciar transações, o que é crucial para manter a integridade dos dados. Exemplo:

try:
  conn.execute("BEGIN TRANSACTION")
  cursor.execute("UPDATE Clientes SET email = 'maria_nova@example.com' WHERE nome = 'Maria'")
  conn.commit()
except:
  conn.rollback()
  raise

Funções para manipular tabelas no SQLite.

Para adicionar comandos SQL importamos o módulo sqlite3, e usamos a função cursor.execute().

Criar Banco de dados

import sqlite3
from pathlib import Path
ROOT_PATH = Path(__file__).parent
conexao = sqlite3.connect(ROOT_PATH / "teste_banco.sqlite")
cursor = conexao.cursor()

Criar tabela

def criar_tabela(conexao, cursor):
  cursor.execute(
  "CREATE TABLE clientes (id INTEGER PRIMARY KEY AUTOINCREMENT, nome VARCHAR(100), email VARCHAR(150))"
  )
  conexao.commit()
criar_tabela(conexao, cursor)

Inserir um registro

def inserir_registro(conexao, cursor, nome, email):
  data = (nome, email)
  cursor.execute("INSERT INTO clientes (nome, email) VALUES (?,?);", data)
  conexao.commit()
inserir_registro(conexao, cursor, "João", "joao@gmail.com")

Atualizar um registro

def atualizar_registro(conexao, cursor, nome, email, id):
  data = (nome, email, id)
  cursor.execute("UPDATE clientes SET nome=?, email=? WHERE id=?;", data)
  conexao.commit()
atualizar_registro(conexao, cursor, "João Atualizado", "joao.atualizado@gmail.com", 1)

Inserir vários registros

def inserir_varios(conexao, cursor, dados):
  cursor.executemany("INSERT INTO clientes (nome, email) VALUES (?,?)", dados)
  conexao.commit()
dados = [
  ("Guilherme", "guilherme@gmail.com"),
  ("Chappie", "chappie@gmail.com"),
  ("Melaine", "melaine@gmail.com"),
  ]
inserir_varios(conexao, cursor, dados)

Excluir um registro

def excluir_registro(conexao, cursor, id):
  data = (id,)
  cursor.execute("DELETE FROM clientes WHERE id=?;", data)
  conexao.commit()
excluir_registro(conexao, cursor, 2)

Recuperar um registro

def recuperar_cliente(cursor, id):
  cursor.execute("SELECT email, id, nome FROM clientes WHERE id=?", (id,))
  return cursor.fetchone()
cliente = recuperar_cliente(cursor, 5)
print(cliente)

Recuperar um dicionário do registro

É necessário um novo cursor para converter a tupla em dicionário, para isso adicione:

cursor.row_factory = sqlite3.Row

def recuperar_cliente(cursor, id):
  cursor.execute("SELECT email, id, nome FROM clientes WHERE id=?", (id,))
  return cursor.fetchone()
cliente = recuperar_cliente(cursor, 5)
print(dict(cliente))
print(cliente["email"], cliente["id"], cliente["nome"])
print(f'Seja bem vindo ao sistema {cliente["nome"]}')

Listar os nomes do dicionário de registros

def listar_clientes(cursor):
  return cursor.execute("SELECT * FROM clientes ORDER BY nome DESC;")
clientes = listar_clientes(cursor)
for cliente in clientes:
  print(dict(cliente))

Conclusão

Compreender os conceitos de bancos de dados relacionais e saber como interagir com eles usando Python é essencial para o desenvolvimento de aplicações robustas e eficientes. Ao seguir boas práticas e usar as ferramentas adequadas, podemos garantir a segurança e a integridade dos nossos dados.

Este artigo cobriu os fundamentos e práticas básicas. À medida que você se aprofunda, explorará tópicos mais avançados e específicos para suas necessidades de desenvolvimento.

Esse conteúdo foi anotado da trilha Desenvolvedor Python.