SQLAlchemy Core - Verwenden von Konjunktionen

Konjunktionen sind Funktionen im SQLAlchemy-Modul, die relationale Operatoren implementieren, die in der WHERE-Klausel von SQL-Ausdrücken verwendet werden. Die Operatoren AND, OR, NOT usw. werden verwendet, um einen zusammengesetzten Ausdruck zu bilden, der zwei einzelne logische Ausdrücke kombiniert. Ein einfaches Beispiel für die Verwendung von AND in der SELECT-Anweisung lautet wie folgt:

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

SQLAlchemy-Funktionen und_ (), oder_ () und not_ () implementieren jeweils AND-, OR- und NOT-Operatoren.

und_ () Funktion

Es erzeugt eine Konjunktion von Ausdrücken, die durch UND verbunden sind. Ein Beispiel ist unten zum besseren Verständnis angegeben -

from sqlalchemy import and_

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

Dies bedeutet -

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

Verwenden Sie die folgende Codezeile, um and_ () in einem select () -Konstrukt in einer Schülertabelle zu verwenden:

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

Die SELECT-Anweisung der folgenden Art wird erstellt:

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

Der vollständige Code, der die Ausgabe der obigen SELECT-Abfrage anzeigt, lautet wie folgt:

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())

Die folgende Zeile wird unter der Annahme ausgewählt, dass die Schülertabelle mit den im vorherigen Beispiel verwendeten Daten gefüllt ist.

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

or_ () Funktion

Es erzeugt eine Konjunktion von Ausdrücken, die durch ODER verbunden sind. Wir werden das stmt-Objekt im obigen Beispiel durch das folgende mit or_ () ersetzen.

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

Was effektiv der folgenden SELECT-Abfrage entspricht -

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

Sobald Sie die Ersetzung vorgenommen und den obigen Code ausgeführt haben, werden zwei Zeilen in die ODER-Bedingung fallen.

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

asc () Funktion

Es wird eine aufsteigende ORDER BY-Klausel erzeugt. Die Funktion verwendet die Spalte, um die Funktion als Parameter anzuwenden.

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

Die Anweisung implementiert den folgenden SQL-Ausdruck:

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

Der folgende Code listet alle Datensätze in der Schülertabelle in aufsteigender Reihenfolge der Namensspalte auf -

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)

Der obige Code erzeugt folgende Ausgabe -

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

desc () Funktion

In ähnlicher Weise erzeugt die Funktion desc () eine absteigende ORDER BY-Klausel wie folgt:

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

Der entsprechende SQL-Ausdruck lautet -

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

Und die Ausgabe für die obigen Codezeilen ist -

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

zwischen () Funktion

Es wird eine ZWISCHEN Prädikatklausel erzeugt. Dies wird im Allgemeinen verwendet, um zu überprüfen, ob der Wert einer bestimmten Spalte zwischen einem Bereich liegt. Mit dem folgenden Code werden beispielsweise Zeilen ausgewählt, für die die ID-Spalte zwischen 2 und 4 liegt.

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

Der resultierende SQL-Ausdruck ähnelt -

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

und das Ergebnis ist wie folgt -

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