Verwenden der JSON-Schemavalidierung - Amazon DocumentDB
JSON-Schemavalidierung erstellen und verwendenUnterstützte SchlüsselwörterbypassDocumentValidationEinschränkungen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Verwenden der JSON-Schemavalidierung

Mithilfe des $jsonSchema Testabfrageoperators können Sie überprüfen, ob Dokumente in Ihre Sammlungen eingefügt werden.

JSON-Schemavalidierung erstellen und verwenden

Eine Sammlung mit Schemavalidierung erstellen

Sie können eine Sammlung mit createCollection Betriebs- und Validierungsregeln erstellen. Diese Validierungsregeln werden beim Einfügen oder Aktualisieren von Amazon DocumentDB DocumentDB-Dokumenten angewendet. Das folgende Codebeispiel zeigt Validierungsregeln für eine Sammlung von Mitarbeitern:

db.createCollection("employees", {
   "validator": {
      "$jsonSchema": {
         "bsonType": "object",
         "title": "employee validation",
         "required": [ "name", "employeeId"],
         "properties": {
            "name": {
                  "bsonType": "object",
                  "properties": {
                     "firstName": {
                        "bsonType": ["string"]
                     },
                     "lastName": {
                        "bsonType": ["string"]
                     }
                  },
                  "additionalProperties" : false 
            },
            "employeeId": {
               "bsonType": "string",
               "description": "Unique Identifier for employee"
            },
             "salary": {
               "bsonType": "double"
            },
            "age": {
               "bsonType": "number"
            }
         },
         "additionalProperties" : true 
      }
   },
   "validationLevel": "strict", "validationAction": "error"
} )

Ein gültiges Dokument einfügen

Im folgenden Beispiel werden Dokumente eingefügt, die den oben genannten Schemavalidierungsregeln entsprechen:

db.employees.insert({"name" : { "firstName" : "Carol" , "lastName" : "Smith"}, "employeeId": "c720a" , "salary": 1000.0 })
db.employees.insert({ "name" : { "firstName" : "William", "lastName" : "Taylor" }, "employeeId" : "c721a", "age" : 24})

Ein ungültiges Dokument wird eingefügt

Im folgenden Beispiel werden Dokumente eingefügt, die den obigen Schemavalidierungsregeln nicht entsprechen. In diesem Beispiel ist der EmployeeID-Wert keine Zeichenfolge:

db.employees.insert({
    "name" : { "firstName" : "Carol" , "lastName" : "Smith"}, 
    "employeeId": 720 , 
    "salary": 1000.0 
})

Dieses Beispiel zeigt eine falsche Syntax innerhalb des Dokuments.

Eine Sammlung ändern

Der collMod Befehl wird verwendet, um Validierungsregeln einer vorhandenen Sammlung hinzuzufügen oder zu ändern. Im folgenden Beispiel wird der Liste der erforderlichen Felder ein Gehaltsfeld hinzugefügt:

db.runCommand({"collMod" : "employees", 
   "validator": {
      "$jsonSchema": {
         "bsonType": "object",
         "title": "employee validation",
         "required": [ "name", "employeeId", "salary"],
         "properties": {
            "name": {
                  "bsonType": "object",
                  "properties": {
                     "firstName": {
                        "bsonType": ["string"]
                     },
                     "lastName": {
                        "bsonType": ["string"]
                     }
                  },
                  "additionalProperties" : false 
            },
            "employeeId": {
               "bsonType": "string",
               "description": "Unique Identifier for employee"
            },
             "salary": {
               "bsonType": "double"
            },
            "age": {
               "bsonType": "number"
            }
         },
         "additionalProperties" : true 
      }
   }
} )

Adressierung von Dokumenten, die vor der Änderung der Validierungsregeln hinzugefügt wurden

Verwenden Sie die folgenden validationLevel Modifikatoren, um Dokumente zu adressieren, die Ihrer Sammlung hinzugefügt wurden, bevor die Validierungsregeln geändert wurden:

  • Strikt: Wendet Validierungsregeln auf alle Einfügungen und Aktualisierungen an.

  • moderat: Wendet Validierungsregeln auf bestehende gültige Dokumente an. Bei Aktualisierungen werden vorhandene ungültige Dokumente nicht überprüft.

Im folgenden Beispiel ist nach der Aktualisierung der Validierungsregeln für die Sammlung mit dem Namen „Mitarbeiter“ das Feld Gehalt erforderlich. Die Aktualisierung des folgenden Dokuments schlägt fehl:

db.runCommand({ 
    update: "employees", 
    updates: [{ 
        q: { "employeeId": "c721a" }, 
        u: { age: 25 , salary : 1000}, 
        upsert: true }] 
})

Amazon DocumentDB gibt die folgende Ausgabe zurück:

{
"n" : 0,
    "nModified" : 0,
    "writeErrors" : [
        {
"index" : 0,
            "code" : 121,
            "errmsg" : "Document failed validation"
        }
    ],
    "ok" : 1,
    "operationTime" : Timestamp(1234567890, 1)
}

Wenn Sie die Validierungsstufe moderate auf aktualisieren, kann das obige Dokument erfolgreich aktualisiert werden:

db.runCommand({
    "collMod" : "employees", 
    validationLevel : "moderate"
})

db.runCommand({ 
    update: "employees", 
    updates: [{ 
        q: { "employeeId": "c721a" }, 
        u: { age: 25 , salary : 1000}, 
        upsert: true }]
})

Amazon DocumentDB gibt die folgende Ausgabe zurück:

{
"n" : 1,
    "nModified" : 1,
    "ok" : 1,
    "operationTime" : Timestamp(1234567890, 1)
}

Dokumente werden mit dem $JsonSchema abgerufen

Der $jsonSchema Operator kann als Filter verwendet werden, um Dokumente abzufragen, die dem JSON-Schema entsprechen. Dies ist ein Operator der obersten Ebene, der in Filterdokumenten als Feld der obersten Ebene vorhanden sein oder mit Abfrageoperatoren wie $and$or, und $nor verwendet werden kann. Die folgenden Beispiele zeigen die Verwendung von $jsonSchema als Einzelfilter und mit anderen Filteroperatoren:

Dokument, das in eine Sammlung „Mitarbeiter“ eingefügt wurde:

{ "name" : { "firstName" : "Carol", "lastName" : "Smith" }, "employeeId" : "c720a", "salary" : 1000 }
{ "name" : { "firstName" : "Emily", "lastName" : "Brown" }, "employeeId" : "c720b", "age" : 25, "salary" : 1050.2 }
{ "name" : { "firstName" : "William", "lastName" : "Taylor" }, "employeeId" : "c721a", "age" : 24, "salary" : 1400.5 }
{ "name" : { "firstName" : "Jane", "lastName" : "Doe" }, "employeeId" : "c721a", "salary" : 1300 }

Sammlung wurde nur mit dem $jsonSchema Operator gefiltert:

db.employees.find({ 
       $jsonSchema: { required: ["age"] } })

Amazon DocumentDB gibt die folgende Ausgabe zurück:

{ "_id" : ObjectId("64e5f91c6218c620cf0e8f8b"), "name" : { "firstName" : "Emily", "lastName" : "Brown" }, "employeeId" : "c720b", "age" : 25, "salary" : 1050.2 }
{ "_id" : ObjectId("64e5f94e6218c620cf0e8f8c"), "name" : { "firstName" : "William", "lastName" : "Taylor" }, "employeeId" : "c721a", "age" : 24, "salary" : 1400.5 }

Sammlung, die mit dem $jsonSchema Operator und einem anderen Operator gefiltert wurde:

db.employees.find({ 
       $or: [{ $jsonSchema: { required: ["age", "name"]}}, 
            { salary: { $lte:1000}}]});

Amazon DocumentDB gibt die folgende Ausgabe zurück:

{ "_id" : ObjectId("64e5f8886218c620cf0e8f8a"), "name" : { "firstName" : "Carol", "lastName" : "Smith" }, "employeeId" : "c720a", "salary" : 1000 }
{ "_id" : ObjectId("64e5f91c6218c620cf0e8f8b"), "name" : { "firstName" : "Emily", "lastName" : "Brown" }, "employeeId" : "c720b", "age" : 25, "salary" : 1050.2 }
{ "_id" : ObjectId("64e5f94e6218c620cf0e8f8c"), "name" : { "firstName" : "William", "lastName" : "Taylor" }, "employeeId" : "c721a", "age" : 24, "salary" : 1400.5 }

Sammlung, die mit dem $jsonSchema Operator und mit dem Aggregatfilter $match gefiltert wurde:

db.employees.aggregate(
    [{ $match: { 
        $jsonSchema: { 
            required: ["name", "employeeId"],  
            properties: {"salary" :{"bsonType": "double"}}
        }
       }
    }]
)

Amazon DocumentDB gibt die folgende Ausgabe zurück:

{ 
"_id" : ObjectId("64e5f8886218c620cf0e8f8a"),
 "name" : { "firstName" : "Carol", "lastName" : "Smith" },
"employeeId" : "c720a",
"salary" : 1000 
}
{
"_id" : ObjectId("64e5f91c6218c620cf0e8f8b"),
"name" : { "firstName" : "Emily", "lastName" : "Brown" },
"employeeId" : "c720b",
"age" : 25,
"salary" : 1050.2
}
{
"_id" : ObjectId("64e5f94e6218c620cf0e8f8c"),
"name" : { "firstName" : "William", "lastName" : "Taylor" },
"employeeId" : "c721a",
"age" : 24,
"salary" : 1400.5
}
{
"_id" : ObjectId("64e5f9786218c620cf0e8f8d"),
"name" : { "firstName" : "Jane", "lastName" : "Doe" },
"employeeId" : "c721a",
"salary" : 1300
}

Bestehende Validierungsregeln anzeigen

Um die vorhandenen Validierungsregeln für eine Sammlung zu sehen, verwenden Sie:

db.runCommand({
    listCollections: 1, 
    filter: { name: 'employees' }
})

Amazon DocumentDB gibt die folgende Ausgabe zurück:

{
    "waitedMS" : NumberLong(0),
    "cursor" : {
        "firstBatch" : [
            {
                "name" : "employees",
                "type" : "collection",
                "options" : {
                    "autoIndexId" : true,
                    "capped" : false,
                    "validator" : {
                        "$jsonSchema" : {
                            "bsonType" : "object",
                            "title" : "employee validation",
                            "required" : [
                                "name",
                                "employeeId",
                                "salary"
                            ],
                            "properties" : {
                                "name" : {
                                    "bsonType" : "object",
                                    "properties" : {
                                        "firstName" : {
                                            "bsonType" : [
                                                "string"
                                            ]
                                        },
                                        "lastName" : {
                                            "bsonType" : [
                                                "string"
                                            ]
                                        }
                                    },
                                    "additionalProperties" : false
                                },
                                "employeeId" : {
                                    "bsonType" : "string",
                                    "description" : "Unique Identifier for employee"
                                },
                                "salary" : {
                                    "bsonType" : "double"
                                },
                                "age" : {
                                    "bsonType" : "number"
                                }
                            },
                            "additionalProperties" : true
                        }
                    },
                    "validationLevel" : "moderate",
                    "validationAction" : "error"
                },
                "info" : {
                    "readOnly" : false
                },
                "idIndex" : {
                    "v" : 2,
                    "key" : {
                        "_id" : 1
                    },
                    "name" : "_id_",
                    "ns" : "test.employees"
                }
            }
        ],
        "id" : NumberLong(0),
        "ns" : "test.$cmd.listCollections"
    },
    "ok" : 1,
    "operationTime" : Timestamp(1692788937, 1)
}

Amazon DocumentDB behält auch die Validierungsregeln in der $out Aggregationsphase bei.

Unterstützte Schlüsselwörter

Die folgenden Felder werden in den collMod Befehlen create und unterstützt:

  • Validator— Unterstützt den $jsonSchem Operator a.

  • ValidationLevel— Unterstützt moderate Werte offstrict, und.

  • ValidationAction— Unterstützt den error Wert.

Der $jsonSchema-Operator unterstützt die folgenden Schlüsselwörter:

  • additionalItems

  • additionalProperties

  • allOf

  • anyOf

  • bsonType

  • dependencies

  • description

  • enum

  • exclusiveMaximum

  • exclusiveMinimum

  • items

  • maximum

  • minimum

  • maxItems

  • minItems

  • maxLength

  • minLength

  • maxProperties

  • minProperties

  • multipleOf

  • not

  • oneOf

  • pattern

  • patternProperties

  • properties

  • required

  • title

  • type

  • uniqueItems

bypassDocumentValidation

Amazon DocumentDB unterstützt bypassDocumentValidation die folgenden Befehle und Methoden:

  • insert

  • update

  • findAndModify

  • $outStufe im aggregate Befehl und in der Methode db.collection.aggregate()

Amazon DocumentDB unterstützt die folgenden Befehle nicht fürbypassDocumentValidation:

  • $mergeim aggregate Befehl und in der Methode db.collection.aggregate()

  • mapReduceBefehl und db.collection.mapReduce() Methode

  • applyOps command

Einschränkungen

Für die $jsonSchema Validierung gelten die folgenden Einschränkungen:

  • Amazon DocumentDB gibt den Fehler „Dokument konnte nicht validiert werden“ zurück, wenn ein Vorgang die Validierungsregel nicht erfüllt.

  • Elastische Amazon DocumentDB-Cluster werden nicht unterstützt$jsonSchema.