MongoDB
 sql >> Base de Dados >  >> NoSQL >> MongoDB

MongoDB $indexOfBytes


No MongoDB, o $indexOfBytes O operador de pipeline de agregação pesquisa uma string para uma ocorrência de uma substring e retorna o índice de bytes UTF-8 da primeira ocorrência.

O índice de bytes UTF é baseado em zero (ou seja, começa em 0 ).

Sintaxe


A sintaxe fica assim:
{ $indexOfBytes: [ <string expression>, <substring expression>, <start>, <end> ] }

Onde:
  • <string expression> é a string a ser pesquisada.
  • <substring expression> é a substring que você deseja encontrar na string.
  • <start> é um argumento opcional que especifica uma posição de índice inicial para a pesquisa. Pode ser qualquer expressão válida que resolva para um número inteiro não negativo.
  • <end> é um argumento opcional que especifica uma posição de índice final para a pesquisa. Pode ser qualquer expressão válida que resolva para um número inteiro não negativo.

Se o valor especificado não for encontrado, $indexOfBytes retorna -1 .

Se houver várias instâncias do valor especificado, apenas a primeira será retornada.

Exemplo


Suponha que tenhamos uma coleção chamada test com os seguintes documentos:
{ "_id" : 1, "data" : "c 2021" }
{ "_id" : 2, "data" : "© 2021" }
{ "_id" : 3, "data" : "ไม้เมือง" }

Aqui está um exemplo de aplicação de $indexOfBytes a esses documentos:
db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "2021" ] }
          }
     }
   ]
)

Resultado:
{ "data" : "c 2021", "result" : 2 }
{ "data" : "© 2021", "result" : 3 }
{ "data" : "ไม้เมือง", "result" : -1 }

Podemos ver que os dois primeiros documentos produziram resultados diferentes, embora a substring pareça estar na mesma posição para cada documento. No primeiro documento, a substring foi encontrada na posição do índice de bytes 2 , enquanto o segundo documento o tinha em 3 .

A razão para isso é que o símbolo de copyright (© ) no segundo documento ocupa 2 bytes. O c caractere (no primeiro documento) usa apenas 1 byte. O caractere de espaço também usa 1 byte.

O resultado de $indexOfBytes é baseado em zero (o índice começa em 0 ), e assim acabamos com um resultado de 2 e 3 respectivamente.

Em relação ao terceiro documento, a substring não foi encontrada e, portanto, o resultado é -1 .

Aqui está outro exemplo, exceto que desta vez procuramos um caractere tailandês:
db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "เ" ] }
          }
     }
   ]
)

Resultado:
{ "data" : "c 2021", "result" : -1 }
{ "data" : "© 2021", "result" : -1 }
{ "data" : "ไม้เมือง", "result" : 9 }

Nesse caso, procuramos um caractere que aparece na terceira posição no terceiro documento e seu índice de bytes UTF-8 retorna como 9 .

Isso ocorre porque, nesse caso, cada caractere usa 3 bytes. Mas o segundo caractere tem uma marca diacrítica, que também é de 3 bytes. Portanto, os dois primeiros caracteres (incluindo o diacrítico) usam 9 bytes. Dada a indexação baseada em zero, seus índices de bytes UTF-8 variam de 0 para 8 . Isso significa que o terceiro caractere começa na posição 9 .

Veja MongoDB $strLenBytes para um exemplo que retorna o número de bytes para cada caractere nessa string específica.

Especifique uma posição inicial


Você pode fornecer um terceiro argumento para especificar uma posição de índice inicial para a pesquisa.

Suponha que temos o seguinte documento:
{ "_id" : 4, "data" : "ABC XYZ ABC" }

Aqui está um exemplo de aplicação de $indexOfBytes com uma posição inicial:
db.test.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "ABC", 1 ] }
          }
     }
   ]
)

Resultado:
{ "data" : "ABC XYZ ABC", "result" : 8 }

Nesse caso, a segunda instância da substring foi retornada. Isso ocorre porque iniciamos a pesquisa na posição 1 , e a primeira instância da substring começa na posição 0 (antes da posição inicial para a busca).

Se a posição inicial for um número maior que o comprimento do byte da string ou maior que a posição final, $indexOfBytes retorna -1 .

Se for um número negativo, $indexOfBytes retorna um erro.

Especifique uma posição final


Você também pode fornecer um quarto argumento para especificar a posição final do índice para a pesquisa.

Se você fornecer esse argumento, também precisará fornecer uma posição inicial. Se isso não for feito, esse argumento será interpretado como o ponto de partida.

Exemplo:
db.test.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "XYZ", 0, 5 ] }
          }
     }
   ]
)

Resultado:
{ "data" : "ABC XYZ ABC", "result" : -1 }

O resultado é -1 o que significa que a substring não foi encontrada. Isso porque iniciamos nossa pesquisa na posição 0 e terminou na posição 5 , portanto, não capturando a substring.

Aqui está o que acontece se incrementarmos a posição do índice final:
db.test.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "XYZ", 0, 7 ] }
          }
     }
   ]
)

Resultado:
{ "data" : "ABC XYZ ABC", "result" : 4 }

Desta vez, o valor foi incluído e sua posição de índice foi retornada.

Se a posição final for um número menor que a posição inicial, $indexOfBytes retorna -1 .

Se for um número negativo, $indexOfBytes retorna um erro.

Campos ausentes


Se o campo não estiver no documento, $indexOfBytes retorna null .

Suponha que temos o seguinte documento:
{ "_id" : 5 }

Veja o que acontece quando aplicamos $indexOfBytes :
db.test.aggregate(
   [
     { $match: { _id: { $in: [ 5 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "XYZ" ] }
          }
     }
   ]
)

Resultado:
{ "result" : null }

Valores nulos


Se o primeiro argumento for null , $indexOfBytes retorna null .

Suponha que temos o seguinte documento:
{ "_id" : 6, "data" : null }

Veja o que acontece quando aplicamos $indexOfBytes :
db.test.aggregate(
   [
     { $match: { _id: { $in: [ 6 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "XYZ" ] }
          }
     }
   ]
)

Resultado:
{ "data" : null, "result" : null }

No entanto, quando o segundo argumento (ou seja, a substring) é null , um erro é retornado:
db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", null ] }
          }
     }
   ]
)

Resultado:
uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$indexOfBytes requires a string as the second argument, found: null",
	"code" : 40092,
	"codeName" : "Location40092"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1

Tipo de dados incorreto


Se o primeiro argumento for o tipo de dados errado (ou seja, não resolver para uma string), $indexOfBytes retorna um erro.

Suponha que temos o seguinte documento:
{ "_id" : 7, "data" : 123 }

Veja o que acontece quando aplicamos $indexOfBytes a esse documento:
db.test.aggregate(
   [
     { $match: { _id: { $in: [ 7 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $indexOfBytes: [ "$data", "XYZ" ] }
          }
     }
   ]
)

Resultado:
uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$indexOfBytes requires a string as the first argument, found: double",
	"code" : 40091,
	"codeName" : "Location40091"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1

Como a mensagem de erro indica, $indexOfBytes requires a string as the first argument .