做一个项目，必然是少不了数据库设计的！在学习阶段，基本都是单表。然而在实际开发过程中，一对多，多对多的表处处都是！简单整理一下，一对多，多对多表如何设计整理一下思路：
       数据库实体间有三种对应关系：一对一，一对多，多对多。
       一对一关系示例：
一个学生对应一个学生档案材料，或者每个人都有唯一的身份证编号。
       一对多关系示例：
一个学生只属于一个班，但是一个班级有多名学生。
       多对多关系示例：
一个学生可以选择多门课，一门课也有多名学生。
1.一对多关系处理：
       通过学生和班级问题了解一对多：
       设计数据库表：只需在 学生表 中多添加一个班级号的ID；
注：在数据库中表中初学时，还是通过添加主外键约束，避免删除数据时造成数据混乱！
 
2.多对多关系处理：
    通过学生选课了解多对多问题的处理：
 
       在多对多中在一个表中添加一个字段就行不通了，所以处理多对多表问题时，就要考虑建立关系表了
例：
 学生表：     课程表：   关系表：
 
注：所以对于多对多表，通过关系表就建立起了两张表的联系！多对多表时建立主外键后，要先删除约束表内容再删除主表内容

thinkPHP5中的数据库的关系基本分为：一对一、多对一、多对多这三种
一.引例
1、一对一关系实例
一个老师对应一个id，一个id对应一个老师  
2、多对一关系实例   
一个班级拥有多个学生，一个学生只能够属于某个班级 
3、多对多实例
一个学生可以选修多门课程，一个课程可以被多个学生选修
二.一对一
一对一的关系下，thinkPHP框架可以直接访问数据库中的数据，像下面一样  
class TeacherController
{
    public function index()
    {
        $Teacher = new Teacher;
        $teachers = $Teacher->select();
        var_dump($teachers);
    }
}
这样可以直接输出teacher的所有信息
三.多对一
多对一的关系

在thinkPHP5中
多个学生对应于一个班级，这种情况下的访问法则为：
2、在这个方法中，通过一个id字段来获取这个对象；  
3、返回这个对象。
4，用该对象访问各种数据
以一个klass类为例子
 public function Klass()
{
   return $this->belongsTo('Klass');
}
四.多对多
多对多的访问比较复杂，需要通过中间表来完成，像这样

通过访问中间表来取得班级对应的课程
在thinkPHP5中可以自动对中间表进行操作，十分方便
但是thinkPHP中同样存在着bug：
BUG1：
在Course中关联Klass，如果不加任何设置（直接将代码写为：return $this->belongsToMany(‘Klass’);），thinkphp 会尝试找course_klass这张表；而在Klass中关联Course，那么 thinkphp 则会尝试找klass_course这张表。显然，中间表只能有一个名字。这就使得我们在使用多对多关联时，还需要设置中间表的名字。
BUG2：
当我们传入表名时，thinkphp 没有自动为我们加入表前缀。这使得我们需要手动的进行配置，但显然我更希望默认是自动加入表前缀的。
​

Flask 数据库 一对多 多对多



app.py
import os
from flask import Flask
# 引入表格模块
from flask_sqlalchemy import SQLAlchemy
#导入pymysql
import pymysql
#用pymysql 代替 MySqldb
pymysql.install_as_MySQLdb()
app=Flask(__name__)
# 获取文件路径
BASE_DIR=os.path.abspath(os.path.dirname(__file__))
# 配置数据库sqlite
app.config['SQLALCHEMY_DATABASE_URI']='sqlite:///'+os.path.join(BASE_DIR,'sqlite3.db')
#配置数据库mysql
# app.config['SQLALCHEMY_DATABASE_URI']='mysql://root:root@127.0.0.1:3306/test'
# 创建一个父类让python中的类去继承 就可映射成表格
db=SQLAlchemy(app)


main.py
#控制文件
from app import app
from models import db
from views import *


if __name__ == '__main__':
	#删除所有表
    db.drop_all()
    #创建所有表
    db.create_all()
    app.run(debug=True)

