Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# $ maximum N
Nouveau depuis la version 8.0.1.
L'`$maxN`opérateur d'Amazon DocumentDB renvoie les N plus grandes valeurs. Lorsqu'il est utilisé comme accumulateur dans une `$group` étape, il renvoie un tableau des N valeurs maximales de chaque groupe. Lorsqu'il est utilisé comme opérateur d'expression de tableau, il renvoie les N éléments maximum d'un tableau.
**Paramètres**
+ `input`: expression qui renvoie au tableau ou au champ à partir duquel les `n` valeurs maximales doivent être renvoyées.
+ `n`: expression qui se résout en un entier positif spécifiant le nombre de valeurs maximales à renvoyer.
## Comportement
**Comportement des opérateurs d'expression de tableau **
+ Vous ne pouvez pas spécifier une valeur `n` inférieure à`1`.
+ `$maxN`filtre les `null` valeurs présentes dans le `input` tableau.
+ Si la valeur spécifiée `n` est supérieure ou égale au nombre d'éléments du `input` tableau, `$maxN` renvoie tous les éléments du `input` tableau.
+ Si elle est `input` résolue en une valeur non matricielle, l'opération d'agrégation entraîne des erreurs.
+ S'il `input` contient à la fois des éléments numériques et des éléments de chaîne, les éléments de chaîne sont triés avant les éléments numériques selon l'ordre de comparaison BSON.
**Comportement de l'accumulateur **
+ Lorsqu'il est utilisé comme accumulateur, `n` il doit s'agir d'une expression intégrale positive qui est soit une constante, soit dépend de la `_id` valeur de`$group`.
+ `$maxN`filtre les valeurs nulles et manquantes.
+ Si le groupe contient moins d'`n`éléments, `$maxN` renvoie tous les éléments du groupe.
+ `$maxN`compare les données d'entrée selon l'ordre de comparaison BSON pour déterminer le type de sortie approprié. Lorsque les données d'entrée contiennent plusieurs types de données, le type `$maxN` de sortie est le plus élevé dans l'ordre de comparaison.
**Ordre des sorties **
`$maxN`renvoie des valeurs sans ordre de tri particulier. S'il est obligatoire de garantir un ordre de tri particulier, `$topN` utilisez-le plutôt ou enveloppez le résultat avec`$sortArray`.
## Exemple (MongoDB Shell)
L'exemple suivant montre comment utiliser l'`$maxN`accumulateur pour récupérer les deux meilleurs scores pour chaque sujet.
**Créez des exemples de documents **
```
db.scores.insertMany([
{ subject: "math", score: 85 },
{ subject: "math", score: 72 },
{ subject: "math", score: 93 },
{ subject: "math", score: 68 },
{ subject: "science", score: 90 },
{ subject: "science", score: 78 },
{ subject: "science", score: 65 },
{ subject: "science", score: 88 }
]);
```
**Exemple de requête **
```
db.scores.aggregate([
{ $group: { _id: "$subject", highestTwo: { $maxN: { input: "$score", n: 2 } } } }
]);
```
**Sortie**
```
[
{ "_id": "math", "highestTwo": [85, 93] },
{ "_id": "science", "highestTwo": [88, 90] }
]
```
## Exemple d'utilisation d'expressions (MongoDB Shell)
L'`$maxN`opérateur peut également être utilisé comme expression au sein d'une `$project` étape pour renvoyer les N plus grands éléments d'un champ de tableau.
**Créez des exemples de documents **
```
db.readings.insertMany([
{ _id: 1, sensor: "A", values: [45, 12, 78, 3, 56] },
{ _id: 2, sensor: "B", values: [90, 23, 67, 11, 44] }
]);
```
**Exemple de requête **
```
db.readings.aggregate([
{ $project: {
highestThree: { $maxN: { input: "$values", n: 3 } }
}}
]);
```
**Sortie**
```
[
{ "_id": 1, "highestThree": [45, 56, 78] },
{ "_id": 2, "highestThree": [44, 90, 67] }
]
```
## Exemples de code
Pour afficher un exemple de code d'utilisation de l'`$maxN`opérateur, choisissez l'onglet correspondant à la langue que vous souhaitez utiliser. Les exemples suivants montrent à la fois l'utilisation de l'accumulateur (in`$group`) et l'utilisation de l'expression (in`$project`) :
------
#### [ Node.js ]
```
const { MongoClient } = require('mongodb');
async function example() {
const client = new MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
try {
await client.connect();
const db = client.db('test');
// Accumulator usage: N largest values per group
const scores = db.collection('scores');
const accumulatorResult = await scores.aggregate([
{ $group: { _id: "$subject", highestTwo: { $maxN: { input: "$score", n: 2 } } } }
]).toArray();
console.log('Accumulator result:', accumulatorResult);
// Expression usage: N largest elements from an array field
const readings = db.collection('readings');
const expressionResult = await readings.aggregate([
{ $project: { highestThree: { $maxN: { input: "$values", n: 3 } } } }
]).toArray();
console.log('Expression result:', expressionResult);
} finally {
await client.close();
}
}
example();
```
------
#### [ Python ]
```
from pymongo import MongoClient
def example():
client = MongoClient('mongodb://:@:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
try:
db = client['test']
# Accumulator usage: N largest values per group
scores = db['scores']
accumulator_result = list(scores.aggregate([
{ '$group': { '_id': '$subject', 'highestTwo': { '$maxN': { 'input': '$score', 'n': 2 } } } }
]))
print('Accumulator result:', accumulator_result)
# Expression usage: N largest elements from an array field
readings = db['readings']
expression_result = list(readings.aggregate([
{ '$project': { 'highestThree': { '$maxN': { 'input': '$values', 'n': 3 } } } }
]))
print('Expression result:', expression_result)
finally:
client.close()
example()
```
------