Range MongoDB $

Range MongoDB $
O operador do Range MongoDB $ é um operador personalizado que gera uma variedade de números com base em um determinado valor de início, valor final e valor da etapa. Este operador é uma ferramenta útil para gerar sequências de números para uso em manipulação de dados ou análise. É normalmente usado como um componente do operador de projeto $ em um pipeline agregado, para criar um novo campo nos documentos de saída que contêm uma matriz de números. É preciso um total de três argumentos: o valor inicial, o nome do campo no qual o campo de intervalo será aplicado e o número de incremento para aumentar o valor até atingir o último ponto de um valor de campo. Este guia vai explicar e demonstrar o uso do operador "range" do MongoDB com a ajuda de alguns exemplos.

Exemplo # 01:

Verifique se o seu banco de dados MongoDB já está configurado em sua máquina. Caso contrário, tente instalá -lo junto com a criação de uma coleção. A coleção deve ter registros. Configuramos nosso banco de dados MongoDB, criando uma coleção chamada "Dummy" e adicionamos alguns documentos a ele. É hora de usar o operador de alcance em uma coleção fictícia. Antes disso, estaremos exibindo os documentos que temos em nossa coleção fictícia. A instrução mostrada abaixo é executada no shell do MongoDB para esse fim. O comando está usando o método "find ()" para pesquisar todos os documentos em uma coleção chamada "Dummy" com os aparelhos encaracolados vazios "". Nenhum critério de pesquisa específico está sendo usado; portanto, todos os registros da coleção "manequim" serão exibidos.

A saída do comando é uma variedade de documentos, cada registro contendo vários campos. Os campos incluem um objeto único “_id” de cada registro, o campo da cidade representa o nome de uma cidade, o campo de contagem representa um campo numérico, o campo DESC representa uma corda descrevendo a cidade e o campo aleatório está representando um valor numérico aleatório.

Teste> dB.Fictício.encontrar()
[_id: objectId ("63C8A1F94FF07039AA6CDF6B"), Cidade: 'Texas', Conde: 3, Desc: 'Cidade de médio porte', aleatória: 81,
_id: objectId ("63C8A1F94FF07039AA6CDF6C"), Cidade: 'Los Angeles', Conde: 3, Desc: 'Cidade de médio porte', aleatória: 5,
_id: objectId ("63C8A1F94FF07039AA6CDF6D"), Cidade: 'Itália', Conde: 10, Desc: 'mais bonita e lotada', aleatória: 12,
_id: objectId ("63C8A1F94FF07039AA6CDF6E"), Cidade: 'Istambul', Conde: 3, Desc: 'Cidade de médio porte', aleatória: 95,
_id: objectId ("63C8A1F94FF07039AA6CDF6F"), Cidade: 'Delhi', Conde: 3, Desc: 'Cidade de médio porte', aleatória: 22]

É hora de aplicar o campo "Range" em todos os registros de uma coleção "Dummy" MongoDB para obter a gama de números. O comando para a aplicação do operador de intervalo foi anexado abaixo. Ele está usando o método "agregate ()" para executar uma operação agregada em uma coleção chamada "manequim". O operador "$ projeto" é usado para remodelar os documentos em uma coleção, incluindo ou excluindo campos e também pode criar novos campos. Nesse caso, o operador "$ Project" está sendo usado para criar um novo campo chamado "REST", que é uma matriz contendo uma variedade de números de 0 ao valor do campo "aleatório" em cada documento, incrementando em 10. A saída do comando mostra uma variedade de registros, o campo de restos representa uma nova matriz contendo uma variedade de números com base no valor do campo "aleatório" e no campo "Cidade" com o nome de uma cidade específica. O ponto de restante pode ser adivinhado a partir da faixa fornecida no campo de matriz "Rest".

Teste> dB.Fictício.agregado ([$ Project: City: 1, "Rest": $ range: [0, "$ Random", 10]])
[_id: objectId ("63C8A1F94FF07039AA6CDF6B"), Cidade: 'Texas', descanso: [0, 10, 20, 30, 40, 50, 50, 60, 70, 80],
_id: objectId ("63C8A1F94FF07039AA6CDF6C"), Cidade: 'Los Angeles', descanso: [0],
_id: objectId ("63C8A1F94FF07039AA6CDF6D"), Cidade: 'Itália', descanso: [0, 10],
_id: objectId ("63C8A1F94FF07039AA6CDF6E"), Cidade: 'Istambul', descanso: [0, 10, 20, 30, 40, 40, 50, 60, 70, 80, 90],
_id: objectId ("63C8A1F94FF07039AA6CDF6F"), cidade: 'Delhi', descanso: [0, 10, 20]]

