एंटिटी एसोसिएशन की परिभाषा

1. एंटिटी और संघ की मूल अवधारणाएँ

ent फ़्रेमवर्क में, एक एंटिटी डेटाबेस में प्रबंधित मूल डेटा इकाई को संदर्भित करती है, जो आम तौर पर डेटाबेस में एक तालिका को संदर्भित करती है। एंटिटी में क्षेत्र तालिका में स्तम्भों के संदर्भ में बराबरी का मुख्या और एंटिटियों के बीच संघ (किनारे) का उपयोग एंटिटी के बीच संबंधों और निर्भरताओं का वर्मण करने के लिए प्रयोग किए जाते हैं। एंटिटी संघ एक उच्च स्तरीय नक्शा तैयार करने के लिए आधार बनाती है, जो मुख्य रूप से माता-पिता संबंधों और मालिकी संबंधों जैसे व्यावसायिक संबंधों का प्रतिनिधि करने की अनुमति देता है।

ent फ़्रेमवर्क एपीआई में एक समृद्ध सेट प्रदान करता है, जो डेटा में इन संघों को परिभाषित और प्रबंधित करने देता है। इन संघों के माध्यम से, हम आसानी से डेटा के बीच जटिल व्यावसायिक तर्क को व्यक्त कर सकते हैं और उन पर काम कर सकते हैं।

2. ent में एंटिटी संघों के प्रकार

2.1 एक से एक (O2O) संघ

एक से एक संघ दो एंटिटियों के बीच एक से एक के सम्बंध को संदर्भित करता है। उदाहरण के लिए, उपभोक्ताओं और बैंक खातों के मामले में, प्रत्येक उपभोक्ता के पास केवल एक बैंक खाता हो सकता है, और प्रत्येक बैंक खाता केवल एक ही उपभोक्ता का हो सकता है। ent फ़्रेमवर्क इस प्रकार के संघों को परिभाषित करने के लिए edge.To और edge.From विधियों का उपयोग करता है।

पहले, हम User स्कीमा के भीतर Card की ओर इस प्रकार की संघ को संदर्भित कर सकते हैं:

