دليل استخدام Django ORM

ORM أو Object-Relational Mapping هي تقنية تتيح لك التعامل مع قواعد البيانات باستخدام الكائنات (Objects) بدلاً من كتابة استعلامات SQL بشكل مباشر. في إطار Django، ORM هو العمود الفقري الذي يربط بين قاعدة البيانات ونماذج البيانات (Models) التي تكتبها بلغة بايثون، بحيث يمكنك إنشاء، قراءة، تحديث، وحذف البيانات دون الحاجة لكتابة استعلامات SQL يدوياً.

الهدف من ORM هو تبسيط التفاعل مع قاعدة البيانات من خلال واجهة كائنية (Object-Oriented)، وهذا يسهل على المطورين التركيز على منطق التطبيق دون الانشغال بالتفاصيل الدقيقة للاستعلامات. فبدلاً من أن تكتب استعلامًا مثل:

SELECT * FROM products WHERE price > 100;

يمكنك في Django ببساطة أن تكتب:

Product.objects.filter(price__gt=100)

هذا يجعل الكود أكثر وضوحًا، وأسهل في القراءة والصيانة، كما يقلل من الأخطاء الأمنية مثل SQL Injection إذا تم استخدامه بشكل صحيح.

ميزة Django ORM أنه متكامل تمامًا مع باقي مكونات الإطار، مثل نظام النماذج (Forms)، لوحة التحكم الإدارية (Admin)، والترحيل (Migrations)، مما يجعل عملية التطوير أكثر سلاسة وكفاءة. ORM في Django لا يختصر فقط الاستعلامات، بل يقدم طبقة تجريد كاملة فوق قاعدة البيانات، مما يسمح لك بتبديل قاعدة البيانات من SQLite إلى PostgreSQL مثلًا دون الحاجة لإعادة كتابة الاستعلامات.

في المشاريع الكبيرة أو الصغيرة، استخدام ORM في Django هو معيار أساسي، لأنه يسهم في تنظيم الكود، ويوفر أمانًا واستقرارًا أفضل عند التعامل مع البيانات.

إنشاء النماذج (Models) في Django

النموذج (Model) في Django هو ببساطة كائن يمثل جدولًا في قاعدة البيانات. وعندما تنشئ نموذجًا جديدًا، فأنت فعليًا تصف شكل الجدول: ما هي الأعمدة التي يحتويها، وما نوع كل عمود، وما القيود التي عليه. يقوم Django بتحويل هذا الوصف إلى جداول حقيقية في قاعدة البيانات عند تنفيذ أوامر الترحيل.

لإنشاء نموذج، تقوم بتعريف صنف (class) يرث من django.db.models.Model. داخل هذا الصنف، تُكتب الحقول كمتغيرات تحدد نوع البيانات التي سيقبلها كل عمود.

مثال عملي:

from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    in_stock = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)

في المثال أعلاه:

  • name: حقل نصي بحد أقصى 100 حرف.

  • price: حقل أرقام عشرية بدقة معينة.

  • in_stock: حقل منطقي يشير إلى توافر المنتج.

  • created_at: حقل تاريخ ووقت يُملأ تلقائيًا عند إنشاء السجل.

يمكنك أيضًا تخصيص خصائص النموذج من خلال الكلاس الداخلي Meta، مثل تحديد اسم الجدول في قاعدة البيانات أو ترتيب النتائج:

class Meta:
    db_table = 'store_products'
    ordering = ['-created_at']

بعد إنشاء النموذج، لن يتم إنشاء الجدول في قاعدة البيانات تلقائيًا. لا بد من تنفيذ أوامر الترحيل (makemigrations وmigrate) والتي سنشرحها في النقطة التالية.

الترحيل (Migrations) وإنشاء الجداول

بعد أن تقوم بتعريف نموذج جديد أو تعديل نموذج قائم، لا يقوم Django بتحديث قاعدة البيانات تلقائيًا. بدلاً من ذلك، يستخدم نظام يُعرف بالترحيل (Migrations)، وهو آلية تسجل التغييرات التي أجريتها على النماذج وتحولها إلى أوامر تُنفذ على قاعدة البيانات لإبقائها متزامنة مع كود المشروع.

