sqlalchemy union

时间: 2024-05-28 19:07:04 浏览: 188

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 的优势和适用场景。

SQLAlchemy是一种Python SQL工具，它提供了多种方法来执行SQL查询。其中之一就是union。union用于将两个或多个SELECT语句的结果组合成一个结果集。可以使用union实现类似于SQL的UNION功能，即合并两个或多个表的查询结果。在SQLAlchemy中，使用union方法可以将多个查询结果合并成一个结果集。使用方法如下： ```python from sqlalchemy import create_engine, select, union engine = create_engine('sqlite:///example.db') metadata = MetaData() table = Table('my_table', metadata, autoload=True, autoload_with=engine) stmt1 = select([table.c.column1, table.c.column2]).where(table.c.column3 == 'value1') stmt2 = select([table.c.column1, table.c.column2]).where(table.c.column3 == 'value2') union_stmt = union(stmt1, stmt2) ``` 上述代码会生成两个select语句，然后将它们用union方法合并成一个结果集。

阅读全文

sqlalchemy union

相关推荐

sqlalchemy官方文档

sqlalchemy documentation sqlalchemy 文档

sqlalchemy 英文文档

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

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

SQLAlchemy ORM高级特性：继承映射与复合主键的深度探索

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

SQLAlchemy查询构建器深度解析：构建复杂查询的5大技巧

【SQLAlchemy全能指南】：从入门到精通的Python ORM框架

SQLAlchemy安全性终极指南：预防SQL注入与XSS攻击的最佳实践

SQLAlchemy多数据库支持秘籍：配置与使用多个数据库实例的技巧

SQLAlchemy多表查询艺术：JOIN用法深度探索（推荐词汇+价值型）

SQLAlchemy核心教程：构建ORM模型的最佳实践（数字型+推荐词汇）

[In-depth Analysis of ORM]: Mastering the Art of Interaction Between SQLAlchemy and MySQL

1基于蓝牙的项目开发--蓝牙温度监测器.docx

AppDynamics：性能瓶颈识别与优化.docx

percona-xtrabackup-2.4.28-1.ky10.x86-64.rpm

2024年全球产品经理大会（脱敏）PPT合集（34份）.zip

最新推荐

Python SqlAlchemy动态添加数据表字段实例解析

Python流行ORM框架sqlalchemy安装与使用教程

基于sqlalchemy对mysql实现增删改查操作

1基于蓝牙的项目开发--蓝牙温度监测器.docx

AppDynamics：性能瓶颈识别与优化.docx

Haskell编写的C-Minus编译器针对TM架构实现

管理建模和仿真的文件

【数据整理秘籍】：R语言与tidyr包的高效数据处理流程

在使用STEP7编程环境为S7-300 PLC进行编程时，如何正确分配I/O接口地址并利用SM信号模板进行编址？

水电模拟工具HydroElectric开发使用Matlab