Bases: pybind11_object

append(self: duckdb.duckdb.DuckDBPyConnection, table_name: str, df: pandas.DataFrame, *, by_name: bool = False) → duckdb.duckdb.DuckDBPyConnection¶

Append the passed DataFrame to the named table

array_type(self: duckdb.duckdb.DuckDBPyConnection, type: duckdb.duckdb.typing.DuckDBPyType) → duckdb.duckdb.typing.DuckDBPyType¶

Create an array type object of ‘type’

arrow(self: duckdb.duckdb.DuckDBPyConnection, rows_per_batch: int = 1000000) → pyarrow.lib.Table¶

Fetch a result as Arrow table following execute()

begin(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶

Start a new transaction

close(self: duckdb.duckdb.DuckDBPyConnection) → None¶

Close the connection

commit(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶

Commit changes performed within a transaction

create_function(self: duckdb.duckdb.DuckDBPyConnection, name: str, function: function, return_type: object = None, parameters: duckdb.duckdb.typing.DuckDBPyType = None, *, type: duckdb.duckdb.functional.PythonUDFType = <PythonUDFType.NATIVE: 0>, null_handling: duckdb.duckdb.functional.FunctionNullHandling = 0, exception_handling: duckdb.duckdb.PythonExceptionHandling = 0, side_effects: bool = False) → duckdb.duckdb.DuckDBPyConnection¶

Create a DuckDB function out of the passing in python function so it can be used in queries

cursor(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶

Create a duplicate of the current connection

decimal_type(self: duckdb.duckdb.DuckDBPyConnection, width: int, scale: int) → duckdb.duckdb.typing.DuckDBPyType¶

Create a decimal type with ‘width’ and ‘scale’

property description¶

Get result set attributes, mainly column names

df(self: duckdb.duckdb.DuckDBPyConnection, *, date_as_object: bool = False) → pandas.DataFrame¶

Fetch a result as DataFrame following execute()

dtype(self: duckdb.duckdb.DuckDBPyConnection, type_str: str) → duckdb.duckdb.typing.DuckDBPyType¶

Create a type object by parsing the ‘type_str’ string

duplicate(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶

Create a duplicate of the current connection

enum_type(self: duckdb.duckdb.DuckDBPyConnection, name: str, type: duckdb.duckdb.typing.DuckDBPyType, values: list) → duckdb.duckdb.typing.DuckDBPyType¶

Create an enum type of underlying ‘type’, consisting of the list of ‘values’

execute(self: duckdb.duckdb.DuckDBPyConnection, query: str, parameters: object = None, multiple_parameter_sets: bool = False) → duckdb.duckdb.DuckDBPyConnection¶

Execute the given SQL query, optionally using prepared statements with parameters set

executemany(self: duckdb.duckdb.DuckDBPyConnection, query: str, parameters: object = None) → duckdb.duckdb.DuckDBPyConnection¶

Execute the given prepared statement multiple times using the list of parameter sets in parameters

fetch_arrow_table(self: duckdb.duckdb.DuckDBPyConnection, rows_per_batch: int = 1000000) → pyarrow.lib.Table¶

Fetch a result as Arrow table following execute()

fetch_df(self: duckdb.duckdb.DuckDBPyConnection, *, date_as_object: bool = False) → pandas.DataFrame¶

Fetch a result as DataFrame following execute()

fetch_df_chunk(self: duckdb.duckdb.DuckDBPyConnection, vectors_per_chunk: int = 1, *, date_as_object: bool = False) → pandas.DataFrame¶

Fetch a chunk of the result as Data.Frame following execute()

fetch_record_batch(self: duckdb.duckdb.DuckDBPyConnection, rows_per_batch: int = 1000000) → pyarrow.lib.RecordBatchReader¶

Fetch an Arrow RecordBatchReader following execute()

fetchall(self: duckdb.duckdb.DuckDBPyConnection) → list¶

Fetch all rows from a result following execute

fetchdf(self: duckdb.duckdb.DuckDBPyConnection, *, date_as_object: bool = False) → pandas.DataFrame¶

Fetch a result as DataFrame following execute()

fetchmany(self: duckdb.duckdb.DuckDBPyConnection, size: int = 1) → list¶

Fetch the next set of rows from a result following execute

fetchnumpy(self: duckdb.duckdb.DuckDBPyConnection) → dict¶

Fetch a result as list of NumPy arrays following execute

fetchone(self: duckdb.duckdb.DuckDBPyConnection) → Optional[tuple]¶

Fetch a single row from a result following execute

filesystem_is_registered(self: duckdb.duckdb.DuckDBPyConnection, name: str) → bool¶

Check if a filesystem with the provided name is currently registered

from_arrow(self: duckdb.duckdb.DuckDBPyConnection, arrow_object: object) → duckdb.duckdb.DuckDBPyRelation¶

Create a relation object from an Arrow object

from_csv_auto(self: duckdb.duckdb.DuckDBPyConnection, name: object, *, header: object = None, compression: object = None, sep: object = None, delimiter: object = None, dtype: object = None, na_values: object = None, skiprows: object = None, quotechar: object = None, escapechar: object = None, encoding: object = None, parallel: object = None, date_format: object = None, timestamp_format: object = None, sample_size: object = None, all_varchar: object = None, normalize_names: object = None, filename: object = None, null_padding: object = None) → duckdb.duckdb.DuckDBPyRelation¶

Create a relation object from the CSV file in ‘name’

from_df(self: duckdb.duckdb.DuckDBPyConnection, df: pandas.DataFrame = None) → duckdb.duckdb.DuckDBPyRelation¶

Create a relation object from the Data.Frame in df

from_parquet(*args, **kwargs)¶

Overloaded function.

1. 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

Create a relation object from the Parquet files in file_glob

2. 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

Create a relation object from the Parquet files in file_globs

from_query(self: duckdb.duckdb.DuckDBPyConnection, query: str, *, alias: str = '', params: object = None) → duckdb.duckdb.DuckDBPyRelation¶

Run a SQL query. If it is a SELECT statement, create a relation object from the given SQL query, otherwise run the query as-is.

from_substrait(self: duckdb.duckdb.DuckDBPyConnection, proto: bytes) → duckdb.duckdb.DuckDBPyRelation¶

Create a query object from protobuf plan

from_substrait_json(self: duckdb.duckdb.DuckDBPyConnection, json: str) → duckdb.duckdb.DuckDBPyRelation¶

Create a query object from a JSON protobuf plan

get_substrait(self: duckdb.duckdb.DuckDBPyConnection, query: str, *, enable_optimizer: bool = True) → duckdb.duckdb.DuckDBPyRelation¶

Serialize a query to protobuf

get_substrait_json(self: duckdb.duckdb.DuckDBPyConnection, query: str, *, enable_optimizer: bool = True) → duckdb.duckdb.DuckDBPyRelation¶

Serialize a query to protobuf on the JSON format

get_table_names(self: duckdb.duckdb.DuckDBPyConnection, query: str) → Set[str]¶

Extract the required table names from a query

install_extension(self: duckdb.duckdb.DuckDBPyConnection, extension: str, *, force_install: bool = False) → None¶

Install an extension by name

interrupt(self: duckdb.duckdb.DuckDBPyConnection) → None¶

Interrupt pending operations

list_filesystems(self: duckdb.duckdb.DuckDBPyConnection) → list¶

List registered filesystems, including builtin ones

list_type(self: duckdb.duckdb.DuckDBPyConnection, type: duckdb.duckdb.typing.DuckDBPyType) → duckdb.duckdb.typing.DuckDBPyType¶

Create an array type object of ‘type’

load_extension(self: duckdb.duckdb.DuckDBPyConnection, extension: str) → None¶

Load an installed extension

map_type(self: duckdb.duckdb.DuckDBPyConnection, key: duckdb.duckdb.typing.DuckDBPyType, value: duckdb.duckdb.typing.DuckDBPyType) → duckdb.duckdb.typing.DuckDBPyType¶

Create a map type object from ‘key_type’ and ‘value_type’

pl(self: duckdb.duckdb.DuckDBPyConnection, rows_per_batch: int = 1000000) → duckdb::PolarsDataFrame¶

Fetch a result as Polars DataFrame following execute()

query(self: duckdb.duckdb.DuckDBPyConnection, query: str, *, alias: str = '', params: object = None) → duckdb.duckdb.DuckDBPyRelation¶

Run a SQL query. If it is a SELECT statement, create a relation object from the given SQL query, otherwise run the query as-is.

read_csv(self: duckdb.duckdb.DuckDBPyConnection, name: object, *, header: object = None, compression: object = None, sep: object = None, delimiter: object = None, dtype: object = None, na_values: object = None, skiprows: object = None, quotechar: object = None, escapechar: object = None, encoding: object = None, parallel: object = None, date_format: object = None, timestamp_format: object = None, sample_size: object = None, all_varchar: object = None, normalize_names: object = None, filename: object = None, null_padding: object = None) → duckdb.duckdb.DuckDBPyRelation¶

Create a relation object from the CSV file in ‘name’

read_json(self: duckdb.duckdb.DuckDBPyConnection, name: str, *, columns: Optional[object] = None, sample_size: Optional[object] = None, maximum_depth: Optional[object] = None, records: Optional[str] = None, format: Optional[str] = None) → duckdb.duckdb.DuckDBPyRelation¶

Create a relation object from the JSON file in ‘name’

read_parquet(*args, **kwargs)¶

Overloaded function.

1. 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

Create a relation object from the Parquet files in file_glob

2. 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

Create a relation object from the Parquet files in file_globs

register(self: duckdb.duckdb.DuckDBPyConnection, view_name: str, python_object: object) → duckdb.duckdb.DuckDBPyConnection¶

Register the passed Python Object value for querying with a view

register_filesystem(self: duckdb.duckdb.DuckDBPyConnection, filesystem: fsspec.AbstractFileSystem) → None¶

Register a fsspec compliant filesystem

remove_function(self: duckdb.duckdb.DuckDBPyConnection, name: str) → duckdb.duckdb.DuckDBPyConnection¶

Remove a previously created function

rollback(self: duckdb.duckdb.DuckDBPyConnection) → duckdb.duckdb.DuckDBPyConnection¶

Roll back changes performed within a transaction

row_type(self: duckdb.duckdb.DuckDBPyConnection, fields: object) → duckdb.duckdb.typing.DuckDBPyType¶

Create a struct type object from ‘fields’

sql(self: duckdb.duckdb.DuckDBPyConnection, query: str, *, alias: str = '', params: object = None) → duckdb.duckdb.DuckDBPyRelation¶

Run a SQL query. If it is a SELECT statement, create a relation object from the given SQL query, otherwise run the query as-is.

sqltype(self: duckdb.duckdb.DuckDBPyConnection, type_str: str) → duckdb.duckdb.typing.DuckDBPyType¶

Create a type object by parsing the ‘type_str’ string

string_type(self: duckdb.duckdb.DuckDBPyConnection, collation: str = '') → duckdb.duckdb.typing.DuckDBPyType¶

Create a string type with an optional collation

struct_type(self: duckdb.duckdb.DuckDBPyConnection, fields: object) → duckdb.duckdb.typing.DuckDBPyType¶

Create a struct type object from ‘fields’

table(self: duckdb.duckdb.DuckDBPyConnection, table_name: str) → duckdb.duckdb.DuckDBPyRelation¶

Create a relation object for the name’d table

table_function(self: duckdb.duckdb.DuckDBPyConnection, name: str, parameters: object = None) → duckdb.duckdb.DuckDBPyRelation¶

Create a relation object from the name’d table function with given parameters

tf(self: duckdb.duckdb.DuckDBPyConnection) → dict¶

Fetch a result as dict of TensorFlow Tensors following execute()

torch(self: duckdb.duckdb.DuckDBPyConnection) → dict¶

Fetch a result as dict of PyTorch Tensors following execute()

type(self: duckdb.duckdb.DuckDBPyConnection, type_str: str) → duckdb.duckdb.typing.DuckDBPyType¶

Create a type object by parsing the ‘type_str’ string

union_type(self: duckdb.duckdb.DuckDBPyConnection, members: object) → duckdb.duckdb.typing.DuckDBPyType¶

Create a union type object from ‘members’

unregister(self: duckdb.duckdb.DuckDBPyConnection, view_name: str) → duckdb.duckdb.DuckDBPyConnection¶

Unregister the view name

unregister_filesystem(self: duckdb.duckdb.DuckDBPyConnection, name: str) → None¶

Unregister a filesystem

values(self: duckdb.duckdb.DuckDBPyConnection, values: object) → duckdb.duckdb.DuckDBPyRelation¶

Create a relation object from the passed values

view(self: duckdb.duckdb.DuckDBPyConnection, view_name: str) → duckdb.duckdb.DuckDBPyRelation¶

Create a relation object for the name’d view

Bases: pybind11_object

abs(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str) → duckdb.duckdb.DuckDBPyRelation¶

Returns the absolute value for the specified columns.

aggregate(self: duckdb.duckdb.DuckDBPyRelation, aggr_expr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the aggregate aggr_expr by the optional groups group_expr on the relation

property alias¶

Get the name of the current alias

apply(self: duckdb.duckdb.DuckDBPyRelation, function_name: str, function_aggr: str, group_expr: str = '', function_parameter: str = '', projected_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the function of a single column or a list of columns by the optional groups on the relation

arrow(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → pyarrow.lib.Table¶

Execute and fetch all rows as an Arrow Table

close(self: duckdb.duckdb.DuckDBPyRelation) → None¶

Closes the result

property columns¶

Return a list containing the names of the columns of the relation.

count(self: duckdb.duckdb.DuckDBPyRelation, count_aggr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the aggregate count of a single column or a list of columns by the optional groups on the relation

create(self: duckdb.duckdb.DuckDBPyRelation, table_name: str) → None¶

Creates a new table named table_name with the contents of the relation object

create_view(self: duckdb.duckdb.DuckDBPyRelation, view_name: str, replace: bool = True) → duckdb.duckdb.DuckDBPyRelation¶

Creates a view named view_name that refers to the relation object

cummax(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str) → duckdb.duckdb.DuckDBPyRelation¶

Returns the cumulative maximum of the aggregate column.

cummin(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str) → duckdb.duckdb.DuckDBPyRelation¶

Returns the cumulative minimum of the aggregate column.

cumprod(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str) → duckdb.duckdb.DuckDBPyRelation¶

Returns the cumulative product of the aggregate column.

cumsum(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str) → duckdb.duckdb.DuckDBPyRelation¶

Returns the cumulative sum of the aggregate column.

describe(self: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶

Gives basic statistics (e.g., min,max) and if null exists for each column of the relation.

property description¶

Return the description of the result

df(self: duckdb.duckdb.DuckDBPyRelation, *, date_as_object: bool = False) → pandas.DataFrame¶

Execute and fetch all rows as a pandas DataFrame

distinct(self: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶

Retrieve distinct rows from this relation object

property dtypes¶

Return a list containing the types of the columns of the relation.

except_(self: duckdb.duckdb.DuckDBPyRelation, other_rel: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶

Create the set except of this relation object with another relation object in other_rel

execute(self: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶

Transform the relation into a result set

explain(self: duckdb.duckdb.DuckDBPyRelation, type: duckdb.duckdb.ExplainType = 'standard') → str¶

fetch_arrow_reader(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → pyarrow.lib.RecordBatchReader¶

Execute and return an Arrow Record Batch Reader that yields all rows

fetch_arrow_table(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → pyarrow.lib.Table¶

Execute and fetch all rows as an Arrow Table

fetchall(self: duckdb.duckdb.DuckDBPyRelation) → list¶

Execute and fetch all rows as a list of tuples

fetchdf(self: duckdb.duckdb.DuckDBPyRelation, *, date_as_object: bool = False) → pandas.DataFrame¶

Execute and fetch all rows as a pandas DataFrame

fetchmany(self: duckdb.duckdb.DuckDBPyRelation, size: int = 1) → list¶

Execute and fetch the next set of rows as a list of tuples

fetchnumpy(self: duckdb.duckdb.DuckDBPyRelation) → dict¶

Execute and fetch all rows as a Python dict mapping each column to one numpy arrays

fetchone(self: duckdb.duckdb.DuckDBPyRelation) → Optional[tuple]¶

Execute and fetch a single row as a tuple

filter(self: duckdb.duckdb.DuckDBPyRelation, filter_expr: str) → duckdb.duckdb.DuckDBPyRelation¶

Filter the relation object by the filter in filter_expr

insert(self: duckdb.duckdb.DuckDBPyRelation, values: object) → None¶

Inserts the given values into the relation

insert_into(self: duckdb.duckdb.DuckDBPyRelation, table_name: str) → None¶

Inserts the relation object into an existing table named table_name

intersect(self: duckdb.duckdb.DuckDBPyRelation, other_rel: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶

Create the set intersection of this relation object with another relation object in other_rel

join(self: duckdb.duckdb.DuckDBPyRelation, other_rel: duckdb.duckdb.DuckDBPyRelation, condition: str, how: str = 'inner') → duckdb.duckdb.DuckDBPyRelation¶

Join the relation object with another relation object in other_rel using the join condition expression in join_condition. Types supported are ‘inner’ and ‘left’

kurt(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str, group_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Returns the excess kurtosis of the aggregate column.

limit(self: duckdb.duckdb.DuckDBPyRelation, n: int, offset: int = 0) → duckdb.duckdb.DuckDBPyRelation¶

Only retrieve the first n rows from this relation object, starting at offset

mad(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str, group_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Returns the median absolute deviation for the aggregate columns. NULL values are ignored. Temporal types return a positive INTERVAL.

map(self: duckdb.duckdb.DuckDBPyRelation, map_function: function, *, schema: Optional[object] = None) → duckdb.duckdb.DuckDBPyRelation¶

Calls the passed function on the relation

max(self: duckdb.duckdb.DuckDBPyRelation, max_aggr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the aggregate max of a single column or a list of columns by the optional groups on the relation

mean(self: duckdb.duckdb.DuckDBPyRelation, mean_aggr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the aggregate mean of a single column or a list of columns by the optional groups on the relation

median(self: duckdb.duckdb.DuckDBPyRelation, median_aggr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the aggregate median of a single column or a list of columns by the optional groups on the relation

min(self: duckdb.duckdb.DuckDBPyRelation, min_aggr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the aggregate min of a single column or a list of columns by the optional groups on the relation

mode(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str, group_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Returns the most frequent value for the aggregate columns. NULL values are ignored.

order(self: duckdb.duckdb.DuckDBPyRelation, order_expr: str) → duckdb.duckdb.DuckDBPyRelation¶

Reorder the relation object by order_expr

pl(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → duckdb::PolarsDataFrame¶

Execute and fetch all rows as a Polars DataFrame

prod(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str, group_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Calculates the product of the aggregate column.

project(self: duckdb.duckdb.DuckDBPyRelation, project_expr: str) → duckdb.duckdb.DuckDBPyRelation¶

Project the relation object by the projection in project_expr

quantile(self: duckdb.duckdb.DuckDBPyRelation, q: str, quantile_aggr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the quantile of a single column or a list of columns by the optional groups on the relation

query(self: duckdb.duckdb.DuckDBPyRelation, virtual_table_name: str, sql_query: str) → duckdb.duckdb.DuckDBPyRelation¶

Run the given SQL query in sql_query on the view named virtual_table_name that refers to the relation object

record_batch(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → pyarrow.lib.RecordBatchReader¶

Execute and return an Arrow Record Batch Reader that yields all rows

select_dtypes(self: duckdb.duckdb.DuckDBPyRelation, types: object) → duckdb.duckdb.DuckDBPyRelation¶

Select columns from the relation, by filtering based on type(s)

select_types(self: duckdb.duckdb.DuckDBPyRelation, types: object) → duckdb.duckdb.DuckDBPyRelation¶

Select columns from the relation, by filtering based on type(s)

sem(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str, group_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Returns the standard error of the mean of the aggregate column.

set_alias(self: duckdb.duckdb.DuckDBPyRelation, alias: str) → duckdb.duckdb.DuckDBPyRelation¶

Rename the relation object to new alias

property shape¶

Tuple of # of rows, # of columns in relation.

show(self: duckdb.duckdb.DuckDBPyRelation) → None¶

Display a summary of the data

skew(self: duckdb.duckdb.DuckDBPyRelation, aggregation_columns: str, group_columns: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Returns the skewness of the aggregate column.

sql_query(self: duckdb.duckdb.DuckDBPyRelation) → str¶

Get the SQL query that is equivalent to the relation

std(self: duckdb.duckdb.DuckDBPyRelation, std_aggr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the standard deviation of a single column or a list of columns by the optional groups on the relation

sum(self: duckdb.duckdb.DuckDBPyRelation, sum_aggr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the aggregate sum of a single column or a list of columns by the optional groups on the relation

tf(self: duckdb.duckdb.DuckDBPyRelation) → dict¶

Fetch a result as dict of TensorFlow Tensors

to_arrow_table(self: duckdb.duckdb.DuckDBPyRelation, batch_size: int = 1000000) → pyarrow.lib.Table¶

Execute and fetch all rows as an Arrow Table

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) → None¶

Write the relation object to a CSV file in ‘file_name’

to_df(self: duckdb.duckdb.DuckDBPyRelation, *, date_as_object: bool = False) → pandas.DataFrame¶

Execute and fetch all rows as a pandas DataFrame

to_parquet(self: duckdb.duckdb.DuckDBPyRelation, file_name: str, *, compression: object = None) → None¶

Write the relation object to a Parquet file in ‘file_name’

to_table(self: duckdb.duckdb.DuckDBPyRelation, table_name: str) → None¶

Creates a new table named table_name with the contents of the relation object

to_view(self: duckdb.duckdb.DuckDBPyRelation, view_name: str, replace: bool = True) → duckdb.duckdb.DuckDBPyRelation¶

Creates a view named view_name that refers to the relation object

torch(self: duckdb.duckdb.DuckDBPyRelation) → dict¶

Fetch a result as dict of PyTorch Tensors

property type¶

Get the type of the relation.

property types¶

Return a list containing the types of the columns of the relation.

union(self: duckdb.duckdb.DuckDBPyRelation, union_rel: duckdb.duckdb.DuckDBPyRelation) → duckdb.duckdb.DuckDBPyRelation¶

Create the set union of this relation object with another relation object in other_rel

unique(self: duckdb.duckdb.DuckDBPyRelation, unique_aggr: str) → duckdb.duckdb.DuckDBPyRelation¶

Number of distinct values in a column.

value_counts(self: duckdb.duckdb.DuckDBPyRelation, value_counts_aggr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Count number of rows with each unique value of variable

var(self: duckdb.duckdb.DuckDBPyRelation, var_aggr: str, group_expr: str = '') → duckdb.duckdb.DuckDBPyRelation¶

Compute the variance of a single column or a list of columns by the optional groups on the relation

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) → None¶

Write the relation object to a CSV file in ‘file_name’

write_parquet(self: duckdb.duckdb.DuckDBPyRelation, file_name: str, *, compression: object = None) → None¶

Write the relation object to a Parquet file in ‘file_name’

Bases: pybind11_object

Members:

STANDARD

ANALYZE

ANALYZE = <ExplainType.ANALYZE: 1>¶

STANDARD = <ExplainType.STANDARD: 0>¶

property name¶

property value¶

Bases: pybind11_object

Members:

DEFAULT

RETURN_NULL

DEFAULT = <PythonExceptionHandling.DEFAULT: 0>¶

RETURN_NULL = <PythonExceptionHandling.RETURN_NULL: 1>¶

property name¶

property value¶