用SQLAlchemy创建一对多，多对多关系表

多对多关系表的创建：

如果建立好多对多关系后，我们就可以通过关系名进行循环查找，比如laowang = Teacher.query.filter(Teacher.name=='laowang').first().classes[0].teachers,

表示查找老师表中名为老王的所有教的班级中教第一个班级的所有老师对象，复杂吧，不过建立好关系了，这些程序都会自动帮你找到相关数据。

#多对多的关系的表，不是用class建立，而是用db.Table,此处连接的外键都是对象相应的id
association_table = db.Table('teacher_classes',db.metadata,
db.Column('teacher_id',db.Integer,db.ForeignKey('teacher.id')),
db.Column('classes_id',db.Integer,db.ForeignKey('classes.id'))
)



class Teacher(db.Model):
  __tablename__ = 'teacher'
  id = db.Column(db.Integer,primary_key=True)
  tno = db.Column(db.String(10))
  name = db.Column(db.String(50))
  age = db.Column(db.Integer)
  # eacher.query.filter(条件).first()可获取一个对象
  # 建立关系，通过Teacher.query.filter(条件).first().classes即可获取该老师对象的教的所有班级
  # 通过Classes.query.filter(条件).first().teachers即可获取教该班级对象的所有老师对象信息
  # 参数secondary即是上面建立的多对多关系的表
  classes = db.relationship('Classes',secondary=association_table,back_populates='teachers')
  def __str__(self):
      return '{id:%s,tno:%s,name:%s,age:%s}'%(self.id,self.tno,self.name,self.age)
  def __repr__(self):
      return self.__str__()



class Classes(db.Model):
  __tablename__ = 'classes'
  id = db.Column(db.Integer,primary_key=True)
  cno = db.Column(db.String(10))
  name = db.Column(db.String(50))
  # 建立关系，通过Teacher.query.filter(条件).first().classes即可获取该老师对象的教的所有班级信息
  # 通过Classes.query.filter(条件).first().teachers即可获取教该班级对象的所有老师对象信息
  teachers = db.relationship('Teacher',secondary=association_table,back_populates='classes')
  def __str__(self):
      return self.name
  def __repr__(self):
      return self.__str__()





db.create_all()

完整代码：

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import pymysql
pymysql.install_as_MySQLdb()
import config

app = Flask(__name__)
app.config.from_object(config)

db = SQLAlchemy(app) #与数据库建立连接



#多对多的关系的表，不是用class建立，而是用db.Table,此处连接的外键都是对象相应的id
association_table = db.Table('teacher_classes',db.metadata,
db.Column('teacher_id',db.Integer,db.ForeignKey('teacher.id')),
db.Column('classes_id',db.Integer,db.ForeignKey('classes.id'))
)



class Teacher(db.Model):
  __tablename__ = 'teacher'
  id = db.Column(db.Integer,primary_key=True)
  tno = db.Column(db.String(10))
  name = db.Column(db.String(50))
  age = db.Column(db.Integer)
  # eacher.query.filter(条件).first()可获取一个对象
  # 建立关系，通过Teacher.query.filter(条件).first().classes即可获取该老师对象的教的所有班级
  # 通过Classes.query.filter(条件).first().teachers即可获取教该班级对象的所有老师对象信息
  # 参数secondary即是上面建立的多对多关系的表
  classes = db.relationship('Classes',secondary=association_table,back_populates='teachers')
  def __str__(self):
      return '{id:%s,tno:%s,name:%s,age:%s}'%(self.id,self.tno,self.name,self.age)
  def __repr__(self):
      return self.__str__()



class Classes(db.Model):
  __tablename__ = 'classes'
  id = db.Column(db.Integer,primary_key=True)
  cno = db.Column(db.String(10))
  name = db.Column(db.String(50))
  # 建立关系，通过Teacher.query.filter(条件).first().classes即可获取该老师对象的教的所有班级信息
  # 通过Classes.query.filter(条件).first().teachers即可获取教该班级对象的所有老师对象信息
  teachers = db.relationship('Teacher',secondary=association_table,back_populates='classes')
  def __str__(self):
      return self.name
  def __repr__(self):
      return self.__str__()





db.create_all()

# 实例化，并操作数据库
@app.route('/')
def hello_world():
    teacher1 = Teacher(tno=10,name='laowang',age=29)
    teacher2 = Teacher(tno=10, name='laoli', age=29)
    db.session.add(teacher1)
    db.session.add(teacher2)
    
    banji = Classes(cno='6年1班',name='6年1班')
    banji2 = Classes(cno='6年2班', name='6年2班')
    db.session.add(banji)
    db.session.add(banji2)


    
    
    db.session.commit()
    #

    # teacher1 = Teacher.query.filter(Teacher.id == 1).first()
    # 查找老师表中名为laowang所教的所有班级对象
    laowang = Teacher.query.filter(Teacher.name=='laowang').first()
    laowangClass = laowang.classes
    print(laowang)
    print(laowangClass)
    # 打印教第一个班级所有的老师对象,
    print(laowangClass[0].teachers)



    return 'helloworld'



if __name__ == '__main__':
    app.run()

此处的config配置：

from datetime import timedelta
DEBUG = True
SECRET_KEY = "123456"
PERMANENT_SESSION_LIFETIME = timedelta(days=7)


HOSTNAME = '127.0.0.1'  # 主机名
PORT = 3306  # 端口号
DATABASE = 'cms'  # 数据库名称
USERNAME = 'root'  # 用户名
PASSWORD = '123456'  # 密码


#数据库SQLAlchemy，SQLALCHEMY_DATABASE_URI
DB_URI = 'mysql+mysqldb://{}:{}@{}:{}/{}?charset=utf8'.format(
    USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)
SQLALCHEMY_DATABASE_URI = DB_URI

SQLALCHEMY_TRACK_MODIFICATIONS = False

一对多的关系：

class User(db.Model):
    __tablename__ = 'user' #如果不想将类名作为表名，可以使用这个方式更改表名
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    username = db.Column(db.String(100),nullable=False)

class Article(db.Model):
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    title = db.Column(db.String(100),nullable=False)
    content = db.Column(db.Text,nullable=False)
    # 设置作者ID，user表里的id，使2表通过anthor_id联系在一起
    author_id = db.Column(db.Integer,db.ForeignKey('user.id'))
    # 通过Article.query.filter(条件).author即可查找到相应文章的作者信息
    # 通过User.query.filter(条件).articles即可查找相应的用户对应的文章
    author = db.relationship('User',backref=db.backref('articles'))

    # author = db.relationship('User',backref=db.backref('articles'))

    #1对1是1对多的一种特殊情况，只需要在最后设置uselist=False,表示限定每个用户只能写一篇文章
    # author = db.relationship('User', backref=db.backref('articles'), uselist=False)



db.create_all()