sqlalchemy func.sum

时间: 2023-10-31 14:56:25 浏览: 156

sqlalchemy

The SQLAlchemy Object Relational Mapper presents a method of associating user-defined Python classes with database tables, and instances of those classes (objects) with rows in their corresponding tables. It includes a sys- tem that transparently synchronizes all changes in state between objects and their related rows, called a unit of work, as well as a system for expressing database queries in terms of the user defined classes and their defined relationships between each other. The ORM is in contrast to the SQLAlchemy Expression Language, upon which the ORM is constructed. Whereas the SQL Expression Language, introduced in SQL Expression Language Tutorial, presents a system of representing the primitive constructs of the relational database directly without opinion, the ORM presents a high level and abstracted pattern of usage, which itself is an example of applied usage of the Expression Language. While there is overlap among the usage patterns of the ORM and the Expression Language, the similarities are more superficial than they may at first appear. One approaches the structure and content of data from the perspective of a user-defined domain model which is transparently persisted and refreshed from its underlying storage model. The other approaches it from the perspective of literal schema and SQL expression representations which are explicitly composed into messages consumed individually by the database. A successful application may be constructed using the Object Relational Mapper exclusively. In advanced situations, an application constructed with the ORM may make occasional usage of the Expression Language directly in certain areas where specific database interactions are required. The following tutorial is in doctest format, meaning each >>> line represents something you can type at a Python command prompt, and the following text represents the expected return value. ### SQLAlchemy：对象关系映射（ORM）详解 #### 概述 SQLAlchemy 是一个 Python 的 SQL 工具包和 ORM（对象关系映射），它提供了一种方式将自定义的 Python 类与数据库表关联起来，并将这些类的实例（对象）与其对应的表中的行进行映射。SQLAlchemy 包含了一个称为“单元工作”（unit of work）的系统，该系统可以透明地同步所有对象与其相关行之间的状态变化；此外还包括了一个基于用户定义的类及其定义的关系来表达数据库查询的系统。 ORM 和 SQLAlchemy 的表达式语言（Expression Language）不同，后者是 ORM 的基础。表达式语言是一种直接表示关系数据库原始构造的方法，不带有任何预设的意见或模式；而 ORM 提供了一个高层次且抽象化的使用模式，这本身是表达式语言的一种应用实例。虽然 ORM 和表达式语言在使用模式上有一定的重叠，但它们之间的相似之处更多的是表面性的。一个成功的应用程序可以仅使用对象关系映射器来构建。在高级情况下，使用 ORM 构建的应用程序可能偶尔会直接使用表达式语言来进行特定的数据库交互操作。以下教程采用 doctest 格式，即每行 `>>>` 表示可以在 Python 命令提示符下输入的内容，随后的文本代表预期的返回值。 #### SQLAlchemy 文档概览 **版本**：0.7.4 **作者**：Mike Bayer **发布日期**：2012 年 1 月 28 日 ### SQLAlchemy ORM 入门指南 #### 对象关系映射教程 ##### 版本检查在开始之前，确认安装的 SQLAlchemy 版本是否满足需求： ```python >>> import sqlalchemy >>> sqlalchemy.__version__ '0.7.4' ``` ##### 连接数据库使用 SQLAlchemy 连接到数据库需要创建一个 `create_engine` 实例，指定数据库类型、主机名、用户名、密码以及数据库名称。 ```python >>> from sqlalchemy import create_engine >>> engine = create_engine("postgresql://scott:tiger@localhost/mydatabase") ``` ##### 声明映射定义一个 Python 类并使用 `declarative_base()` 来声明一个基类，该基类将包含一个 `__tablename__` 属性，该属性定义了数据库表的名称。同时，需要导入 `Column` 和数据类型如 `Integer` 和 `String`。 ```python >>> from sqlalchemy.ext.declarative import declarative_base >>> from sqlalchemy import Column, Integer, String >>> Base = declarative_base() >>> class User(Base): ... __tablename__ = 'users' ... id = Column(Integer, primary_key=True) ... name = Column(String(50)) ... fullname = Column(String(50)) ... password = Column(String(12)) ... ``` ##### 创建实例创建基类的实例即为创建数据库表的行。每个实例代表一个具体的对象。 ```python >>> ed_user = User(name='ed', fullname='Ed Jones', password='edspassword') ``` ##### 创建会话为了与数据库交互，需要创建一个 `Session`。`Session` 是一个用于管理所有数据库操作的上下文。 ```python >>> from sqlalchemy.orm import sessionmaker >>> Session = sessionmaker(bind=engine) >>> session = Session() ``` ##### 添加新对象使用 `session.add()` 方法添加新对象到数据库。`commit()` 方法用于提交更改。 ```python >>> session.add(ed_user) >>> session.commit() ``` ##### 回滚如果在事务中发生错误，可以使用 `session.rollback()` 来撤销所有更改。 ```python >>> fake_user = User(name='fakeuser', fullname='Invalid', password='12345') >>> session.add(fake_user) >>> session.commit() # 假设此处出现异常 Traceback (most recent call last): ... >>> session.rollback() ``` ##### 查询使用 `session.query()` 发起查询。查询结果默认按列表形式返回。 ```python >>> users = session.query(User).all() >>> for u in users: ... print(u.name) ... ed fakeuser ``` ##### 使用过滤器可以使用多种过滤器来筛选查询结果。 ```python >>> for u in session.query(User).filter(User.name == 'ed'): ... print(u.fullname) ... Ed Jones ``` ##### 返回列表和标量可以指定查询返回的对象类型。 ```python >>> names = session.query(User.name).all() >>> print(names) [('ed',), ('fakeuser',)] ``` ##### 使用纯 SQL 有时可能需要执行更复杂的 SQL 查询，可以通过 `text()` 函数实现。 ```python >>> from sqlalchemy import text >>> stmt = text("SELECT * FROM users WHERE name=:name") >>> ed_user = session.query(User).from_statement(stmt).params(name='ed').first() >>> print(ed_user.name) ed ``` ##### 计数使用 `func.count()` 函数来获取记录数量。 ```python >>> from sqlalchemy import func >>> count = session.query(func.count(User.id)).scalar() >>> print(count) 2 ``` ##### 建立关系通过定义 `relationship` 来建立类之间的关系。 ```python >>> from sqlalchemy import ForeignKey >>> from sqlalchemy.orm import relationship >>> class Address(Base): ... __tablename__ = 'addresses' ... id = Column(Integer, primary_key=True) ... email_address = Column(String(50), nullable=False) ... user_id = Column(Integer, ForeignKey('users.id')) ... user = relationship("User", back_populates="addresses") ... def __repr__(self): ... return "<Address(email_address='%s')>" % self.email_address ... ``` ##### 处理相关对象当一个对象与另一个对象关联时，可以方便地访问和修改相关对象。 ```python >>> jack = User(name='jack', fullname='Jack Bean', addresses=[Address(email_address='jack@google.com')]) >>> session.add(jack) >>> session.commit() >>> jack.addresses [<Address(email_address='jack@google.com')>] ``` ##### 使用连接查询通过 `join()` 方法来处理涉及多个表的查询。 ```python >>> for u, a in session.query(User, Address).filter(User.id==Address.user_id).filter(Address.email_address=='jack@google.com').all(): ... print(u) ... jack ``` ##### 使用别名可以为表创建别名来简化多表查询。 ```python >>> from sqlalchemy.orm import aliased >>> address_alias = aliased(Address) >>> for u, a1, a2 in session.query(User, address_alias, Address).\ ... filter(User.id==address_alias.user_id).\ ... filter(User.id==Address.user_id).\ ... filter(address_alias.email_address=='jack@google.com').\ ... filter(Address.email_address=='jack@yahoo.com').all(): ... print(u) ... jack ``` ##### 使用子查询子查询可以嵌入主查询中，以提取特定的数据集。 ```python >>> from sqlalchemy import select >>> stmt = select([Address]).where(Address.email_address == 'jack@google.com') >>> query = session.query(User).filter(User.addresses.any(stmt)) >>> query.all() [<User(name='jack', fullname='Jack Bean', addresses=[<Address(email_address='jack@google.com')>])>] ``` ##### 从子查询选择实体可以使用子查询的结果作为主查询的一部分。 ```python >>> subq = session.query(Address.user_id, Address.email_address).subquery() >>> query = session.query(User.name, subq.c.email_address).join(subq, User.id==subq.c.user_id).order_by(User.name) >>> query.all() [('jack', 'jack@google.com')] ``` ##### 使用 EXISTS 检查是否存在满足条件的记录。 ```python >>> from sqlalchemy import exists >>> session.query(exists().where(User.name == 'jack')).scalar() True ``` ##### 常用关系操作符 SQLAlchemy 支持多种关系操作符，包括 `any()` 和 `contains()` 等。 ```python >>> session.query(User).filter(User.addresses.any(Address.email_address == 'jack@google.com')).all() [<User(name='jack', fullname='Jack Bean', addresses=[<Address(email_address='jack@google.com')>])>] ``` ##### 贪婪加载在查询时，可以预先加载相关对象，以减少后续的查询次数。 ```python >>> from sqlalchemy.orm import joinedload >>> user = session.query(User).options(joinedload(User.addresses)).filter(User.name == 'jack').one() >>> user.addresses [<Address(email_address='jack@google.com')>] ``` ##### 删除使用 `delete()` 方法从数据库中删除对象。 ```python >>> session.delete(user) >>> session.commit() ``` ##### 配置级联删除可以配置级联删除选项，以便当父对象被删除时，其相关的子对象也会被自动删除。 ```python >>> session.query(User).filter(User.name == 'jack').delete(synchronize_session='fetch') ``` ##### 建立多对多关系多对多关系通常需要一个关联表来维护两个类之间的关系。 ```python >>> from sqlalchemy import Table >>> user_keywords = Table('user_keywords', Base.metadata, ... Column('user_id', Integer, ForeignKey('users.id')), ... Column('keyword_id', Integer, ForeignKey('keywords.id')) ... ) >>> class Keyword(Base): ... __tablename__ = 'keywords' ... id = Column(Integer, primary_key=True) ... keyword = Column(String(50)) ... def __init__(self, keyword): ... self.keyword = keyword ... def __repr__(self): ... return "<Keyword(keyword='%s')>" % self.keyword ... >>> User.keywords = relationship("Keyword", ... secondary=user_keywords, ... backref=backref("users", lazy="dynamic") ... ) ``` #### 映射配置 ##### 经典映射经典映射允许手动指定类与表之间的映射关系，提供了更多的灵活性。 ```python >>> from sqlalchemy.orm import mapper >>> class User(object): ... pass ... >>> mapper(User, User.__table__) ``` ##### 自定义列属性可以自定义列属性，例如改变列名或添加额外的行为。 ```python >>> from sqlalchemy.orm import column_property >>> user_table = Table('users', Base.metadata, ... Column('id', Integer, primary_key=True), ... Column('name', String(50)), ... Column('fullname', String(50)), ... Column('password', String(12)) ... ) >>> class User(object): ... def __init__(self, name, fullname, password): ... self.name = name ... self.fullname = fullname ... self.password = password ... def __repr__(self): ... return "<User('%s','%s', '%s')>" % (self.name, self.fullname, self.password) ... >>> mapper(User, user_table, properties={ ... 'name': user_table.c.name, ... 'fullname': user_table.c.fullname, ... 'password': user_table.c.password, ... 'username': column_property(user_table.c.name + '_username') ... }) ``` ##### 延迟加载可以配置某些属性为延迟加载，这意味着除非明确请求，否则不会加载这些属性。 ```python >>> from sqlalchemy.orm import deferred >>> mapper(User, user_table, properties={ ... 'name': deferred(user_table.c.name) ... }) ``` ##### SQL 表达式作为映射属性可以将 SQL 表达式映射为类的属性。 ```python >>> from sqlalchemy.sql.expression import func >>> mapper(User, user_table, properties={ ... 'lower_name': column_property(func.lower(user_table.c.name)) ... }) ``` ##### 改变属性行为可以通过各种方法改变属性的行为，例如使用验证器、混合类或自定义比较器等。 ```python >>> from sqlalchemy.orm import validates >>> class User(object): ... @validates('name') ... def validate_name(self, key, name): ... if not name.isalpha(): ... raise ValueError("Name must contain only letters") ... return name ... >>> mapper(User, user_table) ``` ##### 复合列类型可以使用复合类型来存储复杂的数据结构。 ```python >>> from sqlalchemy.ext.declarative import declared_attr >>> class Address(object): ... @declared_attr ... def id(cls): ... return Column(Integer, primary_key=True) ... email_address = Column(String(50), nullable=False) ... user_id = Column(Integer, ForeignKey('users.id')) ... user = relationship("User", back_populates="addresses") ... >>> class CompositeType(Base): ... __tablename__ = 'composite_type' ... id = Column(Integer, primary_key=True) ... data = Column(PickleType) ... ``` ##### 映射多个表一个类可以映射到多个表，这适用于复杂的数据模型。 ```python >>> class Person(object): ... pass ... >>> person_table = Table('person', Base.metadata, ... Column('id', Integer, primary_key=True), ... Column('name', String(50)), ... Column('type', String(50)) ... ) >>> mapper(Person, person_table) >>> class Engineer(Person): ... pass ... >>> engineer_table = Table('engineer', Base.metadata, ... Column('person_id', Integer, ForeignKey('person.id'), primary_key=True), ... Column('status', String(30)), ... Column('engineer_name', String(50)), ... Column('primary_language', String(50)) ... ) >>> mapper(Engineer, engineer_table, inherits=mapper(Person)) ``` 以上内容介绍了 SQLAlchemy ORM 的基本概念和常见用法，通过上述示例和解释，开发者可以快速掌握如何使用 SQLAlchemy 来实现数据库操作，并了解 ORM 的优势和适用场景。

