MongoDB
 sql >> база данни >  >> NoSQL >> MongoDB

MongoDB $indexOfBytes

В 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 .


  1. Redis
  2.   
  3. MongoDB
  4.   
  5. Memcached
  6.   
  7. HBase
  8.   
  9. CouchDB
  1. Как да направя вложено $lookup търсене в MongoDB?

  2. MongoDB агрегиране на Loopback

  3. Mongo Дава „грешка с дублиран ключ“ в неуникални полета

  4. Как Trello съхранява данни в MongoDB? (Колекция на дъска?)

  5. MongoDB :Редът на индексите и редът на заявките трябва да съвпадат?