列元素和表达式

SQL表达式API最基本的部分是“列元素”，它允许基本的SQL表达式支持。所有SQL表达式结构的核心是ClauseElement，它是几个子分支的基础。ColumnElement类是用于构造任何类型的SQL表达式的基本单位。

sqlalchemy.sql.expression。 T0> 所有_ T1> （ T2> EXPR T3> ） T4> ¶< / T5>

产生一个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中的新功能

也可以看看

expression.any_()

sqlalchemy.sql.expression。 T0> 和_ T1> （ T2> *条款 T3> ） T4> ¶ T5>

Produce a conjunction of expressions joined by AND.

例如。：

from sqlalchemy import and_

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

使用Python &运算符也可以使用and_()连接符（但要注意复合表达式需要用括号括起来才能用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。 T0> 任何_ T1> （ T2> EXPR T3> ） T4> ¶< / T5>

产生一个ANY表达式。

这可能适用于某些方言的数组类型（例如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中的新功能

也可以看看

expression.all_()

sqlalchemy.sql.expression。 T0> ASC T1> （ T2> 列 T3> ） T4> ¶< / T5>

产生一个升序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()函数是所有SQL表达式上可用的ColumnElement.asc()方法的独立版本，例如：

stmt = select([users_table]).order_by(users_table.c.name.asc())
参数：column – A ColumnElement (e.g. scalar SQL expression) with which to apply the asc() operation.

也可以看看

desc()

nullsfirst()

nullslast()

Select.order_by()

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

The between() function is a standalone version of the ColumnElement.between() method available on all SQL expressions, as in:

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

如果值不是ColumnElement子类，则所有传递给()之间传递给between()例如，可以比较三个固定值，如下所示：

print(between(5, 3, 7))

这会产生：

:param_1 BETWEEN :param_2 AND :param_3
参数：
  • expr – a column expression, typically a ColumnElement instance or alternatively a Python scalar expression to be coerced into a column expression, serving as the left side of the BETWEEN expression.
  • lower_bound – a column or Python scalar expression serving as the lower bound of the right side of the BETWEEN expression.
  • upper_bound – a column or Python scalar expression serving as the upper bound of the right side of the BETWEEN expression.
  • symmetric -

    如果为True，则呈现“BETWEEN SYMMETRIC”。请注意，并非所有数据库都支持此语法。

    版本0.9.5中的新功能

也可以看看

ColumnElement.between()

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

产生一个“约束表达”。

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

在SQLAlchemy中，bindparam()构造能够携带将在表达时最终使用的实际值。通过这种方式，它不仅可以作为最终人口的“占位符”，还可以作为表示不应直接在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的Core表达式系统以隐含的意义广泛使用bindparam()。通常传递给几乎所有SQL表达式函数的Python文本值被强制转换为固定的bindparam()结构。例如，给定一个比较操作，例如：

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

The above expression will produce a BinaryExpression construct, where the left side is the Column object representing the name column, and the right side is a BindParameter representing the literal value:

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数据库。

同样，就“VALUES”部分而言，在使用CRUD语句时，会自动调用bindparam()。insert()结构会产生一个INSERT表达式，该表达式在语句执行时将根据传递的参数生成绑定占位符，如下所示：

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

以上将生成SQL输出为：

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

The Insert construct, at compilation/execution time, rendered a single bindparam() mirroring the column name name as a result of the single name parameter we passed to the Connection.execute() method.

参数：
  • key – the key (e.g. the name) for this bind param. 将在生成的SQL语句中用于使用命名参数的方言。如果其他BindParameter对象存在于同一个关键字中，或者其长度过长并且需要截断，则可能会修改此值。
  • value – Initial value for this bind param. 如果没有其他值针对此特定参数名称的语句执行方法指示，则将在语句执行时间用作传递给DBAPI的此参数的值。默认为None。
  • callable _ - 代替“value”的可调用函数。该函数将在语句执行时调用以确定最终值。用于在创建子句结构时无法确定实际绑定值的场景，但嵌入式绑定值仍然是可取的。
  • type _ -

    TypeEngine类或实例表示此bindparam()的可选数据类型。如果没有通过，基于给定的值可以自动确定绑定的类型；例如，诸如str，int，bool等普通Python类型可能会导致String，Integer或Boolean

    bindparam()的类型特别重要，因为类型将在将值传递到数据库之前对值进行预处理。例如，引用datetime值并指定为保存DateTime类型的bindparam()可以将所需的转换应用于该值（例如SQLite上的字符串化）在将值传递给数据库之前。

  • unique – if True, the key name of this BindParameter will be modified if another BindParameter of the same name already has been located within the containing expression. 当生成所谓的“匿名”绑定表达式时，这个标志一般由内部使用，它通常不适用于显式命名的bindparam()结构。
  • 必填 -

    如果True，则在执行时需要一个值。如果没有通过，如果bindparam.value或bindparam.callable都没有通过，则默认为True。如果其中任何一个参数存在，那么bindparam.required默认为False。

    在0.8版中更改：如果未指定required标志，它将自动设置为True或False取决于是否指定了value或callable参数。

  • quote – True if this parameter name requires quoting and is not currently known as a SQLAlchemy reserved word; this currently only applies to the Oracle backend, where bound names must sometimes be quoted.
  • isoutparam – if True, the parameter should be treated like a stored procedure “OUT” parameter. 这适用于支持OUT参数的后端，如Oracle。

也可以看看

Bind Parameter Objects

Insert Expressions

outparam()

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

产生一个CASE表达式。

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

case() in its usual form is passed a list of “when” constructs, that is, a list of conditions and results as tuples:

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

When simple equality expressions of several values against a single parent column are needed, case() also has a “shorthand” format used via the case.value parameter, which is passed a column expression to be compared. 在这种形式下，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 -

    The criteria to be compared against, case.whens accepts two different forms, based on whether or not case.value is used.

    In the first form, it accepts a list of 2-tuples; each 2-tuple consists of (<sql expression>, <value>), where the SQL expression is a boolean expression and “value” is a resulting value, e.g.:

    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 – An optional SQL expression which will be used as a fixed “comparison point” for candidate values within a dictionary passed to case.whens.
  • else_ – An optional SQL expression which will be the evaluated result of the CASE construct if all expressions within case.whens evaluate to false. 省略时，如果没有“when”表达式评估为true，大多数数据库将产生NULL结果。
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()函数在使用时执行两个不同的函数。首先是它在结果SQL字符串中呈现CAST表达式。The second is that it associates the given type (e.g. TypeEngine class or instance) with the column expression on the Python side, which means the expression will take on the expression operator behavior associated with that type, as well as the bound-value handling and result-row-handling behavior of the type.

版本0.9.0更改： cast()现在将给定类型应用于表达式，以使其对边界值生效。除了结果处理之外，Python到数据库的方向也是如此。数据库到Python，方向。

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

参数：
  • expression – A SQL expression, such as a ColumnElement expression or a Python string which will be coerced into a bound literal value.
  • type_ – A TypeEngine class or instance indicating the type to which the CAST should apply.

也可以看看

type_coerce() - 没有发射CAST的Python端类型强制。

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

Once constructed, column() may be used like any other SQL expression element such as within select() constructs:

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此外，完整的SQL语句最好使用text()结构进行处理。

column() can be used in a table-like fashion by combining it with the table() function (which is the lightweight analogue to Table) to produce a working table construct with minimal boilerplate:

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() construct like that illustrated above can be created in an ad-hoc fashion and is not associated with any schema.MetaData, DDL, or events, unlike its Table counterpart.

Changed in version 1.0.0: expression.column() can now be imported from the plain sqlalchemy namespace like any other SQL element.

参数：
  • 文本 - 元素的文本。
  • type – types.TypeEngine object which can associate this ColumnClause with a type.
  • is_literal – if True, the ColumnClause is assumed to be an exact expression that will be delivered to the output with no quoting rules applied regardless of case sensitive settings. the literal_column() function essentially invokes column() while passing is_literal=True.

也可以看看

Column

literal_column()

table()

text()

Using More Specific Text with table(), literal_column(), and column()中使用更多特定文本

sqlalchemy.sql.expression。 整理 （ 表达式，整理 ） T5> ¶ T6>

返回子句表达式 COLLATE 整理。

例如。：

collate(mycolumn, 'utf8_bin')

生产：

mycolumn COLLATE utf8_bin
sqlalchemy.sql.expression。 T0> 递减 T1> （ T2> 列 T3> ） T4> ¶< / T5>

