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¶ – 额外的 kwargs 通常由子类使用。

另请参阅

func

Function

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

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

提示

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

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 函数构造，当与 relationship.primaryjoin 参数一起使用时，该构造还可以向 ORM 提供此信息。返回值是一个名为 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，则列值函数中的 “table” 部分可以是 FROM 子句的成员，而无需任何显式 JOIN 到 SQL 查询中的其他表，并且不会生成 “笛卡尔积” 警告。对于诸如 func.json_array_elements() 之类的 SQL 函数可能很有用。

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，因为函数通常是列表达式而不是 FromClause。

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。

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

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

返回此 FunctionElement 的 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, ...)

method 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 统一教程中

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

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

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

class 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

上面的函数将可以从 func 使用包名称 time 访问

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” 属性一起使用时的引号，以便可以强制打开或关闭函数名称的引号。

类签名

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

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

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

这通常由 GenericFunction 调用，但它本身也可用，以便可以将非 Function 构造与 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¶

选定的“已知”函数¶