Querying

SELECT * FROM users WHERE name = 'Alice';

users = User.objects.filter(name="Alice")

from sqlalchemy import select

with Session(engine) as session:
    users = session.scalars(
        select(User).where(User.name == "Alice")
    ).all()

from sqlmodel import select

with Session(engine) as session:
    users = session.exec(
        select(User).where(User.name == "Alice")
    ).all()

users = await User.filter(name="Alice")

users = User.select().where(User.name == "Alice")

const users = await prisma.user.findMany({
  where: { name: "Alice" },
});

const result = await db.select()
  .from(users)
  .where(eq(users.name, "Alice"));

const users = await db
  .selectFrom('users')
  .selectAll()
  .where('name', '=', 'Alice')
  .execute()

const users = await userRepository.findBy({ name: "Alice" });

const em = orm.em.fork();

const users = await em.find(User, {
  name: "Alice",
});

const users = await User.findAll({
  where: { name: "Alice" },
});

SELECT * FROM users ORDER BY created_at DESC;

users = User.objects.order_by("-created_at")

from sqlalchemy import select

with Session(engine) as session:
    users = session.scalars(
        select(User).order_by(User.created_at.desc())
    ).all()

from sqlmodel import select

with Session(engine) as session:
    users = session.exec(
        select(User).order_by(User.created_at.desc())
    ).all()

users = await User.all().order_by("-created_at")

users = User.select().order_by(User.created_at.desc())

const users = await prisma.user.findMany({
  orderBy: { createdAt: "desc" },
});

const result = await db.select()
  .from(users)
  .orderBy(desc(users.createdAt));

const users = await db
  .selectFrom('users')
  .selectAll()
  .orderBy('created_at', 'desc')
  .execute()

const users = await userRepository.find({
  order: { createdAt: "DESC" },
});

const em = orm.em.fork();

const users = await em.find(User, {}, {
  orderBy: { createdAt: "desc" },
});

const users = await User.findAll({
  order: [["createdAt", "DESC"]],
});

SELECT name, email FROM users;

users = User.objects.values("name", "email")

from sqlalchemy import select

with Session(engine) as session:
    rows = session.execute(
        select(User.name, User.email)
    ).all()

from sqlmodel import select

with Session(engine) as session:
    rows = session.exec(
        select(User.name, User.email)
    ).all()

users = await User.all().values("name", "email")

users = User.select(User.name, User.email)

const users = await prisma.user.findMany({
  select: { name: true, email: true },
});

const result = await db.select({
  name: users.name,
  email: users.email,
}).from(users);

const users = await db
  .selectFrom('users')
  .select(['name', 'email'])
  .execute()

const users = await userRepository.find({
  select: { name: true, email: true },
});

const em = orm.em.fork();

const users = await em.find(User, {}, {
  fields: ["name", "email"],
});

const users = await User.findAll({
  attributes: ["name", "email"],
});

SELECT * FROM users
ORDER BY created_at DESC
LIMIT 10 OFFSET 20;

users = User.objects.order_by("-created_at")[20:30]

from sqlalchemy import select

with Session(engine) as session:
    users = session.scalars(
        select(User)
        .order_by(User.created_at.desc())
        .limit(10)
        .offset(20)
    ).all()

from sqlmodel import select

with Session(engine) as session:
    users = session.exec(
        select(User)
        .order_by(User.created_at.desc())
        .limit(10)
        .offset(20)
    ).all()

users = await User.all().order_by(
    "-created_at"
).offset(20).limit(10)

users = (
    User.select()
    .order_by(User.created_at.desc())
    .offset(20)
    .limit(10)
)

const users = await prisma.user.findMany({
  orderBy: { createdAt: "desc" },
  take: 10,
  skip: 20,
});

const result = await db.select()
  .from(users)
  .orderBy(desc(users.createdAt))
  .limit(10)
  .offset(20);

const users = await db
  .selectFrom('users')
  .selectAll()
  .orderBy('created_at', 'desc')
  .offset(20)
  .limit(10)
  .execute()

const users = await userRepository.find({
  order: { createdAt: "DESC" },
  take: 10,
  skip: 20,
});

const em = orm.em.fork();

const users = await em.find(User, {}, {
  orderBy: { createdAt: "desc" },
  offset: 20,
  limit: 10,
});

