Skip to main content

Schemas

In MongoDB, the concept of a schema is more flexible than in traditional relational databases. Unlike SQL databases, where you must define the structure of the data before inserting it, MongoDB collections do not enforce a fixed schema. This means that documents within a single collection can have different fields, and the data types of these fields can vary across documents.

However, MongoDB does provide ways to impose structure on the data through Schema Validation, which allows you to define specific rules for what kind of data can be stored in a collection.

Dynamic Schema​

The dynamic schema nature of MongoDB provides several advantages:

  1. Rapid Prototyping: You can quickly change the structure of your documents without affecting existing data.
  2. Polymorphism: Documents in the same collection can have different shapes and sizes, making it easier to represent hierarchical relationships, arrays, and other complex structures.
  3. Flexibility: You can adapt the schema to meet the changing requirements of your application without requiring a database migration.

Schema Validation​

Schema validation in MongoDB provides a way to enforce a specific structure for documents in a collection. This feature allows you to define rules that specify the types, ranges, and presence of fields in documents. Schema validation is particularly useful for maintaining data integrity, especially in applications where multiple services or components interact with the same database.

Basic Components​

Here are some of the basic components used in schema validation:

  • Type Validation: Specifies the data type of a field (e.g., string, integer, array, etc.).
  • Required Fields: Specifies which fields must be present in each document.
  • Field Constraints: Specifies constraints like minimum or maximum values for numerical fields, or pattern matching for string fields.
  • Nested Fields: Allows validation of fields within embedded documents or arrays.

Syntax​

Schema validation is generally defined using the $jsonSchema operator. Here's a simple example that defines a schema for a users collection:

db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email"],
      properties: {
        name: {
          bsonType: "string",
          description: "Name must be a string"
        },
        email: {
          bsonType: "string",
          pattern: "@mongodb\\.com$",
          description: "Email must be a string and match the specified pattern"
        },
        age: {
          bsonType: "int",
          minimum: 0,
          maximum: 120,
          description: "Age must be an integer between 0 and 120"
        }
      }
    }
  }
});

Validation Levels and Actions​

MongoDB allows you to specify how strictly the schema should be enforced:

  • Validation Level:
    • strict (default): Validates all inserts and updates.
    • moderate: Validates only inserts and updates to documents that already fulfill the validation criteria.
  • Validation Action:
    • error (default): Rejects any insert or update that doesn't meet the schema.
    • warn: Allows the operation but logs a warning.

These can be set using the validationLevel and validationAction options when creating or modifying a collection.

Conditional Validation​

You can apply conditional validation rules based on the value of other fields in the document. For example, you can require a phoneNumber field only if the contactMethod field is set to "phone".

{
  "if": { "properties": { "contactMethod": { "enum": ["phone"] } } },
  "then": { "required": ["phoneNumber"] }
}

Logical Operators​

You can use logical operators like $and, $or, and $not to combine multiple validation rules.

{
  "anyOf": [
    { "properties": { "status": { "enum": ["In Stock"] }, "required": ["quantity"] } },
    { "properties": { "status": { "enum": ["Out of Stock"] }, "required": ["restockDate"] } }
  ]
}

Custom Validation Messages​

You can include custom validation messages using the description field to make it easier to understand why a validation failed.

{
  "properties": {
    "age": {
      "bsonType": "int",
      "minimum": 0,
      "maximum": 120,
      "description": "Age must be an integer between 0 and 120"
    }
  }
}

Array Validation​

You can validate arrays in multiple ways, such as by specifying the types of items they can contain, the minimum and maximum number of items, or even applying schema validation to each item in the array.

{
  "properties": {
    "tags": {
      "bsonType": "array",
      "items": {
        "bsonType": "string"
      },
      "minItems": 1,
      "uniqueItems": true
    }
  }
}

Pattern Properties​

You can use regular expressions to match field names and apply validation rules to them. This is useful for dynamic fields.

{
  "patternProperties": {
    "^data_": {
      "bsonType": "int",
      "minimum": 0
    }
  }
}

Referencing External Schemas​

In some MongoDB drivers and tools, you can reference external JSON Schema files, making it easier to manage complex schemas and reuse them across multiple collections or services.

{
  "$ref": "external-schema.json"
}

Enum Validation​

You can restrict a field to a set of predefined values using the enum keyword.

{
  "properties": {
    "status": {
      "enum": ["Active", "Inactive", "Pending"]
    }
  }
}

Considerations​

  1. Backward Compatibility: Be cautious when applying schema validation to existing collections, as it may cause existing documents that don't meet the criteria to become invalid based on the validation level.

  2. Performance: Schema validation adds some computational overhead to each write operation, which could impact performance.

  3. Flexibility vs. Strictness: MongoDB is schema-less by nature, offering great flexibility in data modeling. Adding strict schema validation may negate some of this flexibility, so it's essential to find the right balance for your use case.

Embedded Documents and References​

MongoDB allows you to define complex schemas with embedded documents and references:

  1. Embedded Documents: You can embed one document inside another, which is useful for representing hierarchical relationships.
  2. References: You can store a reference to a document from another collection, which is useful for representing relationships between documents.

Data Types​

MongoDB supports various data types, including:

  • String
  • Integer
  • Boolean
  • Double
  • Min/Max keys
  • Arrays
  • Timestamp
  • Object
  • Null
  • Symbol
  • Date
  • Object ID
  • Binary Data
  • Code
  • Regular expression

Indexing​

You can create indexes on any field in the document, including fields within embedded documents, to improve query performance.

Schema Design Patterns​

There are several design patterns for MongoDB schema design, such as:

  1. Embedded Data Models: For "contains" relationships between entities.
  2. Normalized Data Models: For "references" between entities.
  3. Bucketing: Useful for time-series data.
  4. Pre-allocation: Pre-creating document structures that you'll fill in later.
  5. Sharding: Distributing data across multiple servers.