Flask SQLAlchemy

最新推荐文章于 2024-02-21 15:14:07 发布

i0208

最新推荐文章于 2024-02-21 15:14:07 发布

阅读量216

点赞数

分类专栏： Flask

本文链接：https://blog.csdn.net/Waller_/article/details/106176657

版权

Flask 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

SQLAlchemy

SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。

SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
    
pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
    
MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
    
cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
    
更多：http://docs.sqlalchemy.org/en/latest/dialects/index.html

使用

pip3 install sqlalchemy

创建数据库表

models.py

import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
from sqlalchemy.orm import relationship
Base = declarative_base()

创建表案例:
class Users(Base):
    __tablename__ = 'users'  # 数据库表名称
    id = Column(Integer, primary_key=True)  # id 主键
    name = Column(String(32), index=True, nullable=False)  # name列，索引，不可为空
    #email = Column(String(32), unique=True)
    age = Column(Integer,default=0)
    #datetime.datetime.now不能加括号，加了括号，以后永远是当前时间
    ctime = Column(DateTime, default=datetime.datetime.now)
    #extra = Column(Text, nullable=True)

    # __table_args__ = (
    #     UniqueConstraint('id', 'name', name='uix_id_name'), #联合唯一
    #     Index('ix_id_name', 'name', 'email'), #索引
    # )
    def __repr__(self):
        return self.name

创建一对多案例:
class Hobby(Base):
    __tablename__ = 'hobby'
    id = Column(Integer, primary_key=True)  # 主键
    caption = Column(String(50), default='篮球')

class 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"))  # 外键
    
    # relationship跟数据库无关，不会新增字段，只用于快速链表操作
    # 类名，backref用于反向查询,uselist=False
    hobby = relationship('Hobby', backref='pers')
    def __repr__(self):
        return self.name

创建多对多案例: 第三张表需要手动创建
class Boy2Girl(Base):
    __tablename__ = 'boy2girl'
    id = Column(Integer, primary_key=True, autoincrement=True)
    girl_id = Column(Integer, ForeignKey('girl.id'))
    boy_id = Column(Integer, ForeignKey('boy.id'))

class Girl(Base):
    __tablename__ = 'girl'
    id = Column(Integer, primary_key=True)
    name = Column(String(64), unique=True, nullable=False)

class Boy(Base):
    __tablename__ = 'boy'
    id = Column(Integer, primary_key=True, autoincrement=True)
    hostname = Column(String(64), unique=True, nullable=False)

    # 与生成表结构无关，仅用于查询方便,放在哪个单表中都可以
    girl = relationship('Girl', secondary='boy2girl', backref='boys')

# 根据类创建数据库表
def init_db():
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/flask?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )

    Base.metadata.create_all(engine)

# 根据类删除数据库表
def drop_db():
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/库名?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )
    Base.metadata.drop_all(engine)

if __name__ == '__main__':
    #drop_db()  # 删除表
    init_db()  # 生成表

步骤:

1.Base = declarative_base() 实例化对象Base
2.model类继承Base
3.model类中用 __tablename__ = '表明' 声明表名
4.表关系 ForeignKey :
    - 一对多查询字段: hobby = relationship('被关联表名', backref='pers')
            hobby用于正向, pers用于反向
    - 多对多关系,要手动创建第三张表, girl = relationship('关系表名', secondary='第三张表名', backref='boys')
            girl用于正向, boys用于反向
5.创建生成表与删除表的两个函数

增删查改

test.py

from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text

import models

1.创建连接池
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/库名", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)

2.从连接池中获取数据库连接
session = Session()

3.执行ORM操作 增删改查

# ################ 增加 ################
obj1 = models.Users(name="xionger",age=40)
# 单增
session.add(obj1)
# 群增
session.add_all([
    models.Users(name="hanmm"),
    models.Users(name="lilei"),
    ...
])
# 提交
session.commit()


# ################ 查询 ################

r1 = session.query(models.Users).all()  # 群查 得到的是列表套对象

# 按条件筛选查询  filter传的是表达式，filter_by传的是参数
r3 = session.query(models.Users).filter(models.Users.id > 2).all()  # 查询id大于2的 得到的是列表套对象
r4 = session.query(models.Users).filter_by(name='waller').all()
r5 = session.query(models.Users).filter_by(name='lqz').first()

#:value 和:name 相当于占位符，用params传参数, order_by用于排序
r6 = session.query(models.Users).filter(text("id<:value and name=:name")).params(value=224, name='fred').order_by(models.Users.id).all() 

# 自定义查询sql
r7 = session.query(models.Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='ed').all()

# 只取age列，和name列, label相当于取别名
r8 = session.query(models.Users.name.label('xx'), models.Users.age).all()
print(r8)  # [('waller', 18),('xionger', 20), ...]

# ################ 删除 ################
session.query(Users).filter(Users.id == 5).delete()
session.commit()


# ################ 修改 ################
#传字典
session.query(Users).filter(Users.id ==4 ).update({"age" : 30,})
#类似于django的F查询
session.query(Users).filter(Users.id == 3).update(
    {Users.name: Users.name + "sb"}, 
    synchronize_session=False
    )  # 操作的字典值是字符串 需要synchronize_session=False
session.query(Users).filter(Users.id == 7).update(
    {"age": Users.age + 16}, 
    synchronize_session="evaluate"
    )  # 操作的字典值是数字 需要synchronize_session="evaluate"
session.commit()

4.最后关闭数据库连接(本质是将连接放回连接池)
session.close()

其他常用操作

#　条件
ret = session.query(Users).filter_by(name='alex').all()
ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()
from sqlalchemy import and_, or_
ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
ret = session.query(Users).filter(
    or_(
        Users.id < 2,
        and_(Users.name == 'eric', Users.id > 3),
        Users.extra != ""
    )).all()


# 通配符
ret = session.query(Users).filter(Users.name.like('e%')).all()
ret = session.query(Users).filter(~Users.name.like('e%')).all()

# 限制
ret = session.query(Users)[1:2]

# 排序
ret = session.query(Users).order_by(Users.name.desc()).all()
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()

# 分组
from sqlalchemy.sql import func

ret = session.query(Users).group_by(Users.extra).all()
ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).all()

ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()

# 连表

ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()

ret = session.query(Person).join(Favor).all()

ret = session.query(Person).join(Favor, isouter=True).all()


# 组合
q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union(q2).all()

q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union_all(q2).all()

其他详情用法 https://www.cnblogs.com/waller/p/11862025.html

i0208

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Flask SQLAlchemy

SQLAlchemySQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：MySQL-Python mysql+mysqldb://<user&gt
复制链接

扫一扫