Release: 1.4.0b1 | Release Date: November 2, 2020

SQLAlchemy 1.4 Documentation

术语表

1.x风格
2.0风格
1.x风格
2.0风格

这些术语在SQLAlchemy 1.4中是新的,并引用SQLAlchemy 1.4->2.0过渡计划,如中所述 迁移到Alchemy . 术语“1.x样式”指的是在SQLAlchemy 1.x系列和更早版本(例如1.3、1.2等)中使用的API,术语“2.0样式”指的是API在版本2.0中的外观。版本1.4以所谓的“过渡模式”实现了几乎所有2.0的API。

启用2.0样式使用

当使用文档示例中的代码时 2.0-style , the Engine 以及 Session 使用中应使用“未来”模式,通过 create_engine.futureSession.future 旗帜::

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker


engine = create_engine("mysql://user:pass:host/dbname", future=True)
Session = sessionmaker(bind=engine, future=True)

2.0风格的ORM查询

除了上述变化 EngineSession ,可能1.x->2.0所暗示的最主要的API更改是从使用 Query 对象,而不是使用 select()Session.execute() 方法。总体变化如下所示。给予 Session 和A Query 反对这个 Session ::

list_of_users = session.query(User).join(User.addresses).all()

新样式独立于 Session 使用 select() 构造;当使用像 User 类从 ORM Tutorial ,结果 Select construct接收额外的“plugin”状态,允许它像 Query ::

from sqlalchemy import select

# a Core select statement with ORM entities is
# now ORM-enabled at the compiler level
stmt = select(User).join(User.addresses)

session = Session(engine)

result = session.execute(stmt)

# Session returns a Result that has ORM entities
list_of_users = result.scalars().all()
ACID
ACID 酸模型

“原子性、一致性、隔离性、持久性”的缩写;一组确保数据库事务处理可靠的属性。(通过维基百科)

注解

注解是一个概念,由SQLAlchemy内部使用,以便存储附加信息以及 ClauseElement 物体。python字典与对象的副本相关联,该副本包含对各种内部系统(主要在ORM中)重要的键/值对:

some_column = Column('some_column', Integer)
some_column_annotated = some_column._annotate({"entity": User})

注释系统不同于公共字典 Column.info 上面的注释操作创建了一个 copy 新的 Column 而不是将所有注释值都视为单个单元的一部分。ORM创建表达式对象的副本,以便应用特定于其上下文的注释,例如区分应将其自身呈现为关联继承实体的列与应仅呈现为直接父表的列,以及区分“joi”中的列n condition”指一种关系,在某些情况下,列需要根据其在联接表达式中的位置用一个或另一个特定表别名表示。

关联关系

两层的 relationship 使用中间的关联表将两个表链接在一起。关联关系不同于 many to many 关系,即多对多表由一个完整的类映射,而不是由 sqlalchemy.orm.relationship() 与多对多的情况一样构造,以便显式地提供附加属性。

例如,如果我们希望将员工与项目关联起来,同时将该员工的特定角色存储到项目中,那么关系模式可能如下所示:

CREATE TABLE employee (
    id INTEGER PRIMARY KEY,
    name VARCHAR(30)
)

CREATE TABLE project (
    id INTEGER PRIMARY KEY,
    name VARCHAR(30)
)

CREATE TABLE employee_project (
    employee_id INTEGER PRIMARY KEY,
    project_id INTEGER PRIMARY KEY,
    role_name VARCHAR(30),
    FOREIGN KEY employee_id REFERENCES employee(id),
    FOREIGN KEY project_id REFERENCES project(id)
)

上面的SQLAlchemy声明性映射可能如下所示:

class Employee(Base):
    __tablename__ = 'employee'

    id = Column(Integer, primary_key)
    name = Column(String(30))


class Project(Base):
    __tablename__ = 'project'

    id = Column(Integer, primary_key)
    name = Column(String(30))


class EmployeeProject(Base):
    __tablename__ = 'employee_project'

    employee_id = Column(Integer, ForeignKey('employee.id'), primary_key=True)
    project_id = Column(Integer, ForeignKey('project.id'), primary_key=True)
    role_name = Column(String(30))

    project = relationship("Project", backref="project_employees")
    employee = relationship("Employee", backref="employee_projects")

可以将员工添加到给定角色名称的项目中:

proj = Project(name="Client A")

