列元素和表达式¶

表达式API由一系列类组成,每个类表示SQL字符串中的特定词汇元素。它们组合成一个更大的结构,形成一个语句结构 编译的 传递到可以传递到数据库的字符串表示形式中。这些类被组织成一个从最基本的子句类开始的层次结构。键子类包括ColumnElement,它表示SQL语句中任何基于列的表达式的角色,例如在Columns子句、Where子句和Order By子句中,以及FromClause,它表示放置在Select语句的From子句中的标记的角色。

sqlalchemy.sql.expression.all_(expr)

生成一个all表达式。

这可能适用于某些方言的数组类型(例如PostgreSQL),也可能适用于其他方言的子查询(例如MySQL)。例如。::

# postgresql '5 = ALL (somearray)'
expr = 5 == all_(mytable.c.somearray)

# mysql '5 = ALL (SELECT value FROM table)'
expr = 5 == all_(select([table.c.value]))

1.1 新版功能.

sqlalchemy.sql.expression.and_(*clauses)

生成由以下对象连接的表达式的连接 AND .

例如。::

from sqlalchemy import and_

stmt = select([users_table]).where(
                and_(
                    users_table.c.name == 'wendy',
                    users_table.c.enrolled == True
                )
            )

这个 and_() 也可以使用python & 运算符(不过请注意,复合表达式需要加括号才能使用python运算符优先行为运行)::

stmt = select([users_table]).where(
                (users_table.c.name == 'wendy') &
                (users_table.c.enrolled == True)
            )

这个 and_() 操作在某些情况下也是隐式的;在 Select.where() 例如,可以对一个语句多次调用方法,该语句将具有每个子句组合的效果,使用 and_() ::

stmt = select([users_table]).                        where(users_table.c.name == 'wendy').                        where(users_table.c.enrolled == True)

参见

or_()

sqlalchemy.sql.expression.any_(expr)

生成任意表达式。

这可能适用于某些方言的数组类型(例如PostgreSQL),也可能适用于其他方言的子查询(例如MySQL)。例如。::

# postgresql '5 = ANY (somearray)'
expr = 5 == any_(mytable.c.somearray)

# mysql '5 = ANY (SELECT value FROM table)'
expr = 5 == any_(select([table.c.value]))

1.1 新版功能.

sqlalchemy.sql.expression.asc(column)

产生一个上升的 ORDER BY 子句元素。

例如。::

from sqlalchemy import asc
stmt = select([users_table]).order_by(asc(users_table.c.name))

将生成以下SQL::

SELECT id, name FROM user ORDER BY name ASC

这个 asc() 函数是 ColumnElement.asc() 方法可用于所有SQL表达式,例如:

stmt = select([users_table]).order_by(users_table.c.name.asc())
参数

column -- A ColumnElement (例如,标量SQL表达式)用于应用 asc() 操作。

sqlalchemy.sql.expression.between(expr, lower_bound, upper_bound, symmetric=False)

产生一个 BETWEEN 谓词子句。

例如。::

from sqlalchemy import between
stmt = select([users_table]).where(between(users_table.c.id, 5, 7))

将生成类似以下内容的SQL:

SELECT id, name FROM user WHERE id BETWEEN :id_1 AND :id_2

这个 between() 函数是 ColumnElement.between() 方法可用于所有SQL表达式,如:

stmt = select([users_table]).where(users_table.c.id.between(5, 7))

传递给的所有参数 between() 如果值不是 ColumnElement 子类。例如,可以将三个固定值进行比较,如下所示:

print(between(5, 3, 7))

会产生:

:param_1 BETWEEN :param_2 AND :param_3
参数
  • expr -- 列表达式,通常是 ColumnElement 实例,或者将python标量表达式强制为列表达式,用作 BETWEEN 表达式。

  • lower_bound -- 列或python标量表达式,用作 BETWEEN 表达式。

  • upper_bound -- 列或python标量表达式,用作 BETWEEN 表达式。

  • symmetric -- 如果为真,将呈现“在对称之间”。请注意,并非所有数据库都支持此语法。…添加的版本:0.9.5

sqlalchemy.sql.expression.bindparam(key, value=symbol('NO_ARG'), type_=None, unique=False, required=symbol('NO_ARG'), quote=None, callable_=None, expanding=False, isoutparam=False, _compared_to_operator=None, _compared_to_type=None)

生成“绑定表达式”。

返回值是的实例 BindParameter 这是一个 ColumnElement 表示SQL表达式中所谓的“占位符”值的子类,该值在语句针对数据库连接执行时提供。

在SQLAlchemy中, bindparam() construct能够携带最终在表达式时使用的实际值。这样,它不仅作为最终填充的“占位符”,而且作为表示所谓“不安全”值的方法,这些值不应直接在SQL语句中呈现,而是应传递给 DBAPI 作为需要正确转义并可能为类型安全处理的值。

使用时 bindparam() 明确地说,用例通常是传统的参数延迟之一; bindparam() 构造接受可在执行时引用的名称::

from sqlalchemy import bindparam

stmt = select([users_table]).\
            where(users_table.c.name == bindparam('username'))

上述语句在呈现时将生成类似以下内容的SQL:

SELECT id, name FROM user WHERE name = :username

为了填充 :username 上面,该值通常在执行时应用于 Connection.execute() ::

result = connection.execute(stmt, username='wendy')

明确使用 bindparam() 在生成要多次调用的UPDATE或DELETE语句时也是常见的,其中语句的WHERE条件在每次调用时都要更改,例如:

stmt = (users_table.update().
        where(user_table.c.name == bindparam('username')).
        values(fullname=bindparam('fullname'))
        )

connection.execute(
    stmt, [{"username": "wendy", "fullname": "Wendy Smith"},
           {"username": "jack", "fullname": "Jack Jones"},
           ]
)

SQLAlchemy的核心表达式系统广泛使用 bindparam() 在一个隐含的意义上。通常,传递给几乎所有SQL表达式函数的python文本值都被强制为fixed bindparam() 构造。例如,给定一个比较操作,例如:

expr = users_table.c.name == 'Wendy'

上面的表达式将生成 BinaryExpression 在左侧为 Column 表示的对象 name 立柱,右侧为 BindParameter 表示文字值:

print(repr(expr.right))
BindParameter('%(4327771088 name)s', 'Wendy', type_=String())

上面的表达式将呈现SQL,例如:

user.name = :name_1

何处 :name_1 参数名是匿名名称。实际字符串 Wendy 不在呈现的字符串中,而是在以后语句执行中使用该字符串的位置进行。如果我们调用如下语句:

stmt = select([users_table]).where(users_table.c.name == 'Wendy')
result = connection.execute(stmt)

我们将看到SQL日志记录输出为:

SELECT "user".id, "user".name
FROM "user"
WHERE "user".name = %(name_1)s
{'name_1': 'Wendy'}

上面,我们看到了 Wendy 作为参数传递到数据库,而占位符 :name_1 以目标数据库的适当形式呈现,在本例中是PostgreSQL数据库。

同样地, bindparam() 使用时自动调用 CRUD 关于“价值”部分的陈述。这个 insert() 构造生成 INSERT 表达式,它将在语句执行时根据传递的参数生成绑定的占位符,如:

stmt = users_table.insert()
result = connection.execute(stmt, name='Wendy')

上面将生成SQL输出,如下所示:

INSERT INTO "user" (name) VALUES (%(name)s)
{'name': 'Wendy'}

这个 Insert 在编译/执行时,构造 bindparam() 镜像列名 name 因为单身 name 我们传递给 Connection.execute() 方法。

参数
  • key -- 此绑定参数的键(例如名称)。将在生成的SQL语句中用于使用命名参数的方言。如果编译操作是编译操作的一部分,则可以修改此值 BindParameter 对象具有相同的键,或者其长度太长,需要截断。

  • value -- 此绑定参数的初始值。将在语句执行时用作传递给DBAPI的该参数的值,如果没有为该特定参数名的语句执行方法指示其他值。默认为 None .

  • callable_ -- 代替“value”的可调用函数。函数将在语句执行时调用以确定最终值。用于在创建子句构造时无法确定实际绑定值,但仍需要嵌入绑定值的情况。

  • type_ -- A TypeEngine 表示此的可选数据类型的类或实例 bindparam() . 如果没有传递,则可以根据给定的值自动确定绑定的类型;例如,简单的python类型,如 strintbool 可能导致 StringIntegerBoolean 正在自动选择类型。A的类型 bindparam() 特别重要的是,类型将在传递给数据库之前对值应用预处理。例如,A bindparam() 它引用日期时间值,并指定为保存 DateTime 类型,可以在将值传递到数据库之前将所需的转换应用于该值(如sqlite上的字符串化)。

  • unique -- 如果为真,则为 BindParameter 如果另一个 BindParameter 已在包含表达式中找到相同名称的。当生成所谓的"匿名"绑定表达式时,内部通常使用此标志,它一般不适用于显式命名的 bindparam() 构造。

  • required -- 如果 True ,执行时需要一个值。如果未通过,则默认为 True 如果既不 bindparam.valuebindparam.callable 通过了。如果这些参数中有一个存在,那么 bindparam.required 默认为 False .

  • quote -- 如果此参数名需要引用,并且当前不被称为sqlAlchemy保留字,则为true;此参数名当前仅适用于Oracle后端,其中绑定名有时必须被引用。

  • isoutparam -- 如果为true,则应将参数视为存储过程“out”参数。这适用于后端,如支持out参数的Oracle。

  • expanding -- 如果为true,则该参数在执行时将被视为一个“扩展”参数;参数值应为一个序列,而不是一个标量值,并且字符串SQL语句将在每次执行的基础上进行转换,以适应传递给DBAPI的参数槽数可变的序列。这是为了允许语句缓存与IN子句一起使用。…参阅: ColumnOperators.in_() 在表达式中使用 -有了不完整的查询..注意:“展开”功能不支持“ExecuteMany”样式的参数集。…版本已添加::1.2..versionChanged::1.3“扩展”绑定参数功能现在支持空列表。

sqlalchemy.sql.expression.case(whens, value=None, else_=None)

产生一个 CASE 表达式。

这个 CASE SQL中的构造是一个条件对象,其行为与其他语言中的“if/then”构造有些类似。它返回的实例 Case .

case() 在其通常的形式中,传递一个“when”构造列表,即条件和结果列表作为元组:

from sqlalchemy import case

stmt = select([users_table]).\
            where(
                case(
                    [
                        (users_table.c.name == 'wendy', 'W'),
                        (users_table.c.name == 'jack', 'J')
                    ],
                    else_='E'
                )
            )

上面的语句将生成类似以下内容的SQL:

SELECT id, name FROM user
WHERE CASE
    WHEN (name = :name_1) THEN :param_1
    WHEN (name = :name_2) THEN :param_2
    ELSE :param_3
END

当需要对单个父列使用多个值的简单相等表达式时, case() 还具有通过 case.value 参数,传递一个要比较的列表达式。在这种形式下, case.whens 参数作为字典传递,该字典包含要与键入结果表达式进行比较的表达式。下面的语句等价于前面的语句:

stmt = select([users_table]).\
            where(
                case(
                    {"wendy": "W", "jack": "J"},
                    value=users_table.c.name,
                    else_='E'
                )
            )

作为结果接受的值 case.whens 以及与 case.else_ 从python文本强制到 bindparam() 构造。SQL表达式,例如 ColumnElement 也接受构造。若要将文本字符串表达式强制为内联呈现的常量表达式,请使用 literal_column() 构造,如:

from sqlalchemy import case, literal_column

case(
    [
        (
            orderline.c.qty > 100,
            literal_column("'greaterthan100'")
        ),
        (
            orderline.c.qty > 10,
            literal_column("'greaterthan10'")
        )
    ],
    else_=literal_column("'lessthan10'")
)

上面将呈现给定的常量,而不使用结果值的绑定参数(但仍用于比较值),如:

CASE
    WHEN (orderline.qty > :qty_1) THEN 'greaterthan100'
    WHEN (orderline.qty > :qty_2) THEN 'greaterthan10'
    ELSE 'lessthan10'
END
参数
  • whens -- 要比较的标准, case.whens 根据是否接受两种不同的形式 case.value 使用。在第一种形式中,它接受2个元组的列表;每个2个元组由 (<sql expression>, <value>) ,其中SQL表达式是布尔表达式,“value”是结果值,例如::case( [ (users_table.c.name == 'wendy', 'W'), (users_table.c.name == 'jack', 'J') ] )在第二个表单中,它接受映射到结果值的比较值的python字典;此表单要求 case.value 并将使用 == 运算符,例如::case(“wendy”:“w”,“jack”:“j”,value=users_table.c.name)

  • value -- 一个可选的SQL表达式,将用作传递给的字典中候选值的固定“比较点”。 case.whens .

  • else_ -- 可选的SQL表达式,它将是 CASE 如果所有表达式都在 case.whens 评估为假。当省略时,如果“when”表达式中没有一个计算结果为true,则大多数数据库都将生成空结果。

