$ MaxN

Neu ab Version 8.0.1.

Der $maxN Operator in Amazon DocumentDB gibt die N größten Werte zurück. Wenn er als Akkumulator in einer $group Stufe verwendet wird, gibt er ein Array mit den N Maximalwerten in jeder Gruppe zurück. Wenn er als Array-Ausdrucksoperator verwendet wird, gibt er die N maximalen Elemente eines Arrays zurück.

Parameter

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

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

Behavior

Verhalten des Operators „Array-Ausdruck

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

• $maxNfiltert 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 $maxN 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 Zeichenkettenelemente gemäß der BSON-Vergleichsreihenfolge vor den numerischen Elementen 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

• $maxNfiltert Nullwerte und fehlende Werte heraus.

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

• $maxNvergleicht Eingabedaten gemäß der BSON-Vergleichsreihenfolge, um den geeigneten Ausgabetyp zu ermitteln. Wenn die Eingabedaten mehrere Datentypen enthalten, ist der $maxN Ausgabetyp der höchste in der Vergleichsreihenfolge.

Reihenfolge der Ausgaben

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

Beispiel (MongoDB Shell)

Das folgende Beispiel zeigt, wie der $maxN Akkumulator verwendet wird, um die beiden höchsten 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", highestTwo: { $maxN: { input: "$score", n: 2 } } } }
]);

Ausgabe

[
  { "_id": "math", "highestTwo": [85, 93] },
  { "_id": "science", "highestTwo": [88, 90] }
]

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

Der $maxN Operator kann auch als Ausdruck innerhalb einer $project Stufe verwendet werden, um die N größten 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: {
      highestThree: { $maxN: { input: "$values", n: 3 } }
    }}
]);

Ausgabe

[
  { "_id": 1, "highestThree": [45, 56, 78] },
  { "_id": 2, "highestThree": [44, 90, 67] }
]

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

Neu ab Version 8.0.2.

Der $maxN Operator kann auch als Fensterbediener auf der $setWindowFields Bühne verwendet werden. In diesem Zusammenhang gibt er ein Array mit bis zu den n größten 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 $maxN 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 hour und gibt die beiden höchsten Preise vom Anfang der Partition bis zum aktuellen Dokument zurück.

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

Ausgabe

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

Jedes Dokument wird um die beiden größten price Werte in seinem Fenster erweitert. highestTwoSoFar 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 $maxN 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 largest 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", 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');
    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: { highestThree: { $maxN: { input: "$values", n: 3 } } } }
    ]).toArray();
    console.log('Expression result:', expressionResult);

    // Window operator usage: N largest 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: {
            highestTwoSoFar: {
              $maxN: { 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 largest 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', 'highestTwo': { '$maxN': { 'input': '$score', 'n': 2 } } } }
        ]))
        print('Accumulator result:', accumulator_result)

        # Expression usage: N largest 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': { 'highestThree': { '$maxN': { 'input': '$values', 'n': 3 } } } }
        ]))
        print('Expression result:', expression_result)

        # Window operator usage: N largest 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': {
                        'highestTwoSoFar': {
                            '$maxN': { 'input': '$price', 'n': 2 },
                            'window': { 'documents': ['unbounded', 'current'] }
                        }
                    }
                }
            }
        ]))
        print('Window result:', window_result)

    finally:
        client.close()

example()