SQLAlchemy 1.1文档
列元素和表达式¶
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中的新功能
也可以看看
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)
也可以看看
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中的新功能
也可以看看
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 theasc()
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 theColumnElement.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 theBETWEEN
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中的新功能
- expr¶ – a column expression, typically a
-
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 theColumn
object representing thename
column, and the right side is aBindParameter
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 singlebindparam()
mirroring the column namename
as a result of the singlename
parameter we passed to theConnection.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 anotherBindParameter
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。
- key¶ – the key (e.g. the name) for this bind param. 将在生成的SQL语句中用于使用命名参数的方言。如果其他
-
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 thecase.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 notcase.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 withincase.whens
evaluate to false. 省略时,如果没有“when”表达式评估为true,大多数数据库将产生NULL结果。
- whens ¶ -
-
sqlalchemy.sql.expression.
cast
(expression, type_)¶ 产生一个
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 theCAST
should apply.
也可以看看
type_coerce()
- 没有发射CAST的Python端类型强制。- expression¶ – A SQL expression, such as a
-
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 withinselect()
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 thetable()
function (which is the lightweight analogue toTable
) 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 anyschema.MetaData
, DDL, or events, unlike itsTable
counterpart.Changed in version 1.0.0:
expression.column()
can now be imported from the plainsqlalchemy
namespace like any other SQL element.参数: - 文本 ¶ - 元素的文本。
- type¶ –
types.TypeEngine
object which can associate thisColumnClause
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. theliteral_column()
function essentially invokescolumn()
while passingis_literal=True
.
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 thedesc()
operation.
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
表达式。请参阅该方法以获取更多信息。
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()
andfalse()
constants also feature “short circuit” operation within anand_()
oror_()
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
也可以看看
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透视图中的“函数”不完全相同。被解释为“通用”函数的函数知道如何自动计算它们的返回类型。有关已知泛型函数的列表,请参阅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中的新功能
-
sqlalchemy.sql.expression.
label
(name, element, type_=None)¶ 为给定的
ColumnElement
返回一个Label
对象。标签通常通过
AS
SQL关键字更改SELECT
语句的columns子句中元素的名称。通过
ColumnElement
上的ColumnElement.label()
方法可以更方便地使用此功能。参数: - 名称 ¶ - 标签名称
- obj¶ – a
ColumnElement
.
-
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 tocolumn()
, except that it is more often used as a “standalone” column expression that renders exactly as stated; whilecolumn()
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。
- 文本 ¶ - 表达式的文本;可以是任何SQL表达式。引用规则将不适用。要指定应受引用规则约束的列名称表达式,请使用
sqlalchemy.sql.expression。 T0>
不_ T1> ( T2> 子句 T3> ) T4> ¶< / T5>
返回给定子句的否定,即
NOT(clause)
。所有
ColumnElement
子类中的~
运算符也被重载,以产生相同的结果。
sqlalchemy.sql.expression。 T0>
nullsfirst T1> ( T2> 列 T3> ) T4> ¶< / T5>
为
ORDER BY t3生成
NULLS FIRST
>表达。nullsfirst()
is intended to modify the expression produced byasc()
ordesc()
, 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()
anddesc()
,nullsfirst()
is typically invoked from the column expression itself usingColumnElement.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> ¶< / T5>
为
ORDER BY t3生成
NULLS LAST
>表达。nullslast()
is intended to modify the expression produced byasc()
ordesc()
, 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()
anddesc()
,nullslast()
is typically invoked from the column expression itself usingColumnElement.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') )
也可以看看
-
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 theFunctionElement.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中的新功能
该函数也可以通过
FunctionElement.over()
方法从func
构造本身使用。
-
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 asINSERT
,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 thebindparams
argument totext()
. - 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 thetypemap
argument totext()
.
- text ¶ - 要创建的SQL语句的文本。使用
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()
andfalse()
constants also feature “short circuit” operation within anand_()
oror_()
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
也可以看看
-
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.
也可以看看
- expression¶ – A SQL expression, such as a
-
sqlalchemy.sql.expression.
within_group
(element, *order_by)¶ 根据函数生成一个
WithinGroup
对象。针对所谓的“有序集合”和“假设集合”功能,包括
percentile_cont
,rank
,dense_rank
等。within_group()
is usually called using theFunctionElement.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 byfunc
. - *order_by¶ – one or more column elements that will be used as the ORDER BY clause of the WITHIN GROUP construct.
版本1.1中的新功能
- element¶ – a
- 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 thebindparam()
function, as in:from sqlalchemy import bindparam stmt = select([users_table]).\ where(users_table.c.name == bindparam('username'))
关于如何使用
BindParameter
的详细讨论位于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, elsevalue
.
- class
sqlalchemy.sql.expression.
Case
(whens, value=None, else_=None)¶ 基础:
sqlalchemy.sql.expression.ColumnElement
代表一个
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' ) )
也可以看看
- class
sqlalchemy.sql.expression.
Cast
(expression, type_)¶ 基础:
sqlalchemy.sql.expression.ColumnElement
表示一个
CAST
表达式。from sqlalchemy import cast, Numeric stmt = select([ cast(product_table.c.unit_price, Numeric(10, 4)) ])
也可以看看
- 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
orConnection
from which aCompiled
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 aCompiled
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中的新功能
- bind¶ – An
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 anotherselect()
. (请注意,通常应使用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 likex OR (y AND z)
- AND takes precedence over OR.ClauseElement
的baseself_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 theColumn
class, is typically invoked using thecolumn()
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-specificColumn
object. 尽管Column
类具有与ColumnClause
完全相同的功能,但在行为需求仅限于简单的情况下,ColumnClause
类本身可以使用SQL表达式生成。该对象与模式级别的元数据或与Column
所执行的执行时间行为没有任何关联,因此从这个意义上来说是Column
的“轻量级”版本。有关
ColumnClause
用法的详细信息位于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 theColumn
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 asNULL
, 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 abindparam()
will be produced featuring the given value embedded into the construct; the resultingBindParameter
object is an instance ofColumnElement
. 在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; aUser
class which contains a mapped attribute named.name
will have a methodUser.name.__clause_element__()
which when invoked returns theColumn
calledname
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 furtherColumnElement
instances which are composed from other, more fundamentalColumnElement
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
__当量__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
实施
==
运算符。在列上下文中,生成子句
a = b
。If the target isNone
, producesa IS NULL
.
__初始化__ T0> ¶ T1>
- 继承自
__init__
属性object
x .__ init __(...)初始化x;请参阅帮助(类型(x))进行签名
__文件__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
- inherited from the
__le__()
method ofColumnOperators
实现
<=
运算符。在列上下文中,生成子句
a <= b
。
__ LT __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
- inherited from the
__lt__()
method ofColumnOperators
实现
<
运算符。在列上下文中,生成子句
a b
。
__ NE __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
- inherited from the
__ne__()
method ofColumnOperators
实现
!=
运算符。在列上下文中,生成子句
a != b
。If the target isNone
, producesa IS NOT NULL
.
anon_label T0> ¶ T1>
为此ColumnElement提供了一个常量“匿名标签”。
这是一个label()表达式,它将在编译时被命名。每次调用anon_label时都会返回相同的label(),以便表达式可以多次引用anon_label,并在编译时生成相同的标签名称。
编译器在编译时自动使用这个函数来表达已知为“未命名”的表达式,如二进制表达式和函数调用。
任何_ T0> ( T1> ) T2> ¶ T3>
- inherited from the
any_()
method ofColumnOperators
针对父对象生成
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 ofColumnOperators
在()子句之间针对父对象生成
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 ofColumnOperators
根据给定的排序字符串,针对父对象生成一个
collate()
子句。
比较 T0> ¶ T1>
-
compare
(other, use_proxies=False, equivalents=None, **kw)¶ 将此ColumnElement与另一个进行比较。
特别理由:
参数:
编译
( bind = None,dialect = None,** kw ) T5> ¶ T6>- inherited from the
compile()
method ofClauseElement
编译这个SQL表达式。
返回值是一个
Compiled
对象。对返回值调用str()
或unicode()
将产生结果的字符串表示形式。Compiled
对象还可以使用params
访问器返回一个绑定参数名称和值的字典。参数: - bind¶ – An
Engine
orConnection
from which aCompiled
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 aCompiled
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中的新功能
- bind¶ – An
的concat T0> ( T1> 其他 T2> ) T3> ¶ T4>
实现'concat'操作符。
在列上下文中,生成子句
a || b
,或者使用concat()
运算符在MySQL上。
包含
( 其他,** kwargs ) >- inherited from the
contains()
method ofColumnOperators
实现'包含'运算符。
在列上下文中,生成子句
LIKE '%&lt; other&gt;%'
说明
=无 ¶
不同 T0> ( T1> ) T2> ¶ T3>
- inherited from the
distinct()
method ofColumnOperators
针对父对象生成一个
distinct()
子句。
endswith
( 其他,** kwargs ) t5 >- inherited from the
endswith()
method ofColumnOperators
实现'endswith'操作符。
在列上下文中,生成子句
LIKE '%&lt; other&gt;
表达 T0> ¶ T1>
返回一个列表达式。
检查界面的一部分;回报自我。
foreign_keys
= [] ¶
get_children T0> ( T1> ** kwargs T2> ) T3> ¶ T4>
- inherited from the
get_children()
method ofClauseElement
返回这个
ClauseElement
的直接子元素。这用于访问遍历。
** kwargs可能包含更改返回的集合的标志,例如为了减少更大的遍历而返回项目的子集,或者从不同的上下文返回子项目(例如模式级集合而不是子句-水平)。
ilike
( 其他,escape =无 ) t5 >- inherited from the
ilike()
method ofColumnOperators
实现
ilike
运算符。在列上下文中,生成子句
a ILIKE 其他
。例如。:
select([sometable]).where(sometable.c.column.ilike("%foobar%"))
参数:
在_ T0> ( T1> 其他 T2> ) T3> ¶ T4>
- inherited from the
in_()
method ofColumnOperators
在运算符中实现
in
在列上下文中,生成子句
a IN 其他
。“other”可以是列表达式的元组/列表,或者是select()
结构。
是_ T0> ( T1> 其他 T2> ) T3> ¶ T4>
- inherited from the
is_()
method ofColumnOperators
实现
IS
运算符。通常,当与
None
的值进行比较时,会自动生成IS
,这会解析为NULL
。但是,如果与某些平台上的布尔值进行比较,则可能需要明确使用IS
。New in version 0.7.9.
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 ofColumnOperators
实现
IS NOT
运算符。Normally,
IS NOT
is generated automatically when comparing to a value ofNone
, which resolves toNULL
. 但是,如果与某些平台上的布尔值进行比较,则可能需要明确使用IS NOT
。New in version 0.7.9.
isnot_distinct_from T0> ( T1> 其他 T2> ) T3> ¶ T4>
实现
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 ofColumnOperators
像运算符一样实现
like
在列上下文中,生成子句
a LIKE 其他
。例如。:
select([sometable]).where(sometable.c.column.like("%foobar%"))
参数:
匹配
( 其他,** 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兼容。
- Postgresql - 呈现
-
notilike
(other, escape=None)¶ - inherited from the
notilike()
method ofColumnOperators
执行
NOT ILIKE
运算符。这相当于对
ColumnOperators.ilike()
使用否定,即~x.ilike(y)
。0.8版本中的新功能
notin _ T0> ( T1> 其他 T2> ) T3> ¶ T4>
- 继承自
notin_()
方法ColumnOperators
执行
NOT IN
运算符。这相当于对
ColumnOperators.in_()
,即~x.in_(y)
使用否定。0.8版本中的新功能
notlike
( 其他,转义=无 ) t5 >- inherited from the
notlike()
method ofColumnOperators
执行
NOT LIKE
运算符。这相当于对
ColumnOperators.like()
,即~x.like(y)
使用否定。0.8版本中的新功能
nullsfirst T0> ( T1> ) T2> ¶ T3>
- inherited from the
nullsfirst()
method ofColumnOperators
针对父对象生成
nullsfirst()
子句。
nullslast T0> ( T1> ) T2> ¶ T3>
针对父对象生成一个
nullslast()
子句。
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
标志。
操作 tt> ( op,*其他,** kwargs / T5> ¶ T6>
params
( * optionaldict,** kwargs ) T5>- inherited from the
params()
method ofClauseElement
返回带有
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 ofColumnOperators
实现
startwith
运算符。在列上下文中,生成子句
LIKE '&lt; other&gt;%'
supports_execution
= False ¶
timetuple
=无 ¶
型 T0> ¶ T1>
unique_params
( * optionaldict,** kwargs ) T5>- inherited from the
unique_params()
method ofClauseElement
返回带有
bindparam()
元素的副本。与
params()
功能相同,除了将unique = True添加到受影响的绑定参数以便可以使用多个语句。
- a literal Python value, such as a string, integer or floating point value, boolean, datetime,
- 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
__添加__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
实施
+
运算符。在列上下文中,如果父对象具有非字符串亲和性,则会生成子句
a + b
。If the parent object has a string affinity, produces the concatenation operator,a || b
- seeColumnOperators.concat()
.
__和__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
实施
&
运算符。与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 isNone
, producesa 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 ofOperators
实施
~
运算符。与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 isNone
, producesa 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 ofobject
__或__ T0> ( T1> 其他 T2> ) T3> ¶ T4>
实施
|
运算符。与SQL表达式一起使用时,会产生OR操作,等同于
or_()
,即:a | b
相当于:
from sqlalchemy import or_ or_(a, b)
在使用
|
时应注意运营商的优先级;|
运算符的优先级最高。如果操作数包含更多的子表达式,则应将其括在括号中:(a == 2) | (b == 4)
__ RADD __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
反向实施
+
运算符。
__ RDIV __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
反向实施
/
运算符。
__减少__ T0> ( T1> ) T2> ¶ T3>
- 继承自
object
的__reduce__()
方法腌菜的帮手
__ reduce_ex __ T0> ( T1> ) T2> ¶ T3>
- inherited from the
__reduce_ex__()
method ofobject
腌菜的帮手
__再版__ T0> ¶ T1>
- 继承自
__repr__
属性object
__ RMOD __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
反过来实施
%
运算符。
__ RMUL __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
反向实施
*
运算符。
__ RSHIFT __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
执行>>操作符。
SQLAlchemy核心不使用它,这是为想要使用>>作为扩展点的自定义操作系统提供的。
__ RSUB __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
反过来实施
-
运算符。
__ rtruediv __ T0> ( T1> 其他 T2> ) T3> ¶ T4>
反向实施
//
运算符。
__ 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
。
的concat T0> ( T1> 其他 T2> ) T3> ¶ T4>
实现'concat'操作符。
在列上下文中,生成子句
a || b
,或者使用concat()
运算符在MySQL上。
不同 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%"))
参数:
是_ 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 ofNone
, which resolves toNULL
. 但是,如果与某些平台上的布尔值进行比较,则可能需要明确使用IS NOT
。New in version 0.7.9.
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%"))
参数:
匹配
( 其他,** 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兼容。
- Postgresql - 呈现
-
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版本中的新功能
notlike
( 其他,转义=无 ) t5 >执行
NOT LIKE
运算符。这相当于对
ColumnOperators.like()
,即~x.like(y)
使用否定。0.8版本中的新功能
nullsfirst T0> ( T1> ) T2> ¶ T3>
针对父对象生成
nullsfirst()
子句。
nullslast T0> ( T1> ) T2> ¶ T3>
针对父对象生成一个
nullslast()
子句。
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
标志。
操作 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))
参数:
reverse_operate
( op,其他,** kwargs T5> ¶ T6>- inherited from the
reverse_operate()
method ofOperators
对参数进行反向操作。
用法与
operate()
相同。
startswith
( 其他,** kwargs ) ¶ t5 >实现
startwith
运算符。在列上下文中,生成子句
LIKE '&lt; other&gt;%'
timetuple
=无 ¶Hack,允许在LHS上比较日期时间对象。
- class
sqlalchemy.sql.base。
DialectKWArgs
¶ 建立一个具有缺省和构造函数验证的特定方言参数的类的能力。
The
DialectKWArgs
interacts with theDefaultDialect.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 theDefaultDialect.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_name¶ – name of a dialect. The dialect must be locatable, else a
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>
- classmethod
- class
sqlalchemy.sql.expression.
Extract
(field, expr, **kwargs)¶ 基础:
sqlalchemy.sql.expression.ColumnElement
表示一个SQL EXTRACT子句,
提取(field FROM expr)
。
- class
sqlalchemy.sql.elements。
False _
¶ 基础:
sqlalchemy.sql.expression.ColumnElement
在SQL语句中表示
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中的新功能
-
__init__
(func, *criterion)¶ 构造一个新的
FunctionFilter
对象。这个构造函数被镜像为公共API函数;有关完整的用法和参数说明,请参阅
funcfilter()
。
过滤 T0> ( T1> *标准 T2> ) T3> ¶ T4>
针对该功能生成额外的FILTER。
此方法将附加条件添加到由
FunctionElement.filter()
设置的初始条件中。多个标准通过
AND
在SQL呈现时间连接在一起。
-
- class
sqlalchemy.sql.expression.
Label
(name, element, type_=None)¶ 基础:
sqlalchemy.sql.expression.ColumnElement
表示一个列标签(AS)。
使用
AS
sql关键字通常应用于任何列级元素来表示标签。
- class
sqlalchemy.sql.elements。
空
¶ 基础:
sqlalchemy.sql.expression.ColumnElement
在SQL语句中表示NULL关键字。
- class
sqlalchemy.sql.expression.
Over
(element, partition_by=None, order_by=None, range_=None, rows=None)¶ 基础:
sqlalchemy.sql.expression.ColumnElement
代表OVER子句。
这是一个针对所谓的“窗口”函数的特殊操作符,以及任何聚合函数,它会产生相对于结果集本身的结果。它仅受特定数据库后端支持。
- 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()
函数生成的;请参阅该函数以获取完整文档。也可以看看
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 namesname
andtimestamp
, and values ofjack
anddatetime.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 argumentbindparams
passed totext()
.
列
( * 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, theseTypeEngine
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 theTextClause.columns()
method. 此方法取代text()
的typemap
参数。
- class
sqlalchemy.sql.expression.
Tuple
(*clauses, **kw)¶ 基础:
sqlalchemy.sql.expression.ClauseList
,sqlalchemy.sql.expression.ColumnElement
表示一个SQL元组。
- 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
关键字或等效项。
- class
sqlalchemy.sql.expression.
TypeCoerce
(expression, type_)¶ 基础:
sqlalchemy.sql.expression.ColumnElement
表示一个Python端的类型强制包装器。
TypeCoerce
supplies theexpression.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 ) ¶ 代表一个'自定义'操作符。
当使用
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()
andreverse_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
标志。
操作 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))
参数:
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 bydesc()
,asc()
,distinct()
,nullsfirst()
andnullslast()
.比较
( 其他,** kw ) t5 >将此
UnaryExpression
与给定的ClauseElement
进行比较。