Alquimia SQL

SQLAlchemy es una biblioteca Python de código abierto que proporciona un conjunto de herramientas SQL (denominado "SQLAlchemy Core") y un mapeador relacional de objetos (ORM) para interacciones con bases de datos. Permite a los desarrolladores trabajar con bases de datos utilizando objetos Python, lo que permite un acceso eficiente y flexible a las bases de datos.

SQLAlchemy ofrece herramientas para la generación de esquemas de bases de datos, consultas y mapeo de objetos relacionales. Las características principales incluyen:

• Un lenguaje integral integrado específico de dominio para SQL en Python llamado "SQLAlchemy Core" que proporciona medios para construir y ejecutar consultas SQL.
• Un ORM potente que permite el mapeo de clases de Python a tablas de bases de datos.
• Soporte para migraciones de esquemas de bases de datos.
• Compatibilidad con múltiples backends de bases de datos.
• Herramientas para la agrupación de conexiones de bases de datos y la gestión de transacciones.

SQLAlchemy se lanzó por primera vez en febrero de 2006. Ha evolucionado para incluir una amplia gama de funciones para la interacción con bases de datos y ha ganado popularidad entre los desarrolladores de Python. Las versiones más destacadas incluyen:

• Versión 0.1 (2006): ^[5] Versión inicial.
• Versión 1.0 (2015): ^[6] Mejoras importantes en el lenguaje de expresiones ORM y SQL.
• Versión 1.4 (2021): ^[7] Introducción de una nueva API ORM.

El siguiente ejemplo representa una relación n a 1 entre películas y sus directores. Se muestra cómo las clases de Python definidas por el usuario crean las tablas de bases de datos correspondientes, cómo se crean instancias con relaciones desde ambos lados de la relación y, por último, cómo se pueden consultar los datos, lo que ilustra las consultas SQL generadas automáticamente tanto para la carga diferida como para la carga ansiosa.

Creación de dos clases de Python y las tablas de base de datos correspondientes en el DBMS:

desde  sqlalchemy  importar  * 
desde  sqlalchemy.ext.declarative  importar  declarative_base 
desde  sqlalchemy.orm  importar  relación ,  sessionmaker

Base  =  base_declarativa ()

clase  Película ( Base ): 
    __tablename__  =  "películas"

    id  =  Columna ( Entero ,  clave_principal = Verdadero ) 
    título  =  Columna ( Cadena ( 255 ),  que acepta valores null = Falso ) 
    año  =  Columna ( Entero ) 
    dirigido_por  =  Columna ( Entero ,  Clave_externa ( "directors.id" ))

    director  =  relación ( "Director" ,  backref = "películas" ,  lazy = False )

    def  __init__ ( self ,  título = None ,  año = None ): 
        self . título  =  título 
        self . año  =  año

    def  __repr__ ( self ): 
        return  f "Película( { self . título } , { self . año } , { self . director } )"

clase  Director ( Base ): 
    __tablename__  =  "directores"

    id  =  Columna ( Entero ,  clave principal = Verdadero ) 
    nombre  =  Columna ( Cadena ( 50 ),  nulo = Falso ,  único = Verdadero )

    def  __init __ ( self ,  nombre = None ) 
        : self.nombre = nombre  

    def  __repr __ ( self ): 
        return  f "Director( { self.name } ) "

motor  =  crear_motor ( " dbms :// usuario : contraseña @ host/nombre_base" ) 
Base.metadatos.crear_todos ( motor )

Se puede insertar una relación director-película a través de cualquiera de las entidades:

Sesión  =  sessionmaker ( bind = motor ) 
sesión  =  Session ()

m1  =  Película ( "Robocop" ,  1987 ) 
m1 . director  =  Director ( "Paul Verhoeven" )

d2  =  Director ( "George Lucas" ) 
d2 . películas  =  [ Película ( "Star Wars" ,  1977 ),  Película ( "THX 1138" ,  1971 )]

intentar : 
    sesión.add ( m1 ) sesión.add ( d2 ) sesión.commit ( ) excepto : sesión.rollback ( )​​​​​​
    
    

    

alldata  =  session . query ( Movie ) . all () 
para  somedata  en  alldata : 
    print ( somedata )

SQLAlchemy emite la siguiente consulta al DBMS (omitiendo los alias):

SELECCIONAR películas . id , películas . título , películas . año , películas . dirigido_por , directores . id , directores . nombre DE películas UNIÓN EXTERNA IZQUIERDA directores EN directores . id = películas . dirigido_por      
         

La salida:

Película ( 'Robocop' ,  1987 L ,  Director ( 'Paul Verhoeven' )) 
Película ( 'Star Wars' ,  1977 L ,  Director ( 'George Lucas' )) 
Película ( 'THX 1138' ,  1971 L ,  Director ( 'George Lucas' ))

En cambio, si se configura lazy=True(por defecto), SQLAlchemy primero emitiría una consulta para obtener la lista de películas y solo cuando sea necesario (de forma diferida) para cada director, una consulta para obtener el nombre del director correspondiente:

SELECCIONAR películas . id , películas . título , películas . año , películas . dirigido_por DE películas    
 

SELECCIONAR directores . id , directores . nombre DE directores DONDE directores . id = % s  
 
   

• Objeto SQL
• Tormenta
• Pilones
• TurboGears
• Cubos (servidor OLAP)

Notas

• Gift, Noah (12 de agosto de 2008). "Usando SQLAlchemy". Developerworks . IBM . Consultado el 8 de febrero de 2011 .
• Rick Copeland, SQLAlchemy esencial, O'Reilly , 2008, ISBN 0-596-51614-2