SQLAlchemy Core - używanie koniunkcji

Koniunkcje to funkcje w module SQLAlchemy, które implementują operatory relacyjne używane w klauzuli WHERE wyrażeń SQL. Operatory AND, OR, NOT itd. Służą do tworzenia wyrażenia złożonego łączącego dwa pojedyncze wyrażenia logiczne. Prosty przykład użycia AND w instrukcji SELECT jest następujący -

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

Funkcje SQLAlchemy i_ (), or_ () i not_ () odpowiednio implementują operatory AND, OR i NOT.

and_ () funkcja

Tworzy koniunkcję wyrażeń połączonych AND. Poniżej podano przykład dla lepszego zrozumienia -

from sqlalchemy import and_

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

To przekłada się na -

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

Aby użyć and_ () w konstrukcji select () w tabeli uczniów, użyj następującego wiersza kodu -

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

Zostanie skonstruowana instrukcja SELECT o następującym charakterze -

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

Pełny kod, który wyświetla dane wyjściowe powyższego zapytania SELECT, jest następujący:

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

Następny wiersz zostanie wybrany przy założeniu, że tabela uczniów jest wypełniona danymi używanymi w poprzednim przykładzie -

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

funkcja or_ ()

Tworzy koniunkcję wyrażeń połączonych OR. Zastąpimy obiekt stmt w powyższym przykładzie następującym za pomocą or_ ()

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

Który będzie efektywnie równoważny z następującym zapytaniem SELECT -

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

Po dokonaniu podstawienia i uruchomieniu powyższego kodu wynik będą dwa wiersze mieszczące się w warunku LUB -

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

funkcja asc ()

Tworzy rosnącą klauzulę ORDER BY. Funkcja przyjmuje kolumnę, aby zastosować funkcję jako parametr.

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

Instrukcja implementuje następujące wyrażenie SQL -

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

Poniższy kod wymienia wszystkie rekordy w tabeli uczniów w rosnącej kolejności według kolumny nazw -

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)

Powyższy kod daje następujące dane wyjściowe -

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

desc (), funkcja

Podobnie funkcja desc () generuje malejącą klauzulę ORDER BY w następujący sposób -

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

Równoważne wyrażenie SQL to -

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

Wynik dla powyższych wierszy kodu to -

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

between () funkcja

Tworzy klauzulę predykatu BETWEEN. Jest to zwykle używane do sprawdzania, czy wartość określonej kolumny mieści się w zakresie. Na przykład poniższy kod wybiera wiersze, dla których kolumna id zawiera się w przedziale od 2 do 4 -

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

Wynikowe wyrażenie SQL przypomina -

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

a wynik jest następujący -

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