产生一个降序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()函数是所有SQL表达式上可用的ColumnElement.desc()方法的独立版本，例如：

stmt = select([users_table]).order_by(users_table.c.name.desc())
参数：column – A ColumnElement (e.g. scalar SQL expression) with which to apply the desc() operation.

也可以看看

asc()

nullsfirst()

nullslast()

Select.order_by()

sqlalchemy.sql.expression。 T0> 不同 T1> （ T2> EXPR T3> ） T4> ¶< / T5>

生成列表达式级别的一元DISTINCT子句。

这将DISTINCT关键字应用于单个列表达式，并且通常包含在聚合函数中，如下所示：

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

以上将产生一个表达式，类似于：

SELECT COUNT(DISTINCT name) FROM user

The distinct() function is also available as a column-level method, e.g. ColumnElement.distinct(), as in:

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

distinct()运算符与Select的Select.distinct()方法不同，后者会生成SELECT将DISTINCT语句作为一个整体应用于结果集，例如一个SELECT DISTINCT表达式。请参阅该方法以获取更多信息。

也可以看看

ColumnElement.distinct()

Select.distinct()

func

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

返回一个Extract结构。

这通常可以从func命名空间中以extract()和func.extract的形式获得。

sqlalchemy.sql.expression。 T0> 假 T1> （ T2> ） T3> ¶ T4>

返回一个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

The true() and false() constants also feature “short circuit” operation within an and_() or or_() conjunction:

>>> 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 =＆lt； sqlalchemy.sql.functions._FunctionGenerator对象＆gt；

生成SQL函数表达式。

func是一个特殊的对象实例，它基于基于名称的属性生成SQL函数，例如：

>>> print(func.count(1))
count(:param_1)

该元素是一个像任何其他列一样的SQL元素，并且以这种方式使用：

>>> print(select([func.count(table.c.id)]))
SELECT count(sometable.id) FROM sometable

任何名字都可以给予func。如果函数名称对SQLAlchemy是未知的，它将完全按照原样呈现。对于SQLAlchemy知道的常用SQL函数，名称可能被解释为一个通用函数，它将被正确编译到目标数据库：

>>> print(func.current_timestamp())
CURRENT_TIMESTAMP

要调用点分隔包中存在的函数，请按照相同的方式指定它们：

>>> print(func.stats.yield_curve(5, 10))
stats.yield_curve(:yield_curve_1, :yield_curve_2)

可以使SQLAlchemy知道函数的返回类型，以启用特定于类型的词法和基于结果的行为。例如，要确保基于字符串的函数返回Unicode值并在表达式中将其类似地视为字符串，请将Unicode指定为类型：

>>> print(func.my_string(u'hi', type_=Unicode) + ' ' +
...       func.my_string(u'there', type_=Unicode))
my_string(:my_string_1) || :my_string_2 || my_string(:my_string_3)

由func调用返回的对象通常是Function的一个实例。此对象符合“列”界面，包括比较和标注功能。该对象还可以传递给Connection或Engine的execute()方法，在那里它首先被包装在SELECT语句中：

print(connection.execute(func.current_timestamp()).scalar())

在一些例外情况下，func访问器将把名称重定向到内置表达式，例如cast()或extract()因为这些名称具有众所周知的含义，但与SQLAlchemy透视图中的“函数”不完全相同。

版本0.8中的新功能 func可以返回常用准功能名称的非函数表达式结构，如cast()和extract()

被解释为“通用”函数的函数知道如何自动计算它们的返回类型。有关已知泛型函数的列表，请参阅SQL and Generic Functions。

注意

func构造仅有限地支持调用独立的“存储过程”，特别是那些有特殊参数化问题的构件。

有关如何将DBAPI级callproc()方法用于完全传统存储过程的详细信息，请参阅Calling Stored Procedures部分。

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

针对一个函数产生一个FunctionFilter对象。

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

例如。：

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

会产生“COUNT（1）FILTER（WHERE myclass.name ='某个名字'）”。

该函数也可以通过FunctionElement.filter()方法从func构造本身使用。

版本1.0.0中的新功能

也可以看看

FunctionElement.filter()

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

为给定的ColumnElement返回一个Label对象。

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

通过ColumnElement上的ColumnElement.label()方法可以更方便地使用此功能。

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

返回绑定到绑定参数的文字子句。

当非ClauseElement对象（例如字符串，整数，日期等）时，将自动创建文本子句。用于与ColumnElement子类的比较操作，例如Column对象。使用此函数强制生成一个文字子句，该子句将被创建为具有绑定值的BindParameter。

参数：
  • value – the value to be bound. 可以是底层DB-API支持的任何Python对象，也可以通过给定的类型参数进行翻译。
  • type_ – an optional TypeEngine which will provide bind-parameter translation for this literal.
sqlalchemy.sql.expression.literal_column(text, type_=None)

生成column.is_literal标志设置为True的ColumnClause对象。

literal_column() is similar to column(), except that it is more often used as a “standalone” column expression that renders exactly as stated; while column() stores a string name that will be assumed to be part of a table and may be quoted as such, literal_column() can be that, or any other arbitrary column-oriented expression.

参数：
  • 文本 - 表达式的文本；可以是任何SQL表达式。引用规则将不适用。要指定应受引用规则约束的列名称表达式，请使用column()函数。
  • type_ – an optional TypeEngine object which will provide result-set translation and additional expression semantics for this column. 如果保留为None，那么类型将是NullType。

也可以看看

column()

text()

Using More Specific Text with table(), literal_column(), and column()中使用更多特定文本

sqlalchemy.sql.expression。 T0> 不_ T1> （ T2> 子句 T3> ） T4> ¶< / T5>

返回给定子句的否定，即NOT(clause)。

所有ColumnElement子类中的~运算符也被重载，以产生相同的结果。

sqlalchemy.sql.expression。 T0> 空 T1> （ T2> ） T3> ¶ T4>

返回一个常量Null结构。

sqlalchemy.sql.expression。 T0> nullsfirst T1> （ T2> 列 T3> ） T4> ¶< / T5>

为ORDER BY t3生成NULLS FIRST >表达。

nullsfirst() is intended to modify the expression produced by asc() or desc(), and indicates how NULL values should be handled when they are encountered during ordering:

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

Like asc() and desc(), nullsfirst() is typically invoked from the column expression itself using ColumnElement.nullsfirst(), rather than as its standalone function version, as in:

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

也可以看看

asc()

desc()

nullslast()

Select.order_by()

sqlalchemy.sql.expression。 T0> nullslast T1> （ T2> 列 T3> ） T4> ¶< / T5>

为ORDER BY t3生成NULLS LAST >表达。

nullslast() is intended to modify the expression produced by asc() or desc(), and indicates how NULL values should be handled when they are encountered during ordering:

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

Like asc() and desc(), nullslast() is typically invoked from the column expression itself using ColumnElement.nullslast(), rather than as its standalone function version, as in:

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

也可以看看

asc()

desc()

nullsfirst()

Select.order_by()

sqlalchemy.sql.expression。 T0> 或_ T1> （ T2> *条款 T3> ） T4> ¶ T5>

生成由OR连接的表达式的连接。

例如。：

from sqlalchemy import or_

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

使用Python |运算符也可以使用or_()连接符（尽管注意复合表达式需要用括号括起来才能用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可以像常规函数参数一样使用。“output”值将通过其out_parameters属性从ResultProxy对象中提供，该属性返回包含这些值的字典。

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

针对函数生成Over对象。

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

over() is usually called using the FunctionElement.over() method, e.g.:

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

会产生：

ROW_NUMBER() OVER(ORDER BY some_column)

范围也可以使用expression.over.range_和expression.over.rows参数。这些互斥参数都接受一个2元组，它包含整数和None的组合：

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)

值None表示“无界限”，值为零表示“当前行”，负/正整数表示“之前”和“跟随”：

版本1.1中的新功能：支持窗口内的RANGE / ROWS

参数：
  • element – a FunctionElement, WithinGroup, or other compatible construct.
  • partition_by – a column element or string, or a list of such, that will be used as the PARTITION BY clause of the OVER construct.
  • order_by – a column element or string, or a list of such, that will be used as the ORDER BY clause of the OVER construct.
  • 范围_ -

    窗口的可选范围子句。这是一个元组值，它可以包含整数值或无，并将呈现一个RANGE BETWEEN PRECEDING / FOLLOWING子句

    版本1.1中的新功能

  • 行 -

    窗口的可选行子句。这是一个元组值，可以包含整数值或无，并将呈现ROWS BETWEEN PRECEDING / FOLLOWING子句。

    版本1.1中的新功能

