Abfragen in Amazon DocumentDB - Amazon DocumentDB
Dokumente abfragenAbfrageplanErläutern Sie die Ergebnisse

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Abfragen in Amazon DocumentDB

In diesem Abschnitt werden alle Aspekte der Abfrage mit Amazon DocumentDB erklärt.

Themen

Dokumente abfragen

Manchmal müssen Sie möglicherweise den Bestand Ihres Online-Shops nachschlagen, damit Kunden das Angebot sehen und kaufen können. Die Abfrage einer Sammlung ist relativ einfach, unabhängig davon, ob Sie alle Dokumente in der Sammlung haben möchten oder nur die Dokumente, die ein bestimmtes Kriterium erfüllen.

Verwenden Sie die Operation find(), um Dokumente abzufragen. Der Befehl find() hat einen einzigen Dokumentenparameter, der die Kriterien für die Auswahl der zurückzugebenden Dokumente definiert. Die Ausgabe von find() ist ein Dokument, das als einzelne Textzeile ohne Zeilenumbrüche formatiert ist. Um das Ausgabedokument für eine bessere Lesbarkeit zu formatieren, verwenden Sie find().pretty(). Alle Beispiele in diesem Thema verwenden .pretty() zum Formatieren der Ausgabe.

In den folgenden Codebeispielen werden die vier Dokumente verwendet, die Sie in den beiden vorangegangenen Übungen in insertMany() die example Sammlung eingefügt haben. Sie befinden sich im Abschnitt Dokumente hinzufügen von Arbeiten mit Dokumenten. insertOne()

Alle Dokumente in einer Sammlung werden abgerufen

Um alle Dokumente in Ihrer Sammlung abzurufen, verwenden Sie die Operation find() mit einem leeren Abfragedokument.

Die folgende Abfrage gibt alle Dokumente der Sammlung example zurück.

db.example.find( {} ).pretty()

Dokumente werden abgerufen, die einem Feldwert entsprechen

Um alle Dokumente abzurufen, die mit einem Feld und einem Wert übereinstimmen, verwenden Sie die Operation find() mit einem Abfragedokument, das die entsprechenden Felder und Werte identifiziert.

Bei Verwendung der vorangegangenen Dokumente gibt diese Abfrage alle Dokumente zurück, bei denen das Feld "Item" (Element) "Pen" (Stift) entspricht.

db.example.find( { "Item": "Pen" } ).pretty()

Dokumente werden abgerufen, die einem eingebetteten Dokument entsprechen

Um alle Dokumente zu suchen, die mit einem eingebetteten Dokument übereinstimmen, verwenden Sie die Operation find() mit einem Abfragedokument, in dem der Name des eingebetteten Dokuments sowie alle Felder und Werte für dieses eingebettete Dokument angegeben werden.

Beim Vergleichen mit einem eingebetteten Dokument muss das eingebettete Dokument denselben Namen haben wie in der Abfrage. Zudem müssen die Felder und Werte im eingebetteten Dokument mit der Abfrage übereinstimmen.

Die folgende Abfrage gibt nur das Dokument "Poster Paint" zurück. Dies liegt daran, dass "Pen" über verschiedene Werte für "OnHand" und "MinOnHand" verfügt und "Spray Paint" ein weiteres Feld (OrderQnty) als das Abfragedokument besitzt.

db.example.find({"Inventory": {
    "OnHand": 47,
    "MinOnHand": 50 } } ).pretty()

Dokumente werden abgerufen, die einem Feldwert in einem eingebetteten Dokument entsprechen

Um alle Dokumente zu suchen, die mit einem eingebetteten Dokument übereinstimmen, verwenden Sie die Operation find() mit einem Abfragedokument, in dem der Name des eingebetteten Dokuments sowie alle Felder und Werte für dieses eingebettete Dokument angegeben werden.

