Django ORM verstehen

Was ist ORM?

Objektrelationale Zuordnung (ORM) ist eine Funktion in Django, die es uns ermöglicht, mithilfe von Python-Code mit Datenbanken zu interagieren, ohne SQL-Abfragen schreiben zu müssen. Das ORM übersetzt CRUD-Operationen unter der Haube in SQL und ermöglicht so das einfache Erstellen, Abrufen, Aktualisieren und Löschen von Datenbankobjekten.

Arbeiten mit ORM

In Django repräsentiert eine Modellklasse eine Datenbanktabelle und eine Instanz dieser Klasse repräsentiert einen Datensatz in der Tabelle.

Jedes Modell hat mindestens einen Manager, der Objekte genannt wird. Über diesen Manager können wir Datensätze aus der Datenbank abrufen, was zu einem QuerySet führt.

QuerySets sind verzögert, was bedeutet, dass Ergebnisse erst abgerufen werden, wenn sie ausdrücklich angefordert werden.

Gemeinsame QuerySet-Methoden
filter(): Datensätze abrufen, die bestimmten Kriterien entsprechen.
all(): Alle Datensätze abrufen.
order_by(): Datensätze basierend auf bestimmten Feldern anordnen.
unique(): Gibt eindeutige Datensätze zurück.
annotate(): Aggregatwerte zu jedem Datensatz hinzufügen.
aggregat(): Berechnen Sie einen Wert aus einem Abfragesatz.
defer(): Nur einige Felder eines Modells laden, andere zurückstellen.

Erweiterte ORM-Funktionen

Q- und F-Objekte ermöglichen komplexe Abfragen und effiziente Vorgänge auf Datenbankebene. Wir können „Q“ für Abfragen verwenden, die ODER-Bedingungen beinhalten, während „F“ es Ihnen ermöglicht, Modellfelder direkt in Abfragen zu referenzieren.

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'))

Abfrageausdrücke (verweisen auf Modellfelder) und Datenbankfunktionen (Anwenden von SQL-ähnlichen Funktionen) ermöglichen es uns beide, Vorgänge auf Datenbankebene auszuführen, anstatt Daten zur Verarbeitung in Python abzurufen . Dies hilft, Abfragen zu optimieren und die Datenbanklast zu reduzieren.

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'))

Benutzerdefinierte Manager Lassen Sie uns zusätzliche Managermethoden hinzufügen oder das QuerySet ändern, das der Manager zunächst zurückgibt.

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 ist ein Modell, das zum Erstellen allgemeiner Beziehungen zwischen Modellen nützlich ist, ohne sie mit direkten Fremdschlüsseln anzugeben. Zu den häufigsten Anwendungsfällen gehören Kommentare oder Tags, die an verschiedene Modelltypen angehängt werden müssen.

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!'
)

Transaktionen bündeln Datenbankoperationen als eine einzige Einheit, um die Datenkonsistenz zu gewährleisten. Wir können den @transaction.atomic-Dekorator oder den Transaction.atomic()-Kontextmanager verwenden, um Code in einen Transaktionsblock einzuschließen.

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 ermöglicht die Ausführung von Roh-SQL-Abfragen für komplexe Abfragen, bei denen Sie Flexibilität benötigen. Es sollte jedoch mit Vorsicht verwendet werden.

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

Abschluss

Djangos ORM vereinfacht Datenbankinteraktionen, indem es eine High-Level-API für die Arbeit mit Modellen, Managern und Abfragen bereitstellt. Das Verstehen und Nutzen dieser Funktionen kann Ihre Produktivität und die Leistung Ihrer Anwendungen erheblich steigern.

Das obige ist der detaillierte Inhalt vonDjango ORM verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!