MongoDB Queries: So funk­tio­nie­ren die Da­ten­ab­fra­gen

Mit MongoDB Queries durch­su­chen und ana­ly­sie­ren Sie Ihre Datenbank schnell und effektiv. Der Aufbau der Methode ist sehr logisch und erlaubt den Einsatz zahl­rei­cher Parameter, mit denen Sie Anfragen spe­zi­fi­zie­ren können.

Samm­lun­gen effektiv durch­su­chen

Als do­ku­men­ten­ba­sier­te NoSQL-Lösung bietet MongoDB die Mög­lich­keit, auch große und viel­fäl­ti­ge Da­ten­men­gen einfach zu speichern und zu verwalten. Das Da­ten­bank­ma­nage­ment­sys­tem ist sehr flexibel und leicht ho­ri­zon­tal ska­lier­bar.

Anders als bei re­la­tio­na­len Da­ten­ban­ken werden hier die Daten in BSON-Do­ku­men­ten (Binary JSON) ge­spei­chert und in Coll­ec­tions oder Samm­lun­gen gebündelt. Damit dieser Ansatz auch wirklich funk­tio­niert, benötigt es starke Ab­fra­ge­me­cha­nis­men, die die Datenbank filtern und nur die wirklich be­nö­tig­ten In­for­ma­tio­nen prä­sen­tie­ren. Diese MongoDB Queries durch­su­chen selbst weit­ver­zweig­te Samm­lun­gen und liefern die gesuchten In­for­ma­tio­nen.

Was sind MongoDB Queries?

MongoDB Queries sind dabei ein be­nut­zer­freund­li­ches Tool, um komplexe Da­ten­struk­tu­ren zu durch­su­chen. Sie folgen logischen Regeln und funk­tio­nie­ren wie die von vielen Websites bekannten Fil­ter­op­tio­nen. Sie haben dadurch die Mög­lich­keit, Ihre Suche möglichst präzise zu for­mu­lie­ren und so die best­mög­li­chen Er­geb­nis­se zu erzielen. Das ist gerade auch deshalb wichtig, da MongoDB die Option bietet, viele ver­schie­de­ne Da­ten­ty­pen zu speichern. Ohne die not­wen­di­gen Fil­ter­mög­lich­kei­ten wäre es nur schwer­lich möglich, die Datenbank zu­frie­den­stel­lend zu verwalten. Wie Sie MongoDB Queries ganz einfach erstellen und so für sich nutzen können, erklären wir Ihnen nun Schritt für Schritt.

Welche Vor­aus­set­zun­gen gibt es für MongoDB Queries?

Um MongoDB Queries nutzen zu können, sind nur wenige Vor­aus­set­zun­gen nötig.

1. Sie müssen MongoDB zunächst auf Ihrem Rechner in­stal­lie­ren. Die Datenbank funk­tio­niert auf vielen Be­triebs­sys­te­men, sodass es für diese Anleitung keinen großen Un­ter­schied macht, ob Sie Linux, OS X oder Windows verwenden. Die Ar­beits­schrit­te über die In­stal­la­ti­on hinaus sind auf allen Systemen gleich und betreffen nur die Datenbank selbst. Wie die In­stal­la­ti­on funk­tio­niert, erfahren Sie in unserem MongoDB-Tutorial.
2. Vor­aus­set­zung für die Such­funk­ti­on sind außerdem Ad­mi­nis­tra­ti­ons­rech­te.
3. Erstellen Sie am besten zunächst eine Test­um­ge­bung, damit Sie die Methode ohne Gefahr aus­pro­bie­ren können. Zu den dafür not­wen­di­gen Schritten kommen wir jetzt.

Aufbau einer Test­samm­lung

Öffnen Sie zuerst die Shell und loggen Sie sich mit Ihren Daten als Ad­mi­nis­tra­tor oder Ad­mi­nis­tra­to­rin ein. Dann erstellen Sie eine neue Sammlung, die als Test­um­ge­bung für Ihre ersten MongoDB Queries fungiert. Da die Methode nicht nur einfache Dokumente, sondern auch Arrays, ver­schie­de­ne Felder oder ein­ge­bun­de­ne Dokumente be­rück­sich­ti­gen kann, erstellen wir für eine De­mons­tra­ti­on des Umfangs der MongoDB Queries eine etwas kom­ple­xe­re Coll­ec­tion.