该函数也可以通过FunctionElement.over()方法从func构造本身使用。

也可以看看

expression.func

expression.within_group()

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结构包含的方法可以提供有关绑定参数的信息，以及从文本语句中返回的列值（假设它是可执行的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)

当文本字符串SQL片段被指定为较大查询的一部分时（例如SELECT语句的WHERE子句），将使用text()结构：

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()方法。例如，可以使用Connection.execution_options.autocommit选项显式设置应该服从“autocommit”的text()结构：

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

Note that SQLAlchemy’s usual “autocommit” behavior applies to text() constructs implicitly - that is, statements which begin with a phrase such as INSERT, UPDATE, DELETE, or a variety of other phrases specific to certain backends, will be eligible for autocommit if no transaction is in progress.

参数：
  • text - 要创建的SQL语句的文本。使用:<param>指定绑定参数；它们将被编译为其引擎特定的格式。
  • autocommit - 弃用。Use .execution_options(autocommit=) to set the autocommit option.
  • bind – an optional connection or engine to be used for this text query.
  • bindparams -

    已过时。bindparam()实例的列表，用于提供有关嵌入语句中的参数的信息。该参数现在在返回之前调用构造上的TextClause.bindparams()方法。例如。：

    stmt = text("SELECT * FROM table WHERE id=:id",
          bindparams=[bindparam('id', value=5, type_=Integer)])

    相当于：

    stmt = text("SELECT * FROM table WHERE id=:id").\
          bindparams(bindparam('id', value=5, type_=Integer))

    Deprecated since version 0.9.0: the TextClause.bindparams() method supersedes the bindparams argument to text().

  • typemap -

    已过时。一个字典，它将SELECT语句的columns子句中表示的列的名称映射到类型对象，这些对象将用于对结果集中的列执行后处理。此参数现在调用TextClause.columns()方法，该方法返回一个获取.c集合的TextAsFrom结构，并且可以嵌入其他表达式。例如。：

    stmt = text("SELECT * FROM table",
              typemap={'id': Integer, 'name': String},
          )

    相当于：

    stmt = text("SELECT * FROM table").columns(id=Integer,
                                           name=String)

    或者：

    from sqlalchemy.sql import column
stmt = text("SELECT * FROM table").columns(
                      column('id', Integer),
                      column('name', String)
                  )

    Deprecated since version 0.9.0: the TextClause.columns() method supersedes the typemap argument to text().

也可以看看

Using Textual SQL - 在Core教程中

Using Textual SQL - in the ORM tutorial

sqlalchemy.sql.expression。 T0> 真 T1> （ T2> ） T3> ¶ T4>

返回一个常量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

The true() and false() constants also feature “short circuit” operation within an and_() or or_() conjunction:

>>> 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)

返回一个Tuple。

主要用途是生成一个复合IN构造：

from sqlalchemy import tuple_

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

警告

所有后端都不支持组合IN构造，目前已知可在Postgresql和MySQL上使用，但不支持SQLite。当这种表达式被调用时，不支持的后端会引发DBAPIError的子类。

sqlalchemy.sql.expression。 type_coerce （ 表达式，类型_ ） T5> ¶ T6>

将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 – A SQL expression, such as a ColumnElement expression or a Python string which will be coerced into a bound literal value.
  • type_ – A TypeEngine class or instance indicating the type to which the expression is coerced.

也可以看看

cast()

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

根据函数生成一个WithinGroup对象。

针对所谓的“有序集合”和“假设集合”功能，包括percentile_cont，rank，dense_rank等。

within_group() is usually called using the FunctionElement.within_group() method, e.g.:

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

The above statement would produce SQL similar to SELECT department.id, percentile_cont(0.5) WITHIN GROUP (ORDER BY department.salary DESC).

参数：
  • element – a FunctionElement construct, typically generated by func.
  • *order_by – one or more column elements that will be used as the ORDER BY clause of the WITHIN GROUP construct.

版本1.1中的新功能

也可以看看

expression.func

expression.over()

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

基础：sqlalchemy.sql.expression.ColumnElement

表示一个LEFT ＆lt；运算符＆gt； RIGHT的表达式。

每当在Python二进制表达式中使用两个列表达式时，会自动生成BinaryExpression：

>>> from sqlalchemy.sql import column
>>> column('a') + column('b')
<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>
>>> print column('a') + column('b')
a + b
比较 （ 其他，** kw ） t5 >

根据给定的BinaryExpression比较这个BinaryExpression。

class sqlalchemy.sql.expression。 BindParameter （ key，value =符号（'NO_ARG'），type_ = None，unique = False，required =符号（'NO_ARG'） quote = None，callable_ = None，isoutparam = False，_compared_to_operator = None，_compared_to_type = None T13> ） T14> ¶ T15>

基础：sqlalchemy.sql.expression.ColumnElement

代表“绑定表达”。

BindParameter is invoked explicitly using the bindparam() function, as in:

from sqlalchemy import bindparam

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

关于如何使用BindParameter的详细讨论位于bindparam()处。

也可以看看

bindparam()

__ init __ （ 键，value =符号（'NO_ARG'），type_ =无 t4 >，unique = False，required = symbol（'NO_ARG'），quote = None，callable_ = None ，isoutparam = False，_compared_to_operator = None，_compared_to_type = None ）

构建一个新的BindParameter对象。

这个构造函数被镜像为公共API函数；有关完整的用法和参数说明，请参阅bindparam()。

比较 （ 其他，** kw ） t5 >

将这个BindParameter与给定的子句进行比较。

effective_value T0> ¶ T1>

考虑是否设置了callable参数，返回此绑定参数的值。

The callable value will be evaluated and returned if present, else 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 ） T5> ¶ T6>

构建一个新的Case对象。

这个构造函数被镜像为公共API函数；有关完整的用法和参数说明，请参阅case()。

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()。

class sqlalchemy.sql.expression。 ClauseElement

基础：sqlalchemy.sql.visitors.Visitable

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

比较 （ 其他，** kw ） t5 >

将此ClauseElement与给定的ClauseElement进行比较。

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

** kw是由subclass compare()方法消耗的参数，可用于修改比较条件。（请参阅ColumnElement）

编译 （ bind = None，dialect = None，** kw ） T5> ¶ T6>

编译这个SQL表达式。

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

参数：
  • bind – An Engine or Connection from which a Compiled will be acquired. 这个参数优先于这个ClauseElement的绑定引擎，如果有的话。
  • column_keys – Used for INSERT and UPDATE statements, a list of column names which should be present in the VALUES clause of the compiled statement. 如果None，则呈现目标表格对象中的所有列。
  • dialect – A Dialect instance from which a Compiled will be acquired. 该参数优先于bind参数以及ClauseElement的绑定引擎（如果有的话）。
  • inline – Used for INSERT statements, for a dialect which does not support inline retrieval of newly generated primary key columns, will force the expression used to create the new primary key value to be rendered inline within the INSERT statement’s VALUES clause. 这通常是指序列执行，但也可能指与主键Column关联的任何服务器端默认生成函数。
  • compile_kwargs -

    在所有“访问”方法中将传递给编译器的附加参数的可选字典。例如，这允许将自定义标志传递给自定义编译构造。它也用于传递literal_binds标志的情况：

    from sqlalchemy.sql import table, column, select

t = table('t', column('x'))

s = select([t]).where(t.c.x == 5)

print s.compile(compile_kwargs={"literal_binds": True})

    版本0.9.0中的新功能

也可以看看

How do I render SQL expressions as strings, possibly with bound parameters inlined?

get_children T0> （ T1> ** kwargs T2> ） T3> ¶ T4>

返回这个ClauseElement的直接子元素。

这用于访问遍历。

** kwargs可能包含更改返回的集合的标志，例如为了减少更大的遍历而返回项目的子集，或者从不同的上下文返回子项目（例如模式级集合而不是子句-水平）。

params （ * optionaldict，** kwargs ） T5>

返回带有bindparam()元素的副本。

返回此ClauseElement的一个副本，其中bindparam()元素替换为从给定字典中取得的值：

>>> clause = column('x') + bindparam('foo')
>>> print clause.compile().params
{'foo':None}
>>> print clause.params({'foo':7}).compile().params
{'foo':7}
self_group T0> （ T1> 针对=无 T2> ） T3> ¶ T4>

