Saltar al contenido principal

Carga Implícita

[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 →

Resumen​

ent permite consultar entidades junto con sus asociaciones (a través de sus aristas). Las entidades asociadas se cargan en el campo Edges del objeto devuelto.

Veamos un ejemplo de cómo se ve la API para el siguiente esquema:

er-group-users

Consulta todos los usuarios con sus mascotas:

users, err := client.User.
    Query().
    WithPets().
    All(ctx)
if err != nil {
    return err
}
// The returned users look as follows:
//
//  [
//      User {
//          ID:   1,
//          Name: "a8m",
//          Edges: {
//              Pets: [Pet(...), ...]
//              ...
//          }
//      },
//      ...
//  ]
//
for _, u := range users {
    for _, p := range u.Edges.Pets {
        fmt.Printf("User(%v) -> Pet(%v)\n", u.ID, p.ID)
        // Output:
        // User(...) -> Pet(...)
    }
}

La carga implícita permite consultar más de una asociación (incluyendo anidadas), además de filtrar, ordenar o limitar sus resultados. Por ejemplo:

admins, err := client.User.
    Query().
    Where(user.Admin(true)).
    // Populate the `pets` that associated with the `admins`.
    WithPets().
    // Populate the first 5 `groups` that associated with the `admins`.
    WithGroups(func(q *ent.GroupQuery) {
        q.Limit(5)              // Limit to 5.
        q.WithUsers()           // Populate the `users` of each `groups`.
    }).
    All(ctx)
if err != nil {
    return err
}

// The returned users look as follows:
//
//  [
//      User {
//          ID:   1,
//          Name: "admin1",
//          Edges: {
//              Pets:   [Pet(...), ...]
//              Groups: [
//                  Group {
//                      ID:   7,
//                      Name: "GitHub",
//                      Edges: {
//                          Users: [User(...), ...]
//                          ...
//                      }
//                  }
//              ]
//          }
//      },
//      ...
//  ]
//
for _, admin := range admins {
    for _, p := range admin.Edges.Pets {
        fmt.Printf("Admin(%v) -> Pet(%v)\n", u.ID, p.ID)
        // Output:
        // Admin(...) -> Pet(...)
    }
    for _, g := range admin.Edges.Groups {
        for _, u := range g.Edges.Users {
            fmt.Printf("Admin(%v) -> Group(%v) -> User(%v)\n", u.ID, g.ID, u.ID)
            // Output:
            // Admin(...) -> Group(...) -> User(...)
        }
    }
}

API​

Cada constructor de consultas (query-builder) incluye métodos con la forma With<E>(...func(<N>Query)) para cada arista. <E> representa el nombre de la arista (ej. WithGroups) y <N> el tipo de arista (ej. GroupQuery).

Nota: solo los dialectos SQL admiten esta funcionalidad.

Aristas con nombre​

En ciertos escenarios se requiere precargar aristas con nombres personalizados. Por ejemplo, consultas GraphQL con dos alias que referencian la misma arista con argumentos distintos. Para estos casos, Ent ofrece otra API llamada WithNamed<E> activada mediante la bandera namedges, integrable directamente con EntGQL Fields Collection.

See the GraphQL tab to learn more about the motivation behind this API.

posts, err := client.Post.Query().
    WithNamedComments("published", func(q *ent.CommentQuery) {
        q.Where(comment.StatusEQ(comment.StatusPublished))
    })
    WithNamedComments("draft", func(q *ent.CommentQuery) {
        q.Where(comment.StatusEQ(comment.StatusDraft))
    }).
    Paginate(...)

// Get the preloaded edges by their name:
for _, p := range posts {
    published, err := p.Edges.NamedComments("published")
    if err != nil {
        return err
    }
    draft, err := p.Edges.NamedComments("draft")
    if err != nil {
        return err
    }
}

Implementación​

Dado que una consulta de Ent puede cargar implícitamente múltiples aristas, es imposible recuperar todas las asociaciones en una única operación JOIN. Por ello, Ent ejecuta consultas adicionales para cargar cada asociación. Se prevé optimizar este comportamiento en futuras versiones.