मोंगोडीबी $bsonSize

MongoDB 4.4 से, आप $bsonSize . का उपयोग कर सकते हैं एकत्रीकरण पाइपलाइन ऑपरेटर किसी दिए गए दस्तावेज़ के आकार को बाइट्स में वापस करने के लिए।

$bsonSize किसी भी मान्य व्यंजक को तब तक स्वीकार करता है जब तक वह किसी वस्तु या null . का समाधान करता है .

उदाहरण

मान लीजिए हमारे पास bars . नामक संग्रह है निम्नलिखित दस्तावेज़ के साथ:

{
	"_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"
		}
	]
}

हम देख सकते हैं कि location फ़ील्ड में एक दस्तावेज़ है। और reviews फ़ील्ड में दस्तावेज़ों की एक सरणी होती है।

आइए $bsonSize . का उपयोग करें location . के आकार की जांच करने के लिए ऑपरेटर फ़ील्ड:

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

परिणाम:

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

इस मामले में, location . का आकार फ़ील्ड 61 बाइट्स है।

सरणी में ऑब्जेक्ट

यहाँ एक दस्तावेज़ का आकार प्राप्त करने का एक उदाहरण है जो एक सरणी का एक तत्व है:

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

परिणाम:

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

इस मामले में, हम $arrayElemAt . का उपयोग करते हैं वास्तविक समीक्षा वापस करने के लिए, और फिर उस समीक्षा के आकार को वापस करने के लिए।

MongoDB सरणियाँ शून्य-आधारित हैं, इसलिए समीक्षा पहली समीक्षा है।

शीर्ष स्तर के दस्तावेज़ का आकार प्राप्त करें

हम $$ROOT . का उपयोग कर सकते हैं शीर्ष स्तर के दस्तावेज़ - या रूट दस्तावेज़ को संदर्भित करने के लिए सिस्टम चर। यह वह दस्तावेज़ है जिसे वर्तमान में पाइपलाइन द्वारा संसाधित किया जा रहा है।

इसलिए, हम $$ROOT . पास कर सकते हैं चर से $bsonSize पूरे दस्तावेज़ का आकार प्राप्त करने के लिए जिसे वर्तमान में संसाधित किया जा रहा है।

उदाहरण:

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

परिणाम:

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

इस मामले में, दस्तावेज़ 502 बाइट्स है।

गलत डेटा प्रकार

जैसा कि बताया गया है, $bsonSize किसी भी मान्य व्यंजक को तब तक स्वीकार करता है जब तक वह किसी वस्तु या null . का समाधान करता है ।

यहां एक उदाहरण दिया गया है कि क्या होता है यदि आप एक अलग बीएसओएन प्रकार के लिए एक अभिव्यक्ति प्रदान करते हैं:

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

परिणाम:

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

इस मामले में, हमने एक स्ट्रिंग का आकार खोजने की कोशिश की, लेकिन यह समर्थित BSON प्रकारों में से एक नहीं है, इसलिए हमें एक त्रुटि मिलती है।

वैसे, सबकुछ नष्ट नहीं हुआ है। हम $binarySize . का उपयोग कर सकते हैं एक स्ट्रिंग का आकार प्राप्त करने के लिए।

संग्रह में सभी दस्तावेज़ों का कुल आकार प्राप्त करें

मान लीजिए हमारे पास cats . नामक संग्रह है निम्नलिखित दस्तावेजों के साथ:

{ "_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") }

जैसा कि पहले दिखाया गया है, हम $$ROOT . का उपयोग कर सकते हैं वर्तमान में संसाधित किए जा रहे शीर्ष स्तरीय दस्तावेज़ को वापस करने के लिए:

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

परिणाम:

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

लेकिन हम कुल . भी प्राप्त कर सकते हैं संग्रह में सभी दस्तावेज़ों का आकार।

हम इसे इस प्रकार हासिल कर सकते हैं:

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

परिणाम:

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

यहां, हमने $group . का उपयोग करके परिणामों को समूहीकृत किया है ऑपरेटर और एक _id providing प्रदान करना का null . हम किसी अन्य स्थिर मान का उपयोग कर सकते थे।

हमने $sum . का भी इस्तेमाल किया विभिन्न दस्तावेज़ों के संयुक्त आकार की गणना करने के लिए।

हम देख सकते हैं कि संग्रह में सभी दस्तावेज़ों का कुल आकार 294 है, जिसकी पुष्टि हम पिछले उदाहरण में परिणामों को जोड़कर कर सकते हैं।

Object.bsonSize() विधि

दस्तावेज़ का आकार प्राप्त करने का दूसरा तरीका Object.bsonSize() . का उपयोग करना है विधि।