Quer aprender a criar um banco de dados em Python da melhor forma? Aprenda a fazer isso com o SQLAlchemy, sem precisar escrever comandos SQL.
Se quiser pode acompanhar esse conteúdo em formato de vídeo ou pode acessar o nosso Canal do YouTube para mais vídeos!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.
O SQLAlchemy é uma das melhores opções para integrar Python com bancos de dados SQL! É uma biblioteca extremamente útil e prática para quem precisa criar um banco de dados em Python de forma rápida e eficiente.
Nesta postagem você encontrará informações detalhadas sobre o que é o SQLAlchemy, como configurá-lo e utilizá-lo para criar bancos de dados, tabelas e realizar as operações CRUD (Criação, Leitura, Atualização e Exclusão de dados).
Quer aprender como fazer tudo isso de forma simples, sem precisar dominar comandos SQL? Então faça o download do material disponível e vem comigo!
O SQLAlchemy é uma biblioteca de mapeamento objeto-relacional (ORM – Object Relational Mapper) para Python que permite a interação com bancos de dados SQL de forma simplificada e eficiente.
Com o SQLAlchemy, você pode criar, editar e manipular bancos de dados utilizando objetos Python, o que facilita a integração e o gerenciamento de dados sem a necessidade de escrever comandos SQL diretamente.
Saiba mais: Documentação do SQLAlchemy
O primeiro passo para usar o SQLAlchemy é instalá-lo. Para isso, execute o seguinte comando no terminal do seu editor de código: pip install SQLAlchemy
Após a instalação, a biblioteca estará disponível para você criar e manipular bancos de dados SQL, sejam eles locais ou remotos.
O SQLAlchemy utiliza o conceito de engine para se conectar a um banco de dados, seja para criá-lo ou para se conectar a um banco existente. Para isso, usaremos a função create_engine.
Vamos criar uma variável chamada db para representar o nosso banco de dados. Esta variável armazenará a instância do banco de dados criado pela função create_engine, que, neste exemplo, será um banco de dados SQLite chamado meubanco.db.
from sqlalchemy import create_engine
db = create_engine("sqlite:///meubanco.db")O SQLAlchemy suporta diferentes tipos de bancos de dados, como PostgreSQL, MySQL, entre outros. Para utilizá-los, é necessário ter os drivers apropriados instalados e adaptar a string de conexão ao formato correspondente.
Caso esteja lidando com um banco de dados online, a string de conexão deve incluir todas as informações necessárias para o login, proporcionando acesso direto.
Para interagir com o banco de dados, é necessário criar uma sessão. A sessão serve para enviar e confirmar as mudanças realizadas, como criação, leitura, atualização e exclusão de dados. Para criar uma sessão, utilizamos a função sessionmaker.
O processo é simples e requer apenas duas etapas: primeiro, instanciamos o sessionmaker, passando a conexão com o banco de dados para o parâmetro bind; depois, carregamos a sessão criada em uma variável, que chamaremos de session.
Esse é o formato padrão para a criação de sessões no SQLAlchemy, permitindo que todas as operações no banco de dados sejam gerenciadas de forma eficiente e segura.
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()No SQLAlchemy, as tabelas são definidas como classes Python, onde cada atributo da classe representa uma coluna da tabela. Essas classes herdam de uma base declarativa fornecida pela biblioteca.
Portanto, para criar uma tabela no banco de dados precisaremos importar a função declarative_base.
Essa base criada servirá como classe-mãe para todas as tabelas que serão definidas no banco de dados.
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base
db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()
Base = declarative_base()Vamos pegar como exemplo o banco de dados para uma biblioteca. Para criar esse banco de dados, precisaremos de no mínimo duas tabelas: Usuários e Livro.
Cada tabela precisará ter colunas que representem os dados que serão armazenados nelas.
A tabela de usuários incluirá as colunas: id, nome, e-mail, senha e ativo (indicando se o usuário está ativo). Já a tabela de livros conterá: id, título, quantidade de páginas e dono (o usuário que possui o livro).
Cada tabela será definida como uma classe Python, e cada instância da classe representará um registro na tabela.
As classes herdarão da Base, e seus nomes estarão no singular, enquanto os nomes das tabelas (definidos com __tablename__) estarão no plural.
Para criar os campos, utilizamos os tipos específicos do SQLAlchemy, como Column (colunas), String (texto), Integer (número inteiro) e Boolean (valores verdadeiro ou falso).
Cada coluna é definida usando a função Column, onde o primeiro parâmetro é o nome do campo e o segundo é seu tipo.
from sqlalchemy import create_engine, Column, String, Integer, Boolean
from sqlalchemy.orm import sessionmaker, declarative_base
db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()
Base = declarative_base()
#Tabelas
class Usuario(Base):
__tablename__ = "usuarios"
id = Column("id", Integer)
nome = Column("nome", String)
email = Column("email", String)
senha = Column("senha", String)
ativo = Column("ativo", Boolean)
# Livros
class Livro(Base):
__tablename__ = "livros"
id = Column("id", Integer)
titulo = Column("titulo", String)
qtde_paginas = Column("qtde_paginas", Integer)
dono = Column("dono", )Por enquanto não preencheremos o campo dono, porque antes precisamos entender sobre relacionamento entre tabelas.
Ao trabalhar com bancos de dados relacionais, é fundamental compreender o conceito de chaves primárias (Primary Keys) e chaves estrangeiras (Foreign Keys).
Essas chaves desempenham um papel fundamental na integridade dos dados e na definição do relacionamento entre tabelas.
A primary key (chave primário) é uma coluna que identifica de forma única cada registro em uma tabela e deve ser única, não nula e imutável:
Na maioria dos casos, a chave primária é representada por um número inteiro que é automaticamente incrementado toda vez que um novo registro é inserido na tabela.
A foreign key (chave estrangeira, por sua vez, é uma coluna em uma tabela que estabelece um vínculo, um relacionamento, com a chave primária de outra tabela.
As chaves estrangeiras são usadas para manter a integridade referencial, garantindo que o valor da chave estrangeira corresponda a um valor existente na tabela referenciada.
Por exemplo, no sistema de biblioteca que estamos desenvolvendo, a coluna id na tabela de usuários será a chave primária. Na tabela de livros, a coluna dono será uma chave estrangeira que faz referência ao campo id da tabela de usuários.
A tabela de livros além de ter uma coluna como chave estrangeira, também pode ter na coluna id, a sua chave primária, que pode ser usada para fazer referência em outras tabelas do sistema e garantindo um identificar único para cada livro.
Definindo a Chave Primária da Tabela de Usuários:
Para criar a chave primária de uma tabela, definimos o parâmetro primary_key como True. Além disso, como esse valor precisa ser incrementado automaticamente, também configuramos o parâmetro autoincrement como True.
Dessa forma, a coluna id da tabela de usuários será a chave primária, única para cada registro e automaticamente incrementada, garantindo que cada usuário tenha um identificador exclusivo.
#Tabelas
class Usuario(Base):
__tablename__ = "usuarios"
id = Column("id", Integer, primary_key=True, autoincrement=True)
nome = Column("nome", String)
email = Column("email", String)
senha = Column("senha", String)
ativo = Column("ativo", Boolean)Definindo a Chave Primária e Estrangeira da Tabela de Livros:
A tabela de livros também terá a coluna id como sua chave primária, assim como fizemos com a tabela de usuários.
Para definir a chave estrangeira, precisamos importar a função ForeignKey e atribuí-la à coluna dono, passando como argumento o nome da tabela e a coluna a qual ela faz referência.
No nosso caso, desejamos vincular o campo dono da tabela de livros com a coluna id da tabela de usuários, então passaremos usuarios.id como argumento.
from sqlalchemy import create_engine, Column, String, Integer, Boolean, ForeignKey
from sqlalchemy.orm import sessionmaker, declarative_base
db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()
Base = declarative_base()
#Tabelas
class Usuario(Base):
__tablename__ = "usuarios"
id = Column("id", Integer, primary_key=True, autoincrement=True)
nome = Column("nome", String)
email = Column("email", String)
senha = Column("senha", String)
ativo = Column("ativo", Boolean)
# Livros
class Livro(Base):
__tablename__ = "livros"
id = Column("id", Integer, primary_key=True, autoincrement=True)
titulo = Column("titulo", String)
qtde_paginas = Column("qtde_paginas", Integer)
dono = Column("dono", ForeignKey("usuarios.id"))Para entender mais sobre os conceitos envolvendo relacionamentos entre tabelas, chaves primárias e estrangeiras, confira a nossa aula: JOIN no SQL: Conceitos e Aplicações (Guia para Iniciantes)
Com os campos das tabelas criados, precisamos definir a função __init__ para inicializar essas classes.
Em Python, a função __init__ é um método especial, também conhecido como construtor de classe. Quando você cria uma nova instância de uma classe, o método __init__ é automaticamente chamado para inicializar o objeto.
Usamos esse método para definir os atributos de um objeto no momento de sua criação.
Dentro das classes de tabelas do SQLAlchemy, esse método facilita a criação de novos registros no banco de dados.
Com o __init__, os objetos podem ser criados de forma direta, passando os atributos necessários como argumentos ao inicializar uma nova instância da classe.
Assim, quando você criar um novo Usuario ou Livro, poderá passar os dados diretamente para o construtor, pois, através da função __init__, ele sabe exatamente quais informações precisa receber.
Para garantir que todos os usuários sejam criados com status ativo por padrão, você pode definir o parâmetro ativo=True na função __init__.
Além disso, o parâmetro id será gerado automaticamente pela classe, portanto não precisará ser declarado na função __init__, evitando que o usuário forneça um id manualmente.
from sqlalchemy import create_engine, Column, String, Integer, Boolean, ForeignKey
from sqlalchemy.orm import sessionmaker, declarative_base
db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()
Base = declarative_base()
# as tabelas
class Usuario(Base):
__tablename__ = "usuarios"
id = Column("id", Integer, primary_key=True, autoincrement=True)
nome = Column("nome", String)
email = Column("email", String)
senha = Column("senha", String)
ativo = Column("ativo", Boolean)
def __init__(self, nome, email, senha, ativo=True):
self.nome = nome
self.email = email
self.senha = senha
self.ativo = ativo
# Livros
class Livro(Base):
__tablename__ = "livros"
id = Column("id", Integer, primary_key=True, autoincrement=True)
titulo = Column("titulo", String)
qtde_paginas = Column("qtde_paginas", Integer)
dono = Column("dono", ForeignKey("usuarios.id"))
def __init__(self, titulo, qtde_paginas, dono):
self.titulo = titulo
self.qtde_paginas = qtde_paginas
self.dono = donoPara saber mais sobre Classes no Python, confira a nossa aula: Classes no Python – Como Sair do Zero
Após definir todas as classes para suas tabelas, o próximo passo é criar as tabelas no banco de dados. Isso pode ser feito executando a função create_all e passando a variável que representa o banco de dados como parâmetro para o argumento bind.
from sqlalchemy import create_engine, Column, String, Integer, Boolean, ForeignKey
from sqlalchemy.orm import sessionmaker, declarative_base
db = create_engine("sqlite:///meubanco.db")
Session = sessionmaker(bind=db)
session = Session()
Base = declarative_base()
# as tabelas
class Usuario(Base):
__tablename__ = "usuarios"
id = Column("id", Integer, primary_key=True, autoincrement=True)
nome = Column("nome", String)
email = Column("email", String)
senha = Column("senha", String)
ativo = Column("ativo", Boolean)
def __init__(self, nome, email, senha, ativo=True):
self.nome = nome
self.email = email
self.senha = senha
self.ativo = ativo
# Livros
class Livro(Base):
__tablename__ = "livros"
id = Column("id", Integer, primary_key=True, autoincrement=True)
titulo = Column("titulo", String)
qtde_paginas = Column("qtde_paginas", Integer)
dono = Column("dono", ForeignKey("usuarios.id"))
def __init__(self, titulo, qtde_paginas, dono):
self.titulo = titulo
self.qtde_paginas = qtde_paginas
self.dono = dono
Base.metadata.create_all(bind=db)Ao executar esse código, você criará o banco de dados e todas as tabelas previamente configuradas.
Para visualizar e manipular o banco de dados, você pode utilizar um aplicativo como o DB Browser for SQLite. Este software gratuito permite visualizar o banco de dados de forma clara e intuitiva. Acesse o site oficial do DB Browser para fazer o download.
Agora que você já sabe como criar o banco de dados, vamos aprender a manipular e editar essas tabelas através das operações CRUD (Create, Read, Update e Delete).
Create (Criar):
Para adicionar um novo registro às suas tabelas, você precisa criar uma instância da classe que representa a tabela e adicionar essa instância à sessão.
Por exemplo, para definir um novo usuário, criamos uma instância da classe Usuario passando os atributos necessários. Em seguida, o usuário criado deve ser adicionado à sessão do banco de dados.
Por fim, para editar o banco, deve-se realizar um commit para salvar as alterações oficialmente.
usuario = Usuario(nome="Lira", email="[email protected]", senha="123123") session.add(usuario) session.commit()
Depois de executar esse código, se você acessar a tabela pelo DB Browser, será possível visualizar o usuário criado.
Read (Ler):
Para buscar informações no banco de dados, você deve realizar uma consulta dentro da sessão. Para isso, Utilizamos o método query() e passamos a tabela que desejamos consultar.
Para obter todos os itens retornados pela consulta, usamos o método .all().
lista_usuarios = session.query(Usuario).all() print(lista_usuarios)
O resultado dessa consulta é uma lista Python, onde podemos acessar e manipular os registros.
Para buscar um usuário específico por e-mail, usamos o método query() seguido de filter_by(), passando o parâmetro desejado.
Obs.: O nome do parâmetro deve corresponder exatamente ao nome dos campos na tabela.
Essa consulta também pode retornar um único item com .first() ou todos os itens correspondentes com .all().
usuario_lira = session.query(Usuario).filter_by(email="[email protected]").first() print(usuario_lira) print(usuario_lira.nome) print(usuario_lira.email)
Observe que podemos acessar as informações do usuário através da estrutura de classes do Python, como usuario.nome e usuario.email.
Agora que temos um usuário no banco de dados e sabemos como acessar suas informações, podemos adicionar um livro a um usuário existente.
livro = Livro(titulo="Nome do Vento", qtde_paginas=1000, dono=usuario_lira.id) session.add(livro) session.commit()
Update (Atualizar):
Para atualizar um registro, primeiro você o busca, altera os atributos desejados e, em seguida, realiza um commit.
usuario_lira.nome = "Joao Lira" session.add(usuario_lira) session.commit()
Delete (Deletar):
Para deletar um registro do banco de dados, basta buscar o dado que deseja remover e utilizar o método delete() para deletá-lo.
session.delete(usuario_lira) session.commit()
O SQLAlchemy facilita muito o trabalho com bancos de dados em Python, eliminando a necessidade de escrever SQL diretamente e permitindo que você trabalhe com classes e objetos Python.
Isso torna o processo mais intuitivo e claro, especialmente se você já está familiarizado com Python.
om essa biblioteca, você pode criar, ler, atualizar e deletar registros de forma eficiente, além de definir relacionamentos entre tabelas. Para aprofundar seus conhecimentos em Python e SQL e se tornar um profissional impressionador nessas áreas, confira os nossos cursos completos:
Para acessar outras publicações de Python, clique aqui!
Posts mais recentes de Python
Posts mais recentes da Hashtag Treinamentos
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.