Hogyan működik a sémavalidálás a MongoDB-ben?

Question

Accepted Answer

Bár a MongoDB alapértelmezésben rugalmas, támogatja az **sémavalidálást** az adatbázis szintjén — olyan szabályok definiálásával (kötelező mezők, típusok, értékkorlátok), amelyeknek a dokumentumoknak meg kell felelniük. Ez az adatintegritást *magában a MongoDB-ben* biztosítja (nem csak az alkalmazás kódjában), egyensúlyt teremtve a rugalmasság és az összhang között.

## Validálási szabályok definiálása

```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
```

A MongoDB **JSON Schema** használatával definiál validálási szabályokat — kötelező mezőket, típusokat, mintákat, tartományokat —, amelyeket az adatbázis kényszerít ki dokumentumok beszúrásakor vagy frissítésekor.

## Validálási szintek és műveletek

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

A `validationLevel` vezérli, mely dokumentumokat ellenőrzik; a `validationAction` vezérli, hogy a szabálysértések hibát okoznak-e (elutasítás) vagy csak figyelmeztetést.

## Miért validáljon az adatbázisban (csak az alkalmazás helyett)?

```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.
```

## Rugalmasság és szerkezet egyensúlya

```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.)
```

## Miért fontos

A MongoDB sémavalidálásának megértése értékes a **MongoDB rugalmasságának és az adatintegritásnak az egyensúlyozásához**, ezért hasznos tudás megbízható MongoDB alkalmazások fejlesztéséhez.

Bár a MongoDB séma nélküli rugalmassága nagy előny (és az evolúciós, változatos adatokhoz megfelelő), az **ellenőrzetlen rugalmasság inkonzisztens adatokhoz vezethet** (hiányzó mezők, helytelen típusok, érvénytelen értékek) — ez valós adatminőségi probléma.

A sémavalidálás ezt úgy oldja meg, hogy lehetővé teszi szabályok érvényre juttatását (kötelező mezők, típusok, mintázatok, tartományok JSON Schema segítségével) **az adatbázis szintjén**, így a dokumentumoknak meg kell felelniük azoknak.

An **adatbázis szintű validálás** (csak az alkalmazás szintűvel szemben) kulcsfontosságú előnye az, hogy azt kikényszerítik függetlenül attól, hogy mely alkalmazás, szolgáltatás, szkript vagy manuális művelet írja az adatokat — konzisztens integritási garanciát és biztonsági hálót nyújtva akkor is, ha az alkalmazás validálása meg van kerülve vagy hibás (ugyanaz az érvelés, mint az SQL korlátok esetén: az adatbázis az utolsó védelmi vonal).

A **validálási szintek és műveletek** megértése (annak szabályozása, hogy mely dokumentumokat ellenőrzik és hogy a szabálysértések elutasítanak vagy figyelmeztetnek) rugalmas bevezetést tesz lehetővé.

Legfontosabb, hogy megértsük, hogyan kell **egyensúlyt tartani a rugalmasság és a szerkezet között** — validálás hozzáadása ott, ahol az összhang számít, miközben máshol megőrizzük a rugalmasságot, gyakran rugalmas kezdéssel és validálás hozzáadásával, ahogy a séma stabilizálódik — ez a MongoDB érett használatát tükrözi, amely a rugalmasság előnyeit szerzed meg anélkül, hogy kritikus adatintegritást feláldoznál.

Annak tudatában, hogy a validálást gyakran az alkalmazás szintjén is elvégzik (például Mongoose schémák), az is releváns.

Mivel az adatintegritás még rugalmas adatbázisokban is fontos, és mivel a MongoDB sémavalidálása lehetővé teszi a szerkezet érvényre juttatását ott, ahol szükséges (az adatbázis szintjén erős garancia érdekében), miközben megőrzi a rugalmasságot, a sémavalidálás megértése — hogyan működik, az adatbázis szintű érvényre juttatás előnyei és a rugalmasság és szerkezet egyensúlya — értékes, praktikus tudás MongoDB alkalmazások fejlesztéséhez, amelyek megőrzik az adatminőséget, egy hasznos képesség, amely a rugalmas séma adatbázisaiban az inkonzisztens adat gyakori problémáját oldja meg.