func.sum函数是SQLAlchemy中的一个聚合函数，用于计算某一列的总和。可以通过以下方式使用func.sum函数： ```python from sqlalchemy import func result = session.query(func.sum(column_name)).first() ``` 其中，column_name是要求和的列名。该函数返回的结果存放在一个元组中，可以通过`.first()`方法获取第一个元素来获取结果。请注意，session是SQLAlchemy中用于与数据库进行交互的会话对象，需要提前创建并与数据库建立连接。参考资料：聚合函数: https://docs.sqlalchemy.org/en/14/core/sqlelement.html#sqlalchemy.sql.expression.Function 示例代码: https://docs.sqlalchemy.org/en/14/orm/tutorial.html#building-a-relationship 创建ORM模型: https://docs.sqlalchemy.org/en/14/orm/tutorial.html#declare-a-mapping [2 [3123 #### 引用[.reference_title] - *1* *2* *3* [sqlalchemy的基本操作大全](https://blog.csdn.net/qq_43713303/article/details/106766700)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

阅读全文

sqlalchemy func.sum

相关推荐

paste.registry与SQLAlchemy：数据库操作的paste.registry实践指南

【进阶】使用SQLAlchemy进行高级查询

数据库操作进阶：Flask-SQLAlchemy详解

【进阶】数据库高级操作：使用SQLAlchemy

