Collections maken in MongoDB: handmatige en automatische methoden

Als je met MongoDB werkt, vooral als developer met een relationele database-achtergrond, valt al snel op hoe flexibel het schemadesign kan zijn.

Collecties in MongoDB hoeven niet vooraf expliciet te worden aangemaakt, maar soms is het zinvol om ze bewust te definiëren en zorgvuldig te configureren.

In dit artikel kijken we naar hoe en wanneer je een collectie in MongoDB wilt aanmaken, enkele belangrijke configuratie-opties om te overwegen en wat codevoorbeelden in JS en C# (mijn favoriet). 

Geen zorgen: er is veel feature parity tussen drivers, dus veel van wat je hier ziet, is mogelijk in <insert your language of choice>.

Ben je nieuw met NoSQL-databases? Begin dan met een Introductie tot NoSQL.

Wat is een MongoDB-collectie?

Voordat we kijken hoe je collecties maakt, staan we kort stil bij wat een collectie eigenlijk is. 

Als je uit de SQL-wereld komt, ben je gewend aan tabellen, rijen en kolommen. In MongoDB zijn de termen net even anders. In plaats van tabellen hebben we collecties en in plaats van rijen hebben we documenten met velden, geen kolommen. 

Eén van de superkrachten van MongoDB is het dynamische schema. Dat betekent dat je niet handmatig een collectie hoeft te maken voordat je die gebruikt. Als je een document invoegt in een collectie die nog niet bestaat, maakt MongoDB die automatisch aan. Als je bijvoorbeeld draait: 

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

Dan probeert MongoDB een enkel document voor de film “The Matrix” in de collectie movies in te voegen. Bestaat die al, dan wordt het document toegevoegd. Bestaat die nog niet, dan wordt de collectie movies eerst aangemaakt en daarna het document toegevoegd.

Je kunt ook meerdere documenten tegelijk toevoegen met insertMany in plaats van insertOne.

Wanneer MongoDB-collecties expliciet definiëren

Ook al kun je MongoDB collecties automatisch laten aanmaken, er zijn goede redenen om collecties vooraf te definiëren, zeker in productieomgevingen. Collecties expliciet aanmaken geeft je de kans om:

• Af te stemmen op capped collecties voor logging of caching.
• Regels voor validatie in te stellen om constraints in je schema’s af te dwingen.
• Bepaalde standaardindexen toe te passen, zoals time-to-live (TTL). Deze indexen op een datumveld verwijderen automatisch documenten in je collectie na de door jou opgegeven tijd.
• Te optimaliseren voor schrijfintensieve workloads door collecties vooraf te resizen.

Zo maak je een collectie aan in de MongoDB Shell:

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

Of met validatie:

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

Hoewel MongoDB een flexibel schema ondersteunt, kun je alsnog validatieregels toevoegen, zoals verplichte velden of het specificeren van eigenschappen voor bepaalde velden, zoals datatypes of e-mailformatting, zoals hierboven te zien. Handig als je wilt zekerstellen dat je documenten een specifiek schema volgen. 

Schemahandhaving voelt vertrouwd als je uit SQL komt, en zelfs als dat niet zo is, hebben productietoepassingen soms voorspelbaar gevormde documenten nodig. Validatie is hier dus uitstekend voor!

MongoDB-collecties maken met de C#-driver

In een C#-applicatie kun je ook expliciet collecties aanmaken met de MongoDB-driver. Dat is niet vereist voor basishandelingen, maar dit is wél waar je geavanceerde opties programmatisch kunt instellen.

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

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

Een validator toevoegen:

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);

Voor Python-developers is de tutorial Introductie tot MongoDB en Python een aanrader.

Belangrijke configuratie-opties voor collecties

Als je collecties expliciet aanmaakt, zijn dit opties die je wilt kennen:

• capped: maakt een collectie met vaste grootte
• size: maximale grootte in bytes voor een capped collectie
• max: maximaal toegestaan aantal documenten
• validator: JSON-object in schema-syntax dat schema-validatie definieert
• expireAfterSeconds: gebruikt met TTL-indexen voor automatische verwijdering van documenten

Je kunt ook indexen toepassen bij het aanmaken of kort daarna. MongoDB maakt indexen niet automatisch aan, behalve wanneer dat vereist is voor _id.

Indexen in MongoDB verbeteren de performance van je meest geraadpleegde velden. De waarden worden in het geheugen gecachet, waardoor er geen schijftoegang nodig is om ze op te halen. Dat kan veel tijd en performance schelen bij regelmatig gebruik.

Best practices voor het definiëren van MongoDB-collecties

Hier zijn enkele richtlijnen om te helpen beslissen wanneer je collecties expliciet definieert:

• Impliciete aanmaak voor snelle proof-of-concepts of lokale ontwikkeling, of wanneer de eindgebruiker de content dynamisch kan genereren
• Expliciete aanmaak wanneer je validatie wilt toepassen of instellingen voor indexering of performance wilt configureren

Conclusie

MongoDB staat bekend om zijn flexibele schema, wat ons vrijheid geeft in hoe we data structureren—en dat geldt ook voor het maken en beheren van collecties. Impliciete aanmaak is snel en handig, maar expliciete collectiedefinities ontgrendelen krachtige features zoals schema-validatie, capped gedrag en performance tuning.

Zoals altijd maakt MongoDB Atlas het beheren van collecties nog eenvoudiger met UI-tools, automatisering en ingebouwde performance-inzichten. En als je in .NET werkt, biedt de C#-driver sterke, getypeerde modellen en vloeiende API’s.

Bij het overwegen van best practices voor het definiëren van MongoDB-collecties kunnen fundamentele principes van databaseontwerp ook nuttig zijn.

Happy coding! Dat je collecties snel, valide en goed geïndexeerd mogen zijn!