antonino, Autor em Área de Trampo

Django Models: Definindo Estruturas de Dados com Classe

22/05/202623/04/2026 Por antonino

Django Models são a espinha dorsal de aplicações Django. Eles definem como os dados são estruturados no banco. Cada model vira uma tabela no banco de dados. Primeiramente, você escreve classes Python comuns. Cada atributo de classe vira uma coluna da tabela. Isso é chamado de ORM (Mapeamento Objeto-Relacional). Por exemplo, um model Produto vira tabela “produto”. Os campos incluem CharField, IntegerField, entre outros. Além disso, relacionamentos são muito intuitivos. Use ForeignKey para ligações entre tabelas. Portanto, você manipula objetos, não SQL. Assim, o desenvolvimento fica mais rápido e seguro.

Características fundamentais dos Django Models

Uma característica central é a geração automática de schemas. O Django cria tabelas e índices sem intervenção manual. Outro ponto forte é a validação integrada dos campos. Cada tipo de campo já valida os dados recebidos. Por exemplo, EmailField verifica formato de e-mail. Isso foi pensado para segurança e conveniência. Além disso, os models têm uma API de consulta poderosa. Você faz filtros com filter() e exclude(). Encadeie métodos para consultas complexas facilmente. Uma fórmula que representa isso é:

\(\text{QuerySet} = \text{Model.objects.filter(condição)}\)

Isso retorna um conjunto iterável de objetos. Primeiramente, entenda que os QuerySets são lazy. Eles só executam quando você realmente precisa dos dados. Portanto, a performance é otimizada automaticamente.

Outra característica importante é o sistema de migrações. O Django rastreia mudanças nos seus models. Comandos como makemigrations geram scripts sob demanda. Depois, migrate aplica essas mudanças no banco. Isso foi inspirado em práticas de engenharia reversa. Consequentemente, você versiona sua estrutura de dados. Assim, equipes inteiras evoluem o banco sincronizadamente.

Quando utilizar Django Models

Use Django Models em qualquer aplicação web Django. Elas são obrigatórias no framework para persistência. Projetos de blog, e-commerce e redes sociais usam. Outro caso comum é em sistemas administrativos internos. Por outro lado, evite models para análises pesadas. Nesse cenário, pandas ou Spark são mais eficientes. Primeiramente, avalie se os dados são relacionais. Se sim, Django Models são uma excelente escolha. Se você precisa de flexibilidade de schemas, considere NoSQL. O Django não é ideal para bancos não-relacionais. Além disso, para scripts únicos de carga de dados, Use SQL direto, mais rápido e sem overhead. Portanto, Django Models brilham em aplicações transacionais.

Outro bom uso é em projetos de longo prazo. A manutenção é facilitada pela abstração do ORM. Novos desenvolvedores entendem rapidamente os models. Isso foi observado em empresas com equipes grandes. Use também para protótipos que podem crescer. O Django escala muito bem com otimizações pontuais. Portanto, é uma escolha profissional e segura.

Exemplo prático: blog com usuários e posts

O código abaixo simula um app Django completo. Definimos dois models: Autor e Artigo. Um autor pode ter vários artigos (relação 1:N). Primeiramente, cada model herda de models.Model. Depois, adicionamos campos com tipos específicos. Incluímos também métodos personalizados nos models. Por exemplo, __str__ controla a exibição no admin. Outro método, publicar, altera o estado do artigo. Observe como a lógica fica dentro do próprio model. Isso é chamado de “model rico” (fat model). Vamos ao código comentado para entendimento completo.

# Este código simula o arquivo models.py de um app Django
# Para usar em um projeto real, execute dentro de um ambiente Django

from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User
from django.urls import reverse

# ============================================
# EXEMPLO 1: MODEL SIMPLES
# ============================================