العملية تمر بمرحلتيْن:

  1. إنشاء ملف الترحيل:
    يتم ذلك باستخدام الأمر:

    python manage.py makemigrations

    هذا الأمر يُنشئ ملفًا جديدًا داخل مجلد migrations/ في تطبيقك. يحتوي هذا الملف على التعليمات التي تُترجم التغييرات التي أجريتها إلى أوامر SQL. على سبيل المثال، إذا أضفت حقلًا جديدًا للنموذج، فإن ملف الترحيل سيحتوي على أمر لإضافة عمود في الجدول.

  2. تطبيق الترحيل:
    يتم تنفيذ الأمر:

    python manage.py migrate

    هذا الأمر يطبق كل ملفات الترحيل على قاعدة البيانات، أي ينشئ أو يعدل الجداول حسب التغييرات الموجودة.

مثال عملي:

python manage.py makemigrations
python manage.py migrate

في أول مرة تنفذ فيها migrate على مشروع جديد، سيتم إنشاء الجداول الأساسية التي يحتاجها Django للعمل (مثل الجداول الخاصة بالمستخدمين والجلسات).

نقطة مهمة: Django يحتفظ بسجل للهجرات التي تم تنفيذها في جدول داخلي باسم django_migrations. لذلك، عند تنفيذ migrate، فهو لا يكرر العمليات التي تمت سابقًا، بل ينفذ فقط ما هو جديد.

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

أنواع العلاقات بين الجداول في ORM

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

فيما يلي الأنواع الثلاثة الأساسية للعلاقات في Django:

1. علاقة واحد إلى واحد (OneToOneField)

تستخدم لربط سجل واحد في جدول مع سجل واحد فقط في جدول آخر. مثال نموذجي: كل مستخدم له ملف تعريف خاص به.

class User(models.Model):
    username = models.CharField(max_length=100)

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()

  • كل سجل في Profile مرتبط بسجل واحد فقط في User.

  • on_delete=models.CASCADE تعني أنه إذا تم حذف المستخدم، يُحذف ملفه الشخصي أيضًا.

2. علاقة واحد إلى متعدد (ForeignKey)

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

class Category(models.Model):
    name = models.CharField(max_length=100)

class Product(models.Model):
    name = models.CharField(max_length=100)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)

  • كل منتج مرتبط بتصنيف واحد.

  • التصنيف الواحد يمكن أن يحتوي على العديد من المنتجات.

  • هذه العلاقة تنشئ عمودًا في جدول Product باسم category_id.

3. علاقة متعدد إلى متعدد (ManyToManyField)

تستخدم عندما يمكن لعدة سجلات في جدول أن ترتبط بعدة سجلات في جدول آخر. مثال: المقالات والوسوم، حيث يمكن للمقال أن يحمل عدة وسوم، والوسم الواحد يمكن أن يُستخدم في عدة مقالات.

class Tag(models.Model):
    name = models.CharField(max_length=50)

class Article(models.Model):
    title = models.CharField(max_length=100)
    tags = models.ManyToManyField(Tag)

  • Django ينشئ جدول وسيط تلقائيًا (join table) لربط المقالات بالوسوم.

ملخص استخدام العلاقات:

نوع العلاقة عندك جدولين: A و B A يحتوي على... مثال
OneToOne User و Profile واحد فقط من B مستخدم وملف
ForeignKey Category و Product عدة من B تصنيف ومنتجات
ManyToMany Article و Tag عدة من B مقال ووسوم

فهم هذه العلاقات بشكل جيد ضروري لتصميم قاعدة بيانات قوية، ويسهّل لاحقًا عمليات الاستعلام والوصول إلى البيانات في أي مشروع Django.

إجراء عمليات CRUD باستخدام ORM

العمليات الأساسية التي تُجرى على البيانات تُعرف اختصارًا بـ CRUD، وهي:

  • Create (إنشاء)

  • Read (قراءة)

  • Update (تعديل)

  • Delete (حذف)