对这个ClauseElement应用“分组”。

子类重写此方法以返回“分组”结构，即括号。In particular it’s used by “binary” expressions to provide a grouping around themselves when placed into a larger expression, as well as by select() constructs when placed into the FROM clause of another select(). （请注意，通常应使用Select.alias()方法创建子查询，因为许多平台需要命名嵌套的SELECT语句）。

由于表达式组合在一起，所以self_group()的应用程序是自动的 - 最终用户代码不需要直接使用此方法。Note that SQLAlchemy’s clause constructs take operator precedence into account - so parenthesis might not be needed, for example, in an expression like x OR (y AND z) - AND takes precedence over OR.

ClauseElement的base self_group()方法仅返回self。

unique_params （ * optionaldict，** kwargs ） T5>

返回带有bindparam()元素的副本。

与params()功能相同，除了将unique = True添加到受影响的绑定参数以便可以使用多个语句。

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

基础：sqlalchemy.sql.expression.ClauseElement

描述由操作员分隔的子句列表。

默认情况下，以逗号分隔，例如列列表。

比较 （ 其他，** kw ） t5 >

将这个ClauseList与给定的ClauseList进行比较，包括所有子句项的比较。

class sqlalchemy.sql.expression。 ColumnClause （ text，type_ =无，is_literal = False，_selectable =无 ）

基础：sqlalchemy.sql.expression.Immutable，sqlalchemy.sql.expression.ColumnElement

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

The ColumnClause, a lightweight analogue to the Column class, is typically invoked using the column() function, as in:

from sqlalchemy import column

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

上面的语句会产生如下的SQL：

SELECT id, name FROM user

ColumnClause is the immediate superclass of the schema-specific Column object. 尽管Column类具有与ColumnClause完全相同的功能，但在行为需求仅限于简单的情况下，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子句。

添加 T0> （ T1> 列 T2> ） T3> ¶ T4>

在此集合中添加一列。

该列的关键属性将用作此字典的散列键。

替换 T0> （ T1> 列 T2> ） T3> ¶ T4>

将给定的列添加到此集合中，删除此列的未认证版本以及具有相同密钥的现有列。

例如。：

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

将从集合中删除原来的'col1'，并在名称'columnname'下添加新列。

由schema.Column用于在表反射期间覆盖列。

class sqlalchemy.sql.expression。 ColumnElement

基础：sqlalchemy.sql.operators.ColumnOperators，sqlalchemy.sql.expression.ClauseElement

表示适用于“列”子句，WHERE子句等的面向列的SQL表达式的声明。

While the most familiar kind of ColumnElement is the Column object, ColumnElement serves as the basis for any unit that may be present in a SQL expression, including the expressions themselves, SQL functions, bound parameters, literal expressions, keywords such as NULL, etc. ColumnElement is the ultimate base class for all such elements.

各种各样的SQLAlchemy Core函数在SQL表达式级别工作，并且打算接受ColumnElement的实例作为参数。这些函数通常会记录他们接受“SQL表达式”作为参数。这对于SQLAlchemy来说意味着什么，通常是指一个输入，它既可以是一个ColumnElement对象，也可以是一个可以被强制为一个的值。关于SQL表达式的大部分（但不是全部）SQLAlchemy核心函数遵循的强制规则如下所示：

  • a literal Python value, such as a string, integer or floating point value, boolean, datetime, Decimal object, or virtually any other Python object, will be coerced into a “literal bound value”. This generally means that a bindparam() will be produced featuring the given value embedded into the construct; the resulting BindParameter object is an instance of ColumnElement. 在SQLAlchemy特定于类型的转换器（例如，Python）之后，Python的值最终会在执行时作为execute()或executemany()方法的参数化参数发送给DBAPI。由任何关联的TypeEngine对象提供的值）应用于该值。
  • 任何特殊的对象值，通常是ORM级别的构造，它们具有称为__clause_element__()的方法。当一个未知类型的对象被传递给一个将参数强制为一个ColumnElement表达式的函数时，Core表达式系统查找这个方法。__clause_element__()方法（如果存在）应该返回一个ColumnElement实例。The primary use of __clause_element__() within SQLAlchemy is that of class-bound attributes on ORM-mapped classes; a User class which contains a mapped attribute named .name will have a method User.name.__clause_element__() which when invoked returns the Column called name associated with the mapped table.
  • Python None值通常被解释为NULL，它在SQLAlchemy Core中生成null()的实例。

一个ColumnElement提供了使用Python表达式生成新的ColumnElement对象的能力。This means that Python operators such as ==, != and < are overloaded to mimic SQL operations, and allow the instantiation of further ColumnElement instances which are composed from other, more fundamental ColumnElement objects. 例如，可以将两个ColumnClause对象与加法运算符+一起添加以产生BinaryExpression。ColumnClause和BinaryExpression都是ColumnElement的子类：

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

也可以看看

Column

expression.column()

__当量__ T0> （ T1> 其他 T2> ） T3> ¶ T4>
继承自 __eq__() ColumnOperators

实施==运算符。

在列上下文中，生成子句a = b。If the target is None, produces a IS NULL.

__初始化__ T0> ¶ T1>
继承自 __init__ 属性 object

x .__ init __（...）初始化x；请参阅帮助（类型（x））进行签名

__文件__ T0> （ T1> 其他 T2> ） T3> ¶ T4>
inherited from the __le__() method of ColumnOperators

实现<=运算符。

在列上下文中，生成子句a <= b。

__ LT __ T0> （ T1> 其他 T2> ） T3> ¶ T4>
inherited from the __lt__() method of ColumnOperators

实现<运算符。

在列上下文中，生成子句a b。

__ NE __ T0> （ T1> 其他 T2> ） T3> ¶ T4>
inherited from the __ne__() method of ColumnOperators

实现!=运算符。

在列上下文中，生成子句a ！= b。If the target is None, produces a IS NOT NULL.

所有_ T0> （ T1> ） T2> ¶ T3>
继承自 all_() ColumnOperators

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

版本1.1中的新功能

anon_label T0> ¶ T1>

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

这是一个label()表达式，它将在编译时被命名。每次调用anon_label时都会返回相同的label()，以便表达式可以多次引用anon_label，并在编译时生成相同的标签名称。

编译器在编译时自动使用这个函数来表达已知为“未命名”的表达式，如二进制表达式和函数调用。

任何_ T0> （ T1> ） T2> ¶ T3>
inherited from the any_() method of ColumnOperators

针对父对象生成any_()子句。

版本1.1中的新功能

ASC T0> （ T1> ） T2> ¶ T3>
继承自 asc() ColumnOperators

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

base_columns T0> ¶ T1>
（ cleft，cright，symmetric = False T5> ¶ T6>
inherited from the between() method of ColumnOperators

在()子句之间针对父对象生成between()

绑定 =无
铸造 T0> （ T1> 类型_ T2> ） T3> ¶ T4>

制作一个类型演员，即CAST（＆lt； expression＆gt； AS ＆lt； type＆gt；）。

这是cast()函数的快捷方式。

版本1.0.7中的新功能

整理 T0> （ T1> 整理 T2> ） T3> ¶ T4>
inherited from the collate() method of ColumnOperators

根据给定的排序字符串，针对父对象生成一个collate()子句。

比较 T0> ¶ T1>
compare(other, use_proxies=False, equivalents=None, **kw)

将此ColumnElement与另一个进行比较。

特别理由：

参数：
  • use_proxies – when True, consider two columns that share a common base column as equivalent (i.e. shares_lineage())
  • equivalents – a dictionary of columns as keys mapped to sets of columns. 如果此字典中存在给定的“其他”列，则相应set()中的任何列都会通过比较测试，结果为True。这用于将比较扩展到可能通过外键或其他标准已知等效于此的其他列。
编译 （ bind = None，dialect = None，** kw ） T5> ¶ T6>
inherited from the compile() method of ClauseElement

编译这个SQL表达式。

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

参数：
  • bind – An Engine or Connection from which a Compiled will be acquired. 这个参数优先于这个ClauseElement的绑定引擎，如果有的话。
  • column_keys – Used for INSERT and UPDATE statements, a list of column names which should be present in the VALUES clause of the compiled statement. 如果None，则呈现目标表格对象中的所有列。
  • dialect – A Dialect instance from which a Compiled will be acquired. 该参数优先于bind参数以及ClauseElement的绑定引擎（如果有的话）。
  • inline – Used for INSERT statements, for a dialect which does not support inline retrieval of newly generated primary key columns, will force the expression used to create the new primary key value to be rendered inline within the INSERT statement’s VALUES clause. 这通常是指序列执行，但也可能指与主键Column关联的任何服务器端默认生成函数。
  • compile_kwargs -

    在所有“访问”方法中将传递给编译器的附加参数的可选字典。例如，这允许将自定义标志传递给自定义编译构造。它也用于传递literal_binds标志的情况：

    from sqlalchemy.sql import table, column, select

