Como usar o operador $ jsonschema em mongodb

MongoDB é um banco de dados NoSQL para gerenciar dados em larga escala. O recurso mais saliente que permitiu que o MongoDB ganhasse alturas é o suporte de esquema flexível em comparação com o tipo SQL de bancos de dados. Ele fornece suporte para um operador de esquema JSON nomeado como $ jsonschema que ajuda a validar os documentos JSON. O operador $ jsonschema em MongoDB ajuda a executar várias operações como inserção, exclusão seguindo o esquema JSON especificado.

Neste artigo, forneceremos uma visão para usar o operador $ jsonschema em MongoDB e o processo para fazer o documento baseado em esquema JSON também é fornecido. Vamos começar este guia entendendo o esquema JSON, seguido de seu trabalho e uso em MongoDB.

O que é JSON Schema

É um documento JSON que ajuda a definir a estrutura de uma mensagem JSON e pode ser usado para validar os documentos JSON. Também pode ser usado para validar as solicitações da API para verificar o formato, tipos de dados de solicitações de API também. Geralmente, o esquema JSON é criado antes de qualquer mensagem JSON e deve ser seguido para outras ações suportadas. No entanto, também pode ser praticado após documentos JSON. Se algum documento JSON ou solicitação de API não seguir o esquema JSON especificado, você não poderá obter a saída necessária.

Como usar o operador $ jsonschema em mongodb

A sintaxe para usar $ jsonschema em MongoDB é fornecida abaixo:

$ jsonschema:

No nosso caso, usamos o “clientes"Coleção em uma"Linuxhint" base de dados:

Exemplo 1: Usando $ jsonschema para definir um esquema para operação de inserção

Em primeiro lugar, você deve especificar o $ jsonschema Durante a criação da coleção em MongoDB: para isso, você deve seguir a sintaxe mencionada abaixo:

Sintaxe: (para definir regras de validação para uma coleção em MongoDB)

dB.CreateCollection (, Validator: $ jsonschema:)

Na sintaxe acima,

: Refere -se ao nome que você definirá para nova coleção

““validador”: É uma palavra -chave predefinida iniciar a validação

: Contém as regras; Por exemplo, os tipos BSON podem ser definidos para cada campo.

Após a sintaxe, criamos um “clientes”Coleção e $ jsonschema O operador é usado para definir regras de validação de esquema nele:

dB.createCollection ("clientes",
validador:
$ jsonschema:
BSONTYPE: "Objeto",
Necessário: ["Nome", "Ano", "Cat"],
Propriedades:
nome:
BSONTYPE: "String",
Descrição: "O nome deve ser um valor de string"
,
ano:
BSONTYPE: "INT",
Descrição: "Deve ser um número inteiro como 2021)"
,
gato:
BSONTYPE: "String",
"Descrição": "um valor de string"




)

Agora o seguinte comando é usado aqui para inserir os campos especificados no “clientes" coleção. O comando satisfaz as regras de validação do esquema JSON:

> dB.clientes.inserir(
Nome: "Alen",
Ano: Número (2021),
Gato: "Autor"
)

Por exemplo, se as regras não forem seguidas; O comando abaixo mencionado tenta inserir um Inteiro valor em “gato“Campo: como o“gato”O campo só pode aceitar o“cordaOs valores, então, a consulta Mongo mencionada abaixo dará um erro:

> dB.clientes.inserir(
Nome: "Alen",
Ano: Número (2021),
Cat: Número (123)
)

Exemplo 2: Usando o operador $ jsonschema na leitura de documentos do MongoDBB

Com a ajuda de $ jsonschema, você pode encontrar documentos inseridos que seguem o esquema JSON definido na consulta: você deve definir o esquema JSON em seu “encontrar()”Método de consulta:

Neste exemplo, “minha coleção”É usado e os documentos seguintes residem dentro dele:

> dB.minha coleção.encontrar().bonito()

Criamos o seguinte objeto de esquema com o nome de “Linuxhintschema“:

Deixe Linuxhintschema =
Necessário: ["Nome", "Salário", "Designação"],
Propriedades:
Nome: BSONTYPE: "String",
Salário: BSONTYPE: "Double",
Designação: BSONTYPE: "String"

Agora, para encontrar os documentos que seguem as regras Linuxhintschema; Você pode usar o comando abaixo mencionado para fazer isso:

> dB.minha coleção.encontre ($ jsonschema: linuxhintschema).bonito()

Usando $ nem com $ jsonschema Operator: Além disso, você pode usar $nem Operador com o operador de $ jsonschema para encontrar os documentos que não satisfazem o esquema especificado:

> dB.minha coleção.encontre ($ Nor: [$ jsonschema: linuxhintschema]).bonito()

Usando o operador $ jsonschema com $ nem operador e método de exclusão: Usando “$ jsonschema" com "$ nem" e "Excluir”Método, você pode excluir os documentos que não satisfazem o esquema JSON (Linuxhintschema) usando o comando declarado abaixo:

> dB.minha coleção.DeLeTemany ($ Nor: [$ jsonschema: linuxhintschema])

Conclusão

Os sistemas de gerenciamento de banco de dados estão focados para manipular os dados de uma organização de maneira eficaz. O operador $ jsonschema é usado para corresponder aos documentos que seguem as regras do esquema JSON; Essas regras são definidas pelos usuários. Além de recuperar, o operador $ jsonschema pode ser usado para definir o conjunto de regras para operação de inserção no MongoDBB. Qualquer consulta de inserção que satisfaça o esquema JSON terá permissão para colocar dados na coleção relevante.