Transaction

1. مقدمة حول المعاملات واتساق البيانات

المعاملة هي وحدة منطقية في عملية تنفيذ نظام إدارة قاعدة البيانات، تتكون من سلسلة من العمليات. هذه العمليات إما أن تنجح جميعاً أو تفشل جميعاً وتُعامل كوحدة لا يمكن تجزئتها. يمكن تلخيص السمات الرئيسية للمعاملة بالاختصار ACID على النحو التالي:

• Atomicity: جميع العمليات في المعاملة إما أن تكتمل بشكل كامل أو تفشل تماماً؛ ولا يمكن أن يحدث الإكمال الجزئي.
• Consistency: يجب أن تنتقل المعاملة قاعدة البيانات من حالة متناسقة واحدة إلى حالة متناسقة أخرى.
• Isolation: يجب أن يكون تنفيذ المعاملة معزولاً عن التداخل من قبل معاملات أخرى، ويجب أن يكون البيانات بين معاملات متزامنة معزولة.
• Durability: بمجرد أن تتم تأكيد المعاملة، ستستمر التعديلات التي أجريتها في قاعدة البيانات.

اتساق البيانات يشير إلى الحفاظ على حالة البيانات الصحيحة والصالحة في قاعدة بيانات بعد سلسلة من العمليات. في السيناريوهات التي تتضمن الوصول المتزامن أو فشل النظام، يكون الاتساق في البيانات مهمًا بشكل خاص، وتوفر المعاملات آلية لضمان عدم المساس باتساق البيانات حتى في حالة الأخطاء أو التضاربات.

2. نظرة عامة على إطار العمل ent

ent هو إطار عمل كيان يوفر واجهة برمجية آمنة نوعياً لتشغيل قواعد البيانات من خلال إنشاء الكود باستخدام لغة برمجة Go. يجعل هذا الإطار عمليات قاعدة البيانات أكثر بديهية وآمنة، وقادر على تجنب مشاكل الأمان مثل حقن SQL. من حيث معالجة المعاملات، يوفر إطار ent دعماً قوياً، مما يتيح للمطورين إجراء عمليات معقدة للمعاملات باستخدام كود موجز وضمان تلبية خصائص ACID للمعاملات.

3. بدء المعاملة

3.1 كيفية بدء معاملة في ent

في إطار ent، يمكن بدء معاملة جديدة بسهولة داخل سياق معين باستخدام طريقة client.Tx، وتُعيد كائن معاملة Tx. يكون مثال الكود على النحو التالي:

tx, err := client.Tx(ctx)
if err != nil {
    // التعامل مع الأخطاء عند بدء المعاملة
    return fmt.Errorf("حدث خطأ أثناء بدء المعاملة: %w", err)
}
// أداء العمليات التالية باستخدام tx...

3.2 أداء العمليات ضمن معاملة

بمجرد إنشاء كائن Tx بنجاح، يمكن استخدامه لأداء عمليات قاعدة البيانات. ستصبح جميع العمليات الخاصة بالإنشاء والحذف والتحديث والاستعلام المُنفذة على كائن Tx جزءًا من المعاملة. يُظهر المثال التالي سلسلة من العمليات:

hub, err := tx.Group.
    Create().
    SetName("Github").
    Save(ctx)
if err != nil {
    // إذا حدث خطأ، ألغِ المعاملة
    return rollback(tx, fmt.Errorf("فشل إنشاء المجموعة: %w", err))
}
// يمكن إضافة عمليات إضافية هنا...
// تأكيد المعاملة
tx.Commit()

4. معالجة الأخطاء والعودة في المعاملات

4.1 أهمية معالجة الأخطاء

عند العمل مع قواعد البيانات، يمكن أن تحدث أخطاء مختلفة مثل مشاكل الشبكة أو تضاربات البيانات أو انتهاكات القيود في أي وقت. معالجة هذه الأخطاء بشكل صحيح أمر حاسم للحفاظ على اتساق البيانات. في المعاملة، إذا فشلت عملية، فإنه يجب أن يتم إلغاء المعاملة لضمان عدم ترك عمليات جزئية مكتملة قد تؤثر على اتساق قاعدة البيانات.

