जावा का उपयोग करते हुए MongoDB एकत्रीकरण

1. अवलोकन

इस ट्यूटोरियल में, हम MongoDB जावा ड्राइवर का उपयोग करके MongoDB एग्रीगेशन फ्रेमवर्क में गोता लगाएंगे। ।

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

2. एकत्रीकरण क्या हैं?

डेटा का विश्लेषण करने और इससे सार्थक जानकारी प्राप्त करने के लिए MongoDB में एकत्रीकरण का उपयोग किया जाता है ।

ये आम तौर पर विभिन्न चरणों में किए जाते हैं, और चरण एक पाइपलाइन बनाते हैं - जैसे कि एक चरण का आउटपुट अगले चरण में इनपुट के रूप में पारित किया जाता है।

सबसे अधिक उपयोग किए जाने वाले चरणों को संक्षेप में प्रस्तुत किया जा सकता है:

प्रत्येक एकत्रीकरण चरण के लिए SQL समतुल्य को ऊपर शामिल किया गया है ताकि हमें यह पता चल सके कि SQL दुनिया में उक्त ऑपरेशन का क्या अर्थ है।

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

3. डेटाबेस सेटअप

3.1। डेटासेट

डेटाबेस से संबंधित कुछ भी सीखने के लिए सबसे पहली और सबसे महत्वपूर्ण आवश्यकता स्वयं डेटासेट है!

इस ट्यूटोरियल के उद्देश्य के लिए, हम सार्वजनिक रूप से उपलब्ध आराम से एपीआई एंडपॉइंट का उपयोग करेंगे जो दुनिया के सभी देशों के बारे में व्यापक जानकारी प्रदान करता है। यह API हमें किसी देश के लिए सुविधाजनक JSON प्रारूप में बहुत सारे डेटा पॉइंट देता है . हमारे विश्लेषण में हम जिन कुछ क्षेत्रों का उपयोग करेंगे वे हैं:

• नाम - देश का नाम; उदाहरण के लिए, संयुक्त राज्य अमेरिका
• alpha3Code - देश के नाम के लिए एक शोर्ट कोड; उदाहरण के लिए, भारत (भारत के लिए)
  
• क्षेत्र - जिस क्षेत्र से देश संबंधित है; उदाहरण के लिए, यूरोप
• क्षेत्र - देश का भौगोलिक क्षेत्र
• भाषाएं - एक सरणी प्रारूप में देश की आधिकारिक भाषाएं; उदाहरण के लिए, अंग्रेज़ी
• सीमाएं - पड़ोसी देशों की एक सरणी 'alpha3Code एस

अब देखते हैं इस डेटा को MongoDB डेटाबेस में संग्रह में कैसे परिवर्तित करें ।

3.2. MongoDB में आयात करना

सबसे पहले, हमें सभी देशों को प्राप्त करने और JSON फ़ाइल में स्थानीय रूप से प्रतिक्रिया सहेजने के लिए API समापन बिंदु को हिट करने की आवश्यकता है . अगला कदम mongoimport . का उपयोग करके इसे MongoDB में आयात करना है आदेश:

mongoimport.exe --db <db_name> --collection <collection_name> --file <path_to_file> --jsonArray

सफल आयात हमें 250 दस्तावेजों के साथ एक संग्रह देना चाहिए।

4. जावा में एकत्रीकरण के नमूने

अब जबकि हमारे पास आधार शामिल हैं, आइए सभी देशों के लिए हमारे पास मौजूद डेटा से कुछ सार्थक अंतर्दृष्टि प्राप्त करें पर जाएं . हम इस उद्देश्य के लिए कई JUnit परीक्षणों का उपयोग करेंगे।

लेकिन इससे पहले कि हम ऐसा करें, हमें डेटाबेस से संबंध बनाने की जरूरत है:

@BeforeClass
public static void setUpDB() throws IOException {
    mongoClient = MongoClients.create();
    database = mongoClient.getDatabase(DATABASE);
    collection = database.getCollection(COLLECTION);
}

आने वाले सभी उदाहरणों में, हम समुच्चय . का उपयोग करेंगे MongoDB जावा ड्राइवर द्वारा प्रदान किया गया सहायक वर्ग।

हमारे स्निपेट्स की बेहतर पठनीयता के लिए, हम एक स्थिर आयात जोड़ सकते हैं:

import static com.mongodb.client.model.Aggregates.*;

4.1. मिलान और गिनें

शुरू करने के लिए, आइए कुछ सरल से शुरू करें। पहले हमने नोट किया था कि डेटासेट में भाषाओं के बारे में जानकारी होती है।

अब, मान लें कि हम दुनिया में उन देशों की संख्या की जांच करना चाहते हैं जहां अंग्रेजी आधिकारिक भाषा है :

