SQLAlchemy Core: uso de conjunciones
Las conjunciones son funciones en el módulo SQLAlchemy que implementan operadores relacionales usados en la cláusula WHERE de expresiones SQL. Los operadores Y, O, NO, etc., se utilizan para formar una expresión compuesta que combina dos expresiones lógicas individuales. Un ejemplo simple del uso de AND en la instrucción SELECT es el siguiente:
SELECT * from EMPLOYEE WHERE salary>10000 AND age>30
Las funciones de SQLAlchemy y_ (), or_ () y not_ () implementan operadores AND, OR y NOT respectivamente.
función and_ ()
Produce una conjunción de expresiones unidas por AND. A continuación se ofrece un ejemplo para una mejor comprensión:
from sqlalchemy import and_
print(
and_(
students.c.name == 'Ravi',
students.c.id <3
)
)
Esto se traduce en:
students.name = :name_1 AND students.id < :id_1
Para usar and_ () en una construcción select () en una tabla de estudiantes, use la siguiente línea de código:
stmt = select([students]).where(and_(students.c.name == 'Ravi', students.c.id <3))
Se construirá la declaración SELECT de la siguiente naturaleza:
SELECT students.id,
students.name,
students.lastname
FROM students
WHERE students.name = :name_1 AND students.id < :id_1
El código completo que muestra el resultado de la consulta SELECT anterior es el siguiente:
from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, ForeignKey, select
engine = create_engine('sqlite:///college.db', echo = True)
meta = MetaData()
conn = engine.connect()
students = Table(
'students', meta,
Column('id', Integer, primary_key = True),
Column('name', String),
Column('lastname', String),
)
from sqlalchemy import and_, or_
stmt = select([students]).where(and_(students.c.name == 'Ravi', students.c.id <3))
result = conn.execute(stmt)
print (result.fetchall())
La siguiente fila se seleccionará asumiendo que la tabla de estudiantes se completa con los datos utilizados en el ejemplo anterior:
[(1, 'Ravi', 'Kapoor')]
función or_ ()
Produce conjunción de expresiones unidas por OR. Reemplazaremos el objeto stmt en el ejemplo anterior con el siguiente usando or_ ()
stmt = select([students]).where(or_(students.c.name == 'Ravi', students.c.id <3))
Lo que será efectivamente equivalente a seguir la consulta SELECT -
SELECT students.id,
students.name,
students.lastname
FROM students
WHERE students.name = :name_1
OR students.id < :id_1
Una vez que realice la sustitución y ejecute el código anterior, el resultado serán dos filas que caen en la condición OR:
[(1, 'Ravi', 'Kapoor'),
(2, 'Rajiv', 'Khanna')]
función asc ()
Produce una cláusula ORDER BY ascendente. La función toma la columna para aplicar la función como parámetro.
from sqlalchemy import asc
stmt = select([students]).order_by(asc(students.c.name))
La declaración implementa la siguiente expresión SQL:
SELECT students.id,
students.name,
students.lastname
FROM students
ORDER BY students.name ASC
El siguiente código enumera todos los registros en la tabla de estudiantes en orden ascendente de columna de nombre:
from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, ForeignKey, select
engine = create_engine('sqlite:///college.db', echo = True)
meta = MetaData()
conn = engine.connect()
students = Table(
'students', meta,
Column('id', Integer, primary_key = True),
Column('name', String),
Column('lastname', String),
)
from sqlalchemy import asc
stmt = select([students]).order_by(asc(students.c.name))
result = conn.execute(stmt)
for row in result:
print (row)
El código anterior produce la siguiente salida:
(4, 'Abdul', 'Sattar')
(3, 'Komal', 'Bhandari')
(5, 'Priya', 'Rajhans')
(2, 'Rajiv', 'Khanna')
(1, 'Ravi', 'Kapoor')
función desc ()
De manera similar, la función desc () produce una cláusula ORDER BY descendente de la siguiente manera:
from sqlalchemy import desc
stmt = select([students]).order_by(desc(students.c.lastname))
La expresión SQL equivalente es -
SELECT students.id,
students.name,
students.lastname
FROM students
ORDER BY students.lastname DESC
Y el resultado de las líneas de código anteriores es:
(4, 'Abdul', 'Sattar')
(5, 'Priya', 'Rajhans')
(2, 'Rajiv', 'Khanna')
(1, 'Ravi', 'Kapoor')
(3, 'Komal', 'Bhandari')
entre () función
Produce una cláusula de predicado BETWEEN. Esto se usa generalmente para validar si el valor de una determinada columna se encuentra entre un rango. Por ejemplo, el siguiente código selecciona filas para las que la columna de identificación está entre 2 y 4:
from sqlalchemy import between
stmt = select([students]).where(between(students.c.id,2,4))
print (stmt)
La expresión SQL resultante se parece a:
SELECT students.id,
students.name,
students.lastname
FROM students
WHERE students.id
BETWEEN :id_1 AND :id_2
y el resultado es el siguiente:
(2, 'Rajiv', 'Khanna')
(3, 'Komal', 'Bhandari')
(4, 'Abdul', 'Sattar')