flask的进阶使用方法

【一】一对多关系

# 1 一对一   [本质就是一对多--》多的那个唯一]
# 2 一对多
# 3 多对多

1.1 关系

####  一对多关系
class Hobby(Base):__tablename__ = 'hobby'id = Column(Integer, primary_key=True)caption = Column(String(50), default='篮球')def __str__(self):return self.captionclass Person(Base):__tablename__ = 'person'nid = Column(Integer, primary_key=True)name = Column(String(32), index=True, nullable=True)# hobby指的是tablename而不是类名hobby_id = Column(Integer, ForeignKey("hobby.id"))  # 一个爱好，可以被多个人喜欢，一个人只能喜欢一个爱好# 跟数据库无关，不会新增字段，只用于快速链表操作# 类名，backref用于反向查询hobby = relationship('Hobby', backref='pers')def __str__(self):return self.namedef __repr__(self):return self.name

from models import Person,Hobby
# 第一步：创建engine
from sqlalchemy import create_engine
engine = create_engine("mysql+pymysql://root:1234@127.0.0.1:3306/sqlalchemy001?charset=utf8",max_overflow=0,  # 超过连接池大小外最多创建的连接pool_size=5,  # 连接池大小pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)# 第二步：创建 session对象---老方式
from sqlalchemy.orm import Session
session=Session(engine)if __name__ == '__main__':### 笨办法增加#1 先增加一个hobby# hobby=Hobby()# session.add(hobby)# session.commit()#2 增加Person---》必须要有hobby_id# person=Person(name='lqz',hobby_id=1)# session.add(person)# session.commit()### 简便方法--》增加person的同时，增加了Hobby# person = Person(name='lqz', hobby=Hobby(caption='乒乓球'))# session.add(person)# session.commit()# hobby=session.query(Hobby).filter_by(id=1).first()# person = Person(name='lqz3', hobby=hobby)# session.add(person)# session.commit()# 基于对象的跨表查询--->正向# person=session.query(Person).filter_by(nid=2).first()# print(person)# print(person.hobby_id)# print(person.hobby)# 基于对象的跨表查询--->反向hobby = session.query(Hobby).filter_by(id=1).first()print(hobby.caption)print(hobby.pers)

models.py

from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
import datetime# 新版本创建基类
# 第一步：创建基类，以后所有类，都必须继承基类
from sqlalchemy.orm import DeclarativeBase, relationshipclass Base(DeclarativeBase):pass### 第二步：写个类，继承
### 第三步：写字段：传统方式，类型方式class User(Base):__tablename__ = 'user'id = Column(Integer, primary_key=True, autoincrement=True)# name列varchar32，索引，不可为空 nullable=Falsename = Column(String(32), index=True, nullable=False)# email 列，varchar32，唯一email = Column(String(32), unique=True)ctime = Column(DateTime, default=datetime.datetime.now)extra = Column(Text, nullable=True)def __repr__(self):return f"<User(name={self.name}, email={self.email})>"####  一对多关系
class Hobby(Base):__tablename__ = 'hobby'id = Column(Integer, primary_key=True)caption = Column(String(50), default='篮球')def __str__(self):return self.captionclass Person(Base):__tablename__ = 'person'nid = Column(Integer, primary_key=True)name = Column(String(32), index=True, nullable=True)# hobby指的是tablename而不是类名hobby_id = Column(Integer, ForeignKey("hobby.id"))  # 一个爱好，可以被多个人喜欢，一个人只能喜欢一个爱好# 跟数据库无关，不会新增字段，只用于快速链表操作# 类名，backref用于反向查询hobby = relationship('Hobby', backref='pers')def __str__(self):return self.namedef __repr__(self):return self.nameif __name__ == '__main__':from sqlalchemy import create_engineengine = create_engine("mysql+pymysql://root:123123@127.0.0.1:3306/school?charset=utf8",max_overflow=0,  # 超过连接池大小外最多创建的连接pool_size=5,  # 连接池大小pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）)# 第四步 创建user表Base.metadata.create_all(engine)## 第五步：删除表# Base.metadata.drop_all(engine)

from models import Person, Hobby# 第一步：创建engine
from sqlalchemy import create_engineengine = create_engine("mysql+pymysql://root:123123@127.0.0.1:3306/school?charset=utf8",max_overflow=0,  # 超过连接池大小外最多创建的连接pool_size=5,  # 连接池大小pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)# 第二步 创建 session对象---老方式
from sqlalchemy.orm import Sessionsession = Session(engine)# # 增加一个hobby
res1 = Hobby(caption='rapper')
session.add(res1)# # person ---->>> 必须要有hobby_id
person = Person(name='jingyi', hobby_id=1)
session.add(person)
session.commit()
session.close()## 简便方法--》增加person的同时，增加了Hobby
person = Person(name='jingyi', hobby=Hobby(caption='乒乓球'))
session.add(person)
session.commit()
hobby=session.query(Hobby).filter_by(id=1).first()
person = Person(name='jing', hobby=hobby)
session.add(person)
session.commit()# 基于对象的跨表查询--->正向
person = session.query(Person).filter_by(nid=1).first()
print(person)
print(person.hobby_id)
print(person.hobby)# 基于对象的跨表查询--->反向
hobby = session.query(Hobby).filter_by(id=1).first()
print(hobby.caption)
print(hobby.pers)

基于对象的跨表查询—>正向

基于对象的跨表查询—>反向

【二】多对多关系

modelss.py

from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index, Table
import datetime# 新版本创建基类
# 第一步：创建基类，以后所有类，都必须继承基类
from sqlalchemy.orm import DeclarativeBase, relationshipclass Base(DeclarativeBase):pass### 第二步：写个类，继承
### 第三步：写字段：传统方式，类型方式# 定义关联表 多对多必备可少的参数
association_table = Table('user1_group_association', Base.metadata,Column('user1_id', Integer, ForeignKey('user1.id')),Column('group_id', Integer, ForeignKey('group.id')),UniqueConstraint('user1_id', 'group_id')  # 如果需要的话，可以添加唯一约束)# 定义 User1 模型
class User1(Base):__tablename__ = 'user1'id = Column(Integer, primary_key=True)name = Column(String(32), index=True, nullable=False)groups = relationship("Group", secondary=association_table, backref="users")# 定义 Group 模型
class Group(Base):__tablename__ = 'group'id = Column(Integer, primary_key=True)name = Column(String(32), index=True, nullable=False)if __name__ == '__main__':from sqlalchemy import create_engineengine = create_engine("mysql+pymysql://root:123123@127.0.0.1:3306/school?charset=utf8",max_overflow=0,  # 超过连接池大小外最多创建的连接pool_size=5,  # 连接池大小pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）)# 第四步 创建user表Base.metadata.create_all(engine)## 第五步：删除表# Base.metadata.drop_all(engine)

py
增加

from modelss import User1, Group# 第一步：创建engine
from sqlalchemy import create_engineengine = create_engine("mysql+pymysql://root:123123@127.0.0.1:3306/school?charset=utf8",max_overflow=0,  # 超过连接池大小外最多创建的连接pool_size=5,  # 连接池大小pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)# 第二步 创建 session对象---老方式
from sqlalchemy.orm import Sessionsession = Session(engine)
# # 增加一个group
group1 = Group(name='5A风景区')
group2 = Group(name='大清败家子慈溪')# session.add_all([group1, group2])
# # 增加一个User1
res1 = User1(name='刘亦菲')
res2 = User1(name='赵敏')res1.groups.append(group1)
res2.groups.append(group2)
session.add_all([res1,res2])# 基于对象的跨表查--》正向user = session.query(User1).filter(User1.id == 3).all()[0]
print(user.name)
print(user.groups)session.commit()
session.close()

# 基于对象的跨表查--》正向user = session.query(User1).filter(User1.id == 2).all()[0]
print(user.name)
print(user.groups)group = session.query(Group).filter(Group.id == 3).all()[0]
print(group.name)
print(group.users)

# 基于对象的跨表查–》正向

如果user1表中的字段没有关系可以

user1 = session.query(User1).filter_by(id=2).first()
if user1 is None:print("用户不存在")
else:# 假设你想要关联一个已经存在的组，其id为group_idgroup_id = 2 # 这里替换为你想要关联的组的ID# 查询该组group_to_add = session.query(Group).filter_by(id=group_id).first()if group_to_add is None:print("组不存在")else:# 将组添加到用户的groups列表中user1.groups.append(group_to_add)# 提交事务以保存更改session.commit()print("关联已添加")# 关闭sessionsession.close()

filter[where]查询写条件

# #filter[where]查询  写条件
user1 = session.query(User1).where(User1.id >= 2)
# SELECT user1.id AS user1_id, user1.name AS user1_name
# FROM user1
# WHERE user1.id >= %(id_1)s
user2 = session.query(User1).where(User1.id >= 2).all()
#filter[where]查询  写条件
user3 = session.query(User1).filter(User1.id >= 2).all()
# [小昭, 刘亦菲, 赵敏, 小玲, 小妹]
group1 = session.query(Group).filter_by(name='5A风景区').first()
# 5A风景区
print(user1)
print(user2)
print(user3)
print(group1)

between

## 3 betweenres = session.query(User1).where(User1.id.between(1,7),User1.name == '刘亦菲').all()print(res)
# 这个就代表有两个复合条件
# [刘亦菲, 刘亦菲]

in

## 4 in
res = session.query(User1).filter(User1.id.in_([1,2,7])).all()
print(res)
# [李保平, 小昭, 刘亦菲]

~非，除。。外

# 5 ~非，除。。外
res = session.query(User1).filter(~User1.id.in_([3, 4]),User1.name=='刘亦菲').all()
print(res)
# 原本是有两个刘亦菲的因为我用了~User1.id.in_([3, 4] 中的3 就是一个刘亦菲
# [刘亦菲]

二次筛选

session.query(User1).filter(User1.id.in_(session.query(Group.id).filter_by(name='刘亦菲'))).all()

and,or条件

# 7 and,or条件
from sqlalchemy import and_, or_
# and_
res1 = session.query(User1).filter(and_(User1.id > 1, User1.name == '刘亦菲')).all()
# or_
res2 = session.query(User1).filter(or_(User1.id >= 3, User1.name == '刘亦菲')).all()
print(res1)
# [刘亦菲, 刘亦菲, 刘亦菲]
print(res2)
# [刘亦菲, 刘亦菲, 刘亦菲, 小妹, 小玲, 赵敏]

通配符，以小开头，不以小开头

# 8 通配符，以小开头，不以小开头
res1 = session.query(User1).filter(User1.name.like('小%')).all()res2 = session.query(User1).filter(~User1.name.like('小%')).all()res3 = session.query(User1).filter(~User1.name.like('小%'))
print(res1)
# [小妹, 小昭, 小玲]
print(res2)
# [刘亦菲, 刘亦菲, 刘亦菲, 赵保平, 赵敏]
print(res3) # 原声sql语句
# SELECT user1.id AS user1_id, user1.name AS user1_name 
# FROM user1 
# WHERE user1.name NOT LIKE %(name_1)s

限制，用于分页，区间

# 9 限制，用于分页，区间
res1 = session.query(User1)[5:9]
res2 = session.query(User1)[0:4]
print(res1)
# [小玲, 赵保平, 赵敏]
print(res2)
# [刘亦菲, 刘亦菲, 刘亦菲, 小妹]

排序

# 10 排序，根据name降序排列（从大到小） desc   asc
res = session.query(User1).order_by(User1.name.asc()).all()
print(res)
# [刘亦菲, 刘亦菲, 刘亦菲, 小妹, 小昭, 小玲, 赵保平, 赵敏]res = session.query(User1).order_by(User1.name.desc(), User1.id.asc()).all()
print(res)
# [赵敏, 赵保平, 小玲, 小昭, 小妹, 刘亦菲, 刘亦菲, 刘亦菲]

分组

# 12 分组      一旦分组后，select 字段必须是 分组字段或聚合函数的字段from sqlalchemy.sql import funcret = session.query(# 按 User1.name 分组，并选择每个组的最大 ID、ID 总和、最小 ID 和名称func.max(User1.id).label('max_id'),func.sum(User1.id).label('sum_id'),func.min(User1.id).label('min_id'),User1.name
).group_by(User1.name).all()user1 = session.query(User1).filter(User1.name)
print(user1)
# SELECT user1.id AS user1_id, user1.name AS user1_name
# FROM user1
# WHERE user1.name
# 输出结果
for row in ret:print(row.max_id, row.sum_id, row.min_id, row.name)

连表查询

# 连表查询ret = session.query(Person, Hobby).filter(Person.hobby_id == Hobby.id).all()
print(ret)ret1 = session.query(Person).join(Hobby, Person.nid == Hobby.id, isouter=True)
print(ret1)
# SELECT person.nid AS person_nid, person.name AS person_name, person.hobby_id AS person_hobby_id
# FROM person LEFT OUTER JOIN hobby ON person.nid = hobby.id