emp1 = Employee(name="emp1")
emp2 = Employee(name="emp2")

proj.project_employees.extend([
    EmployeeProject(employee=emp1, role="tech lead"),
    EmployeeProject(employee=emp2, role="account executive")
])

参见

many to many

原子性

原子性是 ACID 模型,并要求每个事务都是“全部或无”:如果事务的一部分失败,则整个事务失败,数据库状态保持不变。原子系统必须保证每种情况下的原子性,包括电源故障、错误和崩溃。(通过维基百科)

背衬
双向关系

扩展到 relationship 两个不同的系统 relationship() 对象可以相互关联,这样它们在内存中随着两侧的变化而协调。构建这两个关系最常见的方法是使用 relationship() 为一侧显式函数并指定 backref 它的关键字,以便另一个 relationship() 自动创建。我们可以用这个例子来说明这一点。 one to many 如下:

class Department(Base):
    __tablename__ = 'department'
    id = Column(Integer, primary_key=True)
    name = Column(String(30))
    employees = relationship("Employee", backref="department")

class Employee(Base):
    __tablename__ = 'employee'
    id = Column(Integer, primary_key=True)
    name = Column(String(30))
    dep_id = Column(Integer, ForeignKey('department.id'))

backref可以应用于任何关系,包括一对多、多对一,以及 many to many .

绑定参数
绑定参数
绑定参数
绑定参数

绑定参数是将数据传递到 DBAPI 数据库驱动程序。虽然要调用的操作基于SQL语句字符串,但数据值本身是单独传递的,其中驱动程序包含将安全地处理这些字符串并将它们传递到后端数据库服务器的逻辑,这可能涉及将参数格式化为SQL字符串本身,或者将它们传递给数据库使用不同的协议。

数据库驱动程序执行此操作的特定系统对调用者来说并不重要;关键是在外部,数据应该 总是 单独传递,而不是作为SQL字符串本身的一部分。这对于具有足够的针对SQL注入的安全性以及允许驱动程序具有最佳性能是不可或缺的。

参见

Prepared Statement -在维基百科

bind parameters -在使用索引,卢克!

候选关键字

A relational algebra 一个术语,指一个属性或一组属性,构成一行的唯一标识键。一行可以有多个候选键,每个候选键都适合用作该行的主键。表的主键始终是候选键。

笛卡尔积

在A中,A和B是两个集合的乘积。

就SQL数据库而言,当我们从两个或多个表(或其他子查询)中进行选择时,如果没有在一个表到另一个表的行之间(直接或间接)建立任何类型的条件,就会产生笛卡尔积。如果我们同时从表A和表B中选择,则A的每一行都匹配到B的第一行,然后A的每一行都匹配到B的第二行,依此类推,直到A中的每一行都与B的每一行配对。

笛卡尔产品会产生大量的结果集,如果不加以预防,很容易使客户端应用程序崩溃。

叶栅

SQLAlchemy中使用的一个术语,用于描述在特定对象上发生的ORM持久性操作如何扩展到与该对象直接相关联的其他对象。在SQLAlchemy中,这些对象关联是使用 relationship() 构造。 relationship() 包含一个名为 relationship.cascade 它提供了某些持久性操作如何级联的选项。

无论好坏,SQLAlchemy中的术语“级联”以及该系统的一般架构都是从HibernateORM中借用的。

参见

级联

检查约束

检查约束是在添加或更新关系数据库表中的条目时定义有效数据的条件。检查约束将应用于表中的每一行。

(通过维基百科)

可以使用以下命令将CHECK约束添加到标准SQL中的表中 DDL 如下所示:

ALTER TABLE distributors ADD CONSTRAINT zipchk CHECK (char_length(zipcode) = 5);
列条款

部分 SELECT 枚举要在结果集中返回的SQL表达式的语句。表达式遵循 SELECT 关键字直接和是单个表达式的逗号分隔列表。

例如。:

SELECT user_account.name, user_account.email
FROM user_account WHERE user_account.name = 'fred'

上面,列列表 user_acount.nameuser_account.email 是的columns子句 SELECT .

复合主键

A primary key 它有多个列。一个特定的数据库行基于两个或多个列而不仅仅是一个值是唯一的。

参见

primary key

一致性

一致性是 ACID 建模,并确保任何事务都会将数据库从一个有效状态转移到另一个有效状态。任何写入数据库的数据必须根据所有定义的规则有效,包括但不限于 constraints ,级联、触发器及其任何组合。(通过维基百科)