const users = await User.findAll({
  order: [["createdAt", "DESC"]],
  limit: 10,
  offset: 20,
});

SELECT COUNT(*) FROM users WHERE name = 'Alice';

count = User.objects.filter(name="Alice").count()

from sqlalchemy import select, func

with Session(engine) as session:
    count = session.scalar(
        select(func.count()).select_from(User).where(User.name == "Alice")
    )

from sqlalchemy import func
from sqlmodel import select

with Session(engine) as session:
    count = session.exec(
        select(func.count())
        .select_from(User)
        .where(User.name == "Alice")
    ).one()

count = await User.filter(name="Alice").count()

count = User.select().where(User.name == "Alice").count()

const count = await prisma.user.count({
  where: { name: "Alice" },
});

const result = await db.select({ count: count() })
  .from(users)
  .where(eq(users.name, "Alice"));

const total = result[0].count;

import { sql } from 'kysely'

const result = await db
  .selectFrom('users')
  .select(sql<number>`count(*)`.as('count'))
  .where('name', '=', 'Alice')
  .executeTakeFirst()

const count = result?.count ?? 0

const count = await userRepository.countBy({ name: "Alice" });

const em = orm.em.fork();

const count = await em.count(User, {
  name: "Alice",
});

const count = await User.count({
  where: { name: "Alice" },
});

-- AND
SELECT * FROM users
WHERE name = 'Alice' AND email LIKE '%@example.com';

-- OR
SELECT * FROM users
WHERE name = 'Alice' OR name = 'Bob';

from django.db.models import Q

# AND (implicit)
users = User.objects.filter(name="Alice", email__endswith="@example.com")

# OR
users = User.objects.filter(Q(name="Alice") | Q(name="Bob"))

from sqlalchemy import select, and_, or_

with Session(engine) as session:
    # AND
    users = session.scalars(
        select(User).where(
            and_(User.name == "Alice", User.email.like("%@example.com"))
        )
    ).all()

    # OR
    users = session.scalars(
        select(User).where(
            or_(User.name == "Alice", User.name == "Bob")
        )
    ).all()

from sqlalchemy import and_, or_
from sqlmodel import select

with Session(engine) as session:
    # AND
    users = session.exec(
        select(User).where(
            and_(User.name == "Alice", User.email.endswith("@example.com"))
        )
    ).all()

    # OR
    users = session.exec(
        select(User).where(
            or_(User.name == "Alice", User.name == "Bob")
        )
    ).all()

from tortoise.queryset import Q

# AND (implicit)
users = await User.filter(
    name="Alice", email__endswith="@example.com"
)

# OR
users = await User.filter(
    Q(name="Alice") | Q(name="Bob")
)

# AND
users = User.select().where(
    (User.name == "Alice") &
    (User.email.endswith("@example.com"))
)

# OR
users = User.select().where(
    (User.name == "Alice") |
    (User.name == "Bob")
)

// AND (implicit)
const users = await prisma.user.findMany({
  where: {
    name: "Alice",
    email: { endsWith: "@example.com" },
  },
});

// OR
const users2 = await prisma.user.findMany({
  where: {
    OR: [{ name: "Alice" }, { name: "Bob" }],
  },
});

// AND
const result = await db.select()
  .from(users)
  .where(and(
    eq(users.name, "Alice"),
    like(users.email, "%@example.com")
  ));

// OR
const result2 = await db.select()
  .from(users)
  .where(or(
    eq(users.name, "Alice"),
    eq(users.name, "Bob")
  ));

// AND
const users = await db
  .selectFrom('users')
  .selectAll()
  .where((eb) =>
    eb.and([
      eb('name', '=', 'Alice'),
      eb('email', 'like', '%@example.com'),
    ])
  )
  .execute()

// OR
const users2 = await db
  .selectFrom('users')
  .selectAll()
  .where((eb) =>
    eb.or([
      eb('name', '=', 'Alice'),
      eb('name', '=', 'Bob'),
    ])
  )
  .execute()

import { Like } from "typeorm";

// AND
const users = await userRepository.findBy({
  name: "Alice",
  email: Like("%@example.com"),
});

// OR (array of conditions)
const users2 = await userRepository.findBy([
  { name: "Alice" },
  { name: "Bob" },
]);

const em = orm.em.fork();

// AND
const users = await em.find(User, {
  $and: [
    { name: "Alice" },
    { email: { $like: "%@example.com" } },
  ],
});

