Que métodos de trabalho com bases de dados conhece…

Módulos integrados:
sqlite3 - para trabalhar com o leve SGBD SQLite. Útil para projetos pequenos ou para usar como base de dados de ficheiros no cliente.

import sqlite3

# Conexão à base de dados (criará o ficheiro se não existir)
conn = sqlite3.connect('mydatabase.db')
cursor = conn.cursor()

# Criar tabela
cursor.execute('''
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        age INTEGER
    )
''')

# Inserir dados
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))

# Confirmar alterações
conn.commit()

# Obter dados
cursor.execute("SELECT name, age FROM users")
rows = cursor.fetchall()
for row in rows:
    print(row)

# Fechar conexão
conn.close()

API Python DB (PEP-249):
Interface padrão que a maioria dos controladores de terceiros para diferentes bases de dados (PostgreSQL, MySQL, Oracle, etc.) definem. Permite escrever código que não depende de uma base de dados específica.

Controladores/conectores especializados:
Bibliotecas que implementam Python DB API para bases de dados específicas:

psycopg2 - para PostgreSQL.
mysql-connector-python ou PyMySQL - para MySQL.
cx_Oracle - para Oracle.
pymssql - para Microsoft SQL Server.

import psycopg2

# Conexão ao PostgreSQL
try:
    conn = psycopg2.connect(
        host="localhost",
        database="mydatabase",
        user="myuser",
        password="mypassword"
    )
    cursor = conn.cursor()

    # Executar consulta SQL
    cursor.execute("SELECT * FROM products;")
    results = cursor.fetchall()
    for row in results:
        print(row)

    conn.close()
except psycopg2.Error as e:
    print(f"Erro ao conectar à base de dados: {e}")

ORM (Object-Relational Mapping):
Frameworks que permitem trabalhar com bases de dados usando objetos Python, em vez de consultas SQL diretamente. Simplificam a interação com a base de dados, fornecem abstração, ajudam a evitar injeções SQL.

SQLAlchemy - uma das ORM mais poderosas e flexíveis em Python. Suporta múltiplos SGBDs, fornece tanto "Core" (para trabalhar ao nível SQL) quanto "ORM" (para abordagem orientada a objetos).
Django ORM - ORM embutido no framework Django, muito conveniente para trabalhar com bases de dados no contexto de aplicações web Django.
Peewee - ORM simples e leve.

Exemplo com SQLAlchemy Core:

from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, select

# Conexão à base de dados (por exemplo, SQLite)
engine = create_engine('sqlite:///mydatabase.db')

# Objeto MetaData para armazenar metadados da base de dados
metadata = MetaData()

# Definição da tabela
users_table = Table(
    'users',
    metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String),
    Column('age', Integer)
)

# Criar a tabela na base de dados (se não existir)
metadata.create_all(engine)

# Estabelecer conexão
with engine.connect() as connection:
    # Inserir dados
    connection.execute(
        users_table.insert().values(name='Bob', age=25)
    )

    # Selecionar dados
    select_query = select(users_table)
    result = connection.execute(select_query)

    for row in result:
        print(row)

Exemplo com SQLAlchemy ORM:

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# Conexão à base de dados
engine = create_engine('sqlite:///mydatabase_orm.db')

# Classe base para modelos ORM
Base = declarative_base()

# Definição do modelo ORM
class User(Base):
    __tablename__ = 'users_orm'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)

    def __repr__(self):
        return f"<User(name='{self.name}', age={self.age})>"

# Criar a tabela (se não existir)
Base.metadata.create_all(engine)

# Criar fábrica de sessões
Session = sessionmaker(bind=engine)
session = Session()

# Criar e adicionar objeto
new_user = User(name='Charlie', age=40)
session.add(new_user)

# Confirmar transação
session.commit()

# Obter objeto
user = session.query(User).filter_by(name='Charlie').first()
print(user)

# Fechar sessão
session.close()

Bases de dados NoSQL:
Para trabalhar com bases NoSQL, usam-se bibliotecas especializadas, por exemplo:
- pymongo - para MongoDB.
- redis - para Redis.
- cassandra-driver - para Cassandra.

A escolha do método depende dos requisitos do projeto, do tipo de SGBD utilizado, da necessidade de ORM e do nível de complexidade do projeto.

Que métodos de trabalho com bases de dados conhece?