Параметры поиска

Неофициальный Бета-перевод

Эта страница переведена PageTurner AI (бета). Не одобрена официально проектом. Нашли ошибку? Сообщить о проблеме →

Базовые параметры

Все методы .find* в репозиториях и менеджерах принимают специальные параметры для запроса данных без использования QueryBuilder:

select — указывает, какие свойства основного объекта должны быть выбраны

userRepository.find({
    select: {
        firstName: true,
        lastName: true,
    },
})

выполнит следующий запрос:

SELECT "firstName", "lastName" FROM "user"

relations — связи, которые должны быть загружены вместе с основной сущностью. Подсвязи также могут быть загружены (сокращение для join и leftJoinAndSelect)

userRepository.find({
    relations: {
        profile: true,
        photos: true,
        videos: true,
    },
})
userRepository.find({
    relations: {
        profile: true,
        photos: true,
        videos: {
            videoAttributes: true,
        },
    },
})

выполнит следующие запросы:

SELECT * FROM "user"
LEFT JOIN "profile" ON "profile"."id" = "user"."profileId"
LEFT JOIN "photos" ON "photos"."id" = "user"."photoId"
LEFT JOIN "videos" ON "videos"."id" = "user"."videoId"

SELECT * FROM "user"
LEFT JOIN "profile" ON "profile"."id" = "user"."profileId"
LEFT JOIN "photos" ON "photos"."id" = "user"."photoId"
LEFT JOIN "videos" ON "videos"."id" = "user"."videoId"
LEFT JOIN "video_attributes" ON "video_attributes"."id" = "videos"."video_attributesId"

where — простые условия для фильтрации сущностей

userRepository.find({
    where: {
        firstName: "Timber",
        lastName: "Saw",
    },
})

выполнит следующий запрос:

SELECT * FROM "user"
WHERE "firstName" = 'Timber' AND "lastName" = 'Saw'

При запросе колонки из встроенной сущности следует учитывать иерархию её определения. Пример:

userRepository.find({
    relations: {
        project: true,
    },
    where: {
        project: {
            name: "TypeORM",
            initials: "TORM",
        },
    },
})

выполнит следующий запрос:

SELECT * FROM "user"
LEFT JOIN "project" ON "project"."id" = "user"."projectId"
WHERE "project"."name" = 'TypeORM' AND "project"."initials" = 'TORM'

Запрос с оператором OR:

userRepository.find({
    where: [
        { firstName: "Timber", lastName: "Saw" },
        { firstName: "Stan", lastName: "Lee" },
    ],
})

выполнит следующий запрос:

SELECT * FROM "user" WHERE ("firstName" = 'Timber' AND "lastName" = 'Saw') OR ("firstName" = 'Stan' AND "lastName" = 'Lee')

order — порядок сортировки результатов

userRepository.find({
    order: {
        name: "ASC",
        id: "DESC",
    },
})

выполнит следующий запрос:

SELECT * FROM "user"
ORDER BY "name" ASC, "id" DESC

withDeleted — включает сущности, помеченные как удалённые через softDelete или softRemove (т.е. имеющие значение в колонке @DeleteDateColumn). По умолчанию такие сущности исключаются

userRepository.find({
    withDeleted: true,
})

Методы find*, возвращающие несколько сущностей (find, findBy, findAndCount, findAndCountBy), также принимают:

skip — смещение (для пагинации) с которого начинается выборка

userRepository.find({
    skip: 5,
})

SELECT * FROM "user"
OFFSET 5

take — лимит (для пагинации) — максимальное количество возвращаемых сущностей

userRepository.find({
    take: 10,
})

выполнит следующий запрос:

SELECT * FROM "user"
LIMIT 10

** skip и take следует использовать вместе

** При использовании TypeORM с MSSQL, для применения take или limit необходимо также указать order, иначе возникнет ошибка: 'Invalid usage of the option NEXT in the FETCH statement.'

userRepository.find({
    order: {
        columnName: "ASC",
    },
    skip: 0,
    take: 10,
})

выполнит следующий запрос:

SELECT * FROM "user"
ORDER BY "columnName" ASC
LIMIT 10 OFFSET 0

cache — включает или отключает кэширование результатов запроса. Подробнее см. кэширование

userRepository.find({
    cache: true,
})

lock — включает механизм блокировок для запроса. Доступен только в методах findOne и findOneBy.
lock — объект, который может быть определён как:

{ mode: "optimistic", version: number | Date }

или

{
    mode: "pessimistic_read" |
        "pessimistic_write" |
        "dirty_read" |
        /*
            "pessimistic_partial_write" and "pessimistic_write_or_fail" are deprecated and
            will be removed in a future version.

            Use onLocked instead.
         */
        "pessimistic_partial_write" |
        "pessimistic_write_or_fail" |
        "for_no_key_update" |
        "for_key_share",

    tables: string[],
    onLocked: "nowait" | "skip_locked"
}

например:

userRepository.findOne({
    where: {
        id: 1,
    },
    lock: { mode: "optimistic", version: 1 },
})

Подробнее см. режимы блокировок

Полный пример параметров поиска:

