JSON Schema Validation & Expressive Query Syntax in MongoDB 3.6

Key Improvements to MongoDB 3.6: JSON Schema Verification and Efficient Query Syntax

MongoDB 3.6 significantly enhances data integrity and control capabilities through the introduction of JSON Schema validation. Compared with previous document verification, JSON Schema verification is more powerful and flexible, supports enforced patterns within arrays and restricts unauthorized properties.

Core advantages of JSON Schema verification:

• Use the $jsonSchema Operator: Allows detailed specification of properties such as types, required status, and additional properties to prevent inserting documents of typos or unauthorized properties.
• Supports complex structures: For example, you can ensure that the lineitems array in an order contains required fields and complies with the specified data types and constraints.
• Combined with efficient query syntax: Transfer a large amount of business logic from the application layer to the database layer, simplify the code base, and reduce errors and inconsistencies in data processing. Efficient query syntax introduces the powerful functions of aggregated expressions into the query language, making it convenient for complex business verification rules and dynamic data inspections.

Migrate from document verification to JSON Schema verification

The following example shows how to upgrade document verification to JSON Schema verification:

First, create a orders collection and verify the configuration using the document:

db.createCollection("orders", {
  validator: {
    item: { $type: "string" },
    price: { $type: "decimal" }
  }
});

This ensures that item is a string and price is a decimal number. However, it cannot prevent the addition of misspelled or unauthorized attributes.

Use the $jsonSchema operator to solve this problem:

db.runCommand({
  collMod: "orders",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["item", "price"],
      properties: {
        item: { bsonType: "string" },
        price: { bsonType: "decimal" }
      }
    }
  }
});

The security can be further enhanced through additionalProperties: false to prevent the addition of undefined properties.

Processing complex data structures (for example: lineitems arrays)

JSON Schema validation allows for verification of complex structures within a document, such as ensuring that each element in the lineitems array contains required fields and complies with the specified data type and constraints. Examples are as follows:

// ... (省略部分代码，与原文类似) ...
lineitems: {
    bsonType: ["array"],
    minItems: 1,
    maxItems: 10,
    items: {
        required: ["unit_price", "sku", "quantity"],
        bsonType: "object",
        additionalProperties: false,
        // ... (省略部分代码，与原文类似) ...
    }
}
// ... (省略部分代码，与原文类似) ...

Use efficient query syntax for more complex business rules verification

Efficient query syntax allows the use of the $expr operator to create dynamic verification rules, such as verifying whether totalWithVAT is equal to total * (1 VAT):

$expr: {
    $eq: [
        "$totalWithVAT",
        { $multiply: ["$total", { $sum: [1, "$VAT"] }] }
    ]
}

Combining $jsonSchema and $expr, complex business logic rules can be integrated into database verification to improve data accuracy and consistency.

Summary

MongoDB 3.6's JSON Schema verification and efficient query syntax provide developers with stronger data integrity and control capabilities, while simplifying application code, reducing errors, and improving data processing efficiency. This makes MongoDB more suitable for handling large, complex applications and data.

The above is the detailed content of JSON Schema Validation & Expressive Query Syntax in MongoDB 3.6. For more information, please follow other related articles on the PHP Chinese website!