$jsonSchema

Feature Compatibility功能兼容性

The featureCompatibilityVersion must be set to "3.6" or higher in order to use $jsonSchema.featureCompatibilityVersion必须设置为"3.6"或更高，才能使用$jsonSchema。

Document Validator文档验证器

You can use $jsonSchema in a document validator to enforce the specified schema on insert and update operations:您可以在文档验证器中使用$jsonSchema在插入和更新操作中强制执行指定的模式：

db.createCollection( <collection>, { validator: { $jsonSchema: <schema> } } )
db.runCommand( { collMod: <collection>, validator:{ $jsonSchema: <schema> } } )

Query Conditions查询条件

You can use $jsonSchema in query conditions for read and write operations to find documents in the collection that satisfy the specified schema:您可以在读写操作的查询条件中使用$jsonSchema来查找集合中满足指定架构的文档：

db.collection.find( { $jsonSchema: <schema> } )
db.collection.aggregate( [ { $match: { $jsonSchema: <schema> } } ] )
db.collection.updateMany( { $jsonSchema: <schema> }, <update> )
db.collection.deleteOne( { $jsonSchema: <schema> } )

To find documents in the collection that do not satisfy the specified schema, use the $jsonSchema expression in a $nor expression. 要查找集合中不满足指定架构的文档，请在$nor表达式中使用$jsonSchema表达式。For example:例如：

db.collection.find( { $nor: [ { $jsonSchema: <schema> } ] } )
db.collection.aggregate( [ { $match: { $nor: [ { $jsonSchema: <schema> } ] } }, ... ] )
db.collection.updateMany( { $nor: [ { $jsonSchema: <schema> } ] }, <update> )
db.collection.deleteOne( { $nor: [ { $jsonSchema: <schema> } ] } )

Schema Validation模式验证

The following db.createCollection() method creates a collection named students and uses the $jsonSchema operator to set schema validation rules:以下db.createCollection()方法创建名为students的集合，并使用$jsonSchema运算符设置架构验证规则：

db.createCollection("students", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: [ "name", "year", "major", "address" ],
         properties: {
            name: {
               bsonType: "string",
               description: "must be a string and is required"
            },
            year: {
               bsonType: "int",
               minimum: 2017,
               maximum: 3017,
               description: "must be an integer in [ 2017, 3017 ] and is required"
            },
            major: {
               enum: [ "Math", "English", "Computer Science", "History", null ],
               description: "can only be one of the enum values and is required"
            },
            gpa: {
               bsonType: [ "double" ],
               description: "must be a double if the field exists"
            },
            address: {
               bsonType: "object",
               required: [ "city" ],
               properties: {
                  street: {
                     bsonType: "string",
                     description: "must be a string if the field exists"
                  },
                  city: {
                     bsonType: "string",
                     "description": "must be a string and is required"
                  }
               }
            }
         }
      }
   }
} )

Given the created validator for the collection, the following insert operation will fail because gpa is an integer when the validator requires a double.给定为集合创建的validator，以下插入操作将失败，因为当validator需要double时，gpa是整数。

db.students.insertOne( {
   name: "Alice",
   year: Int32( 2019 ),
   major: "History",
   gpa: Int32( 3 ),
   address: {
      city: "NYC",
      street: "33rd Street"
   }
} )

The operation returns the following error:操作返回以下错误：

MongoServerError: Document failed validation
Additional information: {
  failingDocumentId: ObjectId("61aa577f666a50a8fccd7ec2"),
  details: {
    operatorName: '$jsonSchema',
    schemaRulesNotSatisfied: [
      {
        operatorName: 'properties',
        propertiesNotSatisfied: [
          {
            propertyName: 'gpa',
            description: 'must be a double if the field exists',
            details: [ [Object] ]
          }
        ]
      }
    ]
  }
}

After changing the gpa to a double, the insert succeeds:将gpa更改为double后，插入成功：