models.py
#存放类模块
from app import db
#抽象父类
class Base(db.Model):
    __abstract__=True
    id = db.Column(db.INT, primary_key=True, autoincrement=True)
    #添加员工
    def save(self):
        # 保存对象
        db.session.add(self)
        # 提交事务
        db.session.commit()
    def updte(self):
        db.session.commit()
    def delete(self):
        # 删除对象
        db.session.delete(self)
        # 提交事务
        db.session.commit()
#职位
class Position(Base):
    __tablename__="position"

    name=db.Column(db.String(32)) #职位名称
    level=db.Column(db.Integer)  #级别
    #关系属性
    #为了查询方便,flask提供了关系属性,为了方便查询,但是不会在数据库中生成相应的字段
    persons=db.relationship("Person",backref='position')
    #当知道职位查询所有的员工时,通过 职位对象.persons就可以获得所有的员工
    # 当员工查询对应的职位的时候,通过 员工对象.position就可获得对应的职位
# 职员
class Person(Base):
    """雇员表"""
    __tablename__ = "person"

    username = db.Column(db.VARCHAR(100))
    password = db.Column(db.VARCHAR(64))

    nickname = db.Column(db.String(64), nullable=True)  # 昵称
    gender = db.Column(db.String(8), nullable=True)  # 性别
    age = db.Column(db.Integer, nullable=True)  # 年龄
    workid = db.Column(db.String(32), nullable=True)  # 工号
    phone = db.Column(db.String(64), nullable=True)  # 电话
    email = db.Column(db.String(64), nullable=True)  # 邮箱
    photo = db.Column(db.String(64), nullable=True)  # 照片
    address = db.Column(db.Text, nullable=True)  # 地址
    score = db.Column(db.Float, nullable=True)  # 绩效
    #关系属性
    #职位和员工一对多关系
    position_id=db.Column(db.Integer,db.ForeignKey("position.id"))
#职位与权限中间表
permission_position=db.Table(
    'permission_position',
    db.Column("id",db.Integer,primary_key=True,autoincrement=True),
    db.Column("position_id",db.Integer,db.ForeignKey("position.id")), #关联position
    db.Column("permission_id",db.Integer,db.ForeignKey("permission.id")), #关联permission
)
#权限表
class Permission(Base):
    __tablename__="permission"

    name=db.Column(db.String(32)) #权限名称
    desc=db.Column(db.String(128)) #权限描述

    #关系属性
    positions=db.relationship(
        'Position',# 和模型类进行关联
        backref='permissions',
        secondary=permission_position
    )

from sqlalchemy import func, or_,and_,not_

from  app import app
from models import *

@app.route('/')
def index():
    return "index"
# 查询所有员工
@app.route('/SelectAll')
def SelectAll():
    # 得到Person表中所有数据(select * from person)
    res=Person.query.all() #得到的是一个列表对象
    for person in res:
        #得到person对象
        for key,value in person.__dict__.items():
            if value!=None:
                print(f"{key}:{value}",end=" ")
        print()
    return "SelectAll"
# 根据id来查找
@app.route('/Select_By_Id/<int:id>')
def Select_By_Id(id):
    Person_list=Person.query.filter(Person.id==id) #得到的是一个sql语句
    res=Person_list.all()
    print(res) #当id=1时  [<Person 1>] 当没有找到时 []
    return "Select_By_Id"
#条件语句
@app.route('/Filter')
def Filter():
    # like 模糊查询
    ret=Person.query.filter(Person.username.like("z%")).all()
    #  limit()限制返回条数
    # ret2=Person.query.limit(2).all()
    # 偏移1条记录,返回2条记录
    ret2=Person.query.limit(2).offset(1).all()
    # order_by() 排序 Person.id.desc() 降序 asc():升序
    ret3=Person.query.order_by(Person.id.desc()).all()
    # 分组  group_by     query(Person.gender,func.count(Person.id))=>select gender,count(id) from person
    ret4=db.session.query(Person.gender,func.count(Person.id)).group_by(Person.gender).all()
    # 逻辑判断 and_,or_,not_
    ret5=Person.query.filter(or_(Person.gender=="男",Person.age>18)).all()

    print(ret) #[<Person 2>]
    print(ret2) #[<Person 2>, <Person 3>]
    print(ret3) #[<Person 4>, <Person 3>, <Person 2>, <Person 1>]
    print(ret4) #[('女', 1), ('男', 3)]
    print(ret5) #[<Person 1>, <Person 2>, <Person 3>, <Person 4>]
    return "Filter"