class Autor(models.Model):
    """Model para autores de artigos."""
    
    # Campos básicos
    nome = models.CharField(max_length=100, verbose_name="Nome completo")
    email = models.EmailField(unique=True, verbose_name="E-mail")
    biografia = models.TextField(blank=True, verbose_name="Biografia")
    data_nascimento = models.DateField(null=True, blank=True)
    
    # Campos automáticos
    data_criacao = models.DateTimeField(auto_now_add=True)
    data_atualizacao = models.DateTimeField(auto_now=True)
    ativo = models.BooleanField(default=True)
    
    class Meta:
        ordering = ['nome']
        verbose_name = 'Autor'
        verbose_name_plural = 'Autores'
    
    def __str__(self):
        return self.nome
    
    def get_absolute_url(self):
        """Retorna URL para detalhe do autor."""
        return reverse('autor_detail', args=[self.id])
    
    @property
    def total_artigos(self):
        """Propriedade calculada: conta artigos publicados."""
        return self.artigos.filter(publicado=True).count()


# ============================================
# EXEMPLO 2: MODEL COM RELACIONAMENTO
# ============================================

class Artigo(models.Model):
    """Model para artigos do blog."""
    
    # Opções para o campo status
    class Status(models.TextChoices):
        RASCUNHO = 'R', 'Rascunho'
        PUBLICADO = 'P', 'Publicado'
        ARQUIVADO = 'A', 'Arquivado'
    
    # Campos básicos
    titulo = models.CharField(max_length=200, unique=True)
    slug = models.SlugField(max_length=200, unique=True)
    conteudo = models.TextField()
    resumo = models.TextField(max_length=500, blank=True)
    
    # Relacionamento (ForeignKey)
    autor = models.ForeignKey(
        Autor, 
        on_delete=models.CASCADE, 
        related_name='artigos',
        verbose_name='Autor'
    )
    
    # Datas
    data_criacao = models.DateTimeField(auto_now_add=True)
    data_publicacao = models.DateTimeField(null=True, blank=True)
    data_atualizacao = models.DateTimeField(auto_now=True)
    
    # Status
    status = models.CharField(
        max_length=1,
        choices=Status.choices,
        default=Status.RASCUNHO
    )
    
    # Campos para SEO
    meta_descricao = models.CharField(max_length=160, blank=True)
    palavras_chave = models.CharField(max_length=200, blank=True, 
                                      help_text="Separe por vírgulas")
    
    class Meta:
        ordering = ['-data_publicacao', '-data_criacao']
        indexes = [
            models.Index(fields=['slug']),
            models.Index(fields=['status', 'data_publicacao']),
        ]
        verbose_name = 'Artigo'
        verbose_name_plural = 'Artigos'
    
    def __str__(self):
        return self.titulo
    
    def get_absolute_url(self):
        """URL amigável para o artigo."""
        return reverse('artigo_detail', args=[self.slug])
    
    def publicar(self):
        """Método para publicar o artigo."""
        if self.status == self.Status.RASCUNHO:
            self.status = self.Status.PUBLICADO
            self.data_publicacao = timezone.now()
            self.save()
            return True
        return False
    
    def arquivar(self):
        """Método para arquivar o artigo."""
        if self.status == self.Status.PUBLICADO:
            self.status = self.Status.ARQUIVADO
            self.save()
            return True
        return False
    
    @property
    def esta_publicado(self):
        return self.status == self.Status.PUBLICADO
    
    @property
    def palavras_chave_lista(self):
        """Retorna lista de palavras-chave."""
        return [p.strip() for p in self.palavras_chave.split(',') if p.strip()]


# ============================================
# EXEMPLO 3: MODEL COM RELAÇÃO MANY-TO-MANY
# ============================================

class Tag(models.Model):
    """Tags para categorizar artigos."""
    
    nome = models.CharField(max_length=50, unique=True)
    slug = models.SlugField(max_length=50, unique=True)
    artigos = models.ManyToManyField(Artigo, related_name='tags', blank=True)
    data_criacao = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        ordering = ['nome']
    
    def __str__(self):
        return self.nome
    
    def get_absolute_url(self):
        return reverse('tag_detail', args=[self.slug])
    
    @property
    def total_artigos(self):
        return self.artigos.count()


# ============================================
# EXEMPLO 4: MODEL COM GERENCIADOR PERSONALIZADO
# ============================================

class ArtigoManager(models.Manager):
    """Manager personalizado para consultas comuns."""
    
    def publicados(self):
        """Retorna apenas artigos publicados."""
        return self.filter(status=Artigo.Status.PUBLICADO)
    
    def recentes(self, limite=5):
        """Retorna os artigos mais recentes."""
        return self.publicados().order_by('-data_publicacao')[:limite]
    
    def por_autor(self, autor_id):
        """Retorna artigos de um autor específico."""
        return self.publicados().filter(autor_id=autor_id)


