Paginación y Ordenación

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

Límite

Limit limita el resultado de la consulta a n entidades.

users, err := client.User.
    Query().
    Limit(n).
    All(ctx)

Desplazamiento

Offset establece el primer nodo que se devolverá en la consulta.

users, err := client.User.
    Query().
    Offset(10).
    All(ctx)

Ordenación

Order devuelve las entidades ordenadas por los valores de uno o más campos. Ten en cuenta que se devolverá un error si los campos proporcionados no son columnas válidas o claves externas.

users, err := client.User.Query().
    Order(ent.Asc(user.FieldName)).
    All(ctx)

A partir de la versión v0.12.0, Ent genera funciones de ordenación con verificación de tipos para campos y relaciones. El siguiente ejemplo demuestra cómo usar estas funciones generadas:

// Get all users sorted by their name (and nickname) in ascending order.
users, err := client.User.Query().
    Order(
        user.ByName(),
        user.ByNickname(),
    ).
    All(ctx)

// Get all users sorted by their nickname in descending order.
users, err := client.User.Query().
    Order(
        user.ByNickname(
            sql.OrderDesc(),
        ),
    ).
    All(ctx)

Ordenar por recuento de relaciones

Order también se puede usar para ordenar entidades según el número de relaciones que tienen. Por ejemplo, la siguiente consulta devuelve todos los usuarios ordenados por el número de publicaciones que tienen:

users, err := client.User.Query().
    Order(
        // Users without posts are sorted first.
        user.ByPostsCount(),
    ).
    All(ctx)

users, err := client.User.Query().
    Order(
        // Users without posts are sorted last.
        user.ByPostsCount(
            sql.OrderDesc(),
        ),
    ).
    All(ctx)

Ordenar por campo de relación

Las entidades también se pueden ordenar por el valor de un campo de una relación. Por ejemplo, la siguiente consulta devuelve todas las publicaciones ordenadas por el nombre de su autor:

// Posts are sorted by their author's name in ascending
// order with NULLs first unless otherwise specified.
posts, err := client.Post.Query().
    Order(
        post.ByAuthorField(user.FieldName),
    ).
    All(ctx)

posts, err := client.Post.Query().
    Order(
        post.ByAuthorField(
            user.FieldName,
            sql.OrderDesc(),
            sql.OrderNullsFirst(),
        ),
    ).
    All(ctx)

Términos personalizados en relaciones

Las funciones generadas para ordenar por relaciones admiten términos personalizados. Por ejemplo, la siguiente consulta devuelve todos los usuarios ordenados por la suma de los "me gusta" y visualizaciones de sus publicaciones:

// Ascending order.
posts, err := client.User.Query().
    Order(
        user.ByPosts(
            sql.OrderBySum(post.FieldNumLikes),
            sql.OrderBySum(post.FieldNumViews),
        ),
    ).
    All(ctx)

// Descending order.
posts, err := client.User.Query().
    Order(
        user.ByPosts(
            sql.OrderBySum(
                post.FieldNumLikes,
                sql.OrderDesc(),
            ),
            sql.OrderBySum(
                post.FieldNumViews,
                sql.OrderDesc(),
            ),
        ),
    ).
    All(ctx)

Seleccionar términos de ordenación

Términos de ordenación como SUM() y COUNT() no están definidos en el esquema y, por tanto, no existen en las entidades generadas. Sin embargo, a veces es necesario recuperar su información para mostrársela al usuario o implementar paginación basada en cursores. El método Value, definido en cada entidad, permite obtener el valor de ordenación si se seleccionó en la consulta:

// Define the alias for the order term.
const as = "pets_count"

// Query users sorted by the number of pets
// they have and select the order term.
users := client.User.Query().
    Order(
        user.ByPetsCount(
            sql.OrderDesc(),
            sql.OrderSelectAs(as),
        ),
        user.ByID(),
    ).
    AllX(ctx)

// Retrieve the order term value.
for _, u := range users {
    fmt.Println(u.Value(as))
}

Ordenación personalizada

Las funciones de ordenación personalizadas pueden ser útiles si quieres escribir tu propia lógica específica del almacenamiento.

names, err := client.Pet.Query().
    Order(func(s *sql.Selector) {
        // Logic goes here.
    }).
    Select(pet.FieldName).
    Strings(ctx)

Ordenar por campos JSON

El paquete sqljson permite ordenar fácilmente datos basándose en el valor de un objeto JSON:

By Value

users := client.User.Query().
    Order(
        sqljson.OrderValue(user.FieldData, sqljson.Path("key1", "key2")),
    ).
    AllX(ctx)

By Length

users := client.User.Query().
    Order(
        sqljson.OrderLen(user.FieldData, sqljson.Path("key1", "key2")),
    ).
    AllX(ctx)

Descending

users := client.User.Query().
    Order(
        sqljson.OrderValueDesc(user.FieldData, sqljson.Path("key1", "key2")),
    ).
    AllX(ctx)

pets := client.Pet.Query().
    Order(
        sqljson.OrderLenDesc(pet.FieldData, sqljson.Path("key1", "key2")),
    ).
    AllX(ctx)

PostgreSQL limitation on ORDER BY expressions with SELECT DISTINCT

PostgreSQL does not support ORDER BY expressions with SELECT DISTINCT. Thus, the Unique modifier should be set to false. However, keep in mind that this may result in duplicate results when performing graph traversals.

users := client.User.Query().
    Order(
        sqljson.OrderValue(user.FieldData, sqljson.Path("key1", "key2")),
    ).
+   Unique(false).
    AllX(ctx)