sqlalchemy.sql.expression.cast(expression, type_)

产生一个 CAST 表达式。

cast() 返回的实例 Cast .

例如。::

from sqlalchemy import cast, Numeric

stmt = select([
            cast(product_table.c.unit_price, Numeric(10, 4))
        ])

上面的语句将生成类似以下内容的SQL:

SELECT CAST(unit_price AS NUMERIC(10, 4)) FROM product

这个 cast() 函数在使用时执行两个不同的函数。首先,它将 CAST 结果SQL字符串中的表达式。第二个问题是,它将给定类型(例如 TypeEngine 类或实例),这意味着表达式将采用与该类型关联的表达式运算符行为,以及该类型的绑定值处理和结果行处理行为。

在 0.9.0 版更改: cast() 现在,将给定的类型应用于表达式,使其对绑定值(例如,python to database方向)生效,此外,还有结果处理(例如,database to python方向)。

替代 cast()type_coerce() 功能。此函数执行将表达式与特定类型关联的第二个任务,但不呈现 CAST SQL中的表达式。

参数
  • expression -- SQL表达式,如 ColumnElement 表达式或python字符串,它将被强制为绑定的文本值。

  • type_ -- A TypeEngine 类或实例,指示 CAST 应适用。

参见

type_coerce() -python端类型强制,不发出cast。

sqlalchemy.sql.expression.column(text, type_=None, is_literal=False, _selectable=None)

产生一个 ColumnClause 对象。

这个 ColumnClause 是一个轻量级的模拟 Column 班级。这个 column() 只能使用名称调用函数,如:

from sqlalchemy import column

id, name = column("id"), column("name")
stmt = select([id, name]).select_from("user")

上面的语句将生成类似SQL的:

SELECT id, name FROM user

一旦建成, column() 可以像任何其他SQL表达式元素一样使用,例如 select() 结构:

from sqlalchemy.sql import column

id, name = column("id"), column("name")
stmt = select([id, name]).select_from("user")

文本由处理 column() 假定处理方式与数据库列的名称类似;如果字符串包含混合大小写、特殊字符或与目标后端上已知的保留字匹配,则列表达式将使用后端确定的引用行为进行呈现。要生成一个文本SQL表达式,该表达式完全没有任何引用,请使用 literal_column() 相反,或通过 True 作为价值 column.is_literal . 此外,最好使用 text() 构造。

column() 通过将其与 table() 功能(轻量级模拟 Table )使用最小样板生成工作台结构:

from sqlalchemy import table, column, select

user = table("user",
        column("id"),
        column("name"),
        column("description"),
)

stmt = select([user.c.description]).where(user.c.name == 'wendy')

A column() / table() 像上面描述的那样的构造可以以一种特别的方式创建,并且不与任何 schema.MetaData ,ddl或事件,与 Table 对应的。

在 1.0.0 版更改: expression.column() 现在可以从平原进口了 sqlalchemy 与任何其他SQL元素一样。

参数
sqlalchemy.sql.expression.collate(expression, collation)

退回条款 expression COLLATE collation .

例如。::

collate(mycolumn, 'utf8_bin')

生产::

mycolumn COLLATE utf8_bin

如果排序规则表达式是区分大小写的标识符,例如包含大写字符,则也会对其进行引用。

在 1.2 版更改: 如果表达式区分大小写,则自动应用引用对其进行排序。

sqlalchemy.sql.expression.desc(column)

生成降序 ORDER BY 子句元素。

例如。::

from sqlalchemy import desc

stmt = select([users_table]).order_by(desc(users_table.c.name))

将生成以下SQL::

SELECT id, name FROM user ORDER BY name DESC

这个 desc() 函数是 ColumnElement.desc() 方法可用于所有SQL表达式,例如:

stmt = select([users_table]).order_by(users_table.c.name.desc())
参数

column -- A ColumnElement (例如,标量SQL表达式)用于应用 desc() 操作。

sqlalchemy.sql.expression.distinct(expr)

生成列表达式级别一元 DISTINCT 条款。

这适用于 DISTINCT 关键字到单个列表达式,通常包含在聚合函数中,如::

from sqlalchemy import distinct, func
stmt = select([func.count(distinct(users_table.c.name))])

上面的表达式类似于:

SELECT COUNT(DISTINCT name) FROM user

这个 distinct() 函数也可用作列级方法,例如 ColumnElement.distinct() ,如:

stmt = select([func.count(users_table.c.name.distinct())])

这个 distinct() 操作符不同于 Select.distinct() 方法 Select ,它产生一个 SELECT 语句与 DISTINCT 应用于整个结果集,例如 SELECT DISTINCT 表达式。有关更多信息,请参阅该方法。

sqlalchemy.sql.expression.extract(field, expr, **kwargs)

返回A Extract 构造。

这通常可用作 extract() 以及 func.extractfunc 命名空间。

sqlalchemy.sql.expression.false()

返回A False_ 构造。

例如。::

>>> from sqlalchemy import false
>>> print select([t.c.x]).where(false())
SELECT x FROM t WHERE false

不支持真/假常量的后端将呈现为针对1或0的表达式::

>>> print select([t.c.x]).where(false())
SELECT x FROM t WHERE 0 = 1

这个 true()false() 常量还具有在 and_()or_() 连词:

>>> print select([t.c.x]).where(or_(t.c.x > 5, true()))
SELECT x FROM t WHERE true

>>> print select([t.c.x]).where(and_(t.c.x > 5, false()))
SELECT x FROM t WHERE false

在 0.9 版更改: true()false() 在连词和不支持真/假常量的方言中具有更好的整合行为。

参见

true()

sqlalchemy.sql.expression.func = <sqlalchemy.sql.functions._FunctionGenerator object>

生成 Function 基于GetAttr调用的对象。

sqlalchemy.sql.expression.funcfilter(func, *criterion)

产生一个 FunctionFilter 对象对函数。

用于聚合函数和窗口函数,用于支持“filter”子句的数据库后端。

例如。::

from sqlalchemy import funcfilter
funcfilter(func.count(1), MyClass.name == 'some name')

将生成“count(1)filter(其中myclass.name='some name')”。

此功能也可从 func 通过 FunctionElement.filter() 方法。

1.0.0 新版功能.

sqlalchemy.sql.expression.label(name, element, type_=None)

返回A Label 给定对象 ColumnElement .

标签更改了的columns子句中元素的名称。 SELECT 语句,通常通过 AS SQL关键字。

此功能通过 ColumnElement.label() 方法对 ColumnElement .

参数
sqlalchemy.sql.expression.literal(value, type_=None)

返回绑定到绑定参数的literal子句。

当非- ClauseElement 对象(如字符串、int、日期等)用于与 ColumnElement 子类,例如 Column 对象。使用此函数强制生成文本子句,该子句将创建为 BindParameter 具有绑定值。

参数
  • value -- 要绑定的值。可以是底层db-api支持的任何python对象,也可以通过给定的类型参数进行转换。

  • type_ -- 可选的 TypeEngine 它将为此文本提供绑定参数转换。

sqlalchemy.sql.expression.literal_column(text, type_=None)

产生一个 ColumnClause 对象具有 column.is_literal 标志设置为真。

literal_column() 类似于 column() ,但它更常被用作“独立”列表达式,该表达式完全按照说明呈现;而 column() 存储一个字符串名称,该名称将被假定为表的一部分,并可以这样引用, literal_column() 可以是该表达式,也可以是任何其他面向列的任意表达式。

参数
  • text -- 表达式的文本;可以是任何SQL表达式。不适用报价规则。要指定应遵循引用规则的列名表达式,请使用 column() 功能。

  • type_ -- 可选的 TypeEngine 对象,它将为此列提供结果集转换和附加表达式语义。如果保留为“无”,则类型将为空类型。

sqlalchemy.sql.expression.not_(clause)

返回给定子句的否定,即 NOT(clause) .

这个 ~ 操作符也在所有 ColumnElement 子类产生相同的结果。

sqlalchemy.sql.expression.null()

返回常量 Null 构造。

sqlalchemy.sql.expression.nullsfirst(column)

生产 NULLS FIRST AN的修饰符 ORDER BY 表达式。

nullsfirst() 用于修改 asc()desc() ,并指示在排序期间遇到空值时应如何处理它们::

from sqlalchemy import desc, nullsfirst

stmt = select([users_table]).                        order_by(nullsfirst(desc(users_table.c.name)))

上面的SQL表达式类似于:

SELECT id, name FROM user ORDER BY name DESC NULLS FIRST

喜欢 asc()desc()nullsfirst() 通常从列表达式本身调用,使用 ColumnElement.nullsfirst() 而不是作为它的独立函数版本,如:

stmt = (select([users_table]).
        order_by(users_table.c.name.desc().nullsfirst())
        )
sqlalchemy.sql.expression.nullslast(column)

生产 NULLS LAST AN的修饰符 ORDER BY 表达式。

nullslast() 用于修改 asc()desc() ,并指示在排序期间遇到空值时应如何处理它们::

from sqlalchemy import desc, nullslast

stmt = select([users_table]).                        order_by(nullslast(desc(users_table.c.name)))

上面的SQL表达式类似于:

SELECT id, name FROM user ORDER BY name DESC NULLS LAST

喜欢 asc()desc()nullslast() 通常从列表达式本身调用,使用 ColumnElement.nullslast() 而不是作为它的独立函数版本,如:

stmt = select([users_table]).                        order_by(users_table.c.name.desc().nullslast())
sqlalchemy.sql.expression.or_(*clauses)

生成由以下对象连接的表达式的连接 OR .

例如。::

from sqlalchemy import or_

stmt = select([users_table]).where(
                or_(
                    users_table.c.name == 'wendy',
                    users_table.c.name == 'jack'
                )
            )

这个 or_() 也可以使用python | 运算符(不过请注意,复合表达式需要加括号才能使用python运算符优先行为运行)::

stmt = select([users_table]).where(
                (users_table.c.name == 'wendy') |
                (users_table.c.name == 'jack')
            )

参见

and_()

sqlalchemy.sql.expression.outparam(key, type_=None)

为支持函数(存储过程)的数据库创建用于函数(存储过程)的“out”参数。

这个 outparam 可用作常规函数参数。“输出”值可从 ResultProxy 对象通过其 out_parameters 属性,返回包含值的字典。

sqlalchemy.sql.expression.over(element, partition_by=None, order_by=None, range_=None, rows=None)

产生一个 Over 对象对函数。

用于聚合或所谓的“窗口”函数,用于支持窗口函数的数据库后端。

over() 通常使用 FunctionElement.over() 方法,例如:

func.row_number().over(order_by=mytable.c.some_column)

将产生:

ROW_NUMBER() OVER(ORDER BY some_column)

也可以使用 expression.over.range_expression.over.rows 参数。这些互斥参数都接受一个2元组,其中包含整数和无的组合:

func.row_number().over(
    order_by=my_table.c.some_column, range_=(None, 0))

以上内容将产生:

ROW_NUMBER() OVER(ORDER BY some_column
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)

无表示“无边界”,零表示“当前行”,负/正整数表示“前”和“后”:

  • 前5个和后10个之间的范围:

    func.row_number().over(order_by='x', range_=(-5, 10))
  • 前一行和当前行之间无边界的行::

    func.row_number().over(order_by='x', rows=(None, 0))
  • 前两个和后两个之间的范围::

    func.row_number().over(order_by='x', range_=(-2, None))
  • 以下1项到以下3项之间的范围:

    func.row_number().over(order_by='x', range_=(1, 3))

1.1 新版功能: 支持窗口中的范围/行

参数
  • element -- 一 FunctionElementWithinGroup 或其他兼容结构。

  • partition_by -- 一个列元素或字符串,或这样的列表,将用作over构造的partition by子句。

  • order_by -- 将用作over构造的order by子句的列元素或字符串或此类元素的列表。

  • range_ -- 窗口的可选范围子句。这是一个tuple值,可以包含整数值,也可以不包含整数值,并将呈现一个介于前/后子句之间的范围。添加的版本:1.1

  • rows -- 窗口的可选行子句。这是一个tuple值,可以包含整数值,也可以不包含整数值,并且将在前面/后面的子句之间呈现一行。…添加的版本:1.1

此功能也可从 func 通过 FunctionElement.over() 方法。

sqlalchemy.sql.expression.text(text, bind=None, bindparams=None, typemap=None, autocommit=None)

构建新的 TextClause 子句,直接表示文本SQL字符串。

例如。::

from sqlalchemy import text

t = text("SELECT * FROM users")
result = connection.execute(t)