约束
约束条件
约束的

在关系数据库中建立的规则,以确保数据的有效性和一致性。常见的约束形式包括 primary key constraintforeign key constraintcheck constraint .

相关
相关子查询
相关子查询

A subquery 如果依赖于封闭中的数据,则关联 SELECT .

下面,子查询选择聚合值 MIN(a.id)email_address 表,以便对 user_account.id ,将此列的值与 email_address.user_account_id 专栏:

SELECT user_account.name, email_address.email
 FROM user_account
 JOIN email_address ON user_account.id=email_address.user_account_id
 WHERE email_address.id = (
    SELECT MIN(a.id) FROM email_address AS a
    WHERE a.user_account_id=user_account.id
 )

上面的子查询引用 user_account 表,它本身不在 FROM 此嵌套查询的子句。相反, user_account 从封闭查询接收表,其中每个行都是从 user_account 导致子查询的不同执行。

在大多数情况下,关联子查询出现在 WHERE clausecolumns clause 立即封闭的 SELECT 声明,以及在ORDER BY或HAVING子句中。

在不太常见的情况下,相关子查询可能出现在 FROM clause 封闭的 SELECT ;在这些情况下,相关性通常是由于 SELECT 包含在另一个的where、order by、columns或having子句中 SELECT ,例如:

SELECT parent.id FROM parent
WHERE EXISTS (
    SELECT * FROM (
        SELECT child.id AS id, child.parent_id AS parent_id, child.pos AS pos
        FROM child
        WHERE child.parent_id = parent.id ORDER BY child.pos
    LIMIT 3)
WHERE id = 7)

从一开始的相关性 SELECT 直接到通过其 FROM 子句是不可能的,因为只有当封闭语句的FROM子句的原始源行可用时,关联才能继续。

克鲁德
CRUD

一个缩写词,意思是“创建、更新、删除”。SQL中的术语是指从数据库中创建、修改和删除数据的一组操作,也称为 DML ,通常指 INSERTUPDATEDELETE 声明。

光标

允许遍历数据库中的记录的一种控制结构。在Python DBAPI中,cursor对象实际上是语句执行的起点,也是用于获取结果的接口。

圈复杂度

一种代码复杂度的度量,基于通过程序源代码的可能路径的数量。

DBAPI

dbapi是短语“python database api specification”的缩写。这是Python中广泛使用的规范,用于为所有数据库连接包定义通用的使用模式。DBAPI是一个“低级”API,通常是Python应用程序中用于与数据库对话的最低级别系统。SQLAlchemy dialect 系统是围绕dbapi的操作构建的,它提供单个方言类,这些方言类在特定的数据库引擎之上为特定的dbapi提供服务;例如, create_engine() URL postgresql+psycopg2://@localhost/test 指的是 psycopg2 dbapi/方言组合,而url mysql+mysqldb://@localhost/test 指的是 MySQL for Python DBAPI DBAPI/方言组合。

DDL

首字母缩写词 数据定义语言 . DDL是关系数据库用来配置数据库模式中的表、约束和其他永久对象的SQL的子集。SQLAlchemy为构造和发出DDL表达式提供了丰富的API。

删除

这描述了对象在 Session ;已删除对象是以前是持久的对象,并且在刷新过程中向数据库发出了删除语句以删除其行。对象将移动到 detached 一旦会话的事务被提交,则状态为;或者,如果会话的事务被回滚,则删除将被还原,对象将移回 persistent 状态。

描述符
描述符

在Python中,描述符是具有“绑定行为”的对象属性,其属性访问已被 descriptor protocol . 这些方法是u get_uu()、u set_uu()和uu delete_uu()。如果为对象定义了这些方法中的任何一个,则称其为描述符。

在SQLAlchemy中,为了在映射类上提供属性行为,大量使用描述符。当类被映射为这样时:

class MyClass(Base):
    __tablename__ = 'foo'

    id = Column(Integer, primary_key=True)
    data = Column(String)

这个 MyClass 班级将 mapped 当其定义完成时,此时 iddata 属性,从 Column 对象,将替换为 instrumentation 具有以下实例的系统 InstrumentedAttribute ,它们是提供上述内容的描述符 __get__()__set__()__delete__() 方法。这个 InstrumentedAttribute 在类级别使用时将生成SQL表达式::

