Zum Inhalt

Beziehung

Ormar unterstützt derzeit zwei Arten von Beziehungen:

  • Eins-zu-Eins (und Multi-zu-Eins) mit foreignkey Feldern
  • Es gibt viele ManyToMany-Punkte.

Im Folgenden finden Sie ein sehr einfaches Beispiel für die Definition jeder Beziehung.

Um mehr über die Methoden, Möglichkeiten, Definitionen usw. zu erfahren, lesen Sie die folgenden Abschnitte der Dokumentation.

außen außen

Um eine Viel-zu-Eins-Beziehung zu definieren, verwenden Sie das Fremdschlüsselfeld.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from typing import Dict, Optional, Union

import databases
import ormar
import sqlalchemy

DATABASE_URL = "sqlite:///test.db"

ormar_base_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL), metadata=sqlalchemy.MetaData()
)


class Department(ormar.Model):
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)


class Course(ormar.Model):
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    department: Optional[Union[Department, Dict]] = ormar.ForeignKey(Department)

Tipp Um mehr über 1:1-Beziehungen zu erfahren, besuchen Sie den Abschnitt Fremdschlüssel

außerhalb des Rückens

Mehrere Beziehungsdefinitionen verwenden auch ForeignKey, das sich automatisch für Sie registriert.

Daher in den oben genannten Beispielen.

1
2
3
4
5
6
7
8
Klassenverwaltung (Ormar Model):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name: str = ormar. String (max_length = 100)
    "Es gibt ein virtuelles Feld, das wie folgt aussieht"
    courses: Optional [List [Kurs]]= ormar. ForeignKey (Kurs, virtuell = True)
    #Hinweis, dass du es nicht selbst definieren kannst, oder es für dich tun.

!!!tip Um mehr über die Mehr-zu-Eins-Beziehung zu erfahren (d. h. den Namen des generierten Felds zu ändern), besuchen Sie den Abschnitt Fremdschlüssel

!!!tip ReverseforeignKey ermöglicht es Ihnen, relevante Modelle mit queryset-proxy abzufragen.

1
Es erlaubt Ihnen,`await department.courses.all()` zu verwenden, um Fetch-Daten nur in Bezug auf eine bestimmte Abteilung etc. zu bestimmen.

mehr zu viel

Zum Definieren einer Mehr-zu-Mehr-Beziehung verwenden Sie das Feld ManyToMany.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Klasse (ormar. Modell):
    Die Abbildung zeigt die Konfidenzintervalle (
        Datenbank = Datenbank,
        Metathek = Metathek,
        tablename ="Kategorien",
    )

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name: str = ormar. String (max_length = 40)

Klasse Post (ormar. model):
    Die Abbildung zeigt die Konfidenzintervalle (
        Datenbank = Datenbank,
        Metathek = Metathek,
    )

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    title: str = ormar. String (max_length = 200)
    Kategorien: Optional [Liste [Kategorie]]= ormar.

!! Tipp Um mehr über Multi-zu-Multi-Beziehungen zu erfahren, besuchen Sie Multi-zu-Multi-Teil

!!!tip ManyToMany ermöglicht es Ihnen, verwandte Modelle mithilfe von queryset-proxy abzufragen.

1
Es erlaubt Ihnen,`await post.categories.all()` zu verwenden, aber auch `await category.posts.all()`, um bestimmte Daten nur auf bestimmte Post, Kategorien etc. zu beziehen.

Über das Feld.

Als Teil der ManyToMany-Beziehung können Sie ein Passthrough-Modell definieren, das zusätzliche Felder wie diese enthalten kann, die zum Filtern, Sortieren usw. verwendet werden können, und das auf der Rückseite der aktuellen Abfrage des m2m-Modells verfügbar ist.

Wenn Sie also von Modell A zu Modell B abfragen, zeigt nur Modell B, was für ein through Feld sinnvoll ist, da es sich um ein unidirektionales Modell/Feld für jedes relevante Modell handelt.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Klasse (ormar. Modell):
    Die Abbildung zeigt die Konfidenzintervalle (
        Datenbank = Datenbank,
        Metathek = Metathek,
        tablename ="Kategorien",
    )

    Integer (primary_key = true) oder id = ormar (primary_key = true)
    name = ormar. String (max_length = 40)[Bearbeiten | Quelltext bearbeiten]