// OR
const users2 = await em.find(User, {
  $or: [
    { name: "Alice" },
    { name: "Bob" },
  ],
});

import { Op } from "sequelize";

// AND
const users = await User.findAll({
  where: {
    name: "Alice",
    email: { [Op.like]: "%@example.com" },
  },
});

// OR
const users2 = await User.findAll({
  where: {
    [Op.or]: [{ name: "Alice" }, { name: "Bob" }],
  },
});

-- Contains
SELECT * FROM users WHERE name LIKE '%ali%';

-- Starts with
SELECT * FROM users WHERE name LIKE 'Ali%';

-- Case-insensitive
SELECT * FROM users WHERE name ILIKE '%ali%';

# Contains
users = User.objects.filter(name__contains="ali")

# Starts with
users = User.objects.filter(name__startswith="Ali")

# Case-insensitive
users = User.objects.filter(name__icontains="ali")

from sqlalchemy import select

with Session(engine) as session:
    # Contains
    users = session.scalars(
        select(User).where(User.name.contains("ali"))
    ).all()

    # Starts with
    users = session.scalars(
        select(User).where(User.name.startswith("Ali"))
    ).all()

    # Case-insensitive
    users = session.scalars(
        select(User).where(User.name.ilike("%ali%"))
    ).all()

from sqlmodel import select

with Session(engine) as session:
    # Contains
    users = session.exec(
        select(User).where(User.name.contains("ali"))
    ).all()

    # Starts with
    users = session.exec(
        select(User).where(User.name.startswith("Ali"))
    ).all()

    # Case-insensitive
    users = session.exec(
        select(User).where(User.name.ilike("%ali%"))
    ).all()

# Contains
users = await User.filter(name__contains="ali")

# Starts with
users = await User.filter(name__startswith="Ali")

# Case-insensitive
users = await User.filter(name__icontains="ali")

# Contains
users = User.select().where(User.name.contains("ali"))

# Starts with
users = User.select().where(User.name.startswith("Ali"))

# Case-insensitive
users = User.select().where(User.name.icontains("ali"))

// Contains
const users = await prisma.user.findMany({
  where: { name: { contains: "ali" } },
});

// Starts with
const users2 = await prisma.user.findMany({
  where: { name: { startsWith: "Ali" } },
});

// Case-insensitive
const users3 = await prisma.user.findMany({
  where: { name: { contains: "ali", mode: "insensitive" } },
});

// Contains
const result = await db.select()
  .from(users)
  .where(like(users.name, "%ali%"));

// Starts with
const result2 = await db.select()
  .from(users)
  .where(like(users.name, "Ali%"));

// Case-insensitive
const result3 = await db.select()
  .from(users)
  .where(ilike(users.name, "%ali%"));

// Contains
const users = await db
  .selectFrom('users')
  .selectAll()
  .where('name', 'like', '%ali%')
  .execute()

// Starts with
const users2 = await db
  .selectFrom('users')
  .selectAll()
  .where('name', 'like', 'Ali%')
  .execute()

// Case-insensitive
const users3 = await db
  .selectFrom('users')
  .selectAll()
  .where('name', 'ilike', '%ali%')
  .execute()

import { Like, ILike } from "typeorm";

// Contains
const users = await userRepository.findBy({
  name: Like("%ali%"),
});

// Starts with
const users2 = await userRepository.findBy({
  name: Like("Ali%"),
});

// Case-insensitive
const users3 = await userRepository.findBy({
  name: ILike("%ali%"),
});

const em = orm.em.fork();

// Contains
const users = await em.find(User, {
  name: { $like: "%ali%" },
});

// Starts with
const users2 = await em.find(User, {
  name: { $like: "Ali%" },
});

// Case-insensitive
const users3 = await em.find(User, {
  name: { $ilike: "%ali%" },
});

import { Op } from "sequelize";

// Contains
const users = await User.findAll({
  where: { name: { [Op.like]: "%ali%" } },
});

// Starts with
const users2 = await User.findAll({
  where: { name: { [Op.like]: "Ali%" } },
});

// Case-insensitive
const users3 = await User.findAll({
  where: { name: { [Op.iLike]: "%ali%" } },
});

-- Greater than
SELECT * FROM users WHERE created_at > '2024-01-01';

-- Less than or equal
SELECT * FROM users WHERE id <= 100;