# 添加员工
@app.route('/add_person')
def add_person():
    # 创建员工对象
    person = Person()
    person.name="zhangsan"
    person.age=18
    person.save()
    return 'add person'

# 用户修改
@app.route('/Person_Update')
def Person_Update():
    person_obj=Person.query.get(1)
    person_obj.age=30
    # 提交事务
    db.session.commit()
    return "update"
@app.route('/Person_Del')
def Person_Del():
    person=Person.query.get(2)
    person.delete()
    return "Person_Del"

#一对多添加
@app.route('/one_add')
def one_add():
    #添加员工
    person = Person(username="zhangsan",age=18,nickname="张三")
    person2 = Person(username="lisi",age=28,nickname="李四")
    person.save()
    person2.save()
    #添加职位
    pos1=Position(name="职员",level=1)
    pos2=Position(name="产品经理",level=2)
    pos1.save()
    pos2.save()
    # 设置关系
    #   张三的职位是职员 李四的职位是产品经理
    # 正向设置关系
    pos1=Position.query.filter(Position.level==1).first() #获取职员对象
    person=Person.query.filter(Person.nickname=="张三").first() #获取张三对象
    pos1.persons=[person]
    pos1.save()
    # 反向设置关系
    pos2 = Position.query.filter(Position.level == 2).first()  # 获取产品经理
    person2 = Person.query.filter(Person.nickname == "李四").first()  # 获取李四
    person2.position=pos2
    person2.save()
    return "one_add"
#多对多添加
@app.route('/two_add')
def two_add():
    #增加权限
    p_list=["考勤权限","新闻权限","人事权限","权限管理"]
    for p in p_list:
        permission_obj=Permission(name=p,desc=p+'crud')
        permission_obj.save()
    #   增加职位
    pos_obj=Position(name="开发工程师",level=3)
    pos_obj2=Position(name="高级开发工程师",level=4)
    pos_obj.save()
    pos_obj2.save()
    # 设置关系
    #正向设置关系
    #   给考勤权限设置 开发工程师 和高级工程师职位
    per_obj=Permission.query.get(1)
    per_obj.positions=[pos_obj,pos_obj2]
    per_obj.save()
    return "two_add"

数据库一对一、一对多、多对多关系


     本来数据库一对一、一对多、多对多关系并不复杂，但是最近在理解的时候感觉又感觉多了写新意，所以现在在来总结一下吧
一、首先给出三种关系的实例
1、一对一关系实例
   * 一个人对应一张身份证，一张身份证对应一个人
2、一对多关系实例
   * 一个班级拥有多个学生，一个学生只能够属于某个班级
3、多对多实例
   * 一个学生可以选修多门课程，一个课程可以被多个学生选修


二、一对一关系


一对一关系是最好理解的一种关系，在数据库建表的时候可以将人表的主键放置与身份证表里面，也可以将身份证表的主键放置于人表里面


三、一对多关系





班级是1端，学生是多端，结合面向对象的思想，1端是父亲，多端是儿子，所以多端具有1端的属性，也就是说多端里面应该放置1端的主键，那么学生表里面应该放置班级表里面的主键

四、多对多关系

对于多对多关系，需要转换成1对多关系，那么就需要一张中间表来转换，这张中间表里面需要存放学生表里面的主键和课程表里面的主键，此时学生与中间表示1对多关系，课程与中间表是1对多关系，学生与课程是多对多关系
四、总结
总而言之，最重要的关系就是1对多关系，根据面向对象思想在建表的时候将1端主键置于多端即可。