Creare collezioni in MongoDB: metodi manuali e automatici

Quando lavori con MongoDB, soprattutto se arrivi da un database relazionale, una delle prime cose che noterai è la flessibilità del design dello schema.

Le collezioni in MongoDB non devono essere create in anticipo in modo esplicito, ma ci sono momenti in cui ha senso definirle e configurarle con attenzione.

In questo articolo vedremo come e quando potresti voler creare una collezione in MongoDB, alcune opzioni di configurazione chiave da considerare e alcuni esempi di codice in JS e C# (il mio preferito). 

Non preoccuparti, abbiamo molta parità di funzionalità tra i driver, quindi gran parte di ciò che vedi qui oggi sarà possibile in <inserisci il linguaggio che preferisci>.

Se sei nuovo ai database NoSQL, valuta di iniziare con una Introduzione a NoSQL.

Che cos’è una collezione MongoDB?

Prima di vedere come creare le collezioni, parliamo brevemente di cosa sia effettivamente una collezione. 

Se provieni dal mondo SQL, sarai abituato a tabelle, righe e colonne. In MongoDB i termini sono leggermente diversi. Al posto delle tabelle abbiamo le collezioni, e al posto delle righe abbiamo documenti con campi, non colonne. 

Uno dei superpoteri di MongoDB è lo schema dinamico. Significa che non devi creare manualmente una collezione prima di usarla. Se inserisci un documento in una collezione che ancora non esiste, MongoDB la creerà automaticamente. Ad esempio, se esegui: 

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

Proverà a inserire un singolo documento per il film “The Matrix” nella collezione movies. Se esiste già, il documento verrà aggiunto alla collezione. Se non esiste, la collezione movies verrà creata prima di aggiungere il nuovo documento.

Puoi anche aggiungere molti documenti in una volta usando insertMany invece di insertOne.

Quando definire esplicitamente le collezioni MongoDB

Anche se puoi lasciare che MongoDB gestisca automaticamente la creazione delle collezioni, ci sono ottimi motivi per definirle in anticipo, soprattutto in produzione. Creare esplicitamente le collezioni ti dà l’opportunità di:

• Configurare le capped collections per logging o caching.
• Impostare regole di validazione per imporre vincoli negli schemi.
• Applicare alcuni indici predefiniti come il time-to-live (TTL). Questi indici su un campo data elimineranno automaticamente i documenti nella tua collezione in base a un intervallo di tempo specificato.
• Ottimizzare carichi di lavoro con molte scritture pre-dimensionando le collezioni.

Ecco come creeresti una collezione nella MongoDB Shell:

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

Oppure con validazione:

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

Sebbene MongoDB supporti uno schema flessibile, potresti comunque voler aggiungere regole di validazione come campi obbligatori o specificare proprietà su determinati campi, ad esempio tipi di dati o formattazione per le email, come visto sopra. Questo se vuoi assicurarti che i tuoi documenti seguano uno schema specifico. 

L’applicazione dello schema ti sembrerà familiare se arrivi da SQL, e anche se non è così, a volte le applicazioni in produzione hanno bisogno di documenti con una forma prevedibile. Quindi la validazione è ottima per questo!

Creare collezioni MongoDB con il driver C#

In un’applicazione C# puoi anche creare esplicitamente collezioni usando il driver MongoDB. Anche se non è richiesto per le operazioni di base, è qui che puoi impostare opzioni avanzate in modo programmatico.

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

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

Per aggiungere un validator:

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

Per gli sviluppatori Python, il tutorial Introduzione a MongoDB e Python è un’ottima risorsa.

Opzioni di configurazione chiave per le collezioni da conoscere

Quando crei esplicitamente le collezioni, ecco alcune opzioni che potresti voler conoscere:

• capped: crea una collezione a dimensione fissa
• size: dimensione massima in byte per una capped collection
• max: numero massimo di documenti consentiti
• validator: oggetto JSON in sintassi schema che definisce la validazione dello schema
• expireAfterSeconds: usato con gli indici TTL per gestire l’eliminazione automatica dei documenti

Puoi anche applicare indici al momento della creazione o subito dopo. MongoDB non crea automaticamente indici a meno che non siano richiesti per _id.

Gli indici in MongoDB ti consentono di migliorare le prestazioni dei campi a cui accedi più spesso. Memorizzano in cache quei valori in memoria, evitando chiamate al disco per il recupero, il che può far risparmiare molto tempo e migliorare le prestazioni quando li accedi regolarmente.

Best practice per definire le collezioni MongoDB

Ecco alcune linee guida per aiutarti a decidere quando definire esplicitamente le collezioni:

• Creazione implicita per proof of concept rapidi o sviluppo locale, o quando l’utente finale può generare contenuti in modo dinamico
• Creazione esplicita quando vuoi applicare validazione o impostare configurazioni per indicizzazione o prestazioni

Conclusione

MongoDB è noto per il suo schema flessibile che ci dà libertà nel modo in cui strutturiamo i dati, inclusa la creazione e la gestione delle collezioni. Sebbene la creazione implicita sia rapida e comoda, le definizioni esplicite sbloccano funzionalità potenti come validazione dello schema, comportamento capped e tuning delle prestazioni.

Come sempre, MongoDB Atlas rende la gestione delle collezioni ancora più semplice con strumenti basati su UI, automazione e insight prestazionali integrati. E se lavori in .NET, il driver C# ti supporta con modelli fortemente tipizzati e API fluide.

Quando valuti le best practice per definire le collezioni MongoDB, comprendere i principi fondamentali di progettazione di database può essere utile.

Buon coding! Che le tue collezioni siano veloci, valide e ben indicizzate!