Django ORM يوفر طريقة مرنة وواضحة للتعامل مع كل هذه العمليات باستخدام كائنات Python، دون الحاجة لكتابة استعلامات SQL مباشرة.

1. إنشاء بيانات (Create)

يمكنك إنشاء سجل جديد بطريقتين:

باستخدام create():

Product.objects.create(name="Laptop", price=1500)

أو بإنشاء الكائن ثم حفظه:

product = Product(name="Phone", price=800)
product.save()

2. قراءة البيانات (Read)

قراءة البيانات من قاعدة البيانات تتم باستخدام QuerySet. بعض الدوال الشائعة:

جميع السجلات:

Product.objects.all()

التصفية بناءً على شرط:

Product.objects.filter(price__gt=1000)

جلب سجل واحد:

Product.objects.get(id=1)

ملاحظة: get() سترفع خطأ إذا لم يتم العثور على سجل أو وُجد أكثر من سجل.

3. تعديل البيانات (Update)

الطريقة الأولى: تعديل الكائن مباشرة ثم حفظه:

product = Product.objects.get(id=1)
product.price = 1200
product.save()

الطريقة الثانية: تحديث جماعي:

Product.objects.filter(in_stock=False).update(in_stock=True)

التحديث الجماعي يتم مباشرة في قاعدة البيانات دون جلب الكائنات إلى الذاكرة، وهو أسرع.

4. حذف البيانات (Delete)

حذف سجل واحد:

product = Product.objects.get(id=1)
product.delete()

حذف عدة سجلات:

Product.objects.filter(price__lt=100).delete()

ملاحظات هامة:

  • يمكن ربط العمليات بالأحداث باستخدام إشعارات (signals) مثل post_save و post_delete.

  • bulk_create و bulk_update تُستخدم لتحسين الأداء عند التعامل مع كميات كبيرة من البيانات.

هذه العمليات الأربعة تُعد الأساس في التعامل اليومي مع ORM، وهي ما يجعل Django قويًا وسهل الاستخدام، حتى مع قواعد بيانات معقدة.

استخدام الاستعلامات المتقدمة (QuerySet API)

بعد أن تتقن العمليات الأساسية (CRUD)، تأتي المرحلة الأهم في Django ORM وهي استخدام QuerySet API لإجراء استعلامات معقدة ومتقدمة بمرونة عالية. هذه الاستعلامات تسمح بتصفية، تصنيف، إحصاء، وتقطيع البيانات بأساليب قوية دون كتابة SQL.

1. التصفية باستخدام filter() وexclude()

filter() لجلب سجلات تطابق شروط معينة:

Product.objects.filter(price__gte=500, in_stock=True)

exclude() لاستبعاد سجلات معينة:

Product.objects.exclude(name__icontains="demo")

2. الاستعلامات الشرطية باستخدام Q objects

عند الحاجة لاستعلامات مركبة بشرط "أو" بدلًا من "و"، نستخدم Q:

from django.db.models import Q

Product.objects.filter(Q(price__lt=1000) | Q(in_stock=False))

3. التجميع والإحصاء باستخدام annotate() وaggregate()

aggregate() تُستخدم لحساب القيم مثل المجموع أو المتوسط:

from django.db.models import Sum, Avg

Product.objects.aggregate(Sum('price'), Avg('price'))

annotate() لإضافة حقل جديد محسوب إلى كل سجل:

from django.db.models import Count

Category.objects.annotate(product_count=Count('product'))

4. الترتيب باستخدام order_by()

تصاعديًا:

Product.objects.order_by('price')

تنازليًا:

Product.objects.order_by('-created_at')

5. التقطيع (Slicing) وتحديد عدد النتائج

Product.objects.all()[:5]  # أول 5 عناصر
Product.objects.all()[10:20]  # من العنصر 11 إلى 20

6. التحقق من وجود بيانات

هل هناك منتجات في المخزون؟

Product.objects.filter(in_stock=True).exists()

