SQLAlchemy Core - Utilizzo delle congiunzioni

Le congiunzioni sono funzioni nel modulo SQLAlchemy che implementano operatori relazionali utilizzati nella clausola WHERE delle espressioni SQL. Gli operatori AND, OR, NOT, ecc. Vengono utilizzati per formare un'espressione composta che combina due espressioni logiche individuali. Un semplice esempio di utilizzo di AND nell'istruzione SELECT è il seguente:

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

Le funzioni SQLAlchemy e_ (), or_ () e not_ () implementano rispettivamente gli operatori AND, OR e NOT.

and_ () funzione

Produce una congiunzione di espressioni unite da AND. Di seguito viene fornito un esempio per una migliore comprensione:

from sqlalchemy import and_

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

Questo si traduce in -

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

Per utilizzare and_ () in un costrutto select () su una tabella studenti, utilizzare la seguente riga di codice:

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

Verrà costruita un'istruzione SELECT della seguente natura:

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

Il codice completo che visualizza l'output della query SELECT sopra è il seguente:

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 riga seguente verrà selezionata supponendo che la tabella degli studenti sia popolata con i dati utilizzati nell'esempio precedente:

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

or_ () funzione

Produce congiunzione di espressioni unite da OR. Sostituiremo l'oggetto stmt nell'esempio sopra con il seguente usando or_ ()

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

Che sarà effettivamente equivalente alla seguente query SELECT -

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

Una volta effettuata la sostituzione ed eseguito il codice sopra, il risultato saranno due righe che cadono nella condizione OR -

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

funzione asc ()

Produce una clausola ORDER BY crescente. La funzione accetta la colonna per applicare la funzione come parametro.

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

L'istruzione implementa la seguente espressione SQL:

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

Il codice seguente elenca tutti i record nella tabella degli studenti in ordine crescente della colonna del nome -

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)

Il codice sopra produce il seguente output:

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

funzione desc ()

Allo stesso modo la funzione desc () produce la clausola ORDER BY decrescente come segue:

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

L'espressione SQL equivalente è -

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

E l'output per le righe di codice sopra è -

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

funzione tra ()

Produce una clausola di predicato BETWEEN. Viene generalmente utilizzato per convalidare se il valore di una determinata colonna rientra in un intervallo. Ad esempio, il codice seguente seleziona le righe per le quali la colonna id è compresa tra 2 e 4 -

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

L'espressione SQL risultante è simile a:

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

e il risultato è il seguente -

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