एकीकरण विश्लेषण

1. एग्रीगेट विश्लेषण का परिचय

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

2. मूल एग्रीगेट ऑपरेशन

2.1 समूहीकरण फ़ंक्शन की अवधारणा

समूहित फ़ंक्शन डेटाबेस क्वेरी भाषाओं में उपयोग किए जाने वाले फ़ंक्शन होते हैं जो एक श्रृंखला के गणना करने और एक एकल मूल्य लौटाने के लिए उपयोग होते हैं। SQL और समान क्वेरी भाषाओं में समूहित फ़ंक्शन डेटा कॉलम पर कार्य कर सकते हैं और एक ही मूल्य लौटा सकते हैं, जैसे कि योग (SUM), औसत (AVG), गणना (COUNT), अधिकतम (MAX), और न्यूनतम (MIN)। जब हमें डेटा सांख्यिकी विश्लेषण करने की आवश्यकता होती है, तो समूहित फ़ंक्शन डेटा संग्रह की प्रसंस्करण और सांख्यिकीय डेटा निकालने के लिए महत्वपूर्ण उपकरण होते हैं।

2.2 एकल-क्षेत्र समूहीकरण

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

func करें(ctx context.Context, client *ent.Client) {
    // भुगतान एंटिटी के लिए राशि का योग निर्धारित करें
    sum, err := client.Payment.Query().
        Aggregate(
            ent.Sum(payment.Amount),
        ).
        Int(ctx)
    if err != nil {
        log.Fatalf("योग प्राप्त करने में विफल: %v", err)
    }
    log.Printf("भुगतान की कुल राशि: %d", sum)
}

उपरोक्त कोड टुकड़े में, हम client.Payment.Query() का उपयोग भुगतान एंटिटी के लिए एक क्वेरी प्रारंभ करते हैं, फिर Aggregate() विधि का उपयोग करके payment.Amount को पैरामीटर के रूप में लाया जाने वाले ent.Sum फ़ंक्शन को कॉल करने के लिए करते हैं राशि की कुल गणना के लिए। हम .Int(ctx) का उपयोग भी करते हैं ताकि समूहीत परिणाम को एक पूर्णांक में परिणामित कर सकें और इसे लॉग कर सकें।

2.3 बहु-क्षेत्र समूहीकरण

कई मामलों में, हमें एक से अधिक क्षेत्रों पर समूहीकरण के ऑपरेशन करने की आवश्यकता होती है बस एकही. इस अनुभाग में, हम एक उदाहरण के माध्यम से बहु-क्षेत्र समूहीकरण कैसे प्राप्त कर सकते हैं उसे दिखाने वाले हैं।

इस उदाहरण में, हम पालतू सामग्री में उम्र को योग करेंगे, न्यूनतम को खोजेंगे, अधिकतम करेंगे, और Age क्षेत्र में गिनती करेंगे।

func करें(ctx context.Context, client *ent.Client) {
    var v []struct {
        योग, न्यूनतम, अधिकतम, गिनती इंट
    }
    err := client.Pet.Query().
        Aggregate(
            ent.Sum(pet.FieldAge), // योग उम्र का
            ent.Min(pet.FieldAge), // न्यूनतम उम्र
            ent.Max(pet.FieldAge), // अधिकतम उम्र
            ent.Count(),           // गिनती
        ).
        Scan(ctx, &v)
    if err != nil {
        log.Fatalf("क्वेरी विफल: %v", err)
    }
    // समूहीत परिणाम सभी आउटपुट करें
    for _, agg := range v {
        fmt.Printf("योग: %d न्यूनतम: %d अधिकतम: %d गिनती: %d\n", agg.योग, agg.न्यूनतम, agg.अधिकतम, agg.गिनती)
    }
}

उपरोक्त कोड में, हम बहु-क्षेत्र समूहीकरण करने के लिए पेट फ़ंक्शन का उपयोग करते हैं, और क्वेरी के यहाँ में समूहीत परिणामों को स्टोर करने के लिए स्कैन फ़ंक्शन का उपयोग करते हैं। फिर, हम v के माध्यम से समूहीत परिणामों को आउटपुट करने के लिए सभी परिणामों पर चलते हैं।

3. समूह आवंटन के एप्लिकेशन

3.1. समूह पोल द्वारा क्षेत्रों का समूहीकरण करना

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

