SQLAlchemy ORM – Declaración de asignación

En este artículo, veremos cómo declarar el mapeo usando SQLAlchemy en Python.

Necesitará una base de datos (MySQL, PostgreSQL, SQLite, etc.) para trabajar. Como vamos a usar MySQL en esta publicación, también instalaremos un conector SQL para MySQL en Python. Sin embargo, ninguna de las implementaciones de código cambia con el cambio en la base de datos, excepto los conectores SQL.

pip install pymysql

Usaremos la base de datos sakila de muestra de MySQL. En este artículo, cubriremos 2 ejemplos. En ambos ejemplos, declararemos el mapeo para la tabla de actores dentro de la base de datos sakila. Si no tiene la base de datos sakila y desea seguir este artículo sin instalarlo, use el script SQL presente en el enlace que se menciona a continuación para crear el esquema requerido y la tabla de actores junto con los registros.

Base de datos utilizada: Sakila Actor Table Script

La consulta SQL que estamos viendo en los dos ejemplos siguientes es:

SELECT COUNT(*) FROM sakila.`actor`;

SQLAlchemy Core utiliza una vista centrada en objetos que encapsula el esquema con objetos comerciales. Es una implementación más pythonica donde las tablas se mapean usando clases orientadas a objetos en python. En SQLAlchemy, hay 2 formas diferentes en las que podemos declarar las configuraciones del mapeador, a saber, Declarativa y Clásica/Imperativa. El estilo » Clásico » o » Imperativo » es la API de mapeo original de SQLAlchemy, mientras que » Declarativo » es el sistema más rico y sucinto que se basa en «Clásico». Veamos cómo podemos declarar el mapeo usando ambas formas.

Mapeo declarativo:

Para el siguiente ejemplo, hemos utilizado el mapeo declarativo. En esto, creamos una clase Actor que hereda de un método `declarative_base()`. Luego proporcionamos el nombre de la tabla y el nombre del esquema como se menciona en el ejemplo. Tenga en cuenta que es posible que el nombre del esquema no sea necesario en las bases de datos MySQL (ya que el nombre de la base de datos y el esquema son eventualmente los mismos en MySQL), pero puede ser una configuración útil para la base de datos PostgreSQL donde el esquema y las bases de datos son distintos. Hemos mapeado la tabla `actor` de la base de datos sakila usando la clase `Actor`. Para probar si nuestro mapeo funciona o no, creamos una conexión de motor sqlalchemy, y usando esta conexión consultamos la base de datos usando el método ORM de SQLAlchemy. En el ejemplo proporcionado, estamos obteniendo el recuento de registros en la tabla `actor`. También podemos mirar el tipo de datos de la clase `Actor`; representa el objeto ORM de SQLAlchemy.

from sqlalchemy.orm import sessionmaker
import sqlalchemy as db
from sqlalchemy.ext.declarative import declarative_base
  
  
Base = declarative_base()
  
# MAPPING CLASS ACTOR USING DECLARATIVE MAPPING
  
  
class Actor(Base):
  
    __table_args__ = {'schema': 'sakila'}
    __tablename__ = 'actor'
  
    actor_id = db.Column(db.SmallInteger, autoincrement=True, primary_key=True)
    first_name = db.Column(db.String(45), nullable=False)
    first_name = db.Column(db.String(45), nullable=False)
    last_update = db.Column(db.TIMESTAMP, nullable=False, server_default=db.text(
        'CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'))
  
  
# DEFINE THE ENGINE (CONNECTION OBJECT)
engine = db.create_engine("mysql+pymysql://root:password@localhost/sakila")
  
# CREATE A SESSION OBJECT TO INITIATE QUERY IN DATABASE
Session = sessionmaker(bind=engine)
session = Session()
  
# SELECT COUNT(*) FROM Actor
result = session.query(Actor).count()
  
print("Count of Records in Actor Table:", result)
print("Type of Actor Class:", type(Actor))

Producción:

Count of Records in Actor Table: 200
Type of Actor Class: <class 'sqlalchemy.orm.decl_api.DeclarativeMeta'>

Mapeo clásico/imperativo:

La asignación declarativa que se muestra en el primer ejemplo se basa en la asignación clásica o imperativa. El mapeo imperativo usa el método Core de SQLAlchemy para definir las bases de datos y luego usa el método `mapper()` de SQLAlchemy ORM para que el mapeo comience con el objeto de registro ORM, que mantiene un conjunto de clases que se asignan (al igual que el mapeo declarativo) . Puede comparar ambos ejemplos para darse cuenta de que una vez que hayamos creado estos objetos mapeadores, podemos usar la misma sintaxis ORM para consultar la base de datos. En este ejemplo, estamos recuperando nuevamente el número de registros de la tabla `actor` presente en la base de datos `sakila`. Vale la pena que en este ejemplo también la clase `Actor` represente el objeto ORM de SQLAlchemy.

from sqlalchemy.orm import sessionmaker
import sqlalchemy as db
from sqlalchemy.orm import mapper
  
# CREATE THE METADATA OBJECT REQUIRED TO CREATE THE TABLE
metadata = db.MetaData()
  
# DEFINE THE ACTOR TABLE USING SQLALCHEMY CORE
actor = db.Table(
    'actor',
    metadata,
    db.Column('actor_id', db.SmallInteger,
              autoincrement=True, primary_key=True),
    db.Column('first_name', db.String(45), nullable=False),
    db.Column('last_name', db.String(45), nullable=False),
    db.Column('last_update', db.TIMESTAMP, nullable=False, server_default=db.text(
        'CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'))
)
  
# MAPPING CLASS ACTOR USING CLASSICAL MAPPING
  
  
class Actor(object):
  
    def __init__(self, first_name, last_name) -> None:
        self.first_name = first_name
        self.last_name = last_name
  
  
mapper(Actor, actor)
  
# DEFINE THE ENGINE (CONNECTION OBJECT)
engine = db.create_engine("mysql+pymysql://root:password@localhost/sakila")
  
# CREATE A SESSION OBJECT TO INITIATE QUERY IN DATABASE
Session = sessionmaker(bind=engine)
session = Session()
  
# SELECT COUNT(*) FROM Actor
result = session.query(Actor).count()
  
print("Count of Records in Actor Table:", result)
print("Type of Actor Class:", type(Actor))

Producción:

Count of Records in Actor Table: 200
Type of Actor Class: <class 'sqlalchemy.orm.decl_api.DeclarativeMeta'>