# mongosh — Die MongoDB-Shell

> Praxis-Guide zu mongosh — die moderne, JavaScript-basierte MongoDB-Shell zum Verbinden, Abfragen, Aggregieren und Verwalten von Collections und Dokumenten.

Source: https://www.jpkc.com/db/cheatsheets/build-languages/mongosh/

<!-- PROSE:intro -->
mongosh ist die moderne, JavaScript-basierte Shell für MongoDB und löst die alte `mongo`-Shell ab. Du tippst echtes JavaScript ein, sodass sich Abfragen, Aggregationen und ganze Verwaltungsskripte direkt in der Konsole zusammenbauen lassen – mit Autovervollständigung, Syntax-Highlighting und besserer Fehlerausgabe als beim Vorgänger. Dieser Guide führt dich durch die wichtigsten Befehle für den Alltag: vom Verbindungsaufbau über CRUD und Aggregation bis zu Indizes und Administration.
<!-- PROSE:intro:end -->

## Verbindung herstellen

`mongosh` — Verbindet sich mit der lokalen MongoDB (localhost:27017).

```bash
mongosh
```

`mongosh '<connection-string>'` — Verbindet sich über eine Connection-URI.

```bash
mongosh 'mongodb://user:pass@host:27017/mydb'
```

`mongosh --host <host> --port <port>` — Verbindet sich mit einem bestimmten Host und Port.

```bash
mongosh --host db.example.com --port 27017
```

`mongosh -u <user> -p <password> --authenticationDatabase <db>` — Verbindet sich mit Authentifizierung.

```bash
mongosh -u admin -p secret --authenticationDatabase admin
```

`mongosh --eval '<code>'` — Führt JavaScript aus und beendet sich danach.

```bash
mongosh --eval 'db.users.countDocuments()'
```

## Datenbank & Collection

`show dbs` — Listet alle Datenbanken auf.

```bash
show dbs
```

`use <database>` — Wechselt zu einer Datenbank (wird beim ersten Schreibvorgang angelegt).

```bash
use myapp
```

`show collections` — Listet alle Collections der aktuellen Datenbank auf.

```bash
show collections
```

`db.createCollection('<name>')` — Legt eine neue Collection explizit an.

```bash
db.createCollection('logs')
```

`db.<collection>.drop()` — Löscht eine Collection.

```bash
db.temp_data.drop()
```

`db.dropDatabase()` — Löscht die aktuelle Datenbank.

```bash
db.dropDatabase()
```

## CRUD-Operationen

`db.<col>.insertOne({<doc>})` — Fügt ein einzelnes Dokument ein.

```bash
db.users.insertOne({name: 'John', email: 'john@example.com'})
```

`db.<col>.insertMany([{<doc>}, {<doc>}])` — Fügt mehrere Dokumente ein.

```bash
db.users.insertMany([{name: 'John'}, {name: 'Jane'}])
```

`db.<col>.find({<filter>})` — Findet Dokumente, die einem Filter entsprechen.

```bash
db.users.find({age: {$gte: 18}})
```

`db.<col>.findOne({<filter>})` — Findet das erste passende Dokument.

```bash
db.users.findOne({email: 'john@example.com'})
```

`db.<col>.updateOne({<filter>}, {$set: {<fields>}})` — Aktualisiert ein einzelnes Dokument.

```bash
db.users.updateOne({name: 'John'}, {$set: {age: 30}})
```

`db.<col>.updateMany({<filter>}, {$set: {<fields>}})` — Aktualisiert mehrere Dokumente.

```bash
db.users.updateMany({active: false}, {$set: {archived: true}})
```

`db.<col>.deleteOne({<filter>})` — Löscht ein einzelnes Dokument.

```bash
db.users.deleteOne({name: 'John'})
```

`db.<col>.deleteMany({<filter>})` — Löscht mehrere Dokumente.

```bash
db.users.deleteMany({archived: true})
```

## Abfrage & Aggregation

`db.<col>.find().sort({<field>: 1})` — Sortiert die Ergebnisse (1=aufsteigend, -1=absteigend).

