Python-Client-API

class duckdb.BinaryValue(object: Any)¶: Bases: Value

class duckdb.BinderException¶: Bases: ProgrammingError

class duckdb.BitValue(object: Any)¶: Bases: Value

class duckdb.BlobValue(object: Any)¶: Bases: Value

class duckdb.BooleanValue(object: Any)¶: Bases: Value

class duckdb.CSVLineTerminator¶

Bases: pybind11_object

Members:

LINE_FEED

CARRIAGE_RETURN_LINE_FEED

CSVLineTerminator.name -> str

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

class duckdb.CatalogException¶: Bases: ProgrammingError

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

duckdb.ColumnExpression(*args) → _duckdb.Expression¶: Erzeugt eine Spaltenreferenz aus dem angegebenen Spaltennamen

class duckdb.ConnectionException¶: Bases: OperationalError

duckdb.ConstantExpression(value: object) → _duckdb.Expression¶: Erzeugt einen konstanten Ausdruck aus dem angegebenen Wert

class duckdb.ConstraintException¶: Bases: IntegrityError

class duckdb.ConversionException¶: Bases: DataError

class duckdb.DBAPITypeObject(types: list[DuckDBPyType])¶

Bases: object

DB API 2.0-Typobjekt zur Kategorisierung von Datenbankspaltentypen.

Diese Klasse implementiert die in PEP 249 (DB API 2.0) definierten Typobjekte. It allows checking whether a specific DuckDB type belongs to a broader category like STRING, NUMBER, DATETIME, etc.

Das Typobjekt unterstützt Gleichheitsvergleiche mit DuckDBPyType-Instanzen, returning True if the type belongs to this category.

Args:

types: Eine Liste von DuckDBPyType-Instanzen, die zu dieser Typkategorie gehören.

Beispiel:

>>> string_types = DBAPITypeObject([sqltypes.VARCHAR, sqltypes.CHAR])
>>> result = sqltypes.VARCHAR == string_types  # True
>>> result = sqltypes.INTEGER == string_types  # False

Note:

Dies folgt der DB-API-2.0-Spezifikation, nach der Typobjekte verglichen werden using equality operators rather than isinstance() checks.

class duckdb.DataError¶: Bases: DatabaseError

class duckdb.DatabaseError¶: Bases: Error

class duckdb.DateValue(object: Any)¶: Bases: Value

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

duckdb.DefaultExpression() → _duckdb.Expression¶

class duckdb.DependencyException¶: Bases: DatabaseError

class duckdb.DoubleValue(object: Any)¶: Bases: Value

class duckdb.DuckDBPyConnection¶

Bases: pybind11_object

append(self: _duckdb.DuckDBPyConnection, table_name: str, df: pandas.DataFrame, *, by_name: bool = False) → _duckdb.DuckDBPyConnection¶: Hängt das übergebene DataFrame an die benannte Tabelle an

array_type(self: _duckdb.DuckDBPyConnection, type: _duckdb._sqltypes.DuckDBPyType, size: SupportsInt) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Array-Typ-Objekt von ‘type’

arrow(self: _duckdb.DuckDBPyConnection, rows_per_batch: SupportsInt = 1000000) → pyarrow.lib.RecordBatchReader¶: Alias von to_arrow_reader(). Verwenden Sie stattdessen to_arrow_reader().

begin(self: _duckdb.DuckDBPyConnection) → _duckdb.DuckDBPyConnection¶: Startet eine neue Transaktion

checkpoint(self: _duckdb.DuckDBPyConnection) → _duckdb.DuckDBPyConnection¶: Synchronisiert Daten aus dem Write-Ahead Log (WAL) in die Datenbankdatei (keine Operation bei In-Memory-Verbindungen)

close(self: _duckdb.DuckDBPyConnection) → None¶: Close the connection

commit(self: _duckdb.DuckDBPyConnection) → _duckdb.DuckDBPyConnection¶: Commitet die innerhalb einer Transaktion vorgenommenen Änderungen

create_function(self: _duckdb.DuckDBPyConnection, name: str, function: collections.abc.Callable, parameters: object = None, return_type: _duckdb._sqltypes.DuckDBPyType = None, *, type: _duckdb._func.PythonUDFType = <PythonUDFType.NATIVE: 0>, null_handling: _duckdb._func.FunctionNullHandling = <FunctionNullHandling.DEFAULT: 0>, exception_handling: _duckdb.PythonExceptionHandling = <PythonExceptionHandling.DEFAULT: 0>, side_effects: bool = False) → _duckdb.DuckDBPyConnection¶: Erzeugt aus der übergebenen Python-Funktion eine DuckDB-Funktion, die in Abfragen verwendet werden kann

cursor(self: _duckdb.DuckDBPyConnection) → _duckdb.DuckDBPyConnection¶: Erzeugt eine Kopie der aktuellen Verbindung

decimal_type(self: _duckdb.DuckDBPyConnection, width: SupportsInt, scale: SupportsInt) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt einen Dezimaltyp mit ‘width’ und ‘scale’

property description¶: Gibt Attribute des Ergebnissets zurück, vor allem Spaltennamen

df(self: _duckdb.DuckDBPyConnection, *, date_as_object: bool = False) → pandas.DataFrame¶: Holt ein Ergebnis als DataFrame nach execute()

disable_profiling(self: _duckdb.DuckDBPyConnection) → None¶: Deaktiviert Profiling für nachfolgende Abfragen

dtype(self: _duckdb.DuckDBPyConnection, type_str: str) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Typobjekt durch Parsen der Zeichenkette ‘type_str’

duplicate(self: _duckdb.DuckDBPyConnection) → _duckdb.DuckDBPyConnection¶: Erzeugt eine Kopie der aktuellen Verbindung

enable_profiling(self: _duckdb.DuckDBPyConnection) → None¶: Aktiviert Profiling für nachfolgende Abfragen

enum_type(self: _duckdb.DuckDBPyConnection, name: str, type: _duckdb._sqltypes.DuckDBPyType, values: list) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt einen Enum-Typ des zugrunde liegenden ‘type’ aus der Liste ‘values’

execute(self: _duckdb.DuckDBPyConnection, query: object, parameters: object = None) → _duckdb.DuckDBPyConnection¶: Führt die angegebene SQL-Abfrage aus, optional mit Prepared Statements und gesetzten Parametern

executemany(self: _duckdb.DuckDBPyConnection, query: object, parameters: object = None) → _duckdb.DuckDBPyConnection¶: Führt das angegebene Prepared Statement mehrfach mit der Liste der Parametersätze in parameters aus

extract_statements(self: _duckdb.DuckDBPyConnection, query: str) → list¶: Parst die Abfragezeichenkette und extrahiert das/die erzeugte(n) Statement-Objekt(e)

fetch_arrow_table(self: _duckdb.DuckDBPyConnection, rows_per_batch: SupportsInt = 1000000) → pyarrow.lib.Table¶: Holt ein Ergebnis als Arrow-Tabelle nach execute()

fetch_df(self: _duckdb.DuckDBPyConnection, *, date_as_object: bool = False) → pandas.DataFrame¶: Holt ein Ergebnis als DataFrame nach execute()

