انضمام تجزیہ

1. تجزیہ کو متوجہ کرنا

روایت کے تحفظ میں ڈیٹا بیس کوئیریوں میں تجمیعی عمل ایک بہت اہم تصور ہے۔ عام طور پر یہ احصائی تجزیہ جیسے مجموعہ، تعداد، اوسط، زیادہ، اور کم سے کم قیمتیں کے لئے استعمال ہوتا ہے۔ یہ عمل صارفین کو بڑی مقدار کے ڈیٹا سے معنی خیز معلومات حاصل کرنے میں مدد فراہم کرتا ہے اور ڈیٹا تجزیہ اور فیصلہ سازی کی مدد فراہم کرتا ہے۔ ڈیٹا بیس میں تجمیع کے لئے عمل کرنے والے تفاعلات عام طور پر تجمیعی تفاعلات کہلاتے ہیں۔

2. بنیادی تجمیعی عمل

2.1. تجمیعی تفاعلات کا تصور

تجمیعی تفاعلات ڈیٹا بیس کوئیری زبانوں میں استعمال ہونے والے تفاعلات ہیں جو ایک سلسلہ کی حساب کتاب کرنے اور ایک واحد قیمت واپس کرنے کیلئے استعمال ہوتے ہیں۔ SQL اور اسی طرح کی کوئیری زبانوں میں تجمیعی تفاعلات ایک ڈیٹا کے کمپوننٹ پر عمل کر سکتے ہیں اور ایک واحد قیمت واپس کر سکتے ہیں، مثلاً کہ مجموعہ (SUM)، اوسط (AVG)، تعداد (COUNT)، زیادہ سے زیادہ (MAX)، اور کم سے کم (MIN)۔ جب ہمیں ڈیٹا کا سٹیٹسٹیکل تجزیہ کرنا ہوتا ہے تو تجمیعی تفاعلات ڈیٹا سیٹس کو پروسیس کرنے اور احصائی ڈیٹا کو نکالنے کیلئے اہم اوزار فراہم کرتے ہیں۔

2.2. ایک سے زیادہ فیلڈ کی تجمیع

عملی استعمال میں، ایک سے زیادہ فیلڈ کی تجمیعی تجزیہ بہت عام ضرورت ہے، جو عام طور پر کسی خاص کالم کی مجموعہ، اوسط، زیادہ سے زیادہ، اور کم سے کم قیمتیں وغیرہ حاصل کرنے کیلئے استعمال ہوتا ہے۔ تصور کریں ہمارے پاس ایک ادائیگی کی معلومات کی ٹیبل ہے، اور ہم صارفین کی جانب سے ادائیگی کی کل رقم کا حساب لگانا چاہتے ہیں۔ ent فریم ورک کا استعمال کرتے ہوئے، ہم ایک کوئیری بنا سکتے ہیں اور تجمیعی تفاعلات کا استعمال کر سکتے ہیں:

func Do(ctx context.Context, client *ent.Client) {
    // Payment انٹٹٹی کے فیلڈ Amount کا مجموعہ حاصل کریں۔
    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() میں ent.Sum کو بلاتے ہیں اور payment.Amount کو پیرامیٹر کے طور پر استعمال کر کے ادائیگی کی کل رقم حاصل کرتے ہیں۔ ہم نے Int(ctx) استعمال کیا ہے تاکہ تجمیعی نتیجے کو ایک مکمل عدد میں تبدیل کریں اور اسے لاگ کریں۔

2.3. متعدد فیلڈ کی تجمیع

بہت ساری صورتوں میں، ہمیں صرف ایک ہی نہیں بلکہ متعدد فیلڈ پر تجمیع حاصل کرنے کی ضرورت ہوتی ہے۔ اس سیکشن میں، ہم ایک مثال کے ذریعہ سے دکھائیں گے کہ کس طرح متعدد فیلڈ کی تجمیع حاصل کی جاسکتی ہے۔

اس مثال میں، ہم واضح کریں گے کی کس طرح ہم پالتو جانور کی ٹیبل میں عمر کا مجموعہ، کم سے کم، زیادہ سے زیادہ، اور تعداد کو حاصل کرتے ہیں۔

func Do(ctx context.Context, client *ent.Client) {
    var v []struct {
        Sum, Min, Max, Count int
    }
    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.Sum, agg.Min, agg.Max, agg.Count)
    }
}

اوپر دیے گئے کوڈ میں، ہم Aggregate تفاعل استعمال کر کے متعدد فیلڈ کی تجمیع کرتے ہیں، اور Scan تفاعل کو استعمال کرتے ہیں تاکہ تجمیعی نتائج کو سلائس v میں محفوظ کریں۔ پھر، ہم v پر چلا کر تمام تجمیعی نتائج کو ظاہر کرتے ہیں۔

3. گروپ بائی کی تجمیع کا استعمال

3.1. گروپ بائی کا استعمال فیلڈز کو گروپ کرنے کیلئے

ڈیٹا بیس کے عمل میں، Group By ڈیٹا کو گروپ کرنے کا ایک عام طریقہ ہے۔ اس سیکشن میں، ہم سیکھیں گے کہ کس طرح ہم Group By کا استعمال کرکے ڈیٹا کو گروپ کرتے ہیں۔

تعلیمی مثال، Group By کا استعمال کر کے ایک یا متعدد فیلڈز کو گروپ کرنا۔

مان لیں ہمارے پاس ایک صارف ٹیبل ہے اور ہمیں صارفوں کے name فیلڈ کو گروپ کرکے ہر گروپ کی تعداد حاصل کرنی ہے۔ نیچے دی گئی کوڈ مثال ہے:

func Do(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("Failed to execute multiple fields grouping and aggregation query: %v", err)
    }
    // ہر گروپ کے لیے تفصیلی معلومات کا اخراج
    for _, group := range v {
        fmt.Printf("Name: %s Age: %d Sum: %d Count: %d\n", group.Name, group.Age, group.Sum, group.Count)
    }
}

اس مثال میں، ہم نے صرف name اور age فیلڈز کے مبنی گروپ کیا ہے بلکہ ہر گروپ میں ریکارڈ کی تعداد اور کل عمر کا حساب لگایا ہے۔

4. گروپ بائی کے ساتھ ہیونگ کا مشترک کرنا

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("Failed to execute Having combined with Group By query: %v", err)
    }
    // ہونگ کے شرائط کو پورا کرنے والی صارف کی معلومات کا اخراج
    for _, user := range users {
        fmt.Printf("ID: %d Age: %d Role: %s\n", user.Id, user.Age, user.Role)
    }
}

اوپر دی گئی کوڈ میں ایک برابر SQL کوئری بنائی جائے گی تاکہ ہر رول میں زیادہ عمر والے صارفین کو منتخب کیا جا سکے۔