MongoDB

Installation

Lokaler Server

Windows:

.msi von MongoDB Community Server Download herunterladen und ausführen

MongoDB Compass

Wird standardmässig mit dem Community Server installiert. Dies ist eine GUI für die Verwaltung des MongoDB-Servers.

MongoDB Shell

Konsolen-Anwendung, Command-Line Interface

Windows:

.msi von MongoDB Shell Download herunterladen und ausführen

MongoDB Database Tools

Windows:

.msi von MongoDB Command Line Database Tools Download herunterladen und ausführen

Grundlagen

Standard-Port für MongoDB-Server: localhost:27017

Ordner des MongoDB-Servers: C:\Program Files\MongoDB\Server\8.0

Ordner der MongoDB Database Tools: C:\Program Files\MongoDB\Tools\100\bin

Standard-Datenbanken:

• admin
• config
• local

MongoDB-Server

Server starten

1. CMD als Administrator öffnen
2. net start MongoDB

Server stoppen

1. CMD als Administrator öffnen
2. net stop MongoDB

Shell

Die Shell kann im Terminal mit mongosh oder über das Programm MongoDBCompass geöffnet werden.

Grundlegende Befehle

Datenbanken:

Befehl	Bedeutung
show databases / show dbs	alle erstellten Datenbanken anzeigen
use <dbname>	beliebige Datenbank (auch noch nicht existierende) als aktive anwählen
db.dropDatabase()	aktive Datenbank löschen

Collections:

Befehl	Bedeutung
show collections	alle Collections anzeigen
db.createCollection("<collectionName>")	Collection erstellen
db.<collectionName>.drop	Collection löschen
db.<collectionName>.insertOne({"vorname": "muster", "alter": 40})	Datensatz in Collection einfügen
db.<collectionName>.insertMany(<br/>{"vorname": "muster", "alter": 40}<br/>{"nachname": "nach")	mehrere Datensätze in Collection einfügen

Datenbank erstellen

Eine Datenbank wird erst richtig erstellt, wenn zu dieser (als aktive Datenbank ausgewählt) das erste Mal ein Datensatz hinzugefügt wird.

use mydb
db.createCollection("firstCollection")
db.firstCollection.insertOne({"key": "value"})

Weiterführende Befehle

getSiblingDB()

Die Methode db.getSiblingDB("...") gibt eine andere Datenbank zurück, ohne dabei die Variable db in der aktuellen Shell zu ändern.

db.getSiblingDB("<database>")

Beispiel:

users = db.getSiblingDB('users')
records = db.getSiblingDB('records')

users.collection.countDocuments()
users.collection.findOne()

records.collection.countDocuments()
records.collection.findOne()

MongoDB Docs - db.getSiblingDB()

CRUD

Create

bei MySQL: Insert

Einzelnes Dokument einfügen

db.collection.insertOne(
    <document>,
    {
      writeConcern: <document>
    }
)

writeConcern

• optional

Beispiel:

db.inventory.insertOne(
    {
      item: "canvas",
      qty: 100,
      tags: ["cotton"],
      size: { h: 28, w: 35.5, uom: "cm" },
      status: "A"
    }
)

Rückgabe:

{
    acknowledged: true,
        insertedId
:
    ObjectId("632f1fd57042d849480e4747")
}

Mehrere Dokumente einfügen

db.collection.insertMany(
   [ <document 1> , <document 2>, ... ],
   {
      writeConcern: <document>,
      ordered: <boolean>
   }
)

Beispiel:

db.inventory.insertMany([
    { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A", tags: ["blank", "red"] },
    { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A", tags: ["red", "blank"] },
    { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D", tags: ["red", "blank", "plain"] },
    { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D", tags: ["blank", "red"] },
    { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A", tags: ["blue"] }
])

Rückgabe:

{
    acknowledged: true,
        insertedIds
:
    {
        '0'
    :
        ObjectId("632f4cad7042d849480e4750"),
            '1'
    :
        ObjectId("632f4cad7042d849480e4751"),
            '2'
    :
        ObjectId("632f4cad7042d849480e4752"),
            '3'
    :
        ObjectId("632f4cad7042d849480e4753"),
            '4'
    :
        ObjectId("632f4cad7042d849480e4754")
    }

Read

db.collection.find( <query>, <projection>, <options> )

Alle finden

Beispiel:

db.inventory.find()

Rückgabe:

[
    {
        _id: ObjectId("632f57a67042d849480e4755"),
        item: 'journal',
        qty: 25,
        size: {h: 14, w: 21, uom: 'cm'},
        status: 'A',
        tags: ['blank', 'red']
    },
    {
        _id: ObjectId("632f57a67042d849480e4756"),
        item: 'notebook',
        qty: 50,
        size: {h: 8.5, w: 11, uom: 'in'},
        status: 'A',
        tags: ['red', 'blank']
    },
    ...

Filtern - query

Beispiel:

db.inventory.find( { status: "D" } )
db.inventory.find( { status: "D", item: "paper" } )

Rückgabe:

[
    {
        _id: ObjectId("632f57a67042d849480e4757"),
        item: 'paper',
        qty: 100,
        size: {h: 8.5, w: 11, uom: 'in'},
        status: 'D',
        tags: ['red', 'blank', 'plain']
    },
    ...

SQL:

SELECT *
FROM inventory
WHERE status = "D"

Operatoren

[
    {
        _id: ObjectId("632f57a67042d849480e4757"),
        item: {$ne: 'paper'},
        qty: {$lte: 100},
        size: {h: {$gt: 8.5}, w: 11, uom: 'in'},
        status: {$in: ['A', 'B' 'C']},
        tags: {$nin: ['red', 'blank', 'plain']},
        user_id: {$exists: true}
    },
    ...

Operator	Bedeutung	Zeichen
$eq	equals	=
$ne	not equals	!=
$gt	greater than	>
$gte	greater than	>=
$lt	less than	<
$lte	less than equals	<=
$in	in, contains/includes
$nin	not in, doesn't contain/include
$exists	exists
$elemMatch	if an element of an array matches

AND-Bedingung

Mehrere Bedingungen werden durch ein Komma getrennt:

db.inventory.find( { status: "D", item: "paper" } )

SQL:

SELECT *
FROM inventory
WHERE status = "D"
  AND item = "paper"

OR-Bedingung

db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )

SQL:

SELECT *
FROM inventory
WHERE status = "A"
   OR qty < 30

Kombination von AND- und OR-Bedingung

db.inventory.find( {
     status: "A",
     $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ]
} )

db.sales.find({
  $or: [{ "items.name": "pens" }, { "items.tags": "writing" }],
})

SQL:

SELECT *
FROM inventory
WHERE status = "A"
  AND (qty < 30 OR item LIKE "p%")

Hinweis: Möchte man einen Operator mehr als einmal verwenden, muss man explizit den $and-Operator verwenden. Denn in jedem JSON-Dokument darf jeder Key nur einmal vorkommen.

Beispiel: Folgendes funktioniert nicht, da es den Key $or mehr als einmal gibt:

db.routes.find({
  $or: [{ dst_airport: "SEA" }, { src_airport: "SEA" }],
  $or: [{ "airline": "American Airlines" }, { "airplane": 320 }]
})

Dies würde funktionieren:

db.routes.find({
 $and: [
      { $or: [{ dst_airport: "SEA" }, { src_airport: "SEA" }] },
      { $or: [{ "airline": "American Airlines" }, { "airplane": 320 }] }
  ]
})

REGEX

Einen regulären Ausdruck (Regex, regular expression) kann man mit Schrägstrichen / anstatt der Gänsefüsschen " bei normalen Strings wahrnehmen.

Beispiel:

db.users.find({"name": /m/})

SQL:

SELECT *
FROM users
WHERE name LIKE '%m%'

Verschachtelung

db.inventory.find( { "pet.name": "Wuff" } )

Like

db.inventory.find( {
  item: /^p/
} )

SQL:

SELECT *
FROM inventory
WHERE item LIKE "p%"

Array-Elemente filtern

Beispiel:

Dies findet alle Elemente, bei welchem das Array tags das Element blue beinhaltet. Es werden jedoch auch Objekte gefunden, bei welchen tags gleich dem String blue ist.

db.inventory.find( { tags: "blue" } )

Möchte man nur Objekte finden, bei welchen tags ein Array mit dem Element blue ist, kann man $elemMatch verwenden:

db.inventory.find( {
    tags: {
        $elemMatch: {
            $eq: "blue"
        }
    }
} )

Dokumente zählen

Die Anzahl der Resultate eines find()-Befehls kann mit count() angezeigt werden:

db.people.find(<query>).count()

Folgende Befehle sind gleichwertig:

db.collection.countDocuments( <query>, <options> )
db.collection.count( <query>, <options> )

countDocuments() wird von der MongoDB-Dokumentation empfohlen. cursor.count() (bei find()) und db.collection.count() sind dabei als veraltet/deprecated markiert.

MongoDB Documentation - db.collection.countDocuments() StackOverflow - MongoDB count() versus countDocuments()

Eindeutige Dokumente filtern

Mit distinct() können alle Dokumente herausgefiltert werden, welche bei einem Feld (unter field) identisch sind.

db.collection.distinct(field, query, options)

SQL:

SELECT DISTINCT <field> FROM <table>;

Rückgabe ändern - projection

db.collection.find( { }, { <field1>: <value>, <field2>: <value> ... } )

Projection	Beschreibung
<field>: <1 or true>	zeigt Feld an
<field>: <0 or false>	zeigt Feld nicht an

Das Feld _id wird standardmässig immer angezeigt. Ist es nicht erwünscht, muss es mit _id: 0 explizit ausgeblendet werden.

Beispiele:

db.inventory.find( { status: "A" }, { item: 1, status: 1 } )

SQL:

SELECT _id, item, status
FROM inventory
WHERE status = 'A'

Verschachtelung:

db.inventory.find( { status: "A" }, { item: 1, "item.name": 1 } )

Rückgabe limitieren

db.people.find().limit(1)

Sortieren

db.collection.find().sort( { field: value } )

Werte für value:

Value	Bedeutung
-1	Descending, absteigende Sortierung
1	Ascending, aufsteigende Sortierung

Beispiele:

db.inventory.find().sort({"qty": 1})
db.inventory.find().sort({"status":1, "item":1})

Update

Operatoren:

Operator	Inhalt
$set	Daten, welche geändert werden sollen
$currentDate	weist gewähltem Attribut aktuelles Datum zu
$inc	Wert addieren
$min	ändert das Feld nur, wenn der neue Wert kleiner als der existierende Wert ist
$max	ändert das Feld nur, wenn der neue Wert grösser als der existierende Wert ist
$mul	Wert multiplizieren
$rename	Feld umbenennen
$unset	löscht ein Feld

Weitere Update-Operatoren findet man unter MongoDB Docs - Update Operators.

updateOne()

• ändert den ersten gefundenen Datensatz

db.collection.updateOne(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ],
     hint:  <document|string>,
     let: <document>,
     sort: <document>
   }
)

Beispiel:

db.inventory.updateOne(
   { item: "stone" },
   {
     $set: { "size.uom": "cm", status: "P" },
     $currentDate: { lastModified: true }
   }
)

updateMany()

• ändert alle gefundenen Dokumente

db.collection.updateMany(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ],
     hint:  <document|string>,
     let: <document>
   }
)

Beispiel:

db.inventory.updateMany(
   { "qty": { $lt: 50 } },
   {
     $set: { "size.uom": "in", status: "P" },
     $currentDate: { lastModified: true }
   }
)

Werte aufgrund anderer Felder setzen

Mit $existingField kann der Wert eines anderen Feldes genommen werden.

db.people.updateMany(
  {},
  [{ $set: { newField: "$existingField" } }]
)

Beispiele

Erhöhen / Increase:

db.people.updateMany(
  {},
  { $inc: { age: 3 } }
)

Erniedrigen / Decrease:

db.people.updateMany(
  {},
  { $inc: { age: -3 } }
)

replaceOne()

• ersetzt erstes gefundenes Dokument

db.collection.replaceOne(
   <filter>,
   <replacement>,
   {
      upsert: <boolean>,
      writeConcern: <document>,
      collation: <document>,
      hint: <document|string>
   }
)

Beispiel:

db.inventory.replaceOne(
   { item: "paper" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D", tags: ["red", "blank", "plain"] }
)

Delete

deleteOne()

• löscht erstes gefundenes Dokument

db.collection.deleteOne(
    <filter>,
    {
      writeConcern: <document>,
      collation: <document>,
      hint: <document|string>
    }
)

deleteMany()

• löscht alle gefundenen Dokumente

db.collection.deleteMany(
   <filter>,
   {
      writeConcern: <document>,
      collation: <document>
   }
)

Dies löscht alle Dokumente:

db.collection.deleteMany({})

Objekte

ObjectId

• Primärschlüssel für Objekte

Zusammensetzung:

• 4-Byte Timestamp: Sekunden seit 1.1.1970
• 5-Byte Zufallswert: eindeutig in Bezug auf Maschine und Prozess
• 3-Byte Zähler: initialisiert mit Zufallswert

acknowledge

• positive Rückmeldung
• true oder false

Aggregation Pipeline

• Methode, um grosse Anzahl verschiedener Dokumente einer Collection zu bearbeiten und auszuwerten
• Bearbeitung und Auswertung verschiedener Dokumente einer Collection
• Aneinanderreihung/Durchlauf verschiedener Stages

MongoDB Docs - Aggregation Reference

Begriffe

Aggregation

• Analyse und Zusammenfassung von Daten

Stage

• Aggregation-Operation, ausgeführt auf den Daten

Aggregation Pipeline

• Ausführung mehrerer Stages geordnet hintereinander

Syntax

db.<collection>.aggregate(
    { <stage> }
)

db.<collection>.aggregate( [
    { <stage> },
    { <stage> },
    ...
] )

Operatoren

MongoDB Docs - Aggregation Operator

Stages

Stages/Einzeloperationen

• werden aneinandergereiht
• jede Stage bearbeitet die Output-Dokumente der letzten Stage
• Funktionen
  • Filterung
  • Sortierung
  • Gruppierung
    • es können Resultate für Gruppen berechnet werden: Anzahl, Summe, Durchschnitt, Minimum, Maximum
  • Bearbeitung

Stage	Beschreibung	Syntax
$match	Filterung	{ $match: { <query predicate> } }
$group	Gruppierung	{ $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } }
$sort	Sortierung	{ $sort: { <field1>: <sort order>, <field2>: <sort order> ... } }
$project	Eigenschaften-Auswahl	{ $project: { <specification(s)> } }
$out	Speicherung in Collection in beliebiger Datenbank	{ $out: "<output-collection>" }
$unwind	Restrukturierung von Array-Elemente in einzelne Dokumente	{ $unwind: <field path> }

$match - Filterung

db.collection.aggregate( [
    {
        $match: {
            <query predicate>
        }
    }
] )

Beispiel:

db.collection.aggregate([
    $match: {
        $or: [
            { score: { $gt: 70, $lt: 90 } }, 
            { views: { $gte: 1000 } } 
        ] 
    }
]);

$group - Gruppierung

db.collection.aggregate([
    {
        $group: {
            _id: <expression>, // property to group with: "$fieldName"
            <field1>: { <accumulator1> : <expression1> },
            ...
        }
    }
])

	Bedeutung
<expression>	existierendes Feld, nach dem gruppiert wird: $fieldName
<field1>	neues Feld mit berechnetem Wert der Gruppe
<accumulator1>	Definierung, welche Berechnung auf Gruppe ausgeführt werden soll
<expression1>	Ausdruck für Berechnungs-Operator

Accumulator	Bedeutung
$avg	Durchschnitt
$bottom	letztes Element
$buttomN	letzte n Elemente
$count	Anzahl der Elemente
$first	Resultat von Expression des ersten Elements
$firstN	Resultat von Expression der ersten n Elemente
$last	Resultat von Expression des letzten Elements
$lastN	Resultat von Expression der letzten n Elemente
$max	grösster Wert einer Expression
$maxN	n grösste Werte
$median	Median
$mergeObjects	Erstellung von Dokument durch Kombinierung aller Elemente
$min	kleinster Wert einer Expression
$minN	n kleinste Werte
$sum	Summe
$top	erstes Element
$topN	erste n Elemente

Beispiel:

db.collection.aggregate([
  {
    $unwind: {
      path: "$module"
    }
  },
  {
    $unwind: {
      path: "$module.noten"
    }
  },
  {
    $group: {
      _id: "$schueler.id",
      schueler_name: {
        $first: "$schueler.name"
      },
      schueler_vorname: {
        $first: "$schueler.vorname"
      },
      noten_durchschnitt: {
        $avg: "$module.noten.note"
      }
    }
  }
])

$sort - Sortierung

db.collection.aggregate([
    {
        $sort: {
            <field1>: <sort order>,
            <field2>: <sort order>
            ... 
        }
    }
])

<sort order>:

Wert	Bedeutung
1	ascending
-1	descending

Beispiel:

db.shoes.aggregate( [
   {
      $match: { sizes: { $gt: 9 } }
   },
   {
      $sort: { sizes: 1 }
   }
] )

$limit - Limitierung

db.collection.aggregate( [
    { $limit: <positive 64-bit integer> }
] )

$project - Feld-Auswahl

Mit $project können Eigenschaften aus-, eingeblendet und hinzugefügt werden.

db.collection.aggregate( [
    {
        $project: {
            <specification(s)>
        }
    }
] )

Beispiel:

db.collection.aggregate( [
    {
        $project: {
           size: 1,
           _id: 0,
           name: { $toUpper: "$_id" }
        }
    }
] )

$set - Änderung und Hinzufügen von Feldern

db.zips.aggregate( [
    {
        $set: {
            <field1>: <expression1>,
            <field2>: <expression2>,
            ...
        }
    }
] )

Beispiel:

db.zips.aggregate( [
    {
        $set: {
            population_2022: {
                $round: {
                    $multiply: [
                        "$population_2021",
                        1.0031
                    ]
                }
            }
        }
    }
] )

$count - Anzahl Dokumente

Zählt die Anzahl der Dokumente, welche durch die Pipeline zurückgegeben werden und zeigt diesen Wert in einem Feld an.

db.collection.aggregate( [```
    {
        $count: "<output-field>"
    }
] )

$out - Speicherung in Collection in beliebiger Datenbank

Schreibt die Dokumente der Pipeline in eine neue Collection in der aktuellen oder einer beliebigen Datenbank. Existiert die zu erstellende Collection schon, wird sie überschrieben. MongoDB Docs - Time Series

db.collection.aggregate( [
    {
        $out: "<output-collection>" 
    }
] )

db.collection.aggregate( [
    {
        $out: {
            db: "<output-db>",
            coll: "<output-collection>"
        }
    }
] )

db.collection.aggregate( [
    {
        $out: {
            db: "<output-db>",
            coll: "<output-collection>",
            timeseries: {
                timeField: "<field-name>",
                metaField: "<field-name>",
                granularity:  "seconds" || "minutes" || "hours" ,
            }
        }
    }
] )

Time Series Collections speichern Daten, welche nach Zeit organisiert sind. Es werden die Werte der Daten an verschiedenen Zeitpunkten gespeichert.

Beispiel:

db.collection.aggregate( [
    {
        $out: {
            db: "analyses",
            coll: "books"
        }
    }
] )

$unwind - Restrukturierung von Array-Elemente in einzelne Dokumente

Mit $unwind werden alle Elemente eines bestimmten Arrays in ein einzelnes Dokument gepackt, wobei die anderen Eigenschaften in jedem so erstellten Dokument vorkommen.

db.collection.aggregate( [
    {
        $unwind: <field path>
    }
] )

db.collection.aggregate( [
    {
        $unwind: {
            path: <field path>,
            includeArrayIndex: <string>,
            preserveNullAndEmptyArrays: <boolean>
        }
    }
] )

Beispiel:

db.clothing.insertMany([
  { "_id" : 1, "item" : "Shirt", "sizes": [ "S", "M", "L"] },
  { "_id" : 2, "item" : "Shorts", "sizes" : [ ] },
  { "_id" : 3, "item" : "Hat", "sizes": "M" },
  { "_id" : 4, "item" : "Gloves" },
  { "_id" : 5, "item" : "Scarf", "sizes" : null }
])

db.clothing.aggregate( [
    {
        $unwind: {
            path: "$sizes"
        }
    }
] )

Ausgabe:

{ _id: 1, item: 'Shirt', sizes: 'S' },
{ _id: 1, item: 'Shirt', sizes: 'M' },
{ _id: 1, item: 'Shirt', sizes: 'L' },
{ _id: 3, item: 'Hat', sizes: 'M' }

Indexing

• full collection scan
  • Durchsuchung aller Dokumente
  • wenn MongoDB keine Indexierung auf einer Eigenschaft einer Collection hat
• unterstützte Indexarten
  • Single Index
  • Compound Index
  • Geospatial Index
  • Text-Index
  • Clustered Index
  • ...
• Realisierung
  • meiste Indexarten: als B-Tree-Index
  • auch unterstützt: als Hash-Index

Index erstellen

• Standard-Name des Indexes: <Attributnamen>_<1|-1>

db.collection.createIndex(
    { <field>: <type>, ... },
    {
        unique: <boolean>,
        name: <string>,
        partialFilterExpression: <document>,
        sparse: <boolean>,
        expireAfterSeconds: <number>,
        storageEngine: <document>,
        collation: <document>,
        key: <document>,
        ...
    },
    <commitQuorum>
)

Feld	Beschreibung
<field>	Eigenschaft/Feld für Indexierung
<type>	-1: descending, 1: ascending

Single field Index

• Basis: B-Tree
• unterstützte Filteroperationen
  • <
  • <=
  • =
  • !=

db.collection.createIndex( { <field>: <type> } )

Beispiel:

db.collection.createIndex( { state: -1 } )

Compound Index

• Index auf mehreren Feldern
• Index mit mehreren Sortierebenen
• Reihenfolge der Felder ist wichtig
• Index enthält zuerst Referenzen auf Dokumente des ersten Feldes, dann innerhalb gleicher Feld-Werte auf das zweite Feld, usw.
• Index wird nur genutzt, wenn alle Felder in der Query vorkommen

db.collection.createIndex( { <field>: <type>, ... } )

Beispiel:

db.collection.createIndex( { firstName: -1, "location.city": 1 } )

Text Index

• ermöglicht Volltext-Suche auf Textfeldern

db.collection.createIndex( { "<field>": "text" } )

Beispiel:

db.collection.createIndex( { "name": "text", "description": "text" } )

Abfrage:

db.collection.find( { $text: { $search: "search string" } } )

Hinweis: Es werden auch Dokumente zurückgegeben, welche das Suchwort nicht exakt enthalten.

Beispiel: Suchwort "spiced" findet auch "spice", "spices", ...

Um die Mass für die Güte des Matches zu erhalten, kann man das Meta-Datum textScore zurückgeben lassen. Wenn man dann nach diesem Metadatenfeld sortieren möchte, muss man das Datenfeld explizit nochmals mit $meta abrufen, da dieses Feld nur bei der $text-Suche verfügbar ist.

db.collection.find(
    {
        $text: {
            $search: "spiced"
        }
    },
    {
        score: {
            $meta: "textScore"
        }
    }
).sort({
    score: {
        $meta: "textScore"
    }
})

Somit wird ein zusätzliches Feld score mit dem Wert textScore zurückgegeben. Der textScore sagt aus, wie gut ein Dokument mit der Suche matcht.

Hashed Index

• unterstütze Operationen
  • =
  • !=
• mögliche Anwendung: Sharding Szenarios
  • Dokumente werden auf verschiedene Server verteilt, um Zugriffszeiten ortsabhängig zu verkürzen

db.collection.createIndex( { <field>: "hashed" } )

Beispiel:

db.collection.createIndex( { name: "hashed" } )

Index löschen

db.collection.dropIndex( "<index>" )

Indexes auflisten

db.collection.getIndexes()

Ausgabe:

[
    {
        v: 2,
        key: { _id: 1 },
        name: "_id_"
    }
]

Eigenschaft	Beschreibung
v	interne Version der Indexstruktur
key

Explaining

• zeigt, wie eine Query ausgeführt wird

db.collection.explain().<method(...)>
db.collection.<method(...)>.explain()

Beispiel:

db.products.explain().remove( { category: "apparel" }, { justOne: true } )
db.products.remove( { category: "apparel" }, { justOne: true } ).explain("executionStats")

Rückgabe

executionStats

executionStats: {
   executionSuccess: <boolean>,
   nReturned: <int>,
   executionTimeMillis: <int>,
   totalKeysExamined: <int>,
   totalDocsExamined: <int>,
   executionStages: {
      stage: <STAGE1>
      nReturned: <int>,
      executionTimeMillisEstimate: <int>,
      opens: <int>, // Starting in MongoDB 5.1
      closes: <int>, // Starting in MongoDB 5.1
      works: <int>,
      advanced: <int>,
      needTime: <int>,
      needYield: <int>,
      saveState: <int>,
      restoreState: <int>,
      isEOF: <boolean>,
      ...
      inputStage: {
         stage: <STAGE2>,
         nReturned: <int>,
         ...
         numReads: <int>, // Starting in MongoDB 5.1
         ...
         executionTimeMillisEstimate: <int>,
         ...
         inputStage: {
            ...
         }
      }
   },
   allPlansExecution: [
      {
         nReturned: <int>,
         executionTimeMillisEstimate: <int>,
         totalKeysExamined: <int>,
         totalDocsExamined:<int>,
         executionStages: {
            stage: <STAGEA>,
            nReturned: <int>,
            executionTimeMillisEstimate: <int>,
            ...
            inputStage: {
               stage: <STAGEB>,
               ...
               inputStage: {
                 ...
               }
            }
         }
      },
      ...
   ]
   operationMetrics: {
      cpuNanos: <int>,
      cursorSeeks: <int>,
      docBytesRead: <int>,
      docBytesWritten: <int>,
      docUnitsRead: <int>,
      docUnitsReturned: <int>,
      docUnitsWritten: <int>,
      idxEntryBytesRead: <int>,
      idxEntryBytesWritten: <int>,
      idxEntryUnitsRead: <int>,
      idxEntryUnitsWritten: <int>,
      totalUnitsWritten: <int>,
      keysSorted: <int>,
      sorterSpills: <int>
   }
}

Eigenschaft	Beschreibung
executionTimeMillis	Dauer der Ausführung in Millisekunden
totalKeysExamined	Anzahl der gescannten Index-Einträge
totalDocsExamined	Anzahl der untersuchten Dokumente
executionStages	Baum der Befehl-Phasen, input stages: thenStage, elseStage, innerStage, outerStage

MongoDB Docs - Explain Results - ExecutionStats

Backup - Restore

Möglichkeiten:

• Backup mit mongodump
• Backup auf Dateiebene (filecopy)

Möglichkeiten, welche nur in gemanagten Cloudumgebung zur Verfügung stehen:

• Backup mit Atlas (fully-managed cloud service)
• Backup mit MongoDB Cloud Manager (fully-managed cloud service)

Datenbank-Dump

• Sicherung der gesamten Datenbanken und Collections mit allen Eigenschaften (Indexes, et cetera)
• eignet sich für kleinere und mittlere Umgebungen
• mit BSON-Datendumps

mongodump

• erstellt binäre BSON-Datendumps

mongodump <options> <connection-string>

Option	Bedeutung
--host=<hostname><:port>, -h	Hostname und Port des MongoDB deployments
--authenticationDatabase=<dbname>	Datenbank, welche den Benutzer enthält, mit dem man sich einloggen möchte
--username=<username>, -u	Benutzername
--password=<password>, -p	Passwort
--db=<database>, -d	Datenbank zum Sichern
--collection=<collection>, -c	Collection zum Sichern
--out=<path>, -o	Verzeichnis, wohin die BSON Dumpdateien gespeichert werden sollen

Beispiele:

mongodump --host=localhost --port=27017 \
          --authenticationDatabase=admin -u=user -p=password \
          --db=database \
          --collection=collection \
          --out=/path/to/outdirectory

mongodump mongodb://localhost:27017/testdb --out=C:\backup

Dabei sind folgende Befehle gleichwertig:

mongodump --uri="mongodb://mongodb0.example.com:27017" [additional options]
mongodump --host="mongodb0.example.com:27017"  [additional options]
mongodump --host="mongodb0.example.com" --port=27017 [additional options]

Referenz: MongoDB Docs - Database Tools - mongodump

mongorestore

• Wiederherstellung der BSON-Datendumps
• überschreibt keine Dokumente, die schon in existierenden Datenbank vorhanden sind (Dokumente mit gleicher id)

mongorestore <options> <connection-string> <directory or file to restore>

Option	Bedeutung
--host=<hostname><:port>, -h	Hostname und Port des MongoDB deployments
--authenticationDatabase=<dbname>	Datenbank, welche den Benutzer enthält, mit dem man sich einloggen möchte
--username=<username>, -u	Benutzername
--password=<password>, -p	Passwort
--db=<database>, -d	Datenbank zum Zurückladen
--collection=<collection>, -c	Collection zum Zurückladen

Beispiele:

mongorestore --host=localhost --port=27017  \
             --authenticationDatabase=admin -u=user -p=password \
             --db=database \
             /path/to/indirectory

mongorestore mongodb://localhost:27017/backup-test "C:\backup"

Referenz: MongoDB Docs - Database Tools - mongorestore

Dateien-Sicherung - filecopy

• Backup auf Dateiebene
• z.B. durch cp oder rsync
• da dies keine point in time-Aktion ist, ist es wichtig, den MongoDB-Server vorher zu stoppen, um Datenkorruption zu vermeiden
• unterstützt das Dateisystem Snapshots, kann auch dies zur Datenbanken-Sicherung verwendet werden

Export und Import

• Exportieren und Importieren von Daten aus Collections bzw. Dokumenten
• Sicherung von Daten der Collections bzw. Dokumenten (ohne Indexes und Eigenschaften)

mongoexport

• Export von Daten

mongoexport --collection=<coll> <options> <connection-string>

Option	Bedeutung
--host/h =<hostname><:port>	Hostname und Port des MongoDB deployments
--db/-d =<database>	Datenbank zum Exportieren
--collection/-c =<collection>	Collection zum Exportieren
--out/-o =<file>	Datei, in der Export gespeichert werden soll
--type=<json/csv>	Dateityp der Export-Datei: json (default), csv. --fields oder --fieldFile muss definiert werden (siehe Referenz)

Beispiel:

mongoexport --collection=movies mongodb://localhost:27017/test --out="C:\backup"

Referenz: MongoDB Docs - Database Tools - MongoExport

mongoimport

• Import von Daten

mongoimport <options> <connection-string> <file>

Option	Bedeutung
--host/h =<hostname><:port>	Hostname und Port des MongoDB deployments
--db/-d =<database>	Datenbank zum Importieren
--collection/-c =<collection>	Collection zum Importieren
--file=<filename>	Datei, in der Export gespeichert werden soll
--type=<json/csv/tsv	Dateityp der Import-Datei

Beispiel:

mongoimport mongodb://localhost:27017/test --file="C:\backup\movies.json"

Links

Datenbank erstellen Datenbank löschen Collection erstellen Collections auflisten

MongoDB Docs - db.collection.count

SQL vs. MongoDB Mapping

StackOverflow - How to query MongoDB with "like"