# Para usar o manager personalizado, adicione ao model Artigo:
# objects = ArtigoManager()

# ============================================
# EXEMPLO DE USO (NO SHELL DO DJANGO)
# ============================================
"""
# Criar um autor
autor1 = Autor.objects.create(
    nome="Ana Oliveira",
    email="ana@exemplo.com",
    biografia="Escritora e desenvolvedora Python"
)

# Criar um artigo
artigo = Artigo(
    titulo="Introdução ao Django",
    slug="introducao-django",
    conteudo="Django é um framework web poderoso...",
    resumo="Aprenda os fundamentos do Django",
    autor=autor1,
    status=Artigo.Status.RASCUNHO
)
artigo.save()

# Publicar o artigo
artigo.publicar()

# Consultar artigos publicados de um autor
artigos_autor = Artigo.objects.filter(autor=autor1, status='P')
print(f"Artigos publicados: {artigos_autor.count()}")

# Usar o manager personalizado (se implementado)
# artigos_recentes = Artigo.objects.recentes(3)

# Buscar por palavra-chave
artigos_python = Artigo.objects.filter(conteudo__icontains="Python")
"""

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

# Este código simula o arquivo models.py de um app Django

# Para usar em um projeto real, execute dentro de um ambiente Django

from django.db import models

from django.utils import timezone

from django.contrib.auth.models import User

from django.urls import reverse

# ============================================

# EXEMPLO 1: MODEL SIMPLES

# ============================================

class Autor(models.Model):

"""Model para autores de artigos."""

# Campos básicos

nome = models.CharField(max_length=100, verbose_name="Nome completo")

email = models.EmailField(unique=True, verbose_name="E-mail")

biografia = models.TextField(blank=True, verbose_name="Biografia")

data_nascimento = models.DateField(null=True, blank=True)

# Campos automáticos

data_criacao = models.DateTimeField(auto_now_add=True)

data_atualizacao = models.DateTimeField(auto_now=True)

ativo = models.BooleanField(default=True)

class Meta:

ordering = ['nome']

verbose_name = 'Autor'

verbose_name_plural = 'Autores'

def __str__(self):

return self.nome

def get_absolute_url(self):

"""Retorna URL para detalhe do autor."""

return reverse('autor_detail', args=[self.id])

@property

def total_artigos(self):

"""Propriedade calculada: conta artigos publicados."""

return self.artigos.filter(publicado=True).count()

# ============================================

# EXEMPLO 2: MODEL COM RELACIONAMENTO

# ============================================

class Artigo(models.Model):

"""Model para artigos do blog."""

# Opções para o campo status

class Status(models.TextChoices):

RASCUNHO = 'R', 'Rascunho'

PUBLICADO = 'P', 'Publicado'

ARQUIVADO = 'A', 'Arquivado'

# Campos básicos

titulo = models.CharField(max_length=200, unique=True)

slug = models.SlugField(max_length=200, unique=True)

conteudo = models.TextField()

resumo = models.TextField(max_length=500, blank=True)

# Relacionamento (ForeignKey)

autor = models.ForeignKey(

Autor,

on_delete=models.CASCADE,

related_name='artigos',

verbose_name='Autor'

)

# Datas

data_criacao = models.DateTimeField(auto_now_add=True)

data_publicacao = models.DateTimeField(null=True, blank=True)

data_atualizacao = models.DateTimeField(auto_now=True)

# Status

status = models.CharField(

max_length=1,

choices=Status.choices,

default=Status.RASCUNHO

)

# Campos para SEO

meta_descricao = models.CharField(max_length=160, blank=True)

palavras_chave = models.CharField(max_length=200, blank=True,

help_text="Separe por vírgulas")

class Meta:

ordering = ['-data_publicacao', '-data_criacao']

indexes = [

models.Index(fields=['slug']),

models.Index(fields=['status', 'data_publicacao']),

]

verbose_name = 'Artigo'

verbose_name_plural = 'Artigos'

def __str__(self):

return self.titulo

def get_absolute_url(self):