db.students.insertOne( {
   name: "Alice",
   year: NumberInt(2019),
   major: "History",
   gpa: Double(3.0),
   address: {
      city: "NYC",
      street: "33rd Street"
   }
} )

Query Conditions查询条件

You can use $jsonSchema in query conditions for read and write operations to find documents in the collection that satisfy the specified schema.您可以在读写操作的查询条件中使用$jsonSchema来查找集合中满足指定模式的文档。

For example, create a sample collection inventory with the following documents:例如，使用以下文档创建样本集合inventory：

db.inventory.insertMany( [
   { item: "journal", qty: NumberInt(25), size: { h: 14, w: 21, uom: "cm" }, instock: true },
   { item: "notebook", qty: NumberInt(50), size: { h: 8.5, w: 11, uom: "in" }, instock: true },
   { item: "paper", qty: NumberInt(100), size: { h: 8.5, w: 11, uom: "in" }, instock: 1 },
   { item: "planner", qty: NumberInt(75), size: { h: 22.85, w: 30, uom: "cm" }, instock: 1 },
   { item: "postcard", qty: NumberInt(45), size: { h: 10, w: 15.25, uom: "cm" }, instock: true },
   { item: "apple", qty: NumberInt(45), status: "A", instock: true },
   { item: "pears", qty: NumberInt(50), status: "A", instock: true }
] )

Next, define the following sample schema object:接下来，定义以下示例架构对象：

let myschema =  {
      required: [ "item", "qty", "instock" ],
      properties: {
         item: { bsonType: "string" },
         qty: { bsonType: "int" },
         size: {
            bsonType: "object",
            required: [ "uom" ],
            properties: {
               uom: { bsonType: "string" },
               h: { bsonType: "double" },
               w: { bsonType: "double" }
            }
          },
          instock: { bsonType: "bool" }
      }
 }

You can use $jsonSchema to find all documents in the collection that satisfy the schema:您可以使用$jsonSchema查找集合中满足架构的所有文档：

db.inventory.find( { $jsonSchema: myschema } )
db.inventory.aggregate( [ { $match: { $jsonSchema: myschema } } ] )

You can use $jsonSchema with the $nor to find all documents that do not satisfy the schema:您可以将$jsonSchema与$nor一起使用，以查找所有不满足架构的文档：

db.inventory.find( { $nor: [ { $jsonSchema: myschema } ] } )

Or, you can update all documents that do not satisfy the schema:或者，您可以更新所有不满足架构的文档：

db.inventory.updateMany( { $nor: [ { $jsonSchema: myschema } ] }, { $set: { isValid: false } } )

Or, you can delete all documents that do not satisfy the schema:或者，您可以删除所有不满足架构的文档：

db.inventory.deleteMany( { $nor: [ { $jsonSchema: myschema } ] } )

Available Keywords可用关键字

Extensions扩展

MongoDB's implementation of JSON Schema includes the addition of the bsonType keyword, which allows you to use all BSON types in the $jsonSchema operator. MongoDB对JSON模式的实现包括添加bsonType关键字，这允许您在$jsonSchema运算符中使用所有BSON类型。bsonType accepts the same string aliases used for the $type operator.接受用于$type运算符的相同字符串别名。

Omissions遗漏

The following are not supported in MongoDB's implementation of JSON Schema:MongoDB对JSON模式的实现不支持以下内容：

• Hypertext definitions in draft 4 of the JSON Schema spec.JSON模式规范草案4中的超文本定义。

• The keywords:关键词：

  • $ref
  • $schema
  • default
  • definitions
  • format
  • id
• The integer type. integer类型。You must use the BSON type int or long with the bsonType keyword.必须将BSON类型int或long与bsonType关键字一起使用。
• Hypermedia and linking properties of JSON Schema, including the use of JSON References and JSON Pointers.JSON模式的超媒体和链接属性，包括JSON引用和JSON游标的使用。
• Unknown keywords.未知关键字。