$ min

Neu ab Version 8.0.1.

Der $minN Operator in Amazon DocumentDB gibt die N kleinsten Werte zurück. Wenn er als Akkumulator in einer $group Stufe verwendet wird, gibt er ein Array mit den N Mindestwerten in jeder Gruppe zurück. Wenn er als Array-Ausdrucksoperator verwendet wird, gibt er die N minimalen Elemente eines Arrays zurück.

Parameter

• input: Ein Ausdruck, der in das Array oder Feld aufgelöst wird, aus dem die n Mindestwerte zurückgegeben werden sollen.

• n: Ein Ausdruck, der in eine positive Ganzzahl aufgelöst wird und angibt, wie viele Mindestwerte zurückgegeben werden sollen.

Behavior

Verhalten des Operators „Array-Ausdruck

• Sie können keinen Wert von n weniger als angeben1.

• $minNfiltert die im input Array gefundenen null Werte heraus.

• Wenn der angegebene n Wert größer oder gleich der Anzahl der Elemente im input Array ist, werden alle Elemente im input Array $minN zurückgegeben.

• Wenn es in einen Wert input aufgelöst wird, der kein Array ist, tritt bei der Aggregationsoperation ein Fehler auf.

• Wenn es sowohl numerische als auch Zeichenkettenelemente input enthält, werden die numerischen Elemente gemäß der BSON-Vergleichsreihenfolge vor den Zeichenkettenelementen sortiert.

Verhalten des Akkumulators

• Bei Verwendung als Akkumulator n muss es sich um einen positiven Integralausdruck handeln, der entweder eine Konstante ist oder vom _id Wert für abhängt. $group

• $minNfiltert Nullwerte und fehlende Werte heraus.

• Wenn die Gruppe weniger als n Elemente enthält, werden alle Elemente in der Gruppe $minN zurückgegeben.

• $minNvergleicht Eingabedaten gemäß der BSON-Vergleichsreihenfolge, um den geeigneten Ausgabetyp zu ermitteln. Wenn die Eingabedaten mehrere Datentypen enthalten, ist der $minN Ausgabetyp der niedrigste in der Vergleichsreihenfolge.

Reihenfolge der Ausgaben

$minNgibt Werte in keiner bestimmten Sortierreihenfolge zurück. Wenn die Garantie einer bestimmten Sortierreihenfolge erforderlich ist, verwenden Sie $bottomN stattdessen die Option oder schließen Sie das Ergebnis damit $sortArray ein.

Beispiel (MongoDB Shell)

Das folgende Beispiel zeigt, wie der $minN Akkumulator verwendet wird, um die beiden niedrigsten Punktzahlen für jedes Subjekt abzurufen.

Erstellen Sie Beispieldokumente

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 }
]);

Beispiel für eine Abfrage

db.scores.aggregate([
  { $group: { _id: "$subject", lowestTwo: { $minN: { input: "$score", n: 2 } } } }
]);

Ausgabe

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

Beispiel für die Verwendung von Ausdrücken (MongoDB Shell)

Der $minN Operator kann auch als Ausdruck innerhalb einer $project Stufe verwendet werden, um die N kleinsten Elemente aus einem Array-Feld zurückzugeben.

Erstellen Sie Beispieldokumente

db.readings.insertMany([
  { _id: 1, sensor: "A", values: [45, 12, 78, 3, 56] },
  { _id: 2, sensor: "B", values: [90, 23, 67, 11, 44] }
]);

Beispiel für eine Abfrage

db.readings.aggregate([
  { $project: {
      lowestThree: { $minN: { input: "$values", n: 3 } }
    }}
]);

Ausgabe

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

Beispiel für die Verwendung von Fensteroperatoren (MongoDB Shell)

Neu ab Version 8.0.2.

Der $minN Operator kann auch als Fensterbediener auf der $setWindowFields Bühne verwendet werden. In diesem Zusammenhang gibt er ein Array mit bis zu den n kleinsten Werten für die Dokumente in jedem Fenster zurück. Sie geben den Operator unter dem output Feld an und definieren optional die Fenstergrenzen mit einem window Dokument.

Anmerkung

Bei Verwendung als Fensteroperator in $setWindowFields $minN ist er auf 100 MB an Zwischendaten begrenzt. Eine Operation, die dieses Limit überschreitet, gibt einen Fehler zurück.

Erstellen Sie Beispieldokumente

db.stockPrices.insertMany([
  { _id: 1, ticker: "ABC", hour: 1, price: 50 },
  { _id: 2, ticker: "ABC", hour: 2, price: 45 },
  { _id: 3, ticker: "ABC", hour: 3, price: 60 },
  { _id: 4, ticker: "ABC", hour: 4, price: 40 },
  { _id: 5, ticker: "XYZ", hour: 1, price: 30 },
  { _id: 6, ticker: "XYZ", hour: 2, price: 35 },
  { _id: 7, ticker: "XYZ", hour: 3, price: 25 }
]);

Beispiel für eine Abfrage

Das folgende Beispiel partitioniert die Dokumente nachticker, sortiert jede Partition nach und gibt die beiden niedrigsten Preise zurückhour, die vom Anfang der Partition bis zum aktuellen Dokument angezeigt wurden.