"""URL amigável para o artigo."""

return reverse('artigo_detail', args=[self.slug])

def publicar(self):

"""Método para publicar o artigo."""

if self.status == self.Status.RASCUNHO:

self.status = self.Status.PUBLICADO

self.data_publicacao = timezone.now()

self.save()

return True

return False

def arquivar(self):

"""Método para arquivar o artigo."""

if self.status == self.Status.PUBLICADO:

self.status = self.Status.ARQUIVADO

self.save()

return True

return False

@property

def esta_publicado(self):

return self.status == self.Status.PUBLICADO

@property

def palavras_chave_lista(self):

"""Retorna lista de palavras-chave."""

return [p.strip() for p in self.palavras_chave.split(',') if p.strip()]

# ============================================

# EXEMPLO 3: MODEL COM RELAÇÃO MANY-TO-MANY

# ============================================

class Tag(models.Model):

"""Tags para categorizar artigos."""

nome = models.CharField(max_length=50, unique=True)

slug = models.SlugField(max_length=50, unique=True)

artigos = models.ManyToManyField(Artigo, related_name='tags', blank=True)

data_criacao = models.DateTimeField(auto_now_add=True)

class Meta:

ordering = ['nome']

def __str__(self):

return self.nome

def get_absolute_url(self):

return reverse('tag_detail', args=[self.slug])

@property

def total_artigos(self):

return self.artigos.count()

# ============================================

# EXEMPLO 4: MODEL COM GERENCIADOR PERSONALIZADO

# ============================================

class ArtigoManager(models.Manager):

"""Manager personalizado para consultas comuns."""

def publicados(self):

"""Retorna apenas artigos publicados."""

return self.filter(status=Artigo.Status.PUBLICADO)

def recentes(self, limite=5):

"""Retorna os artigos mais recentes."""

return self.publicados().order_by('-data_publicacao')[:limite]

def por_autor(self, autor_id):

"""Retorna artigos de um autor específico."""

return self.publicados().filter(autor_id=autor_id)

# Para usar o manager personalizado, adicione ao model Artigo:

# objects = ArtigoManager()

# ============================================

# EXEMPLO DE USO (NO SHELL DO DJANGO)

# ============================================

"""

# Criar um autor

autor1 = Autor.objects.create(

nome="Ana Oliveira",

email="ana@exemplo.com",

biografia="Escritora e desenvolvedora Python"

)

# Criar um artigo

artigo = Artigo(

titulo="Introdução ao Django",

slug="introducao-django",

conteudo="Django é um framework web poderoso...",

resumo="Aprenda os fundamentos do Django",

autor=autor1,

status=Artigo.Status.RASCUNHO

)

artigo.save()

# Publicar o artigo

artigo.publicar()

# Consultar artigos publicados de um autor

artigos_autor = Artigo.objects.filter(autor=autor1, status='P')

print(f"Artigos publicados: {artigos_autor.count()}")

# Usar o manager personalizado (se implementado)

# artigos_recentes = Artigo.objects.recentes(3)

# Buscar por palavra-chave

artigos_python = Artigo.objects.filter(conteudo__icontains="Python")

"""

No exemplo, cada model é uma classe Python comum. Os campos são definidos com tipos específicos do Django. Os relacionamentos usam ForeignKey ou ManyToManyField. Métodos como publicar() encapsulam regras de negócio. Propriedades como total_artigos calculam valores dinamicamente. Isso mantém as views e templates mais limpos. Além disso, o Django cria automaticamente o banco. Não é necessário escrever nenhuma linha de SQL. Primeiramente, execute python manage.py makemigrations. Depois, python manage.py migrate para aplicar. Assim, você tem um banco funcional em segundos. Portanto, a produtividade é imensamente superior.

Outro ponto importante é o painel administrativo. Registre seus models no admin.py com uma linha. Você ganha uma interface CRUD completa automaticamente. Isso foi pensado para acelerar o desenvolvimento de backoffice. Por exemplo, admin.site.register(Autor) é suficiente. O Django gera formulários, listagens e buscas. Isso é incrível para protótipos e MVPs. Além disso, você pode personalizar tudo facilmente. Portanto, Django Models são uma escolha poderosa. Use-os com confiança em seus próximos projetos.

