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:
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:
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 , sessionmakerBase = 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 .svg/1280px-Free_and_open-source_software_logo_(2009).svg.png){kind=logo}