SQL 和通用函数¶

SQL 函数通过使用 func 命名空间来调用。有关如何在语句中使用 func 对象呈现 SQL 函数的背景信息，请参阅教程使用 SQL 函数。

另请参阅

函数 API¶

SQL 函数的基本 API，它提供了 func 命名空间，以及可用于扩展的类。

对象名称	描述
AnsiFunction	以“ansi”格式定义函数，该格式不呈现括号。
Function	描述一个命名的 SQL 函数。
FunctionElement	SQL 函数导向构造的基本类。
GenericFunction	定义一个“通用”函数。
register_function(identifier, fn[, package])	将一个可调用对象与特定的 func. 名称关联。

class sqlalchemy.sql.functions.AnsiFunction¶: 以“ansi”格式定义函数，该格式不呈现括号。

类签名

class sqlalchemy.sql.functions.AnsiFunction (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.Function¶

描述一个命名的 SQL 函数。

Function 对象通常由 func 生成对象生成。

参数:

*clauses¶ – 形成 SQL 函数调用的参数的列表达式列表。
type_¶ – 可选的 TypeEngine 数据类型对象，它将用作此函数调用生成的列表达式的返回值。
packagenames¶ –
一个字符串，表示在生成 SQL 时要附加到函数名称之前的包前缀名称。 func 生成器在使用点分隔格式调用时创建这些名称，例如：
```
func.mypackage.some_function(col1, col2)
```

另请参阅

使用 SQL 函数 - 在 SQLAlchemy 统一教程中

func - 生成已注册或临时 Function 实例的命名空间。

GenericFunction - 允许创建已注册的函数类型。

成员

__init__()

类签名

class sqlalchemy.sql.functions.Function (sqlalchemy.sql.functions.FunctionElement)

method sqlalchemy.sql.functions.Function.__init__(name: str, *clauses: _ColumnExpressionOrLiteralArgument[Any], type_: _TypeEngineArgument[_T] | None = None, packagenames: Tuple[str, ...] | None = None)¶

构造一个 Function。

func 构造通常用于构造新的 Function 实例。

class sqlalchemy.sql.functions.FunctionElement¶

SQL 函数导向构造的基本类。

这是一个泛型类型，这意味着类型检查器和 IDE 可以被指示在这个函数的 Result 中预期哪些类型。请参见 GenericFunction 以了解如何实现此功能的示例。

另请参阅

使用 SQL 函数 - 在 SQLAlchemy 统一教程中

Function - 命名 SQL 函数。

func - 生成已注册或临时 Function 实例的命名空间。

GenericFunction - 允许创建已注册的函数类型。

成员

__init__(), alias(), as_comparison(), c, clauses, column_valued(), columns, entity_namespace, exported_columns, filter(), over(), scalar_table_valued(), select(), self_group(), table_valued(), within_group(), within_group_type()

类签名

class sqlalchemy.sql.functions.FunctionElement (sqlalchemy.sql.expression.Executable, sqlalchemy.sql.expression.ColumnElement, sqlalchemy.sql.expression.FromClause, sqlalchemy.sql.expression.Generative)

method sqlalchemy.sql.functions.FunctionElement.__init__(*clauses: _ColumnExpressionOrLiteralArgument[Any])¶

构建一个 FunctionElement。

参数:

*clauses¶ – 构成 SQL 函数调用参数的列表达式列表。
**kwargs¶ – 额外的关键字参数通常由子类使用。

另请参阅

func

Function

method sqlalchemy.sql.functions.FunctionElement.alias(name: str | None = None, joins_implicitly: bool = False) → TableValuedAlias¶

针对此 FunctionElement 生成一个 Alias 结构。

提示

The FunctionElement.alias() 方法是创建“表值” SQL 函数的机制的一部分。但是，大多数用例都由 FunctionElement 上的更高级方法（包括 FunctionElement.table_valued() 和 FunctionElement.column_valued()）涵盖。

此结构将函数包装在命名别名中，该别名适合于 FROM 子句，其风格与 PostgreSQL 等后端接受的风格一致。还使用特殊的 .column 属性提供了一个列表达式，该属性可用于将函数的输出作为标量值引用到列或 where 子句中，适用于 PostgreSQL 等后端。

对于完整的表值表达式，请先使用 FunctionElement.table_valued() 方法来建立命名列。

例如：

>>> fromsqlalchemyimportfunc,select,column>>> data_view=func.unnest([1,2,3]).alias("data_view")>>> print(select(data_view.column))SELECT data_view
FROM unnest(:unnest_1) AS data_view

The FunctionElement.column_valued() 方法为上述模式提供了一种快捷方式

>>> data_view=func.unnest([1,2,3]).column_valued("data_view")>>> print(select(data_view))SELECT data_view
FROM unnest(:unnest_1) AS data_view

版本 1.4.0b2 中的新增功能：添加了 .column 访问器

参数:

name¶ – 别名，将在 FROM 子句中呈现为 AS <name>
joins_implicitly¶ –
如果为 True，则可以在 FROM 子句中使用表值函数，而无需任何显式 JOIN 到 SQL 查询中的其他表，并且不会生成任何“笛卡尔积”警告。对于诸如 func.json_each() 之类的 SQL 函数可能很有用。

版本 1.4.33 中的新增功能。

另请参阅

表值函数 - 在 SQLAlchemy 统一教程中

FunctionElement.table_valued()

FunctionElement.scalar_table_valued()

FunctionElement.column_valued()

method sqlalchemy.sql.functions.FunctionElement.as_comparison(left_index: int, right_index: int) → FunctionAsBinary¶

将此表达式解释为两个值之间的布尔比较。

此方法用于在基于 SQL 函数的自定义运算符中描述的 ORM 用例。

假设一个 SQL 函数 “is_equal()” 用于比较两个值以确定是否相等，它将在 Core 表达式语言中这样编写

expr = func.is_equal("a", "b")

如果上面的 “is_equal()” 用于比较 “a” 和 “b” 以确定是否相等，则 FunctionElement.as_comparison() 方法将被调用为

expr = func.is_equal("a", "b").as_comparison(1, 2)

上面的整数 “1” 指的是 “is_equal()” 函数的第一个参数，整数 “2” 指的是第二个参数。

这将创建一个 BinaryExpression，它等效于

BinaryExpression("a", "b", operator=op.eq)

但是，在 SQL 级别，它仍然会呈现为 “is_equal(‘a’, ‘b’)”。

ORM 在加载相关对象或集合时，需要能够操作 JOIN 表达式 ON 子句的“左”和“右”部分。此方法的目的是提供一个 SQL 函数结构，该结构还可以将此信息提供给 ORM，当与 relationship.primaryjoin 参数一起使用时。返回值是一个名为 FunctionAsBinary 的容器对象。

一个 ORM 示例如下

class Venue(Base):
    __tablename__ = 'venue'
    id = Column(Integer, primary_key=True)
    name = Column(String)

    descendants = relationship(
        "Venue",
        primaryjoin=func.instr(
            remote(foreign(name)), name + "/"
        ).as_comparison(1, 2) == 1,
        viewonly=True,
        order_by=name
    )

上面，“Venue” 类可以通过确定父 Venue 的名称是否包含在假设的子级值的名称的开头来加载子级 “Venue” 对象，例如，“parent1” 将与 “parent1/child1” 匹配，但不会与 “parent2/child1” 匹配。

可能的用例包括上面给出的“物化路径”示例，以及使用诸如几何函数之类的特殊 SQL 函数来创建连接条件。

参数:

left_index¶ – 函数参数的整数 1 索引，用作表达式的“左”部分。
right_index¶ – 函数参数中作为表达式“右侧”的整数索引（从 1 开始）。

版本 1.3 中新增。

另请参阅

基于 SQL 函数的自定义操作符 - ORM 中的示例用法

attribute sqlalchemy.sql.functions.FunctionElement.c¶: 是 FunctionElement.columns 的别名。

attribute sqlalchemy.sql.functions.FunctionElement.clauses¶: 返回包含此 FunctionElement 参数的底层 ClauseList。

method sqlalchemy.sql.functions.FunctionElement.column_valued(name: str | None = None, joins_implicitly: bool = False) → TableValuedColumn[_T]¶

将此 FunctionElement 返回为一个列表达式，该表达式从其自身作为 FROM 子句进行选择。

例如：

>>> fromsqlalchemyimportselect,func>>> gs=func.generate_series(1,5,-1).column_valued()>>> print(select(gs))SELECT anon_1
FROM generate_series(:generate_series_1, :generate_series_2, :generate_series_3) AS anon_1

这是以下代码的简写

gs = func.generate_series(1, 5, -1).alias().column

参数:

name¶ – 可选的名称，用于分配给生成的别名。如果省略，则使用唯一的匿名名称。
joins_implicitly¶ –
当为 True 时，列值函数的“表”部分可以是 FROM 子句的成员，而无需与 SQL 查询中的其他表进行任何显式 JOIN，并且不会生成任何“笛卡尔积”警告。对于 SQL 函数（如 func.json_array_elements()）可能很有用。

版本 1.4.46 中新增。

另请参阅

列值函数 - 表值函数作为标量列 - 在 SQLAlchemy 统一教程中

列值函数 - 在 PostgreSQL 文档中

FunctionElement.table_valued()

attribute sqlalchemy.sql.functions.FunctionElement.columns¶

此 FunctionElement 导出的列集。

这是一个占位符集合，允许将函数放置在语句的 FROM 子句中

>>> fromsqlalchemyimportcolumn,select,func>>> stmt=select(column('x'),column('y')).select_from(func.myfunction())>>> print(stmt)SELECT x, y FROM myfunction()

以上形式是一个遗留特性，现在已被功能完备的 FunctionElement.table_valued() 方法取代；有关详细信息，请参阅该方法。

另请参阅

FunctionElement.table_valued() - 生成表值 SQL 函数表达式。

attribute sqlalchemy.sql.functions.FunctionElement.entity_namespace¶: 覆盖 FromClause.entity_namespace，因为函数通常是列表达式，而不是 FromClauses。

attribute sqlalchemy.sql.functions.FunctionElement.exported_columns¶

method sqlalchemy.sql.functions.FunctionElement.filter(*criterion: _ColumnExpressionArgument[bool]) → Self | FunctionFilter[_T]¶

针对此函数生成 FILTER 子句。

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

表达式

func.count(1).filter(True)

是以下代码的简写

from sqlalchemy import funcfilter
funcfilter(func.count(1), True)

另请参阅

特殊修饰符 WITHIN GROUP、FILTER - 在 SQLAlchemy 统一教程中

FunctionFilter

funcfilter()

针对此函数生成 OVER 子句。

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

表达式

func.row_number().over(order_by='x')

是以下代码的简写

from sqlalchemy import over
over(func.row_number(), order_by='x')

有关完整描述，请参阅 over()。

另请参阅

over()

使用窗口函数 - 在 SQLAlchemy 统一教程中

method sqlalchemy.sql.functions.FunctionElement.scalar_table_valued(name: str, type_: _TypeEngineArgument[_T] | None = None) → ScalarFunctionColumn[_T]¶

返回针对此 FunctionElement 作为标量表值表达式的列表达式。

返回的表达式类似于从 FunctionElement.table_valued() 构造中访问的单个列返回的表达式，除了不生成 FROM 子句；函数的渲染方式与标量子查询类似。

例如：

>>> fromsqlalchemyimportfunc,select>>> fn=func.jsonb_each("{'k', 'v'}").scalar_table_valued("key")>>> print(select(fn))SELECT (jsonb_each(:jsonb_each_1)).key

1.4.0b2 版本新增。

另请参阅

FunctionElement.table_valued()

FunctionElement.alias()

FunctionElement.column_valued()

method sqlalchemy.sql.functions.FunctionElement.select() → Select¶

针对此 FunctionElement 生成一个 select() 构造。

这是以下代码的简写

s = select(function_element)

method sqlalchemy.sql.functions.FunctionElement.self_group(against: OperatorType | None = None) → ClauseElement¶

对这个 ClauseElement 应用“分组”。

此方法被子类覆盖以返回一个“分组”构造，即括号。特别是，它被“二元”表达式用于在放置到更大的表达式中时提供围绕自身的括号，以及被 select() 构造用于放置到另一个 select() 的 FROM 子句中。(注意，子查询通常应该使用 Select.alias() 方法创建，因为许多平台要求嵌套的 SELECT 语句被命名)。

当表达式组合在一起时，self_group() 的应用是自动的——最终用户代码永远不需要直接使用此方法。注意，SQLAlchemy 的子句构造考虑了运算符优先级——因此括号可能不需要，例如，在像 x OR (y AND z) 这样的表达式中——AND 的优先级高于 OR。

self_group() 的基本方法 ClauseElement 只返回自身。

method sqlalchemy.sql.functions.FunctionElement.table_valued(*expr: _ColumnExpressionOrStrLabelArgument[Any], **kw: Any) → TableValuedAlias¶

返回一个 TableValuedAlias 表示形式，其中添加了表值表达式。

例如：

>>> fn=(...     func.generate_series(1, 5)....     table_valued("value", "start", "stop", "step")... )>>> print(select(fn))SELECT anon_1.value, anon_1.start, anon_1.stop, anon_1.step
FROM generate_series(:generate_series_1, :generate_series_2) AS anon_1
>>> print(select(fn.c.value,fn.c.stop).where(fn.c.value>2))SELECT anon_1.value, anon_1.stop
FROM generate_series(:generate_series_1, :generate_series_2) AS anon_1
WHERE anon_1.value > :value_1

可以通过传递关键字参数“with_ordinality”生成 WITH ORDINALITY 表达式。

>>> fn=func.generate_series(4,1,-1).table_valued("gen",with_ordinality="ordinality")>>> print(select(fn))SELECT anon_1.gen, anon_1.ordinality
FROM generate_series(:generate_series_1, :generate_series_2, :generate_series_3) WITH ORDINALITY AS anon_1

参数:

*expr¶ – 一系列字符串列名，这些列名将被添加到生成的 TableValuedAlias 构造的 .c 集合中作为列。带有或不带有数据类型的 column() 对象也可以使用。
name¶ – 为生成的别名字段分配的可选名称。如果省略，将使用唯一的匿名名称。
with_ordinality¶ – 字符串名称，当存在时，会导致将 WITH ORDINALITY 子句添加到别名中，并且给定的字符串名称将作为列添加到生成的 TableValuedAlias 的 .c 集合中。
joins_implicitly¶ –
如果为 True，则可以在 FROM 子句中使用表值函数，而无需任何显式 JOIN 到 SQL 查询中的其他表，并且不会生成任何“笛卡尔积”警告。对于诸如 func.json_each() 之类的 SQL 函数可能很有用。

版本 1.4.33 中的新增功能。

1.4.0b2 版本新增。

另请参阅

表值函数 - 在 SQLAlchemy 统一教程中

表值函数 - 在 PostgreSQL 文档中

FunctionElement.scalar_table_valued() - FunctionElement.table_valued() 的变体，它将完整的表值表达式作为标量列表达式提供

FunctionElement.column_valued()

TableValuedAlias.render_derived() - 使用派生列子句渲染别名，例如 AS name(col1, col2, ...)

方法 sqlalchemy.sql.functions.FunctionElement.within_group(*order_by: _ColumnExpressionArgument[Any]) → WithinGroup[_T]¶

针对此函数生成一个 WITHIN GROUP (ORDER BY expr) 子句。

用于所谓的“有序集合聚合”和“假设集合聚合”函数，包括 percentile_cont，rank，dense_rank 等。

有关完整描述，请参见 within_group()。

另请参阅

特殊修饰符 WITHIN GROUP、FILTER - 在 SQLAlchemy 统一教程中

方法 sqlalchemy.sql.functions.FunctionElement.within_group_type(within_group: WithinGroup[_S]) → TypeEngine | None¶

对于将返回类型定义为基于 WITHIN GROUP (ORDER BY) 表达式中的条件的类型，由 WithinGroup 结构调用。

默认情况下返回 None，在这种情况下将使用函数的正常 .type。

类 sqlalchemy.sql.functions.GenericFunction¶

定义一个“通用”函数。

泛型函数是一个预先建立的 Function 类，它在从 func 属性中按名称调用时会自动实例化。请注意，从 func 调用任何名称都会导致自动创建新的 Function 实例，并指定该名称。定义 GenericFunction 类的主要用例是，可以为特定名称的函数指定固定的返回类型。它还可以包括自定义参数解析方案以及其他方法。

GenericFunction 的子类会自动注册到类的名称下。例如，用户定义的函数 as_utc() 会立即可用

from sqlalchemy.sql.functions import GenericFunction
from sqlalchemy.types import DateTime

class as_utc(GenericFunction):
    type = DateTime()
    inherit_cache = True

print(select(func.as_utc()))

用户定义的泛型函数可以通过在定义 GenericFunction 时指定“package”属性来组织到包中。包含许多函数的第三方库可能希望使用此功能以避免与其他系统发生名称冲突。例如，如果我们的 as_utc() 函数是“time”包的一部分

class as_utc(GenericFunction):
    type = DateTime()
    package = "time"
    inherit_cache = True

上面的函数可以通过使用包名 time 从 func 获取。

print(select(func.time.as_utc()))

最后一个选项是允许函数从 func 中的一个名称访问，但以不同的名称呈现。 identifier 属性将覆盖从 func 加载时用于访问函数的名称，但将保留使用 name 作为呈现的名称。

class GeoBuffer(GenericFunction):
    type = Geometry()
    package = "geo"
    name = "ST_Buffer"
    identifier = "buffer"
    inherit_cache = True

上面的函数将按如下方式呈现

>>> print(func.geo.buffer())ST_Buffer()

名称将按原样呈现，但是，除非名称包含需要引用的特殊字符，否则不会进行引用。要强制对名称进行引用或取消引用，请使用 quoted_name 结构。

from sqlalchemy.sql import quoted_name

class GeoBuffer(GenericFunction):
    type = Geometry()
    package = "geo"
    name = quoted_name("ST_Buffer", True)
    identifier = "buffer"
    inherit_cache = True

上面的函数将呈现为

>>> print(func.geo.buffer())"ST_Buffer"()

此类的类型参数作为泛型类型可以传递，并且应该与 Result 中看到的类型匹配。例如

class as_utc(GenericFunction[datetime.datetime]):
    type = DateTime()
    inherit_cache = True

上面的代码表示以下表达式返回一个 datetime 对象。

connection.scalar(select(func.as_utc()))

版本 1.3.13 中的新功能：现在 quoted_name 结构在与对象的“name”属性一起使用时会识别为引用，以便可以强制对函数名称进行引用或取消引用。

类签名

类 sqlalchemy.sql.functions.GenericFunction (sqlalchemy.sql.functions.Function)

函数 sqlalchemy.sql.functions.register_function(identifier: str, fn: Type[Function[Any]], package: str = '_default') → None¶

将一个可调用对象与特定的 func. 名称关联。

这通常由 GenericFunction 调用，但本身也可用，因此非函数构造可以与 func 访问器相关联（例如 CAST、EXTRACT）。

选定的“已知”函数¶

这些是 GenericFunction 的实现，用于一组选定的常见 SQL 函数，这些函数会自动为每个函数设置预期的返回类型。它们的调用方式与 func 命名空间中的任何其他成员相同。

select(func.count("*")).select_from(some_table)

请注意，任何 func 不认识的名称都将生成函数名称，不会对其进行任何限制 - 对于可以调用的 SQL 函数没有限制，无论 SQLAlchemy 是否认识，是内置函数还是用户定义的。此部分仅描述 SQLAlchemy 已经了解其正在使用哪些参数和返回类型的函数。

对象名称	描述
aggregate_strings	实现一个通用的字符串聚合函数。
array_agg	支持 ARRAY_AGG 函数。
char_length	CHAR_LENGTH() SQL 函数。
coalesce
concat	SQL CONCAT() 函数，它用于连接字符串。
count	ANSI COUNT 聚合函数。在没有参数的情况下，会发出 COUNT *。
cube	实现 `CUBE` 分组操作。
cume_dist	实现 `cume_dist` 假设集合聚合函数。
current_date	CURRENT_DATE() SQL 函数。
current_time	CURRENT_TIME() SQL 函数。
current_timestamp	CURRENT_TIMESTAMP() SQL 函数。
current_user	CURRENT_USER() SQL 函数。
dense_rank	实现 `dense_rank` 假设集合聚合函数。
grouping_sets	实现 `GROUPING SETS` 分组操作。
localtime	localtime() SQL 函数。
localtimestamp	localtimestamp() SQL 函数。
max	SQL MAX() 聚合函数。
min	SQL MIN() 聚合函数。
mode	实现 `mode` 有序集合聚合函数。
next_value	表示“下一个值”，以 `Sequence` 作为其唯一参数。
now	SQL now() 日期时间函数。
percent_rank	实现 `percent_rank` 假设集合聚合函数。
percentile_cont	实现 `percentile_cont` 有序集合聚合函数。
percentile_disc	实现 `percentile_disc` 有序集合聚合函数。
random	RANDOM() SQL 函数。
rank	实现 `rank` 假设集合聚合函数。
rollup	实现 `ROLLUP` 分组操作。
session_user	SESSION_USER() SQL 函数。
sum	SQL SUM() 聚合函数。
sysdate	SYSDATE() SQL 函数。
user	USER() SQL 函数。

class sqlalchemy.sql.functions.aggregate_strings¶

实现一个通用的字符串聚合函数。

该函数会将非空值连接成一个字符串，并用分隔符分隔这些值。

该函数在每个后端的基础上进行编译，编译成诸如 group_concat()、string_agg() 或 LISTAGG() 的函数。

例如：使用分隔符“.” 的示例用法

stmt = select(func.aggregate_strings(table.c.str_col, "."))

该函数的返回值类型是 String.

类签名

class sqlalchemy.sql.functions.aggregate_strings (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.array_agg¶

支持 ARRAY_AGG 函数。

func.array_agg(expr) 结构返回类型为 ARRAY 的表达式。

例如：

stmt = select(func.array_agg(table.c.values)[2:5])

另请参阅

array_agg() - PostgreSQL 特定版本，返回 ARRAY，它添加了 PG 特定运算符。

类签名

class sqlalchemy.sql.functions.array_agg (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.char_length¶: CHAR_LENGTH() SQL 函数。

类签名

class sqlalchemy.sql.functions.char_length (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.coalesce¶: 类签名

class sqlalchemy.sql.functions.coalesce (sqlalchemy.sql.functions.ReturnTypeFromArgs)

class sqlalchemy.sql.functions.concat¶

SQL CONCAT() 函数，它用于连接字符串。

例如：

>>> print(select(func.concat('a','b')))SELECT concat(:concat_2, :concat_3) AS concat_1

SQLAlchemy 中的字符串连接通常使用 Python + 运算符与字符串数据类型一起使用，这将呈现一个特定于后端的连接运算符，例如

>>> print(select(literal("a")+"b"))SELECT :param_1 || :param_2 AS anon_1

类签名

class sqlalchemy.sql.functions.concat (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.count¶

ANSI COUNT 聚合函数。在没有参数的情况下，会发出 COUNT *。

例如：

from sqlalchemy import func
from sqlalchemy import select
from sqlalchemy import table, column

my_table = table('some_table', column('id'))

stmt = select(func.count()).select_from(my_table)

执行 stmt 会发出

SELECT count(*) AS count_1
FROM some_table

类签名

class sqlalchemy.sql.functions.count (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.cube¶

实现 CUBE 分组操作。

该函数用作语句 GROUP BY 的一部分，例如 Select.group_by()

stmt = select(
    func.sum(table.c.value), table.c.col_1, table.c.col_2
).group_by(func.cube(table.c.col_1, table.c.col_2))

新版功能，版本 1.2。

类签名

class sqlalchemy.sql.functions.cube (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.cume_dist¶

实现 cume_dist 假设集合聚合函数。

该函数必须与 FunctionElement.within_group() 修饰符一起使用，以提供要操作的排序表达式。

该函数的返回值类型是 Numeric.

类签名

class sqlalchemy.sql.functions.cume_dist (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.current_date¶: CURRENT_DATE() SQL 函数。

类签名

class sqlalchemy.sql.functions.current_date (sqlalchemy.sql.functions.AnsiFunction)

class sqlalchemy.sql.functions.current_time¶: CURRENT_TIME() SQL 函数。

类签名

class sqlalchemy.sql.functions.current_time (sqlalchemy.sql.functions.AnsiFunction)

class sqlalchemy.sql.functions.current_timestamp¶: CURRENT_TIMESTAMP() SQL 函数。

类签名

class sqlalchemy.sql.functions.current_timestamp (sqlalchemy.sql.functions.AnsiFunction)

class sqlalchemy.sql.functions.current_user¶: CURRENT_USER() SQL 函数。

类签名

class sqlalchemy.sql.functions.current_user (sqlalchemy.sql.functions.AnsiFunction)

class sqlalchemy.sql.functions.dense_rank¶

实现 dense_rank 假设集合聚合函数。

该函数必须与 FunctionElement.within_group() 修饰符一起使用，以提供要操作的排序表达式。

该函数的返回值类型是 Integer.

类签名

class sqlalchemy.sql.functions.dense_rank (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.grouping_sets¶

实现 GROUPING SETS 分组操作。

该函数用作语句 GROUP BY 的一部分，例如 Select.group_by()

stmt = select(
    func.sum(table.c.value), table.c.col_1, table.c.col_2
).group_by(func.grouping_sets(table.c.col_1, table.c.col_2))

为了按多个集合分组，请使用 tuple_() 结构

from sqlalchemy import tuple_

stmt = select(
    func.sum(table.c.value),
    table.c.col_1, table.c.col_2,
    table.c.col_3
).group_by(
    func.grouping_sets(
        tuple_(table.c.col_1, table.c.col_2),
        tuple_(table.c.value, table.c.col_3),
    )
)

新版功能，版本 1.2。

类签名

class sqlalchemy.sql.functions.grouping_sets (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.localtime¶: localtime() SQL 函数。

类签名

class sqlalchemy.sql.functions.localtime (sqlalchemy.sql.functions.AnsiFunction)

class sqlalchemy.sql.functions.localtimestamp¶: localtimestamp() SQL 函数。

类签名

class sqlalchemy.sql.functions.localtimestamp (sqlalchemy.sql.functions.AnsiFunction)

class sqlalchemy.sql.functions.max¶: SQL MAX() 聚合函数。

类签名

class sqlalchemy.sql.functions.max (sqlalchemy.sql.functions.ReturnTypeFromArgs)

class sqlalchemy.sql.functions.min¶: SQL MIN() 聚合函数。

类签名

class sqlalchemy.sql.functions.min (sqlalchemy.sql.functions.ReturnTypeFromArgs)

class sqlalchemy.sql.functions.mode¶

实现 mode 有序集合聚合函数。

该函数必须与 FunctionElement.within_group() 修饰符一起使用，以提供要操作的排序表达式。

此函数的返回类型与排序表达式相同。

类签名

class sqlalchemy.sql.functions.mode (sqlalchemy.sql.functions.OrderedSetAgg)

class sqlalchemy.sql.functions.next_value¶

表示“下一个值”，以 Sequence 作为其唯一参数。

编译成每个后端的相应函数，或者如果在不支持序列的后端上使用，则会引发 NotImplementedError。

类签名

class sqlalchemy.sql.functions.next_value (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.now¶

SQL now() 日期时间函数。

SQLAlchemy 方言通常会以特定于后端的方式呈现此特定函数，例如将其呈现为 CURRENT_TIMESTAMP。

类签名

class sqlalchemy.sql.functions.now (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.percent_rank¶

实现 percent_rank 假设集合聚合函数。

该函数必须与 FunctionElement.within_group() 修饰符一起使用，以提供要操作的排序表达式。

该函数的返回值类型是 Numeric.

类签名

class sqlalchemy.sql.functions.percent_rank (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.percentile_cont¶

实现 percentile_cont 有序集合聚合函数。

该函数必须与 FunctionElement.within_group() 修饰符一起使用，以提供要操作的排序表达式。

此函数的返回类型与排序表达式相同，或者如果参数是数组，则为 ARRAY 排序表达式的类型。

类签名

class sqlalchemy.sql.functions.percentile_cont (sqlalchemy.sql.functions.OrderedSetAgg)

class sqlalchemy.sql.functions.percentile_disc¶

实现 percentile_disc 有序集合聚合函数。

该函数必须与 FunctionElement.within_group() 修饰符一起使用，以提供要操作的排序表达式。

此函数的返回类型与排序表达式相同，或者如果参数是数组，则为 ARRAY 排序表达式的类型。

类签名

class sqlalchemy.sql.functions.percentile_disc (sqlalchemy.sql.functions.OrderedSetAgg)

class sqlalchemy.sql.functions.random¶: RANDOM() SQL 函数。

类签名

class sqlalchemy.sql.functions.random (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.rank¶

实现 rank 假设集合聚合函数。

该函数必须与 FunctionElement.within_group() 修饰符一起使用，以提供要操作的排序表达式。

该函数的返回值类型是 Integer.

类签名

class sqlalchemy.sql.functions.rank (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.rollup¶

实现 ROLLUP 分组操作。

该函数用作语句 GROUP BY 的一部分，例如 Select.group_by()

stmt = select(
    func.sum(table.c.value), table.c.col_1, table.c.col_2
).group_by(func.rollup(table.c.col_1, table.c.col_2))

新版功能，版本 1.2。

类签名

class sqlalchemy.sql.functions.rollup (sqlalchemy.sql.functions.GenericFunction)

class sqlalchemy.sql.functions.session_user¶: SESSION_USER() SQL 函数。

类签名

class sqlalchemy.sql.functions.session_user (sqlalchemy.sql.functions.AnsiFunction)

class sqlalchemy.sql.functions.sum¶: SQL SUM() 聚合函数。

类签名

class sqlalchemy.sql.functions.sum (sqlalchemy.sql.functions.ReturnTypeFromArgs)

class sqlalchemy.sql.functions.sysdate¶: SYSDATE() SQL 函数。

类签名

class sqlalchemy.sql.functions.sysdate (sqlalchemy.sql.functions.AnsiFunction)

class sqlalchemy.sql.functions.user¶: USER() SQL 函数。

类签名

class sqlalchemy.sql.functions.user (sqlalchemy.sql.functions.AnsiFunction)

SQLAlchemy 2.0 文档

SQLAlchemy 2.0 文档

SQLAlchemy Core

项目版本

SQL 和通用函数¶

函数 API¶

选定的“已知”函数¶