t = table('t', column('x'))

s = select([t]).where(t.c.x == 5)

print s.compile(compile_kwargs={"literal_binds": True})

    版本0.9.0中的新功能

也可以看看

How do I render SQL expressions as strings, possibly with bound parameters inlined?

的concat T0> （ T1> 其他 T2> ） T3> ¶ T4>
继承自 concat() ColumnOperators

实现'concat'操作符。

在列上下文中，生成子句a || b，或者使用concat()运算符在MySQL上。

包含 （ 其他，** kwargs ） >
inherited from the contains() method of ColumnOperators

实现'包含'运算符。

在列上下文中，生成子句LIKE '％＆lt； other＆gt；％'

递减 T0> （ T1> ） T2> ¶ T3>
继承自 desc() ColumnOperators

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

说明 =无
不同 T0> （ T1> ） T2> ¶ T3>
inherited from the distinct() method of ColumnOperators

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

endswith （ 其他，** kwargs ） t5 >
inherited from the endswith() method of ColumnOperators

实现'endswith'操作符。

在列上下文中，生成子句LIKE '％＆lt； other＆gt；

表达 T0> ¶ T1>

返回一个列表达式。

检查界面的一部分；回报自我。

foreign_keys = []
get_children T0> （ T1> ** kwargs T2> ） T3> ¶ T4>
inherited from the get_children() method of ClauseElement

返回这个ClauseElement的直接子元素。

这用于访问遍历。

** kwargs可能包含更改返回的集合的标志，例如为了减少更大的遍历而返回项目的子集，或者从不同的上下文返回子项目（例如模式级集合而不是子句-水平）。

ilike （ 其他，escape =无 ） t5 >
inherited from the ilike() method of ColumnOperators

实现ilike运算符。

在列上下文中，生成子句a ILIKE 其他。

例如。：

select([sometable]).where(sometable.c.column.ilike("%foobar%"))
参数：
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符，呈现ESCAPE关键字，例如：

    somecolumn.ilike("foo/%bar", escape="/")

也可以看看

ColumnOperators.like()

在_ T0> （ T1> 其他 T2> ） T3> ¶ T4>
inherited from the in_() method of ColumnOperators

在运算符中实现in

在列上下文中，生成子句a IN 其他。“other”可以是列表达式的元组/列表，或者是select()结构。

是_ T0> （ T1> 其他 T2> ） T3> ¶ T4>
inherited from the is_() method of ColumnOperators

实现IS运算符。

通常，当与None的值进行比较时，会自动生成IS，这会解析为NULL。但是，如果与某些平台上的布尔值进行比较，则可能需要明确使用IS。

New in version 0.7.9.

也可以看看

ColumnOperators.isnot()

is_clause_element = True
is_distinct_from T0> （ T1> 其他 T2> ） T3> ¶ T4>
继承自 is_distinct_from() 方法 tt> ColumnOperators

实现IS DISTINCT FROM运算符。

在大多数平台上呈现“一个IS DISTINCT FROM b”；在一些如SQLite可能会呈现“一个不是b”。

版本1.1中的新功能

is_selectable = False
IsNot运算 T0> （ T1> 其他 T2> ） T3> ¶ T4>
inherited from the isnot() method of ColumnOperators

实现IS NOT运算符。

Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. 但是，如果与某些平台上的布尔值进行比较，则可能需要明确使用IS NOT。

New in version 0.7.9.

也可以看看

ColumnOperators.is_()

isnot_distinct_from T0> （ T1> 其他 T2> ） T3> ¶ T4>
继承自 isnot_distinct_from() ColumnOperators

实现IS NOT DISTINCT FROM运算符。

在大多数平台上呈现“不是从BIND DISTINCT FROM b”；在某些例如SQLite上可能会呈现“a IS b”。

版本1.1中的新功能

键 =无

在某些情况下在Python命名空间中引用该对象的'关键'。

这典型地指的是存在于可选择的例如.c集合中的列的“关键字”。 sometable.c [“somekey”]会返回一个带有“somekey”.key的Column。

标签 T0> （ T1> 名称 T2> ） T3> ¶ T4>

生成列标签，即＆lt； columnname＆gt； AS ＆lt； name＆gt；。

这是label()函数的快捷方式。

如果'名称'是None，则会生成一个匿名标签名称。

像 （ 其他，escape =无 ） t5 >
inherited from the like() method of ColumnOperators

像运算符一样实现like

在列上下文中，生成子句a LIKE 其他。

例如。：

select([sometable]).where(sometable.c.column.like("%foobar%"))
参数：
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符，呈现ESCAPE关键字，例如：

    somecolumn.like("foo/%bar", escape="/")

也可以看看

ColumnOperators.ilike()

匹配 （ 其他，** kwargs ） t5 >
继承自 match() 方法 tt> ColumnOperators

实现数据库特定的“匹配”运算符。

match() attempts to resolve to a MATCH-like function or operator provided by the backend. 例子包括：

  • Postgresql - 呈现x @@ to_tsquery（y）
  • MySQL - renders MATCH (x) AGAINST (y IN BOOLEAN MODE)
  • Oracle - 呈现CONTAINS（x， y）
  • 其他后端可能会提供特殊的实现。
  • 没有任何特殊实现的后端会将操作符发送为“MATCH”。例如，这与SQlite兼容。
notilike(other, escape=None)
inherited from the notilike() method of ColumnOperators

执行NOT ILIKE运算符。

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

0.8版本中的新功能

也可以看看

ColumnOperators.ilike()

notin _ T0> （ T1> 其他 T2> ） T3> ¶ T4>
继承自 notin_() 方法 ColumnOperators

执行NOT IN运算符。

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

0.8版本中的新功能

也可以看看

ColumnOperators.in_()

notlike （ 其他，转义=无 ） t5 >
inherited from the notlike() method of ColumnOperators

执行NOT LIKE运算符。

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

0.8版本中的新功能

也可以看看

ColumnOperators.like()

nullsfirst T0> （ T1> ） T2> ¶ T3>
inherited from the nullsfirst() method of ColumnOperators

针对父对象生成nullsfirst()子句。

nullslast T0> （ T1> ） T2> ¶ T3>
继承自 nullslast() ColumnOperators

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

op （ opstring，precedence = 0，is_comparison = False ） T5> ¶ T6>
继承自 op() 方法的Operators

产生通用的操作员功能。

例如。：

somecolumn.op("*")(5)

生产：

somecolumn * 5

该函数也可用于使按位运算符明确。例如：

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

是somecolumn中的值的按位与。

参数：
  • operator – a string which will be output as the infix operator between this element and the expression passed to the generated function.
  • 优先顺序 -

    当对表达式加括号时，优先级适用于运算符。较低的数字将使表达式在针对具有较高优先级的另一个运算符应用时加括号。除了逗号（,）和AS运算符以外，0的默认值低于所有运算符。100的值将会高于或等于所有操作员，-100将低于或等于所有操作员。

    New in version 0.8: - added the ‘precedence’ argument.

  • is_comparison -

    如果为True，那么该运算符将被视为“比较”运算符，即，其计算结果为boolean true / false值，如==，>等。应该设置此标志，以便ORM关系可以确定运算符在自定义连接条件中使用时是比较运算符。

    版本0.9.2新增： - 添加了Operators.op.is_comparison标志。

也可以看看

Redefining and Creating New Operators

Using custom operators in join conditions中使用自定义运算符

操作 tt> （ op，*其他，** kwargs / T5> ¶ T6>
params （ * optionaldict，** kwargs ） T5>
inherited from the params() method of ClauseElement

返回带有bindparam()元素的副本。

返回此ClauseElement的一个副本，其中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 T0> ¶ T1>
reverse_operate （ op，其他，** kwargs T5> ¶ T6>
self_group T0> （ T1> 针对=无 T2> ） T3> ¶ T4>
shares_lineage T0> （ T1> othercolumn T2> ） T3> ¶ T4>

如果给定的ColumnElement与此ColumnElement具有共同的祖先，则返回True。

