В MongoDB, $indexOfBytes
Операторът на тръбопровода за агрегиране търси низ за среща на подниз и връща UTF-8 байтов индекс на първото появяване.
Индексът на UTF байтовете е базиран на нула (т.е. започва от 0
).
Синтаксис
Синтаксисът е така:
{ $indexOfBytes: [ <string expression>, <substring expression>, <start>, <end> ] }
Къде:
<string expression>
е низът за търсене.<substring expression>
е поднизът, който искате да намерите в низа.<start>
е незадължителен аргумент, който определя начална позиция на индекса за търсене. Може да бъде всеки валиден израз, който се разрешава до неотрицателно цяло число.<end>
е незадължителен аргумент, който определя крайна индексна позиция за търсенето. Може да бъде всеки валиден израз, който се разрешава до неотрицателно цяло число.
Ако посочената стойност не е намерена, $indexOfBytes
връща -1
.
Ако има няколко екземпляра на посочената стойност, се връща само първият.
Пример
Да предположим, че имаме колекция, наречена test
със следните документи:
{ "_id" : 1, "data" : "c 2021" } { "_id" : 2, "data" : "© 2021" } { "_id" : 3, "data" : "ไม้เมือง" }
Ето пример за прилагане на $indexOfBytes
към тези документи:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "2021" ] }
}
}
]
)
Резултат:
{ "data" : "c 2021", "result" : 2 } { "data" : "© 2021", "result" : 3 } { "data" : "ไม้เมือง", "result" : -1 }
Можем да видим, че първите два документа са дали различни резултати, въпреки че поднизът изглежда е в една и съща позиция за всеки документ. В първия документ поднизът беше намерен в позиция на байтов индекс 2
, докато вторият документ го имаше на 3
.
Причината за това е, че символът за авторско право (©
) във втория документ заема 2 байта. c
символ (в първия документ) използва само 1 байт. Знакът за интервал също използва 1 байт.
Резултатът от $indexOfBytes
е базиран на нула (индексът започва от 0
), и така в крайна сметка получаваме резултат от 2
и 3
съответно.
По отношение на третия документ поднизът изобщо не беше намерен и така резултатът е -1
.
Ето още един пример, освен че този път търсим тайландски знак:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "เ" ] }
}
}
]
)
Резултат:
{ "data" : "c 2021", "result" : -1 } { "data" : "© 2021", "result" : -1 } { "data" : "ไม้เมือง", "result" : 9 }
В този случай потърсихме знак, който се появява на трета позиция в третия документ и неговият UTF-8 байтов индекс се връща като 9
.
Това е така, защото в този случай всеки знак използва 3 байта. Но вторият знак има диакритичен знак, който също е 3 байта. Следователно, първите два знака (включително диакритиката) използват 9 байта. Като се има предвид индексирането на базата на нула, техните UTF-8 байтови индекси варират от 0
до 8
. Това означава, че третият знак започва от позиция 9
.
Вижте MongoDB $strLenBytes
за пример, който връща броя на байтовете за всеки знак в този конкретен низ.
Посочете начална позиция
Можете да предоставите трети аргумент, за да посочите начална позиция на индекса за търсене.
Да предположим, че имаме следния документ:
{ "_id" : 4, "data" : "ABC XYZ ABC" }
Ето пример за прилагане на $indexOfBytes
с изходна позиция:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 4 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "ABC", 1 ] }
}
}
]
)
Резултат:
{ "data" : "ABC XYZ ABC", "result" : 8 }
В този случай вторият екземпляр на подниз беше върнат. Това е така, защото започнахме търсенето на позиция 1
, а първият екземпляр на подниза започва от позиция 0
(преди началната позиция за търсене).
Ако началната позиция е число, по-голямо от дължината на байта на низа или по-голямо от крайната позиция, $indexOfBytes
връща -1
.
Ако е отрицателно число, $indexOfBytes
връща грешка.
Посочете крайна позиция
Можете също да предоставите четвърти аргумент, за да посочите крайната позиция на индекса за търсене.
Ако предоставите този аргумент, трябва да посочите и начална позиция. Ако не го направите, този аргумент ще бъде интерпретиран като отправна точка.
Пример:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 4 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "XYZ", 0, 5 ] }
}
}
]
)
Резултат:
{ "data" : "ABC XYZ ABC", "result" : -1 }
Резултатът е -1
което означава, че поднизът не е намерен. Това е така, защото започнахме търсенето на позиция 0
и го завърши на позиция 5
, следователно не улавя подниз.
Ето какво се случва, ако увеличим позицията на крайния индекс:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 4 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "XYZ", 0, 7 ] }
}
}
]
)
Резултат:
{ "data" : "ABC XYZ ABC", "result" : 4 }
Този път стойността беше включена и нейната индексна позиция беше върната.
Ако крайната позиция е число, по-малко от началната позиция, $indexOfBytes
връща -1
.
Ако е отрицателно число, $indexOfBytes
връща грешка.
Липсващи полета
Ако полето не е в документа, $indexOfBytes
връща null
.
Да предположим, че имаме следния документ:
{ "_id" : 5 }
Ето какво се случва, когато приложим $indexOfBytes
:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 5 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "XYZ" ] }
}
}
]
)
Резултат:
{ "result" : null }
Нулеви стойности
Ако първият аргумент е null
, $indexOfBytes
връща null
.
Да предположим, че имаме следния документ:
{ "_id" : 6, "data" : null }
Ето какво се случва, когато приложим $indexOfBytes
:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 6 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "XYZ" ] }
}
}
]
)
Резултат:
{ "data" : null, "result" : null }
Въпреки това, когато вторият аргумент (т.е. поднизът) е null
, се връща грешка:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", null ] }
}
}
]
)
Резултат:
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
Грешен тип данни
Ако първият аргумент е грешен тип данни (т.е. не се разрешава до низ), $indexOfBytes
връща грешка.
Да предположим, че имаме следния документ:
{ "_id" : 7, "data" : 123 }
Ето какво се случва, когато приложим $indexOfBytes
към този документ:
db.test.aggregate(
[
{ $match: { _id: { $in: [ 7 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $indexOfBytes: [ "$data", "XYZ" ] }
}
}
]
)
Резултат:
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
Както се казва в съобщението за грешка, $indexOfBytes requires a string as the first argument
.