MongoDB $substrCP

Exempel

Föreställ dig att vi har en samling som heter tester med följande dokument:

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

Vi kan använda $substrCP så här:

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

Resultat:

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

Indexet börjar på noll, så vår delsträng började i början av strängen och fortsatte i tre kodpunkter.

I det här fallet använder vi engelska tecken och varje tecken har en kodpunkt. Detta gör det enkelt för oss att räkna hur många kodpunkter som ska användas.

Låt oss köra ett annat exempel:

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()

Resultat:

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

Observera att i vårt tredje resultat angav vi fler kodpunkter än vad som var tillgängliga, men det returnerade helt enkelt alla tecken till slutet av strängen.

Diakritiska tecken

Vissa tecken har ett diakritiskt tecken lagt till, vilket resulterar i flera kodpunkter.

Anta att vi har en samling som heter thai som innehåller följande dokument:

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

Dessa dokument innehåller thailändska tecken. Vi kan se att två av dessa tecken innehåller en diakritisk (en liten glyf ovanför den initiala glyfen).

Dokument 2 till 7 listar helt enkelt vart och ett av tecknen som finns i dokument 1.

Innan vi tar en delsträng, låt oss ta reda på hur många kodpunkter vart och ett av dessa tecken har genom att använda $strLenCP operatör:

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

Resultat:

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

Vi kan se att de två tecknen med diakritiska tecken har två kodpunkter och de andra har en kodpunkt.

Låt oss tillämpa $substrCP till det första dokumentet:

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

Resultat:

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

Baserat på vår utgångspunkt 1 och vårt antal kodpunkter på 2 , får vi det andra tecknet och dess tillhörande diakritiska tecken.

Separera glyferna

I det föregående exemplet var vårt tredje argument 2 så att det gav tecken och diakrit tillsammans. Det här är vad som händer när vi tillhandahåller ett tredje argument på 1.

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

Resultat:

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

Det första tecknet returneras utan diakritiskt tecken.

Andra datatyper

$substrCP operatören fungerar bara på strängar. Men om du har en annan datatyp bör den fortfarande fungera, så länge den kan lösas till en sträng.

Anta att vi har följande dokument:

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

data fältet innehåller ett nummer.

Det här är vad som händer när vi använder $substrCP till det fältet:

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

Resultat:

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

Den lyckades göra jobbet bra (även om du kom ihåg att resultatet är en sträng – inte en siffra).

Vi har ett annat dokument med ett Date-objekt:

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

Låt oss nu tillämpa $substrCP till det dokumentet:

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

Resultat:

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

Så det fungerade bra i det här scenariot också.

Nullvärden

Om strängen är null , resultatet är en tom sträng.

Anta att vi har följande dokument:

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

Det här är vad som händer när vi använder $substrCP till det dokumentet:

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

Resultat:

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

Fält saknas

Ett försök att hämta en delsträng från ett fält som inte finns resulterar i en tom sträng.

Anta att vi har följande dokument:

{ "_id" : 5 } 

Använd $substrCP :

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

Resultat:

{ "result" : "" }