-- Not equal
SELECT * FROM users WHERE name != 'Alice';

-- Between
SELECT * FROM users
WHERE created_at BETWEEN '2024-01-01' AND '2024-12-31';

from datetime import date

# Greater than
users = User.objects.filter(created_at__gt=date(2024, 1, 1))

# Less than or equal
users = User.objects.filter(id__lte=100)

# Not equal
users = User.objects.exclude(name="Alice")

# Between
users = User.objects.filter(
    created_at__range=(date(2024, 1, 1), date(2024, 12, 31))
)

from datetime import date
from sqlalchemy import select, and_

with Session(engine) as session:
    # Greater than
    users = session.scalars(
        select(User).where(User.created_at > date(2024, 1, 1))
    ).all()

    # Less than or equal
    users = session.scalars(
        select(User).where(User.id <= 100)
    ).all()

    # Not equal
    users = session.scalars(
        select(User).where(User.name != "Alice")
    ).all()

    # Between
    users = session.scalars(
        select(User).where(
            User.created_at.between(date(2024, 1, 1), date(2024, 12, 31))
        )
    ).all()

from datetime import date
from sqlmodel import select

with Session(engine) as session:
    # Greater than
    users = session.exec(
        select(User).where(User.created_at > date(2024, 1, 1))
    ).all()

    # Less than or equal
    users = session.exec(
        select(User).where(User.id <= 100)
    ).all()

    # Not equal
    users = session.exec(
        select(User).where(User.name != "Alice")
    ).all()

    # Between
    users = session.exec(
        select(User).where(
            User.created_at.between(date(2024, 1, 1), date(2024, 12, 31))
        )
    ).all()

from datetime import date

# Greater than
users = await User.filter(
    created_at__gt=date(2024, 1, 1)
)

# Less than or equal
users = await User.filter(id__lte=100)

# Not equal
users = await User.exclude(name="Alice")

# Between
users = await User.filter(
    created_at__range=(
        date(2024, 1, 1), date(2024, 12, 31)
    )
)

from datetime import date

# Greater than
users = User.select().where(User.created_at > date(2024, 1, 1))

# Less than or equal
users = User.select().where(User.id <= 100)

# Not equal
users = User.select().where(User.name != "Alice")

# Between
users = User.select().where(
    User.created_at.between(date(2024, 1, 1), date(2024, 12, 31))
)

// Greater than
const users = await prisma.user.findMany({
  where: { createdAt: { gt: new Date("2024-01-01") } },
});

// Less than or equal
const users2 = await prisma.user.findMany({
  where: { id: { lte: 100 } },
});

// Not equal
const users3 = await prisma.user.findMany({
  where: { name: { not: "Alice" } },
});

// Between
const users4 = await prisma.user.findMany({
  where: {
    createdAt: {
      gte: new Date("2024-01-01"),
      lte: new Date("2024-12-31"),
    },
  },
});

// Greater than
const result = await db.select()
  .from(users)
  .where(gt(users.createdAt, new Date("2024-01-01")));

// Less than or equal
const result2 = await db.select()
  .from(users)
  .where(lte(users.id, 100));

// Not equal
const result3 = await db.select()
  .from(users)
  .where(ne(users.name, "Alice"));

// Between
const result4 = await db.select()
  .from(users)
  .where(between(
    users.createdAt,
    new Date("2024-01-01"),
    new Date("2024-12-31")
  ));

// Greater than
const users = await db
  .selectFrom('users')
  .selectAll()
  .where('created_at', '>', new Date('2024-01-01'))
  .execute()

// Less than or equal
const users2 = await db
  .selectFrom('users')
  .selectAll()
  .where('id', '<=', 100)
  .execute()

// Not equal
const users3 = await db
  .selectFrom('users')
  .selectAll()
  .where('name', '!=', 'Alice')
  .execute()

// Between
const users4 = await db
  .selectFrom('users')
  .selectAll()
  .where('created_at', '>=', new Date('2024-01-01'))
  .where('created_at', '<=', new Date('2024-12-31'))
  .execute()

import { MoreThan, LessThanOrEqual, Not, Between } from "typeorm";

// Greater than
const users = await userRepository.findBy({
  createdAt: MoreThan(new Date("2024-01-01")),
});

// Less than or equal
const users2 = await userRepository.findBy({
  id: LessThanOrEqual(100),
});