fetch_df_chunk(self: _duckdb.DuckDBPyConnection, vectors_per_chunk: SupportsInt = 1, *, date_as_object: bool = False) → pandas.DataFrame¶: Holt einen Chunk des Ergebnisses als DataFrame nach execute()

fetch_record_batch(self: _duckdb.DuckDBPyConnection, rows_per_batch: SupportsInt = 1000000) → pyarrow.lib.RecordBatchReader¶: Holt einen Arrow RecordBatchReader nach execute()

fetchall(self: _duckdb.DuckDBPyConnection) → list¶: Holt alle Zeilen eines Ergebnisses nach execute

fetchdf(self: _duckdb.DuckDBPyConnection, *, date_as_object: bool = False) → pandas.DataFrame¶: Holt ein Ergebnis als DataFrame nach execute()

fetchmany(self: _duckdb.DuckDBPyConnection, size: SupportsInt = 1) → list¶: Holt den nächsten Satz Zeilen eines Ergebnisses nach execute

fetchnumpy(self: _duckdb.DuckDBPyConnection) → dict¶: Holt ein Ergebnis als Liste von NumPy-Arrays nach execute

fetchone(self: _duckdb.DuckDBPyConnection) → Optional[tuple]¶: Holt eine einzelne Zeile eines Ergebnisses nach execute

filesystem_is_registered(self: _duckdb.DuckDBPyConnection, name: str) → bool¶: Prüft, ob ein Dateisystem mit dem angegebenen Namen derzeit registriert ist

from_arrow(self: _duckdb.DuckDBPyConnection, arrow_object: object) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus einem Arrow-Objekt

from_csv_auto(self: _duckdb.DuckDBPyConnection, path_or_buffer: object, **kwargs) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus der CSV-Datei in ‘name’

from_df(self: _duckdb.DuckDBPyConnection, df: pandas.DataFrame) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus dem DataFrame in df

from_parquet(*args, **kwargs)¶

Overloaded function.