📌 Resumo dos tipos de campos mais comuns:

CharField TextField IntegerField FloatField BooleanField DateField DateTimeField EmailField URLField ForeignKey ManyToManyField OneToOneField

Finalmente, lembre-se de documentar seus models. Use help_text nos campos para explicações. Isso ajuda outros desenvolvedores no futuro. Além disso, mantenha as migrações versionadas no Git. Nunca edite migrações manualmente a menos que necessário. Nunca exclua uma migração já aplicada em produção. Isso pode corromper o estado do banco de dados. Primeiramente, planeje bem a estrutura dos dados. Depois, evolua os models com migrações novas. Assim, você evita dores de cabeça no futuro. Portanto, Django Models são robustos e confiáveis. Aprenda-os bem e você construirá sistemas incríveis.

SQLAlchemy: Trabalhando com Bancos de Dados em Python

22/05/202623/04/2026 Por antonino

SQLAlchemy é o ORM mais popular do ecossistema Python. ORM significa Mapeamento Objeto-Relacional. Ele traduz tabelas do banco em classes Python. Linhas das tabelas viram instâncias dessas classes. Primeiramente, isso elimina a necessidade de SQL puro. Você interage com o banco usando objetos familiares. Por exemplo, session.query(Usuario).filter_by(nome="Ana"). Isso é muito mais intuitivo que strings SQL. Além disso, o SQLAlchemy é compatível com vários bancos. PostgreSQL, MySQL, SQLite e Oracle são suportados. Portanto, você troca de banco sem reescrever tudo. Assim, a produtividade do desenvolvedor aumenta drasticamente.

Características fundamentais do SQLAlchemy

SQLAlchemy tem duas camadas principais: Core e ORM. A camada Core fornece acesso SQL de baixo nível. Ela é útil para consultas complexas e otimizadas. A camada ORM é mais abstrata e amigável. Ela foi projetada para produtividade do dia a dia. Outra característica importante é o lazy loading. Relacionamentos são carregados sob demanda automaticamente. Isso evita consultas desnecessárias ao banco. Além disso, o SQLAlchemy protege contra injeção de SQL. As consultas são parametrizadas automaticamente. Consequentemente, a segurança é significativamente melhor. Uma fórmula que representa isso é:

\(\text{SQLAlchemy} = \text{Abstração} + \text{Segurança} – \text{SQL manual}\)

Portanto, você ganha tempo e reduz riscos.

Outro ponto forte é a migração de esquemas. A biblioteca Alembic integra-se perfeitamente com ela. Você pode evoluir seu banco de forma versionada. Isso é essencial para equipes em produção. Primeiramente, defina seus modelos em Python puro. Depois, gere as migrações automaticamente. Assim, todos os ambientes ficam sincronizados.

Quando utilizar SQLAlchemy no seu projeto

Use SQLAlchemy em aplicações web com banco de dados. Frameworks como Flask e Django o suportam bem. Também é ideal para APIs REST que persistem dados. Projetos de médio a grande porte se beneficiam mais. Por outro lado, evite ORM para scripts muito simples. Uma única consulta SQL direta pode ser mais rápida. Além disso, não use para análises de dados pesadas. Nesse caso, pandas é a ferramenta mais adequada. Primeiramente, avalie a complexidade das suas queries. Se você tem muitos joins e relações, ORM é ótimo. Se são consultas simples, o SQL puro resolve bem. Portanto, a escolha depende do seu contexto específico.

Outro bom uso é em projetos com equipes grandes. O ORM padroniza o acesso ao banco de dados. Novos desenvolvedores aprendem mais rapidamente. Isso foi observado em muitas empresas de sucesso. Use SQLAlchemy também quando a portabilidade importa. Trocar de PostgreSQL para MySQL é simples. Assim, você evita o lock-in com fornecedores. Portanto, SQLAlchemy é uma escolha profissional.

Exemplo prático: modelo de usuários e posts

O código abaixo implementa um blog simples. Temos duas tabelas: Usuario e Post. Um usuário pode ter muitos posts (relação 1:N). Primeiramente, definimos as classes com declarative_base. Depois, configuramos a conexão com SQLite em memória. Criamos as tabelas automaticamente com create_all. Por fim, inserimos dados e fazemos consultas. Observe como não escrevemos nenhuma linha de SQL. Tudo é feito através de objetos Python familiares. Isso é o poder do mapeamento objeto-relacional. Vamos ao código comentado para detalhes.

