मोंगोडीबी $ट्रंक

MongoDB में, $trunc एग्रीगेशन पाइपलाइन ऑपरेटर किसी संख्या को पूरे पूर्णांक या निर्दिष्ट दशमलव स्थान तक छोटा कर देता है।

आपके पास यह निर्दिष्ट करने का विकल्प है कि कितने दशमलव स्थानों के लिए संख्या को छोटा करना है। ऐसा करने के लिए, दूसरा तर्क पास करें। पहला तर्क छोटा करने की संख्या है, और दूसरा (वैकल्पिक) तर्क दशमलव स्थानों की संख्या है जिसमें इसे छोटा करना है।

दूसरे तर्क को छोड़ देने से दशमलव के दायीं ओर के सभी अंक छोटे हो जाते हैं और पूरा पूर्णांक मान वापस आ जाता है।

उदाहरण

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

{ "_id" : 1, "data" : 8.99 }
{ "_id" : 2, "data" : 8.45 }
{ "_id" : 3, "data" : 8.451 }
{ "_id" : 4, "data" : -8.99 }
{ "_id" : 5, "data" : -8.45 }
{ "_id" : 6, "data" : -8.451 }
{ "_id" : 7, "data" : 8 }
{ "_id" : 8, "data" : 0 }

हम $trunc . का उपयोग कर सकते हैं data में मानों को छोटा करने के लिए ऑपरेटर फ़ील्ड:

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data" ] }
          }
     }
   ]
)

परिणाम:

{ "data" : 8.99, "truncated" : 8 }
{ "data" : 8.45, "truncated" : 8 }
{ "data" : 8.451, "truncated" : 8 }
{ "data" : -8.99, "truncated" : -8 }
{ "data" : -8.45, "truncated" : -8 }
{ "data" : -8.451, "truncated" : -8 }
{ "data" : 8, "truncated" : 8 }
{ "data" : 0, "truncated" : 0 }

ध्यान दें कि $trunc $round . जैसी संख्याओं को गोल नहीं करता है करता है। $trunc ऑपरेटर बस संख्या को छोटा कर देता है। अगर हमने $round . लागू किया होता इस संग्रह के लिए, पहले और चौथे दस्तावेज़ों को 9 . में पूर्णांकित किया गया होगा और -9 क्रमशः।

दशमलव स्थान निर्दिष्ट करें

हमारे पास यह निर्दिष्ट करने के लिए दूसरे तर्क का उपयोग करने का विकल्प है कि संख्या को कितने दशमलव स्थानों तक छोटा करना है।

उदाहरण:

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data", 1 ] }
          }
     }
   ]
)

परिणाम:

{ "data" : 8.99, "truncated" : 8.9 }
{ "data" : 8.45, "truncated" : 8.4 }
{ "data" : 8.451, "truncated" : 8.4 }
{ "data" : -8.99, "truncated" : -8.9 }
{ "data" : -8.45, "truncated" : -8.4 }
{ "data" : -8.451, "truncated" : -8.4 }
{ "data" : 8, "truncated" : 8 }
{ "data" : 0, "truncated" : 0 }

दोबारा, यह केवल संख्या को छोटा कर देता है। अगर हम $round का इस्तेमाल करते , यह इनमें से कुछ संख्याओं को गोल कर देता।

नकारात्मक दशमलव स्थान

दूसरा तर्क कोई भी मान्य व्यंजक हो सकता है जो -20 और 100 के बीच एक पूर्णांक को हल करता है, अनन्य। इसलिए, आप एक ऋणात्मक दशमलव स्थान निर्दिष्ट कर सकते हैं।

जब आप ऐसा करते हैं, तो संख्या को दशमलव स्थान के बाईं ओर छोटा कर दिया जाता है। यदि ऋणात्मक पूर्णांक का निरपेक्ष मान दशमलव के बाईं ओर अंकों की संख्या से अधिक है, तो परिणाम 0 है ।

मान लीजिए हम अपने संग्रह में निम्नलिखित दस्तावेज़ जोड़ते हैं:

{ "_id" : 9, "data" : 8111.32 }
{ "_id" : 10, "data" : 8514.321 }
{ "_id" : 11, "data" : 8999.454 }

$trunc . लागू करते समय विभिन्न नकारात्मक दशमलव स्थानों का उपयोग करने का एक उदाहरण यहां दिया गया है उन दस्तावेज़ों के लिए:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 9, 10, 11 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            a: { $trunc: [ "$data", -1 ] },
            b: { $trunc: [ "$data", -2 ] },
            c: { $trunc: [ "$data", -3 ] },
            d: { $trunc: [ "$data", -4 ] },
            e: { $trunc: [ "$data", -5 ] }
          }
     }
   ]
).pretty()

परिणाम:

{
	"data" : 8111.32,
	"a" : 8110,
	"b" : 8100,
	"c" : 8000,
	"d" : 0,
	"e" : 0
}
{
	"data" : 8514.321,
	"a" : 8510,
	"b" : 8500,
	"c" : 8000,
	"d" : 0,
	"e" : 0
}
{
	"data" : 8999.454,
	"a" : 8990,
	"b" : 8900,
	"c" : 8000,
	"d" : 0,
	"e" : 0
}