الحصول على أول أو آخر سجل:

Product.objects.first()
Product.objects.last()

7. قصر النتائج باستخدام only() وdefer()

لتحسين الأداء بتحديد الحقول التي تُجلب:

Product.objects.only('name')  # يجلب فقط الاسم ويؤجل الباقي
Product.objects.defer('description')  # يؤجل جلب الوصف حتى يُطلب

هذه الأدوات تجعل Django ORM أكثر من مجرد وسيلة للتعامل مع البيانات — بل أداة تحليل واستعلام قوية تستطيع تنفيذ مهام معقدة بسهولة، مما يجعل الكود أنظف وأكثر كفاءة.

العلاقات العكسية (Reverse Relations)

عند تعريف علاقة بين نموذجين في Django، مثل ForeignKey أو OneToOneField أو ManyToManyField، فإن Django يقوم تلقائيًا بإنشاء علاقة عكسية تتيح لك الوصول من الجهة الأخرى للعلاقة. هذه الميزة مهمة جدًا لتصفح البيانات المرتبطة بسهولة دون كتابة استعلامات يدوية معقدة.

1. العلاقات العكسية في ForeignKey

إذا كان لدينا العلاقة التالية:

class Category(models.Model):
    name = models.CharField(max_length=100)

class Product(models.Model):
    name = models.CharField(max_length=100)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)

فمن جهة المنتج يمكن الوصول إلى category مباشرة:

product = Product.objects.get(id=1)
print(product.category.name)

ومن جهة الفئة (Category)، يمكن الوصول إلى كل المنتجات المرتبطة بها باستخدام العلاقة العكسية:

category = Category.objects.get(id=1)
products = category.product_set.all()

لاحظ الاسم الافتراضي product_set، وهو مشتق من اسم النموذج المرتبط مضافًا له _set.

2. تخصيص اسم العلاقة العكسية باستخدام related_name

لتجنب استخدام product_set الافتراضي، يمكنك تخصيص اسم العلاقة العكسية:

class Product(models.Model):
    name = models.CharField(max_length=100)
    category = models.ForeignKey(Category, related_name='products', on_delete=models.CASCADE)

الآن يمكنك فعل التالي:

category.products.all()

هذا يجعل الكود أوضح وأسهل في القراءة، خاصة في المشاريع الكبيرة.

3. العلاقات العكسية في OneToOneField

class User(models.Model):
    username = models.CharField(max_length=100)

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile')
    bio = models.TextField()

الآن يمكنك من جهة المستخدم:

user.profile.bio

4. العلاقات العكسية في ManyToManyField

class Tag(models.Model):
    name = models.CharField(max_length=50)

class Article(models.Model):
    title = models.CharField(max_length=100)
    tags = models.ManyToManyField(Tag, related_name='articles')

من جهة المقال:

article.tags.all()

ومن جهة الوسم:

tag.articles.all()

ملاحظات:

  • العلاقات العكسية لا تُضاف إلى قاعدة البيانات كأعمدة، بل يتم إنشاؤها تلقائيًا في طبقة الـ ORM.

  • استخدام related_name مهم جدًا لتفادي التعارضات، خاصة عند وجود أكثر من علاقة بنفس النوع داخل نموذج واحد.

  • يمكنك أيضًا استخدام related_query_name لتخصيص الاسم عند استخدام الاستعلامات.

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

التحسينات في الأداء باستخدام ORM

مع ازدياد حجم البيانات في المشروع، يصبح تحسين أداء الاستعلامات أمرًا حاسمًا. Django ORM يوفر أدوات قوية لتقليل عدد الاستعلامات وتحسين زمن تنفيذها دون الحاجة لكتابة SQL يدويًا. لكن كثيرًا من المطورين الجدد لا يستخدمون هذه الأدوات أو يسيئون استخدامها، مما يؤدي إلى مشاكل مثل "N+1 query problem" وتباطؤ شديد في الأداء.

فيما يلي أبرز الأساليب لتحسين أداء الاستعلامات باستخدام ORM:

1. select_related()

