SQLAlchemy 查询结果格式分析

原创 已于 2025-04-24 02:02:20 修改 · 429 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#SQLAlchemy

于 2025-04-24 01:30:26 首次发布

SQLAlchemy 中结果集 Result 及其子类定义在 sqlalchemy\engine\result.py 中，故分析 Result 相关数据获取方法（例如，Result.all()、Result.one_or_none()）返回的”最终数据格式“从此开始，在SQLALchemy 中，这个”最终数据格式“由_RowData所代表的”行“构成。

_RowData = Union[Row[Any], RowMapping, Any]

A generic form of “row” that accommodates for the different kinds of “rows” that different result objects return, including row, row mapping, and scalar values.
一种通用的“行”形式，适用于不同结果对象返回的不同类型的“行”，包括行、行映射和标量值。

_RowData 是三种类型集合：

  1. Any：标量值。例如，int、datetime、str以及SQLAlchemy 模型类实例等。
  2. Row：SQLAlchemy的行对象。Row父类BaseRow的__iter__方法揭示Row底层数据源于BaseRow的属性_data: _RawRowType，其中_RawRowType是一个Any元组_RawRowType = Tuple[Any, ...]，即Row底层元组每个元素都是Any类型。
  3. RowMapping：Row的字典形式，Row可转换为RowMapping。

通过如下代码分析一个具体返回形式：

import asyncio

from sqlalchemy import Column, Integer, String, select
from sqlalchemy import ForeignKey
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.ext.asyncio import async_sessionmaker
from sqlalchemy.orm import declarative_base
from sqlalchemy.orm import relationship

Base = declarative_base()


class Group(Base):
    __tablename__ = 'tb_group'
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    # 添加与 Item 的一对多关系
    items = relationship("Item", back_populates="group")


class Item(Base):
    __tablename__ = 'tb_item'
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    # 添加与 Group 的多对一关系
    group_id = Column(Integer, ForeignKey('tb_group.id'), nullable=False)
    group = relationship("Group", back_populates="items")
    

# 创建异步引擎
engine = create_async_engine(
    "mysql+aiomysql://root:mYsql123456_@localhost/test4",
    echo='debug',
    echo_pool='debug',
)

# 创建会话
async_session = async_sessionmaker(
    engine, expire_on_commit=False, class_=AsyncSession
)


async def prepare():
    # 创建表（如果不存在）
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)

    # 插入示例数据
    async with async_session() as session:
        async with session.begin():
            session.add(Group(id=1, name="Group 1"))
            session.add(Item(id=1, name="Item 1", group_id=1))
            session.add(Item(id=2, name="Item 2", group_id=1))
            session.add(Item(id=3, name="Item 3", group_id=1))
            session.add(Group(id=2, name="Group 2"))
            session.add(Item(id=4, name="Item 4", group_id=2))
            session.add(Item(id=5, name="Item 5", group_id=2))
            session.add(Item(id=6, name="Item 6", group_id=2))


