इस ट्यूटोरियल के लिए हम official dummy dataset का उपयोग करेंगे , जिसमें न्यूयॉर्क क्षेत्र के आसपास के कई रेस्तरां दस्तावेज़ शामिल हैं।
.findOne() . का उपयोग करते हुए, इस संग्रह में मूल दस्तावेज़ संरचना का एक उदाहरण यहां दिया गया है विधि:
> db.restaurants.findOne()
{
"_id" : ObjectId("56c651e7d84ccfde319961af"),
"address" : {
"building" : "469",
"coord" : [
-73.961704,
40.662942
],
"street" : "Flatbush Avenue",
"zipcode" : "11225"
},
"borough" : "Brooklyn",
"cuisine" : "Hamburgers",
"grades" : [
{
"date" : ISODate("2014-12-30T00:00:00Z"),
"grade" : "A",
"score" : 8
},
{
"date" : ISODate("2014-07-01T00:00:00Z"),
"grade" : "B",
"score" : 23
},
{
"date" : ISODate("2013-04-30T00:00:00Z"),
"grade" : "A",
"score" : 12
},
{
"date" : ISODate("2012-05-08T00:00:00Z"),
"grade" : "A",
"score" : 12
}
],
"name" : "Wendy'S",
"restaurant_id" : "30112340"
}
दि पावर ऑफ फाइंड
MongoDB संग्रह में खोज करते समय पहेली का सबसे महत्वपूर्ण हिस्सा सरल लेकिन लचीला है db.collection.find() विधि।
.find() . के साथ , आप कुछ सरल पैरामीटर पास करके दस्तावेज़ों के संग्रह को आसानी से क्वेरी कर सकते हैं, और एक cursor लौटा सकते हैं . एक cursor बस एक परिणाम सेट है और इसे cursor द्वारा इंगित किए जा रहे दस्तावेज़ों में हेरफेर करने या अन्यथा उपयोग करने के लिए पुनरावृत्त किया जा सकता है ।
.find() . के एक साधारण उदाहरण के रूप में कार्रवाई में विधि, हम अपने संग्रह में सभी रेस्तरां खोजने का प्रयास करेंगे जो सर्वर Hamburgers उनके cuisine . के रूप में :
>db.restaurants.find( { cuisine: "Hamburgers" } )
{ "_id" : ObjectId("56c651e7d84ccfde319961af"), "address" : { "building" : "469", "coord" : [ -73.961704, 40.662942 ], "street" : "Flatbush Avenue", "zipcode" : "11225" }, "borough" : "Brooklyn", "cuisine" : "Hamburgers", "grades" : [ { "date" : ISODate("2014-12-30T00:00:00Z"), "grade" : "A", "score" : 8 }, { "date" : ISODate("2014-07-01T00:00:00Z"), "grade" : "B", "score" : 23 }, { "date" : ISODate("2013-04-30T00:00:00Z"), "grade" : "A", "score" : 12 }, { "date" : ISODate("2012-05-08T00:00:00Z"), "grade" : "A", "score" : 12 } ], "name" : "Wendy'S", "restaurant_id" : "30112340" }
...
परिणाम सेट काफी बड़ा है, इसलिए हमारे परीक्षण उदाहरणों के लिए एक बेहतर माप .count() को श्रृंखलाबद्ध करना होगा .find() . पर विधि यह देखने के लिए कि कितने दस्तावेज़ हमारी क्वेरी से मेल खाते हैं:
> db.restaurants.find( { cuisine: "Hamburgers" } ).count()
433
यह बहुत सारे बर्गर हैं!
Regex का उपयोग करके शब्द समानताएं खोजना
अब जब हम .find() . का उपयोग कर रहे हैं हमारे संग्रह को क्वेरी करने के लिए, हम वास्तव में अपने सिंटैक्स को कभी भी थोड़ा संशोधित कर सकते हैं और ऐसे शब्द या वाक्यांश के आधार पर मिलान खोजना शुरू कर सकते हैं जो आंशिक हो सकता है किसी दिए गए फ़ील्ड में LIKE . के समान मिलान करें SQL इंजन के लिए ऑपरेटर।
ट्रिक regular expressions का उपयोग करना है (या regex संक्षेप में), जो मूल रूप से एक टेक्स्ट स्ट्रिंग है जो एक खोज पैटर्न को परिभाषित करता है। कई regex हैं इंजन जो थोड़े अलग सिंटैक्स में लिखे गए हैं, लेकिन मूल सिद्धांत सभी मूल रूप से समान हैं, और इस मामले में, MongoDB Perl Regex (PCRE) का उपयोग करता है। इंजन।
सबसे बुनियादी स्तर पर, एक regex अभिव्यक्ति एक स्ट्रिंग (वर्णों की श्रृंखला) है जो दोनों तरफ एक ही स्लैश (/ द्वारा संलग्न है) )।
उदाहरण के लिए, यदि हम regex . का उपयोग करना चाहते हैं ऊपर के समान क्वेरी करने के लिए और पता करें कि कितने रेस्तरां Hamburgers परोसते हैं , हम अपनी स्ट्रिंग "Hamburgers" . को बदल सकते हैं /Hamburgers/ . के साथ इसके बजाय:
> db.restaurants.find( { cuisine: /Hamburgers/ } ).count()
433
उत्सुक पर्यवेक्षक यह मान सकते हैं कि हमने वास्तविक क्वेरी के बारे में प्रभावी रूप से कुछ भी नहीं बदला है - हम अभी भी केवल उन सभी दस्तावेज़ों को देख रहे हैं जहां cuisine फ़ील्ड बराबर . है स्ट्रिंग "Hamburgers" ।
उस ने कहा, बस regex . का उपयोग करके सामान्य "उद्धृत स्ट्रिंग" के बजाय, हम आंशिक शब्द/वाक्यांश मिलान की तलाश शुरू कर सकते हैं इसके बजाय।
उदाहरण के लिए, आइए borough . देखें यह कैसे काम करता है इसका एक बेहतर विचार प्राप्त करने के लिए क्षेत्र। पहले हम देखेंगे कि हमारे संग्रह में कुल छह नगर हैं:
> db.restaurants.distinct('borough')
[
"Brooklyn",
"Bronx",
"Manhattan",
"Queens",
"Staten Island",
"Missing"
]
आइए अब regex . का उपयोग करें Bronx . में यह पता लगाने के लिए कि कितने रेस्तरां हैं नगर:
> db.restaurants.find( { borough: /Bronx/ } ).count()
2338
लेकिन कल्पना कीजिए कि हम ऐसे रेस्तरां की संख्या ज्ञात करना चाहते हैं जहां borough से शुरू होता है पहले तीन अक्षर "Bro" . हम अपने regex . को संशोधित करेंगे बहुत थोड़ा, ऐसा:
> db.restaurants.find( { borough: /^Bro/ } ).count()
8424
हम इस परिणाम सेट में 6000 से अधिक अतिरिक्त दस्तावेज़ देख रहे हैं, जो समझ में आता है क्योंकि न केवल हमें ऐसे परिणाम मिल रहे हैं जहां borough "Bronx" . है , लेकिन "Brooklyn" . के लिए भी सब कुछ साथ ही।
कैरेट कैरेक्टर (^ ) हमारे स्ट्रिंग में स्थान निर्दिष्ट करता है जो शुरुआत . होना चाहिए , इसलिए यदि हमारे पास एक दस्तावेज़ होता जिसमें वे तीन अक्षर फ़ील्ड के बीच में होते, तो हमें एक मैच नहीं मिलता।
एक और त्वरित उदाहरण के रूप में, आइए कहीं भी खोजते हैं "at" . वर्णों के लिए फ़ील्ड में , जो हमें "Manhattan" . दोनों के लिए परिणाम देना चाहिए और "Staten Island" :
> db.restaurants.find( { borough: /Manhattan/ } ).count()
10259
> db.restaurants.find( { borough: /Staten Island/ } ).count()
969
> db.restaurants.find( { borough: /AT/i } ).count()
11228
निश्चित रूप से, हमारी अंतिम क्वेरी ने दो परिणाम सेट को एक में जोड़ दिया है।
आप देख सकते हैं कि भले ही हमारे अक्षर "AT" हमारे regex . में अपरकेस हैं स्ट्रिंग, लेकिन वे लोअरकेस . हैं वास्तविक दस्तावेज़ रिकॉर्ड में, हमने अभी भी परिणाम लौटाए हैं। ऐसा इसलिए है क्योंकि हमने विशेष i . भी जोड़ा है हमारे रेगेक्स क्लोजिंग स्लैश के बाद फ़्लैग करें (/ ) यह regex . को सूचित करता है इंजन जिसे हम खोज करना चाहते हैं case insensitive , अपरकेस या लोअरकेस पर ध्यान दिए बिना मिलान।
