MongoDB $bsonSize

A partir do MongoDB 4.4, você pode usar o $bsonSize operador de pipeline de agregação para retornar o tamanho de um determinado documento em bytes.

$bsonSize aceita qualquer expressão válida desde que resolva para um objeto ou null .

Exemplo

Suponha que tenhamos uma coleção chamada bars com o seguinte documento:

{
	"_id" : 1,
	"name" : "Boardwalk Social",
	"location" : {
		"type" : "Point",
		"coordinates" : [
			-16.919297718553366,
			145.77675259719823
		]
	},
	"categories" : [
		"Bar",
		"Restaurant",
		"Hotel"
	],
	"reviews" : [
		{
			"name" : "Steve",
			"date" : "20 December, 2020",
			"rating" : 5,
			"comments" : "Great vibe."
		},
		{
			"name" : "Lisa",
			"date" : "25 October, 2020",
			"rating" : 3,
			"comments" : "They just raised their prices :("
		},
		{
			"name" : "Kim",
			"date" : "21 October, 2020",
			"rating" : 4,
			"comments" : "Nice for Friday happy hour"
		}
	]
}

Podemos ver que o location campo contém um documento. E as reviews campo contém uma matriz de documentos.

Vamos usar o $bsonSize operador para verificar o tamanho do location campo:

db.bars.aggregate([
  {
    $project: {
      "locationSize": { $bsonSize: "$location" }
    }
  }
])

Resultado:

{ "_id" : 1, "locationSize" : 61 }

Nesse caso, o tamanho do location campo é de 61 bytes.

Objetos em Arrays

Aqui está um exemplo de como obter o tamanho de um documento que é um elemento de uma matriz:

db.bars.aggregate([
  {
    $project: {
      "review": { $arrayElemAt: [ "$reviews", 0 ] },
      "reviewSize": { $bsonSize: { $arrayElemAt: [ "$reviews", 0 ] } }
    }
  }
]).pretty()

Resultado:

{
	"_id" : 1,
	"review" : {
		"name" : "Steve",
		"date" : "20 December, 2020",
		"rating" : 5,
		"comments" : "Great vibe."
	},
	"reviewSize" : 91
}

Neste caso, usamos $arrayElemAt para retornar a revisão real e, novamente, para retornar o tamanho dessa revisão.

As matrizes do MongoDB são baseadas em zero, portanto, a revisão é a primeira revisão.

Obter o tamanho do documento de nível superior

Podemos usar o $$ROOT variável de sistema para se referir ao documento de nível superior – ou documento raiz. Este é o documento que está sendo processado atualmente pelo pipeline.

Portanto, podemos passar o $$ROOT variável para $bsonSize para obter o tamanho de todo o documento que está sendo processado no momento.

Exemplo:

db.bars.aggregate([
  {
    $project: {
      "rootSize": { $bsonSize: "$$ROOT" }
    }
  }
])

Resultado:

{ "_id" : 1, "rootSize" : 502 }

Nesse caso, o documento tem 502 bytes.

Tipos de dados incorretos

Como mencionado, $bsonSize aceita qualquer expressão válida desde que resolva para um objeto ou null .

Aqui está um exemplo do que acontece se você fornecer uma expressão que resolve para um tipo diferente de BSON:

db.bars.aggregate([
  {
    $project: {
      "nameSize": { $bsonSize: "$name" }
    }
  }
])

Resultado:

Error: command failed: {
	"ok" : 0,
	"errmsg" : "$bsonSize requires a document input, found: string",
	"code" : 31393,
	"codeName" : "Location31393"
} : 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:618:17
example@sqldat.com/mongo/shell/assert.js:708:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1046:12
@(shell):1:1

Nesse caso, tentamos encontrar o tamanho de uma string, mas esse não é um dos tipos BSON suportados, então recebemos um erro.

No entanto, nem tudo está perdido. Podemos usar $binarySize para obter o tamanho de uma string.

Obter o tamanho total de todos os documentos em uma coleção

Suponha que tenhamos uma coleção chamada cats com os seguintes documentos:

{ "_id" : 1, "name" : "Scratch", "born" : "March, 2020" }
{ "_id" : 2, "name" : "Meow", "weight" : 30 }
{ "_id" : 3, "name" : "Fluffy", "height" : 15 }
{ "_id" : 4, "name" : "Sox", "weight" : 40 }
{ "_id" : 5, "name" : null, "weight" : 20 }
{ "_id" : 6, "height" : 20, "born" : ISODate("2021-01-03T23:30:15.123Z") }

Como mostrado anteriormente, podemos usar $$ROOT para retornar o documento de nível superior que está sendo processado:

db.cats.aggregate([
  {
    $project: {
      "rootSize": { $bsonSize: "$$ROOT" }
    }
  }
])

Resultado:

{ "_id" : 1, "rootSize" : 58 }
{ "_id" : 2, "rootSize" : 49 }
{ "_id" : 3, "rootSize" : 51 }
{ "_id" : 4, "rootSize" : 48 }
{ "_id" : 5, "rootSize" : 40 }
{ "_id" : 6, "rootSize" : 48 }

Mas também podemos obter o total tamanho de todos os documentos da coleção.

Podemos conseguir isso da seguinte forma:

db.cats.aggregate([
  {
    $group: {
      "_id": null,
      "rootSize": { $sum: { $bsonSize: "$$ROOT" } }
    }
  }
])

Resultado:

{ "_id" : null, "rootSize" : 294 }

Aqui, agrupamos os resultados usando o $group operador e fornecendo um _id de null . Poderíamos ter usado qualquer outro valor constante.

Também usamos $sum para calcular os tamanhos combinados dos vários documentos.

Podemos ver que o tamanho total de todos os documentos da coleção é 294, o que podemos confirmar somando os resultados do exemplo anterior.

Método Object.bsonSize()

Outra maneira de obter o tamanho de um documento é usar o Object.bsonSize() método.