Python 客户端 API – DuckDB 数据库

搜索快捷键 cmd + k | ctrl + k

文档 / 客户端API / Python

Python 客户端 API

class duckdb.BinaryValue(object: Any)¶: 基类: Value

class duckdb.BinderException¶: 基类: ProgrammingError

class duckdb.BitValue(object: Any)¶: 基类: Value

class duckdb.BlobValue(object: Any)¶: 基类: Value

class duckdb.BooleanValue(object: Any)¶: 基类: Value

class duckdb.CSVLineTerminator¶

基类: pybind11_object

成员

LINE_FEED

CARRIAGE_RETURN_LINE_FEED

property name¶

duckdb.CaseExpression(condition: duckdb.duckdb.Expression, value: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶

class duckdb.CatalogException¶: 基类: ProgrammingError

duckdb.CoalesceOperator(*args) → duckdb.duckdb.Expression¶

duckdb.ColumnExpression(*args) → duckdb.duckdb.Expression¶: 从提供的列名创建列引用

class duckdb.ConnectionException¶: 基类: OperationalError

duckdb.ConstantExpression(value: object) → duckdb.duckdb.Expression¶: 从提供的值创建常量表达式

class duckdb.ConstraintException¶: 基类: IntegrityError

class duckdb.ConversionException¶: 基类: DataError

class duckdb.DataError¶: 基类: DatabaseError

class duckdb.DateValue(object: Any)¶: 基类: Value

class duckdb.DecimalValue(object: Any, width: int, scale: int)¶: 基类: Value

duckdb.DefaultExpression() → duckdb.duckdb.Expression¶

class duckdb.DoubleValue(object: Any)¶: 基类: Value

class duckdb.DuckDBPyConnection¶

基类: pybind11_object

append(self: duckdb.duckdb.DuckDBPyConnection, table_name: str, df: pandas.DataFrame, *, by_name: bool = False) → duckdb.duckdb.DuckDBPyConnection¶: 将传入的 DataFrame 追加到指定表

array_type(self: duckdb.duckdb.DuckDBPyConnection, type: duckdb.duckdb.typing.DuckDBPyType, size: int) → duckdb.duckdb.typing.DuckDBPyType¶: 创建“类型”的数组类型对象

arrow(self: duckdb.duckdb.DuckDBPyConnection, rows_per_batch: int = 1000000) → pyarrow.lib.Table¶: 执行后将结果作为 Arrow 表获取

begin(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶: 启动新事务

checkpoint(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶: 将预写日志 (WAL) 中的数据同步到数据库数据文件（对于内存连接是空操作）

close(self: duckdb.duckdb.DuckDBPyConnection) → None¶: 关闭连接

commit(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶: 提交事务中执行的更改

create_function(self: duckdb.duckdb.DuckDBPyConnection, name: str, function: Callable, parameters: object = None, return_type: duckdb.duckdb.typing.DuckDBPyType = None, *, type: duckdb.duckdb.functional.PythonUDFType = <PythonUDFType.NATIVE: 0>, null_handling: duckdb.duckdb.functional.FunctionNullHandling = <FunctionNullHandling.DEFAULT: 0>, exception_handling: duckdb.duckdb.PythonExceptionHandling = <PythonExceptionHandling.DEFAULT: 0>, side_effects: bool = False) → duckdb.duckdb.DuckDBPyConnection¶: 将传入的 Python 函数创建为 DuckDB 函数，以便在查询中使用

cursor(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶: 创建当前连接的副本

decimal_type(self: duckdb.duckdb.DuckDBPyConnection, width: int, scale: int) → duckdb.duckdb.typing.DuckDBPyType¶: 创建具有“宽度”和“比例”的十进制类型

property description¶: 获取结果集属性，主要是列名

df(self: duckdb.duckdb.DuckDBPyConnection, *, date_as_object: bool = False) → pandas.DataFrame¶: 执行后将结果作为 DataFrame 获取

dtype(self: duckdb.duckdb.DuckDBPyConnection, type_str: str) → duckdb.duckdb.typing.DuckDBPyType¶: 通过解析“type_str”字符串创建类型对象

duplicate(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶: 创建当前连接的副本

enum_type(self: duckdb.duckdb.DuckDBPyConnection, name: str, type: duckdb.duckdb.typing.DuckDBPyType, values: list) → duckdb.duckdb.typing.DuckDBPyType¶: 创建一个由“values”列表组成的底层“类型”的枚举类型

execute(self: duckdb.duckdb.DuckDBPyConnection, query: object, parameters: object = None) → duckdb.duckdb.DuckDBPyConnection¶: 执行给定的 SQL 查询，可选择使用已设置参数的预处理语句

executemany(self: duckdb.duckdb.DuckDBPyConnection, query: object, parameters: object = None) → duckdb.duckdb.DuckDBPyConnection¶: 使用参数集列表多次执行给定的预处理语句

extract_statements(self: duckdb.duckdb.DuckDBPyConnection, query: str) → list¶: 解析查询字符串并提取生成的 Statement 对象

fetch_arrow_table(self: duckdb.duckdb.DuckDBPyConnection, rows_per_batch: int = 1000000) → pyarrow.lib.Table¶: 执行后将结果作为 Arrow 表获取

fetch_df(self: duckdb.duckdb.DuckDBPyConnection, *, date_as_object: bool = False) → pandas.DataFrame¶: 执行后将结果作为 DataFrame 获取

fetch_df_chunk(self: duckdb.duckdb.DuckDBPyConnection, vectors_per_chunk: int = 1, *, date_as_object: bool = False) → pandas.DataFrame¶: 执行后将结果的一部分作为 DataFrame 获取

fetch_record_batch(self: duckdb.duckdb.DuckDBPyConnection, rows_per_batch: int = 1000000) → pyarrow.lib.RecordBatchReader¶: 执行后获取 Arrow RecordBatchReader

fetchall(self: duckdb.duckdb.DuckDBPyConnection) → list¶: 执行后从结果中获取所有行

fetchdf(self: duckdb.duckdb.DuckDBPyConnection, *, date_as_object: bool = False) → pandas.DataFrame¶: 执行后将结果作为 DataFrame 获取

fetchmany(self: duckdb.duckdb.DuckDBPyConnection, size: int = 1) → list¶: 执行后从结果中获取下一组行

fetchnumpy(self: duckdb.duckdb.DuckDBPyConnection) → dict¶: 执行后将结果作为 NumPy 数组列表获取

fetchone(self: duckdb.duckdb.DuckDBPyConnection) → Optional[tuple]¶: 执行后从结果中获取单行

filesystem_is_registered(self: duckdb.duckdb.DuckDBPyConnection, name: str) → bool¶: 检查是否已注册具有所提供名称的文件系统

from_arrow(self: duckdb.duckdb.DuckDBPyConnection, arrow_object: object) → duckdb.duckdb.DuckDBPyRelation¶: 从 Arrow 对象创建关系对象

from_csv_auto(self: duckdb.duckdb.DuckDBPyConnection, path_or_buffer: object, **kwargs) → duckdb.duckdb.DuckDBPyRelation¶: 从“名称”中的 CSV 文件创建关系对象

from_df(self: duckdb.duckdb.DuckDBPyConnection, df: pandas.DataFrame) → duckdb.duckdb.DuckDBPyRelation¶: 从 df 中的 DataFrame 创建关系对象

from_parquet(*args, **kwargs)¶

重载函数。

from_parquet(self: duckdb.duckdb.DuckDBPyConnection, file_glob: str, binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None) -> duckdb.duckdb.DuckDBPyRelation

从 file_glob 中的 Parquet 文件创建关系对象

from_parquet(self: duckdb.duckdb.DuckDBPyConnection, file_globs: list[str], binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None) -> duckdb.duckdb.DuckDBPyRelation

从 file_globs 中的 Parquet 文件创建关系对象

from_query(self: duckdb.duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) → duckdb.duckdb.DuckDBPyRelation¶: 运行 SQL 查询。如果是 SELECT 语句，则从给定 SQL 查询创建关系对象，否则按原样运行查询。

get_table_names(self: duckdb.duckdb.DuckDBPyConnection, query: str) → set[str]¶: 从查询中提取所需的表名

install_extension(self: duckdb.duckdb.DuckDBPyConnection, extension: str, *, force_install: bool = False, repository: object = None, repository_url: object = None, version: object = None) → None¶: 按名称安装扩展，可选择指定版本和/或获取扩展的存储库

interrupt(self: duckdb.duckdb.DuckDBPyConnection) → None¶: 中断待处理的操作

list_filesystems(self: duckdb.duckdb.DuckDBPyConnection) → list¶: 列出已注册的文件系统，包括内置文件系统

list_type(self: duckdb.duckdb.DuckDBPyConnection, type: duckdb.duckdb.typing.DuckDBPyType) → duckdb.duckdb.typing.DuckDBPyType¶: 创建“类型”的列表类型对象

load_extension(self: duckdb.duckdb.DuckDBPyConnection, extension: str) → None¶: 加载已安装的扩展

map_type(self: duckdb.duckdb.DuckDBPyConnection, key: duckdb.duckdb.typing.DuckDBPyType, value: duckdb.duckdb.typing.DuckDBPyType) → duckdb.duckdb.typing.DuckDBPyType¶: 从“key_type”和“value_type”创建映射类型对象

pl(self: duckdb.duckdb.DuckDBPyConnection, rows_per_batch: int = 1000000) → duckdb::PolarsDataFrame¶: 执行后将结果作为 Polars DataFrame 获取

query(self: duckdb.duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) → duckdb.duckdb.DuckDBPyRelation¶: 运行 SQL 查询。如果是 SELECT 语句，则从给定 SQL 查询创建关系对象，否则按原样运行查询。

read_csv(self: duckdb.duckdb.DuckDBPyConnection, path_or_buffer: object, **kwargs) → duckdb.duckdb.DuckDBPyRelation¶: 从“名称”中的 CSV 文件创建关系对象

read_json(self: duckdb.duckdb.DuckDBPyConnection, path_or_buffer: object, *, columns: Optional[object] = None, sample_size: Optional[object] = None, maximum_depth: Optional[object] = None, records: Optional[str] = None, format: Optional[str] = None, date_format: Optional[object] = None, timestamp_format: Optional[object] = None, compression: Optional[object] = None, maximum_object_size: Optional[object] = None, ignore_errors: Optional[object] = None, convert_strings_to_integers: Optional[object] = None, field_appearance_threshold: Optional[object] = None, map_inference_threshold: Optional[object] = None, maximum_sample_files: Optional[object] = None, filename: Optional[object] = None, hive_partitioning: Optional[object] = None, union_by_name: Optional[object] = None, hive_types: Optional[object] = None, hive_types_autocast: Optional[object] = None) → duckdb.duckdb.DuckDBPyRelation¶: 从“名称”中的 JSON 文件创建关系对象

read_parquet(*args, **kwargs)¶

重载函数。

read_parquet(self: duckdb.duckdb.DuckDBPyConnection, file_glob: str, binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None) -> duckdb.duckdb.DuckDBPyRelation

从 file_glob 中的 Parquet 文件创建关系对象

read_parquet(self: duckdb.duckdb.DuckDBPyConnection, file_globs: list[str], binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None) -> duckdb.duckdb.DuckDBPyRelation

从 file_globs 中的 Parquet 文件创建关系对象

register(self: duckdb.duckdb.DuckDBPyConnection, view_name: str, python_object: object) → duckdb.duckdb.DuckDBPyConnection¶: 注册传入的 Python 对象值以进行视图查询

register_filesystem(self: duckdb.duckdb.DuckDBPyConnection, filesystem: fsspec.AbstractFileSystem) → None¶: 注册符合 fsspec 标准的文件系统

remove_function(self: duckdb.duckdb.DuckDBPyConnection, name: str) → duckdb.duckdb.DuckDBPyConnection¶: 删除之前创建的函数

rollback(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶: 回滚事务中执行的更改

row_type(self: duckdb.duckdb.DuckDBPyConnection, fields: object) → duckdb.duckdb.typing.DuckDBPyType¶: 从“字段”创建结构类型对象

property rowcount¶: 获取结果集行数

sql(self: duckdb.duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) → duckdb.duckdb.DuckDBPyRelation¶: 运行 SQL 查询。如果是 SELECT 语句，则从给定 SQL 查询创建关系对象，否则按原样运行查询。

sqltype(self: duckdb.duckdb.DuckDBPyConnection, type_str: str) → duckdb.duckdb.typing.DuckDBPyType¶: 通过解析“type_str”字符串创建类型对象

string_type(self: duckdb.duckdb.DuckDBPyConnection, collation: str = '') → duckdb.duckdb.typing.DuckDBPyType¶: 创建带有可选排序规则的字符串类型

struct_type(self: duckdb.duckdb.DuckDBPyConnection, fields: object) → duckdb.duckdb.typing.DuckDBPyType¶: 从“字段”创建结构类型对象

table(self: duckdb.duckdb.DuckDBPyConnection, table_name: str) → duckdb.duckdb.DuckDBPyRelation¶: 为指定的表创建关系对象

table_function(self: duckdb.duckdb.DuckDBPyConnection, name: str, parameters: object = None) → duckdb.duckdb.DuckDBPyRelation¶: 从指定表函数和给定参数创建关系对象

tf(self: duckdb.duckdb.DuckDBPyConnection) → dict¶: 执行后将结果作为 TensorFlow Tensors 的字典获取

torch(self: duckdb.duckdb.DuckDBPyConnection) → dict¶: 执行后将结果作为 PyTorch Tensors 的字典获取

type(self: duckdb.duckdb.DuckDBPyConnection, type_str: str) → duckdb.duckdb.typing.DuckDBPyType¶: 通过解析“type_str”字符串创建类型对象

union_type(self: duckdb.duckdb.DuckDBPyConnection, members: object) → duckdb.duckdb.typing.DuckDBPyType¶: 从“成员”创建联合类型对象

unregister(self: duckdb.duckdb.DuckDBPyConnection, view_name: str) → duckdb.duckdb.DuckDBPyConnection¶: 注销视图名称

unregister_filesystem(self: duckdb.duckdb.DuckDBPyConnection, name: str) → None¶: 注销文件系统

values(self: duckdb.duckdb.DuckDBPyConnection, *args) → duckdb.duckdb.DuckDBPyRelation¶: 从传递的值创建关系对象

view(self: duckdb.duckdb.DuckDBPyConnection, view_name: str) → duckdb.duckdb.DuckDBPyRelation¶: 为命名视图创建关系对象

class duckdb.DuckDBPyRelation¶

基类: pybind11_object

详细示例请参见关系API页面。

aggregate(self: duckdb.duckdb.DuckDBPyRelation, aggr_expr: object, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 通过关系上的可选分组group_expr计算聚合aggr_expr

详细示例请参见关系API页面。

alias¶: 获取当前别名

详细示例请参见关系API页面。

any_value(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 返回给定列的第一个非空值

详细示例请参见关系API页面。

apply(self: duckdb.duckdb.DuckDBPyRelation, function_name: str, function_aggr: str, group_expr: str = '', function_parameter: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 通过关系上的可选分组计算单列或列列表的函数

详细示例请参见关系API页面。

arg_max(self: duckdb.duckdb.DuckDBPyRelation, arg_column: str, value_column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 查找值列具有最大值的行，并返回该行在参数列中的值

详细示例请参见关系API页面。

arg_min(self: duckdb.duckdb.DuckDBPyRelation, arg_column: str, value_column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 查找值列具有最小值的行，并返回该行在参数列中的值

详细示例请参见关系API页面。

arrow(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → pyarrow.lib.Table¶: 执行并以Arrow Table形式获取所有行

详细示例请参见关系API页面。

avg(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的平均值

详细示例请参见关系API页面。

bit_and(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中所有位值的按位AND

详细示例请参见关系API页面。

bit_or(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中所有位值的按位OR

详细示例请参见关系API页面。

bit_xor(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中所有位值的按位XOR

详细示例请参见关系API页面。

bitstring_agg(self: duckdb.duckdb.DuckDBPyRelation, column: str, min: Optional[object] = None, max: Optional[object] = None, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算一个位串，其中为给定列中的每个不同值设置了位

详细示例请参见关系API页面。

bool_and(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中所有值的逻辑AND

详细示例请参见关系API页面。

bool_or(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中所有值的逻辑OR

详细示例请参见关系API页面。

close(self: duckdb.duckdb.DuckDBPyRelation) → None¶: 关闭结果

详细示例请参见关系API页面。

columns¶: 返回包含关系列名称的列表。

详细示例请参见关系API页面。

count(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中元素的数量

详细示例请参见关系API页面。

create(self: duckdb.duckdb.DuckDBPyRelation, table_name: str) → None¶: 创建名为table_name的新表，其内容为关系对象

详细示例请参见关系API页面。

create_view(self: duckdb.duckdb.DuckDBPyRelation, view_name: str, replace: bool = True) → duckdb.duckdb.DuckDBPyRelation¶: 创建名为view_name的视图，该视图引用关系对象

详细示例请参见关系API页面。

cross(self: duckdb.duckdb.DuckDBPyRelation, other_rel: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶: 创建两个关系对象的交叉/笛卡尔积

详细示例请参见关系API页面。

cume_dist(self: duckdb.duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算分区内的累积分布

详细示例请参见关系API页面。

dense_rank(self: duckdb.duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算分区内的密集排名

详细示例请参见关系API页面。

describe(self: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶: 给出关系中每列的基本统计信息（例如，最小值、最大值）以及是否存在NULL。

详细示例请参见关系API页面。

description¶: 返回结果的描述

详细示例请参见关系API页面。

df(self: duckdb.duckdb.DuckDBPyRelation, *, date_as_object: bool = False) → pandas.DataFrame¶: 执行并以pandas DataFrame形式获取所有行

详细示例请参见关系API页面。

distinct(self: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶: 从该关系对象中检索不同的行

详细示例请参见关系API页面。

dtypes¶: 返回包含关系列类型的列表。

详细示例请参见关系API页面。

except_(self: duckdb.duckdb.DuckDBPyRelation, other_rel: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶: 创建此关系对象与other_rel中另一个关系对象的集合差

详细示例请参见关系API页面。

execute(self: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶: 将关系转换为结果集

详细示例请参见关系API页面。

explain(self: duckdb.duckdb.DuckDBPyRelation, type: duckdb.duckdb.ExplainType = 'standard') → str¶: 详细示例请参见关系API页面。

favg(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 使用更精确的浮点求和（Kahan Sum）计算给定列中所有值的平均值

详细示例请参见关系API页面。

fetch_arrow_reader(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → pyarrow.lib.RecordBatchReader¶: 执行并返回一个Arrow Record Batch Reader，它会生成所有行

详细示例请参见关系API页面。

fetch_arrow_table(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → pyarrow.lib.Table¶: 执行并以Arrow Table形式获取所有行

详细示例请参见关系API页面。

fetch_df_chunk(self: duckdb.duckdb.DuckDBPyRelation, vectors_per_chunk: int = 1, *, date_as_object: bool = False) → pandas.DataFrame¶: 执行并获取行的一个块

详细示例请参见关系API页面。

fetchall(self: duckdb.duckdb.DuckDBPyRelation) → list¶: 执行并以元组列表形式获取所有行

详细示例请参见关系API页面。

fetchdf(self: duckdb.duckdb.DuckDBPyRelation, *, date_as_object: bool = False) → pandas.DataFrame¶: 执行并以pandas DataFrame形式获取所有行

详细示例请参见关系API页面。

fetchmany(self: duckdb.duckdb.DuckDBPyRelation, size: int = 1) → list¶: 执行并以元组列表形式获取下一组行

详细示例请参见关系API页面。

fetchnumpy(self: duckdb.duckdb.DuckDBPyRelation) → dict¶: 执行并以Python字典形式获取所有行，将每列映射到一个numpy数组

详细示例请参见关系API页面。

fetchone(self: duckdb.duckdb.DuckDBPyRelation) → Optional[tuple]¶: 执行并以元组形式获取单行

详细示例请参见关系API页面。

filter(self: duckdb.duckdb.DuckDBPyRelation, filter_expr: object) → duckdb.duckdb.DuckDBPyRelation¶: 根据filter_expr中的过滤器过滤关系对象

详细示例请参见关系API页面。

first(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 返回给定列的第一个值

详细示例请参见关系API页面。

first_value(self: duckdb.duckdb.DuckDBPyRelation, column: str, window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算组内或分区内的第一个值

详细示例请参见关系API页面。

fsum(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 使用更精确的浮点求和（Kahan Sum）计算给定列中所有值的总和

详细示例请参见关系API页面。

geomean(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中所有值的几何平均值

详细示例请参见关系API页面。

histogram(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中所有值的直方图

详细示例请参见关系API页面。

insert(self: duckdb.duckdb.DuckDBPyRelation, values: object) → None¶: 将给定值插入关系中

详细示例请参见关系API页面。

insert_into(self: duckdb.duckdb.DuckDBPyRelation, table_name: str) → None¶: 将关系对象插入到名为table_name的现有表中

详细示例请参见关系API页面。

intersect(self: duckdb.duckdb.DuckDBPyRelation, other_rel: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶: 创建此关系对象与other_rel中另一个关系对象的集合交集

详细示例请参见关系API页面。

join(self: duckdb.duckdb.DuckDBPyRelation, other_rel: duckdb.duckdb.DuckDBPyRelation, condition: object, how: str = 'inner') → duckdb.duckdb.DuckDBPyRelation¶: 使用join_condition中的连接条件表达式将关系对象与other_rel中的另一个关系对象连接。支持的类型有“inner”、“left”、“right”、“outer”、“semi”和“anti”

详细示例请参见关系API页面。

lag(self: duckdb.duckdb.DuckDBPyRelation, column: str, window_spec: str, offset: int = 1, default_value: str = 'NULL', ignore_nulls: bool = False, projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算分区内的滞后值

详细示例请参见关系API页面。

last(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 返回给定列的最后一个值

详细示例请参见关系API页面。

last_value(self: duckdb.duckdb.DuckDBPyRelation, column: str, window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算组内或分区内的最后一个值

详细示例请参见关系API页面。

lead(self: duckdb.duckdb.DuckDBPyRelation, column: str, window_spec: str, offset: int = 1, default_value: str = 'NULL', ignore_nulls: bool = False, projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算分区内的前导值

详细示例请参见关系型 API 页面。

limit(self: duckdb.duckdb.DuckDBPyRelation, n: int, offset: int = 0) → duckdb.duckdb.DuckDBPyRelation¶: 仅从此关系对象中检索从指定偏移量开始的前 n 行

详细示例请参见关系型 API 页面。

list(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 返回一个列表，其中包含给定列中存在的所有值

详细示例请参见关系型 API 页面。

map(self: duckdb.duckdb.DuckDBPyRelation, map_function: Callable, *, schema: Optional[object] = None) → duckdb.duckdb.DuckDBPyRelation¶: 在关系上调用传入的函数

详细示例请参见关系型 API 页面。

max(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 返回给定列中存在的最大值

详细示例请参见关系型 API 页面。

mean(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的平均值

详细示例请参见关系型 API 页面。

median(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中所有值的中间值（中位数）

详细示例请参见关系型 API 页面。

min(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 返回给定列中存在的最小值

详细示例请参见关系型 API 页面。

mode(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中所有值的众数

详细示例请参见关系型 API 页面。

n_tile(self: duckdb.duckdb.DuckDBPyRelation, window_spec: str, num_buckets: int, projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 将分区尽可能平均地划分为 num_buckets 份

详细示例请参见关系型 API 页面。

nth_value(self: duckdb.duckdb.DuckDBPyRelation, column: str, window_spec: str, offset: int, ignore_nulls: bool = False, projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算分区内的第 n 个值

详细示例请参见关系型 API 页面。

order(self: duckdb.duckdb.DuckDBPyRelation, order_expr: str) → duckdb.duckdb.DuckDBPyRelation¶: 根据 order_expr 对关系对象重新排序

详细示例请参见关系型 API 页面。

percent_rank(self: duckdb.duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算分区内的相对排名

详细示例请参见关系型 API 页面。

pl(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → duckdb::PolarsDataFrame¶: 执行并以 Polars DataFrame 形式获取所有行

详细示例请参见关系型 API 页面。

product(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 返回给定列中所有值的乘积

详细示例请参见关系型 API 页面。

project(self: duckdb.duckdb.DuckDBPyRelation, *args, groups: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 通过 project_expr 中的投影来投射关系对象

详细示例请参见关系型 API 页面。

quantile(self: duckdb.duckdb.DuckDBPyRelation, column: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的精确分位数

详细示例请参见关系型 API 页面。

quantile_cont(self: duckdb.duckdb.DuckDBPyRelation, column: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的插值分位数

详细示例请参见关系型 API 页面。

quantile_disc(self: duckdb.duckdb.DuckDBPyRelation, column: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的精确分位数

详细示例请参见关系型 API 页面。

query(self: duckdb.duckdb.DuckDBPyRelation, virtual_table_name: str, sql_query: str) → duckdb.duckdb.DuckDBPyRelation¶: 对引用关系对象的名为 virtual_table_name 的视图运行 sql_query 中给定的 SQL 查询

详细示例请参见关系型 API 页面。

rank(self: duckdb.duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算分区内的排名

详细示例请参见关系型 API 页面。

rank_dense(self: duckdb.duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算分区内的密集排名

详细示例请参见关系型 API 页面。

record_batch(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → pyarrow.lib.RecordBatchReader¶: 执行并返回一个Arrow Record Batch Reader，它会生成所有行

详细示例请参见关系型 API 页面。

row_number(self: duckdb.duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算分区内的行号

详细示例请参见关系型 API 页面。

select(self: duckdb.duckdb.DuckDBPyRelation, *args, groups: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 通过 project_expr 中的投影来投射关系对象

详细示例请参见关系型 API 页面。

select_dtypes(self: duckdb.duckdb.DuckDBPyRelation, types: object) → duckdb.duckdb.DuckDBPyRelation¶: 从关系中选择列，通过基于类型进行筛选

详细示例请参见关系型 API 页面。

select_types(self: duckdb.duckdb.DuckDBPyRelation, types: object) → duckdb.duckdb.DuckDBPyRelation¶: 从关系中选择列，通过基于类型进行筛选

详细示例请参见关系型 API 页面。

set_alias(self: duckdb.duckdb.DuckDBPyRelation, alias: str) → duckdb.duckdb.DuckDBPyRelation¶: 将关系对象重命名为新别名

详细示例请参见关系型 API 页面。

shape¶: 关系中的行数和列数的元组。

详细示例请参见关系型 API 页面。

show(self: duckdb.duckdb.DuckDBPyRelation, *, max_width: Optional[int] = None, max_rows: Optional[int] = None, max_col_width: Optional[int] = None, null_value: Optional[str] = None, render_mode: object = None) → None¶: 显示数据的摘要

详细示例请参见关系型 API 页面。

sort(self: duckdb.duckdb.DuckDBPyRelation, *args) → duckdb.duckdb.DuckDBPyRelation¶: 根据提供的表达式对关系对象重新排序

详细示例请参见关系型 API 页面。

sql_query(self: duckdb.duckdb.DuckDBPyRelation) → str¶: 获取与该关系等效的 SQL 查询

详细示例请参见关系型 API 页面。

std(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的样本标准差

详细示例请参见关系型 API 页面。

stddev(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str ='') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的样本标准差

详细示例请参见关系型 API 页面。

stddev_pop(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的总体标准差

详细示例请参见关系型 API 页面。

stddev_samp(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的样本标准差

详细示例请参见关系型 API 页面。

string_agg(self: duckdb.duckdb.DuckDBPyRelation, column: str, sep: str = ',', groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 使用分隔符连接给定列中的值

详细示例请参见关系型 API 页面。

sum(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中所有值的总和

详细示例请参见关系型 API 页面。

tf(self: duckdb.duckdb.DuckDBPyRelation) → dict¶: 以 TensorFlow 张量字典的形式获取结果

详细示例请参见关系型 API 页面。

to_arrow_table(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → pyarrow.lib.Table¶: 执行并以Arrow Table形式获取所有行

详细示例请参见关系型 API 页面。

to_csv(self: duckdb.duckdb.DuckDBPyRelation, file_name: str, *, sep: object = None, na_rep: object = None, header: object = None, quotechar: object = None, escapechar: object = None, date_format: object = None, timestamp_format: object = None, quoting: object = None, encoding: object = None, compression: object = None, overwrite: object = None, per_thread_output: object = None, use_tmp_file: object = None, partition_by: object = None, write_partition_columns: object = None) → None¶: 将关系对象写入名为“file_name”的 CSV 文件

详细示例请参见关系型 API 页面。

to_df(self: duckdb.duckdb.DuckDBPyRelation, *, date_as_object: bool = False) → pandas.DataFrame¶: 执行并以pandas DataFrame形式获取所有行

详细示例请参见关系型 API 页面。

to_parquet(self: duckdb.duckdb.DuckDBPyRelation, file_name: str, *, compression: object = None, field_ids: object = None, row_group_size_bytes: object = None, row_group_size: object = None, overwrite: object = None, per_thread_output: object = None, use_tmp_file: object = None, partition_by: object = None, write_partition_columns: object = None, append: object = None) → None¶: 将关系对象写入名为“file_name”的Parquet文件。

详细示例请参见关系API页面。

to_table(self: duckdb.duckdb.DuckDBPyRelation, table_name: str) → None¶: 创建名为table_name的新表，其内容为关系对象

详细示例请参见关系API页面。

to_view(self: duckdb.duckdb.DuckDBPyRelation, view_name: str, replace: bool = True) → duckdb.duckdb.DuckDBPyRelation¶: 创建名为view_name的视图，该视图引用关系对象

详细示例请参见关系API页面。

torch(self: duckdb.duckdb.DuckDBPyRelation) → dict¶: 将结果作为PyTorch张量字典获取

详细示例请参见关系API页面。

type¶: 获取关系的类型。

详细示例请参见关系API页面。

types¶: 返回包含关系列类型的列表。

详细示例请参见关系API页面。

union(self: duckdb.duckdb.DuckDBPyRelation, union_rel: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶: 创建此关系对象与另一个关系对象（在 `other_rel` 中）的集合并集

详细示例请参见关系API页面。

unique(self: duckdb.duckdb.DuckDBPyRelation, unique_aggr: str) → duckdb.duckdb.DuckDBPyRelation¶: 返回列中的不同值。

详细示例请参见关系API页面。

update(self: duckdb.duckdb.DuckDBPyRelation, set: object, *, condition: object = None) → None¶: 使用提供的表达式更新给定关系

详细示例请参见关系API页面。

value_counts(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列中存在的元素数量，并投影原始列

详细示例请参见关系API页面。

var(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的样本方差

详细示例请参见关系API页面。

var_pop(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的总体方差

详细示例请参见关系API页面。

var_samp(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的样本方差

详细示例请参见关系API页面。

variance(self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶: 计算给定列的样本方差

详细示例请参见关系API页面。

write_csv(self: duckdb.duckdb.DuckDBPyRelation, file_name: str, *, sep: object = None, na_rep: object = None, header: object = None, quotechar: object = None, escapechar: object = None, date_format: object = None, timestamp_format: object = None, quoting: object = None, encoding: object = None, compression: object = None, overwrite: object = None, per_thread_output: object = None, use_tmp_file: object = None, partition_by: object = None, write_partition_columns: object = None) → None¶: 将关系对象写入名为“file_name”的 CSV 文件

详细示例请参见关系API页面。

write_parquet(self: duckdb.duckdb.DuckDBPyRelation, file_name: str, *, compression: object = None, field_ids: object = None, row_group_size_bytes: object = None, row_group_size: object = None, overwrite: object = None, per_thread_output: object = None, use_tmp_file: object = None, partition_by: object = None, write_partition_columns: object = None, append: object = None) → None¶: 将关系对象写入名为“file_name”的Parquet文件。

详细示例请参见关系API页面。

class duckdb.Error¶: 基类：Exception

class duckdb.ExpectedResultType¶

基类: pybind11_object

成员

QUERY_RESULT

CHANGED_ROWS

NOTHING

property name¶

class duckdb.ExplainType¶

基类: pybind11_object

成员

STANDARD

ANALYZE

property name¶

class duckdb.Expression¶

基类: pybind11_object

alias(self: duckdb.duckdb.Expression, arg0: str) → duckdb.duckdb.Expression¶

创建此表达式的副本并使用给定别名。

参数: name：表达式的别名，这将影响其引用方式。
返回: Expression：带有别名的自身。

asc(self: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶: 将排序修饰符设置为升序（ASCENDING）。

between(self: duckdb.duckdb.Expression, lower: duckdb.duckdb.Expression, upper: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶

cast(self: duckdb.duckdb.Expression, type: duckdb.duckdb.typing.DuckDBPyType) → duckdb.duckdb.Expression¶

从自身创建到给定类型 CastExpression

参数: type：要转换的类型
返回: CastExpression：自身::type

collate(self: duckdb.duckdb.Expression, collation: str) → duckdb.duckdb.Expression¶

desc(self: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶: 将排序修饰符设置为降序（DESCENDING）。

get_name(self: duckdb.duckdb.Expression) → str¶

返回表达式的字符串化版本。

返回: str：字符串表示。

isin(self: duckdb.duckdb.Expression, *args) → duckdb.duckdb.Expression¶

返回一个IN表达式，将自身与输入参数进行比较。

返回: DuckDBPyExpression：比较IN表达式

isnotin(self: duckdb.duckdb.Expression, *args) → duckdb.duckdb.Expression¶

返回一个NOT IN表达式，将自身与输入参数进行比较。

返回: DuckDBPyExpression：比较NOT IN表达式

isnotnull(self: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶

从自身创建一个二进制 IS NOT NULL 表达式

返回: DuckDBPyExpression：自身 IS NOT NULL

isnull(self: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶

从自身创建一个二进制 IS NULL 表达式

返回: DuckDBPyExpression：自身 IS NULL

nulls_first(self: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶: 将 NULL 排序修饰符设置为 NULLS FIRST。

nulls_last(self: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶: 将 NULL 排序修饰符设置为 NULLS LAST。

otherwise(self: duckdb.duckdb.Expression, value: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶

向 CaseExpression 添加 ELSE <value> 子句。

参数: value：当所有WHEN条件都不满足时使用的值。
返回: CaseExpression：带 ELSE 子句的自身。

show(self: duckdb.duckdb.Expression) → None¶: 打印表达式的字符串化版本。

when(self: duckdb.duckdb.Expression, condition: duckdb.duckdb.Expression, value: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶

向 CaseExpression 添加额外的 WHEN <condition> THEN <value> 子句。

参数: condition：必须满足的条件。value：如果条件满足则使用的值。
返回: CaseExpression：带有额外 WHEN 子句的自身。

class duckdb.FatalException¶: 基类: DatabaseError

class duckdb.FloatValue(object: Any)¶: 基类: Value

duckdb.FunctionExpression(function_name: str, *args) → duckdb.duckdb.Expression¶

class duckdb.HTTPException¶

基类：IOException

当 httpfs 扩展中或下载扩展时发生错误时抛出。

class duckdb.HugeIntegerValue(object: Any)¶: 基类: Value

class duckdb.IOException¶: 基类: OperationalError

class duckdb.IntegerValue(object: Any)¶: 基类: Value

class duckdb.IntegrityError¶: 基类: DatabaseError

class duckdb.InternalError¶: 基类: DatabaseError

class duckdb.InternalException¶: 基类：InternalError

class duckdb.InterruptException¶: 基类: DatabaseError

class duckdb.IntervalValue(object: Any)¶: 基类: Value

class duckdb.InvalidInputException¶: 基类: ProgrammingError

class duckdb.InvalidTypeException¶: 基类: ProgrammingError

duckdb.LambdaExpression(lhs: object, rhs: duckdb.duckdb.Expression) → duckdb.duckdb.Expression¶

class duckdb.LongValue(object: Any)¶: 基类: Value

class duckdb.NotImplementedException¶: 基类：NotSupportedError

class duckdb.NotSupportedError¶: 基类: DatabaseError

class duckdb.NullValue¶: 基类: Value

class duckdb.OperationalError¶: 基类: DatabaseError

class duckdb.OutOfMemoryException¶: 基类: OperationalError

class duckdb.OutOfRangeException¶: 基类: DataError

class duckdb.ParserException¶: 基类: ProgrammingError

class duckdb.PermissionException¶: 基类: DatabaseError

class duckdb.ProgrammingError¶: 基类: DatabaseError

class duckdb.PythonExceptionHandling¶

基类: pybind11_object

成员

DEFAULT

RETURN_NULL

property name¶

class duckdb.RenderMode¶

基类: pybind11_object

成员

ROWS

COLUMNS

property name¶

duckdb.SQLExpression(expression: str) → duckdb.duckdb.Expression¶

class duckdb.SequenceException¶: 基类: DatabaseError

class duckdb.SerializationException¶: 基类: OperationalError

class duckdb.ShortValue(object: Any)¶: 基类: Value

duckdb.StarExpression(*args, **kwargs)¶

重载函数。

StarExpression(*, exclude: object = None) -> duckdb.duckdb.Expression
StarExpression() -> duckdb.duckdb.Expression

class duckdb.Statement¶

基类: pybind11_object

property expected_result_type¶: 获取此语句预期产生的结果类型，实际类型可能因语句而异。

property named_parameters¶: 获取此语句具有的命名参数映射。

property query¶: 获取与此语句等效的查询。

property type¶: 获取语句的类型。

class duckdb.StatementType¶

基类: pybind11_object

成员

INVALID

SELECT

INSERT

UPDATE

CREATE

DELETE

PREPARE

EXECUTE

ALTER

TRANSACTION

COPY

ANALYZE

VARIABLE_SET

CREATE_FUNC

EXPLAIN

DROP

EXPORT

PRAGMA

VACUUM

CALL

SET

LOAD

RELATION

EXTENSION

LOGICAL_PLAN

ATTACH

DETACH

MULTI

COPY_DATABASE

property name¶

class duckdb.StringValue(object: Any)¶: 基类: Value

class duckdb.SyntaxException¶: 基类: ProgrammingError

class duckdb.TimeTimeZoneValue(object: Any)¶: 基类: Value

class duckdb.TimeValue(object: Any)¶: 基类: Value

class duckdb.TimestampMilisecondValue(object: Any)¶: 基类: Value

class duckdb.TimestampNanosecondValue(object: Any)¶: 基类: Value

class duckdb.TimestampSecondValue(object: Any)¶: 基类: Value

class duckdb.TimestampTimeZoneValue(object: Any)¶: 基类: Value

class duckdb.TimestampValue(object: Any)¶: 基类: Value

class duckdb.TransactionException¶: 基类: OperationalError

class duckdb.TypeMismatchException¶: 基类: DataError

class duckdb.UUIDValue(object: Any)¶: 基类: Value

class duckdb.UnsignedBinaryValue(object: Any)¶: 基类: Value

class duckdb.UnsignedIntegerValue(object: Any)¶: 基类: Value

class duckdb.UnsignedLongValue(object: Any)¶: 基类: Value

class duckdb.UnsignedShortValue(object: Any)¶: 基类: Value

class duckdb.Value(object: Any, type: DuckDBPyType)¶: 基类：object

class duckdb.Warning¶: 基类：Exception

duckdb.aggregate(df: pandas.DataFrame, aggr_expr: object, group_expr: str = '', *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 通过关系上的可选分组group_expr计算聚合aggr_expr

duckdb.alias(df: pandas.DataFrame, alias: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 将关系对象重命名为新别名

duckdb.append(table_name: str, df: pandas.DataFrame, *, by_name: bool = False, connection: duckdb.duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyConnection¶: 将传入的 DataFrame 追加到指定表

duckdb.array_type(type: duckdb.duckdb.typing.DuckDBPyType, size: int, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 创建“类型”的数组类型对象

arrow(*args, **kwargs)¶

重载函数。

arrow(rows_per_batch: int = 1000000, *, connection: duckdb.DuckDBPyConnection = None) -> pyarrow.lib.Table

执行后将结果作为 Arrow 表获取

arrow(rows_per_batch: int = 1000000, *, connection: duckdb.DuckDBPyConnection = None) -> pyarrow.lib.Table

执行后将结果作为 Arrow 表获取

arrow(arrow_object: object, *, connection: duckdb.DuckDBPyConnection = None) -> duckdb.duckdb.DuckDBPyRelation

从 Arrow 对象创建关系对象

duckdb.begin(*, connection: duckdb.Duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyConnection¶: 启动新事务

duckdb.checkpoint(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyConnection¶: 将预写日志 (WAL) 中的数据同步到数据库数据文件（对于内存连接是空操作）

duckdb.close(*, connection: duckdb.DuckDBPyConnection = None) → None¶: 关闭连接

duckdb.commit(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: 提交事务中执行的更改

duckdb.connect(database: object = ':memory:', read_only: bool = False, config: dict = None) → duckdb.DuckDBPyConnection¶: 创建一个 DuckDB 数据库实例。可以提供一个数据库文件名以读/写持久化数据，并且可以设置一个 read_only 标志，如果不需要进行更改。

duckdb.create_function(name: str, function: Callable, parameters: object = None, return_type: duckdb.duckdb.typing.DuckDBPyType = None, *, type: duckdb.duckdb.functional.PythonUDFType = <PythonUDFType.NATIVE: 0>, null_handling: duckdb.duckdb.functional.FunctionNullHandling = <FunctionNullHandling.DEFAULT: 0>, exception_handling: duckdb.duckdb.PythonExceptionHandling = <PythonExceptionHandling.DEFAULT: 0>, side_effects: bool = False, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: 将传入的 Python 函数创建为 DuckDB 函数，以便在查询中使用

duckdb.cursor(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: 创建当前连接的副本

duckdb.decimal_type(width: int, scale: int, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 创建具有“宽度”和“比例”的十进制类型

duckdb.default_connection() → duckdb.DuckDBPyConnection¶: 获取当前注册为模块默认连接的连接对象。

duckdb.description(*, connection: duckdb.DuckDBPyConnection = None) → Optional[list]¶: 获取结果集属性，主要是列名

duckdb.df(*args, **kwargs)¶

重载函数。

df(*, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) -> pandas.DataFrame

执行后将结果作为 DataFrame 获取

df(*, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) -> pandas.DataFrame

执行后将结果作为 DataFrame 获取

df(df: pandas.DataFrame, *, connection: duckdb.DuckDBPyConnection = None) -> duckdb.duckdb.DuckDBPyRelation

从 DataFrame df 创建一个关系对象

duckdb.distinct(df: pandas.DataFrame, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 从该关系对象中检索不同的行

duckdb.dtype(type_str: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 通过解析“type_str”字符串创建类型对象

duckdb.duplicate(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: 创建当前连接的副本

duckdb.enum_type(name: str, type: duckdb.duckdb.typing.DuckDBPyType, values: list, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 创建一个由“values”列表组成的底层“类型”的枚举类型

duckdb.execute(query: object, parameters: object = None, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: 执行给定的 SQL 查询，可选择使用已设置参数的预处理语句

duckdb.executemany(query: object, parameters: object = None, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: 使用参数集列表多次执行给定的预处理语句

duckdb.extract_statements(query: str, *, connection: duckdb.DuckDBPyConnection = None) → list¶: 解析查询字符串并提取生成的 Statement 对象

duckdb.fetch_arrow_table(rows_per_batch: int = 1000000, *, connection: duckdb.DuckDBPyConnection = None) → pyarrow.lib.Table¶: 执行后将结果作为 Arrow 表获取

duckdb.fetch_df(*, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) → pandas.DataFrame¶: 执行后将结果作为 DataFrame 获取

duckdb.fetch_df_chunk(vectors_per_chunk: int = 1, *, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) → pandas.DataFrame¶: 执行后将结果的一部分作为 DataFrame 获取

duckdb.fetch_record_batch(rows_per_batch: int = 1000000, *, connection: duckdb.DuckDBPyConnection = None) → pyarrow.lib.RecordBatchReader¶: 执行后获取 Arrow RecordBatchReader

duckdb.fetchall(*, connection: duckdb.DuckDBPyConnection = None) → list¶: 执行后从结果中获取所有行

duckdb.fetchdf(*, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) → pandas.DataFrame¶: 执行后将结果作为 DataFrame 获取

duckdb.fetchmany(size: int = 1, *, connection: duckdb.DuckDBPyConnection = None) → list¶: 执行后从结果中获取下一组行

duckdb.fetchnumpy(*, connection: duckdb.DuckDBPyConnection = None) → dict¶: 执行后将结果作为 NumPy 数组列表获取

duckdb.fetchone(*, connection: duckdb.DuckDBPyConnection = None) → Optional[tuple]¶: 执行后从结果中获取单行

duckdb.filesystem_is_registered(name: str, *, connection: duckdb.DuckDBPyConnection = None) → bool¶: 检查是否已注册具有所提供名称的文件系统

duckdb.filter(df: pandas.DataFrame, filter_expr: object, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 根据filter_expr中的过滤器过滤关系对象

duckdb.from_arrow(arrow_object: object, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 从 Arrow 对象创建关系对象

duckdb.from_csv_auto(path_or_buffer: object, **kwargs) → duckdb.duckdb.DuckDBPyRelation¶: 从“名称”中的 CSV 文件创建关系对象

duckdb.from_df(df: pandas.DataFrame, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 从 df 中的 DataFrame 创建关系对象

duckdb.from_parquet(*args, **kwargs)¶

重载函数。

from_parquet(file_glob: str, binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None, connection: duckdb.DuckDBPyConnection = None) -> duckdb.duckdb.DuckDBPyRelation

从 file_glob 中的 Parquet 文件创建关系对象

from_parquet(file_globs: list[str], binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None, connection: duckdb.DuckDBPyConnection = None) -> duckdb.duckdb.DuckDBPyRelation

从 file_globs 中的 Parquet 文件创建关系对象

duckdb.from_query(query: object, *, alias: str = '', params: object = None, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 运行 SQL 查询。如果是 SELECT 语句，则从给定 SQL 查询创建关系对象，否则按原样运行查询。

duckdb.get_table_names(query: str, *, connection: duckdb.DuckDBPyConnection = None) → set[str]¶: 从查询中提取所需的表名

duckdb.install_extension(extension: str, *, force_install: bool = False, repository: object = None, repository_url: object = None, version: object = None, connection: duckdb.DuckDBPyConnection = None) → None¶: 按名称安装扩展，可选择指定版本和/或获取扩展的存储库

duckdb.interrupt(*, connection: duckdb.DuckDBPyConnection = None) → None¶: 中断待处理的操作

duckdb.limit(df: pandas.DataFrame, n: int, offset: int = 0, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 仅从此关系对象中检索从指定偏移量开始的前 n 行

duckdb.list_filesystems(*, connection: duckdb.DuckDBPyConnection = None) → list¶: 列出已注册的文件系统，包括内置文件系统

duckdb.list_type(type: duckdb.duckdb.typing.DuckDBPyType, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 创建“类型”的列表类型对象

duckdb.load_extension(extension: str, *, connection: duckdb.DuckDBPyConnection = None) → None¶: 加载已安装的扩展

duckdb.map_type(key: duckdb.duckdb.typing.DuckDBPyType, value: duckdb.duckdb.typing.DuckDBPyType, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 从“key_type”和“value_type”创建映射类型对象

duckdb.order(df: pandas.DataFrame, order_expr: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 根据 order_expr 对关系对象重新排序

duckdb.pl(rows_per_batch: int = 1000000, *, connection: duckdb.DuckDBPyConnection = None) → duckdb::PolarsDataFrame¶: 执行后将结果作为 Polars DataFrame 获取

duckdb.project(df: pandas.DataFrame, *args, groups: str = '', connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 通过 project_expr 中的投影来投射关系对象

duckdb.query(query: object, *, alias: str = '', params: object = None, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 运行 SQL 查询。如果是 SELECT 语句，则从给定 SQL 查询创建关系对象，否则按原样运行查询。

duckdb.query_df(df: pandas.DataFrame, virtual_table_name: str, sql_query: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 对引用关系对象的名为 virtual_table_name 的视图运行 sql_query 中给定的 SQL 查询

duckdb.read_csv(path_or_buffer: object, **kwargs) → duckdb.duckdb.DuckDBPyRelation¶: 从“名称”中的 CSV 文件创建关系对象

duckdb.read_json(path_or_buffer: object, *, columns: Optional[object] = None, sample_size: Optional[object] = None, maximum_depth: Optional[object] = None, records: Optional[str] = None, format: Optional[str] = None, date_format: Optional[object] = None, timestamp_format: Optional[object] = None, compression: Optional[object] = None, maximum_object_size: Optional[object] = None, ignore_errors: Optional[object] = None, convert_strings_to_integers: Optional[object] = None, field_appearance_threshold: Optional[object] = None, map_inference_threshold: Optional[object] = None, maximum_sample_files: Optional[object] = None, filename: Optional[object] = None, hive_partitioning: Optional[object] = None, union_by_name: Optional[object] = None, hive_types: Optional[object] = None, hive_types_autocast: Optional[object] = None, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 从“名称”中的 JSON 文件创建关系对象

duckdb.read_parquet(*args, **kwargs)¶

重载函数。

read_parquet(file_glob: str, binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None, connection: duckdb.DuckDBPyConnection = None) -> duckdb.duckdb.DuckDBPyRelation

从 file_glob 中的 Parquet 文件创建关系对象

read_parquet(file_globs: list[str], binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None, connection: duckdb.DuckDBPyConnection = None) -> duckdb.duckdb.DuckDBPyRelation

从 file_globs 中的 Parquet 文件创建关系对象

duckdb.register(view_name: str, python_object: object, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: 注册传入的 Python 对象值以进行视图查询

duckdb.register_filesystem(filesystem: fsspec.AbstractFileSystem, *, connection: duckdb.DuckDBPyConnection = None) → None¶: 注册符合 fsspec 标准的文件系统

duckdb.remove_function(name: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: 删除之前创建的函数

duckdb.rollback(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: 回滚事务中执行的更改

duckdb.row_type(fields: object, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 从“字段”创建结构类型对象

duckdb.rowcount(*, connection: duckdb.DuckDBPyConnection = None) → int¶: 获取结果集行数

duckdb.set_default_connection(connection: duckdb.DuckDBPyConnection) → None¶: 将提供的连接注册为模块使用的默认连接

duckdb.sql(query: object, *, alias: str = '', params: object = None, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 运行 SQL 查询。如果是 SELECT 语句，则从给定 SQL 查询创建关系对象，否则按原样运行查询。

duckdb.sqltype(type_str: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 通过解析“type_str”字符串创建类型对象

duckdb.string_type(collation: str = '', *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 创建带有可选排序规则的字符串类型

duckdb.struct_type(fields: object, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 从“字段”创建结构类型对象

duckdb.table(table_name: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 为指定的表创建关系对象

duckdb.table_function(name: str, parameters: object = None, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 从指定表函数和给定参数创建关系对象

duckdb.tf(*, connection: duckdb.DuckDBPyConnection = None) → dict¶: 执行后将结果作为 TensorFlow Tensors 的字典获取

class duckdb.token_type¶

基类: pybind11_object

成员

标识符

数字常量

字符串常量

运算符

关键字

注释

property name¶

duckdb.tokenize(query: str) → list¶: 将 SQL 字符串分词，返回一个 (位置, 类型) 元组列表，可用于例如语法高亮。

duckdb.torch(*, connection: duckdb.DuckDBPyConnection = None) → dict¶: 执行后将结果作为 PyTorch Tensors 的字典获取

duckdb.type(type_str: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 通过解析“type_str”字符串创建类型对象

duckdb.union_type(members: object, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.typing.DuckDBPyType¶: 从“成员”创建联合类型对象

duckdb.unregister(view_name: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: 注销视图名称

duckdb.unregister_filesystem(name: str, *, connection: duckdb.DuckDBPyConnection = None) → None¶: 注销文件系统

duckdb.values(*args, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 从传递的值创建关系对象

duckdb.view(view_name: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.duckdb.DuckDBPyRelation¶: 为命名视图创建关系对象

duckdb.write_csv(df: pandas.DataFrame, filename: str, *, sep: object = None, na_rep: object = None, header: object = None, quotechar: object = None, escapechar: object = None, date_format: object = None, timestamp_format: object = None, quoting: object = None, encoding: object = None, compression: object = None, overwrite: object = None, per_thread_output: object = None, use_tmp_file: object = None, partition_by: object = None, write_partition_columns: object = None, connection: duckdb.DuckDBPyConnection = None) → None¶: 将关系对象写入名为“file_name”的 CSV 文件

关于此页面