दिलचस्प पोस्ट
सीएसएस: एक <div> तत्व के भीतर केंद्र तत्व पिछला प्रतिबद्ध करने के लिए Git रिपॉजिटरी को वापस कैसे करें? केवल एक बार एक सत्र की अनुमति दें JDBC और MySQL के साथ एक "संचार लिंक विफलता" सुलझाना MySQL में varchar फ़ील्ड संख्यात्मक रूप से छंटनी SQL सर्वर में फ़ाइलों को संग्रहीत करना केस असंवेदनशील स्ट्रिंग LINQ-to-SQL में तुलना करते हैं "" के बजाय $ _SERVER का उपयोग क्यों करें मल्टी थ्रेडिंग के साथ अस्थिरता का उपयोग कब किया जाए? पायथन में एक एन्क्रिप्टेड ज़िप फ़ाइल बनाएँ क्या आकार (कुछ पॉइंटर) हमेशा चार के बराबर है? एनिमेशन के बिना स्विचन गतिविधियों एनोवा परीक्षा में चिपकाए गए फार्मूले के साथ एलईई फिट बैठता है क्यों स्विच वक्तव्य स्ट्रिंग पर लागू नहीं किया जा सकता है? request.getQueryString () कुछ एन्कोडिंग की आवश्यकता है

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

उदाहरण:

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

वेब के समाधान से एकत्रित समाधान "MongoDB: क्या यह केस-असंवेदनशील क्वेरी करने के लिए संभव है?"

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

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

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

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

अद्यतन करें:

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

मूल उत्तर:

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

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

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

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

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

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

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

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

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

रेगुलर एक्सप्रेशन पर सिंटैक्स सहायता के लिए http://www.regular-expressions.info/ देखें

यदि आपको एक चर से regexp बनाने की आवश्यकता है, तो यह करने का एक बेहतर तरीका है: 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 } ); 

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

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

Mongodb 3.4 के रूप में आपको केस-असंवेदनशील मिलान इंडेक्स का उपयोग करना चाहिए। यह तेजी से बड़े आकार के डेटासेट पर केस-असंवेदनशील खोज करने का सबसे तेज़ तरीका है। मैं इस काम को प्राप्त करने के लिए व्यक्तिगत रूप से एक संस्थापक को ईमेल करता हूं, और उसने ऐसा किया! (यह 5 साल के लिए जीआईआरए पर एक मुद्दा था, और कई ने इस सुविधा का अनुरोध किया है)। यहां देखिए यह कैसे काम करता है:

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

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

या जब आप डेटाबेस को समान बनाते हैं तो आप इसे पूरे संग्रह के लिए कर सकते हैं:

 db.createCollection("Cities",{collation: {locale: "en",strength:2}}); 

और इसे इस तरह प्रयोग करें:

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

यह "न्यूयॉर्क", "न्यू यॉर्क" आदि वापस करेगा।

वैकल्पिक रूप से, जब आप इस तरह से संग्रह करते हैं तो आप सभी इंडेक्सों को डिफ़ॉल्ट रूप से मिलान का उपयोग कर सकते हैं:

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

इस पद्धति का लाभ बहुत अधिक दक्षता और बड़ी डेटासेट पर गति है।

अधिक जानकारी के लिए: https://jira.mongodb.org/browse/SERVER-90 , https://docs.mongodb.com/manual/reference/collation/

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

टी एल; डॉ

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

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

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

चरण 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 :

इंडेक्सिंग क्वेरी के बिना, जो भी TEXT फ़ील्ड आप खोजना चाहते हैं, उस पर सूचकांक बनाने की आवश्यकता बेहद धीमी गति से होगी

 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 

मोंगोज़ का उपयोग करना यह मेरे लिए काम करता है:

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

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

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

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

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

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

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

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

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

 //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" के रूप में विकल्प के रूप में सेट किए गए इनसेंसिव मानदंड के साथ खोज करता है।

शुभकामनाएं।

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

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

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

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

इसके बाद आप केवल एक फ़ील्ड पर फिल्टर कर सकते हैं।

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

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

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

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

 {'_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 

सी # में मेरे लिए एक फिल्टर काम करता है

 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()); 

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

आप केस असंवेदनशील इंडेक्स का उपयोग कर सकते हैं:

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

 /* 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