@Test
public void givenCountryCollection_whenEnglishSpeakingCountriesCounted_thenNinetyOne() {
    Document englishSpeakingCountries = collection.aggregate(Arrays.asList(
      match(Filters.eq("languages.name", "English")),
      count())).first();
    
    assertEquals(91, englishSpeakingCountries.get("count"));
}

यहां हम अपनी एकत्रीकरण पाइपलाइन में दो चरणों का उपयोग कर रहे हैं:मिलान और गिनें ।

सबसे पहले, हम केवल उन दस्तावेज़ों से मिलान करने के लिए संग्रह को फ़िल्टर करते हैं जिनमें अंग्रेज़ी . शामिल हैं उनकी भाषाओं . में खेत। इन दस्तावेज़ों की कल्पना एक अस्थायी या मध्यवर्ती संग्रह के रूप में की जा सकती है जो हमारे अगले चरण, गिनती के लिए इनपुट बन जाता है। यह पिछले चरण में दस्तावेजों की संख्या की गणना करता है।

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

4.2. समूह (योग के साथ ) और क्रमबद्ध करें

इस उदाहरण में, हमारा उद्देश्य अधिकतम देशों वाले भौगोलिक क्षेत्र का पता लगाना . है :

@Test
public void givenCountryCollection_whenCountedRegionWise_thenMaxInAfrica() {
    Document maxCountriedRegion = collection.aggregate(Arrays.asList(
      group("$region", Accumulators.sum("tally", 1)),
      sort(Sorts.descending("tally")))).first();
    
    assertTrue(maxCountriedRegion.containsValue("Africa"));
}

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

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

4.3. क्रमबद्ध करें, सीमा, और बाहर

आइए अब क्रमबद्ध करें . का उपयोग करें , सीमा और बाहर क्षेत्रवार सात सबसे बड़े देशों को निकालने और उन्हें एक नए संग्रह में लिखने के लिए :

@Test
public void givenCountryCollection_whenAreaSortedDescending_thenSuccess() {
    collection.aggregate(Arrays.asList(
      sort(Sorts.descending("area")), 
      limit(7),
      out("largest_seven"))).toCollection();

    MongoCollection<Document> largestSeven = database.getCollection("largest_seven");

    assertEquals(7, largestSeven.countDocuments());

    Document usa = largestSeven.find(Filters.eq("alpha3Code", "USA")).first();

    assertNotNull(usa);
}

यहां, हमने पहले दिए गए संग्रह को क्षेत्र के अवरोही क्रम में क्रमबद्ध किया है। फिर, हमने एग्रीगेट्स#सीमा . का उपयोग किया परिणाम को केवल सात दस्तावेजों तक सीमित रखने की विधि। अंत में, हमने आउट . का उपयोग किया इस डेटा को सबसे बड़ा_सात . नामक एक नए संग्रह में अक्रमांकन करने के लिए चरण . इस संग्रह का उपयोग अब किसी अन्य की तरह ही किया जा सकता है - उदाहरण के लिए, ढूंढने . के लिए अगर इसमें यूएसए. . शामिल है

4.4. प्रोजेक्ट, समूह (अधिकतम के साथ), मिलान

हमारे पिछले नमूने में, आइए कुछ पेचीदा प्रयास करें। मान लें कि हमें यह पता लगाने की आवश्यकता है कि प्रत्येक देश दूसरों के साथ कितनी सीमाएँ साझा करता है, और ऐसी अधिकतम संख्या क्या है ।

अब हमारे डेटासेट में, हमारे पास एक बॉर्डर है फ़ील्ड, जो एक सरणी सूची है alpha3Code देश के सभी सीमावर्ती देशों के लिए, लेकिन ऐसा कोई क्षेत्र नहीं है जो हमें सीधे गिनती दे। इसलिए हमें सीमावर्ती देशों . की संख्या निकालने की आवश्यकता होगी प्रोजेक्ट . का उपयोग करना :

@Test
public void givenCountryCollection_whenNeighborsCalculated_thenMaxIsFifteenInChina() {
    Bson borderingCountriesCollection = project(Projections.fields(Projections.excludeId(), 
      Projections.include("name"), Projections.computed("borderingCountries", 
        Projections.computed("$size", "$borders"))));
    
    int maxValue = collection.aggregate(Arrays.asList(borderingCountriesCollection, 
      group(null, Accumulators.max("max", "$borderingCountries"))))
      .first().getInteger("max");

    assertEquals(15, maxValue);

    Document maxNeighboredCountry = collection.aggregate(Arrays.asList(borderingCountriesCollection,
      match(Filters.eq("borderingCountries", maxValue)))).first();
       
    assertTrue(maxNeighboredCountry.containsValue("China"));
}

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