/ /

Operadores

Operadores de pipeline de agregación

Docs Home

Manual de base de datos

Referencia

Operadores

Operadores de pipeline de agregación

$sortArray (agregación)

Esta versión de la documentación se archivó y ya no se admite. Para actualizar tu implementación de 6.0, consulta el Procedimientos de actualización de MongoDB.7.0

Definición

$sortArray

Nuevo en la versión 5.2.

Ordena un arreglo en función de sus elementos. El orden de clasificación lo especifica el usuario.

$sortArray tiene la siguiente sintaxis:

$sortArray: {
   input: <array>,
   sortBy: <sort spec>
}

Campo	Tipo	Descripción
`input`	expresión	El arreglo a ordenar. El resultado es `null` si la expresión: Se evalúa como faltante. Se evalúa como `null`. Se evalúa como `undefined`. Si la expresión se evalúa a cualquier otro valor que no sea un arreglo, la operación resultará en un error.
`sortBy`	documento o booleano	El documento especifica un orden de clasificación.

Comportamiento

La expresión $sortArray ordena el arreglo input de acuerdo con la especificación sortBy.

La $sortArray sintaxis y la semántica son las mismas que el comportamiento en un $push operación modificada por $sort.

Ordenar por campos de documento

Si los elementos del arreglo son documentos, puedes ordenar por un campo del documento. Especifica el nombre del campo y la dirección de ordenación, ascendente (1) o descendente (-1 ).

{
   input: <array-of-documents>,
   sortBy: { <document-field>: <sort-direction> }
}

Ordenar por Valor

Para ordenar todo el arreglo por valor, o para ordenar por elementos del arreglo que no son documentos, identifique el arreglo de entrada y especifique 1 para un orden ascendente o -1 para descendente en el parámetro sortBy.

{
   input: <array-of-documents>,
   sortBy: <sort-direction>
}

Considerations

No existe un recorrido implícito del arreglo en la clave de ordenación.
Los operadores posicionales no son compatibles. Un nombre de campo como "valores.1" denota un subcampo denominado "1" en el arreglo values. No se refiere al elemento en el índice 1 del arreglo values.
Cuando se ordena un arreglo completo, el ordenamiento es lexicográfico. La etapa de agregación $sort, se comporta de manera diferente. Para más detalles, consulta $sort.
Cuando un arreglo se ordena por un campo, cualquier documento o escalar que no contenga el campo especificado se ordena por igual. El orden resultante de clasificación no está definido.
null Los valores y los valores faltantes se ordenan por igual.

Estabilidad de clasificación

No se especifica la estabilidad del tipo de ordenamiento. Los usuarios no deben depender de $sortArray para utilizar un algoritmo de ordenamiento en particular.

Ejemplos

Los ejemplos en esta sección usan un arreglo team en una colección engineers.

db.engineers.insertOne(
   {
      team:
         [
            {
               name: "pat",
               age: 30,
               address: { street: "12 Baker St", city: "London" }
            },
            {
               name: "dallas",
               age: 36,
               address: { street: "12 Cowper St", city: "Palo Alto" }
            },
            {
              name: "charlie",
              age: 42,
              address: { street: "12 French St", city: "New Brunswick" }
            }
         ]
   }
)

El team arreglo tiene tres elementos. Cada elemento de team tiene subelementos anidados: name, age y address. Los siguientes ejemplos muestran cómo ordenar el arreglo team usando estos subelementos.

Ordenar por campo

La siguiente operación ordena en el campo name dentro del arreglo team:

db.engineers.aggregate( [
   { $project:
      {
         _id: 0,
         result:
            {
               $sortArray: { input: "$team", sortBy: { name: 1 } }
            }
      }
   }
] )

La operación devuelve los siguientes resultados:

