मोंगोडीबी $strcasecmp

MongoDB में, $strcasecmp एकत्रीकरण पाइपलाइन ऑपरेटर दो स्ट्रिंग्स की केस-असंवेदनशील तुलना करता है।

यह या तो 1 लौटाता है , 0 , या -1 , इस पर निर्भर करता है कि पहली स्ट्रिंग दूसरी स्ट्रिंग से बड़ी, उसके बराबर या उससे कम है या नहीं।

विशेष रूप से, $strcasecmp रिटर्न:

• 1 अगर पहली स्ट्रिंग दूसरी स्ट्रिंग से बड़ी है
• 0 अगर दोनों तार बराबर हैं
• -1 अगर पहली स्ट्रिंग दूसरी स्ट्रिंग से कम है

उदाहरण

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

{ "_id" : 1, "a" : "abc", "b" : "def" }
{ "_id" : 2, "a" : "abc", "b" : "abc" }
{ "_id" : 3, "a" : "def", "b" : "abc" }
{ "_id" : 4, "a" : "abc", "b" : "cba" }
{ "_id" : 5, "a" : "cba", "b" : "abc" }

यहां बताया गया है कि जब हम $strcasecmp . लागू करते हैं तो क्या होता है उन दस्तावेज़ों के लिए:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
)

परिणाम:

{ "a" : "abc", "b" : "def", "result" : -1 }
{ "a" : "abc", "b" : "abc", "result" : 0 }
{ "a" : "def", "b" : "abc", "result" : 1 }
{ "a" : "abc", "b" : "cba", "result" : -1 }
{ "a" : "cba", "b" : "abc", "result" : 1 }

केस संवेदनशीलता

जैसा कि बताया गया है, $strcasecmp केस-असंवेदनशील तुलना करता है।

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

{ "_id" : 6, "a" : "ABC", "b" : "abc" }

a फ़ील्ड में एक अपरकेस स्ट्रिंग है, और b फ़ील्ड में एक ही स्ट्रिंग है, लेकिन लोअरकेस में।

यहां बताया गया है कि जब हम $strcasecmp . लागू करते हैं तो क्या होता है दोनों क्षेत्रों के लिए:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 6 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
)

परिणाम:

{ "a" : "ABC", "b" : "abc", "result" : 0 }

परिणाम 0 . है , जिसका अर्थ है कि दोनों तार बराबर हैं।

दूसरे शब्दों में, तुलना केस-असंवेदनशील थी।

शून्य मान

$strcasecmp दो शून्य मानों को समान मानता है। साथ ही, एक स्ट्रिंग को null . से बड़ा माना जाता है ।

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

{ "_id" : 7, "a" : "abc", "b" : null }
{ "_id" : 8, "a" : null, "b" : "abc" }
{ "_id" : 9, "a" : null, "b" : null }

यहां बताया गया है कि जब हम $strcasecmp . लागू करते हैं तो क्या होता है उन दस्तावेज़ों के लिए:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 7, 8 ,9 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
)

परिणाम:

{ "a" : "abc", "b" : null, "result" : 1 }
{ "a" : null, "b" : "abc", "result" : -1 }
{ "a" : null, "b" : null, "result" : 0 }

अनुपलब्ध फ़ील्ड

अनुपलब्ध फ़ील्ड का वही प्रभाव होता है जो null . होता है .

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

{ "_id" : 10, "a" : "abc" }
{ "_id" : 11, "b" : "abc" }
{ "_id" : 12 }

यहां बताया गया है कि जब हम $strcasecmp . लागू करते हैं तो क्या होता है उनके लिए:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11, 12 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
)

परिणाम:

{ "a" : "abc", "result" : 1 }
{ "b" : "abc", "result" : -1 }
{ "result" : 0 }

अन्य डेटा प्रकार

अन्य डेटा प्रकारों की तुलना तब तक की जा सकती है, जब तक वे एक स्ट्रिंग को हल कर सकते हैं।

यहां विभिन्न प्रकार के डेटा वाले दस्तावेज़ों का एक समूह दिया गया है:

{ "_id" : 13, "a" : 123, "b" : 456 }
{ "_id" : 14, "a" : 123, "b" : 123 }
{ "_id" : 15, "a" : 456, "b" : 123 }
{ "_id" : 16, "a" : NumberDecimal("123"), "b" : NumberDecimal("456") }
{ "_id" : 17, "a" : NumberDecimal("123"), "b" : NumberDecimal("123") }
{ "_id" : 18, "a" : NumberDecimal("456"), "b" : NumberDecimal("123") }
{ "_id" : 19, "a" : ISODate("1999-01-03T23:30:15.100Z"), "b" : "2000-01-03T23:30:15.100Z" }
{ "_id" : 20, "a" : ISODate("2000-01-03T23:30:15.100Z"), "b" : "2000-01-03T23:30:15.100Z" }
{ "_id" : 21, "a" : ISODate("2000-01-03T23:30:15.100Z"), "b" : "1999-01-03T23:30:15.100Z" }

और यहां बताया गया है कि जब हम $strcasecmp . लागू करते हैं तो क्या होता है उन दस्तावेज़ों के लिए:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15, 16, 17, 18, 19, 20, 21 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
).pretty()

परिणाम:

{ "a" : 123, "b" : 456, "result" : -1 }
{ "a" : 123, "b" : 123, "result" : 0 }
{ "a" : 456, "b" : 123, "result" : 1 }
{ "a" : NumberDecimal("123"), "b" : NumberDecimal("456"), "result" : -1 }
{ "a" : NumberDecimal("123"), "b" : NumberDecimal("123"), "result" : 0 }
{ "a" : NumberDecimal("456"), "b" : NumberDecimal("123"), "result" : 1 }
{
	"a" : ISODate("1999-01-03T23:30:15.100Z"),
	"b" : "2000-01-03T23:30:15.100Z",
	"result" : -1
}
{
	"a" : ISODate("2000-01-03T23:30:15.100Z"),
	"b" : "2000-01-03T23:30:15.100Z",
	"result" : 0
}
{
	"a" : ISODate("2000-01-03T23:30:15.100Z"),
	"b" : "1999-01-03T23:30:15.100Z",
	"result" : 1
}