【基础】使用SQLAlchemy进行MySQL数据库操作

SQLAlchemy JOIN操作艺术：连接查询的高效技巧

SQLAlchemy与Django ORM对决：比较优势与实践限制

SQLAlchemy查询构建器指南：精通数据库操作的秘诀

进阶必读：SQLAlchemy关联关系与懒加载的高级应用

SQLAlchemy查询优化大师：构建高效复杂SQL查询的秘诀

深入SQLAlchemy架构：掌握ORM机制，提升数据库操作效率

SQLAlchemy与PostgreSQL整合：深入理解数据库特性与ORM优化

SQLAlchemy自定义SQL表达式：编写高性能SQL片段的技巧

SQLAlchemy遇上SQLite：轻量级数据库操作的高效秘诀

【ORM深度解析】：掌握SQLAlchemy与MySQL交互的艺术

SQLAlchemy子查询高级用法：构建复杂查询的6种方法

动态API接口构建者：SQLAlchemy的过滤器与排序技巧

获取 sqlalchemy 字段总值

sqlalchemy 聚合多个字段

最新推荐

Jupyter_关于长期序列预测NeurIPS 2021的自耦分解变压器的代码发布.zip

考研公共课历年真题集-最新发布.zip

2006-2023年上市公司资产误定价Misp数据集（4.9万样本，含原始数据、代码及结果，最新）.zip

高清艺术文字图标资源，PNG和ICO格式免费下载

管理建模和仿真的文件

DMA技术：绕过CPU实现高效数据传输

SGM8701电压比较器如何在低功耗电池供电系统中实现高效率运作？

mui框架HTML5应用界面组件使用示例教程

"互动学习：行动中的多样性与论文攻读经历"

【数据传输高速公路】：总线系统的深度解析