startswith （ 其他，** kwargs ） ¶ t5 >
inherited from the startswith() method of ColumnOperators

实现startwith运算符。

在列上下文中，生成子句LIKE '＆lt； other＆gt；％'

supports_execution = False
timetuple =无
型 T0> ¶ T1>
unique_params （ * optionaldict，** kwargs ） T5>
inherited from the unique_params() method of ClauseElement

返回带有bindparam()元素的副本。

与params()功能相同，除了将unique = True添加到受影响的绑定参数以便可以使用多个语句。

class sqlalchemy.sql.operators。 ColumnOperators

基础：sqlalchemy.sql.operators.Operators

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

默认情况下，所有方法调用operate()或reverse_operate()，从Python内置operator模块传递相应的运算符函数或来自sqlalchemy.expression.operators的SQLAlchemy特定操作符函数。例如__eq__函数：

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

其中operators.eq基本上是：

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

核心列表达式单元ColumnElement覆盖Operators.operate()等等，以进一步返回ColumnElement结构，以便==

也可以看看：

Redefining and Creating New Operators

TypeEngine.comparator_factory

ColumnOperators

PropComparator

__添加__ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实施+运算符。

在列上下文中，如果父对象具有非字符串亲和性，则会生成子句a + b。If the parent object has a string affinity, produces the concatenation operator, a || b - see ColumnOperators.concat().

__和__ T0> （ T1> 其他 T2> ） T3> ¶ T4>
继承自 Operators的 __and__()

实施&运算符。

与SQL表达式一起使用时，会产生AND操作，等同于and_()，即：

a & b

相当于：

from sqlalchemy import and_
and_(a, b)

在使用&时应注意操作符的优先级； &运算符的优先级最高。如果操作数包含更多的子表达式，则应将其括在括号中：

(a == 2) & (b == 4)
__ delattr __ T0> ¶ T1>
继承自 __delattr__ 属性 object

x .__ delattr __（'name'）<==> del x.name

__ DIV __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实施/运算符。

在列上下文中，生成子句a / b。

__当量__ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实施==运算符。

在列上下文中，生成子句a = b。If the target is None, produces a IS NULL.

__格式__ T0> （ T1> ） T2> ¶ T3>
继承自 __format__() object

默认对象格式化程序

__ GE __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实施>=运算符。

在列上下文中，生成子句a ＆gt； = b。

__的getAttribute __ T0> ¶ T1>
继承自 __getattribute__ 属性 object

x .__ getattribute __（'name'）<==> x.name

__的GetItem __ T0> （ T1> 索引 T2> ） T3> ¶ T4>

实现[]运算符。

这可以被一些特定于数据库的类型使用，例如Postgresql ARRAY和HSTORE。

__ GT __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实施>运算符。

在列上下文中，生成子句a ＆gt； b。

__散列__ T0> ¶ T1>
__初始化__ T0> ¶ T1>
继承自 __init__ 属性 object

x .__ init __（...）初始化x；请参阅帮助（类型（x））进行签名

__反相__ T0> （ T1> ） T2> ¶ T3>
inherited from the __invert__() method of Operators

实施~运算符。

与SQL表达式一起使用时，结果为NOT操作，相当于not_()，即：

~a

相当于：

from sqlalchemy import not_
not_(a)
__文件__ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实现<=运算符。

在列上下文中，生成子句a <= b。

__ LSHIFT __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

执行<

没有被SQLAlchemy核心使用，这是为想要使用<

__ LT __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实现<运算符。

在列上下文中，生成子句a b。

__ MOD __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实施%运算符。

在列上下文中，生成子句a ％ b。

__ MUL __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实现*运算符。

在列上下文中，生成子句a * b。

__ NE __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实现!=运算符。

在列上下文中，生成子句a ！= b。If the target is None, produces a IS NOT NULL.

__ NEG __ T0> （ T1> ） T2> ¶ T3>

实施-运算符。

在列上下文中，生成子句-a。

__new__(S, ...) → a new object with type S, a subtype of T
inherited from the __new__() method of object
__或__ T0> （ T1> 其他 T2> ） T3> ¶ T4>
继承自 Operators的 __or__()

实施|运算符。

与SQL表达式一起使用时，会产生OR操作，等同于or_()，即：

a | b

相当于：

from sqlalchemy import or_
or_(a, b)

在使用|时应注意运营商的优先级； |运算符的优先级最高。如果操作数包含更多的子表达式，则应将其括在括号中：

(a == 2) | (b == 4)
__ RADD __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

反向实施+运算符。

参见ColumnOperators.__add__()。

__ RDIV __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

反向实施/运算符。

请参阅ColumnOperators.__div__()。

__减少__ T0> （ T1> ） T2> ¶ T3>
继承自 object的 __reduce__() 方法

腌菜的帮手

__ reduce_ex __ T0> （ T1> ） T2> ¶ T3>
inherited from the __reduce_ex__() method of object

腌菜的帮手

__再版__ T0> ¶ T1>
继承自 __repr__ 属性 object
__ RMOD __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

反过来实施%运算符。

参见ColumnOperators.__mod__()。

__ RMUL __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

反向实施*运算符。

参见ColumnOperators.__mul__()。

__ RSHIFT __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

执行>>操作符。

SQLAlchemy核心不使用它，这是为想要使用>>作为扩展点的自定义操作系统提供的。

__ RSUB __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

反过来实施-运算符。

参见ColumnOperators.__sub__()。

__ rtruediv __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

反向实施//运算符。

参见ColumnOperators.__truediv__()。

__ SETATTR __ T0> ¶ T1>
继承自 __setattr__ 属性 object

x .__ setattr __（'name'，value）<==> x.name = value

__ sizeof __ （ ）→int
继承自 object的 __sizeof__() 方法

内存中对象的大小，以字节为单位

__ STR __ T0> ¶ T1>
继承 object的 __str__ 属性
__子__ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实施-运算符。

在列上下文中，生成子句a - b。

__ subclasshook __ T0> （ T1> ） T2> ¶ T3>
继承自 __subclasshook__() 方法 object

抽象类可以覆盖它来自定义issubclass()。

这是由abc.ABCMeta .__子类检查__()在早期调用的。它应该返回True，False或NotImplemented。如果它返回NotImplemented，则使用正常算法。否则，它会覆盖正常的算法（并且结果被缓存）。

__ truediv __ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实现//运算符。

在列上下文中，生成子句a / b。

所有_ T0> （ T1> ） T2> ¶ T3>

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

版本1.1中的新功能

任何_ T0> （ T1> ） T2> ¶ T3>

针对父对象生成any_()子句。

版本1.1中的新功能

ASC T0> （ T1> ） T2> ¶ T3>

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

（ cleft，cright，symmetric = False T5> ¶ T6>

在()子句之间针对父对象生成between()

整理 T0> （ T1> 整理 T2> ） T3> ¶ T4>

根据给定的排序字符串，针对父对象生成一个collate()子句。

的concat T0> （ T1> 其他 T2> ） T3> ¶ T4>

实现'concat'操作符。

在列上下文中，生成子句a || b，或者使用concat()运算符在MySQL上。

包含 （ 其他，** kwargs ） >

实现'包含'运算符。

在列上下文中，生成子句LIKE '％＆lt； other＆gt；％'

递减 T0> （ T1> ） T2> ¶ T3>

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

不同 T0> （ T1> ） T2> ¶ T3>

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

endswith （ 其他，** kwargs ） t5 >

实现'endswith'操作符。

在列上下文中，生成子句LIKE '％＆lt； other＆gt；

ilike （ 其他，escape =无 ） t5 >

实现ilike运算符。

在列上下文中，生成子句a ILIKE 其他。

例如。：

select([sometable]).where(sometable.c.column.ilike("%foobar%"))
参数：
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符，呈现ESCAPE关键字，例如：

    somecolumn.ilike("foo/%bar", escape="/")

也可以看看

ColumnOperators.like()

在_ T0> （ T1> 其他 T2> ） T3> ¶ T4>

在运算符中实现in

在列上下文中，生成子句a IN 其他。“other”可以是列表达式的元组/列表，或者是select()结构。

是_ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实现IS运算符。

通常，当与None的值进行比较时，会自动生成IS，这会解析为NULL。但是，如果与某些平台上的布尔值进行比较，则可能需要明确使用IS。

New in version 0.7.9.

也可以看看

ColumnOperators.isnot()

is_distinct_from T0> （ T1> 其他 T2> ） T3> ¶ T4>

