View a markdown version of this page

millions de dollars - Amazon DocumentDB
ComportementExemple (MongoDB Shell)Exemple d'utilisation d'expressions (MongoDB Shell)Exemples de code

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.

millions de dollars

Nouveau depuis la version 8.0.1.

L'$minNopérateur d'Amazon DocumentDB renvoie les N plus petites valeurs. Lorsqu'il est utilisé comme accumulateur dans une $group étape, il renvoie un tableau des N valeurs minimales de chaque groupe. Lorsqu'il est utilisé comme opérateur d'expression de tableau, il renvoie les N éléments minimum d'un tableau.

Paramètres

  • input: expression qui renvoie au tableau ou au champ à partir duquel les n valeurs minimales doivent être renvoyées.

  • n: expression qui se résout en un entier positif spécifiant le nombre de valeurs minimales à renvoyer.

Comportement

Comportement des opérateurs d'expression de tableau

  • Vous ne pouvez pas spécifier une valeur n inférieure à1.

  • $minNfiltre 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, $minN 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 numériques sont triés avant les éléments de chaîne 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.

  • $minNfiltre les valeurs nulles et manquantes.

  • Si le groupe contient moins d'néléments, $minN renvoie tous les éléments du groupe.

  • $minNcompare 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 $minN de sortie est le plus bas dans l'ordre de comparaison.

Ordre des sorties

$minNrenvoie des valeurs sans ordre de tri particulier. S'il est obligatoire de garantir un ordre de tri particulier, $bottomN utilisez-le plutôt ou enveloppez le résultat avec$sortArray.

Exemple (MongoDB Shell)

L'exemple suivant montre comment utiliser l'$minNaccumulateur pour récupérer les deux scores les plus faibles 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", lowestTwo: { $minN: { input: "$score", n: 2 } } } }
]);

Sortie

[
  { "_id": "math", "lowestTwo": [72, 68] },
  { "_id": "science", "lowestTwo": [78, 65] }
]

Exemple d'utilisation d'expressions (MongoDB Shell)

L'$minNopérateur peut également être utilisé comme expression au sein d'une $project étape pour renvoyer les N plus petits é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: {
      lowestThree: { $minN: { input: "$values", n: 3 } }
    }}
]);

Sortie

[
  { "_id": 1, "lowestThree": [45, 12, 3] },
  { "_id": 2, "lowestThree": [44, 23, 11] }
]

Exemples de code

Pour afficher un exemple de code d'utilisation de l'$minNopé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://<username>:<password>@<cluster-endpoint>: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 smallest values per group
    const scores = db.collection('scores');
    const accumulatorResult = await scores.aggregate([
      { $group: { _id: "$subject", lowestTwo: { $minN: { input: "$score", n: 2 } } } }
    ]).toArray();
    console.log('Accumulator result:', accumulatorResult);

    // Expression usage: N smallest elements from an array field
    const readings = db.collection('readings');
    const expressionResult = await readings.aggregate([
      { $project: { lowestThree: { $minN: { 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://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')

    try:
        db = client['test']

        # Accumulator usage: N smallest values per group
        scores = db['scores']
        accumulator_result = list(scores.aggregate([
            { '$group': { '_id': '$subject', 'lowestTwo': { '$minN': { 'input': '$score', 'n': 2 } } } }
        ]))
        print('Accumulator result:', accumulator_result)

        # Expression usage: N smallest elements from an array field
        readings = db['readings']
        expression_result = list(readings.aggregate([
            { '$project': { 'lowestThree': { '$minN': { 'input': '$values', 'n': 3 } } } }
        ]))
        print('Expression result:', expression_result)

    finally:
        client.close()

example()