>>> print(MyClass.data == 5)
data = :data_1

在实例级别,跟踪值的更改,以及 lazy loads 已从数据库中卸载属性::

>>> m1 = MyClass()
>>> m1.id = 5
>>> m1.data = "some data"

>>> from sqlalchemy import inspect
>>> inspect(m1).attrs.data.history.added
"some data"
独立的

这描述了对象在 Session ;分离的对象是具有数据库标识(即主键)但不与任何会话关联的对象。以前的对象 persistent 并且被从会话中删除,可能是因为它已被删除,或者所属会话已关闭,从而移动到分离状态。分离状态通常用于在会话之间移动对象或从外部对象缓存移动对象时。

方言

在SQLAlchemy中,“方言”是一个Python对象,它表示允许数据库操作在特定类型的数据库后端和特定类型的Python驱动程序(或 DBAPI )对于那个数据库。SQLAlchemy方言是 Dialect 班级。

参见

引擎配置

鉴别器

polymorphic 加载以确定应将哪种映射类应用于特定的传入结果行。在SQLAlchemy中,类始终是使用继承映射的层次结构映射的一部分。

DML

首字母缩写词 数据操作语言 . DML是关系数据库使用的SQL的子集 修改 表中的数据。DML通常指的是三个广泛熟悉的语句INSERT、UPDATE和DELETE,或者称为 CRUD (“创建、更新、删除”的缩写)。

领域模型

问题解决和软件工程中的领域模型是与特定问题相关的所有主题的概念模型。它描述了各种实体、它们的属性、角色和关系,以及控制问题域的约束。

(通过维基百科)

DQL

首字母缩写词 数据查询语言 . DQL是关系数据库使用的SQL的子集 read 表中的数据。DQL几乎完全将sqlselect构造作为使用中的顶级SQL语句。

耐久性

耐久性是 ACID 模型,这意味着一旦事务被提交,它将保持不变,即使在断电、崩溃或错误的情况下。例如,在关系数据库中,一旦执行了一组SQL语句,就需要永久地存储结果(即使之后数据库立即崩溃)。(通过维基百科)

急载
急载
迫不及待地
急装

在对象关系映射中,“急切加载”是指在从数据库加载对象本身的同时,用其数据库端值填充的属性。在SQLAlchemy中,“急切加载”通常指使用 relationship() 构造。急迫装载是相反的 lazy loading .

到期
期满
到期
期满
过期

在sqlAlchemy ORM中,是指 persistent 或有时 detached 对象被擦除,以便下次访问对象的属性时, lazy load 将发出SQL查询以刷新存储在当前正在进行的事务中的此对象的数据。

参见

刷新/过期

外观

一种作为前向接口的对象,用于屏蔽更复杂的底层或结构代码。

外键约束

两个表之间的引用约束。外键是关系表中与 candidate key 另一张表格。外键可用于交叉引用表。(通过维基百科)

可以使用以下方法将外键约束添加到标准SQL中的表中 DDL 如下所示:

ALTER TABLE employee ADD CONSTRAINT dep_id_fk
FOREIGN KEY (employee) REFERENCES department (dep_id)
从句

部分 SELECT 指示行的初始源的语句。

简单的 SELECT 将在其FROM子句中具有一个或多个表名。多个源由逗号分隔:

SELECT user.name, address.email_address
FROM user, address
WHERE user.id=address.user_id

FROM子句也是指定显式联接的地方。我们可以重写上面的内容 SELECT 使用单一 FROM 元素,由 JOIN 在这两张表中:

SELECT user.name, address.email_address
FROM user JOIN address ON user.id=address.user_id
生成的

SQLAlchemy用来指通常所说的 method chaining ;详情请参见该术语。

同一映射

python对象及其数据库标识之间的映射。标识映射是与ORM关联的集合。 Session 对象,并维护每个键入其标识的数据库对象的单个实例。此模式的优点是,为特定数据库标识发生的所有操作都透明地协调到单个对象实例上。将身份图与 isolated 从实际的角度来看,事务(具有对已知具有特定主键的对象的引用)可以被视为实际数据库行的代理。

仪器仪表
仪器化的
仪表化

Instrumentation是指扩充特定类的功能和属性集的过程。理想情况下,类的行为应该保持接近于常规类,除非提供了额外的行为和特性。圣卢西亚 mapping 除其他外,进程还添加了启用数据库的 descriptors 映射到一个映射类,每个映射类表示特定的数据库列或与相关类的关系。

