sqlalchemy

最新推荐文章于 2023-09-26 18:15:18 发布
最新推荐文章于 2023-09-26 18:15:18 发布
阅读量381 收藏 1
点赞数 1
分类专栏： flask
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DeskyAki/article/details/89716692
版权

插入：filter和filter_by的区别

模块语法><（大于和小于）查询and_和or_查询
filter_by()直接用属性名，比较用=不支持不支持
filter()用类名.属性名，比较用==支持支持

filter更强大

 

一 单表 创建表结构

users.py


from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column
from sqlalchemy import Integer, String, Text, Date, DateTime
from sqlalchemy import create_engine

Base = declarative_base()


class Users(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)
    depart_id =Column(Integer)


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


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


if __name__ == '__main__':
    create_all()
    drop_all()

具体的数据库的操作，增删改查

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from model import Users
# 引入自己写的model

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

SessionFactory = sessionmaker(bind=engine)        # 实例化，SessionFactory，随意的命名
session = SessionFactory()
# -------------------加-------------------
# obj = Users(name='陈日天')
# session.add(obj)
# session.commit()


# 批量添加
# session.add_all([
#     Users(name="斋藤飞鸟"),
#     Users(name='井上苑子'),
# ])
# session.commit()


# --------------------查-------------------
# result = session.query(Users).all()
# for row in result:
#     print(row.id, row.name)


# 指定字段， 返回列表套元组
# result = session.query(Users.id, Users.name).all()
# print(result)
# [(1, 'aki'), (2, 'desky')]

# result = session.query(Users).filter(Users.id >= 4)
# for row in result:
#     print(row.id, row.name)


# --------------------删-------------------
# session.query(Users).filter(Users.id > 4).delete()
# session.commit()


# --------------------改-------------------
# session.query(Users).filter(Users.id == 8).update({Users.name: '大和田南那'})
# session.query(Users).filter(Users.id == 8).update({'name': '井上苑子'})
# session.query(Users).filter(Users.id == 8).update({'name': Users.name+"好きです"}, synchronize_session=False)
# 可以拼接， 后面的参数时拼接字符串，默认时True, 实现int的加
# session.query(Users).filter(Users.id == 8).update({'name': Users.id+1})
# session.commit()



# --------------------其他操作-------------------
# as 别名
# result = session.query(Users.id, Users.name.label('oname')).all()
# for row in result:
#     print(row[1], row.id, row.oname)          # row[1], 拿到是 USer.name


# between
# result = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'aki').all()


# in 注意时 in_[]
# result = session.query(Users).filter(Users.id.in_([1, 3, 4])).all()
# result = session.query(Users).filter(~Users.id.in_([1, 3, 4])).all()  # 不在


# 子查询
# result = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter(Users.name == 'aki'))).all()


# and or  不写默认and, 要写的话，注意引用
from sqlalchemy import and_, or_
# result = session.query(Users).filter(and_(Users.id < 3, Users.name == 'aki')).all()
# result = session.query(Users).filter(or_(Users.id < 2, Users.name == 'aki')).all()
# result = session.query(Users).filter(
#     or_(
#         Users.id < 2,
#         and_(Users.name == 'aki', Users.id > 3),
#         Users.depart_id != ""
#     )).all()


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


# 切片
# result = session.query(Users)[1:2]


# 排序
# result = session.query(Users).order_by(Users.name.desc()).all()
# result = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()   # 先按降序拍，相同再升序


# 分组  注意要引人
from sqlalchemy.sql import func
# ret = session.query(
#         Users.depart_id,
#         func.count(Users.id),
# ).group_by(Users.depart_id).all()
# for item in ret:
#         print(item)

# 加查询条件
# ret = session.query(
#         Users.depart_id,
#         func.count(Users.id),
# ).group_by(Users.depart_id).having(func.count(Users.id) >= 2).all()
# for item in ret:
#         print(item)


# 联表 union去重， union__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()

session.close()

二  多表

一对多， 一对一

model.py

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column
from sqlalchemy import Integer, String, Text, Date, DateTime, ForeignKey, UniqueConstraint, Index
from sqlalchemy import create_engine
from sqlalchemy.orm import relationship

Base = declarative_base()