db.stockPrices.aggregate([
  {
    $setWindowFields: {
      partitionBy: "$ticker",
      sortBy: { hour: 1 },
      output: {
        lowestTwoSoFar: {
          $minN: { input: "$price", n: 2 },
          window: { documents: ["unbounded", "current"] }
        }
      }
    }
  }
]);

Ausgabe

[
  { "_id": 1, "ticker": "ABC", "hour": 1, "price": 50, "lowestTwoSoFar": [50] },
  { "_id": 2, "ticker": "ABC", "hour": 2, "price": 45, "lowestTwoSoFar": [45, 50] },
  { "_id": 3, "ticker": "ABC", "hour": 3, "price": 60, "lowestTwoSoFar": [45, 50] },
  { "_id": 4, "ticker": "ABC", "hour": 4, "price": 40, "lowestTwoSoFar": [40, 45] },
  { "_id": 5, "ticker": "XYZ", "hour": 1, "price": 30, "lowestTwoSoFar": [30] },
  { "_id": 6, "ticker": "XYZ", "hour": 2, "price": 35, "lowestTwoSoFar": [30, 35] },
  { "_id": 7, "ticker": "XYZ", "hour": 3, "price": 25, "lowestTwoSoFar": [25, 30] }
]

Jedes Dokument wird um die beiden kleinsten price Werte in seinem Fenster erweitert. lowestTwoSoFar Wie im Abschnitt Reihenfolge der Ausgaben erwähnt, ist die Reihenfolge der Werte innerhalb des zurückgegebenen Arrays nicht garantiert.

Codebeispiele

Um ein Codebeispiel für die Verwendung des $minN Operators anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten. Die folgenden Beispiele zeigen die Verwendung von Akkumulatoren (in$group), Ausdrücken (in$project) und Fensteroperatoren (in$setWindowFields):

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');
    await 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 }
    ]);
    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');
    await readings.insertMany([
      { _id: 1, sensor: "A", values: [45, 12, 78, 3, 56] },
      { _id: 2, sensor: "B", values: [90, 23, 67, 11, 44] }
    ]);
    const expressionResult = await readings.aggregate([
      { $project: { lowestThree: { $minN: { input: "$values", n: 3 } } } }
    ]).toArray();
    console.log('Expression result:', expressionResult);

    // Window operator usage: N smallest values over a window in each partition
    const stockPrices = db.collection('stockPrices');
    await stockPrices.insertMany([
      { _id: 1, ticker: "ABC", hour: 1, price: 50 },
      { _id: 2, ticker: "ABC", hour: 2, price: 45 },
      { _id: 3, ticker: "ABC", hour: 3, price: 60 },
      { _id: 4, ticker: "ABC", hour: 4, price: 40 },
      { _id: 5, ticker: "XYZ", hour: 1, price: 30 },
      { _id: 6, ticker: "XYZ", hour: 2, price: 35 },
      { _id: 7, ticker: "XYZ", hour: 3, price: 25 }
    ]);
    const windowResult = await stockPrices.aggregate([
      {
        $setWindowFields: {
          partitionBy: "$ticker",
          sortBy: { hour: 1 },
          output: {
            lowestTwoSoFar: {
              $minN: { input: "$price", n: 2 },
              window: { documents: ["unbounded", "current"] }
            }
          }
        }
      }
    ]).toArray();
    console.log('Window result:', windowResult);

  } 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']
        scores.insert_many([
            { '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 }
        ])
        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']
        readings.insert_many([
            { '_id': 1, 'sensor': 'A', 'values': [45, 12, 78, 3, 56] },
            { '_id': 2, 'sensor': 'B', 'values': [90, 23, 67, 11, 44] }
        ])
        expression_result = list(readings.aggregate([
            { '$project': { 'lowestThree': { '$minN': { 'input': '$values', 'n': 3 } } } }
        ]))
        print('Expression result:', expression_result)

        # Window operator usage: N smallest values over a window in each partition
        stock_prices = db['stockPrices']
        stock_prices.insert_many([
            { '_id': 1, 'ticker': 'ABC', 'hour': 1, 'price': 50 },
            { '_id': 2, 'ticker': 'ABC', 'hour': 2, 'price': 45 },
            { '_id': 3, 'ticker': 'ABC', 'hour': 3, 'price': 60 },
            { '_id': 4, 'ticker': 'ABC', 'hour': 4, 'price': 40 },
            { '_id': 5, 'ticker': 'XYZ', 'hour': 1, 'price': 30 },
            { '_id': 6, 'ticker': 'XYZ', 'hour': 2, 'price': 35 },
            { '_id': 7, 'ticker': 'XYZ', 'hour': 3, 'price': 25 }
        ])
        window_result = list(stock_prices.aggregate([
            {
                '$setWindowFields': {
                    'partitionBy': '$ticker',
                    'sortBy': { 'hour': 1 },
                    'output': {
                        'lowestTwoSoFar': {
                            '$minN': { 'input': '$price', 'n': 2 },
                            'window': { 'documents': ['unbounded', 'current'] }
                        }
                    }
                }
            }
        ]))
        print('Window result:', window_result)

    finally:
        client.close()

example()