// Not equal
const users3 = await userRepository.findBy({
  name: Not("Alice"),
});

// Between
const users4 = await userRepository.findBy({
  createdAt: Between(new Date("2024-01-01"), new Date("2024-12-31")),
});

// Greater than
const users = await orm.em.find(User, {
  createdAt: { $gt: new Date("2024-01-01") },
});

// Less than or equal
const users2 = await orm.em.find(User, {
  id: { $lte: 100 },
});

// Not equal
const users3 = await orm.em.find(User, {
  name: { $ne: "Alice" },
});

// Between
const users4 = await orm.em.find(User, {
  createdAt: {
    $gte: new Date("2024-01-01"),
    $lte: new Date("2024-12-31"),
  },
});

import { Op } from "sequelize";

// Greater than
const users = await User.findAll({
  where: {
    createdAt: { [Op.gt]: new Date("2024-01-01") },
  },
});

// Less than or equal
const users2 = await User.findAll({
  where: {
    id: { [Op.lte]: 100 },
  },
});

// Not equal
const users3 = await User.findAll({
  where: {
    name: { [Op.ne]: "Alice" },
  },
});

// Between
const users4 = await User.findAll({
  where: {
    createdAt: {
      [Op.between]: [new Date("2024-01-01"), new Date("2024-12-31")],
    },
  },
});

SELECT * FROM users WHERE name IN ('Alice', 'Bob', 'Charlie');

-- NOT IN
SELECT * FROM users WHERE name NOT IN ('Alice', 'Bob');

users = User.objects.filter(name__in=["Alice", "Bob", "Charlie"])

# NOT IN
users = User.objects.exclude(name__in=["Alice", "Bob"])

from sqlalchemy import select

with Session(engine) as session:
    users = session.scalars(
        select(User).where(User.name.in_(["Alice", "Bob", "Charlie"]))
    ).all()

    # NOT IN
    users = session.scalars(
        select(User).where(User.name.not_in(["Alice", "Bob"]))
    ).all()

from sqlmodel import select

with Session(engine) as session:
    users = session.exec(
        select(User).where(User.name.in_(["Alice", "Bob", "Charlie"]))
    ).all()

    # NOT IN
    users = session.exec(
        select(User).where(~User.name.in_(["Alice", "Bob"]))
    ).all()

users = await User.filter(
    name__in=["Alice", "Bob", "Charlie"]
)

# NOT IN
users = await User.exclude(
    name__in=["Alice", "Bob"]
)

users = User.select().where(
    User.name << ["Alice", "Bob", "Charlie"]
)

# NOT IN
users = User.select().where(
    User.name.not_in(["Alice", "Bob"])
)

const users = await prisma.user.findMany({
  where: { name: { in: ["Alice", "Bob", "Charlie"] } },
});

// NOT IN
const users2 = await prisma.user.findMany({
  where: { name: { notIn: ["Alice", "Bob"] } },
});

const result = await db.select()
  .from(users)
  .where(inArray(users.name, ["Alice", "Bob", "Charlie"]));

// NOT IN
const result2 = await db.select()
  .from(users)
  .where(notInArray(users.name, ["Alice", "Bob"]));

const users = await db
  .selectFrom('users')
  .selectAll()
  .where('name', 'in', ['Alice', 'Bob', 'Charlie'])
  .execute()

// NOT IN
const users2 = await db
  .selectFrom('users')
  .selectAll()
  .where((eb) => eb.not(eb('name', 'in', ['Alice', 'Bob'])))
  .execute()

import { In, Not } from "typeorm";

const users = await userRepository.findBy({
  name: In(["Alice", "Bob", "Charlie"]),
});

// NOT IN
const users2 = await userRepository.findBy({
  name: Not(In(["Alice", "Bob"])),
});

const em = orm.em.fork();

const users = await em.find(User, {
  name: { $in: ["Alice", "Bob", "Charlie"] },
});

// NOT IN
const users2 = await em.find(User, {
  name: { $nin: ["Alice", "Bob"] },
});

import { Op } from "sequelize";

const users = await User.findAll({
  where: {
    name: { [Op.in]: ["Alice", "Bob", "Charlie"] },
  },
});

// NOT IN
const users2 = await User.findAll({
  where: {
    name: { [Op.notIn]: ["Alice", "Bob"] },
  },
});