Aufgrund der vorangegangenen Dokumente verwendet die folgende Abfrage "Punktnotation", um das eingebettete Dokument und die Felder von Interesse anzugeben. Jedes Dokument, das damit übereinstimmt, wird zurückgegeben, unabhängig davon, welche anderen Felder im eingebetteten Dokument vorhanden sind. Die Abfrage gibt "Poster Paint" und "Spray Paint" zurück, weil sie beide den angegebenen Feldern und Werten entsprechen.

db.example.find({"Inventory.OnHand": 47, "Inventory.MinOnHand": 50 }).pretty()

Dokumente werden abgerufen, die einem Array entsprechen

Um alle Dokumente zu finden, die einem Array entsprechen, verwenden Sie die Operation find() mit dem Namen des Arrays, an dem Sie interessiert sind, und allen Werten in diesem Array. Die Abfrage gibt alle Dokumente zurück, in denen sich ein Array mit diesem Namen befindet und in denen die Array-Werte identisch sind und die gleiche Reihenfolge wie in der Abfrage aufweisen.

Die folgende Abfrage gibt nur "Pen" zurück, da "Poster Paint" über eine zusätzlichen Farbe (White) verfügt und die Farben in "Spray Paint" in einer anderen Reihenfolge vorliegen.

db.example.find( { "Colors": ["Red","Green","Blue","Black"] } ).pretty()

Dokumente werden abgerufen, die einem Wert in einem Array entsprechen

Um alle Dokumente mit einem bestimmten Array-Wert zu finden, verwenden Sie die Operation find() mit dem Namen und Wert des Arrays, an dem Sie interessiert sind.

db.example.find( { "Colors": "Red" } ).pretty()

Bei der vorherigen Operation werden alle drei Dokumente zurückgegeben, da jedes davon ein Array mit dem Namen Colors und den Wert "Red" irgendwo im Array besitzt. Wenn Sie den Wert "White" angeben, gibt die Abfrage nur "Poster Paint" zurück.

Dokumente mithilfe von Operatoren abrufen

Die folgende Abfrage gibt alle Dokumente zurück, in denen der Wert "Inventory.OnHand" kleiner als 50 ist.

db.example.find(
        { "Inventory.OnHand": { $lt: 50 } } )

Eine Liste der unterstützten Abfrageoperatoren finden Sie unter Abfrage- und Projektionsoperatoren.

Abfrageplan

Wie kann ich die executionStats für einen Abfrageplan anzeigen?

Wenn Sie ermitteln, warum eine Abfrage langsamer als erwartet ausgeführt wird, kann es hilfreich sein zu verstehen, was die executionStats für den Abfrageplan sind. Die executionStats geben die Anzahl der Dokumente an, die von einer bestimmten Stufe zurückgegeben wurden (nReturned), die in jeder Stufe verbrachte Ausführungszeit (executionTimeMillisEstimate) und die Zeit, die zum Generieren eines Abfrageplans benötigt wird (planningTimeMillis). Sie können die zeitintensivsten Stufen Ihrer Abfrage bestimmen, um Ihre Optimierungsbemühungen aus der Ausgabe von executionStats zu konzentrieren, wie in den Abfragebeispielen unten gezeigt. Der executionStats-Parameter unterstützt derzeit keine update- und delete-Befehle.

Anmerkung

Amazon DocumentDB emuliert MongoDB 3.6 API auf einer speziell entwickelten Datenbank-Engine, die ein verteiltes, fehlertolerantes, selbstheilendes Speichersystem verwendet. Daher explain() können sich die Abfragepläne und die Ausgabe von zwischen Amazon DocumentDB und MongoDB unterscheiden. Kunden, die die Kontrolle über ihren Abfrageplan wünschen, können den $hint-Operator verwenden, um die Auswahl eines bevorzugten Indexes zu erzwingen.

Führen Sie die Abfrage, die Sie verbessern möchten, unter dem Befehl explain() wie folgt aus.

db.runCommand({explain: {query document}}).
explain("executionStats").executionStats;

Im Folgenden finden Sie eine Beispieloperation.

db.fish.find({}).limit(2).explain("executionStats");

Die Ausgabe dieser Operation sieht in etwa folgendermaßen aus.