# Instalação: pip install sqlalchemy

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey, DateTime
from sqlalchemy.orm import declarative_base, sessionmaker, relationship
from datetime import datetime

# ============================================
# MODELOS (DEFINIÇÃO DAS TABELAS)
# ============================================

Base = declarative_base()

class Usuario(Base):
    __tablename__ = 'usuarios'
    
    id = Column(Integer, primary_key=True)
    nome = Column(String(100), nullable=False)
    email = Column(String(100), unique=True, nullable=False)
    data_cadastro = Column(DateTime, default=datetime.now)
    
    # Relacionamento: um usuário tem muitos posts
    posts = relationship("Post", back_populates="autor", cascade="all, delete-orphan")
    
    def __repr__(self):
        return f"<Usuario(id={self.id}, nome='{self.nome}', email='{self.email}')>"


class Post(Base):
    __tablename__ = 'posts'
    
    id = Column(Integer, primary_key=True)
    titulo = Column(String(200), nullable=False)
    conteudo = Column(String, nullable=False)
    data_publicacao = Column(DateTime, default=datetime.now)
    usuario_id = Column(Integer, ForeignKey('usuarios.id'))
    
    # Relacionamento: o post pertence a um usuário
    autor = relationship("Usuario", back_populates="posts")
    
    def __repr__(self):
        return f"<Post(id={self.id}, titulo='{self.titulo}', autor_id={self.usuario_id})>"


# ============================================
# CONFIGURAÇÃO DO BANCO
# ============================================

# Conectando ao SQLite (em memória para exemplo)
engine = create_engine('sqlite:///:memory:', echo=True)
# Para arquivo real: 'sqlite:///meubanco.db'
# Para PostgreSQL: 'postgresql://user:pass@localhost/db'

# Cria todas as tabelas definidas
Base.metadata.create_all(engine)

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


# ============================================
# OPERAÇÕES CRUD (CREATE, READ, UPDATE, DELETE)
# ============================================

print("=== 1. CRIANDO USUÁRIOS ===")
usuario1 = Usuario(nome="Ana Silva", email="ana@email.com")
usuario2 = Usuario(nome="Carlos Oliveira", email="carlos@email.com")
usuario3 = Usuario(nome="Beatriz Santos", email="beatriz@email.com")

# Adicionando à sessão
session.add_all([usuario1, usuario2, usuario3])
session.commit()  # Salva no banco

print(f"Usuários criados: {usuario1}, {usuario2}, {usuario3}")


print("\n=== 2. CRIANDO POSTS ===")
post1 = Post(titulo="Primeiro post", conteudo="Conteúdo do primeiro post", autor=usuario1)
post2 = Post(titulo="SQLAlchemy é incrível", conteudo="Aprendendo ORM em Python", autor=usuario1)
post3 = Post(titulo="Dicas de Python", conteudo="List comprehensions são úteis", autor=usuario2)

session.add_all([post1, post2, post3])
session.commit()

print(f"Posts criados: {post1}, {post2}, {post3}")


print("\n=== 3. CONSULTANDO DADOS ===")
# Buscar todos os usuários
todos_usuarios = session.query(Usuario).all()
print(f"Todos usuários: {todos_usuarios}")

# Filtrar por condição
usuario_ana = session.query(Usuario).filter(Usuario.nome == "Ana Silva").first()
print(f"Usuário encontrado pelo nome: {usuario_ana}")

# Filtrar por email (campo único)
usuario_carlos = session.query(Usuario).filter_by(email="carlos@email.com").first()
print(f"Usuário encontrado por email: {usuario_carlos}")

# Consultar posts de um usuário específico
posts_ana = usuario_ana.posts
print(f"Posts de Ana: {posts_ana}")


print("\n=== 4. ATUALIZANDO DADOS ===")
# Atualizar um usuário
usuario_carlos.nome = "Carlos Alberto Oliveira"
session.commit()
print(f"Usuário atualizado: {usuario_carlos}")