4.2 كيفية تنفيذ العودة

في إطار ent، يمكنك استخدام طريقة Tx.Rollback() لالغاء المعاملة بأكملها. عادةً ما يتم تعريف دالة مساعدة rollback للتعامل مع العودة والأخطاء، كما يُظهر بالشكل التالي:

func rollback(tx *ent.Tx, err error) error {
    if rerr := tx.Rollback(); rerr != nil {
        // إذا فشلت العودة، فإنه من الواجب إعادة الخطأ الأصلي وخطأ العودة معاً
        err = fmt.Errorf("%w: حدث خطأ أثناء عملية العودة للوراء: %v", err, rerr)
    }
    return err
}

مع هذه الدالة rollback، يمكننا التعامل بأمان مع الأخطاء وعملية العودة للمعاملة عند فشل أي عملية ضمن المعاملة. هذا يضمن أنه حتى في حالة الخطأ، لن يكون له تأثير سلبي على اتساق قاعدة البيانات.

5. استخدام العميل القابل للمعاملة

في التطبيقات العملية، قد تظهر سيناريوهات حيث نحتاج إلى تحويل رمز غير قابل للمعاملة بسرعة إلى رمز قابل للمعاملة. لهذه الحالات، يمكننا استخدام عميل قابل للمعاملة لنقل الرمز بسلاسة. فيما يلي مثال على كيفية تحويل رمز العميل غير القابل للمعاملة الحالي لدعم المعاملات:

// في هذا المثال، نقوم بتجميع الدالة الأصلية Gen داخل معاملة.
func WrapGen(ctx context.Context, client *ent.Client) error {
    // أولاً، قم بإنشاء معاملة
    tx, err := client.Tx(ctx)
    if err != nil {
        return err
    }
    // الحصول على عميل معاملة من داخل المعاملة
    txClient := tx.Client()
    // تنفيذ دالة Gen باستخدام العميل القابل للمعاملة دون تغيير في رمز Gen الأصلي
    if err := Gen(ctx, txClient); err != nil {
        // في حال حدوث خطأ، قم بإلغاء المعاملة
        return rollback(tx, err)
    }
    // في حالة النجاح، قم بتأكيد المعاملة
    return tx.Commit()
}

في الرمز أعلاه، يتم استخدام العميل القابل للمعاملة tx.Client()، مما يسمح بتنفيذ الدالة Gen الأصلية تحت ضمان المعاملة. تسمح هذه الطريقة لنا بتحويل رمز غير قابل للمعاملة بسهولة إلى رمز قابل للمعاملة مع أدنى تأثير على المنطق الأصلي.

6. أفضل الممارسات في المعاملات

6.1 إدارة المعاملات باستخدام دوال الاستدعاء

عندما يصبح منطق رمزنا معقدًا ويشمل عمليات قاعدة بيانات متعددة، يصبح إدارة هذه العمليات بشكل مركزي داخل معاملة مهمًا بشكل خاص. فيما يلي مثال على إدارة المعاملات من خلال دوال الاستدعاء:

func WithTx(ctx context.Context, client *ent.Client, fn func(tx *ent.Tx) error) error {
    tx, err := client.Tx(ctx)
    if err != nil {
        return err
    }
    // استخدام defer و recover للتعامل مع سيناريوهات الانهيار المحتملة
    defer func() {
        if v := recover(); v != nil {
            tx.Rollback()
            panic(v)
        }
    }()
    // استدعاء الدالة المقدمة لتنفيذ المنطق التجاري
    if err := fn(tx); err != nil {
        // في حالة حدوث خطأ، إلغاء المعاملة
        if rerr := tx.Rollback(); rerr != nil {
            err = fmt.Errorf("%w: إلغاء المعاملة: %v", err, rerr)
        }
        return err
    }
    // إذا كان المنطق التجاري خالي من الأخطاء، قم بتأكيد المعاملة
    return tx.Commit()
}