class Depart(Base):
    __tablename__ = 'depart'
    id = Column(Integer, primary_key=True)
    title = Column(String(32), index=True, nullable=False)


class Users(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)
    depart_id = Column(Integer, ForeignKey("depart.id"))
    dp = relationship("Depart", backref='pers'，uselist=False)
    #  反向查找的字段， 不会在数据库中创建字段, 加最后面的参数表示的时一对一

    def __repr__(self):
        return '<Users %r>' % self.name


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


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


if __name__ == '__main__':
    create_all()
    # drop_all()

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from model import Users, Depart


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

SessionFactory = sessionmaker(bind=engine)        # 实例化，SessionFactory，随意的命名
session = SessionFactory()

# join联表 默认inner join,   souter=True left join
# ret = session.query(Users.id, Users.name, Depart.title).join(Depart, Users.depart_id == Depart.id).all()
# # ret= session.query(Users.id,Users.name,Depart.title).join(Depart,Users.depart_id == Depart.id,isouter=True)
# for row in ret:
#     print(row.id, row.name, row.title)

# 通过relationship 外键字段正向跨表
# ret = session.query(Users).all()
# for row in ret:
#     print(row.id, row.name, row.depart_id, row.dp.title)
# 反向 pers 反向的名字
# ret = session.query(Depart).filter(Depart.title == 'sas').first()
# for row in ret.pers:
#     print(row.name)


# 通过relationship 正向添加数据
# a = Users(name='斋藤飞鸟', dp=Depart(title='后宫'))
# session.add(a)
# session.commit()

# 反向添加数据，User的depart_id 相同
# a = Depart(title='前台')
# a.pers = [Users(name='石原里美'), Users(name='新垣结衣'), Users(name='佐佐木希')]
# session.add(a)
# session.commit()

# session.close()

多对多，只能自己创建第三张表，和每张表的一对一

model.py


from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column
from sqlalchemy import Integer, String, Text, Date, DateTime, ForeignKey, UniqueConstraint, Index
from sqlalchemy import create_engine
from sqlalchemy.orm import relationship

Base = declarative_base()



class Student(Base):
    __tablename__ = "student"
    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)

    course_list = relationship("Course", secondary='student2course', backref='student_list')
    # 不会生成个字段， 但是会方便查找和添加， 和那个表建立关系，通过那个表，反向查找名称


class Course(Base):
    __tablename__ = 'course'
    id = Column(Integer, primary_key=True)
    title = Column(String(32), index=True, nullable=False)


class Student2Course(Base):
    __tablename__ = 'student2course'
    id = Column(Integer, primary_key=True)
    student_id = Column(Integer, ForeignKey('student.id'))
    course_id = Column(Integer, ForeignKey('course.id'))

    __table_args__ = (
        UniqueConstraint('student_id', 'course_id', name='aki'),
        # Index('student_id', 'course_id', name='aki')
    )


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


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


if __name__ == '__main__':
    create_all()
    # drop_all()

 

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from model import Student,Course,Student2Course


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

SessionFactory = sessionmaker(bind=engine)        # 实例化，SessionFactory，随意的命名
session = SessionFactory()

#  三表相联
# ret = session.query(Student2Course.id, Student.name, Course.title).\
#     join(Student, Student2Course.student_id == Student.id).\
#     join(Course, Student2Course.course_id == Course.id).order_by(Student2Course.id.asc())
# for row in ret:
#     print(row)


# 通过relationship添加
# obj = Course(title='英语')
# obj.student_list = [Student(name='a'), Student(name='c')]
# session.add(obj)
# session.commit()

session.close()

三 多线程

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session
from models import Student,Course,Student2Course

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


def task():
    ret = session.query(Student).all()
    # 将连接交还给连接池
    session.remove()


from threading import Thread

for i in range(20):
    t = Thread(target=task)
    t.start()

四 执行原生sql

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from model import Student,Course,Student2Course


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

SessionFactory = sessionmaker(bind=engine)        # 实例化，SessionFactory，随意的命名
session = SessionFactory()

# -----------查------------
cursor = session.execute('select * from users')
ret = cursor.fetchall()
print(ret)
# -----------加------------
# cursor = session.execute('INSERT INTO users(name) VALUES(:value)', params={"value": 'abc'})
# session.commit()

