Sammlungen in MongoDB erstellen: Manuelle und automatische Methoden

Wenn du mit MongoDB arbeitest, vor allem als Entwickler, der aus einer relationalen Datenbank kommt, ist eines der ersten Dinge, die du bemerken wirst, wie flexibel das Schema-Design sein kann.

Sammlungen in MongoDB müssen nicht explizit erstellt werden, aber es gibt Zeiten, in denen es sinnvoll ist, sie explizit zu definieren und sorgfältig zu konfigurieren.

In diesem Artikel schauen wir uns an, wie und wann du eine Sammlung in MongoDB erstellen kannst, welche wichtigen Konfigurationsoptionen zu beachten sind und welche Codebeispiele in JS und C# (mein Favorit) es gibt. 

Keine Sorge, wir haben eine große Funktionsgleichheit zwischen den Treibern, so dass vieles von dem, was du heute hier siehst, auch in <Füge die Sprache deiner Wahl ein> möglich ist.

Wenn du neu im Bereich NoSQL-Datenbanken bist, solltest du mit der Einführung in NoSQL beginnen.

Was ist eine MongoDB-Sammlung?

Bevor wir uns ansehen, wie man Sammlungen erstellt, wollen wir kurz besprechen, was eine Sammlung eigentlich ist. 

Wenn du aus einer SQL-Umgebung kommst, bist du es vielleicht gewohnt, von Tabellen, Zeilen und Spalten zu hören. In MongoDB sind die Begriffe etwas anders. Anstelle von Tabellen haben wir Sammlungen und anstelle von Zeilen haben wir Dokumente mit Feldern und nicht mit Spalten. 

Eine der größten Stärken von MongoDB ist sein dynamisches Schema. Das bedeutet, dass du eine Sammlung nicht manuell erstellen musst, bevor du sie verwendest. Wenn du ein Dokument in eine Sammlung einfügst, die noch nicht existiert, erstellt MongoDB es automatisch. Wenn du zum Beispiel: 

db.movies.insertOne({ title: "The Matrix", year: 1999 });

Es wird versucht, ein einzelnes Dokument für den Film "The Matrix" in die Sammlung movies einzufügen. Wenn diese bereits existiert, wird das Dokument der Sammlung hinzugefügt. Wenn das nicht der Fall ist, wird die Sammlung movies erstellt, bevor das neue Dokument hinzugefügt wird.

Du kannst auch viele Dokumente auf einmal hinzufügen, indem du insertMany anstelle von insertOne verwendest.

Wann MongoDB-Sammlungen explizit definiert werden sollten

Auch wenn du die Erstellung von Sammlungen automatisch von MongoDB erledigen lassen kannst, gibt es gute Gründe, Sammlungen im Voraus zu definieren, insbesondere in Produktionsszenarien. Das explizite Anlegen von Sammlungen gibt dir die Möglichkeit,:

• Konfiguriere gekappte Sammlungen für die Protokollierung oder das Caching.
• Richte Validierungsregeln ein, um Einschränkungen in deinen Schemata durchzusetzen.
• bestimmte Standard-Indizes wie Time-to-Live (TTL) anwenden. Diese Indizes für ein Datumsfeld löschen automatisch Dokumente in deiner Sammlung nach einer von dir festgelegten Zeitspanne.
• Optimiere die Collections für schreibintensive Workloads, indem du sie vorbereitest.

So erstellst du eine Sammlungin der MongoDB-Shell:

db.createCollection("auditLogs", {
  capped: true,
  size: 10485760, // 10 MB
  max: 1000
});

Oder mit Validierung:

db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["email", "createdAt"],
      properties: {
        email: {
          bsonType: "string",
          pattern: "^.+@.+$"
        },
        createdAt: {
          bsonType: "date"
        }
      }
    }
  }
});

Obwohl MongoDB ein flexibles Schema unterstützt, möchtest du vielleicht trotzdem Validierungsregeln hinzufügen, z. B. erforderliche Felder oder die Angabe von Eigenschaften für bestimmte Felder, wie Datentypen oder Formatierungen für E-Mails, wie oben gezeigt. Dies ist notwendig, wenn du sicherstellen willst, dass deine Dokumente einem bestimmten Schema folgen. 