实现IS DISTINCT FROM运算符。

在大多数平台上呈现“一个IS DISTINCT FROM b”；在一些如SQLite可能会呈现“一个不是b”。

版本1.1中的新功能

IsNot运算 T0> （ T1> 其他 T2> ） T3> ¶ T4>

实现IS NOT运算符。

Normally, IS NOT is generated automatically when comparing to a value of None, which resolves to NULL. 但是，如果与某些平台上的布尔值进行比较，则可能需要明确使用IS NOT。

New in version 0.7.9.

也可以看看

ColumnOperators.is_()

isnot_distinct_from T0> （ T1> 其他 T2> ） T3> ¶ T4>

实现IS NOT DISTINCT FROM运算符。

在大多数平台上呈现“不是从BIND DISTINCT FROM b”；在某些例如SQLite上可能会呈现“a IS b”。

版本1.1中的新功能

像 （ 其他，escape =无 ） t5 >

像运算符一样实现like

在列上下文中，生成子句a LIKE 其他。

例如。：

select([sometable]).where(sometable.c.column.like("%foobar%"))
参数：
  • 其他 - 要比较的表达式
  • 转义 -

    可选的转义字符，呈现ESCAPE关键字，例如：

    somecolumn.like("foo/%bar", escape="/")

也可以看看

ColumnOperators.ilike()

匹配 （ 其他，** kwargs ） t5 >

实现数据库特定的“匹配”运算符。

match() attempts to resolve to a MATCH-like function or operator provided by the backend. 例子包括：

  • Postgresql - 呈现x @@ to_tsquery（y）
  • MySQL - renders MATCH (x) AGAINST (y IN BOOLEAN MODE)
  • Oracle - 呈现CONTAINS（x， y）
  • 其他后端可能会提供特殊的实现。
  • 没有任何特殊实现的后端会将操作符发送为“MATCH”。例如，这与SQlite兼容。
notilike(other, escape=None)

执行NOT ILIKE运算符。

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

0.8版本中的新功能

也可以看看

ColumnOperators.ilike()

notin _ T0> （ T1> 其他 T2> ） T3> ¶ T4>

执行NOT IN运算符。

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

0.8版本中的新功能

也可以看看

ColumnOperators.in_()

notlike （ 其他，转义=无 ） t5 >

执行NOT LIKE运算符。

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

0.8版本中的新功能

也可以看看

ColumnOperators.like()

nullsfirst T0> （ T1> ） T2> ¶ T3>

针对父对象生成nullsfirst()子句。

nullslast T0> （ T1> ） T2> ¶ T3>

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

op （ opstring，precedence = 0，is_comparison = False ） T5> ¶ T6>
继承自 op() 方法的Operators

产生通用的操作员功能。

例如。：

somecolumn.op("*")(5)

生产：

somecolumn * 5

该函数也可用于使按位运算符明确。例如：

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

是somecolumn中的值的按位与。

参数：
  • operator – a string which will be output as the infix operator between this element and the expression passed to the generated function.
  • 优先顺序 -

    当对表达式加括号时，优先级适用于运算符。较低的数字将使表达式在针对具有较高优先级的另一个运算符应用时加括号。除了逗号（,）和AS运算符以外，0的默认值低于所有运算符。100的值将会高于或等于所有操作员，-100将低于或等于所有操作员。

    New in version 0.8: - added the ‘precedence’ argument.

  • is_comparison -

    如果为True，那么该运算符将被视为“比较”运算符，即，其计算结果为boolean true / false值，如==，>等。应该设置此标志，以便ORM关系可以确定运算符在自定义连接条件中使用时是比较运算符。

    版本0.9.2新增： - 添加了Operators.op.is_comparison标志。

也可以看看

Redefining and Creating New Operators

Using custom operators in join conditions中使用自定义运算符

操作 tt> （ op，*其他，** kwargs / T5> ¶ T6>
继承自 operate() 方法 Operators

操作一个参数。

这是最低级别的操作，缺省情况下会引发NotImplementedError。

在子类上覆盖它可以使普通行为适用于所有操作。例如，覆盖ColumnOperators将func.lower()应用于左侧和右侧：

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数：
  • op - 操作员可调用。
  • *其他 - 操作的“其他”一侧。对于大多数操作来说，这将是一个单一的标量。
  • ** kwargs - 修饰符。这些可以由特殊的操作符传递，如ColumnOperators.contains()。
reverse_operate （ op，其他，** kwargs T5> ¶ T6>
inherited from the reverse_operate() method of Operators

对参数进行反向操作。

用法与operate()相同。

startswith （ 其他，** kwargs ） ¶ t5 >

实现startwith运算符。

在列上下文中，生成子句LIKE '＆lt； other＆gt；％'

timetuple =无

Hack，允许在LHS上比较日期时间对象。

class sqlalchemy.sql.base。 DialectKWArgs

建立一个具有缺省和构造函数验证的特定方言参数的类的能力。

The DialectKWArgs interacts with the DefaultDialect.construct_arguments present on a dialect.

也可以看看

DefaultDialect.construct_arguments

classmethod argument_for(dialect_name, argument_name, default)

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

例如。：

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

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

The DialectKWArgs.argument_for() method is a per-argument way adding extra arguments to the DefaultDialect.construct_arguments dictionary. 这本词典提供了代表方言的各种模式层次结构所接受的参数名称列表。

新方言通常应该一次性将该字典指定为方言类的数据成员。用于临时添加参数名称的用例通常用于最终用户代码，该代码也使用了使用额外参数的自定义编译方案。

参数：
  • dialect_name – name of a dialect. The dialect must be locatable, else a NoSuchModuleError is raised. 该方言还必须包含一个现有的DefaultDialect.construct_arguments集合，指示它参与关键字参数验证和默认系统，否则引发ArgumentError。如果方言不包括这个集合，那么任何关键字参数都可以代表这个方言指定。所有包含在SQLAlchemy中的方言都包含这个集合，但是对于第三方方言，支持可能会有所不同。
  • argument_name - 参数的名称。
  • 默认 - 参数的默认值。

版本0.9.4中的新功能

dialect_kwargs T0> ¶ T1>

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

这些参数在它们的原始<dialect>_<kwarg>格式中呈现。只包括实际通过的论点；不同于DialectKWArgs.dialect_options集合，其中包含此方言已知的所有选项，包括默认值。

该集合也是可写的；键被接受为形式<dialect>_<kwarg>，其中值将被组合到选项列表中。

版本0.9.2中的新功能

在版本0.9.4中更改： DialectKWArgs.dialect_kwargs集合现在可写入。

也可以看看

DialectKWArgs.dialect_options - nested dictionary form

dialect_options T0> ¶ T1>

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

这是一个两级嵌套注册表，键入<dialect_name>和<argument_name>。例如，postgresql_where参数可以定位为：

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

版本0.9.2中的新功能

也可以看看

DialectKWArgs.dialect_kwargs - flat dictionary form

kwargs T0> ¶ T1>

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()。

class sqlalchemy.sql.elements。 False _

基础：sqlalchemy.sql.expression.ColumnElement

在SQL语句中表示false关键字或等效项。

False_通过false()函数作为常量访问。

class sqlalchemy.sql.expression。 FunctionFilter （ func，*标准 T5> ） T6> ¶ T7>

基础：sqlalchemy.sql.expression.ColumnElement

表示一个函数FILTER子句。

这是一个针对聚集和窗口函数的特殊操作符，它控制将哪些行传递给它。它仅受特定数据库后端支持。

通过FunctionElement.filter()调用FunctionFilter：

func.count(1).filter(True)

版本1.0.0中的新功能

也可以看看

FunctionElement.filter()

__init__(func, *criterion)

构造一个新的FunctionFilter对象。

这个构造函数被镜像为公共API函数；有关完整的用法和参数说明，请参阅funcfilter()。

过滤 T0> （ T1> *标准 T2> ） T3> ¶ T4>

针对该功能生成额外的FILTER。

此方法将附加条件添加到由FunctionElement.filter()设置的初始条件中。

多个标准通过AND在SQL呈现时间连接在一起。

over(partition_by=None, order_by=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()。

class sqlalchemy.sql.elements。 空

基础：sqlalchemy.sql.expression.ColumnElement

在SQL语句中表示NULL关键字。

Null通过null()函数作为常量访问。

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()。

FUNC T0> ¶ T1>

由Over子句引用的元素。

从版本1.1开始弃用： func元素已被重命名为.element。虽然.func是只读的，但这两个属性是同义词。

class sqlalchemy.sql.expression。 TextClause （ text，=无 T5> ） T6> ¶ T7>

基础：sqlalchemy.sql.expression.Executable，sqlalchemy.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 ） T5>

在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))

