Tudo o que você precisa saber sobre Python e mapas relacionais de objetos

Tudo o que você precisa saber sobre Python e mapas relacionais de objetos

Você pode ter ouvido falar de mapeamento objeto-relacional (ORM). Você pode até ter usado um, mas o que exatamente são? E como você os usa em Python?





Aqui está tudo o que você precisa saber sobre ORMs e Python.



O que é um ORM?

Mapeamento objeto-relacional (ORM) é uma técnica de programação usada para acessar um banco de dados. Ele expõe seu banco de dados em uma série de objetos. Você não precisa escrever comandos SQL para inserir ou recuperar dados, você usa uma série de atributos e métodos anexados a objetos.





Pode parecer complexo e desnecessário, mas eles podem economizar muito tempo e ajudar a controlar o acesso ao seu banco de dados.

Aqui está um exemplo. Digamos que sempre que você inserir uma senha em seu banco de dados, você queira fazer um hash, conforme explicado em segurança de senhas de sites. Isso não é um problema para casos de uso simples - você faz o cálculo antes de inserir. Mas e se você precisar inserir um registro em vários lugares do código? E se outro programador inserir em sua tabela e você não souber?



Usando um ORM, você pode escrever código para garantir que, sempre e onde qualquer linha ou campo em seu banco de dados for acessado, seu outro código personalizado seja executado primeiro.

Isso também atua como uma 'fonte única de verdade'. Se quiser alterar um cálculo personalizado, você só precisa alterá-lo em um lugar, não em vários. É possível realizar muitos desses princípios com programação orientada a objetos (OOP) em Python , mas os ORMs trabalham em conjunto com os princípios OOP para controlar o acesso a um banco de dados.



Há certas coisas a serem observadas ao usar um ORM, e há circunstâncias em que você pode não querer usar um, mas geralmente é considerado bom ter, especialmente em uma grande base de código.

ORMs em Python usando SQLAlchemy

Como muitas tarefas em Python, é mais rápido e fácil importar um módulo do que escrever o seu próprio. Claro, é possível escrever seu próprio ORM, mas por que reinventar a roda?



Todos os exemplos a seguir usam SQLAlchemy , um Python ORM popular, mas muitos dos princípios se aplicam independentemente da implementação.

Configurando Python para SQLAlchemy

Antes de começar, você precisará configurar sua máquina para desenvolvimento Python com SQLAlchemy.

Você precisará usar o Python 3.6 para acompanhar esses exemplos. Embora as versões mais antigas funcionem, o código abaixo precisará de algumas modificações antes de ser executado. Não tem certeza das diferenças? Nosso FAQ do Python cobre todas as diferenças.

Antes de codificar, você deve configurar um ambiente Python, o que evitará problemas com outros pacotes Python importados.

Assegure-se de ter PIP, o gerenciador de pacotes Python instalado, que vem com a maioria das versões modernas do Python.

Quando estiver pronto para começar, você pode começar preparando o SQLAlchemy. De dentro de seu ambiente Python na linha de comando, instale SQLAlchemy com o pip install comando:

pip install SQLAlchemy-1.2.9

o 1.2.9 é o número da versão. Você pode deixar isso de fora para obter o pacote mais recente, mas é uma boa prática ser específico. Você não sabe quando uma nova versão pode quebrar seu código atual.

Agora você está pronto para começar a codificar. Você pode precisar preparar seu banco de dados para aceitar uma conexão Python, mas todos os exemplos a seguir usam um SQLite banco de dados criado na memória abaixo.

Modelos em SQLAlchemy

Um dos principais componentes de um ORM é um modelo . Esta é uma classe Python que descreve a aparência de uma tabela e como ela deve funcionar. É a versão ORM do CRIAR A TABELA declaração em SQL. Você precisa de um modelo para cada tabela em seu banco de dados.

Abra seu editor de texto ou IDE favorito e crie um novo arquivo chamado test.py . Insira este código inicial, salve o arquivo e execute-o:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
engine = create_engine('sqlite://') # Create the database in memory
Base.metadata.create_all(engine) # Create all the tables in the database

