MongoDB

MongoDB ist die führende Open-Source, Document Datenbank die für einfache Entwicklung und Skalierung aber auch für Big Data Szenarien entwickelt wurde.

JSON Schema Validierung - Überprüfen von Arrays

Marc-David Militz
Experte
  • Artikel von Ken W. Alger

    • englischer Originalartikel
      https://www.mongodb.com/blog/post/json-schema-validation--checking-your-arrays
      Übersetzung mit freundlicher Genehmigung von MongoDB


      Mit dem Thema JSON Schema Validierung haben wir uns ja schon in einem früheren Beitrag beschäftigt.
      https://www.qualiero.com/community/mongodb/mongodb-theorie/json-schema-validierung-ein-datenmodell-auf-clevere-art-festlegen.html
      Diesmal gehen wir über die einfache Validierung hinaus und kümmern uns um die erweiterten Möglichkeiten und Validierungstechniken für Arrays, die uns das Dokument Model von MongoDB bietet.

      • Überprüfe deine Arrays

        • Beim letzten Mal haben wir uns darum gekümmert, dass unsere Arrays die richtige Struktur haben. Diesmal beschäftigen wir uns mit den Daten im Array. Ein Array enthält eine Auswahl von Elementen. Manchmal, oder eigentlich ziemlich regelmäßig, sind diese alle unterschiedlich, aber manchmal können sie auch Duplikate enthalten. Wenn wir nun sichergehen wollen, dass sie alle unterschiedlich sind, dann müssen wir festlegen, dass die Elemente in dem Array unique sein müssen.

          Stell die einfach mal vor, dass deine kulinarischen Entdeckungsreisen dich zu einer Firma für Lebensmittelfarben führen. Das Produkt, das die Firma vertreibt, sind Farbsets mit einer Auswahl an Lebensmittelfarben. Möglicherweise wäre es eine gute Idee, wenn jede der Boxen, die verkauft werden, lauter unterschiedliche Farben enthält. Die Kunden wären möglicherweise enttäuscht, wenn sie eine Box bekommen die nur blaue Farben enthält. Wir können mit dem "uniqueItems" Schlüsselwort, die Eindeutigkeit in unserem Schema Validator sicherstellen.

          db.foodColor.drop()
          db.createCollection ( "foodColor",
          {
          validator:
          {
          $jsonSchema:
          {
          bsonType: "object",
          required: ["name", "box_size", "dyes"],
          properties:
          {
          _id: {},
          name: {
          bsonType: ["string"],
          description: "'name' is a required string"
          },
          box_size: {
          enum: [3, 4, 6],
          description: "'box_size' must be one of the values listed and is required"
          },
          dyes: {
          bsonType: ["array"],
          minItems: 1, // each box of food color must have at least one color
          uniqueItems: true,
          additionalProperties: false,
          items: {
          bsonType: ["object"],
          required: ["size", "color"],
          additionalProperties: false,
          description: "'items' must contain the stated fields.",
          properties: {
          size: {
          enum: ["small", "medium", "large"],
          description: "'size' is required and can only be one of the given enum values"
          },
          color: {
          bsonType: "string",
          description: "'color' is a required field of type string"
          }
          }
          }
          }
          }
          }
          }
          })


          Unser Paket mit den Lebensmittelfarben, wie wir es oben festgelegt haben, muss eindeutige Tuben mit Farbe enthalten. Die Eindeutigkeit wird über die Kombination aus Größe und Farbe ermittelt.

          • Dokument 1

            • Natürlich können wir eine Box mit drei verschiedenen Größen von unterschiedlichen Farben haben.
              db.foodColor.insertOne({name: "Rainbow RGB", box_size: 3,
              dyes: [
              {size: "small", color: "red"},
              {size: "medium", color: "green"},
              {size: "large", color: "blue"}]}) // works


              • Dokument 2

                • Wir können außerdem ein Paket mit drei verschiedenen Größen der gleichen Farbe haben. Aber die Kombination von Farbe und Packungsgröße muss eindeutig sein. Das bedeutet, dass folgendes Dokument
                  db.foodColor.insertOne({name: "Singinꞌ the Blues", box_size: 3,
                  dyes: [
                  {size: "small", color: "blue"},
                  {size: "medium", color: "blue"},
                  {size: "large", color: "blue"}]}) // works

                  valide ist, weil jede Farbe/Größe Kombination nur einmal vorkommt.

                  • Dokument 3

                    • Füllen wir unsere Box doch mal mit roten Farben in unterschiedlichen Größen.
                      db.foodColor.insertOne({name: "Reds", box_size: 6,
                      dyes: [
                      {size: "small", color: "red"},
                      {size: "medium", color: "red"},
                      {size: "large", color: "red"},
                      {size: "small", color: "scarlet"},
                      {size: "small", color: "brick red"},
                      {size: "small", color: "red"}
                      ]}) // doesn't work, there are two small red dyes in this box

                      Da hier zwei "kleine" "rote" Elemente enthalten sind, schlägt das Einfügen fehl.

                      • Dokument 4

                        • Was, wenn jemand auf die Idee kommt eine "Special Edition" von Farben mit einem Aroma oder Geschmack zu machen, um die Boxen etwas interessanter zu gestalten? Auch hier hilft uns das Validierungsschema.
                          db.foodColor.insertOne({name: "Specials", box_size: 3,
                          dyes: [
                          {size: "small", color: "red", aroma:"malty"},
                          {size: "medium", color: "red", aroma:"fruity"},
                          {size: "large", color: "red",taste:"salty"},
                          ]}) // doesn't work, there are extra properties

                          Das schlägt fehl, weil in unserem Schema nur Größe und Farbe definiert sind. Die zusätzlichen Attribute sind für die Validierung nicht relevant. Die Möglichkeit ein Schema auch anhand der Inhalte zu validieren ist ein mächtiges Werkzeug. Es ermöglicht uns unser abstraktes Validierungsschema, um spezifische Elemente zu erweitern.

                          • Zusammenfassung

                            • JSON Schema Validierung kann eine Applikation stark verbessern und dem System eine gewisse Sicherheit hinzufügen. In diesem speziellen Fall haben wir die Validierung benutzt, um sicherzugehen, dass keinerlei Duplikate in einem eingebetteten Array, innerhalb eines Dokumentes enthalten sind. Einfach nur indem wir ein entsprechendes Schema definiert haben, aber ohne dafür zusätzlichen Code zu schreiben. Wir haben uns damit außerdem vor unautorisierten Erweiterungen in der Spezifikation dieses Arrays geschützt. Für das Beispiel, unserer Boxen mit den Lebensmittelfarben, kann das Schema das Sortenproblem nicht lösen, aber es kann einige der schlimmsten Fehler auf Datenbankebene verhindern.

Neueste Mitgliederaktivitäten

Tags

Diesen Community Beitrag weiterempfehlen