SELECT DISTINCT name FROM users;

names = User.objects.values_list("name", flat=True).distinct()

from sqlalchemy import select

with Session(engine) as session:
    names = session.scalars(
        select(User.name).distinct()
    ).all()

from sqlmodel import select

with Session(engine) as session:
    names = session.exec(
        select(User.name).distinct()
    ).all()

names = await User.all().values_list(
    "name", flat=True
).distinct()

names = User.select(User.name).distinct()

const names = await prisma.user.findMany({
  distinct: ["name"],
  select: { name: true },
});

const result = await db.selectDistinct({ name: users.name })
  .from(users);

const names = await db
  .selectFrom('users')
  .select('name')
  .distinct()
  .execute()

const names = await userRepository
  .createQueryBuilder("user")
  .select("DISTINCT user.name", "name")
  .getRawMany();

const names = await orm.em
  .createQueryBuilder(User, "u")
  .select("distinct u.name")
  .execute();

import { col, fn } from "sequelize";

const names = await User.findAll({
  attributes: [[fn("DISTINCT", col("name")), "name"]],
});

SELECT EXISTS (
  SELECT 1 FROM users
  WHERE email = 'alice@example.com'
);

exists = User.objects.filter(
    email="alice@example.com"
).exists()

from sqlalchemy import exists, select

stmt = select(
    exists().where(
        User.email == "alice@example.com"
    )
)
result = session.execute(stmt).scalar()

from sqlalchemy import exists
from sqlmodel import select

stmt = select(
    exists().where(
        User.email == "alice@example.com"
    )
)

with Session(engine) as session:
    exists_result = session.exec(stmt).one()

exists = await User.filter(
    email="alice@example.com"
).exists()

exists = User.select().where(
    User.email == "alice@example.com"
).exists()

// Prisma has no .exists(); use findFirst
const exists =
  (await prisma.user.findFirst({
    where: { email: "alice@example.com" },
    select: { id: true },
  })) !== null;

import { sql, eq } from "drizzle-orm";

const [row] = await db
  .select({ value: sql`1` })
  .from(users)
  .where(eq(users.email, "alice@example.com"))
  .limit(1);
const exists = !!row;

const result = await db
  .selectNoFrom((eb) => [
    eb.exists(
      db
        .selectFrom('users')
        .select('id')
        .where('email', '=', 'alice@example.com')
    ).as('exists'),
  ])
  .executeTakeFirst()

const exists = result?.exists ?? false

const exists = await dataSource
  .getRepository(User)
  .existsBy({ email: "alice@example.com" });

const user = await orm.em.findOne(User, {
  email: "alice@example.com",
}, {
  fields: ["id"],
});

const exists = user !== null;

const exists =
  (await User.count({
    where: { email: "alice@example.com" },
    limit: 1,
  })) > 0;

SELECT * FROM products
WHERE sale_price < original_price;

from django.db.models import F

products = Product.objects.filter(
    sale_price__lt=F("original_price")
)

from sqlalchemy import select

stmt = select(Product).where(
    Product.sale_price < Product.original_price
)
products = session.execute(stmt).scalars().all()

from sqlmodel import select

with Session(engine) as session:
    products = session.exec(
        select(Product).where(
            Product.sale_price < Product.original_price
        )
    ).all()

from tortoise.expressions import F

products = await Product.filter(
    sale_price__lt=F("original_price")
)

products = Product.select().where(
    Product.sale_price < Product.original_price
)

// No field-to-field comparison API;
// use raw SQL
const products = await prisma.$queryRaw`
  SELECT * FROM products
  WHERE sale_price < original_price
`;

import { lt } from "drizzle-orm";

const result = await db
  .select()
  .from(products)
  .where(
    lt(products.salePrice, products.originalPrice)
  );

const products = await db
  .selectFrom('products')
  .selectAll()
  .whereRef('sale_price', '<', 'original_price')
  .execute()

const products = await dataSource
  .getRepository(Product)
  .createQueryBuilder("p")
  .where("p.sale_price < p.original_price")
  .getMany();

const products = await orm.em
  .createQueryBuilder(Product, "p")
  .select("*")
  .where("p.sale_price < p.original_price")
  .getResultList();

import { Op, col, where } from "sequelize";

const products = await Product.findAll({
  where: where(col("sale_price"), Op.lt, col("original_price")),
});