userRepository.find({
    select: {
        firstName: true,
        lastName: true,
    },
    relations: {
        profile: true,
        photos: true,
        videos: true,
    },
    where: {
        firstName: "Timber",
        lastName: "Saw",
        profile: {
            userName: "tshaw",
        },
    },
    order: {
        name: "ASC",
        id: "DESC",
    },
    skip: 5,
    take: 10,
    cache: true,
})

Поиск без аргументов:

userRepository.find()

выполнит следующий запрос:

SELECT * FROM "user"

Расширенные параметры

TypeORM предоставляет множество встроенных операторов для создания сложных условий сравнения:

Not (Отрицание)

import { Not } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    title: Not("About #1"),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "title" != 'About #1'

LessThan (Меньше чем)

import { LessThan } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    likes: LessThan(10),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "likes" < 10

LessThanOrEqual (Меньше или равно)

import { LessThanOrEqual } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    likes: LessThanOrEqual(10),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "likes" <= 10

MoreThan (Больше чем)

import { MoreThan } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    likes: MoreThan(10),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "likes" > 10

MoreThanOrEqual (Больше или равно)

import { MoreThanOrEqual } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    likes: MoreThanOrEqual(10),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "likes" >= 10

Equal (Равно)

import { Equal } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    title: Equal("About #2"),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "title" = 'About #2'

Like (Похоже на)

import { Like } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    title: Like("%out #%"),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "title" LIKE '%out #%'

ILike (Без учёта регистра)

import { ILike } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    title: ILike("%out #%"),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "title" ILIKE '%out #%'

Between (Между)

import { Between } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    likes: Between(1, 10),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "likes" BETWEEN 1 AND 10

In (Входит в набор)

import { In } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    title: In(["About #2", "About #3"]),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "title" IN ('About #2','About #3')

Any (Любой из массива)

import { Any } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    title: Any(["About #2", "About #3"]),
})

выполнит следующий запрос (нотация Postgres):

SELECT * FROM "post" WHERE "title" = ANY(['About #2','About #3'])

IsNull (Равно NULL)

import { IsNull } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    title: IsNull(),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "title" IS NULL

ArrayContains (Массив содержит)

import { ArrayContains } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    categories: ArrayContains(["TypeScript"]),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "categories" @> '{TypeScript}'

ArrayContainedBy (Массив содержится в)

import { ArrayContainedBy } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    categories: ArrayContainedBy(["TypeScript"]),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "categories" <@ '{TypeScript}'

ArrayOverlap (Массивы пересекаются)

import { ArrayOverlap } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    categories: ArrayOverlap(["TypeScript"]),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "categories" && '{TypeScript}'

JsonContains (только для PostgreSQL/CockroachDB)

import { JsonContains } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    metadata: JsonContains({ author: { name: "John" } }),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "metadata" ::jsonb @> '{"author":{"name":"John"}}'

Raw (Сырой SQL)

import { Raw } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    likes: Raw("dislikes - 4"),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "likes" = "dislikes" - 4

В простейшем случае необработанный запрос вставляется сразу после символа равенства.
Но вы можете полностью переопределить логику сравнения, используя функцию.

import { Raw } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    currentDate: Raw((alias) => `${alias} > NOW()`),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "currentDate" > NOW()

Если требуется передать пользовательский ввод, не следует включать его напрямую в запрос, так как это может создать уязвимость к SQL-инъекциям. Вместо этого используйте второй аргумент функции Raw для передачи списка параметров, привязываемых к запросу.

import { Raw } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    currentDate: Raw((alias) => `${alias} > :date`, { date: "2020-10-06" }),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "currentDate" > '2020-10-06'

Если требуется передать пользовательский ввод в виде массива, привяжите его как список значений в SQL-запросе, используя специальный синтаксис выражений:

import { Raw } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    title: Raw((alias) => `${alias} IN (:...titles)`, {
        titles: [
            "Go To Statement Considered Harmful",
            "Structured Programming",
        ],
    }),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "title" IN ('Go To Statement Considered Harmful', 'Structured Programming')

Комбинирование расширенных опций

Эти операторы также можно комбинировать с помощью следующих конструкций:

Not (Отрицание)

import { Not, MoreThan, Equal } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    likes: Not(MoreThan(10)),
    title: Not(Equal("About #2")),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE NOT("likes" > 10) AND NOT("title" = 'About #2')

Or (Логическое ИЛИ)

import { Or, Equal, ILike } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    title: Or(Equal("About #2"), ILike("About%")),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE "title" = 'About #2' OR "title" ILIKE 'About%'

And (Логическое И)

import { And, Not, Equal, ILike } from "typeorm"

const loadedPosts = await dataSource.getRepository(Post).findBy({
    title: And(Not(Equal("About #2")), ILike("%About%")),
})

выполнит следующий запрос:

SELECT * FROM "post" WHERE NOT("title" = 'About #2') AND "title" ILIKE '%About%'

Базовые параметры​

Расширенные параметры​

Комбинирование расширенных опций​

Базовые параметры

Расширенные параметры

Комбинирование расширенных опций