Entity Operations

1. `ent` एंटिटी ऑपरेशंस का परिचय

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

3. एंटिटी बनाने की ऑपरेशन

3.1 एकल एंटिटी बनाना

एक एंटिटी बनाना डेटा स्थिरता के लिए मौलिक ऑपरेशन है। नीचे वर्णित हैं एकल एंटिटी ऑब्ज

4.1 मूल प्रश्न

डेटाबेस क्वेरी करना सूचना प्राप्त करने का मौलिक तरीका होता है। ent में, Query मेथड का उपयोग क्वेरी आरंभ करने के लिए किया जाता है। नीचे मूल एंटिटी क्वेरी करने के चरण और एक उदाहरण हैं:

सुनिश्चित करें कि आपके पास उपयोगी Client इंस्टेंस है।
क्वेरी बनाने के लिए Client.Query() या एंटिटी सहायक मेथड जैसे Pet.Query() का उपयोग करें।
आवश्यकतानुसार फ़िल्टर करने वाली स्थितियाँ जोड़ें, जैसे Where।
All मेथड को कॉल करके क्वेरी को निष्पादित करें और परिणाम प्राप्त करें।

package main

import (
    "context"
    "log"
    "entdemo/ent"
    "entdemo/ent/user"
)

func main() {
    client, err := ent.Open("sqlite3", "file:ent?cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("डेटाबेस कनेक्शन खोलने में विफल: %v", err)
    }
    defer client.Close()
    ctx := context.Background()

    // "a8m" नाम के सभी उपयोगकर्ताओं को क्वेरी करें
    users, err := client.User.
        Query().
        Where(user.NameEQ("a8m")).
        All(ctx)
    if err != nil {
        log.Fatalf("उपयोगकर्ताओं को क्वेरी करने में विफल: %v", err)
    }

    for _, u := range users {
        log.Printf("उपयोगकर्ता मिल गया: %#v\n", u)
    }
}

इस उदाहरण में दिखाया गया है कि "a8m" नाम वाले सभी उपयोगकर्ताओं को कैसे खोजा जाए।

4.2 पृष्ठांकन और क्रमबद्धीकरण

पृष्ठांकन और क्रमबद्धीकरण क्वेरी करते समय सामान्यत: प्रयोग किए जाते हैं, डेटा के आउटपुट क्रम और मात्रा को नियंत्रित करने के लिए। ent का उपयोग करके पृष्ठांकन और क्रमबद्धीकरण क्वेरी करने का तरीका निम्नलिखित है:

Limit मेथड का उपयोग करके परिणामों की अधिकतम संख्या सेट करें।
पिछले परिणामों में से कुछ को छोड़ने के लिए Offset मेथड का उपयोग करें।
क्रमबद्धीकरण क्षेत्र और दिशा निर्धारित करने के लिए Order मेथड का उपयोग करें।

निम्नलिखित उदाहरण में एक पृष्ठांकन और क्रमबद्धीकरण क्वेरी का वर्णन है:

package main

import (
    "context"
    "log"
    "entdemo/ent"
    "entdemo/ent/pet"
)

func main() {
    client, err := ent.Open("sqlite3", "file:ent?cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("डेटाबेस कनेक्शन खोलने में विफल: %v", err)
    }
    defer client.Close()
    ctx := context.Background()

    // पशुओं को आयु के अवरोही क्रम में क्वेरी करें
    pets, err := client.Pet.
        Query().
        Order(ent.Desc(pet.FieldAge)).
        Limit(10).
        Offset(0).
        All(ctx)
    if err != nil {
        log.Fatalf("पशुओं को क्वेरी करने में विफल: %v", err)
    }

    for _, p := range pets {
        log.Printf("पशु मिला: %#v\n", p)
    }
}

इस उदाहरण में दिखाया गया है कि आयु के अवरोही क्रम में छोटा हुआ पहला पृष्ठ, 10 रिकॉर्ड, को कैसे प्राप्त किया जा सकता है। Limit और Offset के मानों को संशोधित करके, आप पूरे डेटासेट में पृष्ठांकन प्राप्त कर सकते हैं।

5. एंटिटी अपडेट कार्य

5.1 एकल एंटिटी का अपडेट करना

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

पहले, मान लें कि हमें एक उपयोगकर्ता की आयु अपडेट करनी है, हम Ent द्वारा उत्पन्न किए गए Update मेथड का उपयोग कर सकते हैं।

// मान लें कि हमारे पास पहले से ही उपयोगकर्ता एंटिटी 'a8m' और एक संदर्भ 'ctx' हैं

a8m, err := a8m.Update().         // एक उपयोगकर्ता अपडेट निर्माता बनाएं
    SetAge(30).                   // उपयोगकर्ता की आयु को 30 वर्ष की करें
    Save(ctx)                     // ऑपरेशन को करने और परिणाम प्राप्त करने के लिए
if err != nil {
    log.Fatalf("उपयोगकर्ता का अपडेट विफल: %v", err)
}

आप एक साथ कई फ़ील्डों को भी अपडेट कर सकते हैं:

a8m, err := a8m.Update().
    SetAge(30).                    // आयु अपडेट करें
    SetName("एरियल").              // नाम अपडेट करें
    AddRank(10).                   // 10 से रैंक बढ़ाएं
    Save(ctx)
if err != nil {
    log.Fatalf("उपयोगकर्ता का अपडेट विफल: %v", err)
}

अपडेट ऑपरेशन एक साथ जुड़ा जा सकता है, जो बहुत लचीला और सहज पढ़ने योग्य होता है। Save मेथड को कॉल करने से अपडेट होगा और अद्यतित एंटिटी या त्रुटि संदेश प्राप्त होगा।

5.2 शर्ताधीन अपडेट

Ent आपको शर्तों के आधार पर अपडेट करने की अनुमति देता है। यहां एक उदाहरण है जहां केवल उन उपयोगकर्ताओं को अपड

1. ent एंटिटी ऑपरेशंस का परिचय