Flask-SQLAlchemy
参考学习了 阮一峰ORM 实例教程
面向对象编程把所有实体看成对象（object），关系型数据库则是采用实体之间的关系（relation）连接数据。ORM就是通过面向对象的思维去操作数据库，ORM 使用对象封装了数据库操作，因此可以不碰 SQL 语言。开发者只使用面向对象编程，与数据对象直接交互，不用关心底层数据库。
ORM 把数据库映射成对象：
- 数据库的表（table） --> 类（class）
- 记录（record，行数据）--> 对象（object）
- 字段（field）--> 对象的属性（attribute）
许多语言都有自己的 ORM 库，最典型、最规范的实现公认是 Ruby 语言的 Active Record。Active Record 对于对象和数据库表的映射，有一些命名限制。
（1）一个类对应一张表。类名是单数，且首字母大写；表名是复数，且全部是小写。比如，表books对应类Book。
（2）如果名字是不规则复数，则类名依照英语习惯命名，比如，表mice对应类Mouse，表people对应类Person。
（3）如果名字包含多个单词，那么类名使用首字母全部大写的骆驼拼写法，而表名使用下划线分隔的小写单词。比如，表book_clubs对应类BookClub，表line_items对应类LineItem。
（4）每个表都必须有一个主键字段，通常是叫做id的整数字段。外键字段名约定为单数的表名 + 下划线 + id，比如item_id表示该字段对应items表的id字段。
SQLAlchemy是一个强大的关系型数据库框架，提供了高层ORM，也提供了使用数据库原生SQL的功能，Flask-SQLAlchemy是一个Flask扩展，简化了SQLAlchemy的操作。
SQLAlchemy创建的数据库实例为模型提供了一个基类以及一系列的辅助类、辅助函数，可用于定义模型的数据结构。
一对多：
1、定义模型
比如：一个Role对应对应多个User, 一个User对应多个Post
#定义模型 class Role(db.Model): __tablename__ = 'roles' id = db.Column(db.INTEGER, primary_key=True) name = db.Column(db.String(64), unique=True) def __repr__(self): return self.name class User(db.Model): __tablename__ = 'users' id = db.Column(db.INTEGER, primary_key=True) username = db.Column(db.String(64), unique=True, index=True) def __repr__(self): return self.username
2、建立关系
class Role(db.Model): #...... # relationship给Role类增加了一个users属性，内容是以role.id为关联的一组User， # backref='role'给User类增加了一个role属性，内容是以role.id为关联的Role，可以代替role_id访问Role模型（通过u.role），否则只能用u.role_id
# 第一个参数是建立关系的表名称 users = db.relationship('User', backref='role') class User(db.Model): #...... role_id = db.Column(db.INTEGER, db.ForeignKey('roles.id')) #定义关系，在多的一侧加入一个外键关联，指向“一”这一侧的记录，对应到Role中的id，建立“一对多”的关系，
3、准备数据
def insert_data(): admin_role = Role(name='Admin') mod_role = Role(name='Mod') user_role = Role(name='User') #如果没有backref='role',则只能通过role_id=1来插入数据 user_join = User(username='join', role=admin_role) user_susan = User(username='susan', role_id=3) user_david = User(username='david', role=user_role) db.session.add_all([admin_role, mod_role, user_role, user_join, user_susan, user_david]) if __name__ == '__main__': insert_data() db.session.commit()
4、查询
for r in Role.query.all(): print('Role自身数据:{},{}'.format(r.id, r.name)) print('r.user:{}'.format(r.users))# relationship给Role类增加了一个users属性，内容是以role.id为关联的一组User for u in User.query.all(): print('User自身数据:{},{}'.format(u.id, u.username)) print('正向，外键foreignkey作用：role_id={}，role={}'.format(u.role_id, u.role)) # backref='role'给User类增加了一个role属性，内容是以role.id为关联的Role。 print('反向，backfer字段：b.role.name={}'.format(u.role.name))
5、可以在视图函数中直接操作数据库
多对多：
多对多关系可以分解成原表和关联表之间的两个多对一的关系，通过一个关联表将两个表关联起来。
1、建立模型
# 关联表，第一个参数为中间表的表名，然后在表中添加两个字段，这两个字段分别为关联的两个表的一对多的外键，也同为主键
# 关联表就是一个简单的表，不是模型，SQLAlchemy会自动接收这个表
registrations =db.Table('registrations', db.Column('student_id', db.INTEGER, db.ForeignKey('students.id'), primary_key=True), db.Column('class_id', db.INTEGER, db.ForeignKey('classes.id'), primary_key=True)) class Student(db.Model): __tablename__ = 'students' id = db.Column(db.INTEGER, primary_key=True) name = db.Column(db.String(64)) # 多对多可以在任意一方中添加一个relationship字段，第一个参数为关联的另外一个表， # 第二个参数为中间表的表名，第三个参数backref是反向查询时的关键字（这里给Student增加了一个classes属性，给Class增加了一个students属性） classes = db.relationship('Class', secondary=registrations, backref='students', lazy='dynamic') def __repr__(self): return self.name class Class(db.Model): __tablename__ = 'classes' id = db.Column(db.INTEGER, primary_key=True) name = db.Column(db.String(64)) def __repr__(self): return self.name
2、准备数据
def insert_data2(): stu1 = Student(name='cc') stu2 = Student(name='dd') cur1 = Class(name="python") cur2 = Class(name="c") cur3 = Class(name="java") # 关联数据,给student添加classes属性 stu1.classes.append(cur1) stu1.classes.append(cur2) stu2.classes.append(cur2) stu2.classes.append(cur3) # 添加到数据库 db.session.add_all([stu1, stu2, cur1, cur2, cur3]) db.session.commit()
3、查询
# 通过student查询classes courses = Student.query.filter_by(name='dd').first().classes.all()#这里最后的all()是因为前面的lazy='dynamic' print('dd的courses:', courses) # 通过classes查询students stus = Class.query.filter_by(name='c').first().students print('c课程stuents:', stus)
自引用关系：
学生和课程的多对多关系中，是两个实例之间的多对多关系。
但是关注用户存在的多对多关系，只有用户一个实例。如果关系中的两侧都在同一个表中，这种关系成为自引用关系。
1、关联表的模型
# 多对多关系，关联表完全是由SQLALchemy掌控的内部表，为了能在关系中处理自定义的数据，提升关联表的地位，使用程序可访问的模型 # 要把这个多对多关系的左右两侧拆分成两个基本的一对多关系 class Follow(db.Model): __tablename__ = 'follows' # follower_id、followed_id外键关联的都是users.id，因为是只有一个实例的自引用关系 follower_id = db.Column(db.INTEGER, db.ForeignKey('users.id'), primary_key=True) followed_id = db.Column(db.INTEGER, db.ForeignKey('users.id'), primary_key=True) timestamp = db.Column(db.DATETIME, default=datetime.utcnow)
2、在User模型中增加外键关联，实现两个一对多的关系
# 用户模型 class User(UserMixin, db.Model): #... # 把这个多对多关系的左右两侧拆分成两个基本的一对多关系 # 建立一对多关系，给User增加一个followed属性（被关注的），给Follow增加一个follower属性（关注者） followed = db.relationship('Follow', foreign_keys=[Follow.follower_id],#为了消除外键之间的歧义，建立关系是使用foreign_keys指定的外键 backref=db.backref('follower', lazy='joined'),#回引Follow模型，joined实现立即从联结查询中加载相关对象 lazy='dynamic',#不会直接返回记录，而是返回查询对象，可在其上添加过滤器 cascade='all, delete-orphan')#配置在父对象上执行的操作对相关对象的影响 # 建立一对多关系，给User增加一个followers属性，给Follow增加一个followed属性 followers = db.relationship('Follow', foreign_keys=[Follow.followed_id],#为了消除外键之间的歧义，建立关系是使用foreign_keys指定的外键 backref=db.backref('followed', lazy='joined'),#回引Follow模型，joined实现立即从联结查询中加载相关对象 lazy='dynamic', cascade='all, delete-orphan')
3、增加数据
david = User.query.filter_by(username='david').first() #id=1 susan = User.query.filter_by(username='susan').first() #id=2 john = User.query.filter_by(username='john').first() #id=3 john.follow(david) susan.follow(john) susan.follow(david)
follows表如下：
| follower_id | followed_id | timestamp |
| 1 | 3 | 2020-04-19 13:23:36 |
| 2 | 1 | 2020-04-19 13:23:39 |
| 2 | 3 | 2020-04-19 13:23:45 |
4、查询
john.is_following(david) #True david.is_followed_by(john) #True david.is_followed_by(susan) #True john.is_following(susan) #False john.followed.count()#1 susan.followed.count() #2 被susan关注的人 susan.followers.count() #0 关注susan的人 j = john.followed.first() #得到的是一个Follow模型 j.followed_id #3--------->followed:david j.follower_id #1--------->follower:john for i in susan.followed.all(): print(i.followed_id) #1 3 被susan关注的人 for j in david.followers.all(): print(j.follower_id) #1 2 关注daivd的人
