انٹٹی کارروائیاں

1. ent اینٹٹی عملیات پر مکمل مرور

اس ہدایت نامہ میں آپ کو ent فریم ورک میں اینٹٹی کے عملیات کو مکمل طریقے سے مسٹر کرنے کا راستہ دکھایا جائے گا، جیسے کے اینٹٹی بنانا، کوئیری کرنا، اپ ڈیٹ کرنا اور حذف کرنا۔ یہ ابتدائی سطح کے لوگوں کے لئے موزوں ہے تاکہ وہ ent کی بنیادی کام کو دھیرے دھیرے سمجھ سکیں۔

3. اینٹٹی بنانے کا عمل

3.1 ایک اینٹٹی کو بنانا

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

1. پہلے، اینٹٹی کے ڈیٹا ماڈل (schema) میں اینٹٹی کی ساخت اور فیلڈز کا تعین کریں۔
2. مطابقتی اینٹٹی عمل کو تیار کرنے کے لئے ent generate کمانڈ کو رن کریں۔
3. بنیادی "Create" میکانکا استعمال کریں تاکہ نیا اینٹٹی بنایا جا سکے اور تسلسل بندی کے ذریعے اینٹٹی کے فیلڈ کی قیمتوں کو تعین کریں۔
4. آخر میں، "Save" میکانک کو بلایا جاے تاکہ اینٹٹی کو ڈیٹا بیس میں محفوظ کیا جا سکے۔

نیچے مثال شامل ہے جو دکھاتی ہے کہ کس طرح سے ایک صارف کی اینٹٹی کو بنایا اور محفوظ کیا جاتا ہے:

package main

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

func main() {
    // ڈیٹا بیس کمیونکے کے لئے کلائنٹ موقع کریں
    client, err := ent.Open("sqlite3", "file:ent?mode=memory&cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("ڈیٹا بیس کنکشن کھولنے میں ناکام: %v", err)
    }
    defer client.Close()

    // کنٹیکسٹ بنائیں
    ctx := context.Background()
    
    // کلائنٹ کا استعمال کرتے ہوئے ایک صارف کی اینٹٹی بنائیں
    a8m, err := client.User.
        Create().
        SetName("a8m").
        Save(ctx)
    if err != nil {
        log.Fatalf("صارف کی اینٹٹی بنانے میں ناکام: %v", err)
    }

    // اینٹٹی کو کامیابی سے ڈیٹا بیس میں محفوظ کر دیا گیا۔
    log.Printf("صارف کی اینٹٹی محفوظ ہوگئی: %v", a8m)
}

اس مثال میں، پہلے ایک ڈیٹا بیس کلائنٹ client بنایا گیا ہے۔ پھر، "User.Create" میکانک استعمال کرکے نئے صارف کے خصوصیات تعین کی گئیں ہیں، اور آخر میں "Save" میکانک کو بلایا گیا ہے تاکہ صارف کو ڈیٹا بیس میں محفوظ کیا جا سکے۔

3.2 جمع میں اینٹٹی بنانا

کچھ مناظر میں، متعدد اینٹٹیز کو بنانے کی ضرورت پڑ سکتی ہے، جیسے کے ڈیٹا بیس کی شروعات یا ڈیٹا کی بڑی تعداد کا اندراج۔ ent فریم ورک بڑی تعداد کے ڈیٹا کو ہر اینٹٹی کامیابی سے بنانے کی صلاحیت فراہم کرتا ہے، جو الگ-الگ اینٹٹیز کو بنانے اور محفوظ کرنے کی بجائے بہتر کارکردگی فراہم کرتا ہے۔

جمع میں اینٹٹی بنانے کے مراحل درج ذیل ہیں:

1. CreateBulk میکانک کا استعمال کریں جبکہ Create میکانک کے بجائے متعدد اینٹٹیز کو ایک ہی عمل کے ذریعے بنایا جا سکتا ہے۔
2. ہر اینٹٹی کے لئے Create کو بلائیں جو بنائی جانی ہو۔
3. جب تمام اینٹٹیز بنا دی جائیں تو، انہیں بلک میں ڈیٹا بیس میں محفوظ کرنے کے لئے Save میکانک کا استعمال کریں۔

نیچے جمع میں اینٹٹی بنانے کی ایک مثال ہے:

package main

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

func main() {
    client, err := ent.Open("sqlite3", "file:ent?mode=memory&cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("ڈیٹا بیس کنکشن کھولنے میں ناکام: %v", err)
    }
    defer client.Close()
    ctx := context.Background()

    // Pet اینٹٹیز کو جمع میں بنائیں
    pets, err := client.Pet.CreateBulk(
        client.Pet.Create().SetName("pedro").SetOwner(a8m),
        client.Pet.Create().SetName("xabi").SetOwner(a8m),
        client.Pet.Create().SetName("layla").SetOwner(a8m),
    ).Save(ctx)
    if err != nil {
        log.Fatalf("بیچ میں Pet اینٹٹیز بنانے میں ناکام: %v", err)
    }

    log.Printf("بیچ میں %d Pet اینٹٹیز بنائی گئیں ہیں\n", len(pets))
}

اس مثال میں، پہلے ایک کلائنٹ بنایا جاتا ہے، پھر متعدد Pet اینٹٹیز CreateBulk میکانک کا استعمال کرکے تیار کیے جاتے ہیں، ان کے نام اور مالک کے فیلڈز کو تعین کرتے ہوئے۔ جب Save میکانک کو بلایا جاتا ہے تو سب اینٹٹیز کو ایک ساتھ ڈیٹا بیس میں محفوظ کر دیا جاتا ہے، جو بڑی تعداد کے ڈیٹا کو منظم کرنے کے لئے بہتر کارکردگی فراہم کرتا ہے۔

4.1 بنیادی کوئری کرنا

ڈیٹا بیس کوئری کرنا معلومات حاصل کرنے کا بنیادی طریقہ ہے۔ ent میں، Query میتھڈ کوئیری شروع کرنے کے لیے استعمال ہوتی ہے۔ نیچے بنیادی اینٹٹی کوئیری کرنے کے اقدامات اور ایک مثال دی گئی ہے:

1. یقینی بنائیں کہ آپ کے پاس ایک قابل استعمال Client کی مثال ہے۔
2. Client.Query() یا اینٹٹی ہیلپر میتھڈ کی مدد سے جیسے Pet.Query() کوئیری بنانے کے لیے استعمال کریں۔
3. ضرورت کے مطابق فلٹرنگ شرائط شامل کریں، مثلاً Where۔
4. کوئیری کو اجراء کریں اور 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 کا استعمال کرتے ہوئے صفحہ بندی اور ترتیب کوئیری کیسے کریں:

1. Limit میتھڈ کا استعمال کریں تاکہ واپسی نتائج کی زیادہ سے زیادہ تعداد مقرر کی جا سکے۔
2. Offset میتھڈ کو استعمال کریں تاکہ پچھلے نتائج میں کچھ چھوڑ دیا جا سکے۔
3. 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 ایک اینٹٹی کو اپ ڈیٹ کرنا

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

سب سے پہلے، فرض کرتے ہیں کہ ہمیں ایک صارف کی عمر کو اپ ڈیٹ کرنا ہے، ہم اینٹٹ جنریٹ کرتے ہیں جو اینٹٹ کے ذریعے بنایا گیا ہو

// فرض کریں ہمارے پاس پہلے ہی اینٹٹی '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("Ariel").              // نام اپ ڈیٹ کریں
    AddRank(10).                   // رینک کو 10 سے بڑھانا
    Save(ctx)
if err != nil {
    log.Fatalf("صارف کو اپ ڈیٹ کرنے میں ناکام رہا: %v", err)
}

