版本:1.1.0b2 |发布日期:2016年7月1日

SQLAlchemy 1.1文档

列元素和表达式

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

sqlalchemy.sql.expression。 T0> 所有_ T1> ( T2> EXPR T3> ) T4>

产生一个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>

产生一个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>

产生一个升序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.
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))

All arguments passed to between(), including the left side column expression, are coerced from Python scalar values if a the value is not a ColumnElement subclass. 例如,三个固定值可以比较为:

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中的新功能

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()结构能够携带将在表达式时间最终使用的实际值。In this way, it serves not just as a “placeholder” for eventual population, but also as a means of representing so-called “unsafe” values which should not be rendered directly in a SQL statement, but rather should be passed along to the DBAPI as values which need to be correctly escaped and potentially handled for type-safety.

明确使用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')

在生成要多次调用的UPDATE或DELETE语句时,显式使用bindparam()也是常见的,其中语句的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()的可选数据类型。如果不通过,基于给定的值可以自动确定类型的绑定。例如,诸如strintbool的普通Python类型可能会导致StringIntegerBoolean

    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.valuebindparam.callable都没有通过,则默认为True如果其中任何一个参数存在,那么bindparam.required默认为False

    更改为0.8版:如果没有指定required标志,它将自动设置为TrueFalse取决于是否指定了valuecallable参数。

  • 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。
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. In this form, the case.whens parameter is passed as a dictionary containing expressions to be compared against keyed to result expressions. 以下声明等同于上述声明:

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

case.whenscase.else_中被接受为结果值的值被从Python文字转换为bindparam()结构。SQL expressions, e.g. ColumnElement constructs, are accepted as well. 要将文字字符串表达式强制转换为内联呈现的常量表达式,请使用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.

    在第一种形式中,它接受2元组列表;每个2元组由(< sql 表达式>, <值>) expression是一个布尔表达式,“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 – 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()函数执行两个不同的函数。The first is that it renders the CAST expression within the resulting SQL string. 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对象。

The ColumnClause is a lightweight analogue to the Column class. 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.

参数:
  • 文本 - 元素的文本。
  • typetypes.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. 在传递is_literal=True时,literal_column()函数本质上调用column()
sqlalchemy.sql.expression.collate(expression, collation)

返回子句表达式 COLLATE 整理

例如。:

collate(mycolumn, 'utf8_bin')

生产:

mycolumn COLLATE utf8_bin
sqlalchemy.sql.expression。 T0> 递减 T1> ( T2> 列 T3> ) T4>

产生一个降序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.
sqlalchemy.sql.expression。 T0> 不同 T1> ( T2> EXPR T3> ) T4>

产生列表达式级别的一元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()运算符与SelectSelect.distinct()方法不同,后者会产生一个SELECT语句与DISTINCT作为一个整体应用于结果集,例如一个SELECT DISTINCT表达式。请参阅该方法以获取更多信息。

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

不支持true / 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 / false常量。

也可以看看

true()

sqlalchemy.sql.expression。 func =< sqlalchemy.sql.functions._FunctionGenerator对象>

生成SQL函数表达式。

func is a special object instance which generates SQL functions based on name-based attributes, e.g.:

>>> 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的一个实例。此对象符合“列”界面,包括比较和标签功能。该对象还可以传递给ConnectionEngineexecute()方法,在那里它将首先被包装在SELECT语句中:

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

在一些例外情况下,func访问器将把名称重定向到内建的表达式,如cast()extract()因为这些名称具有众所周知的意义,但与SQLAlchemy的角度来看,它们并不完全一样。

New in version 0.8: func can return non-function expression constructs for common quasi-functional names like cast() and 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 ='某个名字')”。

这个函数也可以从func构造本身通过FunctionElement.filter()方法获得。

版本1.0.0中的新功能

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对象。Use this function to force the generation of a literal clause, which will be created as a BindParameter with a bound value.

参数:
  • 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。
sqlalchemy.sql.expression。 T0> 不_ T1> ( T2> 子句 T3> ) T4>

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

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

sqlalchemy.sql.expression。 T0> 空 T1> ( T2> ) T3> ¶ T4>

返回一个常量Null结构。

sqlalchemy.sql.expression。 T0> nullsfirst T1> ( T2> 列 T3> ) T4>

ORDER BY生成NULLS FIRST修饰符BY t3 >表达。

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())
        )
