Opciones de Búsqueda

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Opciones básicas

Todos los métodos .find* del repositorio y del administrador aceptan opciones especiales que puedes usar para consultar los datos que necesitas sin utilizar QueryBuilder:

select - indica qué propiedades del objeto principal deben seleccionarse

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

ejecutará la siguiente consulta:

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

relations - relaciones que deben cargarse con la entidad principal. También se pueden cargar sub-relaciones (abreviatura de join y leftJoinAndSelect)

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

ejecutará las siguientes consultas:

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 - condiciones simples por las que se debe consultar la entidad.

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

ejecutará la siguiente consulta:

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

Consultar una columna de una entidad embebida debe hacerse respetando la jerarquía en la que fue definida. Ejemplo:

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

ejecutará la siguiente consulta:

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

Consultas con operador OR:

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

ejecutará la siguiente consulta:

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

order - orden de selección.

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

ejecutará la siguiente consulta:

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

withDeleted - incluye entidades eliminadas suavemente con softDelete o softRemove (por ejemplo, que tengan su columna @DeleteDateColumn establecida). Por defecto, las entidades eliminadas suavemente no se incluyen.

userRepository.find({
    withDeleted: true,
})

Los métodos find* que devuelven múltiples entidades (find, findBy, findAndCount, findAndCountBy) también aceptan estas opciones:

skip - desplazamiento (paginado) desde donde deben tomarse las entidades.

userRepository.find({
    skip: 5,
})

SELECT * FROM "user"
OFFSET 5

take - límite (paginado) - número máximo de entidades que deben tomarse.

userRepository.find({
    take: 10,
})

ejecutará la siguiente consulta:

SELECT * FROM "user"
LIMIT 10

** skip y take deben usarse conjuntamente

** Si usas TypeORM con MSSQL y quieres utilizar take o limit, debes incluir order o recibirás el error: 'Invalid usage of the option NEXT in the FETCH statement.'

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

ejecutará la siguiente consulta:

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

cache - Habilita o deshabilita el caché de resultados de consultas. Ver caching para más información y opciones.

userRepository.find({
    cache: true,
})

lock - Habilita mecanismo de bloqueo para consultas. Solo puede usarse en métodos findOne y findOneBy. lock es un objeto que puede definirse como:

{ 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"
}

por ejemplo:

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

Consulta lock modes para más información

Ejemplo completo de opciones de búsqueda:

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,
})

Búsqueda sin argumentos:

userRepository.find()

ejecutará la siguiente consulta:

SELECT * FROM "user"

Opciones avanzadas

TypeORM proporciona numerosos operadores integrados para crear comparaciones más complejas:

Not (Negación lógica)

import { Not } from "typeorm"

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

ejecutará la siguiente consulta:

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

LessThan (Menor que)

import { LessThan } from "typeorm"

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

ejecutará la siguiente consulta:

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

LessThanOrEqual (Menor o igual que)

import { LessThanOrEqual } from "typeorm"

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

ejecutará la siguiente consulta:

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

MoreThan (Mayor que)

import { MoreThan } from "typeorm"

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

ejecutará la siguiente consulta:

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

MoreThanOrEqual (Mayor o igual que)

import { MoreThanOrEqual } from "typeorm"

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

ejecutará la siguiente consulta:

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

Equal (Igual a)

import { Equal } from "typeorm"

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

ejecutará la siguiente consulta:

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

Like (Coincidencia de patrón)

import { Like } from "typeorm"

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

ejecutará la siguiente consulta:

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

ILike (Coincidencia de patrón insensible a mayúsculas/minúsculas)

import { ILike } from "typeorm"

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

ejecutará la siguiente consulta:

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

Between (Entre valores)

import { Between } from "typeorm"

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

ejecutará la siguiente consulta:

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

In (En conjunto de valores)

import { In } from "typeorm"

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

ejecutará la siguiente consulta:

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

Any (Cumple alguna condición en array)

import { Any } from "typeorm"

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

ejecutará la siguiente consulta (notación de Postgres):

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

IsNull (Es nulo)

import { IsNull } from "typeorm"

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

ejecutará la siguiente consulta:

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

ArrayContains (Array contiene elemento)

import { ArrayContains } from "typeorm"

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

ejecutará la siguiente consulta:

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

ArrayContainedBy (Array está contenido por)

import { ArrayContainedBy } from "typeorm"

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

ejecutará la siguiente consulta:

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

ArrayOverlap (Arrays se superponen)

import { ArrayOverlap } from "typeorm"

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

ejecutará la siguiente consulta:

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

JsonContains (solo para PostgreSQL/CockroachDB)

import { JsonContains } from "typeorm"

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

ejecutará la siguiente consulta:

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

Raw (Expresión SQL en bruto)

import { Raw } from "typeorm"

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

ejecutará la siguiente consulta:

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

En el caso más simple, una consulta en bruto se inserta inmediatamente después del símbolo de igual. Pero también puedes reescribir completamente la lógica de comparación usando la función.

import { Raw } from "typeorm"

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

ejecutará la siguiente consulta:

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

Si necesitas proporcionar datos de usuario, no debes incluirlos directamente en tu consulta ya que esto podría crear una vulnerabilidad de inyección SQL. En su lugar, puedes usar el segundo argumento de la función Raw para proporcionar una lista de parámetros que se vincularán a la consulta.

import { Raw } from "typeorm"

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

ejecutará la siguiente consulta:

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

Si necesitas proporcionar datos de usuario que sean un array, puedes vincularlos como una lista de valores en la sentencia SQL usando la sintaxis de expresión especial:

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",
        ],
    }),
})

ejecutará la siguiente consulta:

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

Combinando opciones avanzadas

También puedes combinar estos operadores con los siguientes:

Not (Negación lógica)

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

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

ejecutará la siguiente consulta:

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

Or (Operador OR)

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

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

ejecutará la siguiente consulta:

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

And (Operador AND)

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

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

ejecutará la siguiente consulta:

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

Opciones básicas​

Opciones avanzadas​

Combinando opciones avanzadas​

Opciones básicas

Opciones avanzadas

Combinando opciones avanzadas