# Atualizar um post
post2.titulo = "SQLAlchemy ORM - Guia Completo"
session.commit()
print(f"Post atualizado: {post2}")


print("\n=== 5. DELETANDO DADOS ===")
# Deletar um post
session.delete(post3)
session.commit()
print(f"Post {post3.id} deletado!")

# Deletar um usuário (cascade deleta seus posts também)
session.delete(usuario2)
session.commit()
print(f"Usuário {usuario2.nome} e seus posts foram deletados!")


print("\n=== 6. CONSULTAS MAIS AVANÇADAS ===")
from sqlalchemy import func

# Contagem de posts
total_posts = session.query(func.count(Post.id)).scalar()
print(f"Total de posts restantes: {total_posts}")

# Usuários com seus posts (join automático)
resultados = session.query(Usuario, Post).join(Post).all()
for usuario, post in resultados:
    print(f"{usuario.nome} escreveu: '{post.titulo}'")

# Filtro com LIKE
posts_com_python = session.query(Post).filter(Post.conteudo.like("%Python%")).all()
print(f"Posts mencionando Python: {posts_com_python}")


print("\n=== 7. FECHANDO CONEXÃO ===")
session.close()
print("Sessão fechada com sucesso!")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

# Instalação: pip install sqlalchemy

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey, DateTime

from sqlalchemy.orm import declarative_base, sessionmaker, relationship

from datetime import datetime

# ============================================

# MODELOS (DEFINIÇÃO DAS TABELAS)

# ============================================

Base = declarative_base()

class Usuario(Base):

__tablename__ = 'usuarios'

id = Column(Integer, primary_key=True)

nome = Column(String(100), nullable=False)

email = Column(String(100), unique=True, nullable=False)

data_cadastro = Column(DateTime, default=datetime.now)

# Relacionamento: um usuário tem muitos posts

posts = relationship("Post", back_populates="autor", cascade="all, delete-orphan")

def __repr__(self):

return f"<Usuario(id={self.id}, nome='{self.nome}', email='{self.email}')>"

class Post(Base):

__tablename__ = 'posts'

id = Column(Integer, primary_key=True)

titulo = Column(String(200), nullable=False)

conteudo = Column(String, nullable=False)

data_publicacao = Column(DateTime, default=datetime.now)

usuario_id = Column(Integer, ForeignKey('usuarios.id'))

# Relacionamento: o post pertence a um usuário

autor = relationship("Usuario", back_populates="posts")

def __repr__(self):

return f"<Post(id={self.id}, titulo='{self.titulo}', autor_id={self.usuario_id})>"

# ============================================

# CONFIGURAÇÃO DO BANCO

# ============================================

# Conectando ao SQLite (em memória para exemplo)

engine = create_engine('sqlite:///:memory:', echo=True)

# Para arquivo real: 'sqlite:///meubanco.db'

# Para PostgreSQL: 'postgresql://user:pass@localhost/db'

# Cria todas as tabelas definidas

Base.metadata.create_all(engine)

# Cria uma fábrica de sessões

Session = sessionmaker(bind=engine)

session = Session()

# ============================================

# OPERAÇÕES CRUD (CREATE, READ, UPDATE, DELETE)

# ============================================

print("=== 1. CRIANDO USUÁRIOS ===")

usuario1 = Usuario(nome="Ana Silva", email="ana@email.com")

usuario2 = Usuario(nome="Carlos Oliveira", email="carlos@email.com")

usuario3 = Usuario(nome="Beatriz Santos", email="beatriz@email.com")

# Adicionando à sessão

session.add_all([usuario1, usuario2, usuario3])

session.commit() # Salva no banco

print(f"Usuários criados: {usuario1}, {usuario2}, {usuario3}")

print("\n=== 2. CRIANDO POSTS ===")

post1 = Post(titulo="Primeiro post", conteudo="Conteúdo do primeiro post", autor=usuario1)

post2 = Post(titulo="SQLAlchemy é incrível", conteudo="Aprendendo ORM em Python", autor=usuario1)

post3 = Post(titulo="Dicas de Python", conteudo="List comprehensions são úteis", autor=usuario2)

session.add_all([post1, post2, post3])

session.commit()

print(f"Posts criados: {post1}, {post2}, {post3}")