ट्यूटोरियल उदाहरण, किसी अथवा अधिक क्षेत्रों को समूह बाय का उपयोग करके समूहित कैसे करें।

मान लें हमारे पास एक उपयोगकर्ता तालिका है और हमें उपयोगकर्ताओं के नाम क्षेत्र को समूहित करना है और हर समूह में उपयोगकर्ताओं की संख्या को गणना करनी है। नीचे दिए गए एक कोड उदाहरण में इस आवश्यकता को पूरा करने का आदान है:

func करें(ctx context.Context, client *ent.Client) {
    names, err := client.User.
        Query().
        GroupBy(user.FieldName).
        Strings(ctx)
    if err != nil {
        log.Fatalf("समूह से जुड़ी क्वेरी को नहीं कर पाया: %v", err)
    }
    // प्रत्येक समूह का नाम आउटपुट
    for _, name := range names {
        fmt.Println("समूह नाम:", name)
    }
}

उपरोक्त कोड में, हम क्वेरी बिल्डर के GroupBy मेथड का उपयोग कर रहे हैं जिससे हमें बताना है कि हम कौन सा क्षेत्र समूहित करना चाहते हैं।

3.2. क्रमवारी और एकत्रित कई क्षेत्र

कभी-कभी, हमें डेटा को कई क्षेत्रों पर आधारित करके और प्रत्येक समूह पर सारांश कार्यों को करना चाहिए। नीचे इस आवश्यकता को पूरा करने का एक उदाहरण है:

निम्नलिखित कोड में दिखाया गया है कि कैसे name और age क्षेत्रों पर आधारित करके उपयोगकर्ता तालिका में डेटा को समूहीकृत करें और प्रत्येक समूह में कुल आयु और उपयोगकर्ताओं की संख्या को गणना करें।

func Do(ctx context.Context, client *ent.Client) {
    var v []struct {
        Name  string `json:"name"`
        Age   int    `json:"age"`
        Sum   int    `json:"sum"`
        Count int    `json:"count"`
    }
    err := client.User.Query().
        GroupBy(user.FieldName, user.FieldAge).
        Aggregate(ent.Count(), ent.Sum(user.FieldAge)).
        Scan(ctx, &v)
    if err != nil {
        log.Fatalf("कई क्षेत्रों का समूहीकरण और समूहीकरण क्वेरी को क्रियान्वित करने में विफल: %v", err)
    }
    // प्रत्येक समूह के लिए विस्तृत जानकारी निकालें
    for _, group := range v {
        fmt.Printf("नाम: %s आयु: %d योग: %d गणना: %d\n", group.Name, group.Age, group.Sum, group.Count)
    }
}

इस उदाहरण में, हम उपयोगकर्ता तालिका में name और age क्षेत्रों पर डेटा को समूहीकृत करते हैं न केवल, बल्कि प्रत्येक समूह में रिकॉर्डों की कुल संख्या और कुल आयु की गणना करने के लिए गणना और सदस्य समागम कार्यों का भी उपयोग करते हैं।

4. Group By के साथ Having को जोड़ना

Having शर्त Group By क्रिया के बाद प्राप्त अग्रीगेट परिणामों को फ़िल्टर करती है। निम्नलिखित उदाहरण में दिखाया गया है कि कैसे केवल हर भूमिका में सबसे अधिक आयु वाले उपयोगकर्ताओं को चयनित करना:

func Do(ctx context.Context, client *ent.Client) {
    var users []struct {
        Id      Int
        Age     Int
        Role    string
    }
    err := client.User.Query().
        Modify(func(s *sql.Selector) {
            s.GroupBy(user.FieldRole)
            s.Having(
                sql.EQ(
                    user.FieldAge,
                    sql.Raw(sql.Max(user.FieldAge)),
                ),
            )
        }).
        ScanX(ctx, &users)
    if err != nil {
        log.Fatalf("Having क्रिया के साथ समूह द्वारा कम्पलीत करने के क्वेरी को क्रियान्वित करने में विफल: %v", err)
    }
    // Having शर्त को पूरा करने वाली उपयोगकर्ता जानकारी निकालें
    for _, user := range users {
        fmt.Printf("ID: %d आयु: %d भूमिका: %s\n", user.Id, user.Age, user.Role)
    }
}

उपरोक्त कोड, हर भूमिका में सबसे अधिक आयु वाले उपयोगकर्ताओं को चयनित करने के लिए एक समतिक SQL क्वेरी उत्पन्न करेगा।