من خلال استخدام الدالة WithTx لتجميع المنطق التجاري، يمكننا ضمان أنه حتى إذا حدثت أخطاء أو استثناءات داخل المنطق التجاري، سيتم التعامل مع المعاملة بشكل صحيح (سواء بالتأكيد أو الإلغاء).

6.2 استخدام خطافات المعاملة

بشكل مشابه لخطافات النموذج البياني وخطافات التشغيل، يمكننا أيضًا تسجيل خطافات داخل معاملة نشطة (Tx) سيتم تشغيلها عند Tx.Commit أو Tx.Rollback:

func Do(ctx context.Context, client *ent.Client) error {
    tx, err := client.Tx(ctx)
    if err != nil {
        return err
    }
    tx.OnCommit(func(next ent.Committer) ent.Committer {
        return ent.CommitFunc(func(ctx context.Context, tx *ent.Tx) error {
            // المنطق قبل تأكيد المعاملة
            err := next.Commit(ctx, tx)
            // المنطق بعد تأكيد المعاملة
            return err
        })
    })
    tx.OnRollback(func(next ent.Rollbacker) ent.Rollbacker {
        return ent.RollbackFunc(func(ctx context.Context, tx *ent.Tx) error {
            // المنطق قبل إلغاء المعاملة
            err := next.Rollback(ctx, tx)
            // المنطق بعد إلغاء المعاملة
            return err
        })
    })
    // تنفيذ منطق تجاري آخر
    //
    // 
    //
    return err
}

من خلال إضافة خطافات أثناء تأكيد المعاملة وإلغاءها، يمكننا التعامل مع المنطق الإضافي، مثل تسجيل أو تنظيف الموارد.

7. فهم مستويات عزل المعاملات المختلفة

في نظام قاعدة البيانات، تعيين مستوى عزل المعاملات أمر حيوي لمنع مشاكل التنافر المختلفة (مثل القراءات القذرة، والقراءات غير القابلة للتكرار، والقراءات الوهمية). فيما يلي بعض مستويات العزل القياسية وكيفية ضبطها في إطار ent:

• READ UNCOMMITTED: أدنى مستوى يسمح بقراءة تغييرات البيانات التي لم يتم تأكيدها بعد، مما قد يؤدي إلى قراءات قذرة، وقراءات غير قابلة للتكرار، وقراءات وهمية.
• READ COMMITTED: يسمح بقراءة وتأكيد البيانات، مما يمنع القراءات القذرة، ولكن قد تحدث قراءات غير قابلة للتكرار وقراءات وهمية.
• REPEATABLE READ: يضمن أن قراءة نفس البيانات مرارًا داخل نفس المعاملة تنتج نتائج متسقة، مما يمنع القراءات غير القابلة للتكرار، لكن قد تحدث قراءات وهمية.
• SERIALIZABLE: أعلى مستوى عزل، حيث يحاول منع القراءات القذرة، والقراءات غير القابلة للتكرار، والقراءات الوهمية عن طريق قفل البيانات المعنية.

في ent، إذا كان برنامج تشغيل قاعدة البيانات يدعم ضبط مستوى عزل المعاملات، يمكن ضبطه على النحو التالي:

// ضبط مستوى عزل المعاملات على قراءة قابلة للتكرار
tx، err := client.BeginTx(ctx، &sql.TxOptions{Isolation: sql.LevelRepeatableRead})

فهم مستويات عزل المعاملات وتطبيقها في قواعد البيانات أمر حيوي لضمان تناسق البيانات واستقرار النظام. يجب على المطورين اختيار مستوى عزل مناسب استنادًا إلى متطلبات التطبيق النوعية لتحقيق أفضل ممارسة لضمان أمان البيانات وتحسين الأداء.