print("\n=== 3. CONSULTANDO DADOS ===")

# Buscar todos os usuários

todos_usuarios = session.query(Usuario).all()

print(f"Todos usuários: {todos_usuarios}")

# Filtrar por condição

usuario_ana = session.query(Usuario).filter(Usuario.nome == "Ana Silva").first()

print(f"Usuário encontrado pelo nome: {usuario_ana}")

# Filtrar por email (campo único)

usuario_carlos = session.query(Usuario).filter_by(email="carlos@email.com").first()

print(f"Usuário encontrado por email: {usuario_carlos}")

# Consultar posts de um usuário específico

posts_ana = usuario_ana.posts

print(f"Posts de Ana: {posts_ana}")

print("\n=== 4. ATUALIZANDO DADOS ===")

# Atualizar um usuário

usuario_carlos.nome = "Carlos Alberto Oliveira"

session.commit()

print(f"Usuário atualizado: {usuario_carlos}")

# Atualizar um post

post2.titulo = "SQLAlchemy ORM - Guia Completo"

session.commit()

print(f"Post atualizado: {post2}")

print("\n=== 5. DELETANDO DADOS ===")

# Deletar um post

session.delete(post3)

session.commit()

print(f"Post {post3.id} deletado!")

# Deletar um usuário (cascade deleta seus posts também)

session.delete(usuario2)

session.commit()

print(f"Usuário {usuario2.nome} e seus posts foram deletados!")

print("\n=== 6. CONSULTAS MAIS AVANÇADAS ===")

from sqlalchemy import func

# Contagem de posts

total_posts = session.query(func.count(Post.id)).scalar()

print(f"Total de posts restantes: {total_posts}")

# Usuários com seus posts (join automático)

resultados = session.query(Usuario, Post).join(Post).all()

for usuario, post in resultados:

print(f"{usuario.nome} escreveu: '{post.titulo}'")

# Filtro com LIKE

posts_com_python = session.query(Post).filter(Post.conteudo.like("%Python%")).all()

print(f"Posts mencionando Python: {posts_com_python}")

print("\n=== 7. FECHANDO CONEXÃO ===")

session.close()

print("Sessão fechada com sucesso!")

No exemplo, todas as operações são naturais. Criamos objetos Usuario e Post como classes normais. A sessão (session) gerencia as transações. Quando chamamos commit(), os dados vão ao banco. Consultas usam query() com filtros Python. Relacionamentos são acessados como atributos comuns. Por exemplo, usuario.posts retorna a lista de posts. Isso é muito mais legível que SQL puro. Além disso, o SQLAlchemy gerencia as chaves estrangeiras. Não precisamos escrever JOINs manualmente. Portanto, o código fica focado na lógica de negócio. Assim, você desenvolve aplicações mais rapidamente.

Outra vantagem importante é a portabilidade. Mude a string de conexão para outro banco. Por exemplo, troque sqlite:// por postgresql://. O código permanece exatamente igual. Isso é incrível para projetos que podem crescer. Primeiramente, comece com SQLite durante o desenvolvimento. Depois, migre para PostgreSQL em produção. Assim, você economiza tempo de configuração. Finalmente, sempre use sessões em contextos controlados. Evite manter sessões abertas por muito tempo. Use padrões como with session.begin(): para transações. Portanto, SQLAlchemy é uma ferramenta madura e confiável.

✅ Vantagens do SQLAlchemy
Abstração do banco de dados
Segurança contra SQL injection
Relacionamentos fáceis
Migrations com Alembic

⚠️ Desvantagens
Curva de aprendizado
Overhead em queries simples
Debugging mais complexo
Pode gerar SQL ineficiente

Para projetos pequenos, considere alternativas mais leves. Peewee ou SQLite puro podem ser suficientes. No entanto, para qualquer projeto profissional, SQLAlchemy brilha. Ele é usado por empresas como Reddit, Dropbox e SurveyMonkey. Isso atesta sua robustez e escalabilidade. Portanto, invista tempo aprendendo essa ferramenta. Ela será útil em praticamente todos seus projetos futuros. Primeiramente, domine os exemplos básicos apresentados. Depois, explore recursos avançados como eventos e híbridos. Assim, você se torna um desenvolvedor completo e eficiente.