يُستخدم مع العلاقات من نوع ForeignKey وOneToOneField لجلب البيانات المرتبطة دفعة واحدة في نفس الاستعلام.

مثال:

products = Product.objects.select_related('category').all()

بدون select_related()، فإن الوصول إلى product.category.name لكل منتج سيؤدي إلى تنفيذ استعلام إضافي في كل مرة. لكن باستخدامه، سيتم جلب كل شيء مرة واحدة، مما يقلل عدد الاستعلامات من N+1 إلى 1 فقط.

2. prefetch_related()

يُستخدم مع العلاقات من نوع ManyToManyField أو عند الحاجة لجلب أكثر من مجموعة بيانات فرعية. على عكس select_related()، يقوم prefetch_related() بتنفيذ استعلام منفصل لكل علاقة، ثم يربط النتائج في الذاكرة.

مثال:

articles = Article.objects.prefetch_related('tags')

سيتم تنفيذ استعلام للمقالات واستعلام آخر للوسوم المرتبطة بها، ثم يتم ربط البيانات داخل Django دون تنفيذ استعلامات إضافية لاحقًا.

3. تحديد الحقول المطلوبة فقط باستخدام only() وdefer()

only():

يجلب الحقول المحددة فقط عند الاستعلام:

Product.objects.only('name')

defer():

يؤجل جلب الحقول غير المهمة لحين استخدامها:

Product.objects.defer('description')

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

4. التجميع الذكي بدلًا من جلب كل السجلات

بدلًا من تحميل كل البيانات وتحليلها في Python، استخدم annotate() وaggregate() لتنفيذ العمليات داخل قاعدة البيانات.

مثال:

Product.objects.aggregate(Sum('price'))

أسرع بكثير من:

total = sum([p.price for p in Product.objects.all()])

5. تجنب الحلقات التي تحتوي على استعلامات

من الأخطاء الشائعة:

for product in Product.objects.all():
    print(product.category.name)

هذا سينتج عنه استعلام إضافي لكل منتج. الحل الصحيح:

products = Product.objects.select_related('category')
for product in products:
    print(product.category.name)

6. استخدام values() وvalues_list() عند الحاجة فقط للبيانات الخام

values():

Product.objects.values('name', 'price')

values_list():

Product.objects.values_list('name', flat=True)

هذه الطرق تُعيد بيانات أولية بدلًا من كائنات النموذج، وهي أسرع عند الحاجة لقراءة البيانات فقط دون تعديلها.

خلاصة:

  • select_related() لتحسين استعلامات ForeignKey وOneToOne.

  • prefetch_related() لتحسين استعلامات ManyToMany والعلاقات العكسية.

  • استخدم only() وdefer() لتقليل حجم البيانات.

  • نفّذ التجميع داخل قاعدة البيانات.

  • لا تضع استعلامات داخل الحلقات.

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

الفروق بين .get() و.filter() في Django ORM

هاتان الدالتان تُستخدمان لاسترجاع بيانات من قاعدة البيانات، لكنهما تختلفان في السلوك وطريقة التعامل مع النتائج.

1. .get()

  • تُستخدم لاسترجاع سجل واحد فقط يتطابق مع شروط البحث.

  • إذا وُجد سجل واحد مطابق، تُعيده ككائن نموذج.

  • إذا لم يُوجد أي سجل، ترفع استثناء DoesNotExist.

  • إذا وُجد أكثر من سجل، ترفع استثناء MultipleObjectsReturned.

  • لا تُعيد QuerySet وإنما كائن مفرد.

مثال:

product = Product.objects.get(id=1)

يجب استخدامها فقط عندما تكون متأكدًا أن هناك سجلًا واحدًا فقط مطابقًا.

2. .filter()

  • تُستخدم لاسترجاع مجموعة سجلات (QuerySet) تطابق الشروط.

  • تُعيد QuerySet يمكن أن يحتوي على 0 أو أكثر من السجلات.

  • إذا لم يوجد سجل مطابق، تُعيد QuerySet فارغ.

  • لا ترفع أي استثناء بسبب عدم وجود سجلات.

  • يمكن استخدامها لتصفية البيانات بعدة شروط.