隔离
孤立的
隔离
隔离级别

的隔离属性 ACID 模型确保事务的并发执行产生一个系统状态,如果事务是连续执行的,即一个接一个地执行,那么将获得该状态。每个事务必须完全隔离地执行,即如果T1和T2同时执行,那么每个事务都应该独立于另一个事务。(通过维基百科)

延迟初始化

延迟某些初始化操作的策略,如创建对象、填充数据或建立与其他服务的连接,直到需要这些资源为止。

怠速载荷
惰性负载
懒散加载
延迟加载

在对象关系映射中,“延迟加载”指的是在一段时间内(通常是在首次加载对象时)不包含其数据库端值的属性。相反,该属性接收 记忆化 这会导致它在第一次使用时输出到数据库并加载其数据。使用这种模式,有时可以减少对象获取的复杂性和时间,因为不需要立即处理相关表的属性。延迟加载与 eager loading .

多对多

一种风格 sqlalchemy.orm.relationship() 通过中间的中间表将两个表链接在一起。使用此配置,左侧的任意行数可能表示右侧的任意行数,反之亦然。

员工可以与项目关联的架构:

CREATE TABLE employee (
    id INTEGER PRIMARY KEY,
    name VARCHAR(30)
)

CREATE TABLE project (
    id INTEGER PRIMARY KEY,
    name VARCHAR(30)
)

CREATE TABLE employee_project (
    employee_id INTEGER PRIMARY KEY,
    project_id INTEGER PRIMARY KEY,
    FOREIGN KEY employee_id REFERENCES employee(id),
    FOREIGN KEY project_id REFERENCES project(id)
)

上面, employee_project 表是多对多表,它自然形成由每个相关表的主键组成的复合主键。

在SQLAlchemy中, sqlalchemy.orm.relationship() 函数可以以最透明的方式表示这种类型的关系,其中多对多表是使用普通表元数据指定的:

class Employee(Base):
    __tablename__ = 'employee'

    id = Column(Integer, primary_key)
    name = Column(String(30))

    projects = relationship(
        "Project",
        secondary=Table('employee_project', Base.metadata,
                    Column("employee_id", Integer, ForeignKey('employee.id'),
                                primary_key=True),
                    Column("project_id", Integer, ForeignKey('project.id'),
                                primary_key=True)
                ),
        backref="employees"
        )

class Project(Base):
    __tablename__ = 'project'

    id = Column(Integer, primary_key)
    name = Column(String(30))

上面, Employee.projects 和反向引用 Project.employees 集合已定义::

proj = Project(name="Client A")

emp1 = Employee(name="emp1")
emp2 = Employee(name="emp2")

proj.employees.extend([emp1, emp2])
多对一

一种风格 relationship() 它将父映射器表中的外键链接到相关表的主键。然后,每个父对象都可以引用零个或一个相关对象。

相关对象将依次具有隐式或显式 one to many 与引用它们的任何数量的父对象的关系。

示例多对一模式(注意,它与 one to many 模式):

CREATE TABLE department (
    id INTEGER PRIMARY KEY,
    name VARCHAR(30)
)

CREATE TABLE employee (
    id INTEGER PRIMARY KEY,
    name VARCHAR(30),
    dep_id INTEGER REFERENCES department(id)
)

关系来自 employeedepartment 是多对一,因为许多员工记录可以与单个部门关联。SQLAlchemy映射可能如下所示:

class Department(Base):
    __tablename__ = 'department'
    id = Column(Integer, primary_key=True)
    name = Column(String(30))

class Employee(Base):
    __tablename__ = 'employee'
    id = Column(Integer, primary_key=True)
    name = Column(String(30))
    dep_id = Column(Integer, ForeignKey('department.id'))
    department = relationship("Department")
映射
映射
映射类

当一个类通过 mapper() 功能。此进程将类与数据库表或其他 selectable 构造,以便可以使用 Session .

编组
数据编组

当数据必须在计算机程序的不同部分之间或从一个程序转移到另一个程序时,将对象的存储器表示形式转换成适合存储或传输到系统另一部分的数据格式的过程。就SQLAlchemy而言,我们经常需要将数据“封送”为适合传递到关系数据库的格式。

参见