优势 text() 在普通字符串上提供对绑定参数、每语句执行选项以及绑定参数和结果列类型行为的后端中性支持,允许在执行逐字指定的语句时,sqlAlchemy类型构造发挥作用。构造还可以提供 .c 列元素的集合,允许它作为子查询嵌入到其他SQL表达式构造中。

绑定参数由名称指定,格式为 :name . 例如。::

t = text("SELECT * FROM users WHERE id=:user_id")
result = connection.execute(t, user_id=12)

对于需要逐字冒号的SQL语句(如在内联字符串中),请使用反斜杠转义::

t = text("SELECT * FROM users WHERE name='\:username'")

这个 TextClause construct包含一些方法,这些方法可以提供有关绑定参数的信息,以及假设它是可执行的select类型语句,则从文本语句返回的列值。这个 TextClause.bindparams() 方法用于提供绑定参数详细信息,以及 TextClause.columns() 方法允许指定返回列,包括名称和类型:

t = text("SELECT * FROM users WHERE id=:user_id").\
        bindparams(user_id=7).\
        columns(id=Integer, name=String)

for id, name in connection.execute(t):
    print(id, name)

这个 text() 构造用于将文本字符串SQL片段指定为较大查询的一部分时,例如对于select语句的where子句:

s = select([users.c.id, users.c.name]).where(text("id=:user_id"))
result = connection.execute(s, user_id=12)

text() 也用于使用纯文本构造完整、独立的语句。因此,sqlAlchemy将其称为 Executable 对象,它支持 Executable.execution_options() 方法。例如,A text() 应服从“autocommit”的构造可以显式设置,以便使用 Connection.execution_options.autocommit 选项:

t = text("EXEC my_procedural_thing()").\
        execution_options(autocommit=True)

请注意,SQLAlchemy通常的“自动提交”行为适用于 text() 隐式构造-即以短语开头的语句,如 INSERTUPDATEDELETE 或者特定于某些后端的各种其他短语,如果没有正在进行的事务,则可以自动提交。