مثال:

products = Product.objects.filter(price__gt=1000)

3. الاختلافات الرئيسية

خاصية .get() .filter()
نوع النتيجة كائن مفرد (Model instance) QuerySet (مجموعة سجلات)
استرجاع سجلات سجل واحد فقط صفر أو أكثر من السجلات
التعامل مع عدم وجود سجل يرفع DoesNotExist يُعيد QuerySet فارغ
التعامل مع تعدد السجلات يرفع MultipleObjectsReturned يُعيد كل السجلات المطابقة
استخدام في الكود عندما تتأكد من وجود سجل وحيد للحصول على مجموعة سجلات

4. متى تستخدم كل واحدة؟

  • استخدم .get() إذا كنت تحتاج لسجل محدد وفريد (مثلاً بناءً على id أو حقول فريدة).

  • استخدم .filter() للحصول على قائمة من السجلات التي تطابق شروط معينة، أو للتحقق من وجود سجلات بدون إثارة استثناء.

5. التعامل مع الاستثناءات

عند استخدام .get() يُفضل التعامل مع الاستثناءات لتجنب انهيار التطبيق:

from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned

try:
    product = Product.objects.get(id=1)
except ObjectDoesNotExist:
    # سجل غير موجود
except MultipleObjectsReturned:
    # أكثر من سجل واحد

فهم الفرق بين .get() و.filter() يساعد على كتابة كود أكثر أمانًا وفعالية عند التعامل مع قواعد البيانات في Django.

تعامل ORM مع قواعد البيانات المختلفة

Django ORM مصمم ليكون طبقة تجريدية تعمل فوق قواعد بيانات متعددة دون الحاجة لتغيير كود النماذج أو الاستعلامات، ما يسهل الانتقال بين قواعد البيانات أو دعم أكثر من قاعدة بيانات في نفس المشروع.

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

  • SQLite: قاعدة بيانات خفيفة تُستخدم بشكل افتراضي في مشاريع Django الجديدة، مناسبة للتطوير والاختبار.

  • PostgreSQL: قاعدة بيانات قوية وموثوقة تدعم ميزات متقدمة مثل JSONB، البحث النصي الكامل، وتعدد العمليات.

  • MySQL/MariaDB: قواعد بيانات شهيرة مناسبة للعديد من التطبيقات التجارية.

  • Oracle: مدعومة رسميًا لكنها أقل شيوعًا مع Django.

2. التوافق في ORM

  • معظم وظائف ORM تعمل بشكل موحد عبر قواعد البيانات المختلفة.

  • بعض الميزات الخاصة قد تعتمد على قاعدة البيانات، مثل دعم أنواع بيانات معينة (JSONField في PostgreSQL) أو الوظائف الخاصة (Full Text Search).

  • عند كتابة استعلامات معقدة أو استخدام وظائف خاصة، يجب الانتباه إلى دعم قاعدة البيانات المستهدفة.

3. تكوين قاعدة البيانات

في ملف settings.py، يمكنك تحديد نوع قاعدة البيانات التي تريد استخدامها بسهولة:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

لتغيير قاعدة البيانات، يكفي تعديل ENGINE والبيانات المتعلقة بها.

4. الاختلافات والتحديات

  • دعم الحقول الخاصة: بعض الحقول (مثل ArrayField) مدعومة فقط في PostgreSQL.

  • الأداء: قد تختلف أداء الاستعلامات حسب نوع قاعدة البيانات وإعداداتها.

  • وظائف متقدمة: مثل عمليات البحث النصي، أو التعامل مع JSON، قد تكون مدعومة بشكل مختلف.

  • الهجرات: بعض قواعد البيانات قد تتطلب تغييرات في ملف الترحيل لتتناسب مع قدراتها.

5. الدعم المتعدد لقواعد البيانات (Multi-DB)