# 将连接交还给连接池
session.close()
常用的sqlacm类型
Integerint普通整数，一般是 32 位
SmallIntegerint取值范围小的整数，一般是 16 位
BigIntegerint 或 long不限制精度的整数
Floatfloat 
Numericdecimal.Decimal定点数
String str变长字符串
Textunicode变长 Unicode 字符串
UnicodeTexunicode变长 Unicode 字符串，对较长或不限长度的字符串做了优化 
Booleanbool 
Datedatetime.date 
Timedatetime.time 
DateTimedatetime.datetime 
Intervaldatetime.timedelta时间间隔
Enumstr一组字符串
LargeBinarystr二进制文件

 

列选项
primary_key如果设为 True，这列就是表的主键 
unique如果设为 True，这列不允许出现重复的值 
index如果设为 True，为这列创建索引，提升查询效率 
nullable如果设为 True，这列允许使用空值；如果设为 False，这列不允许使用空值 
default为这列定义默认值
 

 

关系选项
backref在关系的另一个模型中添加反向引用 
primaryjoin明确指定两个模型之间使用的联结条件。只在模棱两可的关系中需要指定
lazy 指定如何加载相关记录。可选值有 select（首次访问时按需加载）、immediate（源对象加 载后就加载）、joined（加载记录，但使用联结）、subquery（立即加载，但使用子查询）， noload（永不加载）和 dynamic（不加载记录，但提供加载记录的查询）
uselist如果设为 Fales，不使用列表，而使用标量值 ， 建立一对一关系，设置为False
order_by指定关系中记录的排序方式 
secondary指定多对多关系中关系表的名字 
secondaryjoinSQLAlchemy 无法自行决定时，指定多对多关系中的二级联结条件

 