{
    "queryPlanner" : {
        "plannerVersion" : 1,
        "namespace" : "test.fish",
        "winningPlan" : {
            "stage" : "SUBSCAN",
            "inputStage" : {
                "stage" : "LIMIT_SKIP",
                "inputStage" : {
                    "stage" : "COLLSCAN"
                }
            }
        }
    },
    "executionStats" : {
        "executionSuccess" : true,
        "executionTimeMillis" : "0.063",
        "planningTimeMillis" : "0.040",
        "executionStages" : {
            "stage" : "SUBSCAN",
            "nReturned" : "2",
            "executionTimeMillisEstimate" : "0.012",
            "inputStage" : {
                "stage" : "LIMIT_SKIP",
                "nReturned" : "2",
                "executionTimeMillisEstimate" : "0.005",
                "inputStage" : {
                    "stage" : "COLLSCAN",
                    "nReturned" : "2",
                    "executionTimeMillisEstimate" : "0.005"
                }
            }
        }
    },
    "serverInfo" : {
        "host" : "enginedemo",
        "port" : 27017,
        "version" : "3.6.0"
    },
    "ok" : 1
}

Wenn Sie nur die executionStats aus der obigen Abfrage sehen möchten, können Sie den folgenden Befehl verwenden. Bei kleinen Sammlungen kann der Amazon DocumentDB DocumentDB-Abfrageprozessor entscheiden, keinen Index zu verwenden, wenn die Leistungssteigerung vernachlässigbar ist.

db.fish.find({}).limit(2).explain("executionStats").executionStats;

Cache für den Abfrageplan

Um die Leistung zu optimieren und die Planungsdauer zu verkürzen, speichert Amazon DocumentDB interne Abfragepläne im Cache. Auf diese Weise können Abfragen mit derselben Form direkt mithilfe eines zwischengespeicherten Plans ausgeführt werden.

Dieses Zwischenspeichern kann jedoch manchmal zu einer zufälligen Verzögerung für dieselbe Abfrage führen. Beispielsweise kann eine Abfrage, deren Ausführung normalerweise eine Sekunde dauert, gelegentlich zehn Sekunden dauern. Das liegt daran, dass die Leserinstanz im Laufe der Zeit verschiedene Formen der Abfrage zwischengespeichert hat, wodurch Speicherplatz verbraucht wurde. Wenn diese zufällige Verlangsamung auftritt, müssen Sie nichts unternehmen, um den Speicher freizugeben. Das System verwaltet die Speicherauslastung für Sie und sobald der Speicher einen bestimmten Schwellenwert erreicht hat, wird er automatisch freigegeben.

Erläutern Sie die Ergebnisse

Wenn Sie Informationen zu Abfrageplänen zurückgeben möchten, unterstützt Amazon DocumentDB den Ausführlichkeitsmodus. queryPlanner Die explain Ergebnisse geben den ausgewählten Abfrageplan zurück, der vom Optimierer ausgewählt wurde, in einem Format, das dem folgenden ähnelt:

{
   "queryPlanner" : {
      "plannerVersion" : <int>,
      "namespace" : <string>,
      "winningPlan" : {
         "stage" : <STAGE1>,
         ...
         "inputStage" : {
            "stage" : <STAGE2>,
            ...
            "inputStage" : {
               ...
            }
         }
      }
   }
}

In den folgenden Abschnitten werden allgemeine explain Ergebnisse definiert.

Phase des Scannens und Filterns

Der Optimierer kann einen der folgenden Scans wählen:

COLLSCAN

Bei dieser Phase handelt es sich um einen sequentiellen Sammelscan.

{
    "stage" : "COLLSCAN"
}

IXSCAN

In dieser Phase werden die Indexschlüssel gescannt. Der Optimierer kann das Dokument in dieser Phase abrufen, was dazu führen kann, dass später eine FETCH Phase angehängt wird.

db.foo.find({"a": 1})
{
    "stage" : "IXSCAN",
    "direction" : "forward",
    "indexName" : <idx_name>
}

FETCH

