MongoDB Query Operatoren

6 Kernkonzepte

Die wichtigsten MongoDB Query Operatoren für präzise Datenabfragen: $eq, $gt, $lt · $and, $or, $not · $exists, $type · $all, $elemMatch · $regex, $where · $geoWithin, $near MongoDB bietet eine Vielzahl von Operatoren für komplexe Abfragen. Diese ermöglichen präzise Filterung von Dokumenten – von einfachen Vergleichen bis zu geospatialen Analysen.

Vergleichsoperatoren – $eq, $gt, $lt, $gte, $lte, $ne, $in, $nin

$eq · $gt · $lt · $in · $ne · $nin

// Preise zwischen 50 und 200 (exklusive obere Grenze) { preis: { $gt: 50, $lt: 200 } } // Kategorien in einer Liste { kategorie: { $in: ["Elektronik", "Bücher"] } }

Vergleichsoperatoren vergleichen Werte in Dokumenten mit angegebenen Kriterien. Sie sind die grundlegendsten Operatoren für MongoDB-Abfragen.

Übersicht der Vergleichsoperatoren

Operator	Bedeutung	Beispiel
$eq	Gleich	{ name: { $eq: "Laptop" } }
$ne	Ungleich	{ status: { $ne: "inaktiv" } }
$gt	Größer als	{ preis: { $gt: 100 } }
$gte	Größer oder gleich	{ preis: { $gte: 100 } }
$lt	Kleiner als	{ preis: { $lt: 50 } }
$lte	Kleiner oder gleich	{ preis: { $lte: 50 } }
$in	In einer Liste	{ kategorie: { $in: ["A", "B"] } }
$nin	Nicht in einer Liste	{ status: { $nin: ["gelöscht", "archiviert"] } }

Beispiele (MongoDB Shell / JavaScript)

// Produkte mit Preis zwischen 100 und 500

db.produkte.find({

preis: { $gte: 100, $lte: 500 }

});

// Elektronik oder Bücher

db.produkte.find({

kategorie: { $in: ["Elektronik", "Bücher"] }

});

// Lagerbestand nicht leer (nicht 0)

db.produkte.find({

bestand: { $ne: 0 }

});

Tipp: In MongoDB können Sie mehrere Vergleichsoperatoren auf ein Feld anwenden – wie bei $gte und $lte für Bereichsabfragen.

Logische Operatoren – $and, $or, $not, $nor

$and · $or · $not · $nor

// Preis > 100 ODER Kategorie = "Premium" { $or: [ { preis: { $gt: 100 } }, { kategorie: "Premium" } ] }

Logische Operatoren kombinieren mehrere Abfragebedingungen. $and verlangt alle Bedingungen, $or mindestens eine.

Beispiele

// $and: Preis > 100 UND Kategorie = "Elektronik"

db.produkte.find({

$and: [

{ preis: { $gt: 100 } },

{ kategorie: "Elektronik" }

]

});

// $or: Preis < 10 ODER Bestand = 0

db.produkte.find({

$or: [

{ preis: { $lt: 10 } },

{ bestand: 0 }

]

});

// $not: KEINE Kategorie "Bücher"

db.produkte.find({

kategorie: { $not: { $eq: "Bücher" } }

});

// $nor: Weder Preis > 100 noch Kategorie = "Premium"

db.produkte.find({

$nor: [

{ preis: { $gt: 100 } },

{ kategorie: "Premium" }

]

});

Tipp: Bei einfachen AND-Bedingungen können Sie die Felder direkt im Abfrageobjekt kombinieren – z.B. { preis: { $gt: 100 }, kategorie: "Elektronik" }.

Elementoperatoren – $exists, $type

$exists · $type

// Felder, die existieren { rabatt: { $exists: true } } // Felder vom Typ "string" { name: { $type: "string" } }

Elementoperatoren prüfen die Existenz und den Typ von Feldern in Dokumenten – nützlich für die Arbeit mit heterogenen Datenstrukturen.

Beispiele

// $exists: Dokumente mit Rabatt-Feld

db.produkte.find({

rabatt: { $exists: true }

});

// $type: Nur Dokumente mit numerischem Preis

db.produkte.find({

preis: { $type: "number" }

});

// $type: Auch mit BSON-Typnummer möglich

db.produkte.find({

preis: { $type: 16 } // 16 = int, 1 = double, 2 = string, 8 = boolean

});

Tipp: Verwenden Sie $exists mit false, um Dokumente zu finden, bei denen ein Feld fehlt – z.B. für Migrationen oder Datenbereinigung.

