/ /

Operadores

Operadores de tuberías de agregación

Docs Home

Manual de base de datos

Referencia

Operadores

Operadores de tuberías de agregación

$sortArray (agregación)

Esta versión de la documentación está archivada y ya no recibe soporte. Para actualizar su implementación 6.0, consulte Procedimientos de actualización de MongoDB.7.0

Definición

$sortArray

Nuevo en la versión 5.2.

Ordena una matriz según 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	La matriz que se va 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 como cualquier otro valor que no sea una matriz, la operación genera un error.
`sortBy`	documento o booleano	El documento especifica un orden de clasificación.

Comportamiento

La expresión ordena $sortArray la input matriz según la sortBy especificación.

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

Ordenar por campos del documento

Si los elementos de la matriz son documentos, puede ordenar por un campo de documento. Especifique 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 toda la matriz por valor, o para ordenar por elementos de la matriz que no sean documentos, identifique la matriz de entrada y especifique 1 para una ordenación ascendente o -1 para una ordenación descendente en el parámetro sortBy.

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

Considerations

No existe un recorrido de matriz implícito 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 una matriz completa, la ordenación es lexicográfica. La etapa de agregación $sort se comporta de forma diferente. Consulte para obtener más $sort detalles.
Cuando una matriz se ordena por un campo, todos los documentos o escalares que no tengan el campo especificado se ordenan por igual. El orden resultante no está definido.
null Los valores y los valores faltantes se ordenan por igual.

Estabilidad de clasificación

No se especifica la estabilidad de la ordenación. Los usuarios no deben confiar en para usar un algoritmo de ordenación $sortArray específico.

Ejemplos

Los ejemplos de esta sección utilizan una matriz 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" }
            }
         ]
   }
)

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

Ordenar por campo

La siguiente operación ordena el campo name dentro de la matriz 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 una matriz de números 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 las posiciones 0 y 2. Los unos se agrupan en los resultados, pero no hay garantías de cómo se ordena el grupo de unos con respecto a su orden original.

Ordenar en campos de tipo mixto

Este ejemplo especifica directamente una matriz de entrada. Los valores son de diferentes tipos:

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.

Por el contrario, después de cambiar el campo sortBy para ordenar según 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