शून्य का दशमलव स्थान

जब आप 0 . का दशमलव स्थान प्रदान करते हैं , $trunc ऑपरेटर दशमलव के दाईं ओर सभी अंकों को काटता है और संपूर्ण पूर्णांक मान देता है।

उदाहरण:

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data", 0 ] }
          }
     }
   ]
)

परिणाम:

{ "data" : 8.99, "truncated" : 8 }
{ "data" : 8.45, "truncated" : 8 }
{ "data" : 8.451, "truncated" : 8 }
{ "data" : -8.99, "truncated" : -8 }
{ "data" : -8.45, "truncated" : -8 }
{ "data" : -8.451, "truncated" : -8 }
{ "data" : 8, "truncated" : 8 }
{ "data" : 0, "truncated" : 0 }
{ "data" : 8111.32, "truncated" : 8111 }
{ "data" : 8514.321, "truncated" : 8514 }
{ "data" : 8999.454, "truncated" : 8999 }

संख्या प्रकार

छंटनी की जाने वाली संख्या कोई भी मान्य व्यंजक हो सकती है जो एक पूर्णांक, दोहरे, दशमलव या लंबे समय तक हल हो जाती है। वापसी मान इनपुट मान के डेटा प्रकार से मेल खाता है।

इसलिए यदि हम अपने संग्रह में निम्नलिखित दस्तावेज़ जोड़ते हैं:

{ "_id" : 12, "data" : NumberDecimal("128.4585") }
{ "_id" : 13, "data" : NumberDecimal("128.12345678912") }

हम $trunc apply लागू कर सकते हैं data . के लिए फ़ील्ड:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 12, 13 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            a: { $trunc: [ "$data", -1 ] },
            b: { $trunc: [ "$data", 0 ] },
            c: { $trunc: [ "$data", 3 ] },
            d: { $trunc: [ "$data", 4 ] },
            e: { $trunc: [ "$data", 5 ] }
          }
     }
   ]
).pretty()

परिणाम:

{
	"data" : NumberDecimal("128.4585"),
	"a" : NumberDecimal("1.2E+2"),
	"b" : NumberDecimal("128"),
	"c" : NumberDecimal("128.458"),
	"d" : NumberDecimal("128.4585"),
	"e" : NumberDecimal("128.45850")
}
{
	"data" : NumberDecimal("128.12345678912"),
	"a" : NumberDecimal("1.2E+2"),
	"b" : NumberDecimal("128"),
	"c" : NumberDecimal("128.123"),
	"d" : NumberDecimal("128.1234"),
	"e" : NumberDecimal("128.12345")
}

शून्य दशमलव स्थानों तक छोटा करना

यदि दूसरा तर्क null है , परिणाम null . है ।

उदाहरण:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data", null ] }
          }
     }
   ]
)

परिणाम:

{ "data" : 8.99, "truncated" : null }
{ "data" : 8.45, "truncated" : null }
{ "data" : 8.451, "truncated" : null }

शून्य मान को छोटा करना

यदि छोटा किया जाने वाला मान null है , परिणाम null . है ।

मान लीजिए कि हम निम्नलिखित दस्तावेज़ को संग्रह में जोड़ते हैं:

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

और हम $trunc . का उपयोग करते हैं शून्य मान को छोटा करने के लिए:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 14 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data", null ] }
          }
     }
   ]
)

परिणाम:

{ "data" : null, "truncated" : null }

इन्फिनिटी को छोटा करना

अगर छोटा किया जाने वाला नंबर Infinity है , परिणाम Infinity . है . इसी तरह, अगर यह -Infinity है , परिणाम -Infinity . है ।

आइए ऐसे मूल्यों के साथ दो दस्तावेज़ जोड़ें:

{ "_id" : 15, "data" : Infinity }
{ "_id" : 16, "data" : -Infinity }

और चलिए उन्हें छोटा करते हैं:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 15, 16 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data", 2 ] }
          }
     }
   ]
)

परिणाम:

{ "data" : Infinity, "truncated" : Infinity }
{ "data" : -Infinity, "truncated" : -Infinity }

NaN को छोटा करना

NaN को छोटा करना NaN में परिणाम ।

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data" * 2 ] }
          }
     }
   ]
)

परिणाम:

{ "data" : 8.99, "truncated" : NaN }
{ "data" : 8.45, "truncated" : NaN }

गैर-संख्यात्मक प्रकार

यदि आप किसी ऐसे मान को छोटा करने का प्रयास करते हैं जो गलत डेटा प्रकार है (अर्थात यह एक पूर्णांक, दोहरा, दशमलव या लंबा नहीं है), तो एक त्रुटि वापस आ जाती है।

मान लीजिए हम अपने संग्रह में निम्नलिखित दस्तावेज़ जोड़ते हैं:

{ "_id" : 17, "data" : "Thirty five" }

और अब हम data . को छोटा करने का प्रयास करते हैं फ़ील्ड:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 17 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data" ] }
          }
     }
   ]
)

परिणाम:

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$trunc only supports numeric types, not string",
	"code" : 51081,
	"codeName" : "Location51081"
} : 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