MongoDB: क्या केस-असंवेदनशील क्वेरी करना संभव है?

Question

उदाहरण:

> db.stuff.save({"foo":"bar"});

> db.stuff.find({"foo":"bar"}).count();
1
> db.stuff.find({"foo":"BAR"}).count();
0

Comments

MongoDB 3.2 के बाद से आप केस-असंवेदनशील खोज को अंजाम दे सकते हैं $caseSensitive: false। देखें: docs.mongodb.org/manual/reference/operator/query/text/…

— martin

ध्यान दें कि यह केवल टेक्स्ट इंडेक्स पर है।

— विलेम डी'हैसेलेर

@ स्मार्टिन: $caseSensitiveपहले से ही डिफ़ॉल्ट रूप से गलत है, और यह सवाल का जवाब नहीं देता है, क्योंकि यह केवल अनुक्रमित क्षेत्रों पर काम करता है। ओपी केस-असंवेदनशील स्ट्रिंग तुलना की तलाश में था।

— दान डैस्कलेस्कु

Answer 1

आप एक regex का उपयोग कर सकते हैं ।

आपके उदाहरण में यह होगा:

db.stuff.find( { foo: /^bar$/i } );

मुझे कहना होगा, हालांकि, हो सकता है कि आप हर बार मिलने वाली अतिरिक्त लागत को वसूलने के बजाय रास्ते में मूल्य को कम (या ऊपर) कर सकें। जाहिर है यह अभ्यस्त लोगों के नामों और इस तरह के काम करते हैं, लेकिन शायद टैग जैसे मामलों का उपयोग करते हैं।

Comments

यह पूरी तरह से काम करता है। समझे कि यह PHP में काम कर रहा है: $ संग्रह-> (सरणी ('कुंजी' => नया MongoRegex ('/' / 'वॉ' '/ i')));

— ल्यूक डेनिस