// उपयोक्ता के एज़.
func (User) Edges() []ent.Edge {
    return []ent.Edge{
        edge.To("card", Card.Type). // कार्ड एंटिटी की ओर पहुंचता है, और संघ का नाम "कार्ड" के रूप म
## 3. इकाई संलग्नताओं के लिए मौलिक क्रियाएँ

इस अनुभाग में बताया जाएगा कि संलग्नता को परिभाषित रिश्तों के साथ `ent` का उपयोग करके मौलिक क्रियाएँ कैसे की जाती हैं, जैसे कि नए इकाइयों को बनाना, पूछताछ करना और संलग्न इकाइयों को चलते रहना।

### 3.1 संलग्न इकाइयों की रचना

इकाइयों को बनाते समय, आप इकाइयों के बीच रिश्ते स्थापित कर सकते हैं। एक सेबहुट (O2M) और बहुबहुट (M2M) रिश्तों के लिए, आप संलग्न इकाइयों को जोड़ने के लिए `Add{Edge}` मेथड का उपयोग कर सकते हैं।

उदाहरण के तौर पर, यदि हमारे पास एक उपयोगकर्ता इकाई और एक पालतू जानवर इकाई है जिसमें एक निश्चित संलग्नता है, जहां एक उपयोगकर्ता के पास कई पालतू जानवर हो सकते हैं, तो निम्नलिखित एक उपयोगकर्ता बनाने और उनके लिए पालतू जोड़ने का एक उदाहरण है:
```go
// एक उपयोगकर्ता बनाएं और पालतू जोड़ें
func CreateUserWithPets(ctx context.Context, client *ent.Client) (*ent.User, error) {
    // पालतू उदाहरण बनाएं
    fido := client.Pet.
        Create().  
        SetName("फाइडो").
        SaveX(ctx)
    // एक उपयोगकर्ता उदाहरण बनाएं और उसे पालतू से जोड़ें
    user := client.User.
        Create().
        SetName("ऐलिस").
        AddPets(fido). // पालतू से संलग्न करने के लिए AddPets मेथड का उपयोग करें
        SaveX(ctx)

    return user, nil
}

इस उदाहरण में, हम पहले फाइडो नामक एक पालतू उदाहरण बनाते हैं, फिर एक उपयोगकर्ता नामक ऐलिस बनाते हैं और AddPets मेथड का उपयोग करके उपयोगकर्ता के साथ पालतू उदाहरण को संलग्न करते हैं।

3.2 संलग्न इकाइयों का पूछताछ

ent में संलग्न इकाइयों का पूछताछ करना एक सामान्य क्रिया है। उदाहरण के लिए, आप Query{Edge} मेथड का उपयोग करके एक विशिष्ट इकाई से संलग्न किए गए अन्य इकाइयों को प्राप्त कर सकते हैं।

उपयोगकर्ता और पालतू के उदाहरण के साथ जारी रखते हुए, यहाँ ऐसा होता है कि एक उपयोगकर्ता द्वारा पोसेस की जाने वाली सभी पालतू जानवरों का पूछताछ कैसे किया जाता है:

// एक उपयोगकर्ता के सभी पालतू का पूछताछ
func QueryUserPets(ctx context.Context, client *ent.Client, userID int) ([]*ent.Pet, error) {
    pets, err := client.User.
        Get(ctx, userID). // उपयोगकर्ता आईडी के आधार पर उपयोगकर्ता उदाहरण प्राप्त करें
        QueryPets().      // उपयोगकर्ता से संलग्न पालतू इकाइयों को पूछताछ करें
        All(ctx)          // पूछताछ की गई सभी पालतू इकाइयों को लौटाएँ
    if err != nil {
        return nil, err
    }

    return pets, nil
}

उपरोक्त कोड स्निपेट में, हम पहले उपयोगकर्ता उदाहरण को उपयोगकर्ता आईडी के आधार पर प्राप्त करते हैं, फिर QueryPets मेथड को कॉल करके उस उपयोगकर्ता से संलग्न सभी पालतू इकाइयों को प्राप्त करते हैं।

ध्यान दें: ent कोड जेनरेशन टूल स्वचालित रूप से परिभाषित इकाई रिश्तों के आधार पर संलग्नता पूछताछ के लिए API जेनरेट करता है। सिफारिश की जाती है कि जेनरेट किए गए कोड की समीक्षा की जाए।

एकल एसोसिएशन को प्रीलोड करना

मान लीजिए हमें डेटाबेस से सभी उपयोगकर्ताओं को प्राप्त करना है और पालतू पशु डेटा को प्रीलोड करना है। हम निम्नलिखित कोड लिखकर इसे प्राप्त कर सकते हैं:

users, err := client.User.
    Query().
    WithPets().
    All(ctx)
if err != nil {
    // त्रुटि का सामना करें
    return err
}
for _, u := range users {
    for _, p := range u.Edges.Pets {
        fmt.Printf("उपयोगकर्ता (%v) के पास पालतू पशु है (%v)\n", u.ID, p.ID)
    }
}

इस उदाहरण में, हम WithPets मेथड का उपयोग करते हैं ताकि ent से उपयोगकर्ताओं से जुड़े पालतू पशु इकाइयों को प्रीलोड करें। प्रीलोड किए गए पालतू पशु डेटा को Edges.Pets फील्ड में भरा जाता है, जिससे हम इस जुड़े डेटा तक पहुँच सकते हैं।

मल्टीपल एसोसिएशन प्रीलोड करना

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

admins, err := client.User.
    Query().
    Where(user.Admin(true)).
    WithPets().
    WithGroups(func(q *ent.GroupQuery) {
        q.Limit(5)          // पहले 5 टीमों तक सीमित करें
        q.Order(ent.Asc(group.FieldName)) // टीम के नाम से समर्थ क्रम में क्रमबद्ध करें
        q.WithUsers()       // टीम में उपयोगकर्ताओं को प्रीलोड करें
    }).
    All(ctx)
if err != nil {
    // त्रुटियों का सामना करें
    return err
}
for _, admin := range admins {
    for _, p := range admin.Edges.Pets {
        fmt.Printf("प्रशासक (%v) के पास पालतू पशु है (%v)\n", admin.ID, p.ID)
    }
    for _, g := range admin.Edges.Groups {
        fmt.Printf("प्रशासक (%v) टीम (%v) का सदस्य है\n", admin.ID, g.ID)
        for _, u := range g.Edges.Users {
            fmt.Printf("टीम (%v) में सदस्य (%v) है\n", g.ID, u.ID)
        }
    }
}

इस उदाहरण के माध्यम से, आप देख सकते हैं कि ent कितना शक्तिशाली और लचीला है। कुछ सरल मेथड कॉल्स के साथ, यह संबद्ध डेटा को प्रीलोड कर सकता है और इन्हें एक संरचित ढंग से व्यवस्थित कर सकता है। यह डेटा-नियंत्रित अनुप्रयोग विकसित करने के लिए महान सुविधाएँ प्रदान करता है।