मोंगोडीबी $लॉग

MongoDB में, $log एकत्रीकरण पाइपलाइन ऑपरेटर निर्दिष्ट आधार में किसी संख्या के लॉग की गणना करता है और परिणाम को डबल के रूप में देता है।

सिंटैक्स

वाक्य रचना इस प्रकार है:

{ $log: [ <number>, <base> ] }

कहां:

• <number> कोई भी मान्य व्यंजक हो सकता है जो एक गैर-ऋणात्मक संख्या का समाधान करता है।
• <base> कोई भी मान्य व्यंजक हो सकता है जो 1 . से बड़ी धनात्मक संख्या का समाधान करता हो ।

उदाहरण

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

{ "_id" : 1, "data" : 0.5 }
{ "_id" : 2, "data" : 20 }
{ "_id" : 3, "data" : 200 }

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

db.test.aggregate(
  [
    { $match: { _id: { $in: [ 1, 2, 3 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", 10 ] }
        }
    }
  ]
)

परिणाम:

{ "data" : 0.5, "result" : -0.30102999566398114 }
{ "data" : 20, "result" : 1.301029995663981 }
{ "data" : 200, "result" : 2.301029995663981 }

ऐसा करने का दूसरा तरीका $log10 . का उपयोग करना होता ऑपरेटर।

हालांकि, $log10 केवल किसी संख्या का लॉग बेस 10 लौटाता है। $log . के साथ , दूसरी ओर, हम उपयोग के लिए आधार निर्दिष्ट कर सकते हैं।

यहां 16 का आधार निर्दिष्ट करने का एक उदाहरण दिया गया है:

db.test.aggregate(
  [
    { $match: { _id: { $in: [ 1, 2, 3 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", 16 ] }
        }
    }
  ]
)

परिणाम:

{ "data" : 0.5, "result" : -0.25 }
{ "data" : 20, "result" : 1.0804820237218407 }
{ "data" : 200, "result" : 1.910964047443681 }

प्राकृतिक लघुगणक

किसी संख्या का प्राकृतिक लघुगणक गणितीय स्थिरांक e के आधार पर उसका लघुगणक है , जहां ई एक अपरिमेय और पारलौकिक संख्या है जो 2.7182818284590452353602874713527 से शुरू होती है और हमेशा के लिए जारी रहती है।

गणितीय स्थिरांक e इसे यूलर संख्या भी कहते हैं।

जावास्क्रिप्ट में, हम Math.E . का उपयोग कर सकते हैं e . का प्रतिनिधित्व करने के लिए . इसलिए हम Math.E . का उपयोग करके किसी संख्या का प्राकृतिक लघुगणक प्राप्त कर सकते हैं $log . का उपयोग करते समय दूसरे तर्क के रूप में ।

उदाहरण:

db.test.aggregate(
  [
    { $match: { _id: { $in: [ 1, 2, 3 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", Math.E ] }
        }
    }
  ]
)

परिणाम:

{ "data" : 0.5, "result" : -0.6931471805599453 }
{ "data" : 20, "result" : 2.995732273553991 }
{ "data" : 200, "result" : 5.298317366548036 }

ध्यान रखें कि MongoDB में $ln . भी है ऑपरेटर, जिसे विशेष रूप से किसी संख्या के प्राकृतिक लघुगणक को वापस करने के लिए डिज़ाइन किया गया है, इसलिए आपको इसके बजाय उस ऑपरेटर का उपयोग करना आसान हो सकता है। MongoDB देखें $ln उदाहरण के लिए।

सीमा मान से बाहर

जैसा कि बताया गया है, $log ऑपरेटर किसी भी मान्य अभिव्यक्ति को स्वीकार करता है जो एक गैर-ऋणात्मक संख्या को हल करता है। उस सीमा से बाहर के मान त्रुटि उत्पन्न करेंगे।

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

{ "_id" : 4, "data" : -20 }

चलिए $log चलाते हैं उस दस्तावेज़ के विरुद्ध ऑपरेटर:

db.test.aggregate(
  [
    { $match: { _id: { $in: [ 4 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", 16 ] }
        }
    }
  ]
)

परिणाम:

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$log's argument must be a positive number, but is -20",
	"code" : 28758,
	"codeName" : "Location28758"
} : 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

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

गलत डेटा प्रकार प्रदान करने से भी त्रुटि होगी।

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

{ "_id" : 5, "data" : "Ten" }

चलिए $log चलाते हैं उस दस्तावेज़ के विरुद्ध ऑपरेटर:

db.test.aggregate(
  [
    { $match: { _id: { $in: [ 5 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", 16 ] }
        }
    }
  ]
)

परिणाम:

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$log's argument must be numeric, not string",
	"code" : 28756,
	"codeName" : "Location28756"
} : 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

हमने एक स्ट्रिंग प्रदान की है, और इसलिए त्रुटि संदेश हमें बताता है कि $log's argument must be numeric, not string ।

शून्य मान

शून्य मान null लौटाते हैं $log . का उपयोग करते समय ऑपरेटर।

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

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

चलिए $log चलाते हैं उस दस्तावेज़ के विरुद्ध ऑपरेटर:

db.test.aggregate(
  [
    { $match: { _id: { $in: [ 6 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", 16 ] }
        }
    }
  ]
)

परिणाम:

{ "data" : null, "result" : null }

हम देख सकते हैं कि परिणाम null है .

NaN मान

अगर तर्क का समाधान NaN . हो जाता है , $log रिटर्न NaN ।

उदाहरण:

db.test.aggregate(
  [
    { $match: { _id: { $in: [ 1 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data" * 1, 16 ] }
        }
    }
  ]
)

परिणाम:

{ "data" : 0.5, "result" : NaN }

गैर-मौजूद फ़ील्ड

अगर $log ऑपरेटर को उस फ़ील्ड के विरुद्ध लागू किया जाता है जो मौजूद नहीं है, null लौटा दिया गया है।

उदाहरण:

db.test.aggregate(
  [
    { $match: { _id: { $in: [ 1 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$age", 16 ] }
        }
    }
  ]
)

परिणाम:

{ "data" : 0.5, "result" : null }

इस मामले में हमने $log . लागू करने का प्रयास किया age . नामक फ़ील्ड के सामने , लेकिन वह फ़ील्ड दस्तावेज़ में मौजूद नहीं है, और इसलिए हमें null . मिलता है ।