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 : [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
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 : [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
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 : [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