Django يسمح باستخدام أكثر من قاعدة بيانات في مشروع واحد، عبر إعدادات متقدمة، مع إمكانية تحديد قاعدة البيانات التي يُجرى عليها الاستعلامات باستخدام مدير قواعد بيانات مخصص.

استخدام ORM مع النماذج الإدارية (Django Admin)

Django Admin هو نظام إدارة تلقائي يأتي مدمجًا مع إطار Django، يسمح لك بإدارة بيانات التطبيق بسهولة عبر واجهة ويب، ويعتمد بشكل كامل على نماذج ORM التي تعرفها. هذا التكامل يجعل من إعداد لوحة التحكم الإدارية أمرًا سريعًا وفعالًا.

1. التسجيل الأساسي للنماذج في لوحة الإدارة

لتظهر النماذج في لوحة الإدارة، تحتاج إلى تسجيلها في ملف admin.py الخاص بالتطبيق:

from django.contrib import admin
from .models import Product

admin.site.register(Product)

بعد التسجيل، يمكنك إضافة، تعديل، وحذف سجلات Product من خلال واجهة الإدارة.

2. تخصيص عرض النماذج في لوحة الإدارة

يمكنك إنشاء صنف ModelAdmin لتخصيص كيفية عرض وإدارة البيانات:

class ProductAdmin(admin.ModelAdmin):
    list_display = ('name', 'price', 'in_stock')
    search_fields = ('name',)
    list_filter = ('in_stock',)

admin.site.register(Product, ProductAdmin)

  • list_display لتحديد الأعمدة المعروضة في قائمة السجلات.

  • search_fields لإضافة مربع بحث حسب الحقول المحددة.

  • list_filter لإضافة فلاتر جانبية لتصفية السجلات.

3. إدارة العلاقات بين النماذج

لو كانت هناك علاقات ForeignKey أو ManyToMany، يمكن لـ Admin عرضها وتحريرها بسهولة من خلال واجهة الإدارة، مما يسهل ربط الجداول دون الحاجة لأدوات خارجية.

4. الفوائد العملية لدمج ORM مع Admin

  • تسريع التطوير: لا تحتاج لبناء واجهة إدارة مخصصة، لوحة الإدارة جاهزة للعمل.

  • تكامل كامل: جميع العمليات CRUD يتم تنفيذها من خلال ORM، مما يضمن التوافق مع قاعدة البيانات.

  • الأمان: يمكنك التحكم في صلاحيات المستخدمين عبر إعدادات الـ Admin.

  • المرونة: إمكانية تخصيص الواجهة لتناسب احتياجات المشروع بسهولة.

5. ملاحظات

  • Django Admin مناسب لإدارة البيانات الخلفية وليس كواجهة أمامية للمستخدمين.

  • يعتمد على التعريف الصحيح للنماذج باستخدام ORM، لذا فهم النماذج ضروري للاستفادة من لوحة الإدارة.

  • يمكنك بناء صفحات إدارية مخصصة باستخدام ModelAdmin لتتناسب مع تعقيدات مشروعك.

باختصار، ORM هو الأساس الذي تقوم عليه لوحة إدارة Django، مما يجعل العمل مع قواعد البيانات بسيطًا وسلسًا من خلال واجهة متكاملة وقوية.

خاتمة

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

ORM لا يختصر فقط على تسهيل التعامل مع قواعد البيانات، بل يوفر طبقة أمان من الأخطاء الشائعة مثل هجمات SQL Injection، ويساعد على جعل الكود أكثر وضوحًا وقابلية للتوسع.

مع ذلك، يجب على المطور أن يعرف حدود ORM، ويكون مستعدًا لاستخدام استعلامات SQL مباشرة عند الحاجة، خصوصًا في الحالات التي تتطلب أداء عاليًا أو استعلامات معقدة.

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

حول المحتوى:

الهدف من ORM هو تبسيط التفاعل مع قاعدة البيانات من خلال واجهة كائنية (Object-Oriented)، وهذا يسهل على المطورين التركيز على منطق التطبيق دون الانشغال بالتفاصيل الدقيقة للاستعلامات.