Where above, new BindParameter objects will be generated with the names name and timestamp, and values of jack and datetime.datetime(2012, 10, 8, 15, 12, 5), respectively. 类型将根据给出的值推断，在这种情况下String和DateTime。

当需要特定的键入行为时，可以使用位置*binds参数来直接指定bindparam()结构。这些结构必须至少包含key参数，然后是可选值和类型：

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

在上面，我们为timestamp绑定指定了DateTime的类型，name绑定的String的类型。在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)
)

New in version 0.9.0: The TextClause.bindparams() method supersedes the argument bindparams passed to text().

列 （ * cols，**类型 ） T5>

将此TextClause对象转换为可以嵌入到另一个语句中的TextAsFrom对象。

这个函数基本上弥补了完全文本的SELECT语句和“可选择”的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列集合中的第一个类元素，就像任何其他可选元素一样。

The column expressions we pass to TextClause.columns() may also be typed; when we do so, these TypeEngine objects become the effective return type of the column, so that SQLAlchemy’s result-set-processing systems may be used on the return values. 对于类型（如日期或布尔类型）以及某些方言配置上的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)

New in version 0.9.0: text() can now be converted into a fully featured “selectable” construct using the TextClause.columns() method. 此方法取代text()的typemap参数。

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

基础：sqlalchemy.sql.expression.ClauseList，sqlalchemy.sql.expression.ColumnElement

表示一个SQL元组。

__ init __ （ *子句，** kw ） T5>

构建一个新的Tuple对象。

这个构造函数被镜像为公共API函数；有关完整的用法和参数说明，请参阅tuple_()。

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

基础：sqlalchemy.sql.expression.ColumnElement

代表一个WITHIN GROUP（ORDER BY）子句。

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

它仅受特定数据库后端支持，如PostgreSQL，Oracle和MS SQL Server。

WithinGroup构造从方法FunctionElement.within_group_type()中提取它的类型。如果返回None，则使用函数的.type。

__ init __ （ 元素，* order_by ）

构建一个新的WithinGroup对象。

这个构造函数被镜像为公共API函数；有关完整的用法和参数说明，请参见within_group()。

over(partition_by=None, order_by=None)

根据WithinGroup结构产生一个OVER子句。

该函数具有与FunctionElement.over()相同的签名。

class sqlalchemy.sql.elements。 True _

基础：sqlalchemy.sql.expression.ColumnElement

在SQL语句中表示true关键字或等效项。

True_ is accessed as a constant via the true() function.

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

基础：sqlalchemy.sql.expression.ColumnElement

表示一个Python端的类型强制包装器。

TypeCoerce supplies the expression.type_coerce() function; see that function for usage details.

在版本1.1中更改： type_coerce()函数现在生成一个持久化的TypeCoerce包装器对象，而不是将给定的对象就地转换。

也可以看看

expression.type_coerce()

__init__(expression, type_)

构建一个新的TypeCoerce对象。

这个构造函数被镜像为公共API函数；有关完整的用法和参数说明，请参阅type_coerce()。

class sqlalchemy.sql.operators。 custom_op （ opstring，precedence = 0，is_comparison = False，natural_self_precedent = False ）

代表一个'自定义'操作符。

当使用ColumnOperators.op()方法创建自定义操作符可调用时，custom_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。 运算符

比较基础和逻辑运算符。

Implements base methods operate() and reverse_operate(), as well as __and__(), __or__(), __invert__().

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

__和__ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实施&运算符。

与SQL表达式一起使用时，会产生AND操作，等同于and_()，即：

a & b

相当于：

from sqlalchemy import and_
and_(a, b)

在使用&时应注意操作符的优先级； &运算符的优先级最高。如果操作数包含更多的子表达式，则应将其括在括号中：

(a == 2) & (b == 4)
__反相__ T0> （ T1> ） T2> ¶ T3>

实施~运算符。

与SQL表达式一起使用时，结果为NOT操作，相当于not_()，即：

~a

相当于：

from sqlalchemy import not_
not_(a)
__或__ T0> （ T1> 其他 T2> ） T3> ¶ T4>

实施|运算符。

与SQL表达式一起使用时，会产生OR操作，等同于or_()，即：

a | b

相当于：

from sqlalchemy import or_
or_(a, b)

在使用|时应注意运营商的优先级； |运算符的优先级最高。如果操作数包含更多的子表达式，则应将其括在括号中：

(a == 2) | (b == 4)
op （ opstring，precedence = 0，is_comparison = False ） T5> ¶ T6>

产生通用的操作员功能。

例如。：

somecolumn.op("*")(5)

生产：

somecolumn * 5

该函数也可用于使按位运算符明确。例如：

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

是somecolumn中的值的按位与。

参数：
  • operator – a string which will be output as the infix operator between this element and the expression passed to the generated function.
  • 优先顺序 -

    当对表达式加括号时，优先级适用于运算符。较低的数字将使表达式在针对具有较高优先级的另一个运算符应用时加括号。除了逗号（,）和AS运算符以外，0的默认值低于所有运算符。100的值将会高于或等于所有操作员，-100将低于或等于所有操作员。

    New in version 0.8: - added the ‘precedence’ argument.

  • is_comparison -

    如果为True，那么该运算符将被视为“比较”运算符，即，其计算结果为boolean true / false值，如==，>等。应该设置此标志，以便ORM关系可以确定运算符在自定义连接条件中使用时是比较运算符。

    版本0.9.2新增： - 添加了Operators.op.is_comparison标志。

也可以看看

Redefining and Creating New Operators

Using custom operators in join conditions中使用自定义运算符

操作 tt> （ op，*其他，** kwargs / T5> ¶ T6>

操作一个参数。

这是最低级别的操作，缺省情况下会引发NotImplementedError。

在子类上覆盖它可以使普通行为适用于所有操作。例如，覆盖ColumnOperators将func.lower()应用于左侧和右侧：

class MyComparator(ColumnOperators):
    def operate(self, op, other):
        return op(func.lower(self), func.lower(other))
参数：
  • op - 操作员可调用。
  • *其他 - 操作的“其他”一侧。对于大多数操作来说，这将是一个单一的标量。
  • ** kwargs - 修饰符。这些可以由特殊的操作符传递，如ColumnOperators.contains()。
reverse_operate （ op，其他，** kwargs T5> ¶ T6>

对参数进行反向操作。

用法与operate()相同。

class sqlalchemy.sql.elements。 quoted_name

基础：sqlalchemy.util.langhelpers.MemoizedSlots，__builtin__.unicode

用一个引用首选项来表示一个SQL标识符。

quoted_name是一个Python unicode / str子类，它表示一个特定的标识符名称和一个quote标志。当设置为True或False时，quote标志会覆盖此标识符的自动引用行为，以便无条件引用或不引用名称。如果保留默认值None，则基于对令牌本身的检查，将引用行为应用于每个后端基础上的标识符。

quote=True的quoted_name对象也可以防止在所谓的“name normalize”选项中被修改。某些数据库后端（如Oracle，Firebird和DB2）将大小写不区分大小写的名称“归一化”。这些后端的SQLAlchemy方言可以从SQLAlchemy的小写方式不敏感约定转换为这些后端的大小写不敏感约定。这里的quote=True标志将阻止这种转换发生，以支持被标记为全部小写字母的标识符。

指定Table，Column等关键架构结构的名称时，通常会自动创建quoted_name对象。该类也可以显式作为名称传递给接收可引用名称的任何函数。如使用具有无条件引用名称的Engine.has_table()方法：

from sqlaclchemy import create_engine
from sqlalchemy.sql.elements 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中的新功能

class sqlalchemy.sql.expression。 UnaryExpression （ 元素，运算符=无，修饰符=无，type_ =无，negate =无，wraps_column_expression = False ） T10> ¶ T11>

基础：sqlalchemy.sql.expression.ColumnElement

定义一个“一元”表达式。

一元表达式具有单列表达式和运算符。运算符可以放置在列表达式的左侧（称为“运算符”）或右侧（称为“修饰符”）。

UnaryExpression is the basis for several unary operators including those used by desc(), asc(), distinct(), nullsfirst() and nullslast().

比较 （ 其他，** kw ） t5 >

将此UnaryExpression与给定的ClauseElement进行比较。