Marshalling (via Wikipedia)

扩充现有类型 -SQL炼金术 TypeDecorator 通常用于在将数据发送到数据库以执行INSERT和UPDATE语句时进行数据编组,以及在使用SELECT语句检索数据时“解组”数据。

元数据
数据库元数据
表元数据

术语“元数据”通常指“描述数据的数据”;数据本身表示某种其他类型数据的格式和/或结构。在SQLAlchemy中,“元数据”一词通常指 MetaData 构造,它是有关表、列、约束和其他 DDL 可能存在于特定数据库中的对象。

方法链

一种面向对象的技术,通过对对象调用方法来构造对象的状态。对象具有任意数量的方法,每个方法都返回一个新对象(或者在某些情况下返回同一个对象),并向对象添加其他状态。

最常用方法链接的两个sqlAlchemy对象是 Select 对象与 Query 对象。例如,A Select 对象可以通过调用 Select.where()Select.order_by() 方法::

stmt = select(user.c.name).\
            where(user.c.id > 5).\
            where(user.c.name.like('e%').\
            order_by(user.c.name)

上面的每个方法调用都返回原始 Select 添加了附加限定符的对象。

参见

generative

n加上一个问题
N加1

n+1问题是 lazy load 模式,应用程序希望在结果集对象的每个成员上迭代相关的属性或集合,其中该属性或集合设置为通过惰性加载模式加载。最终结果是,会发出一条select语句来加载父对象的初始结果集;然后,当应用程序迭代每个成员时,会为每个成员发出一条额外的select语句,以便加载该成员的相关属性或集合。最终结果是,对于n个父对象的结果集,将发出n+1 select语句。

n+1问题可以用 eager loading .

一对多

一种风格 relationship() 它将父映射器表的主键链接到相关表的外键。然后,每个唯一的父对象可以引用零个或更多唯一的相关对象。

相关对象将依次具有隐式或显式 many to one 与其父对象的关系。

示例一对多模式(注意,它与 many to one 模式):

CREATE TABLE department (
    id INTEGER PRIMARY KEY,
    name VARCHAR(30)
)

CREATE TABLE employee (
    id INTEGER PRIMARY KEY,
    name VARCHAR(30),
    dep_id INTEGER REFERENCES department(id)
)

关系来自 departmentemployee 是一对多的,因为许多员工记录可以与单个部门关联。SQLAlchemy映射可能如下所示:

class Department(Base):
    __tablename__ = 'department'
    id = Column(Integer, primary_key=True)
    name = Column(String(30))
    employees = relationship("Employee")

class Employee(Base):
    __tablename__ = 'employee'
    id = Column(Integer, primary_key=True)
    name = Column(String(30))
    dep_id = Column(Integer, ForeignKey('department.id'))
悬而未决的

这描述了对象在 Session ;挂起对象是一个新对象,它没有任何数据库标识,但最近已与会话关联。当会话发出刷新并插入行时,对象将移动到 persistent 状态。

持久的

这描述了对象在 Session ;持久对象是具有数据库标识(即主键)且当前与会话关联的对象。以前的任何对象 pending 和会话从数据库加载的任何对象一样,插入的对象现在处于持久状态。当从会话中删除持久对象时,它被称为 detached .

插件
特定于插件

“特定于插件”通常表示SQLAlchemy Core中的函数或方法,在ORM上下文中使用时,该函数或方法的行为会有所不同。

SQLAlchemy允许核心构造,如 Select 对象来参与“插件”系统,它可以向对象注入默认情况下不存在的其他行为和特性。

具体地说,主要的“插件”是“orm”插件,它是SQLAlchemy orm使用核心结构来编写和执行返回orm结果的SQL查询的基础。

多态的
多态

一次处理多个类型的函数。在sqlAlchemy中,该方言通常应用于ORM映射类的概念,查询操作将根据结果集中的信息返回不同的子类,通常通过检查结果中特定列的值(称为 discriminator .

SQLAlchemy中的多态加载意味着使用一个或三个不同方案的组合来映射类的层次结构:“联合”、“单一”和“具体”。断面 映射类继承层次结构 完全描述继承映射。

主键
主键约束

A constraint 它唯一地定义了表中每一行的特征。主键必须包含不能被任何其他行复制的特征。主键可以由单个属性或多个属性组合而成。(通过维基百科)

表的主键通常在 CREATE TABLE DDL

CREATE TABLE employee (
     emp_id INTEGER,
     emp_name VARCHAR(30),
     dep_id INTEGER,
     PRIMARY KEY (emp_id)
)
已提交读取

四个数据库之一 isolation 级别、读提交特性,即事务不会暴露于其他尚未提交的并发事务的任何数据,从而防止所谓的“脏读”。但是,在read committed下可能存在不可重复的读取,这意味着如果另一个事务已提交更改,则第二次读取时行中的数据可能会更改。

读取未提交

四个数据库之一 isolation 在事务提交之前,对事务中的数据库数据所做的更改不会成为永久性的。但是,在read uncommitted中,在其他事务中未提交的数据可能在另一个事务的范围内可见;这些被称为“脏读”。

登记处

一种对象,通常是全局可访问的,包含有关某些程序状态的长期信息,这些信息通常对程序的许多部分有用。

关系型
关系代数

由埃德加F.Codd开发的一种代数系统,用于对存储在关系数据库中的数据进行建模和查询。

关系
关系

两个映射类之间的连接单元,对应于数据库中两个表之间的某种关系。

使用sqlAlchemy函数定义关系 relationship() . 一旦创建,sqlAlchemy将检查涉及的参数和基础映射,以便将关系分类为三种类型之一: one to manymany to onemany to many . 通过这种分类,关系构造可以处理在数据库中保持适当链接以响应内存中的对象关联的任务,以及根据数据库中的当前链接将对象引用和集合加载到内存中的任务。

参见

关系配置

释放
发行版
释放

在SQLAlchemy的上下文中,术语“released”是指结束使用特定数据库连接的过程。SQLAlchemy的特点是连接池的使用,允许对数据库连接的寿命进行配置。当使用池连接时,将其“关闭”的过程,即调用如下语句 connection.close() ,可能具有返回到现有池的连接的效果,也可能具有实际关闭该连接所引用的基础TCP/IP连接的效果—发生这种情况取决于配置以及池的当前状态。所以我们用这个词 释放 相反,它的意思是“当我们使用完连接后,用它们做任何事情”。

这个术语有时会在短语“释放事务性资源”中使用,以更明确地表示,我们实际上“释放”的是在连接时累积的任何事务性状态。在大多数情况下,从表中选择、发出更新等的过程获取 isolated 在该连接以及潜在的行或表锁上声明。此状态对于连接上的特定事务都是本地的,并且在发出回滚时释放。连接池的一个重要特性是,当我们返回到池的连接时, connection.rollback() 也调用了dbapi的方法,这样当连接设置为再次使用时,它处于“干净”状态,没有对前一系列操作的引用。

参见

连接池

可重复读

四个数据库之一 isolation 级别,可重复读取功能所有的隔离 read committed ,并且还具有这样一个特性:在事务中读取的任何特定行从该点起保证在该事务期间不会发生任何后续的外部值更改(即从其他并发更新语句中)。

RETURNING

这是由某些后端以各种形式提供的非SQL标准子句,它提供在执行insert、update或delete语句时返回结果集的服务。可以返回匹配行中的任何列集,就好像它们是从select语句生成的一样。

返回子句为常见的更新/选择方案提供了显著的性能提升,包括检索内联或默认生成的主键值和创建时的默认值,以及以原子方式获取服务器生成的默认值的方法。

返回postgresql的一个惯用示例如下:

INSERT INTO user_account (name) VALUES ('new name') RETURNING id, timestamp

在上面,insert语句将在执行时提供一个结果集,其中包含列的值 user_account.iduser_account.timestamp ,上面的值应该作为默认值生成,因为它们不包含在其他值中(但请注意,任何列或SQL表达式系列都可以放入返回中,而不仅仅是默认值列)。

当前支持返回或类似构造的后端是PostgreSQL、SQL Server、Oracle和Firebird。PostgreSQL和Firebird实现通常功能齐全,而SQL Server和Oracle的实现则有警告。在SQL Server上,该子句对于insert和update语句被称为“output inserted”,对于delete语句被称为“output deleted”;关键注意事项是触发器不支持与此关键字一起使用。在Oracle上,它被称为“返回…进入”,并要求将值放入out参数中,这意味着不仅语法不好,而且一次只能用于一行。

SQLAlchemy UpdateBase.returning() 系统在这些后端的返回系统之上提供一个抽象层,为返回列提供一致的接口。ORM还包括许多优化,可以在可用时使用返回。

可选择的

SQLAlchemy中用于描述表示行集合的SQL构造的术语。这在很大程度上类似于 relational algebra . 在SQLAlchemy中,子类 Selectable 当使用SQLAlchemy核心时,类被认为是可用的“可选择的”。两个最常见的构造是 Table 还有那个 Select 语句。

可串行化的

四个数据库之一 isolation 级别,可序列化功能所有的隔离 repeatable read 另外,在基于锁的方法中,还可以保证不会发生所谓的“幻象读取”;这意味着在其他事务范围内插入或删除的行在该事务中将无法检测到。在该事务中读取的行保证继续存在,而不存在的行则保证它不能从另一个事务中出现或插入。

可序列化隔离通常依赖于行或行范围的锁定来实现这一效果,并且会增加死锁的几率并降低性能。也有非基于锁的方案,但是如果检测到写入冲突,这些方案必然依赖于拒绝事务。

会话

ORM数据库操作的容器或范围。会话从数据库加载实例,跟踪对映射实例的更改,并在刷新时在单个工作单元中保留更改。

参见

使用会话

子查询
标量子查询

指的是 SELECT 嵌入在封闭中的语句 SELECT .

子查询有两种常见的形式,一种称为“标量选择”,它具体地必须返回一行一列,另一种形式充当“派生表”,并充当另一个选择的FROM子句的行源。标量选择可以放置在 WHERE clausecolumns clause ,ORDER BY子句或HAVING子句的封闭select,而派生表窗体可以放置在封闭select的FROM子句中。 SELECT .

实例:

  1. 放置在 columns clause 封闭的 SELECT . 本例中的子查询是 correlated subquery 因为它选择的部分行是通过封闭语句给出的。

    SELECT id, (SELECT name FROM address WHERE address.user_id=user.id)
    FROM user
  2. 放置在 WHERE clause 封闭的 SELECT . 此示例中的子查询在选择固定结果时不相关。

    SELECT id, name FROM user
    WHERE status=(SELECT status_id FROM status_code WHERE code='C')
  3. 放置在 FROM clause 封闭的 SELECT . 这样的子查询几乎总是被赋予别名。

    SELECT user.id, user.name, ad_subq.email_address
    FROM
        user JOIN
        (select user_id, email_address FROM address WHERE address_type='Q') AS ad_subq
        ON user.id = ad_subq.user_id
瞬态

这描述了对象在 Session ;临时对象是没有任何数据库标识且尚未与会话关联的新对象。当对象添加到会话中时,它将移动到 pending 状态。

唯一约束
唯一键索引

唯一键索引可以唯一地标识数据库表中的每一行数据值。唯一键索引由单个数据库表中的一列或一组列组成。如果不使用空值,则数据库表中的两个不同行或数据记录在这些唯一键索引列中不能具有相同的数据值(或数据值的组合)。根据其设计,数据库表可能有许多唯一的键索引,但最多只能有一个主键索引。

(通过维基百科)

工作单位

在这种模式中,系统透明地跟踪对象的更改,并定期将所有挂起的更改刷新到数据库中。SQLAlchemy的会话以类似于Hibernate的方式完全实现此模式。

版本id列

在SQLAlchemy中,这是指在行更改值时使用跟踪特定行的“版本”的特定表列。虽然有不同类型的关系模式以不同的方式使用“version id column”,但SQLAlchemy的ORM包含一个特定的特性,允许将此类列配置为在用新信息更新行时测试过时数据的方法。如果在尝试将新数据放入行时,此列的最后一个已知“版本”与该行的“版本”不匹配,则说明我们在处理过时的信息。

还有其他方法可以在数据库中存储“版本化”的行,通常称为“临时”数据。除了SQLAlchemy的版本控制功能,文档中还提供了更多示例,请参见下面的链接。

参见

配置版本计数器 -SQLAlchemy的内置版本id特性。

版本控制对象 -临时版本行的其他映射示例。

何处条款

部分 SELECT 指示筛选行的条件的语句。它是关键字后面的单个SQL表达式 WHERE .

SELECT user_account.name, user_account.email
FROM user_account
WHERE user_account.name = 'fred' AND user_account.status = 'E'

上面,这个短语 WHERE user_account.name = 'fred' AND user_account.status = 'E' 包含的Where子句 SELECT .