```bash
db.users.find().sort({name: 1})
```

`db.<col>.find().limit(<n>)` — Begrenzt die Anzahl der Ergebnisse.

```bash
db.users.find().limit(10)
```

`db.<col>.find({}, {<field>: 1})` — Projektion: gibt nur bestimmte Felder zurück.

```bash
db.users.find({}, {name: 1, email: 1, _id: 0})
```

`db.<col>.countDocuments({<filter>})` — Zählt die Dokumente, die einem Filter entsprechen.

```bash
db.users.countDocuments({active: true})
```

`db.<col>.distinct('<field>')` — Ermittelt die eindeutigen Werte eines Feldes.

```bash
db.users.distinct('country')
```

`db.<col>.aggregate([{$group: {_id: '$<field>', count: {$sum: 1}}}])` — Gruppiert und aggregiert Dokumente.

```bash
db.orders.aggregate([{$group: {_id: '$status', count: {$sum: 1}}}])
```

## Indizes

`db.<col>.createIndex({<field>: 1})` — Legt einen aufsteigenden Index auf einem Feld an.

```bash
db.users.createIndex({email: 1}, {unique: true})
```

`db.<col>.getIndexes()` — Listet alle Indizes einer Collection auf.

```bash
db.users.getIndexes()
```

`db.<col>.dropIndex('<name>')` — Löscht einen Index anhand seines Namens.

```bash
db.users.dropIndex('email_1')
```

`db.<col>.find({<filter>}).explain('executionStats')` — Zeigt den Ausführungsplan einer Abfrage an.

```bash
db.users.find({email: 'john@example.com'}).explain('executionStats')
```

## Administration

`db.stats()` — Zeigt Statistiken zur Datenbank an.

```bash
db.stats()
```

`db.<col>.stats()` — Zeigt Statistiken zu einer Collection an.

```bash
db.users.stats()
```

`db.currentOp()` — Zeigt die aktuell laufenden Operationen an.

```bash
db.currentOp()
```

`db.serverStatus()` — Zeigt den detaillierten Serverstatus an.

```bash
db.serverStatus().connections
```

`rs.status()` — Zeigt den Status des Replica-Sets an.

```bash
rs.status()
```

`db.version()` — Zeigt die Version des MongoDB-Servers an.

```bash
db.version()
```

<!-- PROSE:outro -->
## Fazit

mongosh macht den täglichen Umgang mit MongoDB angenehm: Weil die Shell echtes JavaScript versteht, gehen Einzelabfragen genauso leicht von der Hand wie kleine Skripte, die du mit `--eval` direkt aus dem Terminal startest. Ein paar Befehle sind allerdings unwiderruflich – `db.dropDatabase()`, `db.<col>.drop()` und ein `deleteMany({})` ohne Filter löschen ohne Rückfrage und ohne Papierkorb; prüfe deshalb erst mit `use` und `countDocuments`, wo du gerade stehst. Connection-Strings mit Klartext-Passwörtern landen sonst schnell in der Shell-History oder in einem Git-Repo – nutze stattdessen Umgebungsvariablen oder die interaktive Passwortabfrage. Und `--eval` führt aus, was du ihm gibst: Setze es bei Lösch- und Update-Befehlen mit Bedacht ein.

## Weiterführende Links

- [mongosh-Dokumentation](https://www.mongodb.com/docs/mongodb-shell/) – offizielle Referenz zu Installation, Konfiguration und Befehlen (englisch)
- [MongoDB Manual](https://www.mongodb.com/docs/manual/) – vollständige Dokumentation zu Abfragen, Aggregation und Administration (englisch)
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [artisan](https://www.jpkc.com/db/cheatsheets/build-languages/artisan/) – Kommandozeilen-Tool des Laravel-Frameworks (PHP)
- [cargo](https://www.jpkc.com/db/cheatsheets/build-languages/cargo/) – Paketmanager und Build-Tool für Rust
- [composer](https://www.jpkc.com/db/cheatsheets/build-languages/composer/) – Abhängigkeitsverwaltung für PHP-Projekte