苟修今
关注
专栏目录
SQL alchemy使用
Yietong的博客
12-09 2094
SQLAlchemy是一个基于Python实现的ORM框架。独立的orm框架，可以轻松的集成到任意项目中去。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。Engine，框架的引擎Connection Pooling ，数据库连接池Dialect，选择连接数据库的DB API种类Schema/Types，架构和类型SQL Exprression Language，SQL表达式语言。
灵活使用 SQLAlchemy 中的 ORM 查询
kevinbai的博客
09-21 2016
之前做查询一直觉得直接拼 SQL 比较方便，用了 SQLAlchemy 的 ORM 查询之后，发现也还可以，还提高了可读性。 这篇文章主要说说 SQLAlchemy 常用的 ORM 查询方式，偏实践。看了之后，对付开发中的查询需求，我觉得可以满足不少。 为方便说明，假设有如下数据 图书表 books +----+--------+--------------------------+-------+ | id | cat_id | name | price | +--
SQLAchemy---ORM框架
kismile
03-13 1119
SQLAchemy是python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简言之，将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。 优点： 1、隐藏了数据访问细节，‘封闭’的通用数据库交互，ORM的核心。他使我们的通用数据库交互变得简单易行，并且完全不用考虑sql语句，快速开发 2、ORM使我们高中固化数据结构变得更加简单易...
sqlalchemy filter
Claroja
01-15 1893
方法 orm equals query.filter(User.name == ‘wang’) not equals query.filter(User.name != ‘wang’) LIKE query.filter(User.name.like(‘%ed%’)) IN query.filter(User.name.in_([‘ed’, ‘wendy’, ‘ja
sqlalchemy相关操作
有问题请发邮箱dengyifanlittle@163.com进行讨论
11-02 937
sqlalchemy是一个Python ORM工具，类似与Java中的Mybatis、Hibernate等ORM框架，这里主要介绍sqlalchemy的一些常用操作。 安装sqlalchemy： pip install sqlalchemy 基本查询操作：
python sqlalchemy 查询条件设置
ZauberC的博客
12-12 1907
在实际编程中需要根据各种不同的条件查询数据库记录，SQLAlchemy查询条件被称为过滤器。这里列出了最常用的过滤器的使用方法。
SQLAlchemy中filter函数的使用
m0_67093160的博客
09-26 2300
SQLAlchemy中filter函数的使用
SQLAlchemy
06-16
SQLAlchemy是一种流行的ORM（对象关系映射）工具，它在Python社区中被广泛使用，特别是在数据库操作和管理方面。ORM工具的主要目的是将数据库中的数据表结构映射到编程语言中的对象模型，允许开发者使用更加面向对象...
python-pandas-2.0.3及其依赖包+sqlalchemy-2.0.30及其依赖包+pymysql-1.1.0
最新发布
05-11
python安装第三方包失败(使用pip安装失败)的解决方案：在我们使用pip安装软件包的时候，经常会遇到这个错误：ERROR: ...3.0.3-cp38-cp38-win_amd64.whl、SQLAlchemy-2.0.30-cp38-cp38-win_amd64.whl
基于Flask的RESTful API实战代码：集成Flask-SQLAlchemy与MySQL
03-25
它集成了Flask-SQLAlchemy作为ORM工具与MySQL数据库进行交互。项目共包含39个文件，其中主要的Python脚本文件有23个，辅助配置文件包括6个XML文件、2个.gitignore文件、2个ini配置文件等。此外，还包括了项目文档（....
MySQL性能调优【一】
weixin_43246215的博客
10-20 8566
目录前言使用explain 分析你SQL的计划关键字的慎用避免判断 null 值避免使用 or 逻辑慎用 in 和 not in 逻辑Inner join 、left join、right join，优先使用Inner join，如果是left join，左边表结果尽量小exists的合理使用慎用distinct关键字尽量用 union all 替换 union查询优化GROUP BY关键字优化查询SQL尽量不要使用select *，而是select具体字段优化limit分页知道查询结果为一条记录，
SQLAlchemy查询与相对应的sql数据库语法
qq_44697384的博客
01-16 398
关于AQLAlchemy查询的基础以及filter()和filter_by()的用法
Python-SQLAlchemy：第2节：查询条件设置
weixin_34220963的博客
10-22 1618
上一篇文章：Python-SQLAlchemy：第1节：SQLAlchemy入门下一篇文章：Python-SQLAlchemy：第3节：关系操作 在实际编程中需要根据各种不同的条件查询数据库记录，SQLAlchemy查询条件被称为过滤器。这里列出了最常用的过滤器的使用方法。 1、等值过滤器（==） 等值过滤器用于判断某列是否等于某值，是...
Python-SQLAlchemy正确生成浮点型的方法，解决sqlachemy Float浮点型的坑，生成float类型时，长度和精度均为0，导致查询不到结果！
weixin_43343144的博客
06-07 5663
问题：在使用mysql数据库的时候【Float类型生成的长度和精度均为0】,不管是直接操作mysql还是使用SQLAlchemy的filter条件查询浮点数都是如此！ # 查询price字段【定义为Float类型】导致查询==条件的时候失败 orders = db.session.query(cls.create_time, cls.price, cls.amount).filter( ...
sqlalchemy在遍历大量结果ORM对象时占用内存问题解决
silentime的专栏
08-03 2133
python在内存管理上有一个特点，分配出去的内存，及时对象的引用计数为0，也不会立即释放内存，而是作为内存缓存，等待下次分配，到某个时机才会回收内存，因此在使用sqlalchemy的时候，如果查询结果包含大量结果（大于1000个），需要遍历每个ORM的时候，调用query().all()方法会导致内存激增（sqlalchemy会把所有对象放在内存中），下面是遍历290000+条记录的内存激增...
Flask 第三方组件之 SQLAlchemy
fenglepeng的博客
03-05 922
一. 介绍 SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。 安装：pip3 install sqlalchemy 组成部分： Engine，框架的引擎 Connection Pooling ，数据库连接池 Dialect......
ACM牛人给的新手建议
Roowe
07-20 5524
ACM牛人给的新手建议 ACM进阶一位高手的建议：一般要做到50行以内的程序不用调试、100行以内的二分钟内调试成功.训练过ACM等程序设计竞赛的人在算法上有较大的优势，这就说明当你编程能力提高之后，主要时间是花在思考算法上，不是花在写程序与debug上。下面给个计划你练练：第一阶段：练经典常用算法，下面的每个算法给我打上十到二十遍，同时自己精简代码，因为太常用，所以要练到写时不用想，10-15分钟内打完，甚至关掉显示器都可以把程序打出来。1.最短路(Floyd、Dijstra,BellmanFord) 2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值