async def async_main():
    # await prepare()

    async with async_session() as session:
        stmt = select(Group.id, Group.name).where(Group.id.in_([1, 2]))
        result = await session.execute(stmt)
        data = result.all()  # 返回 Sequence[Row[_TP]]，_TP = TypeVar("_TP", bound=Tuple[Any, ...])
        print(type(data[0]))
        print(data[0])
        print(type(data[0]._mapping))
        print(data[0]._mapping)

        # 2025-04-23 23:56:37,686 INFO sqlalchemy.engine.Engine SELECT tb_group.id, tb_group.name
        # FROM tb_group
        # WHERE tb_group.id IN (%s, %s)
        # 2025-04-23 23:56:37,686 INFO sqlalchemy.engine.Engine [generated in 0.00045s] (1, 2)
        # 2025-04-23 23:56:37,687 DEBUG sqlalchemy.engine.Engine Col ('id', 'name')
        # 2025-04-23 23:56:37,689 DEBUG sqlalchemy.engine.Engine Row (1, 'Group 1')
        # 2025-04-23 23:56:37,689 DEBUG sqlalchemy.engine.Engine Row (2, 'Group 2')
        # <class 'sqlalchemy.engine.row.Row'>
        # (1, 'Group 1')
        # <class 'sqlalchemy.engine.row.RowMapping'>
        # {'id': 1, 'name': 'Group 1'}

        # 从以上日志可以看出：Row 是一个元组，元组中存储 select 方法选定的数据，此处选定 Group.id, Group.name，故每个元组中仅包含2个元素，RowMapping 会根据列名作为字典的 key

        stmt = select(Group).where(Group.id.in_([1, 2]))
        result = await session.execute(stmt)
        data = result.all()  # 返回 Sequence[Row[_TP]]，_TP = TypeVar("_TP", bound=Tuple[Any, ...])
        print(type(data[0]))
        print(data[0])
        print(type(data[0]._mapping))
        print(data[0]._mapping)

        # 特别的，异步关联有问题
        # print(data[0][0].items)

        # 2025-04-23 23:56:37,691 INFO sqlalchemy.engine.Engine SELECT tb_group.id, tb_group.name
        # FROM tb_group
        # WHERE tb_group.id IN (%s, %s)
        # 2025-04-23 23:56:37,691 INFO sqlalchemy.engine.Engine [generated in 0.00037s] (1, 2)
        # 2025-04-23 23:56:37,692 DEBUG sqlalchemy.engine.Engine Col ('id', 'name')
        # 2025-04-23 23:56:37,692 DEBUG sqlalchemy.engine.Engine Row (1, 'Group 1')
        # 2025-04-23 23:56:37,692 DEBUG sqlalchemy.engine.Engine Row (2, 'Group 2')
        # <class 'sqlalchemy.engine.row.Row'>
        # (<__main__.Group object at 0x0000029B66A25B70>,)
        # <class 'sqlalchemy.engine.row.RowMapping'>
        # {'Group': <__main__.Group object at 0x0000029B66A25B70>}

        # 从以上日志可以看出：
        # 1. Row 是一个元组，元组中存储 select 方法选定的数据，此处选定 Group，故每个元组中仅包含1个元素，RowMapping 会根据模型类名作为字典的 key

        stmt = select(Group.id, Group.name, Group).where(Group.id.in_([1, 2]))
        result = await session.execute(stmt)
        data = result.all()  # 返回 Sequence[Row[_TP]]，_TP = TypeVar("_TP", bound=Tuple[Any, ...])
        print(type(data[0]))
        print(data[0])
        print(type(data[0]._mapping))
        print(data[0]._mapping)

        # 2025-04-23 23:56:37,694 INFO sqlalchemy.engine.Engine SELECT tb_group.id, tb_group.name
        # FROM tb_group
        # WHERE tb_group.id IN (%s, %s)
        # 2025-04-23 23:56:37,694 INFO sqlalchemy.engine.Engine [generated in 0.00037s] (1, 2)
        # 2025-04-23 23:56:37,695 DEBUG sqlalchemy.engine.Engine Col ('id', 'name')
        # 2025-04-23 23:56:37,695 DEBUG sqlalchemy.engine.Engine Row (1, 'Group 1')
        # 2025-04-23 23:56:37,695 DEBUG sqlalchemy.engine.Engine Row (2, 'Group 2')
        # <class 'sqlalchemy.engine.row.Row'>
        # (1, 'Group 1', <__main__.Group object at 0x0000029B66A25B70>)
        # <class 'sqlalchemy.engine.row.RowMapping'>
        # {'id': 1, 'name': 'Group 1', 'Group': <__main__.Group object at 0x0000029B66A25B70>}

        # 从以上日志可以看出：Row 是一个元组，元组中存储 select 方法选定的数据，此处选定 Group.id, Group.name, Group，故每个元组中包含3个元素，RowMapping 会根据列名或者模型类名作为字典的 key
        # ORM 支持字段和模型混合查询，查询时 SQL 语句还是按照字段查询，模型由 SQLAlchemy 组装，不过这里的问题就是，当一个表连接语句使得A和B连接，此时希望获取 A 的所有字段和B的某些字段，A 模型和B字段在select中混合使用，就会导致 A 的字段和B的字段不是在同一个层级，这时有一个小技巧，将查模型变为查模型所有列 stmt = select(Group.__table__.columns, Item.id).where(Group.id.in_([1, 2]))