Este código faz várias coisas. As importações são necessárias para que o Python entenda onde encontrar os módulos SQLAlchemy de que precisa. Seus modelos usarão o declarative_base mais tarde, e configura todos os novos modelos para funcionar conforme o esperado.

o create_engine método cria uma nova conexão com seu banco de dados. Se você já tiver um banco de dados, você precisará alterar sqlite: // para o URI do seu banco de dados. Do jeito que está, esse código criará um novo banco de dados apenas na memória. O banco de dados é destruído quando seu código termina de ser executado.

finalmente, o create_all método cria todas as tabelas definidas em seus modos em seu banco de dados. Como você ainda não definiu nenhum modelo, nada acontecerá. Vá em frente e execute este código, para garantir que você não tenha problemas ou erros de digitação.

Vamos fazer um modelo. Adicione outra importação ao topo do seu arquivo:

from sqlalchemy import Column, Integer, String

Isso importa o Coluna , Inteiro , e Fragmento módulos de SQLAlchemy. Eles definem como as tabelas, campos, colunas e tipos de dados do banco de dados funcionam.

Embaixo do declarative_base , crie sua classe de modelo:

class Cars(Base):
__tablename__ = 'cars'
id = Column(Integer, primary_key=True)
make = Column(String(50), nullable=False)
color = Column(String(50), nullable=False)

Este exemplo simples usa carros, mas suas tabelas podem conter quaisquer dados.

Cada classe deve herdar Base . O nome da tabela do seu banco de dados é definido em __Nome da tabela__ . Deve ser igual ao nome da classe, mas é apenas uma recomendação e nada será interrompido se eles não corresponderem.

Finalmente, cada coluna é definida como uma variável python dentro da classe. Diferentes tipos de dados são usados, e o chave primária atributo diz ao SQLAlchemy para criar o Eu iria coluna como uma chave primária.

Vá em frente e adicione uma última importação, desta vez para o ForeignKey módulo. Adicione isto ao lado do seu Coluna importar:

from sqlalchemy import Column, ForeignKey, Integer, String

Agora crie uma segunda classe de modelo. Esta classe é chamada CarOwners , e armazena detalhes do proprietário de carros específicos armazenados no Carros tabela:

class CarOwners(Base):
__tablename__ = 'carowners'
id = Column(Integer, primary_key=True)
name = Column(String(50), nullable=False)
age = Column(Integer, nullable=False)
car_id = Column(Integer, ForeignKey('cars.id'))
car = relationship(Cars)

Existem vários novos atributos introduzidos aqui. o car_id campo é definido como uma chave estrangeira. Está ligado ao Eu iria no carros tabela. Observe como o nome da tabela em minúsculas é usado, em vez do nome da classe em maiúsculas.

Finalmente, um atributo de carro é definido como um relação . Isso permite que seu modelo acesse o Carros tabela através desta variável. Isso é demonstrado abaixo.

Se você executar este código agora, verá que nada acontece. Isso ocorre porque você não disse a ele para fazer nada perceptível ainda.

Objetos em SQLAlchemy

Agora que seus modelos foram criados, você pode começar a acessar os objetos e ler e gravar dados. É uma boa ideia colocar sua lógica em sua própria classe e arquivo, mas por enquanto, ela pode ficar ao lado dos modelos.

Gravando dados

Neste exemplo, você precisa inserir alguns dados no banco de dados antes de lê-los. Se você estiver usando um banco de dados existente, talvez já tenha dados. De qualquer forma, ainda é muito útil saber como inserir dados.

Você pode estar acostumado a escrever INSERIR instruções em SQL. SQLAlchemy cuida disso para você. Veja como inserir uma linha no Carros modelo. Comece com uma nova importação para criador de sessões :

from sqlalchemy.orm import sessionmaker

Isso é necessário para criar o sessão e DBSession objetos, que são usados ​​para ler e gravar dados:

DBSession = sessionmaker(bind=engine)
session = DBSession()

Agora coloque isso embaixo do seu create_all demonstração:

car1 = Cars(
make='Ford',
color='silver'
)
session.add(car1)
session.commit()

Vamos analisar esse código. A variável car1 é definido como um objeto com base no Carros modelo. Sua marca e cor são definidas como parâmetros. Isso é como dizer 'faça para mim um carro, mas não grave ainda no banco de dados'. Este carro existe na memória, mas está esperando para ser escrito.

Adicione o carro à sessão com session.add e, em seguida, grave-o no banco de dados com session.commit .

Agora vamos adicionar um proprietário:

owner1 = CarOwners(
name='Joe',
age='99',
car_id=(car1.id)
)
session.add(owner1)
session.commit()

Este código é quase idêntico ao da inserção anterior para o Carros modelo. A principal diferença aqui é que car_id é uma chave estrangeira, portanto, precisa de um ID de linha que existe na outra tabela. Isso é acessado por meio do car1.id propriedade.

Você não precisa consultar o banco de dados ou retornar quaisquer ids, já que o SQLAlchemy faz isso para você (contanto que você confirme os dados primeiro).

Lendo Dados

Depois de escrever alguns dados, você pode começar a lê-los de volta. Veja como consultar o Carros e CarOwners mesas:

result = session.query(Cars).all()

É simples assim. Usando o consulta método encontrado no sessão , você especifica o modelo e, em seguida, usa o tudo método para recuperar todos os resultados. Se você sabe que haverá apenas um resultado, você pode usar o primeiro método:

result = session.query(Cars).first()

Depois de consultar o modelo e armazenar os resultados retornados em uma variável, você pode acessar os dados por meio do objeto:

print(result[0].color)

Isso imprime a cor 'prata', pois esse registro é a primeira linha. Você pode fazer um loop sobre o objeto de resultado se desejar.

Conforme você definiu o relacionamento em seu modelo, é possível acessar dados em tabelas relacionadas sem especificar uma junção:

result = session.query(CarOwners).all()
print(result[0].name)
print(result[0].car.color)

Isso funciona porque seu modelo contém detalhes de sua estrutura de tabela, e o carro atributo foi definido como um link para o carros tabela.

O que há para não gostar nos ORMs?

Este tutorial cobriu apenas o básico, mas depois que você pegar o jeito deles, poderá seguir para os tópicos avançados. Existem algumas desvantagens potenciais para ORMs:

  • Você deve escrever seu modelo antes que qualquer consulta possa ser executada.
  • É outra nova sintaxe para aprender.
  • Pode ser muito complexo para necessidades simples.
  • Você deve ter um bom design de banco de dados para começar.

Esses problemas não são um grande problema por si só, mas são coisas a serem observadas. Se você estiver trabalhando com um banco de dados existente, pode ser pego.

Se você não está convencido de que um ORM é a ferramenta certa para você, certifique-se de ler sobre o comandos SQL importantes que os programadores devem saber .

Compartilhado Compartilhado Tweet O email Você deve atualizar para o Windows 11 imediatamente?

O Windows 11 estará disponível em breve, mas você deve atualizar o mais rápido possível ou esperar algumas semanas? Vamos descobrir.

Leia a seguir Tópicos relacionados
  • Programação
  • Pitão
  • SQL
  • Tutoriais de codificação
Sobre o autor Joe Coburn(136 artigos publicados)

Joe é graduado em Ciência da Computação pela University of Lincoln, no Reino Unido. Ele é um desenvolvedor de software profissional e, quando não está pilotando drones ou escrevendo música, pode ser encontrado tirando fotos ou produzindo vídeos.

o que é bixby no meu telefone
Mais de Joe Coburn

Assine a nossa newsletter

Junte-se ao nosso boletim informativo para dicas de tecnologia, análises, e-books grátis e ofertas exclusivas!

Clique aqui para se inscrever