Die Schemaerzwingung wird dir vertraut vorkommen, wenn du aus dem SQL-Umfeld kommst, und selbst wenn nicht, müssen deine Anwendungen in der Produktion manchmal vorhersehbar geformte Dokumente haben. Die Validierung ist also hervorragend dafür geeignet!

Erstellen von MongoDB-Sammlungen mit dem C#-Treiber

In einer C#-Anwendung kannst du auch explizit Sammlungen mit dem MongoDB-Treiber erstellen. Für die grundlegenden Vorgänge ist dies zwar nicht erforderlich, aber hier kannst du erweiterte Optionen programmatisch einstellen.

var options = new CreateCollectionOptions
{
    Capped = true,
    MaxSize = 10485760, // 10 MB
    MaxDocuments = 1000
};

await database.CreateCollectionAsync("auditLogs", options);

Um einen Validator hinzuzufügen:

var validator = new BsonDocument
{
    { "$jsonSchema", new BsonDocument
        {
            { "bsonType", "object" },
            { "required", new BsonArray { "email", "createdAt" } },
            { "properties", new BsonDocument
                {
                    { "email", new BsonDocument
                        {
                            { "bsonType", "string" },
                            { "pattern", "^.+@.+$" }
                        }
                    },
                    { "createdAt", new BsonDocument
                        {
                            { "bsonType", "date" }
                        }
                    }
                }
            }
        }
    }
};

var collectionOptions = new CreateCollectionOptions<BsonDocument>
{
    Validator = new BsonDocumentFilterDefinition<BsonDocument>(validator)
};

await database.CreateCollectionAsync("users", collectionOptions);

Für Python-Entwicklerist das Tutorial Einführung in MongoDB und Python eine gute Ressource.

Wichtige Konfigurationsoptionen für Sammlungen, die du kennen solltest

Wenn du explizit Sammlungen erstellst, sind hier einige Optionen, die du kennen solltest:

• capped: erstellt eine Sammlung mit fester Größe
• size: Maximale Größe in Bytes für eine gekappte Sammlung
• max: maximale Anzahl von Dokumenten erlaubt
• validator: JSON-Objekt in Schemasyntax, das die Schema-Validierung definiert
• expireAfterSeconds: Wird mit TTL-Indizes verwendet, um die automatische Löschung von Dokumenten zu handhaben.

Du kannst Indizes auchbei der Erstellungme oder kurz danach anwenden. MongoDB erstellt nicht automatisch Indizes, es sei denn, sie sind für _id erforderlich.

Mit Indizes in MongoDB kannst du die Leistung deiner am häufigsten genutzten Felder verbessern. Diese Werte werden im Speicher zwischengespeichert, so dass keine Festplattenaufrufe erforderlich sind, was bei regelmäßigem Zugriff viel Zeit und Leistung sparen kann.

Best Practices für die Definition von MongoDB-Sammlungen

Hier sind ein paar Richtlinien, die dir helfen zu entscheiden, wann du Sammlungen explizit definieren solltest:

• Implizite Erstellung für schnelle Proof-of-Concepts oder lokale Entwicklung oder wenn der Endnutzer in der Lage ist, den Inhalt dynamisch zu erstellen
• Explizite Erstellung für den Fall, dass du eine Validierung anwenden oder Einstellungen für die Indizierung oder Leistung vornehmen willst

Fazit

MongoDB ist für sein flexibles Schema bekannt, mit dem wir unsere Daten flexibel strukturieren können, auch bei der Erstellung und Verwaltung von Sammlungen. Während die implizite Erstellung schnell und bequem ist, bieten explizite Sammlungsdefinitionen leistungsstarke Funktionen wie Schemavalidierung, Capped Behavior und Performance-Tuning.

Wie immer macht MongoDB Atlas die Verwaltung von Sammlungen mit UI-basierten Tools, Automatisierung und integrierten Leistungseinblicken noch einfacher. Und wenn du in .NET arbeitest, ist der C#-Treiber mit stark typisierten Modellen und flüssigen APIs für dich da.

Wenn du über die besten Praktiken für die Definition von MongoDB-Sammlungen nachdenkst,kann es auch von Vorteil sein, die grundlegendenPrinzipien des Datenbankdesigns zu verstehen.

Viel Spaß beim Codieren! Mögen deine Sammlungen schnell, gültig und gut indexiert sein!