asyncio.run(async_main())

以上通过Result.all()方法展示_RowData具体形式以及”最终数据格式“的部分形式，Result及其子类中其他数据获取方法（例如，Result.all()、Result.one_or_none()）等类似，不再逐一列举，整体总结一下，”最终数据格式“有如下形式：

  1. _RowData，即 Row[Any]、RowMapping、Any
  2. Optional[_RowData]
  3. Sequence[_RowData]
  4. Iterator[_RowData]
  5. Iterator[Sequence[_RowData]]

由此，若要对”最终数据格式“转换为 Python 基本数据类型，可以由如下方法转换：

  1. 判断第一层是否为迭代器，是则转列表
  2. 判断第二层不是 _RowData，且迭代一层
  3. 处理 _RowData，将 Row 处理为 RowMapping，RowMapping 可以强制转为 dict
  4. 若 Any 为 模型类对象，调用模型类对象 to_dict 方法，模型类对象 to_dict 方法需要自定义
  5. 其他标量类型不处理
【Python】SQLAlchemy2
宅男很神经
07-05 657
在关系型数据库中，数据分散在多个表中，并通过外键建立关联。而在面向对象编程中，我们倾向于将这些分散的数据聚合到相互关联的对象中，形成一个“对象图”。SQLAlchemy ORM的函数正是这座桥梁，它允许你定义模型类之间的关系，从而能够像访问Python对象的属性一样，轻松地遍历关联数据，而无需手动编写复杂的查询。是SQLAlchemy ORM中用于定义类之间映射关系的核心函数。它并不直接在数据库中创建任何新的列或约束（那是和的职责），而是为ORM提供指令，告诉它如何连接两个模型类，以及如何加载和持久化这两个
SQLAlchemy之查询
程序员八阿哥
07-01 2037
94.jpg 131.gif whyfail 2020-01-21 22:29:59 127 收藏 分类专栏： Flask框架（3）——Flask数据库 版权 query查询函数 query函数可传递的参数一共有3种： 模型名。指定查找这个模型中所有的属性（对应查询表为全表查询）。 模型中的属性。可以指定只查找某个模型的其中几个属性。 聚合函数。 func.count：...
SQLAlchemy查询
OneFine的技术博客
04-16 3287
几种常见sqlalchemy查询 简单查询： print(session.query(User).all()) print(session.query(User.name, User.fullname).all()) print(session.query(User, User.name).all()) 带条件查询： print(session.query(User).f...
Python Sqlalchemy库使用记录
最新发布
MarsAres2的博客
06-15 882
python三方包sqlalchemy简单用法
SQLAlchemy 查询
qq_18987631的博客
03-29 1011
【代码】SQLAlchemy 查询。
SQLAlchemy中常用的查询方法[示例学习]
book_dw5189的博客
03-28 5805
SQLAlchemy 是一个强大的 Python ORM（对象关系映射）工具，它提供了多种方法来执行数据库查询操作。
SQLAlchemy学习-2.query() 查询数据
qq_27371025的博客
08-20 2550
query查询数据
Flask-SQLAlchemy资源序列化：将数据库的数据转化为JSON标准格式输出
雪月的博客
11-19 8610
我觉得最简单明了的就是在模型定义的时候给个序列化的方法，想要哪个或想变成其他格式都很方便，就是要多写一些代码 继承改写 flask 里面的 JSONEncoder，这个方法好像很好，但如何去除自己不想要的变量，不知道有没有可以参考的源代码，求解？ 也有说用 Marshmallow，看起来还要定义很多东西，不知道用的人多不多？ 方法一：见grey li书中例子：https://github.com/...
Python源码-Web开发-使用Flask-SQLAlchemy实现条件查询.zip
05-25
这通常涉及到接收用户输入，构造查询条件，执行查询，并将结果以JSON格式或HTML页面的形式返回给用户。 对于想要深入学习Python在Web开发中应用的开发者来说，掌握Flask和SQLAlchemy的使用是基础且必要的。通过理解...
124、探索SQLAlchemy与Pandas：数据处理与分析的完美搭档
silenceallat的博客
05-27 842
本文探讨了Python在处理异构数据源方面的应用。介绍了异构数据源的概念，分析了整合异本文介绍了SQLAlchemy与Pandas的结合使用，以实现高效的数据库交互和数据处理。通过实际案例，展示了如何利用这两个工具进行电商平台销售数据分析，从而帮助企业了解产品受欢迎程度、构数据源的挑战及解决方案。文章涵盖数据清洗、数据映射、数据同步、数据安全和隐私以及技术选型的相关内容。通过实际案例，展示了Python如何应对异构数据源整合的挑战。文章最后强调了异构数据源整合的重要性，以及Python在这一领域的应用潜力。
基于SQLAlchemy实现操作MySQL并执行原生sql语句
09-08
此外，SQLAlchemy还支持查询、更新和删除操作，例如： - 查询：`session.query(ServiceOrder).filter(ServiceOrder.serviceOrderId == '123').first()` - 更新：`session.query(ServiceOrder).filter(ServiceOrder....
Python使用sqlalchemy模块连接数据库操作示例
09-19
利用Pandas库可以很方便地将SQLAlchemy查询结果转换成DataFrame格式，便于进一步的数据处理和分析。 **示例代码**： ```python import pandas as pd df = pd.read_sql(session.query(Student).filter(Student.id ...
sqlalchemy查询使用
暖雪若峰的博客
02-19 8499
sqlalchemy查询使用
python oracle orm_Python库之SQLAlchemy
weixin_39900736的博客
12-08 292
一、SQLAlchemy简介1.1、SQLAlchemy是什么？sqlalchemy是一个python语言实现的的针对关系型数据库的orm库。可用于连接大多数常见的数据库，比如Postges、MySQL、SQLite、Oracle等。1.2、为什么要使用SQLAlchemy？它将你的代码从底层数据库及其相关的SQL特性中抽象出来。1.3、SQLAlchemy提供了两种主要的使用模式SQL表达式语言...
sqlalchemy文档--查询-定义表
ZHH_Love123的博客
03-08 1119
一、添加对象 1、ed_user = User(name='ed', fullname='Ed Jones', password='edspassword') session.add(ed_user) session.commit() 2、回滚 session.rollback() 二、查询 1、查询 query.filter(User.name == 'ed') #equals query.filter(User.name != 'ed') #not equals query.filte
SQLAlchemy连接MySQL及记录的查询、更新、删除、多表关联查询
小龙在线
12-24 7909
SQLAlchemy是Python的ORM库，支持多种数据库。
sqlalchemy数据操作
godme
10-06 703
sqlalchemy中操作数据主要是通过建立会话session 需要的两个基本条件：引擎，对象 引擎：远程数据库连接 对象：表结构类 首先，创建session会话，连接远程的数据库 sessionclass = sessionmaker(bind=engine) 不过这只是获取了session的类，还需要创建session实例 session = sessionclass()
SQLAlchemy 的基本使用（模糊查询 与 数据去重）
热门推荐
lilygg的博客
04-21 1万+
参考链接：https://www.cnblogs.com/kaerxifa/p/13476317.html 1.模糊查询 原生sql写法： SELECT * FROM 表名 WHERE 字段名 LIKE '%匹配内容%' ; 利用sqlalchemy实现模糊查询： center_filter = db.query(BudgetOrganizational).filter( BudgetOrganizational.center_name.like('%'+ center_name +'%')
flask_sqlalchemy将查询到的数据以JSON格式传到前端
06-01
在这个函数中，我们使用了Flask的jsonify函数，将查询结果转换为JSON格式并返回给前端。注意，我们还定义了一个to_dict方法，该方法将User对象转换为字典格式，以便能够进行JSON序列化。 在前端页面中，可以使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值