Hvordan fungerer skemavalidering i MongoDB?

Question

Accepted Answer

Selvom MongoDB er fleksibel som standard, understøtter det **skemavalidering** på databaseniveauet — definition af regler (påkrævede felter, typer, værdigrænser), som dokumenter skal opfylde. Dette tilføjer dataintegritet *inden i* MongoDB selv (ikke kun i applikationskoden) og balancerer fleksibilitet med konsistens.

## Definition af valideringsregler

```js
// add a JSON Schema validator when creating (or modifying) a collection
db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email"],            // required fields
      properties: {
        name: { bsonType: "string" },
        email: { bsonType: "string", pattern: "^.+@.+$" },   // type + pattern
        age: { bsonType: "int", minimum: 0, maximum: 120 }   // range
      }
    }
  }
});
// → documents that don't satisfy this are REJECTED on insert/update
```

MongoDB bruger **JSON Schema** til at definere valideringsregler — påkrævede felter, typer, mønstre, områder — som databasen håndhæver, når dokumenter indsættes eller opdateres.

## Valideringsniveauer og handlinger

```js
db.runCommand({
  collMod: "users",
  validator: { $jsonSchema: { ... } },
  validationLevel: "moderate",     // "strict" (all) or "moderate" (only valid existing docs)
  validationAction: "error"        // "error" (reject) or "warn" (log but allow)
});
```

`validationLevel` styrer, hvilke dokumenter der kontrolleres; `validationAction` styrer, om overtrædelser resulterer i fejl (afvis) eller blot advarsel.

## Hvorfor validere i databasen (i stedet for kun i appen)?

```text
✓ DATABASE-LEVEL guarantee — enforced regardless of which app/code writes data
  (multiple services, scripts, manual changes) → consistent data integrity
✓ A safety net even if application validation is bypassed or buggy
→ Similar reasoning to SQL constraints: the DB is the last line of defense for integrity.
```

## Balance mellem fleksibilitet og struktur

```text
MongoDB's flexibility is valuable, but UNCONTROLLED flexibility → inconsistent data.
Schema validation lets you add structure WHERE you need it:
  → enforce critical fields/types while keeping flexibility elsewhere
  → start flexible, add validation as the schema stabilizes
(Often validation is also/instead done in the app layer, e.g. via Mongoose schemas.)
```

## Hvorfor det betyder noget

Forståelse af MongoDB-skemavalidering er værdifuld for **at balancere MongoDBs fleksibilitet med dataintegritet**, så det er nyttig viden for at bygge pålidelige MongoDB-applikationer.

MongoDBs schema-løse fleksibilitet er en stor fordel (der passer til udviklings- og varierede data), men **ukontrolleret fleksibilitet kan føre til inkonsistente data** (manglende felter, forkerte typer, ugyldige værdier) — en reel bekymring for datakvalitet.

Skemavalidering løser dette ved at lade dig håndhæve regler (påkrævede felter, typer, mønstre, områder via JSON Schema) **på databaseniveauet**, så dokumenter skal opfylde dem.

Hovedværdien af **databaseniveauvalidering** (i modsætning til kun applikationsniveauvalidering) er, at den håndhæves uanset hvilken applikation, tjeneste, script eller manuel operation, der skriver dataene — hvilket giver en konsistent integritetgaranti og et sikkerhedsnet, selvom applikationsvalidering omgås eller er fejlbehæftet (samme ræsonnement som SQL-begrænsninger: databasen som sidste forsvarslinje).

Forståelse af **valideringsniveauer og handlinger** (styring af, hvilke dokumenter der kontrolleres, og om overtrædelser afvises eller advarer) muliggør fleksibel implementering.

Mest vigtigst er forståelse af, hvordan man **balancerer fleksibilitet og struktur** — tilføjelse af validering hvor konsistens betyder noget, mens fleksibilitet bibeholdes andre steder, ofte ved at starte fleksibel og tilføje validering, når skemaet stabiliseres — hvilket afspejler moden MongoDB-brug, der får fordelene ved fleksibilitet uden at ofre kritisk dataintegritet.

Viden om, at validering ofte også udføres i applikationslaget (f.eks. Mongoose-skemaer) er også relevant.

Da dataintegritet betyder noget selv i fleksible databaser, og da MongoDBs skemavalidering lader dig håndhæve struktur hvor det er nødvendigt (på databaseniveauet for en stærk garanti) samtidig med at bevareifleksibilitet, er forståelse af skemavalidering — hvordan det virker, fordelene ved databaseniveauvalidering og balancering af fleksibilitet med struktur — værdifuld, praktisk-relevant viden for at bygge MongoDB-applikationer, der opretholder datakvalitet, en nyttig egenskab, der løser den almindelige bekymring for inkonsistente data i fleksible-schema-databaser.