MongoDB $substrCP

W MongoDB $substrCP Operator potoku agregacji zwraca podciąg ciągu w oparciu o określone indeksy punktów kodowych UTF-8.

Składnia

Składnia wygląda tak:

{ $substrCP: [ <string expression>, <code point index>, <code point count> ] }

Gdzie:

• <string expression> jest ciągiem. Może to być dowolne prawidłowe wyrażenie, o ile prowadzi do łańcucha.
• <code point index> jest miejscem, od którego zaczyna się podciąg. Może to być dowolne prawidłowe wyrażenie, o ile zostanie rozwiązane na nieujemną liczbę całkowitą.
• <code point count> to liczba punktów kodowych, dla których podciąg powinien być kontynuowany. Może to być dowolne prawidłowe wyrażenie, o ile daje wynik nieujemnej liczby całkowitej lub liczby, która może być reprezentowana jako liczba całkowita.

Przykład

Wyobraź sobie, że mamy kolekcję o nazwie tests z następującym dokumentem:

{ "_id" : 1, "data" : "Red Firetruck" }

Możemy użyć $substrCP tak:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $substrCP: [ "$data", 0, 3 ] }
          }
     }
   ]
)

Wynik:

{ "data" : "Red Firetruck", "result" : "Red" }

Indeks zaczyna się od zera, więc nasz podciąg zaczynał się na początku ciągu i był kontynuowany przez trzy punkty kodowe.

W tym przypadku używamy znaków angielskich, a każdy znak ma jeden punkt kodowy. Ułatwia nam to policzenie, ile punktów kodowych należy użyć.

Przeanalizujmy inny przykład:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result_1: { $substrCP: [ "$data", 4, 4 ] },
            result_2: { $substrCP: [ "$data", 8, 5 ] },
            result_3: { $substrCP: [ "$data", 8, 20 ] }
          }
     }
   ]
).pretty()

Wynik:

{
	"data" : "Red Firetruck",
	"result_1" : "Fire",
	"result_2" : "truck",
	"result_3" : "truck"
}

Zauważ, że w naszym trzecim wyniku określiliśmy więcej punktów kodowych niż było dostępnych, ale po prostu zwrócił wszystkie znaki na koniec ciągu.

Znaki diakrytyczne

Niektóre znaki mają dodany znak diakrytyczny, co skutkuje wieloma punktami kodowymi.

Załóżmy, że mamy kolekcję o nazwie thai który zawiera następujące dokumenty:

{ "_id" : 1, "data" : "ไม้เมือง" }
{ "_id" : 2, "data" : "ไ" }
{ "_id" : 3, "data" : "ม้" }
{ "_id" : 4, "data" : "เ" }
{ "_id" : 5, "data" : "มื" }
{ "_id" : 6, "data" : "อ" }
{ "_id" : 7, "data" : "ง" }

Dokumenty te zawierają znaki tajskie. Widzimy, że dwa z tych znaków zawierają znak diakrytyczny (mały glif nad początkowym glifem).

Dokumenty od 2 do 7 zawierają po prostu listę wszystkich znaków znajdujących się w dokumencie 1.

Zanim weźmiemy podciąg, dowiedzmy się, ile punktów kodowych ma każdy z tych znaków, używając $strLenCP operator:

db.thai.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $strLenCP: "$data" }
          }
     }
   ]
)

Wynik:

{ "data" : "ไม้เมือง", "result" : 8 }
{ "data" : "ไ", "result" : 1 }
{ "data" : "ม้", "result" : 2 }
{ "data" : "เ", "result" : 1 }
{ "data" : "มื", "result" : 2 }
{ "data" : "อ", "result" : 1 }
{ "data" : "ง", "result" : 1 }

Widzimy, że dwa znaki ze znakami diakrytycznymi mają dwa punkty kodowe, a pozostałe mają jeden punkt kodowy.

Zastosujmy $substrCP do pierwszego dokumentu:

db.thai.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $substrCP: [ "$data", 1, 2 ] }
          }
     }
   ]
)

Wynik:

{ "data" : "ไม้เมือง", "result" : "ม้" }

Na podstawie naszego punktu początkowego 1 a nasza liczba punktów kodowych wynosi 2 , otrzymujemy drugi znak i związany z nim znak diakrytyczny.

Oddziel glify

W poprzednim przykładzie naszym trzecim argumentem było 2, więc zwracał razem znak i znak diakrytyczny. Oto, co się dzieje, gdy podamy trzeci argument o wartości 1.

db.thai.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $substrCP: [ "$data", 1, 1 ] }
          }
     }
   ]
)

Wynik:

{ "data" : "ไม้เมือง", "result" : "ม" }

Pierwszy znak jest zwracany bez znaku diakrytycznego.

Inne typy danych

$substrCP operator działa tylko na ciągach. Jednakże, jeśli masz inny typ danych, powinien nadal działać, o ile można go rozwiązać na łańcuch.

Załóżmy, że mamy następujący dokument:

{ "_id" : 2, "data" : 123456 }

data pole zawiera liczbę.

Oto, co się dzieje, gdy zastosujemy $substrCP do tego pola:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 2 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $substrCP: [ "$data", 1, 2 ] }
          }
     }
   ]
)

Wynik:

{ "data" : 123456, "result" : "23" }

Udało mu się dobrze wykonać zadanie (choć pamiętaj, że wynikiem jest ciąg, a nie liczba).

Mamy inny dokument z obiektem Date:

{ "_id" : 3, "data" : ISODate("2021-01-03T23:30:15.100Z") }

Teraz zastosujmy $substrCP do tego dokumentu:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $substrCP: [ "$data", 0, 4 ] }
          }
     }
   ]
)

Wynik:

{ "data" : ISODate("2021-01-03T23:30:15.100Z"), "result" : "2021" }

Więc w tym scenariuszu zadziałało dobrze.

Wartości puste

Jeśli ciąg ma wartość null , wynikiem jest pusty ciąg.

Załóżmy, że mamy następujący dokument:

{ "_id" : 4, "data" : null }

Oto, co się dzieje, gdy zastosujemy $substrCP do tego dokumentu:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $substrCP: [ "$data", 1, 2 ] }
          }
     }
   ]
)

Wynik:

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

Brakujące pole

Próba pobrania podciągu z pola, które nie istnieje, skutkuje powstaniem pustego ciągu.

Załóżmy, że mamy następujący dokument:

{ "_id" : 5 } 

Zastosuj $substrCP :

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 5 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $substrCP: [ "$data", 1, 2 ] }
          }
     }
   ]
)

Wynik:

{ "result" : "" }