खासकर यदि आप एक स्ट्रिंग ({foo: / # {x} / i}) को प्रक्षेपित कर रहे हैं जो इसमें एक प्रश्न चिह्न हो सकता है ..

— पीटर एहरलिच

न भूलें ^ ^ और $: MongoRegex ('/ ^'। preg_quote ($ val)। '$ / i')

— Julien

ध्यान दें कि यह सूचकांक का उपयोग करने के बजाय एक फुलस्कैन करेगा।

— मार्टिन कोनिसक

यह एक फुलस्कैन नहीं करेगा यदि वह शुरुआत में ^ एंकर का उपयोग करता है, इसलिए जूलियन की सलाह का महत्व है।

— पैक्स

Answer 2

अपडेट करें:

मूल उत्तर अब अप्रचलित है। Mongodb अब कई विशेषताओं के साथ उन्नत पूर्ण पाठ खोज का समर्थन करता है।

मूल ANSWER:

यह ध्यान दिया जाना चाहिए कि रेगेक्स के मामले को असंवेदनशील / i के साथ खोजने का मतलब है कि मोंगोडब सूचकांक द्वारा खोज नहीं कर सकता है, इसलिए बड़े डेटासेट के खिलाफ प्रश्नों में लंबा समय लग सकता है।

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

एक विकल्प के रूप में, आप एक अपरकेस कॉपी कर सकते हैं और उस के खिलाफ खोज कर सकते हैं। उदाहरण के लिए, मेरे पास एक उपयोगकर्ता तालिका है जिसमें एक उपयोगकर्ता नाम है जो मिश्रित मामला है, लेकिन आईडी उपयोगकर्ता नाम की एक बड़ी प्रतिलिपि है। यह सुनिश्चित करता है कि केस-सेंसिटिव डुप्लीकेशन असंभव है ("फू" और "फू" दोनों की अनुमति नहीं होगी), और मैं यूजरनेम के लिए केस-इनसेंसिटिव सर्च पाने के लिए id = username.toUpperCase () द्वारा खोज कर सकता हूं।

यदि आपका क्षेत्र बड़ा है, जैसे कि संदेश निकाय, तो डेटा की नक़ल करना शायद एक अच्छा विकल्प नहीं है। मेरा मानना ​​है कि अपाचे ल्यूसिन जैसे विलुप्त इंडेक्स का उपयोग उस मामले में सबसे अच्छा विकल्प है।

Comments

@ डान, केवल जानकारी के लिए, नवीनतम मोंगोडीबी में, "यदि कोई सूचकांक क्षेत्र के लिए मौजूद है, तो MongoDB सूचकांक में मूल्यों के खिलाफ नियमित अभिव्यक्ति से मेल खाता है, जो एक संग्रह स्कैन से तेज हो सकता है।" - docs.mongodb.org/manual/reference/operator/query/regex/…

— Sergiy

डॉक्स को शायद अपडेट कर दिया गया है। वे अब कहते हैं, "केस सेंसिटिव रेगुलर एक्सप्रेशन क्वेश्चन के लिए, अगर कोई इंडेक्स फील्ड के लिए मौजूद है, तो MongoDB इंडेक्स में मौजूद वैल्यूज के खिलाफ रेगुलर एक्सप्रेशन से मेल खाता है, जो कि कलेक्शन स्कैन से तेज हो सकता है।"

— जेफ लुईस

टेक्स्ट इंडेक्स के साथ एक और सीमा यह है कि आपके पास केवल एक संग्रह (कई कॉलम) हो सकते हैं, इसलिए यदि आपको अलग-अलग मामलों के लिए अलग-अलग फ़ील्ड पर खोजों को अलग करने की आवश्यकता नहीं है, तो यह सूट नहीं करता है।

— पॉल ग्रिम्सॉव

@SergiySokolenko: डॉक्स अब कहते हैं ( अनुभाग में अंतिम पैराग्राफ ): "केस असंवेदनशील नियमित अभिव्यक्ति प्रश्न आमतौर पर प्रभावी ढंग से अनुक्रमित का उपयोग नहीं कर सकते हैं। $ रेगेक्स कार्यान्वयन कॉलेशन-अवगत नहीं है और केस-असंवेदनशील इंडेक्स का उपयोग करने में असमर्थ है।"

— डैन डस्केल्सस्कू

इस मामले में पूर्ण-पाठ खोज का उपयोग करना गलत है (और संभावित रूप से खतरनाक ), क्योंकि सवाल केस-असंवेदनशील प्रश्न बनाने के बारे में था, उदाहरण के लिए username: 'bill'मिलान BILLया Bill, पूर्ण-पाठ खोज क्वेरी नहीं, जो कि उपजी शब्दों से भी मेल खाएगी bill, जैसे कि Bills, billedइत्यादि

— डैन डस्केल्सस्कु

Answer 3

यदि आपको एक वैरिएबल से रेगेक्सप बनाने की आवश्यकता है, तो यह करने का एक बेहतर तरीका है: https://stackoverflow.com/a/10728069/309514

फिर आप कुछ ऐसा कर सकते हैं:

var string = "SomeStringToFind";
var regex = new RegExp(["^", string, "$"].join(""), "i");
// Creates a regex of: /^SomeStringToFind$/i
db.stuff.find( { foo: regex } );

इसका लाभ अधिक प्रोग्रामेटिक हो रहा है या यदि आप इसे बहुत अधिक पुन: उपयोग कर रहे हैं, तो आप इसे समय से पहले संकलित करके एक प्रदर्शन को बढ़ावा दे सकते हैं।

Comments

new RegExp("^" + req.params.term.toLowerCase(), "i") यह भी ठीक काम करता है

— ताहिर यासीन

यदि आप चर अनुरोध से आते हैं तो आपको सुरक्षा बढ़ाने के लिए स्ट्रिंग से बचने पर विचार करना चाहिए: stackoverflow.com/a/50633536/5195127

— davidivad

MongoDB 3.4 के साथ शुरू, केस

— इन्सेंसिटिव

Answer 4

ध्यान रखें कि पिछला उदाहरण:

db.stuff.find( { foo: /bar/i } );

बार (बार 1, बारक्सीज़, ओपनबार) से मिलान करने के लिए बार युक्त हर प्रविष्टियाँ का कारण होगा , यह किसी उपयोगकर्ता के लिए किसी फ़ंक्शन पर खोज के लिए बहुत खतरनाक हो सकता है ...

आपको उपयुक्त regexp सिंटैक्स का उपयोग करके इसे केवल खोज शब्द से मेल खाने की आवश्यकता हो सकती है:

db.stuff.find( { foo: /^bar$/i } );

देखें http://www.regular-expressions.info/ नियमित अभिव्यक्ति पर वाक्य रचना की मदद के लिए

Comments

यह उत्तर एक टिप्पणी की तरह लगता है।

— डेन डैस्कलेस्कु

Answer 5

MongoDB 3.4 के साथ शुरू, तेजी से केस-असंवेदनशील खोजों को करने के लिए अनुशंसित तरीका केस असंवेदनशील सूचकांक का उपयोग करना है ।

मैंने व्यक्तिगत रूप से संस्थापकों में से एक को यह काम करने के लिए ईमेल किया, और उसने ऐसा किया! यह 2009 से जेआईआरए पर एक मुद्दा था , और कई लोगों ने इस सुविधा का अनुरोध किया है। यहां देखिए यह कैसे काम करता है:

एक केस-असंवेदनशील इंडेक्स 1 या 2 की ताकत के साथ टकराव को निर्दिष्ट करके बनाया गया है । आप इस तरह एक केस-असंवेदनशील इंडेक्स बना सकते हैं:

db.cities.createIndex(
  { city: 1 },
  { 
    collation: {
      locale: 'en',
      strength: 2
    }
  }
);

जब आप उन्हें बनाते हैं तो आप प्रति संग्रह एक डिफ़ॉल्ट कोलाजेशन भी निर्दिष्ट कर सकते हैं:

db.createCollection('cities', { collation: { locale: 'en', strength: 2 } } );

या तो मामले में, केस-असंवेदनशील इंडेक्स का उपयोग करने के लिए, आपको findऑपरेशन में उसी कोलाज को निर्दिष्ट करने की आवश्यकता है जो इंडेक्स या संग्रह बनाते समय उपयोग किया गया था:

db.cities.find(
  { city: 'new york' }
).collation(
  { locale: 'en', strength: 2 }
);

इससे "न्यूयॉर्क", "न्यू यॉर्क", "न्यू यॉर्क" आदि वापस आ जाएंगे।

अन्य नोट

• पूर्ण-पाठ खोज का उपयोग करने का सुझाव देने वाले उत्तर इस मामले में गलत हैं (और संभावित रूप से खतरनाक )। सवाल एक केस-संवेदी क्वेरी, जैसे बनाने के बारे में था username: 'bill'मिलान BILLया Billनहीं, एक पूर्ण-पाठ खोज क्वेरी, जो भी मैच होगा उपजी के शब्दों billजैसे, Bills, billedआदि

• नियमित अभिव्यक्तियों का उपयोग करने के सुझाव देने वाले उत्तर धीमे हैं, क्योंकि अनुक्रमित के साथ भी, दस्तावेज़ में कहा गया है :

  "केस असंवेदनशील नियमित अभिव्यक्ति प्रश्न आम तौर पर प्रभावी ढंग से अनुक्रमित का उपयोग नहीं कर सकते हैं। $ रेगेक्स कार्यान्वयन टक्कर-जागरूक नहीं है और केस-असंवेदनशील अनुक्रमित का उपयोग करने में असमर्थ है।"

  $regexउत्तर भी उपयोगकर्ता इनपुट इंजेक्शन के जोखिम को चलाते हैं ।

Comments

एकत्रीकरण पाइपलाइन के साथ भी मेरे लिए बहुत अच्छा काम किया।

— Morio

मुझे लगता है कि यह सही उत्तर है, क्योंकि डेटा पढ़ने की गति महत्वपूर्ण है

— रैंडमैक्स

इसे बनाने के बाद मुझे किसी संग्रह में डिफ़ॉल्ट रूप से जोड़ने का कोई तरीका नहीं मिल सकता है। क्या ऐसा करने का कोई तरीका है?

— अतुल्य

Answer 6

db.zipcodes.find({city : "NEW YORK"}); // Case-sensitive
db.zipcodes.find({city : /NEW york/i}); // Note the 'i' flag for case-insensitivity

Comments

@ ओलेगवी.वॉल्कोव के पास इस बारे में विवरण होना चाहिए कि आपका उत्तर कैसे उपयुक्त है और प्रश्नकर्ता कोड में क्या गलत है।

— पार्थ त्रिवेदी

यह कोड-ओनली उत्तर स्वीकार किए गए कुछ को जोड़ता नहीं है, जिसे 6 साल पहले पोस्ट किया गया था।

— डैन डैस्केल्स्कु

Answer 7

टी एल; डॉ

मोंगो में ऐसा करने का सही तरीका

RegExp का उपयोग न करें

प्राकृतिक जाओ और mongodb की इनबिल्ट इंडेक्सिंग, खोज का उपयोग करें

चरण 1 :

db.articles.insert(
   [
     { _id: 1, subject: "coffee", author: "xyz", views: 50 },
     { _id: 2, subject: "Coffee Shopping", author: "efg", views: 5 },
     { _id: 3, subject: "Baking a cake", author: "abc", views: 90  },
     { _id: 4, subject: "baking", author: "xyz", views: 100 },
     { _id: 5, subject: "Café Con Leche", author: "abc", views: 200 },
     { _id: 6, subject: "Сырники", author: "jkl", views: 80 },
     { _id: 7, subject: "coffee and cream", author: "efg", views: 10 },
     { _id: 8, subject: "Cafe con Leche", author: "xyz", views: 10 }
   ]
)

चरण 2 :

इनमें से जो भी पर सूचकांक बनाने की जरूरत पाठ क्षेत्र आप खोजना चाहते हैं, बिना अनुक्रमण क्वेरी बेहद धीमी गति से हो जाएगा

db.articles.createIndex( { subject: "text" } )

चरण 3 :

db.articles.find( { $text: { $search: "coffee",$caseSensitive :true } } )  //FOR SENSITIVITY
db.articles.find( { $text: { $search: "coffee",$caseSensitive :false } } ) //FOR INSENSITIVITY

Comments

अच्छा विकल्प, लेकिन रेगेक्स बनाम टेक्स्ट इंडेक्स का उपयोग करने के बारे में अधिक "सही" नहीं है, यह सिर्फ एक और विकल्प है। यह ओपी के मामले के लिए overkill है।

— जॉनीएचके

रेगेक्स को छोड़कर काफी धीमी है। फुलटेक्स्ट सर्चिंग भी धीमी है, लेकिन उतनी धीमी नहीं है। सबसे तेज़ (लेकिन अधिक फूला हुआ) तरीका एक अलग क्षेत्र होगा जो हमेशा लोअरकेस में सेट होता है।

— टॉम मेट्टैम

इस मामले में पूर्ण-पाठ खोज का उपयोग करना गलत है (और संभावित रूप से खतरनाक ), क्योंकि सवाल केस-असंवेदनशील प्रश्न बनाने के बारे में था, उदाहरण के लिए username: 'bill'मिलान BILLया Bill, पूर्ण-पाठ खोज क्वेरी नहीं, जो कि उपजी शब्दों से भी मेल खाएगी bill, जैसे कि Bills, billedइत्यादि

— डैन डस्केल्सस्कु

Answer 8

db.company_profile.find({ "companyName" : { "$regex" : "Nilesh" , "$options" : "i"}});

Comments

क्या आपने इसे पोस्ट करने से पहले मौजूदा उत्तरों को देखा है? एक अर्ध-डुप्लिकेट कोड-केवल उत्तर के बजाय, आप यह समझाना चाहते हैं कि पिछले उत्तरों की तुलना में यह कुछ मूल्य कैसे जोड़ सकता है।

— डैन डस्केल्सस्कू

मैं बस यह जोड़ना चाहता हूं कि यह उत्तर मुझे एक समाधान के लिए मिला है। मैं एक PHP फ्रेमवर्क का उपयोग कर रहा हूं और यह ओआरएम सिंटैक्स में अच्छी तरह से फिट है जबकि अन्य समाधान यहां नहीं थे। $existing = Users::masterFind('all', ['conditions' => ['traits.0.email' => ['$regex' => "^$value$", '$options' => 'i']]]);

— 17:12 पर डॉन Rzeszut

Answer 9

मोंगो (वर्तमान संस्करण 2.0.0) अनुक्रमित क्षेत्रों के खिलाफ केस-असंवेदनशील खोजों की अनुमति नहीं देता है - उनके प्रलेखन देखें । गैर-अनुक्रमित क्षेत्रों के लिए, अन्य उत्तरों में सूचीबद्ध रेग्जेस ठीक होना चाहिए।

Comments

बस इसे स्पष्ट करने के लिए: अनुक्रमित फ़ील्ड पर केस-असंवेदनशील खोजों की अनुमति है , वे सिर्फ इंडेक्स का उपयोग नहीं करेंगे और उतना ही धीमा होगा जितना कि फ़ील्ड इंडेक्स नहीं किया गया था।

— भारी

@ heavi5ide चूंकि इस प्रश्न का उपयोग डुप्लिकेट को चिह्नित करने के लिए किया जा रहा है मैंने सोचा कि मैं स्पष्ट कर दूंगा कि regexes (केस असंवेदनशील खोजों के लिए आवश्यक) सूचकांक का उपयोग करते हैं, हालांकि, उन्हें पूर्ण सूचकांक स्कैन करना होगा। दूसरे शब्दों में वे कुशलता से सूचकांक का उपयोग नहीं कर सकते हैं । सौभाग्य से प्रलेखन 2011 से अद्यतन किया गया है, लेकिन अभी भी यहाँ ध्यान दें अच्छा है।

— सम्मे

Answer 10

रेगेक्स आधारित क्वेरी का उपयोग करते समय एक बहुत महत्वपूर्ण बात ध्यान में रखें - जब आप एक लॉगिन सिस्टम के लिए ऐसा कर रहे हैं, तो अपने द्वारा खोजे जा रहे हर एक वर्ण से बचें , और ^ और $ ऑपरेटरों को न भूलें। इसके लिए लोदाश का एक अच्छा कार्य है , क्या आपको इसका उपयोग पहले से ही करना चाहिए:

db.stuff.find({$regex: new RegExp(_.escapeRegExp(bar), $options: 'i'})

क्यों? किसी उपयोगकर्ता .*को उसके उपयोगकर्ता नाम के रूप में दर्ज करने की कल्पना करें । यह सभी उपयोगकर्ता नाम से मेल खाता है, किसी भी उपयोगकर्ता के पासवर्ड का अनुमान लगाकर लॉगिन को सक्षम करेगा।

Answer 11

सबसे अच्छी विधि आपकी पसंद की भाषा में है, जब अपनी वस्तुओं के लिए एक मॉडल रैपर बनाते हैं, तो अपने सेव () विधि को खेतों के एक सेट के माध्यम से पुनरावृत्त करें जिसे आप खोज रहे होंगे उस पर भी अनुक्रमित हैं; खेतों के उन सेटों में निचले हिस्से के समकक्ष होने चाहिए जिन्हें खोज के लिए उपयोग किया जाता है।

हर बार जब ऑब्जेक्ट फिर से सहेजा जाता है, तो लोअरकेस गुण फिर से जांचे जाते हैं और मुख्य गुणों में किसी भी बदलाव के साथ अपडेट किए जाते हैं। इससे आप इसे कुशलता से खोज सकते हैं, लेकिन हर बार lc फ़ील्ड को अपडेट करने के लिए आवश्यक अतिरिक्त कार्य को छिपा सकते हैं।

निचला मामला फ़ील्ड एक कुंजी हो सकता है: मान ऑब्जेक्ट स्टोर या बस उपसर्ग lc_ के साथ फ़ील्ड नाम। मैं क्वेरी को सरल बनाने के लिए दूसरे का उपयोग करता हूं (गहरी ऑब्जेक्ट क्वेरी कई बार भ्रमित हो सकती है)।

ध्यान दें: आप lc_ फ़ील्ड्स को इंडेक्स करना चाहते हैं, न कि मुख्य फ़ील्ड्स जो वे आधारित हैं।

Comments

अच्छा समाधान लेकिन सौभाग्य से MongoDB 3.4 के साथ शुरू, केस इनसेंसिटिव इंडेक्स के लिए मूल समर्थन है ।

— डैन डस्केल्सस्कु

Answer 12

मान लीजिए कि आप "तालिका" में "कॉलम" खोजना चाहते हैं और आप चाहते हैं कि मामला असंवेदनशील हो। सबसे अच्छा और कुशल तरीका नीचे दिया गया है;

//create empty JSON Object
mycolumn = {};

//check if column has valid value
if(column) {
    mycolumn.column = {$regex: new RegExp(column), $options: "i"};
}
Table.find(mycolumn);

उपरोक्त कोड केवल RegEx के रूप में आपके खोज मूल्य को जोड़ता है और विकल्प के रूप में "i" के साथ सेट किए गए असंवेदनशील मानदंड के साथ खोज करता है।

शुभकामनाएं।

Answer 13

मेरे लिए काम कर रहे Mongoose का उपयोग करना:

var find = function(username, next){
    User.find({'username': {$regex: new RegExp('^' + username, 'i')}}, function(err, res){
        if(err) throw err;
        next(null, res);
    });
}

Comments

.toLowerCase()यदि आप केस के असंवेदनशील झंडे को निर्दिष्ट कर रहे हैं तो क्या यह बेमानी नहीं है i?

— k00k

हाँ यही है। आपको .toLowerCase () की आवश्यकता नहीं है। मैंने इसे जवाब से हटा दिया है।

— क्रिसरिच

हम्म इस तरह काम करना चाहिए? जब मैं "चिह्न" की खोज करता हूं, तो यह "मार्को" के साथ हर रिकॉर्ड भी प्राप्त करता है - क्या केवल मामला-संवेदनशीलता को अनदेखा करने का एक तरीका है?

— सूइस

ठीक है, यह पाया गया कि सही रेगेक्स होगा: '^' + serach_name + '$', "i"

— Suisse

यह खतरनाक है। आप उपयोगकर्ता नाम से बच नहीं रहे हैं, इसलिए किसी भी मनमाने रीजेक्स को इंजेक्ट किया जा सकता है।

— टॉम मेट्टैम

Answer 14

एकत्रीकरण रूपरेखा को मंगोडब 2.2 में पेश किया गया था। स्ट्रिंग के बीच केस-असंवेदनशील तुलना करने के लिए आप स्ट्रिंग ऑपरेटर "$ strcasecmp" का उपयोग कर सकते हैं। रेगेक्स का उपयोग करने की तुलना में यह अधिक अनुशंसित और आसान है।

यहाँ एकत्रीकरण कमांड ऑपरेटर पर आधिकारिक दस्तावेज है: https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#exp._S_strcasecmp ।

Comments

इसे एक खोज () क्वेरी में कैसे उपयोग करें? db.stuff.find ({नाम: $ strcasecmp (नाम)})?

— सूइस

Answer 15

आप केस इन्सेंसिटिव इंडेक्स का उपयोग कर सकते हैं :

निम्न उदाहरण कोई डिफ़ॉल्ट टकराव के साथ एक संग्रह बनाता है, फिर नाम क्षेत्र पर एक असंवेदनशील टकराव के साथ एक सूचकांक जोड़ता है। यूनिकोड के लिए अंतर्राष्ट्रीय घटक

/* strength: CollationStrength.Secondary
* Secondary level of comparison. Collation performs comparisons up to secondary * differences, such as diacritics. That is, collation performs comparisons of 
* base characters (primary differences) and diacritics (secondary differences). * Differences between base characters takes precedence over secondary 
* differences.
*/
db.users.createIndex( { name: 1 }, collation: { locale: 'tr', strength: 2 } } )

इंडेक्स का उपयोग करने के लिए, प्रश्नों को एक ही कोलाज निर्दिष्ट करना होगा।

db.users.insert( [ { name: "Oğuz" },
                            { name: "oğuz" },
                            { name: "OĞUZ" } ] )

// does not use index, finds one result
db.users.find( { name: "oğuz" } )

// uses the index, finds three results
db.users.find( { name: "oğuz" } ).collation( { locale: 'tr', strength: 2 } )

// does not use the index, finds three results (different strength)
db.users.find( { name: "oğuz" } ).collation( { locale: 'tr', strength: 1 } )

या आप डिफ़ॉल्ट टकराव के साथ एक संग्रह बना सकते हैं:

db.createCollection("users", { collation: { locale: 'tr', strength: 2 } } )
db.users.createIndex( { name : 1 } ) // inherits the default collation

Comments

लगता है कि मामूली वाक्यविन्यास समस्या (लापता ब्रेसेस)। कृपया क्वेरी को अपडेट करें: db.users.createIndex( { name: 1 }, {collation: { locale: 'tr', strength: 2 } } )

— मोहम्मद बेलाल

Answer 16

एक चर खोजने और इससे बचने के लिए:

const escapeStringRegexp = require('escape-string-regexp')
const name = 'foo'
db.stuff.find({name: new RegExp('^' + escapeStringRegexp(name) + '$', 'i')})   

वेरिएबल से बचकर '*। * या अन्य रेगेक्स के साथ हमलों के खिलाफ क्वेरी की रक्षा करता है।

भागने-स्ट्रिंग-regexp

Answer 17

RegExp का उपयोग करें , यदि कोई अन्य विकल्प आपके लिए काम नहीं करता है, तो RegExp एक अच्छा विकल्प है। यह स्ट्रिंग केस को असंवेदनशील बनाता है।

var username = new RegExp("^" + "John" + "$", "i");;

प्रश्नों में उपयोगकर्ता नाम का उपयोग करें, और फिर किया।

मुझे उम्मीद है कि यह आपके लिए भी काम करेगा। शुभकामनाएं।

Answer 18

मैंने केस असंवेदनशील रेगेक्स के लिए एक साधारण फंक बनाया है, जिसका उपयोग मैं अपने फिल्टर में करता हूं।

private Func<string, BsonRegularExpression> CaseInsensitiveCompare = (field) => 
            BsonRegularExpression.Create(new Regex(field, RegexOptions.IgnoreCase));

फिर आप बस एक फ़ील्ड पर निम्नानुसार फ़िल्टर करें।

db.stuff.find({"foo": CaseInsensitiveCompare("bar")}).count();

Answer 19

फ़िल्टर का उपयोग करना मेरे लिए C # में काम करता है।

string s = "searchTerm";
    var filter = Builders<Model>.Filter.Where(p => p.Title.ToLower().Contains(s.ToLower()));
                var listSorted = collection.Find(filter).ToList();
                var list = collection.Find(filter).ToList();

यह इंडेक्स का उपयोग भी कर सकता है क्योंकि मेरा मानना ​​है कि रिटर्न होने के बाद तरीकों को बुलाया जाता है लेकिन मैंने अभी तक इसका परीक्षण नहीं किया है।

यह भी की एक समस्या से बचा जाता है

var filter = Builders<Model>.Filter.Eq(p => p.Title.ToLower(), s.ToLower());

वह मोंगोडब p.Title.ToLower () एक संपत्ति है और ठीक से नक्शा नहीं होगा।

Comments

धन्यवाद, यह मेरे लिए काम करता है। यहां हमें चर में फिल्टर प्राप्त करने की आवश्यकता है फिर फाइंड () विधि में पास करें।

— निलय

Answer 20

गोलंग का उपयोग करने वाले किसी भी व्यक्ति के लिए मोंगोडब और मैगो गोडॉक ग्लोबालसाइन लाइब्रेरी के साथ केस सेंसिटिव फुल टेक्स्ट सर्च होना चाहिए ।

collation := &mgo.Collation{
    Locale:   "en",
    Strength: 2, 
}


err := collection.Find(query).Collation(collation)

Answer 21

जैसा कि आप मोंगो डॉक्स में देख सकते हैं - चूंकि संस्करण 3.2 $textइंडेक्स डिफ़ॉल्ट रूप से केस-इनसेन्सिटिव है: https://docs.mongodb.com/manual/core/index-text/#text-index-case-ins संवेदनशीलता

एक टेक्स्ट इंडेक्स बनाएं और अपनी क्वेरी में $ टेक्स्ट ऑपरेटर का उपयोग करें ।

Comments

इस मामले में पूर्ण-पाठ खोज का उपयोग करना गलत है (और संभावित रूप से खतरनाक ), क्योंकि सवाल केस-असंवेदनशील प्रश्न बनाने के बारे में था, उदाहरण के लिए username: 'bill'मिलान BILLया Bill, पूर्ण-पाठ खोज क्वेरी नहीं, जो कि उपजी शब्दों से भी मेल खाएगी bill, जैसे कि Bills, billedइत्यादि

— डैन डैस्कलेस्क्यू

Answer 22

इनका परीक्षण स्ट्रिंग खोजों के लिए किया गया है

{'_id': /.*CM.*/}               ||find _id where _id contains   ->CM
{'_id': /^CM/}                  ||find _id where _id starts     ->CM
{'_id': /CM$/}                  ||find _id where _id ends       ->CM

{'_id': /.*UcM075237.*/i}       ||find _id where _id contains   ->UcM075237, ignore upper/lower case
{'_id': /^UcM075237/i}          ||find _id where _id starts     ->UcM075237, ignore upper/lower case
{'_id': /UcM075237$/i}          ||find _id where _id ends       ->UcM075237, ignore upper/lower case

Answer 23

मैंने एक ऐसे ही मुद्दे का सामना किया था और यह मेरे लिए काम कर रहा है:

  const flavorExists = await Flavors.findOne({
    'flavor.name': { $regex: flavorName, $options: 'i' },
  });

Comments

यह समाधान पहले भी दो बार दिया जा चुका था। कृपया नया पोस्ट करने से पहले मौजूदा उत्तरों की जाँच करें।

— डैन डस्केल्सस्कू

@DanDascalescu को यकीन नहीं है कि आप किस बारे में बात कर रहे हैं, CTRL + F पर, इसी तरह के कई समाधानों के साथ इसे सितंबर 2018 को पोस्ट किया गया। मैंने अपना जवाब अप्रैल 2018 पोस्ट किया। मैंने वास्तव में इसे पोस्ट किया है क्योंकि उस समय कोई नहीं है। कृपया यह भी जांचें कि यह चेतावनी देने से पहले पोस्ट किया गया था, जो वास्तव में मदद करने की कोशिश करते हैं।

— वोपी

मैं अप्रैल 2016 से इस उत्तर के बारे में बात कर रहा हूं , और मई 2016 से यह उत्तर । दोनों का उपयोग करें $regexऔर $options। आपने Ctrl + F क्या किया?

— डेन डैस्कलेस्क्यू

साथ ही, प्रयोग $regexकरना अक्षम और संभावित असुरक्षित है, जैसा कि मैंने अपने संपादन में 2016 के अन्य उत्तर में समझाया है । यदि वे अब समुदाय की सेवा नहीं करते हैं, तो जवाबों को हटाने में कोई शर्म नहीं है!

— डेन डैस्कलेस्क्यू

अक्षम $ रेगेक्स पर ध्यान दिया गया, बहुत बहुत धन्यवाद। I Ctrl + F $ विकल्प। हम अपने $ रेगेक्स कोड, अप्रैल 2018 और सितंबर 2018 में नए रेगेक्सप के साथ केवल दो ही हैं। मैंने अपने उत्तर में नए रेगेक्सपी का उपयोग नहीं किया। मैं नए Regexp के साथ मेरे पास मौजूद विशिष्ट समस्या को भूल गया जब मैंने इसे हटा दिया और इस समाधान का उपयोग किया जो मैंने इसके बजाय पोस्ट किया था।

— वोपी