#Sie können zusätzliche Felder über das Modell bestimmen
Klasse PostCategory (ormar. Model):
    Die Abbildung zeigt die Konfidenzintervalle (
        Datenbank = Datenbank,
        Metathek = Metathek,
        tablename ="posts_x_categories"(auf Englisch),
    )

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    sort_order: int = ormar. Integer (null = true)[Bearbeiten | Quelltext bearbeiten]
    param_name: str = ormar. String (default ="Name", max_length = 200)


Klasse Post (ormar. model):
    Die Abbildung zeigt die Konfidenzintervalle (
        Datenbank = Datenbank,
        Metathek = Metathek,
    )

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    title: str = ormar. String (max_length = 200)
    ManyToMany (Kategorie, durch = PostCategory)

!!!tip Um mehr über multi-zu-multi-Beziehungen und Felder zu erfahren, besuchen Sie den Abschnitt multi-zu-multi-Abschnitt

!!!tip ManyToMany ermöglicht es Ihnen, verwandte Modelle mithilfe von queryset-proxy abzufragen.

1
Es erlaubt Ihnen,`await post.categories.all()` zu verwenden, aber auch `await category.posts.all()`, um bestimmte Daten nur auf bestimmte Posts, Kategorien etc. zu beziehen.

Beziehungen ordnen sich in Ordnung

Standardmäßig folgen die Beziehungen der Standardsortierreihenfolge des Modells, sodass die Spalte Primary_key in aufsteigender Reihenfolge oder eine beliebige Sortierreihenfolge im Ormar_config-Objekt ist.

Tipp Um mehr über die Reihenfolge der Modelle zu erfahren, besuchen Sie bitte den Modellabschnitt der Dokumentation

Sie können jedoch die Reihenfolge ändern, in der relative Modelle während einer Abfrage geladen werden, indem Sie die Parameter orders_by und related_orders_by für Beziehungen bereitstellen.

In Beziehungen können Sie nur nach der Modellspalte sortieren, die direkt verwandt ist, oder bei mehreren Paaren mehrfacher Spalten auch nach der Modellspalte. {through_field_name}__{column_name}

Die Beispielkonfiguration kann wie folgt aussehen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
database = Datenbank. Datenbank (DATABASE_URL)
metadata = sqlalchemy. metadata ()[Bearbeiten | Quelltext bearbeiten]


Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle: (
    Datenbank = Datenbank,
    Metathek = Metathek,
)


Klasse Autor (ormar. Modell):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name: str = ormar. String (max_length = 100)[Bearbeiten | Quelltext bearbeiten]


Klasse Buch (ormar. model):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    Seite 1-Optional: Optional: Optional (
        Author, orders_by =["name"], related_orders_by =["-year"] und ["-name"]
    )
    title: str = ormar. String (max_length = 100)
    Jahr: int = ormar. Integer (nullable = true)
    Rang: int = ormar. Integer (null = true)

Jetzt anrufen:

await Author.objects.select_related("books").get() - Bücher werden nach Jahr sortiert.

await Book.objects.select_related("author").all() - Die Autoren werden nach Autorennamen sortiert

Aufschieben und Aufschieben von Referenzen

Um eine automatische Beziehung zu erstellen oder zwei Modelle zu erstellen, die sich in mindestens zwei verschiedenen Beziehungen gegenseitig referenzieren (denken Sie daran, dass die Kehrseite automatisch für Sie registriert wird), müssen Sie ForwardRef im Eingabemodul verwenden.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
PersonRef = ForwardRef ("Person") Bearbeiten


Klasse Person (ormar. model):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von Ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name: str = ormar. String (max_length = 100)[Bearbeiten | Quelltext bearbeiten]
    supervisor: PersonRef = ormar. ForeignKey (PersonRef, related_name ="employees")


update_forward_refs ()(Aktualisiert_forward_refs)

Tipps Um mehr über selbstreferenzierende und verzögerte Beziehungen zu erfahren, besuchen Sie bitte den Abschnitt "Verspäteter Kommentar".