Einführung in relationale SQLAlchemy-Operationen unter Python (mit Code)

Dieser Artikel bietet Ihnen eine Einführung in die relationalen Operationen von SQLAlchemy (mit Code). Ich hoffe, dass er Ihnen als Referenz dienen wird.

Eine relationale Datenbank ist eine Datenbank, die auf dem relationalen Modell basiert. Daher ist die Beziehung zwischen Tabellen bei der Datenbankprogrammierung besonders wichtig. Dieser Abschnitt konzentriert sich auf die Definition von Beziehungen in SQLAlchemy und die Verwendung von Beziehungen zum Durchführen von Abfragen, damit die Leser die Beziehungsoperationen von SQLAlchemy schnell beherrschen können.

1. Fall

Entwerfen Sie 3 Entitätstabellen: Klassentabelle, Schülertabelle, Lehrertabelle und 1 relationale Tabelle: class_teacher. Es besteht eine Eins-zu-viele-Beziehung zwischen Klassen und Schülern und eine Viele-zu-viele-Beziehung zwischen Klassen und Lehrern.

from sqlalchemy import Table,Column,Integer,ForeignKey,String
from sqlalchemy.orm import relationship,backref
from sqlalchemy.ext.declarative import declarative_base

Base=declarative_base()

class Class(Base):
    __tablename__='class'
    class_id=Column(Integer,primary_key=True)
    name=Column(String(50))
    level=Column(Integer)
    address=Column(String(50))

    class_teachers=relationship("ClassTeacher",backref="class")
    students=relationship("Student",backref="class")

class Student(Base):
    __tablename__='student'
    student_id=Column(Integer,primary_key=True)
    name=Column(String(50))
    age=Column(Integer)
    gender=Column(String(10))
    address=Column(String(50))
    class_id=Column(Integer,ForeignKey('class.id'))

class Teacher(Base):
    __tablename__='teacher'
    teacher_id=Column(Integer,primary_key=True)
    name=Column(String(50))
    gender=Column(String(10))
    telephone=Column(String(50))
    address=Column(String(50))
    class_teachers=relationship("ClassTeacher",backref="teacher")

class ClassTeacher(Base):
    __tablename__='class_teacher'
    teacher_id=Column(Integer,ForeignKey('teacher.teacher_id'),primary_key=True)
    class_id=Column(Integer,ForeignKey("class.id"),primary_key=True)

Der Code verwendet 4 SQLAlchemy-Modelle, um 4 Tabellen zu definieren. Die mit der Beziehungsdefinition verbundenen Teile sind wie folgt:

• Fremdschlüsseleinstellungen: in der Spalte In Übergeben Sie bei der Definition den ForeignKey für die Spalte, um den Fremdschlüssel festzulegen.

class_id=Column(Integer,ForeignKey('class.id'))

• Beziehungseinstellung: Stellen Sie über das Beziehungsschlüsselwort einen Verweis auf die Worttabelle im übergeordneten Modell her. Die Beziehungseinstellung im Klassenmodell lautet beispielsweise wie folgt folgt:

students=relationship("Student",backref="calss")

Der backref-Parameter ist ein optionaler Parameter. Wenn backref gesetzt ist, setzt diese Anweisung auch den Verweis von der übergeordneten Tabelle auf die untergeordnete Tabelle.

• Verwendung einer Eins-zu-Viele-Beziehung: Zukünftig können Sie die Informationen aller Schüler in der entsprechenden Klasse direkt über das Schülerattribut abrufen. Mit dem folgenden Code können alle Schülerinformationen der Klasse [Klasse 3, Klasse 2] gedruckt werden.

class=session.query(Class).filter(Clss.name=="三年二班").first()

for student in class_.students:
    print(student)