sqlalchemy.sql.expression。 T0> nullslast T1> ( T2> 列 T3> ) T4>

ORDER BY生成NULLS LAST修饰符BY t3 >表达。

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())
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表示“无界限”,值为零表示“当前行”,负/正整数表示“之前”和“跟随”:

  • 5个上一个和下列10个之间的范围:

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

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

    func.row_number().over(order_by='x', range_=(-2, 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中的新功能

这个函数也可以从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'")

The TextClause construct includes methods which can provide information about the bound parameters as well as the column values which would be returned from the textual statement, assuming it’s an executable SELECT type of statement. 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() is also used for the construction of a full, standalone statement using plain 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 – the text of the SQL statement to be created. 使用:<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 - in the Core tutorial

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

不支持true / false常量的后端将作为针对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()在连接和方言中更好的集成行为不支持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(expression, type_)

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

例如。:

from sqlalchemy import type_coerce

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

The above construct will produce a TypeCoerce object, which renders SQL that labels the expression, but otherwise does not modify its value on the SQL side:

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() is similar to the cast() function, except that it does not render the CAST expression in the resulting statement.

参数:
  • 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_contrankdense_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中的新功能

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 >

Compare this BinaryExpression against the given BinaryExpression.

class sqlalchemy.sql.expression。 BindParameter key=符号('NO_ARG')type_ = Noneunique = Falserequired =符号('NO_ARG') quote = Nonecallable_ = Noneisoutparam = 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__(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对象。

这个构造函数被镜像为公共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 is produced using the case() factory function, as in:

from sqlalchemy import case

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

Details on Case usage is at case().

也可以看看

case()

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

构建一个新的Case对象。

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

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

基础:sqlalchemy.sql.expression.ColumnElement

代表一个CAST表达式。

Cast is produced using the cast() factory function, as in:

from sqlalchemy import cast, Numeric

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

Details on Cast usage is at 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

编译 tt> bind = Nonedialect = 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中新增。

get_children T0> ( T1> ** kwargs T2> ) T3> ¶ T4>

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

这用于访问遍历。

** kwargs可能包含标志,这些标志会改变返回的集合,例如为了减少较大的遍历而返回一个项目的子集,或者从不同的上下文中返回子项目(比如模式级集合而不是子句-水平)。

params * optionaldict** kwargs T5>

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

bindparam()元素替换从给定字典中取得的值来返回此ClauseElement的副本:

>>> 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_=None, is_literal=False, _selectable=None)

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

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

通常使用column()函数来调用Column类的轻量级模式的ColumnClause,如下所示:

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. While the Column class has all the same capabilities as ColumnClause, the ColumnClause class is usable by itself in those cases where behavioral requirements are limited to simple SQL expression generation. 该对象与模式级别的元数据或与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

Bases: 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核心函数在SQL表达式级别工作,并打算接受ColumnElement的实例作为参数。这些函数通常会记录他们接受“SQL表达式”作为参数。What this means in terms of SQLAlchemy usually refers to an input which is either already in the form of a ColumnElement object, or a value which can be coerced into one. 与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. The Python value will ultimately be sent to the DBAPI at execution time as a paramterized argument to the execute() or executemany() methods, after SQLAlchemy type-specific converters (e.g. those provided by any associated TypeEngine objects) are applied to the value.
  • 任何特殊的对象值,通常是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对象与加法运算符+一起添加以产生BinaryExpressionBoth ColumnClause and BinaryExpression are subclasses of ColumnElement:

>>> from sqlalchemy.sql import column
>>> column('a') + column('b')
<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>
>>> print column('a') + column('b')
a + b
__当量__ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现==运算符。

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

__初始化__ T0> ¶ T1>
inherited from the __init__ attribute of object

x .__ init __(...)初始化x;请参阅帮助(键入(x))进行签名

__文件__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
继承自 __le__() ColumnOperators的方法

实现<=运算符。

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

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

实现<运算符。

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

__ NE __ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现!=运算符。

在列上下文中,生成子句a != bIf the target is None, produces a IS NOT NULL.

所有_ T0> ( T1> ) T2> ¶ T3>

针对父对象生成一个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>
inherited from the asc() method of ColumnOperators

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

base_columns T0> ¶ T1>
between(cleft, cright, symmetric=False)
inherited from the between() method of ColumnOperators

根据父对象,在()子句之间产生一个between()

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

制作一个类型,即CAST(<expression> AS <type>).

这是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()中的任何一列通过了比较测试,结果为真。这被用来扩展比较到其他列可能被认为是相当于这个通过外键或其他标准。
编译 tt> bind = Nonedialect = 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中新增。

的concat T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the concat() method of ColumnOperators

实现'concat'操作符。

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

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

实现“包含”运算符。

在列上下文中,生成子句LIKE '%&lt; other&gt;%'

递减 T0> ( T1> ) T2> ¶ T3>
inherited from the desc() method of ColumnOperators

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

说明 =无
不同 T0> ( T1> ) T2> ¶ T3>
从 tt> distinct() 方法继承的ColumnOperators

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

endswith other** 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.

is_clause_element = True
is_distinct_from T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the is_distinct_from() method of 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>
inherited from the isnot_distinct_from() method of ColumnOperators

实现IS NOT DISTINCT FROM运算符。

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

版本1.1中的新功能

=无

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

这通常指的是在可选择的例如.c集合中出现的列的“关键字”。 sometable.c [“somekey”]会返回一个.key为“somekey”的列。

标签 T0> ( T1> 名称 T2> ) T3> ¶ T4>

产生一个列标签,即&lt; columnname&gt; AS &lt; name&gt;

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

如果“名称”为“无”,则会生成一个匿名标签名称。

like(other, escape=None)
inherited from the like() method of ColumnOperators

像运算符一样实现like

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

例如。:

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

    可选的转义字符,呈现ESCAPE关键字,例如:

    somecolumn.like("foo/%bar", escape="/")
匹配 其他** kwargs t5 >
inherited from the match() method of 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版本中的新功能

notin _ T0> ( T1> 其他 T2> ) T3> ¶ T4>
inherited from the notin_() method of 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>
inherited from the nullslast() method of ColumnOperators

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

op opstringprecedence = 0is_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将低于或等于所有运算符。

    新版本0.8: - 添加了“优先”参数。

  • is_comparison -

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

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

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

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

bindparam()元素替换从给定字典中取得的值来返回此ClauseElement的副本:

>>> 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 + bIf the parent object has a string affinity, produces the concatenation operator, a || b - see ColumnOperators.concat().

__和__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
继承自 __and__() 方法 Operators

实施&运算符。

与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如果目标是None,则产生NULL

__格式__ T0> ( T1> ) T2> ¶ T3>
inherited from the __format__() method of object

默认对象格式化程序

__ GE __ T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现>=运算符。

在列上下文中,生成子句a > 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>
inherited from the __init__ attribute of 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 != bIf 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>
继承自 __or__() 方法 Operators

实施|运算符。

与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>
继承自 __reduce__() 方法 object

帮手泡菜

__ reduce_ex __ T0> ( T1> ) T2> ¶ T3>
继承自 object__reduce_ex__()

帮手泡菜

__再版__ 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 .__ subclasscheck __()调用的。它应该返回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()子句。

between(cleft, cright, symmetric=False)

根据父对象,在()子句之间产生一个between()

整理 T0> ( T1> 整理 T2> ) T3> ¶ T4>

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

的concat T0> ( T1> 其他 T2> ) T3> ¶ T4>

实现'concat'操作符。

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

包含 其他** kwargs >

实现“包含”运算符。

在列上下文中,生成子句LIKE '%&lt; other&gt;%'

递减 T0> ( T1> ) T2> ¶ T3>

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

不同 T0> ( T1> ) T2> ¶ T3>

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

endswith other** 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.

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”;在某些如SQLite上可能会呈现“a IS b”。

版本1.1中的新功能

like(other, escape=None)

像运算符一样实现like

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

例如。:

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

    可选的转义字符,呈现ESCAPE关键字,例如:

    somecolumn.like("foo/%bar", escape="/")
匹配 其他** 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版本中的新功能

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 opstringprecedence = 0is_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将低于或等于所有运算符。

    新版本0.8: - 添加了“优先”参数。

  • is_comparison -

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

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

操作 tt> op*其他** kwargs / T5> ¶ T6>
inherited from the operate() method of Operators

操作一个参数。

这是最低级别的操作,默认情况下会引发NotImplementedError

在子类上覆盖这个可以允许将所有的操作都应用到常见的行为上。例如,覆盖ColumnOperatorsfunc.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.

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. The dialect must also include an existing DefaultDialect.construct_arguments collection, indicating that it participates in the keyword-argument validation and default system, else ArgumentError is raised. 如果方言不包括这个集合,那么任何关键字参数都可以代表这个方言指定。所有包含在SQLAlchemy中的方言都包括这个集合,但是对于第三方方言,支持可能会有所不同。
  • 参数名称 - 参数的名称。
  • 默认 - 参数的默认值。

版本0.9.4中的新功能

dialect_kwargs T0> ¶ T1>

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

这些参数在它们的原始<dialect>_<kwarg>格式中呈现。Only arguments that were actually passed are included; unlike the DialectKWArgs.dialect_options collection, which contains all options known by this dialect including defaults.

收藏也是可写的;键被接受为形式<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>

A synonym for DialectKWArgs.dialect_kwargs.

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

基础:sqlalchemy.sql.expression.ColumnElement

表示一个SQL EXTRACT子句,extract(field FROM expr)

__init__(field, expr, **kwargs)

构建一个新的Extract对象。

这个构造函数被镜像为公共API函数;请参阅extract()以获得完整的用法和参数说明。

class sqlalchemy.sql.elements。 False _

基础:sqlalchemy.sql.expression.ColumnElement

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

False_ is accessed as a constant via the false() function.

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

基础:sqlalchemy.sql.expression.ColumnElement

表示一个函数FILTER子句。

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

通过FunctionElement.filter()调用FunctionFilter

func.count(1).filter(True)

版本1.0.0中的新功能

__init__(func, *criterion)

构造一个新的FunctionFilter对象。

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

过滤 T0> ( T1> *标准 T2> ) T3> ¶ T4>

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

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

SQL呈现时间通过AND将多个条件连接在一起。

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 is accessed as a constant via the null() function.

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.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 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. 类型将根据给出的值推断,在这种情况下StringDateTime

当需要特定的输入行为时,可以使用位置*binds参数直接指定bindparam()结构。这些结构必须至少包含key参数,然后是一个可选的值并键入:

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

以上我们为timestamp绑定指定了DateTime的类型,name绑定的Stringname的情况下,我们也设置"jack"的默认值。

额外的绑定参数可以在语句执行时提供,例如:

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

The TextClause.bindparams() method can be called repeatedly, where it will re-use existing BindParameter objects to add new information. 例如,我们可以先输入信息,然后第二次输入值信息,然后调用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().

列 tt> * 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. 对于诸如date或boolean类型的类型,以及某些方言配置上的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.ClauseListsqlalchemy.sql.expression.ColumnElement

表示一个SQL元组。

__init__(*clauses, **kw)

构造一个新的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__(element, *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包装对象,而不是翻译给定的对象。

__init__(expression, type_)

构建一个新的TypeCoerce对象。

这个构造函数被镜像为公共API函数;请参阅type_coerce()以获得完整的用法和参数说明。

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

代表一个“自定义”操作符。

custom_op is normally instantitated when the ColumnOperators.op() method is used to create a custom operator callable. 该类也可以在编程构造表达式时直接使用。例如。代表“阶乘”行动:

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 opstringprecedence = 0is_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将低于或等于所有运算符。

    新版本0.8: - 添加了“优先”参数。

  • is_comparison -

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

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

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

操作一个参数。

这是最低级别的操作,默认情况下会引发NotImplementedError

在子类上覆盖这个可以允许将所有的操作都应用到常见的行为上。例如,覆盖ColumnOperatorsfunc.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标志。当设置为TrueFalse时,quote标志将覆盖此标识符的自动引用行为,以便无条件引用或不引用名称。如果保留为None的缺省值,则基于对令牌本身的检查,将引用行为应用于每个后端基础上的标识符。

具有quote=Truequoted_name对象在所谓的“name normalize”选项的情况下也被阻止被修改。某些数据库后端(如Oracle,Firebird和DB2)将大小写不区分大小写的名称“归一化”。这些后端的SQLAlchemy方言可以从SQLAlchemy的小写的方法不敏感的约定转换为这些后端的大小写不敏感的约定。这里的quote=True标志将阻止这种转换的发生,以支持被引用为所有小写字母的标识符。

指定TableColumn等关键模式结构的名称时,通常会自动创建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后端运行“有表格”逻辑,将名称完全传递给"some_table",而不转换为大写。

版本0.9.0中新增。

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

基础: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