MongoDB $strLenBytes

MongoDB, el $strLenBytes El operador de canalización de agregación devuelve el número de bytes codificados en UTF-8 en la cadena especificada.

Cada carácter de una cadena puede contener un número diferente de bytes, según el carácter que se utilice. El $strLenBytes el operador puede averiguar cuántos bytes contiene cada carácter y devolver el resultado correcto para toda la cadena.

Ejemplo

Supongamos que tenemos una colección llamada english con los siguientes documentos:

{ "_id" : 1, "data" : "Maimuang" }
{ "_id" : 2, "data" : "M" }
{ "_id" : 3, "data" : "a" }
{ "_id" : 4, "data" : "i" }
{ "_id" : 5, "data" : "m" }
{ "_id" : 6, "data" : "u" }
{ "_id" : 7, "data" : "a" }
{ "_id" : 8, "data" : "n" }
{ "_id" : 9, "data" : "g" }

Podemos aplicar $strLenBytes al campo de datos en esos documentos:

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

Resultado:

{ "data" : "Maimuang", "result" : 8 }
{ "data" : "M", "result" : 1 }
{ "data" : "a", "result" : 1 }
{ "data" : "i", "result" : 1 }
{ "data" : "m", "result" : 1 }
{ "data" : "u", "result" : 1 }
{ "data" : "a", "result" : 1 }
{ "data" : "n", "result" : 1 }
{ "data" : "g", "result" : 1 }

Podemos ver que la palabra completa tiene 8 bytes y cada carácter tiene 1 byte cada uno.

Caracteres tailandeses

Aquí hay un ejemplo que usa caracteres tailandeses, que tienen 3 bytes cada uno.

Tenemos una colección llamada thai con los siguientes documentos:

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

Y esto es lo que sucede cuando aplicamos $strLenBytes a esos documentos:

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

Resultado:

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

Dos de estos caracteres se han modificado utilizando signos diacríticos, lo que da como resultado que se devuelvan 6 bytes.

Otros personajes

Supongamos que tenemos una colección llamada other con los siguientes documentos:

{ "_id" : 1, "data" : "é" }
{ "_id" : 2, "data" : "©" }
{ "_id" : 3, "data" : "℘" }

Y apliquemos $strLenBytes a esos documentos:

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

Resultado:

{ "data" : "é", "result" : 2 }
{ "data" : "©", "result" : 2 }
{ "data" : "℘", "result" : 3 }

Los primeros dos caracteres son de 2 bytes y el tercero es de 3 bytes. El número de bytes depende del carácter. Algunos caracteres pueden usar 4 bytes.

El carácter de espacio utiliza un byte. Por lo tanto, dos caracteres de espacio usan 2 bytes, y así sucesivamente.

Supongamos que tenemos los siguientes documentos:

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

Y aplicamos $strLenBytes a esos documentos:

db.other.aggregate(
   [
     { $match: { _id: { $in: [ 4, 5 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            result: { $strLenBytes: "$data" }
          }
     }
   ]
)

Resultado:

{ "data" : " ", "result" : 1 }
{ "data" : "  ", "result" : 2 }

Cadenas vacías

Las cadenas vacías devuelven 0 .

Aquí hay un documento con una cadena vacía:

{ "_id" : 6, "data" : "" }

Y esto es lo que sucede cuando aplicamos $strLenBytes a ese documento:

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

Resultado:

{ "data" : "", "result" : 0 }

Tipo de datos incorrecto

Pasar el tipo de datos incorrecto da como resultado un error.

Supongamos que tenemos el siguiente documento:

{ "_id" : 7, "data" : 123 }

El field de datos contiene un número.

Apliquemos $strLenBytes a ese documento:

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

Resultado:

Error: command failed: {
	"ok" : 0,
	"errmsg" : "$strLenBytes requires a string argument, found: double",
	"code" : 34473,
	"codeName" : "Location34473"
} : aggregate failed :
example@sqldat.com/mongo/shell/utils.js:25:13
example@sqldat.com/mongo/shell/assert.js:18:14
example@sqldat.com/mongo/shell/assert.js:639:17
example@sqldat.com/mongo/shell/assert.js:729:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1058:12
@(shell):1:1

Valores nulos

Proporcionar null también da como resultado un error.

Supongamos que tenemos el siguiente documento:

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

El field de datos contiene null .

Apliquemos $strLenBytes a ese documento:

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

Resultado:

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$strLenBytes requires a string argument, found: null",
	"code" : 34473,
	"codeName" : "Location34473"
} : aggregate failed :
example@sqldat.com/mongo/shell/utils.js:25:13
example@sqldat.com/mongo/shell/assert.js:18:14
example@sqldat.com/mongo/shell/assert.js:639:17
example@sqldat.com/mongo/shell/assert.js:729:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1058:12
@(shell):1:1

Campos faltantes

Siguiendo con el tema de producir errores, especificar un campo inexistente también produce un error.

Documento:

{ "_id" : 9 }

Aplicar $strLenBytes :

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

Resultado:

Error: command failed: {
	"ok" : 0,
	"errmsg" : "$strLenBytes requires a string argument, found: missing",
	"code" : 34473,
	"codeName" : "Location34473"
} : aggregate failed :
example@sqldat.com/mongo/shell/utils.js:25:13
example@sqldat.com/mongo/shell/assert.js:18:14
example@sqldat.com/mongo/shell/assert.js:639:17
example@sqldat.com/mongo/shell/assert.js:729:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1058:12
@(shell):1:1