from_parquet(self: _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.DuckDBPyRelation

Erzeugt ein Relation-Objekt aus den Parquet-Dateien in file_glob

from_parquet(self: _duckdb.DuckDBPyConnection, file_globs: collections.abc.Sequence[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.DuckDBPyRelation

Erzeugt ein Relation-Objekt aus den Parquet-Dateien in file_globs

from_query(self: _duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) → _duckdb.DuckDBPyRelation¶: Führt eine SQL-Abfrage aus. Bei einer SELECT-Anweisung wird ein Relation-Objekt aus der Abfrage erzeugt, andernfalls wird die Abfrage unverändert ausgeführt.

get_profiling_information(self: _duckdb.DuckDBPyConnection, format: str = 'json') → str¶: Holt Profiling-Informationen für eine Abfrage

get_table_names(self: _duckdb.DuckDBPyConnection, query: str, *, qualified: bool = False) → set[str]¶: Extrahiert die benötigten Tabellennamen aus einer Abfrage

install_extension(self: _duckdb.DuckDBPyConnection, extension: str, *, force_install: bool = False, repository: object = None, repository_url: object = None, version: object = None) → None¶: Installiert eine Erweiterung anhand des Namens, optional mit Version und/oder Repository

interrupt(self: _duckdb.DuckDBPyConnection) → None¶: Unterbricht ausstehende Operationen

list_filesystems(self: _duckdb.DuckDBPyConnection) → list¶: Listet registrierte Dateisysteme auf, einschließlich der eingebauten

list_type(self: _duckdb.DuckDBPyConnection, type: _duckdb._sqltypes.DuckDBPyType) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Listentyp-Objekt von ‘type’

load_extension(self: _duckdb.DuckDBPyConnection, extension: str) → None¶: Lädt eine installierte Erweiterung

map_type(self: _duckdb.DuckDBPyConnection, key: _duckdb._sqltypes.DuckDBPyType, value: _duckdb._sqltypes.DuckDBPyType) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Map-Typ-Objekt aus ‘key_type’ und ‘value_type’

pl(self: _duckdb.DuckDBPyConnection, rows_per_batch: SupportsInt = 1000000, *, lazy: bool = False) → duckdb::PolarsDataFrame¶: Holt ein Ergebnis als Polars-DataFrame nach execute()

query(self: _duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) → _duckdb.DuckDBPyRelation¶: Führt eine SQL-Abfrage aus. Bei einer SELECT-Anweisung wird ein Relation-Objekt aus der Abfrage erzeugt, andernfalls wird die Abfrage unverändert ausgeführt.

query_progress(self: _duckdb.DuckDBPyConnection) → float¶: Gibt den Fortschritt der ausstehenden Operation zurück

read_csv(self: _duckdb.DuckDBPyConnection, path_or_buffer: object, **kwargs) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus der CSV-Datei in ‘name’

read_json(self: _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.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus der JSON-Datei in ‘name’

read_parquet(*args, **kwargs)¶

Overloaded function.

read_parquet(self: _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.DuckDBPyRelation

Erzeugt ein Relation-Objekt aus den Parquet-Dateien in file_glob

read_parquet(self: _duckdb.DuckDBPyConnection, file_globs: collections.abc.Sequence[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.DuckDBPyRelation

Erzeugt ein Relation-Objekt aus den Parquet-Dateien in file_globs

register(self: _duckdb.DuckDBPyConnection, view_name: str, python_object: object) → _duckdb.DuckDBPyConnection¶: Registriert das übergebene Python-Objekt zur Abfrage über einen View

register_filesystem(self: _duckdb.DuckDBPyConnection, filesystem: fsspec.AbstractFileSystem) → None¶: Registriert ein fsspec-konformes Dateisystem

remove_function(self: _duckdb.DuckDBPyConnection, name: str) → _duckdb.DuckDBPyConnection¶: Entfernt eine zuvor erstellte Funktion

rollback(self: _duckdb.DuckDBPyConnection) → _duckdb.DuckDBPyConnection¶: Rollt die innerhalb einer Transaktion vorgenommenen Änderungen zurück

row_type(self: _duckdb.DuckDBPyConnection, fields: object) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Struct-Typ-Objekt aus ‘fields’

property rowcount¶: Gibt die Zeilenanzahl des Ergebnissets zurück

sql(self: _duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) → _duckdb.DuckDBPyRelation¶: Führt eine SQL-Abfrage aus. Bei einer SELECT-Anweisung wird ein Relation-Objekt aus der Abfrage erzeugt, andernfalls wird die Abfrage unverändert ausgeführt.

sqltype(self: _duckdb.DuckDBPyConnection, type_str: str) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Typobjekt durch Parsen der Zeichenkette ‘type_str’

string_type(self: _duckdb.DuckDBPyConnection, collation: str = '') → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt einen String-Typ mit optionaler Collation

struct_type(self: _duckdb.DuckDBPyConnection, fields: object) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Struct-Typ-Objekt aus ‘fields’

table(self: _duckdb.DuckDBPyConnection, table_name: str) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt für die benannte Tabelle

table_function(self: _duckdb.DuckDBPyConnection, name: str, parameters: object = None) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus der benannten Tabellenfunktion mit den angegebenen Parametern

tf(self: _duckdb.DuckDBPyConnection) → dict¶: Holt ein Ergebnis als dict von TensorFlow-Tensoren nach execute()

to_arrow_reader(self: _duckdb.DuckDBPyConnection, batch_size: SupportsInt = 1000000) → pyarrow.lib.RecordBatchReader¶: Holt einen Arrow RecordBatchReader nach execute()

to_arrow_table(self: _duckdb.DuckDBPyConnection, batch_size: SupportsInt = 1000000) → pyarrow.lib.Table¶: Holt ein Ergebnis als Arrow-Tabelle nach execute()

torch(self: _duckdb.DuckDBPyConnection) → dict¶: Holt ein Ergebnis als dict von PyTorch-Tensoren nach execute()

type(self: _duckdb.DuckDBPyConnection, type_str: str) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Typobjekt durch Parsen der Zeichenkette ‘type_str’

union_type(self: _duckdb.DuckDBPyConnection, members: object) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Union-Typ-Objekt aus ‘members’

unregister(self: _duckdb.DuckDBPyConnection, view_name: str) → _duckdb.DuckDBPyConnection¶: Deregistriert den View-Namen

unregister_filesystem(self: _duckdb.DuckDBPyConnection, name: str) → None¶: Deregistriert ein Dateisystem

values(self: _duckdb.DuckDBPyConnection, *args) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus den übergebenen Werten

view(self: _duckdb.DuckDBPyConnection, view_name: str) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt für den benannten View

class duckdb.DuckDBPyRelation¶

Bases: pybind11_object

Detailed examples can be found at Relational API page.

aggregate(self: _duckdb.DuckDBPyRelation, aggr_expr: object, group_expr: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Aggregation aggr_expr nach den optionalen Gruppen group_expr auf der Relation

Detailed examples can be found at Relational API page.

alias¶: Gibt den Namen des aktuellen Alias zurück

Detailed examples can be found at Relational API page.

any_value(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Gibt den ersten Nicht-Null-Wert eines gegebenen Ausdrucks zurück

Detailed examples can be found at Relational API page.

apply(self: _duckdb.DuckDBPyRelation, function_name: str, function_aggr: str, group_expr: str = '', function_parameter: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Funktion einer einzelnen Spalte oder einer Spaltenliste nach den optionalen Gruppen auf der Relation

Detailed examples can be found at Relational API page.

arg_max(self: _duckdb.DuckDBPyRelation, arg_column: str, value_column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Findet die Zeile mit dem Maximalwert einer Wertspalte und gibt den Wert dieser Zeile für eine Argumentspalte zurück

Detailed examples can be found at Relational API page.

arg_min(self: _duckdb.DuckDBPyRelation, arg_column: str, value_column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Findet die Zeile mit dem Minimalwert einer Wertspalte und gibt den Wert dieser Zeile für eine Argumentspalte zurück

Detailed examples can be found at Relational API page.

arrow(self: _duckdb.DuckDBPyRelation, batch_size: SupportsInt = 1000000) → pyarrow.lib.RecordBatchReader¶: Alias von to_arrow_reader(). Verwenden Sie stattdessen to_arrow_reader().

Detailed examples can be found at Relational API page.

avg(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den Durchschnitt eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

bit_and(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet das bitweise AND aller Bits eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

bit_or(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet das bitweise OR aller Bits eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

bit_xor(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet das bitweise XOR aller Bits eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

bitstring_agg(self: _duckdb.DuckDBPyRelation, expression: str, min: Optional[object] = None, max: Optional[object] = None, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet einen Bitstring, in dem für jeden eindeutigen Wert eines gegebenen Ausdrucks ein Bit gesetzt ist

Detailed examples can be found at Relational API page.

bool_and(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet das logische AND aller Werte eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

bool_or(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet das logische OR aller Werte eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

close(self: _duckdb.DuckDBPyRelation) → None¶: Schließt das Ergebnis

Detailed examples can be found at Relational API page.

columns¶: Gibt eine Liste mit den Namen der Spalten der Relation zurück.

Detailed examples can be found at Relational API page.

count(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Anzahl der Elemente eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

create(self: _duckdb.DuckDBPyRelation, table_name: str) → None¶: Erzeugt eine neue Tabelle namens table_name mit dem Inhalt des Relation-Objekts

Detailed examples can be found at Relational API page.

create_view(self: _duckdb.DuckDBPyRelation, view_name: str, replace: bool = True) → _duckdb.DuckDBPyRelation¶: Erzeugt einen View namens view_name, der auf das Relation-Objekt verweist

Detailed examples can be found at Relational API page.

cross(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation) → _duckdb.DuckDBPyRelation¶: Erzeugt das Kreuz-/kartesische Produkt zweier relationaler Objekte

Detailed examples can be found at Relational API page.

cume_dist(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die kumulative Verteilung innerhalb der Partition

Detailed examples can be found at Relational API page.

dense_rank(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den dichten Rang innerhalb der Partition

Detailed examples can be found at Relational API page.

describe(self: _duckdb.DuckDBPyRelation) → _duckdb.DuckDBPyRelation¶: Liefert Basisstatistiken (z. B. min, max) und ob NULL in jeder Spalte der Relation vorkommt.

Detailed examples can be found at Relational API page.

description¶: Gibt die Beschreibung des Ergebnisses zurück

Detailed examples can be found at Relational API page.

df(self: _duckdb.DuckDBPyRelation, *, date_as_object: bool = False) → pandas.DataFrame¶: Führt aus und holt alle Zeilen als pandas-DataFrame

Detailed examples can be found at Relational API page.

distinct(self: _duckdb.DuckDBPyRelation) → _duckdb.DuckDBPyRelation¶: Holt eindeutige Zeilen aus diesem Relation-Objekt

Detailed examples can be found at Relational API page.

dtypes¶: Gibt eine Liste mit den Typen der Spalten der Relation zurück.

Detailed examples can be found at Relational API page.

except_(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation) → _duckdb.DuckDBPyRelation¶: Erzeugt die Mengendifferenz (EXCEPT) dieses Relation-Objekts mit einem weiteren Relation-Objekt in other_rel

Detailed examples can be found at Relational API page.

execute(self: _duckdb.DuckDBPyRelation) → _duckdb.DuckDBPyRelation¶: Wandelt die Relation in ein Ergebnisset um

Detailed examples can be found at Relational API page.

explain(self: _duckdb.DuckDBPyRelation, type: _duckdb.ExplainType = 'standard') → str¶: Detailed examples can be found at Relational API page.

favg(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den Durchschnitt aller Werte eines gegebenen Ausdrucks mit genauerer Gleitkommasummierung (Kahan-Summe)

Detailed examples can be found at Relational API page.

fetch_arrow_reader(self: object, batch_size: SupportsInt = 1000000) → object¶: Führt aus und gibt einen Arrow Record Batch Reader zurück, der alle Zeilen liefert

Detailed examples can be found at Relational API page.

fetch_arrow_table(self: object, batch_size: SupportsInt = 1000000) → object¶: Führt aus und holt alle Zeilen als Arrow Table

Detailed examples can be found at Relational API page.

fetch_df_chunk(self: _duckdb.DuckDBPyRelation, vectors_per_chunk: SupportsInt = 1, *, date_as_object: bool = False) → pandas.DataFrame¶: Führt aus und holt einen Chunk der Zeilen

Detailed examples can be found at Relational API page.

fetch_record_batch(self: object, rows_per_batch: SupportsInt = 1000000) → object¶: Führt aus und gibt einen Arrow Record Batch Reader zurück, der alle Zeilen liefert

Detailed examples can be found at Relational API page.

fetchall(self: _duckdb.DuckDBPyRelation) → list¶: Führt aus und holt alle Zeilen als Liste von Tupeln

Detailed examples can be found at Relational API page.

fetchdf(self: _duckdb.DuckDBPyRelation, *, date_as_object: bool = False) → pandas.DataFrame¶: Führt aus und holt alle Zeilen als pandas-DataFrame

Detailed examples can be found at Relational API page.

fetchmany(self: _duckdb.DuckDBPyRelation, size: SupportsInt = 1) → list¶: Führt aus und holt den nächsten Satz Zeilen als Liste von Tupeln

Detailed examples can be found at Relational API page.

fetchnumpy(self: _duckdb.DuckDBPyRelation) → dict¶: Führt aus und holt alle Zeilen als Python-dict, das jede Spalte auf ein numpy-Array abbildet

Detailed examples can be found at Relational API page.

fetchone(self: _duckdb.DuckDBPyRelation) → Optional[tuple]¶: Führt aus und holt eine einzelne Zeile als Tupel

Detailed examples can be found at Relational API page.

filter(self: _duckdb.DuckDBPyRelation, filter_expr: object) → _duckdb.DuckDBPyRelation¶: Filtert das Relation-Objekt anhand des Filters in filter_expr

Detailed examples can be found at Relational API page.

first(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Gibt den ersten Wert eines gegebenen Ausdrucks zurück

Detailed examples can be found at Relational API page.

first_value(self: _duckdb.DuckDBPyRelation, expression: str, window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den ersten Wert innerhalb der Gruppe oder Partition

Detailed examples can be found at Relational API page.

fsum(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Summe aller Werte eines gegebenen Ausdrucks mit genauerer Gleitkommasummierung (Kahan-Summe)

Detailed examples can be found at Relational API page.

geomean(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet das geometrische Mittel über alle Werte eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

histogram(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet das Histogramm über alle Werte eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

insert(self: _duckdb.DuckDBPyRelation, values: object) → None¶: Fügt die angegebenen Werte in die Relation ein

Detailed examples can be found at Relational API page.

insert_into(self: _duckdb.DuckDBPyRelation, table_name: str) → None¶: Fügt das Relation-Objekt in eine bestehende Tabelle namens table_name ein

Detailed examples can be found at Relational API page.

intersect(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation) → _duckdb.DuckDBPyRelation¶: Erzeugt die Schnittmenge dieses Relation-Objekts mit einem weiteren Relation-Objekt in other_rel

Detailed examples can be found at Relational API page.

join(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation, condition: object, how: str = 'inner') → _duckdb.DuckDBPyRelation¶: Verknüpft das Relation-Objekt mit einem weiteren Relation-Objekt in other_rel über den Join-Bedingungsausdruck in join_condition. Unterstützte Typen sind ‘inner’, ‘left’, ‘right’, ‘outer’, ‘semi’ und ‘anti’

Detailed examples can be found at Relational API page.

lag(self: _duckdb.DuckDBPyRelation, expression: str, window_spec: str, offset: SupportsInt = 1, default_value: str = 'NULL', ignore_nulls: bool = False, projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den Lag innerhalb der Partition

Detailed examples can be found at Relational API page.

last(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Gibt den letzten Wert eines gegebenen Ausdrucks zurück

Detailed examples can be found at Relational API page.

last_value(self: _duckdb.DuckDBPyRelation, expression: str, window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den letzten Wert innerhalb der Gruppe oder Partition

Detailed examples can be found at Relational API page.

lead(self: _duckdb.DuckDBPyRelation, expression: str, window_spec: str, offset: SupportsInt = 1, default_value: str = 'NULL', ignore_nulls: bool = False, projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den Lead innerhalb der Partition

Detailed examples can be found at Relational API page.

limit(self: _duckdb.DuckDBPyRelation, n: SupportsInt, offset: SupportsInt = 0) → _duckdb.DuckDBPyRelation¶: Holt nur die ersten n Zeilen dieses Relation-Objekts, beginnend bei offset

Detailed examples can be found at Relational API page.

list(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Gibt eine Liste aller Werte eines gegebenen Ausdrucks zurück

Detailed examples can be found at Relational API page.

map(self: _duckdb.DuckDBPyRelation, map_function: collections.abc.Callable, *, schema: Optional[object] = None) → _duckdb.DuckDBPyRelation¶: Ruft die übergebene Funktion auf der Relation auf

Detailed examples can be found at Relational API page.

max(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Gibt den Maximalwert eines gegebenen Ausdrucks zurück

Detailed examples can be found at Relational API page.

mean(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den Durchschnitt eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

median(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den Median über alle Werte eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

min(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Gibt den Minimalwert eines gegebenen Ausdrucks zurück

Detailed examples can be found at Relational API page.

mode(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den Modalwert über alle Werte eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

n_tile(self: _duckdb.DuckDBPyRelation, window_spec: str, num_buckets: SupportsInt, projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Teilt die Partition möglichst gleichmäßig in num_buckets auf

Detailed examples can be found at Relational API page.

nth_value(self: _duckdb.DuckDBPyRelation, expression: str, window_spec: str, offset: SupportsInt, ignore_nulls: bool = False, projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den n-ten Wert innerhalb der Partition

Detailed examples can be found at Relational API page.

order(self: _duckdb.DuckDBPyRelation, order_expr: str) → _duckdb.DuckDBPyRelation¶: Ordnet das Relation-Objekt nach order_expr neu

Detailed examples can be found at Relational API page.

percent_rank(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den relativen Rang innerhalb der Partition

Detailed examples can be found at Relational API page.

pl(self: _duckdb.DuckDBPyRelation, batch_size: SupportsInt = 1000000, *, lazy: bool = False) → duckdb::PolarsDataFrame¶: Führt aus und holt alle Zeilen als Polars-DataFrame

Detailed examples can be found at Relational API page.

product(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Gibt das Produkt aller Werte eines gegebenen Ausdrucks zurück

Detailed examples can be found at Relational API page.

project(self: _duckdb.DuckDBPyRelation, *args, groups: str = '') → _duckdb.DuckDBPyRelation¶: Projiziert das Relation-Objekt anhand der Projektion in project_expr

Detailed examples can be found at Relational API page.

quantile(self: _duckdb.DuckDBPyRelation, expression: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den exakten Quantilwert eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

quantile_cont(self: _duckdb.DuckDBPyRelation, expression: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den interpolierten Quantilwert eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

quantile_disc(self: _duckdb.DuckDBPyRelation, expression: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den exakten Quantilwert eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

query(self: _duckdb.DuckDBPyRelation, virtual_table_name: str, sql_query: str) → _duckdb.DuckDBPyRelation¶: Führt die SQL-Abfrage in sql_query auf dem View namens virtual_table_name aus, der auf das Relation-Objekt verweist

Detailed examples can be found at Relational API page.

rank(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den Rang innerhalb der Partition

Detailed examples can be found at Relational API page.

rank_dense(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet den dichten Rang innerhalb der Partition

Detailed examples can be found at Relational API page.

row_number(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Zeilennummer innerhalb der Partition

Detailed examples can be found at Relational API page.

select(self: _duckdb.DuckDBPyRelation, *args, groups: str = '') → _duckdb.DuckDBPyRelation¶: Projiziert das Relation-Objekt anhand der Projektion in project_expr

Detailed examples can be found at Relational API page.

select_dtypes(self: _duckdb.DuckDBPyRelation, types: object) → _duckdb.DuckDBPyRelation¶: Wählt Spalten der Relation anhand von Typ(en) aus

Detailed examples can be found at Relational API page.

select_types(self: _duckdb.DuckDBPyRelation, types: object) → _duckdb.DuckDBPyRelation¶: Wählt Spalten der Relation anhand von Typ(en) aus

Detailed examples can be found at Relational API page.

set_alias(self: _duckdb.DuckDBPyRelation, alias: str) → _duckdb.DuckDBPyRelation¶: Benennt das Relation-Objekt in einen neuen Alias um

Detailed examples can be found at Relational API page.

shape¶: Tupel aus Anzahl der Zeilen und Anzahl der Spalten der Relation.

Detailed examples can be found at Relational API page.

show(self: _duckdb.DuckDBPyRelation, *, max_width: Optional[SupportsInt] = None, max_rows: Optional[SupportsInt] = None, max_col_width: Optional[SupportsInt] = None, null_value: Optional[str] = None, render_mode: object = None) → None¶: Zeigt eine Zusammenfassung der Daten an

Detailed examples can be found at Relational API page.

sort(self: _duckdb.DuckDBPyRelation, *args) → _duckdb.DuckDBPyRelation¶: Ordnet das Relation-Objekt nach den angegebenen Ausdrücken neu

Detailed examples can be found at Relational API page.

sql_query(self: _duckdb.DuckDBPyRelation) → str¶: Gibt die der Relation entsprechende SQL-Abfrage zurück

Detailed examples can be found at Relational API page.

std(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Stichprobenstandardabweichung eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

stddev(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Stichprobenstandardabweichung eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

stddev_pop(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Populationsstandardabweichung eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

stddev_samp(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Stichprobenstandardabweichung eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

string_agg(self: _duckdb.DuckDBPyRelation, expression: str, sep: str = ',', groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Verkettet die Werte eines gegebenen Ausdrucks mit einem Trennzeichen

Detailed examples can be found at Relational API page.

sum(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Summe aller Werte eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

tf(self: _duckdb.DuckDBPyRelation) → dict¶: Holt ein Ergebnis als dict von TensorFlow-Tensoren

Detailed examples can be found at Relational API page.

to_arrow_reader(self: _duckdb.DuckDBPyRelation, batch_size: SupportsInt = 1000000) → pyarrow.lib.RecordBatchReader¶: Führt aus und gibt einen Arrow Record Batch Reader zurück, der alle Zeilen liefert

Detailed examples can be found at Relational API page.

to_arrow_table(self: _duckdb.DuckDBPyRelation, batch_size: SupportsInt = 1000000) → pyarrow.lib.Table¶: Führt aus und holt alle Zeilen als Arrow Table

Detailed examples can be found at Relational API page.

to_csv(self: _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¶: Schreibt das Relation-Objekt in eine CSV-Datei in ‘file_name’

Detailed examples can be found at Relational API page.

to_df(self: _duckdb.DuckDBPyRelation, *, date_as_object: bool = False) → pandas.DataFrame¶: Führt aus und holt alle Zeilen als pandas-DataFrame

Detailed examples can be found at Relational API page.

to_parquet(self: _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, filename_pattern: object = None, file_size_bytes: object = None) → None¶: Schreibt das Relation-Objekt in eine Parquet-Datei in ‘file_name’

Detailed examples can be found at Relational API page.

to_table(self: _duckdb.DuckDBPyRelation, table_name: str) → None¶: Erzeugt eine neue Tabelle namens table_name mit dem Inhalt des Relation-Objekts

Detailed examples can be found at Relational API page.

to_view(self: _duckdb.DuckDBPyRelation, view_name: str, replace: bool = True) → _duckdb.DuckDBPyRelation¶: Erzeugt einen View namens view_name, der auf das Relation-Objekt verweist

Detailed examples can be found at Relational API page.

torch(self: _duckdb.DuckDBPyRelation) → dict¶: Holt ein Ergebnis als dict von PyTorch-Tensoren

Detailed examples can be found at Relational API page.

type¶: Gibt den Typ der Relation zurück.

Detailed examples can be found at Relational API page.

types¶: Gibt eine Liste mit den Typen der Spalten der Relation zurück.

Detailed examples can be found at Relational API page.

union(self: _duckdb.DuckDBPyRelation, union_rel: _duckdb.DuckDBPyRelation) → _duckdb.DuckDBPyRelation¶: Erzeugt die Mengenvereinigung dieses Relation-Objekts mit einem weiteren Relation-Objekt in other_rel

Detailed examples can be found at Relational API page.

unique(self: _duckdb.DuckDBPyRelation, unique_aggr: str) → _duckdb.DuckDBPyRelation¶: Gibt die eindeutigen Werte einer Spalte zurück.

Detailed examples can be found at Relational API page.

update(self: _duckdb.DuckDBPyRelation, set: object, *, condition: object = None) → None¶: Aktualisiert die gegebene Relation mit den angegebenen Ausdrücken

Detailed examples can be found at Relational API page.

value_counts(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Anzahl der Elemente eines gegebenen Ausdrucks und projiziert zusätzlich den ursprünglichen Ausdruck

Detailed examples can be found at Relational API page.

var(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Stichprobenvarianz eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

var_pop(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Populationsvarianz eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

var_samp(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Stichprobenvarianz eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

variance(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') → _duckdb.DuckDBPyRelation¶: Berechnet die Stichprobenvarianz eines gegebenen Ausdrucks

Detailed examples can be found at Relational API page.

write_csv(self: _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¶: Schreibt das Relation-Objekt in eine CSV-Datei in ‘file_name’

Detailed examples can be found at Relational API page.

write_parquet(self: _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, filename_pattern: object = None, file_size_bytes: object = None) → None¶: Schreibt das Relation-Objekt in eine Parquet-Datei in ‘file_name’

Detailed examples can be found at Relational API page.

class duckdb.Error¶: Bases: Exception

class duckdb.ExpectedResultType¶

Bases: pybind11_object

Members:

QUERY_RESULT

CHANGED_ROWS

NOTHING

ExpectedResultType.name -> str

class duckdb.ExplainType¶

Bases: pybind11_object

Members:

STANDARD

ANALYZE

ExplainType.name -> str

class duckdb.Expression¶

Bases: pybind11_object

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

Erzeugt eine Kopie dieses Ausdrucks mit dem angegebenen Alias.

Parameter:: name: Der Alias für den Ausdruck; beeinflusst, wie er referenziert werden kann.
Returns:: Expression: self mit einem Alias.

asc(self: _duckdb.Expression) → _duckdb.Expression¶: Setzt den order-by-Modifikator auf ASCENDING.

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

cast(self: _duckdb.Expression, type: _duckdb._sqltypes.DuckDBPyType) → _duckdb.Expression¶

Erzeugt eine CastExpression von self nach type

Parameter:: type: Der Zieltyp der Umwandlung
Returns:: CastExpression: self::type

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

desc(self: _duckdb.Expression) → _duckdb.Expression¶: Setzt den order-by-Modifikator auf DESCENDING.

get_name(self: _duckdb.Expression) → str¶

Gibt die Zeichenkettendarstellung des Ausdrucks zurück.

Returns:: str: Die Zeichenkettendarstellung.

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

Gibt einen IN-Ausdruck zurück, der self mit den Eingabeargumenten vergleicht.

Returns:: DuckDBPyExpression: Der Vergleichsausdruck IN

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

Gibt einen NOT-IN-Ausdruck zurück, der self mit den Eingabeargumenten vergleicht.

Returns:: DuckDBPyExpression: Der Vergleichsausdruck NOT IN

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

Erzeugt einen binären IS-NOT-NULL-Ausdruck aus self

Returns:: DuckDBPyExpression: self IS NOT NULL

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

Erzeugt einen binären IS-NULL-Ausdruck aus self

Returns:: DuckDBPyExpression: self IS NULL

nulls_first(self: _duckdb.Expression) → _duckdb.Expression¶: Setzt den NULL-order-by-Modifikator auf NULLS FIRST.

nulls_last(self: _duckdb.Expression) → _duckdb.Expression¶: Setzt den NULL-order-by-Modifikator auf NULLS LAST.

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

Fügt der CaseExpression eine ELSE-<value>-Klausel hinzu.

Parameter:: value: Der Wert, der verwendet wird, wenn keine der WHEN-Bedingungen zutrifft.
Returns:: CaseExpression: self mit einer ELSE-Klausel.

show(self: _duckdb.Expression) → None¶: Gibt die Zeichenkettendarstellung des Ausdrucks aus.

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

Fügt der CaseExpression eine weitere WHEN-<condition>-THEN-<value>-Klausel hinzu.

Parameter:: condition: Die Bedingung, die erfüllt sein muss. value: Der Wert, der verwendet wird, wenn die Bedingung erfüllt ist.
Returns:: CaseExpression: self mit einer zusätzlichen WHEN-Klausel.

class duckdb.FatalException¶: Bases: DatabaseError

class duckdb.FloatValue(object: Any)¶: Bases: Value

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

class duckdb.HTTPException¶

Bases: IOException

Wird ausgelöst, wenn in der httpfs-Erweiterung oder beim Herunterladen einer Erweiterung ein Fehler auftritt.

class duckdb.HugeIntegerValue(object: Any)¶: Bases: Value

class duckdb.IOException¶: Bases: OperationalError

class duckdb.IntegerValue(object: Any)¶: Bases: Value

class duckdb.IntegrityError¶: Bases: DatabaseError

class duckdb.InternalError¶: Bases: DatabaseError

class duckdb.InternalException¶: Bases: InternalError

class duckdb.InterruptException¶: Bases: DatabaseError

class duckdb.IntervalValue(object: Any)¶: Bases: Value

class duckdb.InvalidInputException¶: Bases: ProgrammingError

class duckdb.InvalidTypeException¶: Bases: ProgrammingError

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

class duckdb.ListValue(object: Any, child_type: DuckDBPyType)¶: Bases: Value

class duckdb.LongValue(object: Any)¶: Bases: Value

class duckdb.MapValue(object: Any, key_type: DuckDBPyType, value_type: DuckDBPyType)¶: Bases: Value

class duckdb.NotImplementedException¶: Bases: NotSupportedError

class duckdb.NotSupportedError¶: Bases: DatabaseError

class duckdb.NullValue¶: Bases: Value

class duckdb.OperationalError¶: Bases: DatabaseError

class duckdb.OutOfMemoryException¶: Bases: OperationalError

class duckdb.OutOfRangeException¶: Bases: DataError

class duckdb.ParserException¶: Bases: ProgrammingError

class duckdb.PermissionException¶: Bases: DatabaseError

class duckdb.ProgrammingError¶: Bases: DatabaseError

class duckdb.PythonExceptionHandling¶

Bases: pybind11_object

Members:

DEFAULT

RETURN_NULL

PythonExceptionHandling.name -> str

class duckdb.RenderMode¶

Bases: pybind11_object

Members:

ROWS

COLUMNS

RenderMode.name -> str

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

class duckdb.SequenceException¶: Bases: DatabaseError

class duckdb.SerializationException¶: Bases: OperationalError

class duckdb.ShortValue(object: Any)¶: Bases: Value

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

Overloaded function.

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

class duckdb.Statement¶

Bases: pybind11_object

property expected_result_type¶: Gibt den erwarteten Ergebnistyp dieser Anweisung zurück; der tatsächliche Typ kann je nach Anweisung abweichen.

property named_parameters¶: Gibt die Map der benannten Parameter dieser Anweisung zurück.

property query¶: Gibt die dieser Anweisung entsprechende Abfrage zurück.

property type¶: Gibt den Typ der Anweisung zurück.

class duckdb.StatementType¶

Bases: pybind11_object

Members:

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

MERGE_INTO

StatementType.name -> str

class duckdb.StringValue(object: Any)¶: Bases: Value

class duckdb.StructValue(object: Any, children: dict[str, DuckDBPyType])¶: Bases: Value

class duckdb.SyntaxException¶: Bases: ProgrammingError

class duckdb.TimeTimeZoneValue(object: Any)¶: Bases: Value

class duckdb.TimeValue(object: Any)¶: Bases: Value

class duckdb.TimestampMillisecondValue(object: Any)¶: Bases: Value

class duckdb.TimestampNanosecondValue(object: Any)¶: Bases: Value

class duckdb.TimestampSecondValue(object: Any)¶: Bases: Value

class duckdb.TimestampTimeZoneValue(object: Any)¶: Bases: Value

class duckdb.TimestampValue(object: Any)¶: Bases: Value

class duckdb.TransactionException¶: Bases: OperationalError

class duckdb.TypeMismatchException¶: Bases: DataError

class duckdb.UUIDValue(object: Any)¶: Bases: Value

class duckdb.UnionType(object: Any, members: dict[str, DuckDBPyType])¶: Bases: Value

class duckdb.UnsignedBinaryValue(object: Any)¶: Bases: Value

class duckdb.UnsignedHugeIntegerValue(object: Any)¶: Bases: Value

class duckdb.UnsignedIntegerValue(object: Any)¶: Bases: Value

class duckdb.UnsignedLongValue(object: Any)¶: Bases: Value

class duckdb.UnsignedShortValue(object: Any)¶: Bases: Value

class duckdb.Value(object: Any, type: DuckDBPyType)¶: Bases: object

class duckdb.Warning¶: Bases: Exception

duckdb.__annotate__(format, /)¶

duckdb.aggregate(df: pandas.DataFrame, aggr_expr: object, group_expr: str = '', *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Berechnet die Aggregation aggr_expr nach den optionalen Gruppen group_expr auf der Relation

duckdb.alias(df: pandas.DataFrame, alias: str, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Benennt das Relation-Objekt in einen neuen Alias um

duckdb.append(table_name: str, df: pandas.DataFrame, *, by_name: bool = False, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Hängt das übergebene DataFrame an die benannte Tabelle an

duckdb.array_type(type: _duckdb._sqltypes.DuckDBPyType, size: SupportsInt, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Array-Typ-Objekt von ‘type’

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

Overloaded function.

arrow(rows_per_batch: typing.SupportsInt = 1000000, *, connection: duckdb.DuckDBPyConnection = None) -> pyarrow.lib.RecordBatchReader

Alias von to_arrow_reader(). Verwenden Sie stattdessen to_arrow_reader().

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

Erzeugt ein Relation-Objekt aus einem Arrow-Objekt

duckdb.begin(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Startet eine neue Transaktion

duckdb.checkpoint(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Synchronisiert Daten aus dem Write-Ahead Log (WAL) in die Datenbankdatei (keine Operation bei In-Memory-Verbindungen)

duckdb.close(*, connection: duckdb.DuckDBPyConnection = None) → None¶: Close the connection

duckdb.commit(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Commitet die innerhalb einer Transaktion vorgenommenen Änderungen

duckdb.connect(database: object = ':memory:', read_only: bool = False, config: dict = None) → duckdb.DuckDBPyConnection¶: Erzeugt eine DuckDB-Datenbankinstanz. Kann einen Datenbankdateinamen zum Lesen/Schreiben persistenter Daten und ein read_only-Flag entgegennehmen, wenn keine Änderungen gewünscht sind

duckdb.create_function(name: str, function: collections.abc.Callable, parameters: object = None, return_type: _duckdb._sqltypes.DuckDBPyType = None, *, type: _duckdb._func.PythonUDFType = <PythonUDFType.NATIVE: 0>, null_handling: _duckdb._func.FunctionNullHandling = <FunctionNullHandling.DEFAULT: 0>, exception_handling: _duckdb.PythonExceptionHandling = <PythonExceptionHandling.DEFAULT: 0>, side_effects: bool = False, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Erzeugt aus der übergebenen Python-Funktion eine DuckDB-Funktion, die in Abfragen verwendet werden kann

duckdb.cursor(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Erzeugt eine Kopie der aktuellen Verbindung

duckdb.decimal_type(width: SupportsInt, scale: SupportsInt, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt einen Dezimaltyp mit ‘width’ und ‘scale’

duckdb.default_connection() → duckdb.DuckDBPyConnection¶: Gibt die derzeit als Standard registrierte Verbindung des Moduls zurück

duckdb.description(*, connection: duckdb.DuckDBPyConnection = None) → Optional[list]¶: Gibt Attribute des Ergebnissets zurück, vor allem Spaltennamen

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

Overloaded function.

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

Holt ein Ergebnis als DataFrame nach execute()

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

Holt ein Ergebnis als DataFrame nach execute()

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

Erzeugt ein Relation-Objekt aus dem DataFrame df

duckdb.disable_profiling(*, connection: duckdb.DuckDBPyConnection = None) → None¶: Deaktiviert Profiling für die aktuelle Verbindung

duckdb.distinct(df: pandas.DataFrame, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Holt eindeutige Zeilen aus diesem Relation-Objekt

duckdb.dtype(type_str: str, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Typobjekt durch Parsen der Zeichenkette ‘type_str’

duckdb.duplicate(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Erzeugt eine Kopie der aktuellen Verbindung

duckdb.enable_profiling(*, connection: duckdb.DuckDBPyConnection = None) → None¶: Aktiviert Profiling für die aktuelle Verbindung

duckdb.enum_type(name: str, type: _duckdb._sqltypes.DuckDBPyType, values: list, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt einen Enum-Typ des zugrunde liegenden ‘type’ aus der Liste ‘values’

duckdb.execute(query: object, parameters: object = None, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Führt die angegebene SQL-Abfrage aus, optional mit Prepared Statements und gesetzten Parametern

duckdb.executemany(query: object, parameters: object = None, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Führt das angegebene Prepared Statement mehrfach mit der Liste der Parametersätze in parameters aus

duckdb.extract_statements(query: str, *, connection: duckdb.DuckDBPyConnection = None) → list¶: Parst die Abfragezeichenkette und extrahiert das/die erzeugte(n) Statement-Objekt(e)

duckdb.fetch_arrow_table(rows_per_batch: SupportsInt = 1000000, *, connection: duckdb.DuckDBPyConnection = None) → pyarrow.lib.Table¶: Holt ein Ergebnis als Arrow-Tabelle nach execute()

duckdb.fetch_df(*, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) → pandas.DataFrame¶: Holt ein Ergebnis als DataFrame nach execute()

duckdb.fetch_df_chunk(vectors_per_chunk: SupportsInt = 1, *, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) → pandas.DataFrame¶: Holt einen Chunk des Ergebnisses als DataFrame nach execute()

duckdb.fetch_record_batch(rows_per_batch: SupportsInt = 1000000, *, connection: duckdb.DuckDBPyConnection = None) → pyarrow.lib.RecordBatchReader¶: Holt einen Arrow RecordBatchReader nach execute()

duckdb.fetchall(*, connection: duckdb.DuckDBPyConnection = None) → list¶: Holt alle Zeilen eines Ergebnisses nach execute

duckdb.fetchdf(*, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) → pandas.DataFrame¶: Holt ein Ergebnis als DataFrame nach execute()

duckdb.fetchmany(size: SupportsInt = 1, *, connection: duckdb.DuckDBPyConnection = None) → list¶: Holt den nächsten Satz Zeilen eines Ergebnisses nach execute

duckdb.fetchnumpy(*, connection: duckdb.DuckDBPyConnection = None) → dict¶: Holt ein Ergebnis als Liste von NumPy-Arrays nach execute

duckdb.fetchone(*, connection: duckdb.DuckDBPyConnection = None) → Optional[tuple]¶: Holt eine einzelne Zeile eines Ergebnisses nach execute

duckdb.filesystem_is_registered(name: str, *, connection: duckdb.DuckDBPyConnection = None) → bool¶: Prüft, ob ein Dateisystem mit dem angegebenen Namen derzeit registriert ist

duckdb.filter(df: pandas.DataFrame, filter_expr: object, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Filtert das Relation-Objekt anhand des Filters in filter_expr

duckdb.from_arrow(arrow_object: object, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus einem Arrow-Objekt

duckdb.from_csv_auto(path_or_buffer: object, **kwargs) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus der CSV-Datei in ‘name’

duckdb.from_df(df: pandas.DataFrame, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus dem DataFrame in df

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

Overloaded function.

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

Erzeugt ein Relation-Objekt aus den Parquet-Dateien in file_glob

from_parquet(file_globs: collections.abc.Sequence[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.DuckDBPyRelation

Erzeugt ein Relation-Objekt aus den Parquet-Dateien in file_globs

duckdb.from_query(query: object, *, alias: str = '', params: object = None, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Führt eine SQL-Abfrage aus. Bei einer SELECT-Anweisung wird ein Relation-Objekt aus der Abfrage erzeugt, andernfalls wird die Abfrage unverändert ausgeführt.

duckdb.get_profiling_information(*, format: str = 'json', connection: duckdb.DuckDBPyConnection = None) → str¶: Holt Profiling-Informationen aus einer Abfrage

duckdb.get_table_names(query: str, *, qualified: bool = False, connection: duckdb.DuckDBPyConnection = None) → set[str]¶: Extrahiert die benötigten Tabellennamen aus einer Abfrage

duckdb.install_extension(extension: str, *, force_install: bool = False, repository: object = None, repository_url: object = None, version: object = None, connection: duckdb.DuckDBPyConnection = None) → None¶: Installiert eine Erweiterung anhand des Namens, optional mit Version und/oder Repository

duckdb.interrupt(*, connection: duckdb.DuckDBPyConnection = None) → None¶: Unterbricht ausstehende Operationen

duckdb.limit(df: pandas.DataFrame, n: SupportsInt, offset: SupportsInt = 0, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Holt nur die ersten n Zeilen dieses Relation-Objekts, beginnend bei offset

duckdb.list_filesystems(*, connection: duckdb.DuckDBPyConnection = None) → list¶: Listet registrierte Dateisysteme auf, einschließlich der eingebauten

duckdb.list_type(type: _duckdb._sqltypes.DuckDBPyType, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Listentyp-Objekt von ‘type’

duckdb.load_extension(extension: str, *, connection: duckdb.DuckDBPyConnection = None) → None¶: Lädt eine installierte Erweiterung

duckdb.map_type(key: _duckdb._sqltypes.DuckDBPyType, value: _duckdb._sqltypes.DuckDBPyType, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Map-Typ-Objekt aus ‘key_type’ und ‘value_type’

duckdb.order(df: pandas.DataFrame, order_expr: str, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Ordnet das Relation-Objekt nach order_expr neu

duckdb.pl(rows_per_batch: SupportsInt = 1000000, *, lazy: bool = False, connection: duckdb.DuckDBPyConnection = None) → duckdb::PolarsDataFrame¶: Holt ein Ergebnis als Polars-DataFrame nach execute()

duckdb.project(df: pandas.DataFrame, *args, groups: str = '', connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Projiziert das Relation-Objekt anhand der Projektion in project_expr

duckdb.query(query: object, *, alias: str = '', params: object = None, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Führt eine SQL-Abfrage aus. Bei einer SELECT-Anweisung wird ein Relation-Objekt aus der Abfrage erzeugt, andernfalls wird die Abfrage unverändert ausgeführt.

duckdb.query_df(df: pandas.DataFrame, virtual_table_name: str, sql_query: str, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Führt die SQL-Abfrage in sql_query auf dem View namens virtual_table_name aus, der auf das Relation-Objekt verweist

duckdb.query_progress(*, connection: duckdb.DuckDBPyConnection = None) → float¶: Gibt den Fortschritt der ausstehenden Operation zurück

duckdb.read_csv(path_or_buffer: object, **kwargs) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus der CSV-Datei in ‘name’

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.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus der JSON-Datei in ‘name’

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

Overloaded function.

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

Erzeugt ein Relation-Objekt aus den Parquet-Dateien in file_glob

read_parquet(file_globs: collections.abc.Sequence[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.DuckDBPyRelation

Erzeugt ein Relation-Objekt aus den Parquet-Dateien in file_globs

duckdb.register(view_name: str, python_object: object, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Registriert das übergebene Python-Objekt zur Abfrage über einen View

duckdb.register_filesystem(filesystem: fsspec.AbstractFileSystem, *, connection: duckdb.DuckDBPyConnection = None) → None¶: Registriert ein fsspec-konformes Dateisystem

duckdb.remove_function(name: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Entfernt eine zuvor erstellte Funktion

duckdb.rollback(*, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Rollt die innerhalb einer Transaktion vorgenommenen Änderungen zurück

duckdb.row_type(fields: object, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Struct-Typ-Objekt aus ‘fields’

duckdb.rowcount(*, connection: duckdb.DuckDBPyConnection = None) → int¶: Gibt die Zeilenanzahl des Ergebnissets zurück

duckdb.set_default_connection(connection: duckdb.DuckDBPyConnection) → None¶: Registriert die angegebene Verbindung als Standardverbindung des Moduls

duckdb.sql(query: object, *, alias: str = '', params: object = None, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Führt eine SQL-Abfrage aus. Bei einer SELECT-Anweisung wird ein Relation-Objekt aus der Abfrage erzeugt, andernfalls wird die Abfrage unverändert ausgeführt.

duckdb.sqltype(type_str: str, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Typobjekt durch Parsen der Zeichenkette ‘type_str’

duckdb.string_type(collation: str = '', *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt einen String-Typ mit optionaler Collation

duckdb.struct_type(fields: object, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Struct-Typ-Objekt aus ‘fields’

duckdb.table(table_name: str, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt für die benannte Tabelle

duckdb.table_function(name: str, parameters: object = None, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus der benannten Tabellenfunktion mit den angegebenen Parametern

duckdb.tf(*, connection: duckdb.DuckDBPyConnection = None) → dict¶: Holt ein Ergebnis als dict von TensorFlow-Tensoren nach execute()

duckdb.to_arrow_reader(batch_size: SupportsInt = 1000000, *, connection: duckdb.DuckDBPyConnection = None) → pyarrow.lib.RecordBatchReader¶: Holt einen Arrow RecordBatchReader nach execute()

duckdb.to_arrow_table(batch_size: SupportsInt = 1000000, *, connection: duckdb.DuckDBPyConnection = None) → pyarrow.lib.Table¶: Holt ein Ergebnis als Arrow-Tabelle nach execute()

class duckdb.token_type¶

Bases: pybind11_object

Members:

identifier

numeric_const

string_const

operator

keyword

comment

token_type.name -> str

duckdb.tokenize(query: str) → list¶: Tokenisiert eine SQL-Zeichenkette und gibt eine Liste von (position, type)-Tupeln zurück, z. B. für Syntaxhervorhebung

duckdb.torch(*, connection: duckdb.DuckDBPyConnection = None) → dict¶: Holt ein Ergebnis als dict von PyTorch-Tensoren nach execute()

duckdb.type(type_str: str, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Typobjekt durch Parsen der Zeichenkette ‘type_str’

duckdb.union_type(members: object, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb._sqltypes.DuckDBPyType¶: Erzeugt ein Union-Typ-Objekt aus ‘members’

duckdb.unregister(view_name: str, *, connection: duckdb.DuckDBPyConnection = None) → duckdb.DuckDBPyConnection¶: Deregistriert den View-Namen

duckdb.unregister_filesystem(name: str, *, connection: duckdb.DuckDBPyConnection = None) → None¶: Deregistriert ein Dateisystem

duckdb.values(*args, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt aus den übergebenen Werten

duckdb.version() → str¶: Menschenlesbare Versionszeichenkette des Distributionspakets und der mitgelieferten DuckDB-Engine.

duckdb.view(view_name: str, *, connection: duckdb.DuckDBPyConnection = None) → _duckdb.DuckDBPyRelation¶: Erzeugt ein Relation-Objekt für den benannten View

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¶: Schreibt das Relation-Objekt in eine CSV-Datei in ‘file_name’