اپ ڈیٹ عمل کو چین کرنا ممکن ہے، جو بہت ہی لچکدار اور پڑھنے میں آسان ہوتا ہے۔ Save میتھڈ کو بلانے سے اپ ڈیٹ ہو جائے گا اور اپ ڈیٹ شدہ اینٹٹی یا ایک ایرر پیغام واپس آئے گا۔

5.2 شرائط کے مطابق تازہ کاری

Ent آپ کو شرائط کے مطابق تازہ کاری کرنے کی اجازت دیتا ہے۔ یہاں ایک مثال دی گئی ہے جہاں صرف ان صارفین کو اپ ڈیٹ کیا جائے گا جو مخصوص شرائط پوری کرتے ہیں۔

// یہاں ہمارے پاس ایک صارف کا `id` ہے اور ہم اس صارف کو فعال کرنا چاہتے ہیں
err := client.Todo.
    UpdateOneID(id).          // یوزر کی شناخت کے لیے بلڈر بنائیں
    SetStatus(todo.StatusDone).
    AddVersion(1).
    Where(
        todo.Version(currentVersion),  // اپ ڈیٹ کرنے کا عمل صرف جب کرایا جانے کے وقت کا فرض ہوتا ہے
    ).
    Exec(ctx)
switch {
case ent.IsNotFound(err):
    fmt.Println("ToDo نہیں ملا")
case err != nil:
    fmt.Println("اپ ڈیٹ خرابی:", err)
}

شرائط کے لحاظ سے استعمال کرتے وقت، ہمیں فوراً .Where() میتھڈ کو شامل کرنا ہوتا ہے۔ یہ آپ کو فیصلہ کرنے کی اجازت دیتا ہے کہ کیا اپ ڈیٹ کیا جائے یا نہیں، جو ڈیٹا کی مستقلیت اور صحت میں اہمیت رکھتا ہے۔

6. یکائی کی حذف عملیات

6.1 ایک واحد یکائی کو ہٹانا

یکائیوں کو حذف کرنا ڈیٹا بیس عملیات میں ایک اور اہم کام ہے۔ Ent فریم ورک یہ عملیات کروانے کے لیے ایک سادہ API فراہم کرتا ہے۔

نیچے دی گئی مثال میں دکھایا گیا ہے کہ کس طرح دی گئی صارف یکائی کو حذف کیا جاتا ہے:

err := client.User.
    DeleteOne(a8m).  // ایک یوزر حذف کرنے والا بلڈر بنائیں
    Exec(ctx)        // حذف کرنے کا عمل انجام دیں
if err != nil {
    log.Fatalf("یوزر کو حذف کرنے میں ناکام: %v", err)
}

6.2 شرائط کے مطابق حذف

اپ ڈیٹ کارروائیوں کی طرح، ہم مخصوص شرائط کے مطابق ہٹانے کارروائیاں بھی کر سکتے ہیں۔ کچھ مناظر میں، ہم صرف انٹیٹیز کو حذف کرنا چاہتے ہیں جو خصوصی شرائط پر پورا اترتی ہوں۔ .Where() میتھڈ استعمال کرکے ہم ان شرائط کو تعین کرسکتے ہیں:

// گمان کریں ہمیں تمام فائلوں کو حذف کرنا ہے جو ایک دی گئی تاریخ سے پہلے اپ ڈیٹ ہوئی ہیں
affected, err := client.File.
    Delete().
    Where(file.UpdatedAtLT(date)).  // صرف اس صورت میں حذف کریں جب فائل کی اپ ڈیٹ ٹائم دی گئی تاریخ سے پہلے ہو
    Exec(ctx)
if err != nil {
    log.Fatalf("فائلوں کو حذف کرنے میں ناکام: %v", err)
}

// یہ عمل حذف کرنے کے زمرے میں واقع شدہ ریکارڈز کی تعداد واپس کرتا ہے
fmt.Printf("%d فائلیں حذف کردی گئی ہیں\n", affected)

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