Comment utiliser un opérateur de Jsonschema à MongoDB

MongoDB est un type de base de données NOSQL pour gérer les données à grande échelle. La fonction la plus saillante qui a permis à MongoDB de gagner des hauteurs est le support de schéma flexible par rapport au type de base de données de type SQL. Il prend en charge un opérateur de schéma JSON nommé $ jsonschema qui aide à valider les documents JSON. L'opérateur $ jsonschema de MongoDB aide à effectuer plusieurs opérations comme l'insertion, la suppression en suivant le schéma JSON spécifié.

Dans cet article, nous fournirons un aperçu pour utiliser l'opérateur $ jsonschema à MongoDB et le processus pour faire en sorte que le document basé sur le schéma JSON soit également fourni. Commençons ce guide en comprenant le schéma JSON suivi de son travail et de son utilisation dans MongoDB.

Qu'est-ce que le schéma JSON

Il s'agit d'un document JSON qui aide à définir la structure d'un message JSON et peut être utilisé pour valider les documents JSON. Il peut également être utilisé pour valider les demandes d'API pour vérifier le format, les données des demandes d'API également. Habituellement, le schéma JSON est créé avant tout message JSON et il doit être suivi pour toutes les autres actions soutenues. Cependant, il peut également être pratiqué après les documents JSON. Si un document JSON ou une demande API ne suit pas le schéma JSON spécifié, vous ne pourrez pas obtenir la sortie requise.

Comment utiliser un opérateur de Jsonschema à MongoDB

La syntaxe pour utiliser $ jsonschema dans MongoDB est fournie ci-dessous:

$ jsonschema:

Dans notre cas, nous avons utilisé le «clients«Collection dans un«linuxhint" base de données:

Exemple 1: Utilisation de $ jsonschema pour définir un schéma d'opération d'insertion

Premièrement, vous devez spécifier le $ jsonschema Pendant la création de la collection dans MongoDB: pour cela, vous devez suivre la syntaxe mentionnée ci-dessous:

Syntaxe: (Pour définir des règles de validation pour une collection à MongoDB)

db.createCollection (, validator: $ jsonschema:)

Dans la syntaxe ci-dessus,

: Fait référence au nom que vous allez pour une nouvelle collection

"validateur»: Il s'agit d'un mot-clé prédéfini pour initier la validation

: Contient les règles; Par exemple, les types BSON peuvent être définis pour chaque champ.

Après la syntaxe, nous avons créé un «clients»Collection et $ jsonschema L'opérateur est utilisé pour définir des règles de validation du schéma:

db.CreateCollection ("Clients",
Validator:
$ jsonschema:
BSATYPE: "Objet",
requis: ["nom", "année", "chat"],
propriétés:
nom:
bsaponype: "string",
Description: "Le nom doit être une valeur de chaîne"
,
année:
BSOMATYPE: "INT",
Description: "doit être un entier comme 2021)"
,
chat:
bsaponype: "string",
"Description": "une valeur de chaîne"




)

Maintenant, la commande suivante est utilisée ici pour insérer les champs spécifiés dans le «clients" collection. La commande satisfait les règles de validation du schéma JSON:

> db.clients.insérer(
Nom: "Alen",
Année: NumberInt (2021),
Cat: "Auteur"
)

Par exemple, si les règles ne sont pas suivies; La commande mentionnée ci-dessous essaie d'insérer un entier valeur dans "chat”Field: comme le«chat«Field ne peut qu'accepter le«chaîne»Les valeurs, donc, la requête Mongo mentionnée ci-dessous donnera une erreur:

> db.clients.insérer(
Nom: "Alen",
Année: NumberInt (2021),
Cat: NumberInt (123)
)

Exemple 2: Utilisation de l'opérateur $ jsonschema dans la lecture des documents MongoDB

Avec l'aide de $ jsonschema, vous pouvez trouver des documents insérés qui suit le schéma JSON défini dans Query: vous devez définir le schéma JSON dans votre "trouver()«Méthode de requête:

Dans cet exemple, «ma collection«Est utilisé et les documents suivants résident à l'intérieur:

> db.ma collection.trouver().joli()

Nous avons créé un objet de schéma suivant avec le nom de «linuxhintschema«:

Soit LinuxHintschema =
requis: ["nom", "salaire", "désignation"],
propriétés:
Nom: bsaponype: "String",
Salaire: bsaponype: "double",
Désignation: bsaponype: "String"

Maintenant, pour trouver les documents qui suit les règles LinuxHintschema; Vous pouvez utiliser la commande mentionnée ci-dessous pour le faire:

> db.ma collection.trouver ($ jsonschema: LinuxhintSchema).joli()

Utilisation de $ NOR avec $ JSonschema Operator: De plus, vous pouvez utiliser $ni Opérateur avec $ JSonschema Opérateur pour trouver les documents qui ne satisfont pas le schéma spécifié:

> db.ma collection.find ($ nor: [$ jsonschema: linuxhintschema]).joli()

Utilisation de l'opérateur $ jsonschema avec $ Nor Operator et de la méthode de suppression: En utilisant "$ jsonschema" avec "$ ni" et "Supprimer«Méthode, vous pouvez supprimer les documents qui ne satisfont pas le schéma JSON (linuxhintschema) en utilisant la commande indiquée ci-dessous:

> db.ma collection.DeleteMany ($ nor: [$ jsonschema: linuxhintschema])

Conclusion

Les systèmes de gestion de la base de données sont axés pour manipuler efficacement les données d'une organisation. L'opérateur $ JSonschema est utilisé pour correspondre aux documents qui suivent les règles de schéma JSON; Ces règles sont définies par les utilisateurs. En plus de récupérer, l'opérateur $ jsonschema peut être utilisé pour définir l'ensemble des règles pour le fonctionnement de l'insertion à MongoDB. Toute requête d'insertion qui satisfait le schéma JSON sera autorisé à placer des données dans la collection pertinente.