参数
  • text -- 要创建的SQL语句的文本。使用 :<param> 指定绑定参数;它们将被编译为特定于引擎的格式。…警告:: text.text 参数 text() 可以作为python字符串参数传递,该参数将被视为 可信SQL文本 并按规定呈现。 不要将不受信任的输入传递给此参数 .

  • autocommit -- 是否为此设置“自动提交”执行选项 TextClause 对象。…已弃用::0.6 text.autocommit 参数已弃用,将在将来的版本中删除。请使用 Connection.execution_options.autocommit 参数与 Executable.execution_options() 方法。

  • bind -- 用于此文本查询的可选连接或引擎。

  • bindparams -- 列表 bindparam() 用于提供有关语句中嵌入的参数的信息的实例。…已弃用::0.9 text.bindparams 参数已弃用,将在将来的版本中删除。请参阅 TextClause.bindparams() 方法。例如:stmt=text(“select*from table where id=:id”,bindparams= [bindparam('id', value=5, type_=Integer)] )

  • typemap -- 一种字典,它映射在 SELECT 语句以键入对象。…已弃用::0.9 text.typemap 参数已弃用,将在将来的版本中删除。请参阅 TextClause.columns() 方法。例如:stmt=text(“select*from table”,typemap=id':integer,'name':string,)

参见

使用文本SQL -在核心教程中

使用文本SQL -在ORM教程中

sqlalchemy.sql.expression.true()

返回常量 True_ 构造。

例如。::

>>> from sqlalchemy import true
>>> print select([t.c.x]).where(true())
SELECT x FROM t WHERE true

不支持真/假常量的后端将呈现为针对1或0的表达式::

>>> print select([t.c.x]).where(true())
SELECT x FROM t WHERE 1 = 1

这个 true()false() 常量还具有在 and_()or_() 连词:

>>> print select([t.c.x]).where(or_(t.c.x > 5, true()))
SELECT x FROM t WHERE true

>>> print select([t.c.x]).where(and_(t.c.x > 5, false()))
SELECT x FROM t WHERE false

在 0.9 版更改: true()false() 在连词和不支持真/假常量的方言中具有更好的整合行为。

参见

false()

sqlalchemy.sql.expression.tuple_(*clauses, **kw)

返回A Tuple .

主要用途是在构造中生成复合:

from sqlalchemy import tuple_

tuple_(table.c.col1, table.c.col2).in_(
    [(1, 2), (5, 12), (10, 19)]
)

警告

构造中的composite不受所有后端的支持,目前已知它可用于PostgreSQL和MySQL,但不用于sqlite。不支持的后端将引发的子类 DBAPIError 当调用这样的表达式时。

sqlalchemy.sql.expression.type_coerce(expression, type_)

将SQL表达式与特定类型关联,而不呈现 CAST .

例如。::

from sqlalchemy import type_coerce

stmt = select([
    type_coerce(log_table.date_string, StringDateTime())
])

上述结构将产生 TypeCoerce 对象,该对象呈现标记表达式的SQL,但不修改其在SQL端的值:

SELECT date_string AS anon_1 FROM log

当提取结果行时, StringDateTime 类型将代表应用于结果行 date_string 列。“anon_1”标签的基本原理是,强制类型列在结果列列表中与目标列的其他类型强制或直接值保持独立。要为表达式提供命名标签,请使用 ColumnElement.label() ::

stmt = select([
    type_coerce(
        log_table.date_string, StringDateTime()).label('date')
])

具有绑定值处理功能的类型在文本值或 bindparam() 结构传递给 type_coerce() 作为目标。例如,如果类型实现 TypeEngine.bind_expression() 方法或 TypeEngine.bind_processor() 方法或等效方法,当传递文本值时,这些函数将在语句编译/执行时生效,如::

# bound-value handling of MyStringType will be applied to the
# literal value "some string"
stmt = select([type_coerce("some string", MyStringType)])

type_coerce() 类似于 cast() 函数,但它不呈现 CAST 结果语句中的表达式。

参数
  • expression -- SQL表达式,如 ColumnElement 表达式或python字符串,它将被强制为绑定的文本值。

  • type_ -- A TypeEngine 指示强制表达式的类型的类或实例。

参见

cast()

sqlalchemy.sql.expression.within_group(element, *order_by)

产生一个 WithinGroup 对象对函数。

用于所谓的“有序集聚合”和“假设集聚合”函数,包括 percentile_contrankdense_rank 等。

within_group() 通常使用 FunctionElement.within_group() 方法,例如:

from sqlalchemy import within_group
stmt = select([
    department.c.id,
    func.percentile_cont(0.5).within_group(
        department.c.salary.desc()
    )
])

上面的语句将生成类似于 SELECT department.id, percentile_cont(0.5) WITHIN GROUP (ORDER BY department.salary DESC) .

参数
  • element -- 一 FunctionElement 构造,通常由 func .

  • *order_by -- 将用作内部组构造的ORDER BY子句的一个或多个列元素。

1.1 新版功能.

class sqlalchemy.sql.expression.BinaryExpression(left, right, operator, type_=None, negate=None, modifiers=None)

基地: sqlalchemy.sql.expression.ColumnElement

表示一个表达式 LEFT <operator> RIGHT .

A BinaryExpression 每当在python二进制表达式中使用两个列表达式时自动生成:

>>> from sqlalchemy.sql import column
>>> column('a') + column('b')
<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>
>>> print column('a') + column('b')
a + b
compare(other, **kw)

比较一下 BinaryExpression 对给定的 BinaryExpression .

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

self_group(against=None)

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select() 当放入另一个的FROM子句时构造 select() . (请注意,通常应使用 Select.alias() 方法,因为许多平台都需要命名嵌套的select语句)。

当表达式组合在一起时,应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。

class sqlalchemy.sql.expression.BindParameter(key, value=symbol('NO_ARG'), type_=None, unique=False, required=symbol('NO_ARG'), quote=None, callable_=None, expanding=False, isoutparam=False, _compared_to_operator=None, _compared_to_type=None)

基地: sqlalchemy.sql.expression.ColumnElement

表示“绑定表达式”。

BindParameter 是使用 bindparam() 功能,如:

from sqlalchemy import bindparam

stmt = select([users_table]).\
            where(users_table.c.name == bindparam('username'))

详细讨论如何 BindParameter 使用的是 bindparam() .

参见

bindparam()

__init__(key, value=symbol('NO_ARG'), type_=None, unique=False, required=symbol('NO_ARG'), quote=None, callable_=None, expanding=False, isoutparam=False, _compared_to_operator=None, _compared_to_type=None)

构建新的 BindParameter 对象。

此构造函数被镜像为公共API函数;请参见 bindparam() 完整的用法和参数描述。

compare(other, **kw)

比较一下 BindParameter 对给定的条款。

effective_value

返回此绑定参数的值,并考虑 callable 参数已设置。

这个 callable 值将被评估并返回(如果存在),否则 value .

class sqlalchemy.sql.expression.Case(whens, value=None, else_=None)

基地: sqlalchemy.sql.expression.ColumnElement

代表一个 CASE 表达式。

Case 是使用 case() 工厂功能,如:

from sqlalchemy import case

stmt = select([users_table]).                    where(
                case(
                    [
                        (users_table.c.name == 'wendy', 'W'),
                        (users_table.c.name == 'jack', 'J')
                    ],
                    else_='E'
                )
            )

细节 Case 用法是 case() .

参见

case()

__init__(whens, value=None, else_=None)

构建新的 Case 对象。

此构造函数被镜像为公共API函数;请参见 case() 完整的用法和参数描述。

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

class sqlalchemy.sql.expression.Cast(expression, type_)

基地: sqlalchemy.sql.expression.ColumnElement

代表一个 CAST 表达式。

Cast 是使用 cast() 工厂功能,如:

from sqlalchemy import cast, Numeric

stmt = select([
            cast(product_table.c.unit_price, Numeric(10, 4))
        ])

细节 Cast 用法是 cast() .

参见

cast()

__init__(expression, type_)

构建新的 Cast 对象。

此构造函数被镜像为公共API函数;请参见 cast() 完整的用法和参数描述。

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

class sqlalchemy.sql.expression.ClauseElement

基地: sqlalchemy.sql.visitors.Visitable

以编程方式构造的SQL表达式的元素的基类。

compare(other, **kw)

将这一条款与给定的条款进行比较。

子类应该覆盖默认行为,这是一个直接的身份比较。

* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement

compile(default, bind=None, dialect=None, **kw)

编译此SQL表达式。

返回值为 Compiled 对象。调用 str()unicode() 返回的值将生成结果的字符串表示形式。这个 Compiled 对象还可以返回绑定参数名称和值的字典,方法是 params 访问器。

参数
  • bind -- 安 EngineConnection 从哪一个 Compiled 将被收购。此参数优先于此 ClauseElement 如果有绑定的引擎。

  • column_keys -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None ,将呈现目标表对象中的所有列。

  • dialect -- A Dialect 实例,其中 Compiled 将被收购。此参数优先于 bind 还有这个论点 ClauseElement 如果有绑定的引擎。

  • inline -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .

  • compile_kwargs -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds 通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

params(*optionaldict, **kwargs)

返回副本 bindparam() 元素被替换。

返回此条款的副本 bindparam() 用给定字典中的值替换的元素::

>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
self_group(against=None)

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select() 当放入另一个的FROM子句时构造 select() . (请注意,通常应使用 Select.alias() 方法,因为许多平台都需要命名嵌套的select语句)。

当表达式组合在一起时,应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。

unique_params(*optionaldict, **kwargs)

返回副本 bindparam() 元素被替换。

功能与 params() ,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。

class sqlalchemy.sql.expression.ClauseList(*clauses, **kwargs)

基地: sqlalchemy.sql.expression.ClauseElement

描述由运算符分隔的子句列表。

默认情况下,是逗号分隔的,例如列列表。

compare(other, **kw)

比较一下 ClauseList 到给定的 ClauseList 包括所有子句项的比较。

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

self_group(against=None)

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select() 当放入另一个的FROM子句时构造 select() . (请注意,通常应使用 Select.alias() 方法,因为许多平台都需要命名嵌套的select语句)。

当表达式组合在一起时,应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。

class sqlalchemy.sql.expression.ColumnClause(text, type_=None, is_literal=False, _selectable=None)

基地: sqlalchemy.sql.expression.Immutablesqlalchemy.sql.expression.ColumnElement

表示任何文本字符串中的列表达式。

这个 ColumnClause 一个轻量级的模拟 Column 类,通常使用 column() 功能,如:

from sqlalchemy import column

id, name = column("id"), column("name")
stmt = select([id, name]).select_from("user")

上面的语句将生成类似SQL的:

SELECT id, name FROM user

ColumnClause 是模式特定的直接超类 Column 对象。而 Column 类具有与 ColumnClause , the ColumnClause 在行为需求仅限于简单的SQL表达式生成的情况下,类本身是可用的。对象没有与架构级元数据或执行时间行为的关联 Column 是的,所以在这个意义上是 Column .

详情 ColumnClause 用法是 column() .

参见

column()

Column

__init__(text, type_=None, is_literal=False, _selectable=None)

构建新的 ColumnClause 对象。

此构造函数被镜像为公共API函数;请参见 column() 完整的用法和参数描述。

class sqlalchemy.sql.expression.ColumnCollection(*columns)

基地: sqlalchemy.util._collections.OrderedProperties

存储ColumnElement实例列表的有序字典。

重写 __eq__() 方法在相关列集之间生成SQL子句。

add(column)

向此集合添加列。

列的键属性将用作此字典的哈希键。

as_immutable()

为此返回不可变的代理 Properties .

replace(column)

将给定列添加到此集合中,删除此列的未关联版本以及具有相同键的现有列。

例如。::

t = Table('sometable', metadata, Column('col1', Integer))
t.columns.replace(Column('col1', Integer, key='columnone'))

将从集合中移除原始“col1”,并在“column name”名称下添加新列。

由schema.column用于在表反射期间重写列。

class sqlalchemy.sql.expression.ColumnElement

基地: sqlalchemy.sql.operators.ColumnOperatorssqlalchemy.sql.expression.ClauseElement

表示一个面向列的SQL表达式,适用于语句的“columns”子句、where子句等。

而最熟悉的那种 ColumnElementColumn 对象, ColumnElement 用作SQL表达式中可能存在的任何单元的基础,包括表达式本身、SQL函数、绑定参数、文本表达式、关键字,例如 NULL 等。 ColumnElement 是所有这些元素的最终基类。

各种各样的SQLAlchemy核心函数在SQL表达式级别上工作,并打算接受 ColumnElement 作为争论。这些函数通常会记录它们接受“SQL表达式”作为参数。这在SQLAlchemy中意味着什么,通常指的是一个已经以 ColumnElement 对象,或可以是 强制的 成一体。与SQL表达式相关的大多数(而不是全部)sqlAlchemy核心函数所遵循的强制规则如下:

  • python文本值,如字符串、整数或浮点值、布尔值、日期时间, Decimal 对象,或者几乎任何其他的python对象,将被强制为“文本绑定值”。这通常意味着 bindparam() 将生成具有嵌入到构造中的给定值的;结果 BindParameter 对象是的实例 ColumnElement . python值最终将在执行时作为参数化参数发送给dbapi execute()executemany() 方法,在SQLAlchemy类型特定的转换器之后(例如由任何关联的 TypeEngine 对象)应用于该值。

  • 任何特殊的对象值,通常是ORM级构造,其特征是 __clause_element__() . 当将其他未知类型的对象传递给要将参数强制为 ColumnElement 表达式。这个 __clause_element__() 方法(如果存在)应返回 ColumnElement 实例。主要用途 __clause_element__() 在sqlAlchemy中,是ORM映射类上的类绑定属性;a User 类,该类包含名为 .name 会有一个方法 User.name.__clause_element__() 调用时返回 Column 调用 name 与映射表关联。

  • Python None 值通常解释为 NULL ,它在SQLAlchemy core中生成 null() .

A ColumnElement 提供生成新的 ColumnElement 使用python表达式的对象。这意味着python操作符,例如 ==!=< 重载以模拟SQL操作,并允许进一步实例化 ColumnElement 由其他更基本的实例组成的实例 ColumnElement 对象。例如,两个 ColumnClause 对象可以与加法运算符一起添加 + 产生一个 BinaryExpression .两者都是 ColumnClauseBinaryExpression 是的子类 ColumnElement ::

>>> from sqlalchemy.sql import column
>>> column('a') + column('b')
<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>
>>> print column('a') + column('b')
a + b
__eq__(other)

继承 __eq__() 方法 ColumnOperators

实施 == 操作符。

在列上下文中,生成子句 a = b . 如果目标是 None 生产 a IS NULL .

__init__

继承 __init__ 属性 object

初始化自身。请参阅帮助(键入(self))以获得准确的签名。

__le__(other)

继承 __le__() 方法 ColumnOperators

实施 <= 操作符。

在列上下文中,生成子句 a <= b .

__lt__(other)

继承 __lt__() 方法 ColumnOperators

实施 < 操作符。

在列上下文中,生成子句 a < b .

__ne__(other)

继承 __ne__() 方法 ColumnOperators

实施 != 操作符。

在列上下文中,生成子句 a != b . 如果目标是 None 生产 a IS NOT NULL .

all_()

继承 all_() 方法 ColumnOperators

产生一个 all_() 针对父对象的子句。

此运算符仅适用于标量子查询对象,或某些后端的列表达式适用于数组类型,例如::

# postgresql '5 = ALL (somearray)'
expr = 5 == mytable.c.somearray.all_()

# mysql '5 = ALL (SELECT value FROM table)'
expr = 5 == select([table.c.value]).as_scalar().all_()

参见

all_() -独立版本

any_() -任何操作符

1.1 新版功能.

anon_label

为此ColumnElement提供常量“匿名标签”。

这是一个label()表达式,将在编译时命名。每次调用anon_标签时都返回相同的label(),这样表达式可以多次引用anon_标签,从而在编译时生成相同的标签名称。

编译器在编译时自动将此函数用于已知为“未命名”的表达式,如二进制表达式和函数调用。

any_()

继承 any_() 方法 ColumnOperators

产生一个 any_() 针对父对象的子句。

此运算符仅适用于标量子查询对象,或某些后端的列表达式适用于数组类型,例如::

# postgresql '5 = ANY (somearray)'
expr = 5 == mytable.c.somearray.any_()

# mysql '5 = ANY (SELECT value FROM table)'
expr = 5 == select([table.c.value]).as_scalar().any_()

参见

any_() -独立版本

all_() -所有操作符

1.1 新版功能.

asc()

继承 asc() 方法 ColumnOperators

产生一个 asc() 针对父对象的子句。

base_columns
between(cleft, cright, symmetric=False)

继承 between() 方法 ColumnOperators

产生一个 between() 在给定上下限的情况下,针对父对象的子句。

bind = None
bool_op(opstring, precedence=0)

继承 bool_op() 方法 Operators

返回自定义布尔运算符。

这个方法是调用 Operators.op() 并通过 Operators.op.is_comparison 标记为真。

1.2.0b3 新版功能.

cast(type_)

生成类型转换,即 CAST(<expression> AS <type>) .

这是到 cast() 功能。

1.0.7 新版功能.

collate(collation)

继承 collate() 方法 ColumnOperators

产生一个 collate() 在给定排序规则字符串的情况下,对父对象执行子句。

参见

collate()

comparator
compare(other, use_proxies=False, equivalents=None, **kw)

将此ColumnElement与其他ColumnElement进行比较。

理解特殊论点:

参数
  • use_proxies -- 如果为true,则将共享公共基列的两列视为等效列(即shares_沿袭())

  • equivalents -- 作为映射到列集的键的列字典。如果给定的“其他”列出现在本字典中,则如果相应集合()中的任何列通过比较测试,则结果为真。这用于通过外键或其他条件将比较扩展到其他已知与此列等效的列。

compile(default, bind=None, dialect=None, **kw)

继承 compile() 方法 ClauseElement

编译此SQL表达式。

返回值为 Compiled 对象。调用 str()unicode() 返回的值将生成结果的字符串表示形式。这个 Compiled 对象还可以返回绑定参数名称和值的字典,方法是 params 访问器。

参数
  • bind -- 安 EngineConnection 从哪一个 Compiled 将被收购。此参数优先于此 ClauseElement 如果有绑定的引擎。

  • column_keys -- 用于insert和update语句,列名称的列表,应出现在编译语句的values子句中。如果 None ,将呈现目标表对象中的所有列。

  • dialect -- A Dialect 实例,其中 Compiled 将被收购。此参数优先于 bind 还有这个论点 ClauseElement 如果有绑定的引擎。

  • inline -- 用于insert语句,对于不支持对新生成的主键列进行内联检索的方言,将强制用于创建新主键值的表达式在insert语句的value s子句中进行内联呈现。这通常指序列执行,但也可能指与主键关联的任何服务器端默认生成函数。 Column .

  • compile_kwargs -- 在所有“访问”方法中传递给编译器的附加参数的可选字典。例如,这允许将任何自定义标志传递给自定义编译构造。它还用于通过 literal_binds 通过::从sqlachemy.sql导入表、列,选择t=table('t',column('x'))s=select( [t] .where(t.c.x==5)print s.compile(compile“literal_binds”:true)。添加的版本:0.9.0

concat(other)

继承 concat() 方法 ColumnOperators

实现“concat”运算符。

在列上下文中,生成子句 a || b 或使用 concat() mysql上的操作符。

contains(other, **kwargs)

继承 contains() 方法 ColumnOperators

实现“contains”运算符。

生成一个类似表达式,该表达式根据字符串值中间的匹配项进行测试:

column LIKE '%' || <other> || '%'

例如。::

stmt = select([sometable]).\
    where(sometable.c.column.contains("foobar"))

因为操作符使用 LIKE ,通配符 "%""_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值, ColumnOperators.contains.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符,以便它们与自身匹配,而不是作为通配符匹配。或者, ColumnOperators.contains.escape 参数将建立一个给定字符作为转义字符,当目标表达式不是文本字符串时可以使用该字符。

参数
  • other -- 要比较的表达式。这通常是一个纯字符串值,但也可以是任意的SQL表达式。类似通配符 %_ 默认情况下不转义,除非 ColumnOperators.contains.autoescape 标志设置为真。

  • autoescape -- 布尔值;如果为true,则在like表达式中建立转义符,然后将其应用于 "%""_" 以及转义符本身在比较值中,该值被假定为文本字符串而不是SQL表达式。表达式如::somecolumn.contains(“foo%bar”,autoescape=true)将呈现为::somecolumn,如“%”。|| :param || '%' ESCAPE '/' With the value of :param as "foo/%bar". .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The ColumnOperators.contains.autoescape 参数现在是一个简单的布尔值而不是一个字符;转义字符本身也被转义,并默认为正斜杠,可以使用 ColumnOperators.contains.escape 参数。

  • escape -- 一个字符,当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 %_ 允许它们充当自己而不是通配符。表达式如::somecolumn.contains(“foo/%bar”,escape=“^”)将呈现为::somecolumn,如“%”。|| :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.contains.autoescape ::someColumn.contains(“foo%bar^bat”,escape=“^”,autoescape=true),其中,给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

desc()

继承 desc() 方法 ColumnOperators

产生一个 desc() 针对父对象的子句。

description = None
distinct()

继承 distinct() 方法 ColumnOperators

产生一个 distinct() 针对父对象的子句。

endswith(other, **kwargs)

继承 endswith() 方法 ColumnOperators

实现“endswith”运算符。

生成一个类似表达式,该表达式根据字符串值末尾的匹配项进行测试:

column LIKE '%' || <other>

例如。::

stmt = select([sometable]).\
    where(sometable.c.column.endswith("foobar"))

因为操作符使用 LIKE ,通配符 "%""_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值, ColumnOperators.endswith.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符,以便它们与自身匹配,而不是作为通配符匹配。或者, ColumnOperators.endswith.escape 参数将建立一个给定字符作为转义字符,当目标表达式不是文本字符串时可以使用该字符。

参数
  • other -- 要比较的表达式。这通常是一个纯字符串值,但也可以是任意的SQL表达式。类似通配符 %_ 默认情况下不转义,除非 ColumnOperators.endswith.autoescape 标志设置为真。

  • autoescape -- 布尔值;如果为true,则在like表达式中建立转义符,然后将其应用于 "%""_" 以及转义符本身在比较值中,该值被假定为文本字符串而不是SQL表达式。表达式如::somecolumn.endswith(“foo%bar”,autoescape=true)将呈现为::somecolumn,如“%”。|| :param ESCAPE '/' With the value of :param as "foo/%bar". .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The ColumnOperators.endswith.autoescape 参数现在是一个简单的布尔值而不是一个字符;转义字符本身也被转义,并默认为正斜杠,可以使用 ColumnOperators.endswith.escape 参数。

  • escape -- 一个字符,当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 %_ 允许它们充当自己而不是通配符。表达式如::somecolumn.endswith(“foo/%bar”,escape=“^”)将呈现为::somecolumn,如“%”。|| :param ESCAPE '^' The parameter may also be combined with ColumnOperators.endswith.autoescape ::someColumn.endsWith(“foo%bar^bat”,escape=“^”,autoescape=true),其中,给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

expression

返回列表达式。

检查界面的一部分;返回自身。

foreign_keys = []
get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

ilike(other, escape=None)

继承 ilike() 方法 ColumnOperators

实施 ilike 运算符,例如不区分大小写的like。

在列上下文中,生成以下任一形式的表达式:

lower(a) LIKE lower(other)

或者在支持ilike运算符的后端:

a ILIKE other

例如。::

stmt = select([sometable]).\
    where(sometable.c.column.ilike("%foobar%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.ilike(“foo/%bar”,escape=“/”)

in_(other)

继承 in_() 方法 ColumnOperators

实施 in 操作符。

在列上下文中,生成子句 column IN <other> .

给定参数 other 可能是:

  • 文字值列表,例如:

    stmt.where(column.in_([1, 2, 3]))

    在此调用表单中,项目列表将转换为一组与给定列表长度相同的绑定参数:

    WHERE COL IN (?, ?, ?)
  • 空列表,例如:

    stmt.where(column.in_([]))

    在此调用形式中,表达式呈现“false”表达式,例如:

    WHERE 1 != 1

    这个“假”表达式在旧的sqlAlchemy版本中历史上有不同的行为,请参见 create_engine.empty_in_strategy 对于行为选项。

    在 1.2 版更改: 简化了“空入”表达式的行为

  • 绑定参数,例如 bindparam() ,如果包含 bindparam.expanding 标志:

    stmt.where(column.in_(bindparam('value', expanding=True)))

    在此调用表单中,表达式呈现一个特殊的非SQL占位符表达式,其外观如下:

    WHERE COL IN ([EXPANDING_value])

    此占位符表达式在语句执行时被截取,以便转换为前面所示的绑定参数表单的变量号。如果语句的执行方式为:

    connection.execute(stmt, {"value": [1, 2, 3]})

    将为数据库传递每个值的绑定参数:

    WHERE COL IN (?, ?, ?)

    1.2 新版功能: 添加了“扩展”绑定参数

    如果传递空列表,将呈现一个特定于正在使用的数据库的特殊“空列表”表达式。在sqlite上:

    WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

    1.3 新版功能: “expanding”绑定参数现在支持空列表

  • select() 构造,通常是相关的标量选择:

    stmt.where(
        column.in_(
            select([othertable.c.y]).
            where(table.c.x == othertable.c.x)
        )
    )

    在这个调用表单中, ColumnOperators.in_() 按给定呈现:

    WHERE COL IN (SELECT othertable.y
    FROM othertable WHERE othertable.x = table.x)
参数

other -- 文字列表,a select() 构造,或 bindparam() 构造,包括 bindparam.expanding 标志设置为真。

is_(other)

继承 is_() 方法 ColumnOperators

实施 IS 操作符。

通常情况下, IS 与以下值比较时自动生成 None ,决定 NULL . 但是,明确使用 IS 如果与某些平台上的布尔值进行比较,可能是可取的。

is_clause_element = True
is_distinct_from(other)

实施 IS DISTINCT FROM 操作符。

在大多数平台上呈现“a与b不同”;在某些平台上,例如sqlite可能呈现“a不是b”。

1.1 新版功能.

is_selectable = False
isnot(other)

继承 isnot() 方法 ColumnOperators

实施 IS NOT 操作符。

通常情况下, IS NOT 与以下值比较时自动生成 None ,决定 NULL . 但是,明确使用 IS NOT 如果与某些平台上的布尔值进行比较,可能是可取的。

isnot_distinct_from(other)

实施 IS NOT DISTINCT FROM 操作符。

在大多数平台上呈现“a与b不同”;在某些平台上,例如sqlite可能呈现“a是b”。

1.1 新版功能.

key = None

在某些情况下,在Python命名空间中引用此对象的“key”。

这通常指列的“键”,如 .c 可选择的集合,例如sometable.c ["key"] 将返回.key为“somekey”的列。

label(name)

生成列标签,即 <columnname> AS <name> .

这是到 label() 功能。

如果“name”为“none”,则将生成匿名标签名。

like(other, escape=None)

继承 like() 方法 ColumnOperators

实施 like 操作符。

在列上下文中,生成表达式::

a LIKE other

例如。::

stmt = select([sometable]).\
    where(sometable.c.column.like("%foobar%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.like(“foo/%bar”,escape=“/”)

match(other, **kwargs)

继承 match() 方法 ColumnOperators

实现特定于数据库的“match”运算符。

match() 尝试解析为后端提供的类似匹配的函数或运算符。示例包括:

  • PostgreSQL-呈现 x @@ to_tsquery(y)

  • MySQL -渲染器 MATCH (x) AGAINST (y IN BOOLEAN MODE)

  • Oracle-呈现 CONTAINS(x, y)

  • 其他后端可能提供特殊的实现。

  • 没有任何特殊实现的后端将发出“match”操作符。例如,这与sqlite兼容。

notilike(other, escape=None)

继承 notilike() 方法 ColumnOperators

实施 NOT ILIKE 操作符。

这相当于使用否定 ColumnOperators.ilike() ,即 ~x.ilike(y) .

notin_(other)

继承 notin_() 方法 ColumnOperators

实施 NOT IN 操作符。

这相当于使用否定 ColumnOperators.in_() ,即 ~x.in_(y) .

在这种情况下 other 是一个空序列,编译器生成一个“empty not in”表达式。这将默认表达式“1=1”在所有情况下都生成“真”。这个 create_engine.empty_in_strategy 可用于更改此行为。

在 1.2 版更改: 这个 ColumnOperators.in_()ColumnOperators.notin_() 现在,默认情况下,运算符为空序列生成一个“静态”表达式。

notlike(other, escape=None)

继承 notlike() 方法 ColumnOperators

实施 NOT LIKE 操作符。

这相当于使用否定 ColumnOperators.like() ,即 ~x.like(y) .

nullsfirst()

产生一个 nullsfirst() 针对父对象的子句。

nullslast()

产生一个 nullslast() 针对父对象的子句。

op(opstring, precedence=0, is_comparison=False, return_type=None)

继承 op() 方法 Operators

生成通用运算符函数。

例如。::

somecolumn.op("*")(5)

生产::

somecolumn * 5

此函数还可用于显式地生成位运算符。例如::

somecolumn.op('&')(0xff)

是中的值的位与 somecolumn .

参数
  • operator -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。

  • precedence -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时,较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (,AS 运算符。值100将大于或等于所有运算符,-100将小于或等于所有运算符。

  • is_comparison -- 如果为真,则该运算符将被视为“比较”运算符,即计算为布尔真/假值,如 ==> 等等。应设置此标志,以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded::0.9.2-添加了 Operators.op.is_comparison 标志。

  • return_type -- 一 TypeEngine 类或对象,它将强制此运算符生成的表达式的返回类型为该类型。默认情况下,指定 Operators.op.is_comparison 将决心 Boolean ,而那些不属于左侧操作数的类型。…versionAdded::1.2.0b3-添加了 Operators.op.return_type 争论。

operate(op, *other, **kwargs)

对参数进行运算。

这是最低级别的操作,提升 NotImplementedError 默认情况下。

在子类上覆盖此项可以允许将公共行为应用于所有操作。例如,重写 ColumnOperators 申请 func.lower() 左右两侧:

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数
  • op -- 操作符可调用。

  • *other -- 操作的“另一方”。对于大多数操作,将是单个标量。

  • **kwargs -- 修饰语。这些可由特殊操作符通过,如 ColumnOperators.contains() .

params(*optionaldict, **kwargs)

继承 params() 方法 ClauseElement

返回副本 bindparam() 元素被替换。

返回此条款的副本 bindparam() 用给定字典中的值替换的元素::

>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
primary_key = False
proxy_set
reverse_operate(op, other, **kwargs)

对参数进行反向运算。

用法与 operate() .

self_group(against=None)

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select() 当放入另一个的FROM子句时构造 select() . (请注意,通常应使用 Select.alias() 方法,因为许多平台都需要命名嵌套的select语句)。

当表达式组合在一起时,应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。

shares_lineage(othercolumn)

如果给定 ColumnElement 有着共同的祖先 ColumnElement .

startswith(other, **kwargs)

实施 startswith 操作符。

生成一个类似表达式,该表达式根据字符串值开头的匹配项进行测试:

column LIKE <other> || '%'

例如。::

stmt = select([sometable]).\
    where(sometable.c.column.startswith("foobar"))

因为操作符使用 LIKE ,通配符 "%""_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值, ColumnOperators.startswith.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符,以便它们与自身匹配,而不是作为通配符匹配。或者, ColumnOperators.startswith.escape 参数将建立一个给定字符作为转义字符,当目标表达式不是文本字符串时可以使用该字符。

参数
  • other -- 要比较的表达式。这通常是一个纯字符串值,但也可以是任意的SQL表达式。类似通配符 %_ 默认情况下不转义,除非 ColumnOperators.startswith.autoescape 标志设置为真。

  • autoescape -- 布尔值;如果为true,则在like表达式中建立转义符,然后将其应用于 "%""_" 以及转义符本身在比较值中,该值被假定为文本字符串而不是SQL表达式。表达式如::somecolumn.startswith(“foo%bar”,autoescape=true)将呈现为::somecolumn-like :param || '%' ESCAPE '/' With the value of :param as "foo/%bar". .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The ColumnOperators.startswith.autoescape 参数现在是一个简单的布尔值而不是一个字符;转义字符本身也被转义,并默认为正斜杠,可以使用 ColumnOperators.startswith.escape 参数。

  • escape -- 一个字符,当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 %_ 允许它们充当自己而不是通配符。表达式如::somecolumn.startswith(“foo/%bar”,escape=“^”)将呈现为::somecolumn-like :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.startswith.autoescape ::somecolumn.startswith(“foo%bar^bat”,escape=“^”,autoescape=true),其中,给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

supports_execution = False
timetuple = None
type
unique_params(*optionaldict, **kwargs)

返回副本 bindparam() 元素被替换。

功能与 params() ,除了添加 unique=True 以影响绑定参数,以便可以使用多个语句。

class sqlalchemy.sql.operators.ColumnOperators

基地: sqlalchemy.sql.operators.Operators

为定义布尔、比较和其他运算符 ColumnElement 表达。

默认情况下,所有方法都调用 operate()reverse_operate() ,从python内置函数传入适当的operator函数 operator 模块或特定于sqlAlchemy的运算符函数 sqlalchemy.expression.operators . 例如 __eq__ 功能:

def __eq__(self, other):
    return self.operate(operators.eq, other)

operators.eq 本质上是:

def eq(a, b):
    return a == b

核心列表达式单元 ColumnElement 重写 Operators.operate() 还有其他人要回去 ColumnElement 构造,以便 == 上面的操作被子句构造替换。

__add__(other)

实施 + 操作符。

在列上下文中,生成子句 a + b 如果父对象具有非字符串关联性。如果父对象具有字符串关联性,则生成串联运算符, a || b -见 ColumnOperators.concat() .

__and__(other)

继承 __and__() 方法 Operators

实施 & 操作符。

当与SQL表达式一起使用时,将生成一个和操作,相当于 and_() ,即:

a & b

等于:

from sqlalchemy import and_
and_(a, b)

使用时应小心 & 关于运算符优先级; & 运算符具有最高优先级。如果操作数包含其他子表达式,则应将它们括在括号中::

(a == 2) & (b == 4)
__delattr__

继承 __delattr__ 属性 object

实现delattr(self,name)。

__dir__()

继承 __dir__() 方法 object

Default dir() implementation.

__div__(other)

实施 / 操作符。

在列上下文中,生成子句 a / b .

__eq__(other)

实施 == 操作符。

在列上下文中,生成子句 a = b . 如果目标是 None 生产 a IS NULL .

__format__()

继承 __format__() 方法 object

Default object formatter.

__ge__(other)

实施 >= 操作符。

在列上下文中,生成子句 a >= b .

__getattribute__

继承 __getattribute__ 属性 object

返回getattr(self,name)。

__getitem__(index)

实现[]运算符。

这可以被一些特定于数据库的类型使用,如PostgreSQL数组和hstore。

__gt__(other)

实施 > 操作符。

在列上下文中,生成子句 a > b .

__hash__

返回哈希(self)。

__init__

继承 __init__ 属性 object

初始化自身。请参阅帮助(键入(self))以获得准确的签名。

__init_subclass__()

inherited from the __init_subclass__() method of object

This method is called when a class is subclassed.

The default implementation does nothing. It may be overridden to extend subclasses.

__invert__()

继承 __invert__() 方法 Operators

实施 ~ 操作符。

当与SQL表达式一起使用时,会导致一个非操作,相当于 not_() ,即:

~a

等于:

from sqlalchemy import not_
not_(a)
__le__(other)

实施 <= 操作符。

在列上下文中,生成子句 a <= b .

__lshift__(other)

实现<<运算符。

不由sqlachemy core使用,这是为希望使用<<作为扩展点的自定义操作符系统提供的。

__lt__(other)

实施 < 操作符。

在列上下文中,生成子句 a < b .

__mod__(other)

实施 % 操作符。

在列上下文中,生成子句 a % b .

__mul__(other)

实施 * 操作符。

在列上下文中,生成子句 a * b .

__ne__(other)

实施 != 操作符。

在列上下文中,生成子句 a != b . 如果目标是 None 生产 a IS NOT NULL .

__neg__()

实施 - 操作符。

在列上下文中,生成子句 -a .

__new__()

继承 __new__() 方法 object

创建并返回新对象。请参阅帮助(类型)以获得准确的签名。

__or__(other)

继承 __or__() 方法 Operators

实施 | 操作符。

当与SQL表达式一起使用时,会产生一个或操作,相当于 or_() ,即:

a | b

等于:

from sqlalchemy import or_
or_(a, b)

使用时应小心 | 关于运算符优先级; | 运算符具有最高优先级。如果操作数包含其他子表达式,则应将它们括在括号中::

(a == 2) | (b == 4)
__radd__(other)

实施 + 反向操作。

ColumnOperators.__add__() .

__rdiv__(other)

实施 / 反向操作。

ColumnOperators.__div__() .

__reduce__()

继承 __reduce__() 方法 object

Helper for pickle.

__reduce_ex__()

继承 __reduce_ex__() 方法 object

Helper for pickle.

__repr__

继承 __repr__ 属性 object

返回repr(self)。

__rmod__(other)

实施 % 反向操作。

ColumnOperators.__mod__() .

__rmul__(other)

实施 * 反向操作。

ColumnOperators.__mul__() .

__rshift__(other)

执行>>操作符。

不由sqlachemy core使用,这是为希望使用>>作为扩展点的自定义操作符系统提供的。

__rsub__(other)

实施 - 反向操作。

ColumnOperators.__sub__() .

__rtruediv__(other)

实施 // 反向操作。

ColumnOperators.__truediv__() .

__setattr__

继承 __setattr__ 属性 object

实现setattr(self、name、value)。

__sizeof__()

继承 __sizeof__() 方法 object

Size of object in memory, in bytes.

__str__

继承 __str__ 属性 object

返回str(self)。

__sub__(other)

实施 - 操作符。

在列上下文中,生成子句 a - b .

__subclasshook__()

继承 __subclasshook__() 方法 object

抽象类可以重写此项以自定义issubclass()。

abc.abcmeta.uu subclasscheck_uu()在早期就调用了这个函数。它应该返回true、false或notimplemented。如果返回NotImplemented,则使用普通算法。否则,它将覆盖普通算法(并缓存结果)。

__truediv__(other)

实施 // 操作符。

在列上下文中,生成子句 a / b .

all_()

产生一个 all_() 针对父对象的子句。

此运算符仅适用于标量子查询对象,或某些后端的列表达式适用于数组类型,例如::

# postgresql '5 = ALL (somearray)'
expr = 5 == mytable.c.somearray.all_()

# mysql '5 = ALL (SELECT value FROM table)'
expr = 5 == select([table.c.value]).as_scalar().all_()

参见

all_() -独立版本

any_() -任何操作符

1.1 新版功能.

any_()

产生一个 any_() 针对父对象的子句。

此运算符仅适用于标量子查询对象,或某些后端的列表达式适用于数组类型,例如::

# postgresql '5 = ANY (somearray)'
expr = 5 == mytable.c.somearray.any_()

# mysql '5 = ANY (SELECT value FROM table)'
expr = 5 == select([table.c.value]).as_scalar().any_()

参见

any_() -独立版本

all_() -所有操作符

1.1 新版功能.

asc()

产生一个 asc() 针对父对象的子句。

between(cleft, cright, symmetric=False)

产生一个 between() 在给定上下限的情况下,针对父对象的子句。

bool_op(opstring, precedence=0)

继承 bool_op() 方法 Operators

返回自定义布尔运算符。

这个方法是调用 Operators.op() 并通过 Operators.op.is_comparison 标记为真。

1.2.0b3 新版功能.

collate(collation)

产生一个 collate() 在给定排序规则字符串的情况下,对父对象执行子句。

参见

collate()

concat(other)

实现“concat”运算符。

在列上下文中,生成子句 a || b 或使用 concat() mysql上的操作符。

contains(other, **kwargs)

实现“contains”运算符。

生成一个类似表达式,该表达式根据字符串值中间的匹配项进行测试:

column LIKE '%' || <other> || '%'

例如。::

stmt = select([sometable]).\
    where(sometable.c.column.contains("foobar"))

因为操作符使用 LIKE ,通配符 "%""_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值, ColumnOperators.contains.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符,以便它们与自身匹配,而不是作为通配符匹配。或者, ColumnOperators.contains.escape 参数将建立一个给定字符作为转义字符,当目标表达式不是文本字符串时可以使用该字符。

参数
  • other -- 要比较的表达式。这通常是一个纯字符串值,但也可以是任意的SQL表达式。类似通配符 %_ 默认情况下不转义,除非 ColumnOperators.contains.autoescape 标志设置为真。

  • autoescape -- 布尔值;如果为true,则在like表达式中建立转义符,然后将其应用于 "%""_" 以及转义符本身在比较值中,该值被假定为文本字符串而不是SQL表达式。表达式如::somecolumn.contains(“foo%bar”,autoescape=true)将呈现为::somecolumn,如“%”。|| :param || '%' ESCAPE '/' With the value of :param as "foo/%bar". .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The ColumnOperators.contains.autoescape 参数现在是一个简单的布尔值而不是一个字符;转义字符本身也被转义,并默认为正斜杠,可以使用 ColumnOperators.contains.escape 参数。

  • escape -- 一个字符,当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 %_ 允许它们充当自己而不是通配符。表达式如::somecolumn.contains(“foo/%bar”,escape=“^”)将呈现为::somecolumn,如“%”。|| :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.contains.autoescape ::someColumn.contains(“foo%bar^bat”,escape=“^”,autoescape=true),其中,给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

desc()

产生一个 desc() 针对父对象的子句。

distinct()

产生一个 distinct() 针对父对象的子句。

endswith(other, **kwargs)

实现“endswith”运算符。

生成一个类似表达式,该表达式根据字符串值末尾的匹配项进行测试:

column LIKE '%' || <other>

例如。::

stmt = select([sometable]).\
    where(sometable.c.column.endswith("foobar"))

因为操作符使用 LIKE ,通配符 "%""_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值, ColumnOperators.endswith.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符,以便它们与自身匹配,而不是作为通配符匹配。或者, ColumnOperators.endswith.escape 参数将建立一个给定字符作为转义字符,当目标表达式不是文本字符串时可以使用该字符。

参数
  • other -- 要比较的表达式。这通常是一个纯字符串值,但也可以是任意的SQL表达式。类似通配符 %_ 默认情况下不转义,除非 ColumnOperators.endswith.autoescape 标志设置为真。

  • autoescape -- 布尔值;如果为true,则在like表达式中建立转义符,然后将其应用于 "%""_" 以及转义符本身在比较值中,该值被假定为文本字符串而不是SQL表达式。表达式如::somecolumn.endswith(“foo%bar”,autoescape=true)将呈现为::somecolumn,如“%”。|| :param ESCAPE '/' With the value of :param as "foo/%bar". .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The ColumnOperators.endswith.autoescape 参数现在是一个简单的布尔值而不是一个字符;转义字符本身也被转义,并默认为正斜杠,可以使用 ColumnOperators.endswith.escape 参数。

  • escape -- 一个字符,当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 %_ 允许它们充当自己而不是通配符。表达式如::somecolumn.endswith(“foo/%bar”,escape=“^”)将呈现为::somecolumn,如“%”。|| :param ESCAPE '^' The parameter may also be combined with ColumnOperators.endswith.autoescape ::someColumn.endsWith(“foo%bar^bat”,escape=“^”,autoescape=true),其中,给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

ilike(other, escape=None)

实施 ilike 运算符,例如不区分大小写的like。

在列上下文中,生成以下任一形式的表达式:

lower(a) LIKE lower(other)

或者在支持ilike运算符的后端:

a ILIKE other

例如。::

stmt = select([sometable]).\
    where(sometable.c.column.ilike("%foobar%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.ilike(“foo/%bar”,escape=“/”)

in_(other)

实施 in 操作符。

在列上下文中,生成子句 column IN <other> .

给定参数 other 可能是:

  • 文字值列表,例如:

    stmt.where(column.in_([1, 2, 3]))

    在此调用表单中,项目列表将转换为一组与给定列表长度相同的绑定参数:

    WHERE COL IN (?, ?, ?)
  • 空列表,例如:

    stmt.where(column.in_([]))

    在此调用形式中,表达式呈现“false”表达式,例如:

    WHERE 1 != 1

    这个“假”表达式在旧的sqlAlchemy版本中历史上有不同的行为,请参见 create_engine.empty_in_strategy 对于行为选项。

    在 1.2 版更改: 简化了“空入”表达式的行为

  • 绑定参数,例如 bindparam() ,如果包含 bindparam.expanding 标志:

    stmt.where(column.in_(bindparam('value', expanding=True)))

    在此调用表单中,表达式呈现一个特殊的非SQL占位符表达式,其外观如下:

    WHERE COL IN ([EXPANDING_value])

    此占位符表达式在语句执行时被截取,以便转换为前面所示的绑定参数表单的变量号。如果语句的执行方式为:

    connection.execute(stmt, {"value": [1, 2, 3]})

    将为数据库传递每个值的绑定参数:

    WHERE COL IN (?, ?, ?)

    1.2 新版功能: 添加了“扩展”绑定参数

    如果传递空列表,将呈现一个特定于正在使用的数据库的特殊“空列表”表达式。在sqlite上:

    WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

    1.3 新版功能: “expanding”绑定参数现在支持空列表

  • select() 构造,通常是相关的标量选择:

    stmt.where(
        column.in_(
            select([othertable.c.y]).
            where(table.c.x == othertable.c.x)
        )
    )

    在这个调用表单中, ColumnOperators.in_() 按给定呈现:

    WHERE COL IN (SELECT othertable.y
    FROM othertable WHERE othertable.x = table.x)
参数

other -- 文字列表,a select() 构造,或 bindparam() 构造,包括 bindparam.expanding 标志设置为真。

is_(other)

实施 IS 操作符。

通常情况下, IS 与以下值比较时自动生成 None ,决定 NULL . 但是,明确使用 IS 如果与某些平台上的布尔值进行比较,可能是可取的。

is_distinct_from(other)

实施 IS DISTINCT FROM 操作符。

在大多数平台上呈现“a与b不同”;在某些平台上,例如sqlite可能呈现“a不是b”。

1.1 新版功能.

isnot(other)

实施 IS NOT 操作符。

通常情况下, IS NOT 与以下值比较时自动生成 None ,决定 NULL . 但是,明确使用 IS NOT 如果与某些平台上的布尔值进行比较,可能是可取的。

isnot_distinct_from(other)

实施 IS NOT DISTINCT FROM 操作符。

在大多数平台上呈现“a与b不同”;在某些平台上,例如sqlite可能呈现“a是b”。

1.1 新版功能.

like(other, escape=None)

实施 like 操作符。

在列上下文中,生成表达式::

a LIKE other

例如。::

stmt = select([sometable]).\
    where(sometable.c.column.like("%foobar%"))
参数
  • other -- 要比较的表达式

  • escape -- 可选转义符,呈现 ESCAPE 关键字,例如:somecolumn.like(“foo/%bar”,escape=“/”)

match(other, **kwargs)

实现特定于数据库的“match”运算符。

match() 尝试解析为后端提供的类似匹配的函数或运算符。示例包括:

  • PostgreSQL-呈现 x @@ to_tsquery(y)

  • MySQL -渲染器 MATCH (x) AGAINST (y IN BOOLEAN MODE)

  • Oracle-呈现 CONTAINS(x, y)

  • 其他后端可能提供特殊的实现。

  • 没有任何特殊实现的后端将发出“match”操作符。例如,这与sqlite兼容。

notilike(other, escape=None)

实施 NOT ILIKE 操作符。

这相当于使用否定 ColumnOperators.ilike() ,即 ~x.ilike(y) .

notin_(other)

实施 NOT IN 操作符。

这相当于使用否定 ColumnOperators.in_() ,即 ~x.in_(y) .

在这种情况下 other 是一个空序列,编译器生成一个“empty not in”表达式。这将默认表达式“1=1”在所有情况下都生成“真”。这个 create_engine.empty_in_strategy 可用于更改此行为。

在 1.2 版更改: 这个 ColumnOperators.in_()ColumnOperators.notin_() 现在,默认情况下,运算符为空序列生成一个“静态”表达式。

notlike(other, escape=None)

实施 NOT LIKE 操作符。

这相当于使用否定 ColumnOperators.like() ,即 ~x.like(y) .

nullsfirst()

产生一个 nullsfirst() 针对父对象的子句。

nullslast()

产生一个 nullslast() 针对父对象的子句。

op(opstring, precedence=0, is_comparison=False, return_type=None)

继承 op() 方法 Operators

生成通用运算符函数。

例如。::

somecolumn.op("*")(5)

生产::

somecolumn * 5

此函数还可用于显式地生成位运算符。例如::

somecolumn.op('&')(0xff)

是中的值的位与 somecolumn .

参数
  • operator -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。

  • precedence -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时,较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (,AS 运算符。值100将大于或等于所有运算符,-100将小于或等于所有运算符。

  • is_comparison -- 如果为真,则该运算符将被视为“比较”运算符,即计算为布尔真/假值,如 ==> 等等。应设置此标志,以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded::0.9.2-添加了 Operators.op.is_comparison 标志。

  • return_type -- 一 TypeEngine 类或对象,它将强制此运算符生成的表达式的返回类型为该类型。默认情况下,指定 Operators.op.is_comparison 将决心 Boolean ,而那些不属于左侧操作数的类型。…versionAdded::1.2.0b3-添加了 Operators.op.return_type 争论。

operate(op, *other, **kwargs)

继承 operate() 方法 Operators

对参数进行运算。

这是最低级别的操作,提升 NotImplementedError 默认情况下。

在子类上覆盖此项可以允许将公共行为应用于所有操作。例如,重写 ColumnOperators 申请 func.lower() 左右两侧:

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数
  • op -- 操作符可调用。

  • *other -- 操作的“另一方”。对于大多数操作,将是单个标量。

  • **kwargs -- 修饰语。这些可由特殊操作符通过,如 ColumnOperators.contains() .

reverse_operate(op, other, **kwargs)

对参数进行反向运算。

用法与 operate() .

startswith(other, **kwargs)

实施 startswith 操作符。

生成一个类似表达式,该表达式根据字符串值开头的匹配项进行测试:

column LIKE <other> || '%'

例如。::

stmt = select([sometable]).\
    where(sometable.c.column.startswith("foobar"))

因为操作符使用 LIKE ,通配符 "%""_" 存在于<other>表达式中的也将表现为通配符。对于文本字符串值, ColumnOperators.startswith.autoescape 标志可以设置为 True 将转义应用于字符串值中出现的这些字符,以便它们与自身匹配,而不是作为通配符匹配。或者, ColumnOperators.startswith.escape 参数将建立一个给定字符作为转义字符,当目标表达式不是文本字符串时可以使用该字符。

参数
  • other -- 要比较的表达式。这通常是一个纯字符串值,但也可以是任意的SQL表达式。类似通配符 %_ 默认情况下不转义,除非 ColumnOperators.startswith.autoescape 标志设置为真。

  • autoescape -- 布尔值;如果为true,则在like表达式中建立转义符,然后将其应用于 "%""_" 以及转义符本身在比较值中,该值被假定为文本字符串而不是SQL表达式。表达式如::somecolumn.startswith(“foo%bar”,autoescape=true)将呈现为::somecolumn-like :param || '%' ESCAPE '/' With the value of :param as "foo/%bar". .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The ColumnOperators.startswith.autoescape 参数现在是一个简单的布尔值而不是一个字符;转义字符本身也被转义,并默认为正斜杠,可以使用 ColumnOperators.startswith.escape 参数。

  • escape -- 一个字符,当给定时将用 ESCAPE 关键字将该字符建立为转义字符。然后可以将此字符置于 %_ 允许它们充当自己而不是通配符。表达式如::somecolumn.startswith(“foo/%bar”,escape=“^”)将呈现为::somecolumn-like :param || '%' ESCAPE '^' The parameter may also be combined with ColumnOperators.startswith.autoescape ::somecolumn.startswith(“foo%bar^bat”,escape=“^”,autoescape=true),其中,给定的文本参数将转换为 "foo^%bar^^bat" 在被传递到数据库之前。

timetuple = None

hack,允许在lhs上比较datetime对象。

class sqlalchemy.sql.base.DialectKWArgs

建立一个类的能力,使其具有带有默认值和构造函数验证的方言特定参数。

这个 DialectKWArgsDefaultDialect.construct_arguments 以方言呈现。

classmethod argument_for(dialect_name, argument_name, default)

为此类添加一种新的方言特定关键字参数。

例如。::

Index.argument_for("mydialect", "length", None)

some_index = Index('a', 'b', mydialect_length=5)

这个 DialectKWArgs.argument_for() 方法是按参数向 DefaultDialect.construct_arguments 字典。此字典提供了各种模式级构造代表方言接受的参数名列表。

新方言通常应同时将此字典指定为方言类的数据成员。临时添加参数名的用例通常用于最终用户代码,该代码也使用自定义编译方案,该方案使用附加参数。

参数
  • dialect_name -- 方言的名称。方言必须可定位,否则 NoSuchModuleError 提高了。方言还必须包括现有的 DefaultDialect.construct_arguments 集合,指示它参与关键字参数验证和默认系统,否则 ArgumentError 提高了。如果方言不包含此集合,则可以代表此方言指定任何关键字参数。包含在sqlAlchemy中的所有方言都包含此集合,但是对于第三方方言,支持可能有所不同。

  • argument_name -- 参数的名称。

  • default -- 参数的默认值。

0.9.4 新版功能.

dialect_kwargs

指定为此构造的方言特定选项的关键字参数集合。

这些论据以原版呈现在这里。 <dialect>_<kwarg> 格式。只包括实际传递的参数;与 DialectKWArgs.dialect_options 集合,其中包含此方言已知的所有选项,包括默认值。

集合也是可写的;接受窗体的键 <dialect>_<kwarg> 值将组合到选项列表中。

0.9.2 新版功能.

在 0.9.4 版更改: 这个 DialectKWArgs.dialect_kwargs 集合现在可写。

参见

DialectKWArgs.dialect_options -嵌套字典窗体

dialect_options

指定为此构造的方言特定选项的关键字参数集合。

这是一个两级嵌套注册表,键控为 <dialect_name><argument_name> . 例如, postgresql_where 参数可定位为:

arg = my_object.dialect_options['postgresql']['where']

0.9.2 新版功能.

参见

DialectKWArgs.dialect_kwargs -平字典形式

kwargs

同义词 DialectKWArgs.dialect_kwargs .

class sqlalchemy.sql.expression.Extract(field, expr, **kwargs)

基地: sqlalchemy.sql.expression.ColumnElement

表示一个SQL提取子句, extract(field FROM expr) .

__init__(field, expr, **kwargs)

构建新的 Extract 对象。

此构造函数被镜像为公共API函数;请参见 extract() 完整的用法和参数描述。

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

class sqlalchemy.sql.elements.False_

基地: sqlalchemy.sql.expression.ColumnElement

代表 false SQL语句中的关键字或等效项。

False_ 作为常量通过 false() 功能。

compare(other)

将此ColumnElement与其他ColumnElement进行比较。

理解特殊论点:

参数
  • use_proxies -- 如果为true,则将共享公共基列的两列视为等效列(即shares_沿袭())

  • equivalents -- 作为映射到列集的键的列字典。如果给定的“其他”列出现在本字典中,则如果相应集合()中的任何列通过比较测试,则结果为真。这用于通过外键或其他条件将比较扩展到其他已知与此列等效的列。

class sqlalchemy.sql.expression.FunctionFilter(func, *criterion)

基地: sqlalchemy.sql.expression.ColumnElement

表示一个函数筛选子句。

这是一个针对聚合和窗口函数的特殊运算符,它控制传递给它的行。只有某些数据库后端支持它。

调用 FunctionFilter 是通过 FunctionElement.filter() ::

func.count(1).filter(True)

1.0.0 新版功能.

__init__(func, *criterion)

构建新的 FunctionFilter 对象。

此构造函数被镜像为公共API函数;请参见 funcfilter() 完整的用法和参数描述。

filter(*criterion)

针对函数生成一个额外的过滤器。

此方法将附加条件添加到 FunctionElement.filter() .

在SQL呈现时,多个条件通过 AND .

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

over(partition_by=None, order_by=None, range_=None, rows=None)

针对此筛选函数生成over子句。

用于聚合或所谓的“窗口”函数,用于支持窗口函数的数据库后端。

表达式:

func.rank().filter(MyClass.y > 5).over(order_by='x')

缩写为:

from sqlalchemy import over, funcfilter
over(funcfilter(func.rank(), MyClass.y > 5), order_by='x')

over() 完整描述。

class sqlalchemy.sql.expression.Label(name, element, type_=None)

基地: sqlalchemy.sql.expression.ColumnElement

表示列标签(as)。

表示一个标签,通常应用于任何列级元素,使用 AS SQL关键字。

__init__(name, element, type_=None)

构建新的 Label 对象。

此构造函数被镜像为公共API函数;请参见 label() 完整的用法和参数描述。

foreign_keys

Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

primary_key

布尔(x)->布尔

当参数x为真时返回真,否则返回假。内建的true和false是类bool的唯一两个实例。bool类是int类的子类,不能被子类化。

self_group(against=None)

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select() 当放入另一个的FROM子句时构造 select() . (请注意,通常应使用 Select.alias() 方法,因为许多平台都需要命名嵌套的select语句)。

当表达式组合在一起时,应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。

class sqlalchemy.sql.elements.Null

基地: sqlalchemy.sql.expression.ColumnElement

表示SQL语句中的空关键字。

Null 作为常量通过 null() 功能。

compare(other)

将此ColumnElement与其他ColumnElement进行比较。

理解特殊论点:

参数
  • use_proxies -- 如果为true,则将共享公共基列的两列视为等效列(即shares_沿袭())

  • equivalents -- 作为映射到列集的键的列字典。如果给定的“其他”列出现在本字典中,则如果相应集合()中的任何列通过比较测试,则结果为真。这用于通过外键或其他条件将比较扩展到其他已知与此列等效的列。

class sqlalchemy.sql.expression.Over(element, partition_by=None, order_by=None, range_=None, rows=None)

基地: sqlalchemy.sql.expression.ColumnElement

表示一个over子句。

这是一个针对所谓的“窗口”函数的特殊运算符,以及任何聚合函数,它产生与结果集本身相关的结果。只有某些数据库后端支持它。

__init__(element, partition_by=None, order_by=None, range_=None, rows=None)

构建新的 Over 对象。

此构造函数被镜像为公共API函数;请参见 over() 完整的用法和参数描述。

element = None

此对象的基础表达式对象 Over 对象指向。

func

此引用的元素 Over 条款。

1.1 版后已移除: 这个 Over.func 会员 Over 类已弃用,将在将来的版本中删除。请参阅 Over.element 属性。

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

class sqlalchemy.sql.expression.TextClause(text, bind=None)

基地: sqlalchemy.sql.expression.Executablesqlalchemy.sql.expression.ClauseElement

表示文字SQL文本片段。

例如。::

from sqlalchemy import text

t = text("SELECT * FROM users")
result = connection.execute(t)

这个 Text 构造是使用 text() 函数;有关完整文档,请参见该函数。

参见

text()

bindparams(*binds, **names_to_values)

在此范围内建立绑定参数的值和/或类型 TextClause 构造。

给定文本结构,例如:

from sqlalchemy import text
stmt = text("SELECT id, name FROM user WHERE name=:name "
            "AND timestamp=:timestamp")

这个 TextClause.bindparams() 方法可用于确定 :name:timestamp ,使用简单关键字参数::

stmt = stmt.bindparams(name='jack',
            timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5))

在上面,新的 BindParameter 将使用名称生成对象 nametimestamp 和值 jackdatetime.datetime(2012, 10, 8, 15, 12, 5) ,分别。在这种情况下,将根据给定的值推断类型 StringDateTime .

当需要特定的类型行为时,位置 *binds 参数不能用于指定 bindparam() 直接构造。这些构造必须至少包括 key 参数,然后是可选值和类型::

from sqlalchemy import bindparam
stmt = stmt.bindparams(
                bindparam('name', value='jack', type_=String),
                bindparam('timestamp', type_=DateTime)
            )

上面,我们指定了 DateTime 对于 timestamp 绑定,以及 String 对于 name 绑定。在情况下 name 我们还设置了默认值 "jack" .

可以在语句执行时提供其他绑定参数,例如:

result = connection.execute(stmt,
            timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5))

这个 TextClause.bindparams() 方法可以重复调用,它将在其中重新使用现有的 BindParameter 对象以添加新信息。例如,我们可以调用 TextClause.bindparams() 第一次输入信息,第二次输入值信息,并将其组合:

stmt = text("SELECT id, name FROM user WHERE name=:name "
            "AND timestamp=:timestamp")
stmt = stmt.bindparams(
    bindparam('name', type_=String),
    bindparam('timestamp', type_=DateTime)
)
stmt = stmt.bindparams(
    name='jack',
    timestamp=datetime.datetime(2012, 10, 8, 15, 12, 5)
)
columns(selectable, *cols, **types)

打开这个 TextClause 对象变成 TextAsFrom 可以嵌入到其他语句中的对象。

此函数基本上弥合了纯文本select语句与“selectable”的SQL表达式语言概念之间的差距:

from sqlalchemy.sql import column, text

stmt = text("SELECT id, name FROM some_table")
stmt = stmt.columns(column('id'), column('name')).alias('st')

stmt = select([mytable]).                    select_from(
            mytable.join(stmt, mytable.c.name == stmt.c.name)
        ).where(stmt.c.id > 5)

上面,我们通过了一系列 column() 元素到 TextClause.columns() 方法位置。这些 column() 元素现在成为第一类元素 TextAsFrom.c 列集合,就像其他可选的一样。

我们传递给的列表达式 TextClause.columns() 也可以打印;当我们这样做时,这些 TypeEngine 对象成为列的有效返回类型,因此可以对返回值使用SQLAlchemy的结果集处理系统。这对于日期或布尔类型等类型以及某些方言配置上的Unicode处理通常是必需的:

stmt = text("SELECT id, name, timestamp FROM some_table")
stmt = stmt.columns(
            column('id', Integer),
            column('name', Unicode),
            column('timestamp', DateTime)
        )

for id, name, timestamp in connection.execute(stmt):
    print(id, name, timestamp)

作为上述语法的快捷方式,如果只需要类型转换,则可以使用单独引用类型的关键字参数::

stmt = text("SELECT id, name, timestamp FROM some_table")
stmt = stmt.columns(
            id=Integer,
            name=Unicode,
            timestamp=DateTime
        )

for id, name, timestamp in connection.execute(stmt):
    print(id, name, timestamp)

位置形式 TextClause.columns() 还提供了 位置列目标 这在将ORM用于复杂的文本查询时特别有用。如果我们将模型中的列指定为 TextClause.columns() ,结果集将按位置与这些列匹配,这意味着文本SQL中列的名称或原点无关紧要:

stmt = text("SELECT users.id, addresses.id, users.id, "
     "users.name, addresses.email_address AS email "
     "FROM users JOIN addresses ON users.id=addresses.user_id "
     "WHERE users.id = 1").columns(
        User.id,
        Address.id,
        Address.user_id,
        User.name,
        Address.email_address
     )

query = session.query(User).from_statement(stmt).options(
    contains_eager(User.addresses))

1.1 新版功能: 这个 TextClause.columns() 当列表达式以纯位置方式传递时,方法现在在结果集中提供位置列目标。

这个 TextClause.columns() 方法提供调用的直接路由 FromClause.alias() 以及 SelectBase.cte() 对照文本select语句:

stmt = stmt.columns(id=Integer, name=String).cte('st')

stmt = select([sometable]).where(sometable.c.id == stmt.c.id)

0.9.0 新版功能: text() 现在可以使用 TextClause.columns() 方法。

compare(other)

将这一条款与给定的条款进行比较。

子类应该覆盖默认行为,这是一个直接的身份比较。

* *kw是子类compare()方法使用的参数,可用于修改比较条件。(见 ColumnElement

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

self_group(against=None)

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select() 当放入另一个的FROM子句时构造 select() . (请注意,通常应使用 Select.alias() 方法,因为许多平台都需要命名嵌套的select语句)。

当表达式组合在一起时,应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。

class sqlalchemy.sql.expression.Tuple(*clauses, **kw)

基地: sqlalchemy.sql.expression.ClauseListsqlalchemy.sql.expression.ColumnElement

表示SQL元组。

__init__(*clauses, **kw)

构建新的 Tuple 对象。

此构造函数被镜像为公共API函数;请参见 tuple_() 完整的用法和参数描述。

class sqlalchemy.sql.expression.WithinGroup(element, *order_by)

基地: sqlalchemy.sql.expression.ColumnElement

表示组内(order by)子句。

这是针对所谓的“有序集聚合”和“假设集聚合”函数的特殊运算符,包括 percentile_cont()rank()dense_rank() 等。

它只受某些数据库后端支持,如PostgreSQL、Oracle和MS SQL Server。

这个 WithinGroup 构造从方法中提取其类型 FunctionElement.within_group_type() . 如果这种回报 None ,函数的 .type 使用。

__init__(element, *order_by)

构建新的 WithinGroup 对象。

此构造函数被镜像为公共API函数;请参见 within_group() 完整的用法和参数描述。

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

over(partition_by=None, order_by=None, range_=None, rows=None)

针对此生成一个over子句 WithinGroup 构造。

此函数与的签名相同 FunctionElement.over() .

class sqlalchemy.sql.elements.True_

基地: sqlalchemy.sql.expression.ColumnElement

代表 true SQL语句中的关键字或等效项。

True_ 作为常量通过 true() 功能。

compare(other)

将此ColumnElement与其他ColumnElement进行比较。

理解特殊论点:

参数
  • use_proxies -- 如果为true,则将共享公共基列的两列视为等效列(即shares_沿袭())

  • equivalents -- 作为映射到列集的键的列字典。如果给定的“其他”列出现在本字典中,则如果相应集合()中的任何列通过比较测试,则结果为真。这用于通过外键或其他条件将比较扩展到其他已知与此列等效的列。

class sqlalchemy.sql.expression.TypeCoerce(expression, type_)

基地: sqlalchemy.sql.expression.ColumnElement

表示Python端类型强制包装。

TypeCoerce 供应 expression.type_coerce() 函数;有关用法的详细信息,请参阅该函数。

在 1.1 版更改: 这个 type_coerce() 函数现在产生一个持久的 TypeCoerce 包装对象而不是就地转换给定对象。

__init__(expression, type_)

构建新的 TypeCoerce 对象。

此构造函数被镜像为公共API函数;请参见 type_coerce() 完整的用法和参数描述。

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

class sqlalchemy.sql.operators.custom_op(opstring, precedence=0, is_comparison=False, return_type=None, natural_self_precedent=False, eager_grouping=False)

表示“自定义”运算符。

custom_op 通常在 Operators.op()Operators.bool_op() 方法用于创建可调用的自定义运算符。当以编程方式构造表达式时,也可以直接使用类。例如,表示“阶乘”运算:

from sqlalchemy.sql import UnaryExpression
from sqlalchemy.sql import operators
from sqlalchemy import Numeric

unary = UnaryExpression(table.c.somecolumn,
        modifier=operators.custom_op("!"),
        type_=Numeric)
class sqlalchemy.sql.operators.Operators

比较和逻辑运算符的基础。

实现基方法 operate()reverse_operate() 以及 __and__()__or__()__invert__() .

通常通过其最常见的子类使用 ColumnOperators .

__and__(other)

实施 & 操作符。

当与SQL表达式一起使用时,将生成一个和操作,相当于 and_() ,即:

a & b

等于:

from sqlalchemy import and_
and_(a, b)

使用时应小心 & 关于运算符优先级; & 运算符具有最高优先级。如果操作数包含其他子表达式,则应将它们括在括号中::

(a == 2) & (b == 4)
__invert__()

实施 ~ 操作符。

当与SQL表达式一起使用时,会导致一个非操作,相当于 not_() ,即:

~a

等于:

from sqlalchemy import not_
not_(a)
__or__(other)

实施 | 操作符。

当与SQL表达式一起使用时,会产生一个或操作,相当于 or_() ,即:

a | b

等于:

from sqlalchemy import or_
or_(a, b)

使用时应小心 | 关于运算符优先级; | 运算符具有最高优先级。如果操作数包含其他子表达式,则应将它们括在括号中::

(a == 2) | (b == 4)
bool_op(opstring, precedence=0)

返回自定义布尔运算符。

这个方法是调用 Operators.op() 并通过 Operators.op.is_comparison 标记为真。

1.2.0b3 新版功能.

op(opstring, precedence=0, is_comparison=False, return_type=None)

生成通用运算符函数。

例如。::

somecolumn.op("*")(5)

生产::

somecolumn * 5

此函数还可用于显式地生成位运算符。例如::

somecolumn.op('&')(0xff)

是中的值的位与 somecolumn .

参数
  • operator -- 将作为该元素和传递给生成函数的表达式之间的中缀运算符输出的字符串。

  • precedence -- 在对表达式加括号时应用于运算符的优先级。当对具有更高优先级的另一个运算符应用时,较低的数字将导致表达式加括号。默认值为 0 低于除逗号之外的所有运算符 (,AS 运算符。值100将大于或等于所有运算符,-100将小于或等于所有运算符。

  • is_comparison -- 如果为真,则该运算符将被视为“比较”运算符,即计算为布尔真/假值,如 ==> 等等。应设置此标志,以便ORM关系可以确定在自定义联接条件中使用的运算符是比较运算符。…versionAdded::0.9.2-添加了 Operators.op.is_comparison 标志。

  • return_type -- 一 TypeEngine 类或对象,它将强制此运算符生成的表达式的返回类型为该类型。默认情况下,指定 Operators.op.is_comparison 将决心 Boolean ,而那些不属于左侧操作数的类型。…versionAdded::1.2.0b3-添加了 Operators.op.return_type 争论。

operate(op, *other, **kwargs)

对参数进行运算。

这是最低级别的操作,提升 NotImplementedError 默认情况下。

在子类上覆盖此项可以允许将公共行为应用于所有操作。例如,重写 ColumnOperators 申请 func.lower() 左右两侧:

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数
  • op -- 操作符可调用。

  • *other -- 操作的“另一方”。对于大多数操作,将是单个标量。

  • **kwargs -- 修饰语。这些可由特殊操作符通过,如 ColumnOperators.contains() .

reverse_operate(op, other, **kwargs)

对参数进行反向运算。

用法与 operate() .

class sqlalchemy.sql.elements.quoted_name

基地: sqlalchemy.util.langhelpers.MemoizedSlotsbuiltins.str

表示结合引用首选项的SQL标识符。

quoted_name 是一个python unicode/str子类,它表示一个特定的标识符名称以及 quote 标志。这个 quote 标志,设置为时 TrueFalse ,重写此标识符的自动引用行为,以便无条件地引用或不引用名称。如果不履行 None ,根据对令牌本身的检查,在每个后端的基础上对标识符应用引用行为。

A quoted_name 对象与 quote=True 在所谓的“名称规范化”选项的情况下,还可以防止进行修改。某些数据库后端(如Oracle、Firebird和DB2)将不区分大小写的名称“规范化”为大写。这些后端的sqlAlchemy方言从sqlAlchemy的小写表示不敏感约定转换为大写表示不敏感约定。这个 quote=True 此处的标志将阻止进行此转换以支持引用为此类后端所有小写的标识符。

这个 quoted_name 对象通常在指定键架构构造的名称时自动创建,例如 TableColumn 以及其他。类也可以显式地作为名称传递给任何接收可以引用的名称的函数。比如使用 Engine.has_table() 具有无条件引用名称的方法::

from sqlalchemy import create_engine
from sqlalchemy.sql import quoted_name

engine = create_engine("oracle+cx_oracle://some_dsn")
engine.has_table(quoted_name("some_table", True))

上面的逻辑将针对Oracle后端运行“has table”逻辑,并将名称 "some_table" 不转换为大写。

0.9.0 新版功能.

在 1.2 版更改: 这个 quoted_name 构造现在可从导入 sqlalchemy.sql ,除了之前的位置 sqlalchemy.sql.elements .

quote

字符串是否应无条件引用

class sqlalchemy.sql.expression.UnaryExpression(element, operator=None, modifier=None, type_=None, negate=None, wraps_column_expression=False)

基地: sqlalchemy.sql.expression.ColumnElement

定义“一元”表达式。

一元表达式有一个单列表达式和一个运算符。运算符可以放在列表达式的左侧(在这里称为“operator”)或右侧(在这里称为“modifier”)。

UnaryExpression 是几个一元运算符的基础,包括 desc()asc()distinct()nullsfirst()nullslast() .

compare(other, **kw)

比较一下 UnaryExpression 对给定的 ClauseElement .

get_children(**kwargs)

返回此的直接子元素 ClauseElement .

用于访问遍历。

* *Kwargs可能包含更改返回的集合的标志,例如返回项的子集以减少更大的遍历,或从不同上下文返回子项(例如架构级集合而不是子句级)。

self_group(against=None)

对此应用“分组” ClauseElement .

此方法被子类重写以返回“grouping”构造,即括号。尤其是“binary”表达式使用它在放入更大的表达式时提供围绕其自身的分组,以及 select() 当放入另一个的FROM子句时构造 select() . (请注意,通常应使用 Select.alias() 方法,因为许多平台都需要命名嵌套的select语句)。

当表达式组合在一起时,应用 self_group() 是自动的-最终用户代码不需要直接使用这个方法。请注意,sqlachemy的子句构造将运算符优先考虑在内,因此可能不需要括号,例如,在类似这样的表达式中 x OR (y AND z) -优先于或。

底座 self_group() 方法 ClauseElement 只需返回自我。