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