Arrayoperatoren – $all, $elemMatch, $size

$all · $elemMatch · $size · $push · $addToSet

// Array enthält alle angegebenen Werte { tags: { $all: ["neu", "im_angebot"] } } // Dokument mit Array-Elementen, die Bedingung erfüllen { bewertungen: { $elemMatch: { sterne: { $gte: 4 } } } }

Arrayoperatoren arbeiten mit Array-Feldern – sie prüfen, ob Werte enthalten sind, ob Bedingungen auf Array-Elemente zutreffen oder wie viele Elemente vorhanden sind.

Beispiele

// $all: Tags enthalten sowohl "neu" als auch "im_angebot"

db.produkte.find({

tags: { $all: ["neu", "im_angebot"] }

});

// $elemMatch: Bewertung mit mindestens 4 Sternen

db.produkte.find({

bewertungen: {

$elemMatch: { sterne: { $gte: 4 } }

}

});

// $size: Array mit genau 3 Elementen

db.produkte.find({

tags: { $size: 3 }

});

// $in auf Array (enthält mindestens einen Wert)

db.produkte.find({

tags: "neu" // Vereinfachte Schreibweise für $in mit einem Element

});

Tipp: $elemMatch ist wichtig, wenn Sie mehrere Bedingungen auf dasselbe Array-Element anwenden möchten – einfache Abfragen wie { tags: "neu", tags: "im_angebot" } prüfen nur, ob beide Werte irgendwo im Array vorkommen.

Evaluationsoperatoren – $regex, $where, $expr

$regex · $where · $expr · $text

// Name beginnt mit "A" (regex) { name: { $regex: /^A/ } } // Preis größer als Bestand (expr) { $expr: { $gt: [ "$preis", "$bestand" ] } }

Evaluationsoperatoren führen Berechnungen oder Mustervergleiche durch – für Textsuche, Feldvergleiche und JavaScript-Ausdrücke.

Beispiele

// $regex: Name enthält "book" (case-insensitive)

db.produkte.find({

name: { $regex: /book/i }

});

// $expr: Preis ist größer als Bestand

db.produkte.find({

$expr: { $gt: [ "$preis", "$bestand" ] }

});

// $where: JavaScript (langsam – vermeiden!)

db.produkte.find({

$where: function() { return this.preis > this.bestand; }

});

// $text: Volltextsuche (benötigt Text-Index)

db.produkte.find({

$text: { $search: "Laptop Computer" }

});

⚠️ Achtung: $where und $regex ohne Index sind langsam. Verwenden Sie $text für Volltextsuche und $regex mit Indizes für Performance. $where sollte vermieden werden.

Geospatiale Operatoren – $geoWithin, $near, $geoIntersects

$near · $geoWithin · $geoIntersects

// Punkte in der Nähe (max. 1000 m) { location: { $near: { $geometry: { type: "Point", coordinates: [13.4, 52.5] }, $maxDistance: 1000 } } }

Geospatiale Operatoren ermöglichen Abfragen basierend auf geografischen Koordinaten – für Standortdienste, Umkreissuchen und Flächenabfragen.

Beispiele

// $near: Standorte in der Nähe (max. 5000 m)

db.orte.find({

position: {

$near: {

$geometry: { type: "Point", coordinates: [13.4, 52.5] },

$maxDistance: 5000

}

});

// $geoWithin: Punkte innerhalb eines Polygons

db.orte.find({

position: {

$geoWithin: {

$geometry: {

type: "Polygon",

coordinates: [[

[13.3, 52.4], [13.5, 52.4],

[13.5, 52.6], [13.3, 52.6],

[13.3, 52.4]

]]

}

});

Tipp: Für geospatiale Abfragen müssen Sie einen 2dsphere-Index auf dem Feld mit GeoJSON-Daten erstellen. Verwenden Sie db.collection.createIndex({ position: "2dsphere" }).

MongoDB Query Operatoren im Überblick

$eq Vergleich
$gt, $lt, $in, $ne

$and Logik
$or, $not, $nor

$exists Element
$type

$all Array
$elemMatch, $size

$regex Evaluation
$expr, $where

$near Geospatial
$geoWithin

Quick Summary

$gt

Vergleich

$or

Logik

$exists

Element

$all

Array

$regex

Evaluation

$near

Geospatial

{ preis: { $gt: 100, $lt: 500 } } · { $or: [ { status: "offen" }, { dringend: true } ] } · { tags: { $all: ["neu", "im_angebot"] } }