SQLAlchemy Core - Usando Conjunções

Conjunções são funções no módulo SQLAlchemy que implementam operadores relacionais usados na cláusula WHERE de expressões SQL. Os operadores AND, OR, NOT, etc., são usados para formar uma expressão composta combinando duas expressões lógicas individuais. Um exemplo simples de uso de AND na instrução SELECT é o seguinte -

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

As funções SQLAlchemy and_ (), or_ () e not_ (), respectivamente, implementam os operadores AND, OR e NOT.

and_ () function

Ele produz uma conjunção de expressões unidas por AND. Um exemplo é dado abaixo para melhor compreensão -

from sqlalchemy import and_

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

Isso se traduz em -

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

Para usar and_ () em uma construção select () em uma tabela de alunos, use a seguinte linha de código -

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

A instrução SELECT da seguinte natureza será construída -

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

O código completo que exibe a saída da consulta SELECT acima é o seguinte -

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

A linha a seguir será selecionada assumindo que a tabela de alunos é preenchida com dados usados no exemplo anterior -

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

função or_ ()

Ele produz conjunção de expressões unidas por OR. Devemos substituir o objeto stmt no exemplo acima pelo seguinte usando or_ ()

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

O que será efetivamente equivalente a seguir a consulta SELECT -

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

Depois de fazer a substituição e executar o código acima, o resultado será duas linhas caindo na condição OU -

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

função asc ()

Ele produz uma cláusula ORDER BY crescente. A função usa a coluna para aplicar a função como parâmetro.

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

A declaração implementa a seguinte expressão SQL -

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

O código a seguir lista todos os registros na tabela de alunos em ordem crescente da coluna de 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)

O código acima produz a seguinte saída -

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

função desc ()

Da mesma forma, a função desc () produz a cláusula ORDER BY decrescente da seguinte forma -

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

A expressão SQL equivalente é -

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

E a saída para as linhas de código acima é -

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

entre () função

Ele produz uma cláusula de predicado BETWEEN. Isso geralmente é usado para validar se o valor de uma determinada coluna está entre um intervalo. Por exemplo, o código a seguir seleciona linhas para as quais a coluna id está entre 2 e 4 -

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

A expressão SQL resultante é semelhante a -

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

e o resultado é o seguinte -

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

↰ Previous page Next page ↱