Memahami Django ORM

Apakah ORM?

Pemetaan hubungan objek(ORM) ialah ciri dalam Django yang membolehkan kami berinteraksi dengan pangkalan data menggunakan kod Python tanpa menulis pertanyaan SQL. ORM menterjemah operasi CRUD ke dalam SQL di bawah hud, membolehkan penciptaan, pengambilan semula, pengemaskinian dan pemadaman objek pangkalan data dengan mudah.

Bekerja dengan ORM

Dalam Django, kelas model mewakili jadual pangkalan data dan tika kelas itu mewakili rekod dalam jadual.

Setiap model mempunyai sekurang-kurangnya satu Pengurus, yang dipanggil objek. Kami boleh mendapatkan semula rekod daripada pangkalan data melalui pengurus ini, menghasilkan QuerySet.

QuerySets adalah malas, bermakna keputusan tidak diambil sehingga diminta secara eksplisit.

Kaedah Set Pertanyaan Biasa
filter(): Dapatkan semula rekod yang sepadan dengan kriteria tertentu.
all(): Dapatkan semula semua rekod.
order_by(): Rekod pesanan berdasarkan medan tertentu.
distinct(): Kembalikan rekod unik.
annotate(): Tambahkan nilai agregat pada setiap rekod.
aggregate(): Kira nilai daripada set pertanyaan.
defer(): Muatkan hanya beberapa medan model, menangguhkan yang lain.

Ciri ORM Terperinci

Objek Q dan F membenarkan pertanyaan yang kompleks dan operasi peringkat pangkalan data yang cekap. Kami boleh menggunakan 'Q' untuk pertanyaan yang melibatkan syarat ATAU, manakala 'F' membenarkan anda merujuk medan model terus dalam pertanyaan.

from django.db.models import Q, F

# Using Q to filter published posts or created after a specific date
posts = Post.objects.filter(Q(status='published') | Q(created_at__gte='2024-01-01'))

# Using F to compare fields within a model (e.g., for a discount calculation)
class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    discounted_price = models.DecimalField(max_digits=10, decimal_places=2)

# Retrieve products where discounted price is less than price
discounted_products = Product.objects.filter(discounted_price__lt=F('price'))

Ungkapan Pertanyaan (merujuk medan model) dan Fungsi Pangkalan Data (menggunakan fungsi seperti SQL) kedua-duanya membenarkan kami melakukan operasi pada peringkat pangkalan data dan bukannya menarik data ke dalam Python untuk diproses . Ini membantu mengoptimumkan pertanyaan dan mengurangkan beban pangkalan data.

from django.db.models import Count, Max

# Count the number of posts for each status
status_count = Post.objects.values('status').annotate(count=Count('id'))

# Get the latest created post
latest_post = Post.objects.aggregate(latest=Max('created_at'))

Pengurus tersuai izinkan kami menambah kaedah pengurus tambahan atau mengubah suai QuerySet yang dipulangkan oleh pengurus pada mulanya.

class PublishedManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(status='published')

class Post(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    status = models.CharField(max_length=50)
    created_at = models.DateTimeField(auto_now_add=True)

    objects = models.Manager()  # Default manager
    published = PublishedManager()  # Custom manager for published posts

# Use the custom manager to get published posts
published_posts = Post.published.all()

ContentType ialah model yang berguna untuk mencipta perhubungan generik antara model tanpa menyatakannya dengan kunci asing langsung. Kes penggunaan biasa termasuk ulasan atau teg yang perlu dilampirkan pada pelbagai jenis model.

from django.contrib.contenttypes.models import ContentType

# Example model for comments
class Comment(models.Model):
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey('content_type', 'object_id')
    text = models.TextField()

# Creating a comment for a Post instance
post = Post.objects.get(id=1)
comment = Comment.objects.create(
    content_type=ContentType.objects.get_for_model(Post),
    object_id=post.id,
    text='Great post!'
)

Transaksi menggabungkan operasi pangkalan data sebagai satu unit yang memastikan ketekalan data. Kita boleh menggunakan penghias @transaction.atomic atau pengurus konteks transaction.atomic() untuk membungkus kod dalam blok transaksi.

from django.db import transaction

# Using a transaction block
with transaction.atomic():
    post = Post.objects.create(title='New Post', content='Content here...', status='published')
    # Any other database operations will be part of this transaction

Django membenarkan pelaksanaan pertanyaan SQL mentah untuk pertanyaan kompleks di mana anda memerlukan fleksibiliti. Walau bagaimanapun, ia harus digunakan dengan berhati-hati.

from django.db import connection

def get_published_posts():
    with connection.cursor() as cursor:
        cursor.execute("SELECT * FROM blog_post WHERE status = %s", ['published'])
        rows = cursor.fetchall()
    return rows

Kesimpulan

ORM Django memudahkan interaksi pangkalan data dengan menyediakan API peringkat tinggi untuk bekerja dengan model, pengurus dan pertanyaan. Memahami dan menggunakan ciri ini boleh meningkatkan produktiviti anda dan prestasi aplikasi anda.

Atas ialah kandungan terperinci Memahami Django ORM. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!