Trabajando con Relaciones

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 →

RelationQueryBuilder es un tipo especial de QueryBuilder que te permite trabajar con tus relaciones. Con él, puedes vincular entidades entre sí en la base de datos sin necesidad de cargar ninguna entidad, o puedes cargar entidades relacionadas fácilmente.

Por ejemplo, tenemos una entidad Post que tiene una relación muchos a muchos con Category llamada categories. Agreguemos una nueva categoría a esta relación de muchos a muchos:

await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of(post)
    .add(category)

Este código es equivalente a hacer esto:

const postRepository = dataSource.manager.getRepository(Post)
const post = await postRepository.findOne({
    where: {
        id: 1,
    },
    relations: {
        categories: true,
    },
})
post.categories.push(category)
await postRepository.save(post)

Pero es más eficiente, porque realiza un número mínimo de operaciones y vincula las entidades en la base de datos, a diferencia de llamar al voluminoso método save.

Además, otro beneficio de este enfoque es que no necesitas cargar cada entidad relacionada antes de agregar a ella. Por ejemplo, si tienes diez mil categorías en una sola publicación, agregar nuevas publicaciones a esta lista puede volverse problemático, porque la forma estándar de hacerlo es cargar la publicación con las diez mil categorías, agregar una nueva categoría, y guardarla. Esto resulta en costos de rendimiento muy altos y básicamente es inaplicable en entornos de producción. Sin embargo, usar RelationQueryBuilder resuelve este problema.

Además, no hay necesidad real de usar entidades completas cuando "vinculas" elementos, ya que puedes usar identificadores de entidad. Por ejemplo, agreguemos una categoría con id = 3 a la publicación con id = 1:

await dataSource.createQueryBuilder().relation(Post, "categories").of(1).add(3)

Si usas claves primarias compuestas, debes pasarlas como un mapa de identificadores, por ejemplo:

await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of({ firstPostId: 1, secondPostId: 3 })
    .add({ firstCategoryId: 2, secondCategoryId: 4 })

Puedes eliminar entidades de la misma manera que las agregas:

// this code removes a category from a given post
await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of(post) // you can use just post id as well
    .remove(category) // you can use just category id as well

Agregar y eliminar entidades relacionadas funciona en relaciones many-to-many y one-to-many. Para relaciones one-to-one y many-to-one usa set en su lugar:

// this code sets category of a given post
await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of(post) // you can use just post id as well
    .set(category) // you can use just category id as well

Si quieres desvincular una relación (establecerla como nula), simplemente pasa null al método set:

// this code unsets category of a given post
await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of(post) // you can use just post id as well
    .set(null)

Además de actualizar relaciones, el constructor de consultas relacionales también te permite cargar entidades relacionadas. Por ejemplo, supongamos que dentro de la entidad Post tenemos una relación muchos a muchos categories y una relación muchos a uno user, para cargar esas relaciones puedes usar el siguiente código:

const post = await dataSource.manager.findOneBy(Post, {
    id: 1,
})

post.categories = await dataSource
    .createQueryBuilder()
    .relation(Post, "categories")
    .of(post) // you can use just post id as well
    .loadMany()

post.author = await dataSource
    .createQueryBuilder()
    .relation(Post, "user")
    .of(post) // you can use just post id as well
    .loadOne()