Wenn der Optimierer Dokumente in einer anderen Phase als abgerufen hatIXSCAN, enthält das Ergebnis eine Phase. FETCH Die obige IXSCAN Abfrage kann beispielsweise zu einer Kombination von FETCH und IXSCAN -Phasen führen:

db.foo.find({"a": 1})
{
    "stage" : "FETCH",
    "inputStage" : {
        "stage" : "IXSCAN",
        "indexName" : <idx_name>
    }
}

IXONLYSCANscannt nur den Indexschlüssel. Das Erstellen zusammengesetzter Indizes wird nicht vermiedenFETCH.

Schnittmenge im Index

IXAND

Amazon DocumentDB kann eine IXAND Stufe mit einem inputStages Array enthalten, IXSCAN ob es Indexschnittstellen nutzen kann. Zum Beispiel könnten wir eine Ausgabe wie die folgende sehen:

{
    "stage" : "FETCH",
    "inputStage" : {
        "stage" : "IXAND",
        "inputStages" : [
            {
                "stage" : "IXSCAN",
                "indexName" : "a_1"
            },
            {
                "stage" : "IXSCAN",
                "indexName" : "b_1"
            }
        ]
    }
}

Vereinigung des Indexes

IXOR

Ähnlich wie bei der Indexüberschneidung kann Amazon DocumentDB eine IXOR Stufe mit einem inputStages Array für den $or Operator enthalten.

db.foo.find({"$or": [{"a": {"$gt": 2}}, {"b": {"$lt": 2}}]})

Für die obige Abfrage könnte die Ausgabe von Explain wie folgt aussehen:

{
    "stage" : "FETCH",
    "inputStage" : {
        "stage" : "IXOR",
        "inputStages" : [
            {
                "stage" : "IXSCAN",
                "indexName" : "a_1"
            },
            {
                "stage" : "IXSCAN",
                "indexName" : "b_1"
            }
        ]
    }
}

Schnittpunkt/Vereinigung mehrerer Indizes

Amazon DocumentDB kann mehrere Indexüberschneidungs- oder Union-Phasen miteinander kombinieren und dann das Ergebnis abrufen. Beispielsweise:

{
    "stage" : "FETCH",
    "inputStage" : {
        "stage" : "IXOR",
        "inputStages" : [
            {
                "stage" : "IXSCAN",
                ...
            },
            {
                "stage" : "IXAND",
                "inputStages" : [
                    {
                        "stage" : "IXSCAN",
                        ...
                    },
                    {
                        "stage" : "IXSCAN",
                        ...
                    }
                ]
            }
        ]
    }
}

Der Indextyp (Sparse, Compound usw.) hat keinen Einfluss auf die Verwendung der Stufen „Indexüberschneidung“ oder „Union“.

Zusammengesetzter Index

Die Verwendung des zusammengesetzten Indexes von Amazon DocumentDB ist nicht auf die ersten Teilmengen indizierter Felder beschränkt. Es kann den Index mit dem Suffixteil verwenden, ist aber möglicherweise nicht sehr effizient.

Beispielsweise { a: 1, b: -1 } kann der zusammengesetzte Index von alle drei folgenden Abfragen unterstützen:

db.orders.find( { a: 1 } } )

db.orders.find( { b: 1 } } )

db.orders.find( { a: 1, b: 1 } } )

Phase „Sortieren“

Wenn es einen Index für die angeforderten Sortierschlüssel gibt, kann Amazon DocumentDB den Index verwenden, um die Reihenfolge abzurufen. In diesem Fall enthält das Ergebnis keine SORT Phase, sondern eine IXSCAN Phase. Wenn der Optimierer eine einfache Sortierung bevorzugt, wird er eine Phase wie die folgende enthalten:

{
    "stage" : "SORT",
    "sortPattern" : {
        "a" : 1,
        "b" : -1
    }
}

Gruppenphase

Amazon DocumentDB unterstützt zwei verschiedene Gruppenstrategien:

  • SORT_AGGREGATE: Aggregat zum Sortieren auf der Festplatte.

  • HASH_AGGREGATE: Hash-Aggregat im Speicher.