SQLAlchemy Core - Utilisation des conjonctions

Les conjonctions sont des fonctions du module SQLAlchemy qui implémentent les opérateurs relationnels utilisés dans la clause WHERE des expressions SQL. Les opérateurs AND, OR, NOT, etc. sont utilisés pour former une expression composée combinant deux expressions logiques individuelles. Un exemple simple d'utilisation de AND dans l'instruction SELECT est le suivant:

SELECT * from EMPLOYEE WHERE salary>10000 AND age>30

Les fonctions SQLAlchemy et_ (), or_ () et not_ () implémentent respectivement les opérateurs AND, OR et NOT.

and_ () fonction

Il produit une conjonction d'expressions jointes par AND. Un exemple est donné ci-dessous pour une meilleure compréhension -

from sqlalchemy import and_

print(
   and_(
      students.c.name == 'Ravi',
      students.c.id <3
   )
)

Cela se traduit par -

students.name = :name_1 AND students.id < :id_1

Pour utiliser and_ () dans une construction select () sur une table des étudiants, utilisez la ligne de code suivante -

stmt = select([students]).where(and_(students.c.name == 'Ravi', students.c.id <3))

Une instruction SELECT de la nature suivante sera construite -

SELECT students.id, 
   students.name, 
   students.lastname
FROM students
WHERE students.name = :name_1 AND students.id < :id_1

Le code complet qui affiche la sortie de la requête SELECT ci-dessus est le suivant -

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 ligne suivante sera sélectionnée en supposant que la table des étudiants est remplie avec les données utilisées dans l'exemple précédent -

[(1, 'Ravi', 'Kapoor')]

fonction or_ ()

Il produit une conjonction d'expressions jointes par OR. Nous remplacerons l'objet stmt dans l'exemple ci-dessus par le suivant en utilisant or_ ()

stmt = select([students]).where(or_(students.c.name == 'Ravi', students.c.id <3))

Ce qui sera effectivement équivalent à la requête SELECT suivante -

SELECT students.id, 
   students.name, 
   students.lastname
FROM students
WHERE students.name = :name_1 
OR students.id < :id_1

Une fois que vous faites la substitution et exécutez le code ci-dessus, le résultat sera deux lignes tombant dans la condition OR -

[(1, 'Ravi', 'Kapoor'),
(2, 'Rajiv', 'Khanna')]

fonction asc ()

Il produit une clause ORDER BY ascendante. La fonction prend la colonne pour appliquer la fonction en tant que paramètre.

from sqlalchemy import asc
stmt = select([students]).order_by(asc(students.c.name))

L'instruction implémente l'expression SQL suivante -

SELECT students.id, 
   students.name, 
   students.lastname
FROM students 
ORDER BY students.name ASC

Le code suivant répertorie tous les enregistrements de la table des étudiants dans l'ordre croissant de la colonne de nom -

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)

Le code ci-dessus produit la sortie suivante -

(4, 'Abdul', 'Sattar')
(3, 'Komal', 'Bhandari')
(5, 'Priya', 'Rajhans')
(2, 'Rajiv', 'Khanna')
(1, 'Ravi', 'Kapoor')

fonction desc ()

De même, la fonction desc () produit une clause ORDER BY décroissante comme suit -

from sqlalchemy import desc
stmt = select([students]).order_by(desc(students.c.lastname))

L'expression SQL équivalente est -

SELECT students.id, 
   students.name, 
   students.lastname
FROM students 
ORDER BY students.lastname DESC

Et la sortie pour les lignes de code ci-dessus est -

(4, 'Abdul', 'Sattar')
(5, 'Priya', 'Rajhans')
(2, 'Rajiv', 'Khanna')
(1, 'Ravi', 'Kapoor')
(3, 'Komal', 'Bhandari')

fonction entre ()

Il produit une clause de prédicat BETWEEN. Ceci est généralement utilisé pour valider si la valeur d'une certaine colonne se situe entre une plage. Par exemple, le code suivant sélectionne les lignes pour lesquelles la colonne id est comprise entre 2 et 4 -

from sqlalchemy import between
stmt = select([students]).where(between(students.c.id,2,4))
print (stmt)

L'expression SQL résultante ressemble à -

SELECT students.id, 
   students.name, 
   students.lastname
FROM students
WHERE students.id 
BETWEEN :id_1 AND :id_2

et le résultat est le suivant -

(2, 'Rajiv', 'Khanna')
(3, 'Komal', 'Bhandari')
(4, 'Abdul', 'Sattar')