Introduction aux opérations relationnelles SQLAlchemy sous Python (avec code)

Cet article vous présente une introduction aux opérations relationnelles SQLAlchemy sous Python (avec code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

La base de données relationnelle est une base de données basée sur le modèle relationnel, la relation entre les tables est donc particulièrement importante dans la programmation de bases de données. Cette section se concentre sur la façon de définir des relations dans SQLAlchemy et sur la façon d'utiliser les relations pour effectuer des requêtes, afin que les lecteurs puissent rapidement maîtriser les opérations relationnelles de SQLAlchemy.

1. Cas

Concevoir 3 tables d'entités : table de classe, table d'étudiant, table d'enseignant et 1 table relationnelle : class_teacher. Il existe une relation un-à-plusieurs entre les classes et les élèves, et une relation plusieurs-à-plusieurs entre les classes et les enseignants.

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)

Le code utilise 4 modèles SQLAlchemy pour définir 4 tables. Les parties liées à la définition de la relation sont les suivantes :

• Paramètres des clés étrangères : Dans la colonne. définition, transmettez la clé étrangère pour la colonne pour définir la clé étrangère.

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

• Paramètres de relation : établissez une référence à la table de mots dans le modèle parent via le mot-clé de relation. Par exemple, les paramètres de relation dans le modèle de classe. sont les suivants :

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

Le paramètre backref est un paramètre facultatif. Si backref est défini, cette instruction définit également une référence à la table enfant à partir de la table parent.

• Utilisation de la relation un-à-plusieurs : à l'avenir, vous pourrez obtenir directement les informations de tous les étudiants de la classe concernée via l'attribut étudiants. Le code suivant peut imprimer toutes les informations sur les étudiants de la classe [Classe 3, Classe 2].

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

for student in class_.students:
    print(student)

• Utilisation de la relation plusieurs-à-plusieurs : implémentée via le modèle ClassTeacher associé, où les clés étrangères du modèle Class et Teacher sont définies respectivement ,Et dans le modèle parent Définir l'implémentation de la relation correspondante dans . La relation plusieurs-à-plusieurs peut également être imaginée comme une table d'association, qui implémente une relation plusieurs-à-un entre deux tables parentes. Il existe une relation plusieurs-à-plusieurs entre les classes et les enseignants. Le code suivant peut imprimer les informations de tous les enseignants de la classe [Classe 2, 3e année]

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

Dans le code ci-dessus. , class_teacher.teacher est dans le modèle d'enseignant La référence arrière définie dans ClassTeacher.

2. Requête de connexion

Dans le développement réel, lorsqu'il existe une relation, il existe un besoin inévitable d'une requête de connexion multi-tables. Ce qui suit est un exemple pratique pour montrer comment effectuer des requêtes de jointure multi-tables.

Vous pouvez utiliser le mot-clé join dans l'instruction de requête pour effectuer une requête de connexion et imprimer les noms de tous les élèves de troisième année :

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

La fonction de requête ci-dessus utilisera automatiquement le relation de clé étrangère comme condition de connexion. La requête est automatiquement traduite en l'instruction SQL suivante par SQLAlchemy et exécutée :

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

Si vous devez imprimer le contenu de la table connectée, vous pouvez spécifier plusieurs tables. objets dans la requête.

La déclaration suivante imprime les noms de tous les élèves de troisième année ainsi que les noms de leurs classes.

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

La fonction de requête ci-dessus utilisera automatiquement la relation de clé étrangère comme condition de connexion. La requête sera automatiquement traduite par SQLAlchemy dans l'instruction SQL suivante et exécutée :

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

Si vous devez utiliser des clés étrangères. D'autres champs comme conditions de jointure doivent être définis par le développeur dans la jointure. Ce qui suit imprime les noms des étudiants dont l'adresse de classe est la même que l'adresse de l'étudiant :

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

La fonction de requête ci-dessus utilise l'instruction spécifiée par le développeur comme condition de connexion, et parce que le champ interrogé est directement spécifié, le nombre de champs interrogés dans le SQL réel est réduit et les performances sont améliorées. La requête est automatiquement traduite par SQLAlchemy en l'instruction SQL suivante pour exécution :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!