• Verwendung einer Viele-zu-Viele-Beziehung: implementiert durch das zugehörige Modell ClassTeacher, wobei die Fremdschlüssel des Modells Class und Teacher jeweils festgelegt werden, und Im übergeordneten Modell festgelegt Die entsprechende Beziehung wird implementiert. Die Viele-zu-Viele-Beziehung kann man sich auch als Assoziationstabelle vorstellen, die eine Viele-zu-Eins-Beziehung zwischen zwei übergeordneten Tabellen implementiert. Es besteht eine Viele-zu-Viele-Beziehung zwischen Klassen und Lehrern. Der folgende Code kann die Informationen aller Lehrer in der Klasse [Klasse 2, Klasse 3] drucken

class=session.query(Class).filter(Class.name=="三年二班").first()
for class_teacher in class_.class_teachers:
    teacher=class_teacher.teacher
    print(teacher)

Im obigen Code class_teacher .teacher wird in der von ClassTeacher definierten Modell-Teacher-Backreference als Ziel verwendet.

2. Verbindungsabfrage

Wenn in der tatsächlichen Entwicklung eine Beziehung besteht, ist eine Verbindungsabfrage mit mehreren Tabellen zwangsläufig erforderlich. Das Folgende ist ein praktisches Beispiel, um zu demonstrieren, wie Multi-Table-Join-Abfragen durchgeführt werden.

Sie können das Schlüsselwort „join“ in der Abfrageanweisung verwenden, um eine Verbindungsabfrage durchzuführen und die Namen aller Schüler der dritten Klasse auszugeben:

students=session.query(Student).join(Class).filter(Class.level==3).all()
for student in students:
    print(student.namr)

Die obige Abfragefunktion verwendet automatisch den Fremdschlüssel Beziehung als Verbindungsbedingung. Diese Abfrage wird von SQLAlchemy automatisch in die folgende SQL-Anweisung übersetzt und ausgeführt:

SELECT student.student_id AS student_student_id,
    student.name AS student.name,
    student.age AS student.age,
    student.gender AS student.gender,
    student.address AS student.address,
    student.class_id AS student_class_id
FROM student JOIN class ON student.class_id=class.class_id
WHERE class.leve=?
(3,)

Wenn Sie den Inhalt der verbundenen Tabelle ausdrucken müssen, können Sie mehrere Tabellenobjekte in angeben Abfrage.

Die folgende Anweisung gibt die Namen aller Drittklässler sowie die Namen ihrer Klassen aus.

for student,class_ in session.query(Student,Class).join(Class).filter(Class.level==3).all():
    print(student.name,class_.name)

Die obige Abfragefunktion verwendet automatisch die Fremdschlüsselbeziehung als Verbindungsbedingung. Die Abfrage wird von SQLAlchemy automatisch in die folgende SQL-Anweisung übersetzt und ausgeführt:

SELECT student.student_id AS student_student_id,
    student.name AS student.name,
    student.age AS student.age,
    student.gender AS student.gender,
    student.address AS student.address,
    student.class_id AS student_class_id,
    class.class_id AS class_class_id,
    class.name AS class_name,
    class.level AS class_level,
    class.address AS class_location
FROM student JOIN class ON student.class_id=class.class_id
WHERE class.leve=?
(3,)

Bei Bedarf andere Felder als Fremdschlüssel als Die Verbindungsbedingungen müssen vom Entwickler im Join festgelegt werden. Im Folgenden werden die Namen aller Schüler ausgegeben, deren Klassenadresse mit der Adresse des Schülers übereinstimmt:

for student_name, in session.query(Student.name).join(Class,Class.address==Student.address).filter(Class.level==3).all():
    print(student_name)

Die obige Abfragefunktion verwendet die vom Entwickler angegebene Anweisung als Verbindungsbedingung und weil das abgefragte Feld ist direkt angegeben, reduziert es die abgefragten Felder in tatsächlichem SQL und verbessert die Leistung. Die Abfrage wird von SQLAlchemy automatisch in die folgende SQL-Anweisung zur Ausführung übersetzt:

SELECT student.name AS student_name, FROM student JOIN class ON student.address=class.address

Das obige ist der detaillierte Inhalt vonEinführung in relationale SQLAlchemy-Operationen unter Python (mit Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!