{
   result:
      [
         {
            name: 'charlie',
            age: 42,
            address: { street: '12 French St', city: 'New Brunswick' }
         },
         {
            name: 'dallas',
            age: 36,
            address: { street: '12 Cowper St', city: 'Palo Alto' }
         },
         {
            name: 'pat',
            age: 30,
            address: { street: '12 Baker St', city: 'London' }
         }
      ]
}

Ordenar por un subcampo

La siguiente operación utiliza la notación de puntos para ordenar la matriz según el subcampo address:

db.engineers.aggregate( [
   {
      $project:
         {
                _id: 0,
                result:
               {
                  $sortArray:
                     {
                        input: "$team",
                        sortBy: { "address.city": -1 }
                     }
               }
             }
   }
] )

La dirección de clasificación es descendente porque el valor sortBy es "-1".

{
   result: [
      {
         name: 'dallas',
         age: 36,
         address: { street: '12 Cowper St', city: 'Palo Alto' }
      },
      {
         name: 'charlie',
         age: 42,
         address: { street: '12 French St', city: 'New Brunswick' }
      },
      {
         name: 'pat',
         age: 30,
         address: { street: '12 Baker St', city: 'London' }
      }
  ]
}

Ordenar en múltiples campos

La siguiente operación especifica múltiples campos de índice para realizar una ordenación compuesta dentro de la operación $sortArray:

db.engineers.aggregate( [
   {
      $project:
         {
            _id: 0,
            result:
               {
                  $sortArray:
                     {
                        input: "$team",
                        sortBy: { age: -1, name: 1 }
                     }
               }
         }
    }
 ] )

Ejemplo de salida:

{
   result: [
      {
         name: 'charlie',
         age: 42,
         address: { street: '12 French St', city: 'New Brunswick' }
      },
      {
         name: 'dallas',
         age: 36,
         address: { street: '12 Cowper St', city: 'Palo Alto' }
      },
      {
         name: 'pat',
         age: 30,
         address: { street: '12 Baker St', city: 'London' }
      }
   ]
}

Ordenar un arreglo de enteros

Este ejemplo especifica directamente una matriz de entrada. Todos los valores son del mismo tipo: Int32.

db.engineers.aggregate( [
   {
      $project:
         {
            _id: 0,
            result:
               {
                  $sortArray:
                     {
                         input: [ 1, 4, 1, 6, 12, 5 ],
                         sortBy: 1
                     }
               }
         }
   }
] )

Ejemplo de salida:

[ { result: [ 1, 1, 4, 5, 6, 12 ] } ]

La matriz de entrada tiene un "1" en la posición 0 y la posición 2. Los unos se agrupan en los resultados, pero no hay garantías sobre cómo se ordena el grupo de unos en relación con su orden original.

Ordenar en campos de tipo mixto

Este ejemplo especifica un arreglo de entrada directamente. Los valores tienen tipos diferentes:

db.engineers.aggregate( [
   {
      $project:
         {
            _id: 0,
            result:
            {
               $sortArray:
                  {
                     input: [ 20, 4, { a: "Free" }, 6, 21, 5, "Gratis",
                             { a: null }, { a: { sale: true, price: 19 } },
                             Decimal128( "10.23" ), { a: "On sale" } ],
                     sortBy: 1
                  }
            }
         }
   }
] )

Ejemplo de salida:

{ result:
   [
      4,
      5,
      6,
      Decimal128("10.23"),
      20,
      21,
      'Gratis',
      { a: null },
      { a: 'Free' },
      { a: 'On sale' },
      { a: { sale: true, price: 19 } }
   ]
}

Los resultados están ordenados.

En cambio, después de cambiar el campo sortBy para ordenar en uno de los campos del documento, sortBy: { a: 1 }, el orden de clasificación para los valores escalares y null no está definido:

{ result:
    [
       20,
       4,
       6,
       21,
       5,
       'Gratis',
       { a: null },
       Decimal128("10.23"),
       { a: 'Free' },
       { a: 'On sale' },
       { a: { sale: true, price: 19 } }
    ]
 }

Volver

$slice

$split