In unserem Beispiel ist dies eine Kun­den­lis­te. Das Format dieser Liste sieht fol­gen­der­ma­ßen aus:

{
    "name" : "Schulz",
    "units" : 642,
    "location" : [ "Germany", "Austria" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
}

Dieses Dokument enthält die folgenden In­for­ma­tio­nen:

• name: Der Name des Kun­den­un­ter­neh­mens, das die Ware gekauft hat.
• units: Die Anzahl der Produkte, die das Un­ter­neh­men insgesamt bestellt hat.
• location: Der Sitz der anderen Firma. Gibt es mehrere Nie­der­las­sun­gen, können diese in Form eines Arrays ge­spei­chert werden.
• tran­sac­tions: Dieses Feld enthält nun ein weiteres Dokument, welches ein­ge­schlos­sen wird (im Eng­li­schen spricht man von „embedded documents“ oder „nested documents“). Jedes dieser tran­sac­tions-Dokumente enthält In­for­ma­tio­nen darüber, seit wann das Un­ter­neh­men ein Kunde ist (unter dem Punkt “first”), wann die letzte Be­stel­lung stattfand (unter dem Punkt “last”) und schließ­lich, wie oft es insgesamt bestellt hat (unter dem Punkt “total”).

In diesem Fall wurden die zu­sätz­li­chen Dokumente eingefügt, damit zu einem späteren Zeitpunkt noch weitere In­for­ma­tio­nen ergänzt werden können. Dies wahrt die Übersicht.

Er­stel­lung der Test­samm­lung für die MongoDB Queries

Jetzt erstellen wir eine Sammlung mit dem Namen „Kunden“, die für unser Beispiel zur besseren Übersicht lediglich fünf Einträge enthalten soll. Wenn Sie zu einem späteren Zeitpunkt MongoDB Queries pro­fes­sio­nell nutzen, können Sie deutlich um­fang­rei­che­re Samm­lun­gen erstellen. Dafür nutzen Sie die Methode in­sert­Ma­ny. Für unser Beispiel sieht das so aus:

db.kunden.insertMany ( [
{
    "name" : "Schulz",
    "units" : 642,
    "location" : [ "Germany", "Austria" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
},
{
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2,
    }
},
{
    "name" : "Meyer",
    "units" : 814,
    "location" : [ "Austria", "Germany" ],
    "transactions" : {
        "first" : {
            "year" : 2016,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 22,
    }
},
{
    "name" : "Pawolski",
    "units" : 313,
    "location" : [ "Germany", "Poland" ],
    "transactions" : {
            "first" : {
            "year" : 2017,
            },
        "last" : {
            "year" : 2020,
        },
        "total" : 9,
    }
},
{
    "name" : "Jorgensen",
    "units" : 7,
    "location" : "Denmark",
    "transactions" : {
        "first" : {
            "year" : 2022,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 2,
    }
}
] )

Wenn Sie diese Eingabe so oder mit Ihren eigenen Daten ausführen, erhalten Sie im Gegenzug eine Auf­lis­tung der zu­ge­ord­ne­ten Objekt-IDs. Diese sind ein­zig­ar­tig und sorgen dafür, dass jedes Dokument auch über die ID gefunden werden kann. Wenn Sie sich ver­si­chern möchten, dass alle Dokumente in die Sammlung über­nom­men wurden, können Sie MongoDB find verwenden und dabei auf zu­sätz­li­che Parameter ver­zich­ten:

db.kunden.find ( )

Der Output ist eine Auf­lis­tung aller Objekt-IDs mit den kom­plet­ten Do­ku­men­ten, die Sie nun mit MongoDB Queries durch­su­chen können.

Einzelne Felder mit MongoDB Queries abfragen

Bereits diese Ausgabe wird Ihnen al­ler­dings ver­deut­li­chen, welchen Mehrwert Ihnen MongoDB Queries bieten. Schon in unserem kleinen Beispiel wird die Ausgabe lange Zei­chen­ket­ten her­vor­brin­gen, die eine Un­ter­su­chung ohne Hilfs­mit­tel min­des­tens sehr erschwert. Auch in der Folge nutzen wir daher die find-Methode, spe­zi­fi­zie­ren dabei aber unsere Suche. Dafür legen wir eine spezielle An­for­de­rung fest, die ein Dokument erfüllen muss, um aus­ge­ge­ben zu werden. In unserem Beispiel suchen wir so alle Dokumente, deren Name dem Wert „ATS“ ent­spre­chen. Das sieht so aus:

db.kunden.find (
    { "name" : "ATS" }
)

Einfache MongoDB Queries dieser Art durch­su­chen nun alle hin­ter­leg­ten Dokumente in der ent­spre­chen­den Sammlung und gleichen ab, welche den Na­mens­wert „ATS“ haben. Dies betrifft in unserer Coll­ec­tion nur einen Eintrag, weshalb der Output fol­gen­der­ma­ßen aussieht:

db.kunden.find ( { "name" : "ATS" } )
{
    "_id" : ObjectID ( "673d14684o75iftbb0ct5003" ),
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2
    }

Auch der ge­gen­tei­li­ge Weg funk­tio­niert. Wenn Sie sich alle Er­geb­nis­se außer dem Eintrag für „ATS“ anzeigen lassen möchten, wählen Sie folgende Eingabe und erhalten erneut eine sehr um­fang­rei­che Ausgabe:

db.kunden.find (
    { "name" : { $ne : "ATS" } }
)

Möchten Sie hingegen MongoDB Queries mit ver­schie­de­nen Werten ausgeben, ist auch das mit einem Array möglich. In unserem Beispiel be­rück­sich­ti­gen wir die Kunden „ATS“ und „Jorgensen“.

db.kunden.find (
    { "name" : [ $in : [ "ATS", "Jorgensen" ] } }
)

Mehrere Felder mit MongoDB Queries abfragen

Gerade wenn Sie sehr exakte Er­geb­nis­se benötigen, ist es al­ler­dings wichtig, Ihre Anfrage noch weiter zu spe­zi­fi­zie­ren. Daher können Sie MongoDB Queries durch zu­sätz­li­che Parameter noch genauer bestimmen. Wenn wir nun für eine Anfrage neben dem Fir­men­na­men „ATS“ auch den Wert aus dem Segment „units“ angeben, wird nach einem Dokument gesucht, welches beide Werte enthält:

db.kunden.find (
    { "name" : "ATS", "units" : 17 }
)

Hier gibt es wieder eine exakte Über­ein­stim­mung. Sollte aber einer der beiden Werte nicht stimmen, wird auf diese Weise auch kein Ergebnis aus­ge­ge­ben. Folgende Eingabe würde zum Beispiel keinen Erfolg haben:

db.kunden.find (
    { "name" : "ATS", "units" : 25 }
)

Wenn Sie aber mit MongoDB Queries ver­schie­de­ne Werte be­rück­sich­ti­gen möchten, eine Eingabe aber schon statt­fin­den soll, wenn min­des­tens eine der An­for­de­run­gen erfüllt ist, geben Sie dies ein:

db.kunden.find (
    { $or : [ {"name" : "ATS"}, { "units" : 25 } ] }
)

Werte in Arrays abfragen

Auch Werte in Arrays können mit MongoDB Queries be­rück­sich­tigt werden. In unserem Beispiel gibt es Un­ter­neh­men, die Nie­der­las­sun­gen in mehreren Ländern haben. Wenn Sie nun alle Kunden ausgeben möchten, die min­des­tens eine Nie­der­las­sung in Deutsch­land haben, ist die Eingabe ganz einfach:

db.kunden.find (
    { "location" : "Germany" }
)

Der Output enthält nun alle drei Kunden, die min­des­tens eine Nie­der­las­sung in Deutsch­land haben. Wenn Sie nun aber Ihre Eingabe erweitern und Kunden mit Nie­der­las­sun­gen aus Deutsch­land und Ös­ter­reich gleich­zei­tig abrufen möchten, nutzen Sie dafür einen Array:

db.kunden.find (
    { "location" : [ "Germany", "Austria" ] }
)

Sie werden al­ler­dings merken, dass diese Eingabe lediglich ein Ergebnis zeigt, obwohl zwei Un­ter­neh­men theo­re­tisch den Such­kri­te­ri­en ent­spre­chen. Der Grund dafür ist, dass MongoDB Queries die exakte Eingabe und somit in diesem Fall die Rei­hen­fol­ge beachten. Wenn Sie al­ler­dings Werte be­rück­sich­ti­gen wollen, die in einer be­lie­bi­gen Rei­hen­fol­ge in einem Array stehen dürfen, ergänzen Sie die Anfrage fol­gen­der­ma­ßen:

db.kunden.find (
    { "location" : { $all : [ "Germany", "Austria" ] } }
)

MongoDB Queries für ein­ge­bun­de­ne Dokumente

In unserem Beispiel haben wir zu­sätz­lich ein­ge­bun­de­ne Dokumente verwendet. Auch diese können mit MongoDB Queries aus­ge­ge­ben werden. Dafür müssen Sie einen Punkt einbauen, um MongoDB zu si­gna­li­sie­ren, dass die Felder in einem ein­ge­bun­de­nen Dokument ana­ly­siert werden sollen. Wenn Sie zum Beispiel eine Auf­lis­tung aller Kunden haben möchten, die mehr als zehn Be­stell­vor­gän­ge aufweisen, geben Sie dies ein:

db.kunden.find (
    { "transactions.total" : { $gt : 10 } }
)

So greift MongoDB auf das Dokument „tran­sac­tions“ zu und be­rück­sich­tigt dann die Anzahl der Be­stell­vor­gän­ge unter „total“.

MongoDB Queries: Ausgabe be­schrän­ken

Auch mit den bisher erlernten Methoden kann die Ausgabe der MongoDB Queries al­ler­dings sehr um­fang­reich ausfallen. Daher kann es sinnvoll sein, dass Sie die Ausgabe nur auf einige Felder be­schrän­ken. Dafür werden so­ge­nann­te Pro­jek­tio­nen genutzt. Diese enthalten den Wert 1 (für ent­hal­te­ne Felder) und 0 (für Felder, die aus­ge­schlos­sen werden sollen). Im folgenden Beispiel führen wir eine zwei­tei­li­ge Anfrage durch. Zunächst wird eine Suche ohne Parameter initiiert, die alle In­for­ma­tio­nen be­inhal­ten würde. Direkt danach wird al­ler­dings eine Pro­jek­ti­on durch­ge­führt, die lediglich das Feld für den Namen be­rück­sich­tigt.

db.kunden.find (
    { }
    { "name" : 1 }
)

So erhalten Sie zwar alle Er­geb­nis­se, die Ausgabe be­schränkt sich aber auf die je­wei­li­gen Namen.

Cursors nutzen, um die Ausgabe zu op­ti­mie­ren

Cursors sind eine Methode, um nicht die Er­geb­nis­se der MongoDB Queries selbst zu re­gle­men­tie­ren, sondern deren Widergabe an­zu­pas­sen. So können Sie unter anderem die Anzahl der Er­geb­nis­se be­schrän­ken oder ihre Rei­hen­fol­ge ändern. Möchten Sie lediglich ein zwei der Er­geb­nis­se anzeigen, nutzen Sie die Methode limit. Dies funk­tio­niert so:

db.kunden.find (
    { }
    { "name" : 1 }
).limit ( 2 )

Mit der folgenden Angabe sortieren Sie die Ausgabe um. So werden die drei Kunden angezeigt, die die wenigsten Produkte bestellt haben:

db.kunden.find (
    { }
    { "name" : 1 }
).limit ( 2 ) .sort ( { "units" : 1 } )