MongoDB, o
$strLenBytes operador de pipeline de agregação retorna o número de bytes codificados em UTF-8 na string especificada. Cada caractere em uma string pode conter um número diferente de bytes, dependendo do caractere que está sendo usado. O
$strLenBytes O operador pode descobrir quantos bytes cada caractere contém e retornar o resultado correto para toda a string. Exemplo
Suponha que tenhamos uma coleção chamada
english com os seguintes 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 para o campo de dados nesses documentos:db.english.aggregate(
[
{
$project:
{
_id: 0,
data: 1,
result: { $strLenBytes: "$data" }
}
}
]
) Resultado:
{ "dados" :"Maimuang", "resultado" :8 }{ "dados" :"M", "resultado" :1 }{ "dados" :"a", "resultado" :1 }{ " data" :"i", "resultado" :1 }{ "dados" :"m", "resultado" :1 }{ "dados" :"u", "resultado" :1 }{ "dados" :"a ", "resultado" :1 }{ "dados" :"n", "resultado" :1 }{ "dados" :"g", "resultado" :1 } Podemos ver que a palavra inteira é de 8 bytes e cada caractere é de 1 byte cada.
Personagens tailandeses
Aqui está um exemplo que usa caracteres tailandeses, que são 3 bytes cada.
Temos uma coleção chamada
thai com os seguintes documentos:{ "_id" :1, "data" :"ไม้เมือง" }{ "_id" :2, "data" :"ไ" }{ "_id" :3, "data" :"ม้" }{ "_id" :4, "data" :"เ" }{ "_id" :5, "data" :"มื" }{ "_id" :6, "data" :"อ" }{ "_id" :7 , "dados" :"ง" } E aqui está o que acontece quando aplicamos
$strLenBytes a esses documentos:db.thai.aggregate( [ { $project:{ _id:0, data:1, result:{ $strLenBytes:"$data" } } } ]) Resultado:
{ "dados" :"ไม้เมือง", "resultado" :24 }{ "dados" :"ไ", "resultado" :3 }{ "dados" :"ม้", "resultado" :6 }{ "data" :"เ", "resultado" :3 }{ "dados" :"มื", "resultado" :6 }{ "dados" :"อ", "resultado" :3 }{ "dados" :" ง", "resultado" :3 } Dois desses caracteres foram modificados usando diacríticos, o que resulta no retorno de 6 bytes.
Outros personagens
Suponha que tenhamos uma coleção chamada
other com os seguintes documentos:{ "_id" :1, "data" :"é" }{ "_id" :2, "data" :"©" }{ "_id" :3, "data" :"℘" }
E vamos aplicar $strLenBytes a esses documentos:
db.other.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $strLenBytes: "$data" }
}
}
]
)
Resultado:
{ "dados" :"é", "resultado" :2 }{ "dados" :"©", "resultado" :2 }{ "dados" :"℘", "resultado" :3 }
Os dois primeiros caracteres são de 2 bytes e o terceiro é de 3 bytes. O número de bytes depende do caractere. Alguns caracteres podem usar 4 bytes.
O caractere de espaço usa um byte. Dois caracteres de espaço, portanto, usam 2 bytes e assim por diante.
Suponha que temos os seguintes documentos:
{ "_id" :4, "data" :" " }{ "_id" :5, "data" :" " }
E aplicamos $strLenBytes a esses documentos:
db.other.aggregate(
[
{ $match: { _id: { $in: [ 4, 5 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $strLenBytes: "$data" }
}
}
]
)
Resultado:
{ "dados" :" ", "resultado" :1 }{ "dados" :" ", "resultado" :2 } Strings vazias
Strings vazias retornam 0 .
Aqui está um documento com uma string vazia:
{ "_id" :6, "data" :"" }
E aqui está o que acontece quando aplicamos $strLenBytes a esse documento:
db.other.aggregate(
[
{ $match: { _id: { $in: [ 6 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $strLenBytes: "$data" }
}
}
]
)
Resultado:
{ "dados" :"", "resultado" :0 } Tipo de dados incorreto
Passar o tipo de dados errado resulta em um erro.
Suponha que temos o seguinte documento:
{ "_id" :7, "dados" :123 }
O field de dados contém um número.
Vamos aplicar $strLenBytes a esse documento:
db.other.aggregate(
[
{ $match: { _id: { $in: [ 7 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $strLenBytes: "$data" }
}
}
]
)
Resultado:
Erro:comando falhou:{ "ok":0, "errmsg":"$strLenBytes requer um argumento de string, encontrado:double", "code":34473, "codeName":"Location34473"}:agregado falhou:example@sqldat.com/mongo/shell/utils.js:25:13example@sqldat.com/mongo/shell/assert.js:18:14example@sqldat.com/mongo/shell/assert.js:639:17example@ sqldat.com/mongo/shell/assert.js:729:16example@sqldat.com/mongo/shell/db.js:266:5example@sqldat.com/mongo/shell/collection.js:1058:12@(shell ):1:1 Valores nulos
Fornecendo null também resulta em erro.
Suponha que temos o seguinte documento:
{ "_id":8, "data":null }
O field de dados contém null .
Vamos aplicar $strLenBytes a esse documento:
db.other.aggregate(
[
{ $match: { _id: { $in: [ 8 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $strLenBytes: "$data" }
}
}
]
)
Resultado:
exceção não capturada:Erro:comando falhou:{ "ok":0, "errmsg":"$strLenBytes requer um argumento de string, encontrado:null", "code":34473, "codeName":"Location34473"}:falha na agregação :example@sqldat.com/mongo/shell/utils.js:25:13example@sqldat.com/mongo/shell/assert.js:18:14example@sqldat.com/mongo/shell/assert.js:639 :17example@sqldat.com/mongo/shell/assert.js:729:16example@sqldat.com/mongo/shell/db.js:266:5example@sqldat.com/mongo/shell/collection.js:1058:12 @(shell):1:1 Campos ausentes
Continuando com o tema de produzir erros, especificar um campo inexistente também produz um erro.
Documento:
{ "_id":9 }
Aplicar $strLenBytes :
db.other.aggregate(
[
{ $match: { _id: { $in: [ 9 ] } } },
{
$project:
{
_id: 0,
data: 1,
result: { $strLenBytes: "$data" }
}
}
]
)
Resultado:
Erro:comando falhou:{ "ok":0, "errmsg":"$strLenBytes requer um argumento de string, encontrado:ausente", "code":34473, "codeName":"Location34473"}:agregado falhou:example@sqldat.com/mongo/shell/utils.js:25:13example@sqldat.com/mongo/shell/assert.js:18:14example@sqldat.com/mongo/shell/assert.js:639:17example@ sqldat.com/mongo/shell/assert.js:729:16example@sqldat.com/mongo/shell/db.js:266:5example@sqldat.com/mongo/shell/collection.js:1058:12@(shell ):1:1
