Golang MongoDB दस्तावेज़ क्वेरी

यह अध्याय Golang MongoDB दस्तावेज़ क्वेरी का उपयोग प्रस्तुत करता है।

पूर्वापेक्षित ट्यूटोरियल

• MongoDB Tutorial

सुझाव: यदि आप MongoDB क्वेरी संधि का अभ्यास नहीं है, तो कृपया सबसे पहले MongoDB ट्यूटोरियल पढ़ें। Golang में MongoDB ऑपरेशन के लिए उपयोग की जाने वाली अभिव्यक्ति संधि वही है।

परीक्षण डेटा तैयार करें

coll संग्रह में कई दस्तावेज़ डेटा डालें।

docs := []interface{}{
    bson.D{
        {"item", "journal"},
        {"qty", 25},
        {"size", bson.D{
            {"h", 14},
            {"w", 21},
            {"uom", "cm"},
        }},
        {"status", "A"},
    },
    // ... (अन्य दस्तावेज़ डेटा)
}

result, err := coll.InsertMany(context.Background(), docs)

सभी दस्तावेज़ों की क्वेरी

cursor, err := coll.Find(
    context.Background(),
    bson.D{}, // खाली क्वेरी स्थिति सेट करें
)

समानता क्वेरी स्थितियाँ

SQL के समानता मैच के साथ समान है।

cursor, err := coll.Find(
    context.Background(),
    bson.D{{"status", "D"}},   // समकक्ष शर्त: स्थिति = D
)

in क्वेरी ऑपरेटर

SQL के in क्वेरी के समान है।

cursor, err := coll.Find(
    context.Background(),
    bson.D{{"status", bson.D{{"$in", bson.A{"A", "D"}}}}}) // समकक्ष शर्त: स्थिति in ('A', 'D')

and क्वेरी स्थितियाँ

SQL के and लॉजिकल व्यक्ति के समान है।

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // समकक्ष शर्त: स्थिति='A' और qty < 30 
        {"status", "A"},
        {"qty", bson.D{{"$lt", 30}}},
    })

or क्वेरी स्थितियाँ

SQL के or लॉजिकल व्यक्ति के समान है।

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // समकक्ष शर्त: स्थिति = "A" या qty < 30
        {"$or", // $or ऑपरेटर का उपयोग करें
            bson.A{ // bson.A एरे टाइप की परिभाषा का उपयोग करें
                bson.D{{"status", "A"}},
                bson.D{{"qty", bson.D{{"$lt", 30}}}},
            }},
    })

संयुक्त क्वेरी उदाहरण

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // समकक्ष शर्त: स्थिति = "A" और ( qty < 30 या item LIKE "p%")
        {"status", "A"},
        {"$or", bson.A{
            bson.D{{"qty", bson.D{{"$lt", 30}}}},
            bson.D{{"item", primitive.Regex{Pattern: "^p", Options: ""}}},
        }},
    })

क्वेरी परिणामों को ट्रावर्स करें

उदाहरण 1

// नाम 'Bob' है वाले दस्तावेज़ क्वेरी करें
cursor, err := coll.Find(context.TODO(), bson.D{{"name", "Bob"}}, opts)
if err != nil {
	log.Fatal(err)
}

// एक bson.M प्रकार के दस्तावेज़ों का एक एरे परिभाषित करें, जहाँ bson.M एक मैप के लिए समान है
var results []bson.M
// सभी क्वेरी परिणामों को प्राप्त करने और परिणामों को परिणाम चर में सहेजने के लिए All फ़ंक्शन का उपयोग करें।
if err = cursor.All(context.TODO(), &results); err != nil {
	log.Fatal(err)
}

// परिणामों एरे को ट्रावर्स करें
for _, result := range results {
	fmt.Println(result)
}

स्पष्टीकरण: उदाहरण में दस्तावेज़ डेटा को स्टोर करने के लिए bson.M प्रकार का उपयोग किया गया है। आप जितनी बारीकी से फील्ड मेल खाते हैं, आप एक स्ट्रक्ट प्रकार को सान्ये कर सकते हैं।

उदाहरण 2

// क्वेरी परिणाम को संरचना प्रकार के एक वेरिएबल में परिणाम सहेजें
var result struct {
    Value float64
}

// स्वरूप शर्त नाम = 'pi' को सेट करने के लिए bson.D सहेत करें
filter := bson.D{{"name", "pi"}}
// एक संसाधन ऑब्जेक्ट बनाएं और क्वेरी का समय सीमा 5 सेकंड में सेट करें
ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// शर्त के आधार पर एक एकल डेटा क्वेरी करें, और परिणाम को result वेरिएबल में सहेजने के लिए डिकोड फंक्शन का उपयोग करें
err = collection.FindOne(ctx, filter).Decode(&result)

// क्वेरी त्रुटियों की जाँच करें
if err == mongo.ErrNoDocuments {
    // दस्तावेज़ नहीं मिला
    fmt.Println("दस्तावेज़ मौजूद नहीं है")
} else if err != nil {
    log.Fatal(err)
}
// अन्य संभावित नसीज़

सुझाव: अधिक विविध MongoDB क्वेरी अभिव्यक्ति संधि के लिए, कृपया MongoDB ट्यूटोरियल का संदर्भ लें।