Exemplo # 02:

Vamos dar uma olhada em outro exemplo para usar o campo Range na coleção MongoDBB. A coleção "teste" foi utilizada neste exemplo até agora. A instrução “Find” anexada abaixo foi exibir o conteúdo desta coleção. A saída do comando contém o identificador exclusivo atribuído a cada documento por MongoDB, o campo “S” representa o número do ponto de partida e o campo “E” representa o número do ponto final.

Teste> dB.Teste.encontrar()
[_id: objectId ("63cb65f0bef5adfc81df628e"), s: 2, e: 8,
_id: objectId ("63cb65f0bef5adfc81df628f"), s: 1, e: 5,
_id: objectId ("63cb65f0bef5adfc81df6290"), s: 4, e: 9]

A saída mostra que a matriz é criada usando o operador $ range, que leva dois argumentos: o valor inicial e o valor final. O valor inicial é o campo "S" e o valor final é o campo "E" no documento. A saída final deste comando é uma lista de documentos, cada um com um campo "S", um campo "E" e um campo "R" que contém uma matriz de números inteiros. Os números inteiros no campo "R" são o intervalo de números entre os campos "S" e "E" para cada documento: cada um com um incremento de 1. Isso ocorre porque não atribuímos um valor de incremento para o operador de intervalo. Então, o operador "Range" tomou "1" como o valor de incremento por si só.

Teste> dB.Teste.agregado ([$ Project: s: 1, e: 1, "r": $ range: ["$ s", "$ e"]])
[_id: objectId ("63cb65f0bef5adfc81df628e"), s: 2, e: 8, r: [2, 3, 4, 5, 6, 7],
_id: objectId ("63cb65f0bef5adfc81df628f"), s: 1, e: 5, r: [1, 2, 3, 4],
_id: objectId ("63cb65f0bef5adfc81df6290"), s: 4, e: 9, r: [4, 5, 6, 7, 8]]

Exemplo # 03:

Em todas as ilustrações acima, aplicamos apenas o operador de alcance nos campos de coleções com valores do tipo inteiro. Receberemos um erro quando aplicarmos o operador de intervalo no valor do tipo de string. E se aplicá-lo aos valores de campo do tipo decimal? Vamos verificar se aplicando -o a uma nova coleção chamada "Float" em nosso banco de dados MongoDB. A função find () aplicada à coleção "float" mostra os 5 conjuntos de documentos. Cada documento contém seu identificador exclusivo, campo do tipo String "Title" e o "campo do tipo Float" Age "contendo valores de ponto decimal.

Teste> dB.Flutuador.encontrar()
[_id: objectId ("63cb5f26bef5adfc81df6289"), título: 'nina', idade: 45.6,
_id: objectId ("63cb5f26bef5adfc81df628a"), título: 'ana', idade: 22.75,
_id: objectId ("63cb5f26bef5adfc81df628b"), título: 'eden', idade: 35.9,
_id: objectId ("63cb5f26bef5adfc81df628c"), título: 'rock', idade: 82.5,
_id: objectId ("63CB5F26BEF5ADFC81DF628D"), Título: 'Lia', idade: 27]

Agora, aplicamos o operador "range" na coleção Float usando a função agregada para obter o intervalo de números com um incremento de 11 para o campo "Idade". Esse código, no entanto, gera um erro porque o operador de gama $ exige que o valor final seja um número inteiro de 32 bits, mas o valor do campo "idade" é um número de ponto flutuante e não pode ser convertido em 32- um pouco inteiro. Isso mostra que não podemos aplicar o operador de intervalo em nenhum outro tipo de dados, exceto o tipo de dados inteiro no banco de dados MongoDB.

Teste> dB.Flutuador.agregado ([$ Project: title: 1, "Rest": $ range: [0, "$ AGE", 11]])

MongoserVerRor: Erro do PlaneXecutor durante a agregação :: causado por :: $ range requer um valor final que possa ser representado como um número inteiro de 32 bits, encontrado valor: 45.6.

Conclusão

Informamos o conceito de operador de gama sendo utilizado na função agregada do MongoDB. Depois de definir o uso do operador de intervalo, explicamos seu uso com a ajuda de três exemplos distintos de comandos do MongoDB no shell. A primeira ilustração demonstra o uso do operador de alcance no campo do tipo inteiro para obter a sequência de números com o número de incremento específico. As segundas ilustrações demonstram como um operador de intervalo pode ser aplicado ao campo inicial e final sem usar o número de incremento. Embora o último exemplo mostre que o operador de intervalo não funciona em tipos de dados que não sejam inteiros: carros alegóricos e strings.