Beziehungen zwischen Klassen zu codieren kann zunächst eine Herausforderung sein! Es klingt wie ein Haufen zusammengewürfelter Wörter – dieses Ding kennt dieses Ding durch dieses Ding, aber nicht das andere Ding. Die Verwendung von Beispielen aus dem wirklichen Leben kann bei der Visualisierung dieser Beziehungen hilfreich sein.
Angenommen, Sie haben einige Astronauten. Im Laufe vieler Jahre werden diese Astronauten viele Werke besuchen; ein Planet pro Mission. Jede Mission hat also einen Astronauten und einen Planeten, und viele Planeten werden von vielen Astronauten besucht.
In Flask ist die Beziehung zwischen Astronaut und Planet eine Viele-zu-Viele-Beziehung, während die Beziehung zwischen Astronaut und Mission und Planet und Mission beide eine Eins-zu-Viele-Beziehung ist. Wir haben drei Modelle: Das Modell Mission fungiert als Verbindungstabelle zwischen dem Modell Astronaut und dem Modell Planet. Die Klassen werden Modelle genannt, weil sie die Beziehungen zwischen Ihren Daten definieren (oder modellieren).
Wie kodieren wir diese Beziehungen?
Ich finde es am einfachsten, mit der Verknüpfungstabelle zu beginnen, da ich von dort aus beide Beziehungen aufbaue.
class Mission(db.Model):
__tablename__ = 'missions'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
Damit beginnen wir für unseren Missionskurs.
Wir wissen, dass jede Mission einen Astronauten hat:
astronaut = db.relationship
db.relationship definiert, wie zwei Modelle zueinander in Beziehung stehen.
Verknüpfen wir es mit der Astronautenklasse....
astronaut = db.relationship('Astronaut')
Und nun fügen wir die wechselseitige Beziehung zwischen den beiden Modellen (Astronaut und Mission) hinzu:
astronaut = db.relationship('Astronaut', back_populates="missions")
Tolle Arbeit! Da Mission sowohl die Astronauten- als auch die Planet-Beziehung enthält, machen wir dasselbe mit Planet:
planet = db.relationship('Planet', back_populates="missions")
Dies ist unsere Missionsklasse mit den Beziehungen:
class Mission(db.Model):
__tablename__ = 'missions'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
astronaut = db.relationship('Astronaut', back_populates="missions")
planet = db.relationship('Planet', back_populates="missions")
Super! Gehen wir zurück und werfen einen Blick auf unsere Anweisungen: Das Mission-Modell fungiert als _Join-Tabelle zwischen dem Astronautenmodell und dem Planeten model._
Wir müssen also Astronaut mit Mission und Planet mit Mission verknüpfen. Beginnen wir mit Astronaut:
missions = db.relationship('Mission', back_populates="astronauts")
Missionen sind hier Plural, weil ein Astronaut an einer Reihe davon teilnimmt (hoffentlich!).
Und dann Planet, der ähnlich aussehen sollte:
missions = db.relationship('Mission', back_populates="planets")
GROSSARTIG! Alles in allem sieht das so aus:
class Planet(db.Model):
__tablename__ = 'planets'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
distance_from_earth = db.Column(db.Integer)
nearest_star = db.Column(db.String)
missions = db.relationship('Mission', back_populates="planet")
class Astronaut(db.Model):
__tablename__ = 'astronauts'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
field_of_study = db.Column(db.String)
missions = db.relationship('Mission', back_populates="astronaut")
class Mission(db.Model):
__tablename__ = 'missions'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
astronaut = db.relationship('Astronaut', back_populates="astronauts")
planet = db.relationship('Planet', back_populates="missions")
Zuletzt fügen wir unsere Fremdschlüssel zu unserer Missionstabelle hinzu. Ein Fremdschlüssel ist eine Ganzzahl, die auf ein Element in einer anderen Datenbank verweist und die beiden miteinander verknüpft. Beispielsweise ist der Fremdschlüssel von Astronaut 1 in der Missionstabelle 1, sodass wir jedes Mal, wenn wir die Zahl 1 in dieser Spalte sehen, wissen, dass sie auf diesen Astronauten zutrifft!
Mission ist die einzige Klasse, die Fremdschlüssel benötigt, da sie für alle Beziehungen verantwortlich ist.
class Mission(db.Model, SerializerMixin):
__tablename__ = 'missions'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
astronaut_id = db.Column(db.Integer, db.ForeignKey('astronauts.id'))
planet_id = db.Column(db.Integer, db.ForeignKey('planets.id'))
astronaut = db.relationship('Astronaut', back_populates="missions")
planet = db.relationship('Planet', back_populates="missions")
serialize_rules = ('-astronaut.missions', '-astronaut.planets')
Fantastische Arbeit! Wir haben einige Beziehungen zwischen unseren Modellen eingerichtet. Danke fürs Codieren!
Quellen: Vielen Dank an die Flatiron School für dieses Labor! Ich habe den Klassennamen „Wissenschaftler“ in „Astronaut“ geändert.
Das obige ist der detaillierte Inhalt vonErkunden von Modellbeziehungen in Flask. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
