Relationale API

Die Relationale API ist eine alternative API zum schrittweisen Aufbau von Abfragen. Die API basiert auf DuckDBPyRelation-Knoten. Die Relationen können als symbolische Darstellungen von SQL-Abfragen verstanden werden.

Verzögerte Auswertung

Die Relationen halten keine Daten – und es wird nichts ausgeführt –, bis eine Methode aufgerufen wird, die die Ausführung auslöst.

Zum Beispiel erstellen wir eine Relation, die 1 Milliarde Zeilen lädt:

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("from range(1_000_000_000)")

Zum Zeitpunkt der Ausführung hält rel keine Daten, und es werden keine Daten aus der Datenbank abgerufen.

Durch Aufruf von rel.show() oder durch einfaches Ausgeben von rel im Terminal werden die ersten 10K Zeilen geholt. Gibt es mehr als 10K Zeilen, zeigt das Ausgabefenster >9999 Zeilen (da die Zeilenanzahl der Relation unbekannt ist).

Durch Aufruf einer Ausgabe-Methode werden die Daten abgerufen und im angegebenen Format gespeichert:

rel.to_table("example_rel")

# 100% ▕████████████████████████████████████████████████████████████▏

Relationen erstellen

Dieser Abschnitt beschreibt, wie eine Relation erstellt wird. Die Methoden werden verzögert ausgewertet.

Name	Beschreibung
`from_arrow`	Erstellt ein Relation-Objekt aus einem Arrow-Objekt
`from_csv_auto`	Erstellt ein Relation-Objekt aus der CSV-Datei in ‘name’
`from_df`	Erstellt ein Relation-Objekt aus dem DataFrame in df
`from_parquet`	Erstellt ein Relation-Objekt aus den Parquet-Dateien
`from_query`	Führt eine SQL-Abfrage aus. Ist es eine SELECT-Anweisung, wird ein Relation-Objekt aus der SQL-Abfrage erstellt, andernfalls wird die Abfrage unverändert ausgeführt.
`query`	Führt eine SQL-Abfrage aus. Ist es eine SELECT-Anweisung, wird ein Relation-Objekt aus der SQL-Abfrage erstellt, andernfalls wird die Abfrage unverändert ausgeführt.
`read_csv`	Erstellt ein Relation-Objekt aus der CSV-Datei in ‘name’
`read_json`	Erstellt ein Relation-Objekt aus der JSON-Datei in ‘name’
`read_parquet`	Erstellt ein Relation-Objekt aus den Parquet-Dateien
`sql`	Führt eine SQL-Abfrage aus. Ist es eine SELECT-Anweisung, wird ein Relation-Objekt aus der SQL-Abfrage erstellt, andernfalls wird die Abfrage unverändert ausgeführt.
`table`	Erstellt ein Relation-Objekt für die benannte Tabelle
`table_function`	Erstellt ein Relation-Objekt aus der benannten Tabellenfunktion mit den angegebenen Parametern
`values`	Erstellt ein Relation-Objekt aus den übergebenen Werten
`view`	Erstellt ein Relation-Objekt für die benannte View

`from_arrow`

Signatur

from_arrow(self: _duckdb.DuckDBPyConnection, arrow_object: object) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt ein Relation-Objekt aus einem Arrow-Objekt

Parameter

arrow_object : pyarrow.Table, pyarrow.RecordBatch

Arrow-Objekt, aus dem eine Relation erstellt wird

Beispiel

import duckdb
import pyarrow as pa

ids = pa.array([1], type=pa.int8())
texts = pa.array(['a'], type=pa.string())
example_table = pa.table([ids, texts], names=["id", "text"])

duckdb_conn = duckdb.connect()

rel = duckdb_conn.from_arrow(example_table)

rel.show()

Ergebnis

┌──────┬─────────┐
│  id  │  text   │
│ int8 │ varchar │
├──────┼─────────┤
│    1 │ a       │
└──────┴─────────┘

`from_csv_auto`

Signatur

from_csv_auto(self: _duckdb.DuckDBPyConnection, path_or_buffer: object, **kwargs) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt ein Relation-Objekt aus der CSV-Datei in ‘name’

Aliase: read_csv

Parameter

path_or_buffer : Union[str, StringIO, TextIOBase]

Pfad zur CSV-Datei oder zum Puffer, aus dem gelesen wird.
header : Optional[bool], Optional[int]

Zeilennummer(n) als Spaltennamen, oder None, wenn kein Header vorhanden ist.
compression : Optional[str]

Kompressionstyp (z. B. ‘gzip’, ‘bz2’).
sep : Optional[str]

Zu verwendendes Trennzeichen; Standard ist Komma.
delimiter : Optional[str]

Alternatives Trennzeichen.
dtype : Optional[Dict[str, str]], Optional[List[str]]

Datentypen für Spalten.
na_values : Optional[str], Optional[List[str]]

Zusätzliche Zeichenketten, die als NA/NaN erkannt werden.
skiprows : Optional[int]

Anzahl der am Anfang zu überspringenden Zeilen.
quotechar : Optional[str]

Zeichen zum Quoten von Feldern.
escapechar : Optional[str]

Zeichen zum Escapen von Trenn- oder Quote-Zeichen.
encoding : Optional[str]

Kodierung für UTF beim Lesen/Schreiben.
parallel : Optional[bool]

Paralleles Lesen aktivieren.
date_format : Optional[str]

Format zum Parsen von Datumsangaben.
timestamp_format : Optional[str]

Format zum Parsen von Zeitstempeln.
sample_size : Optional[int]

Anzahl der zu samplenden Zeilen zur Schemaableitung.
all_varchar : Optional[bool]

Alle Spalten als VARCHAR behandeln.
normalize_names : Optional[bool]

Spaltennamen auf Kleinbuchstaben normalisieren.
null_padding : Optional[bool]

Null-Padding für Zeilen mit fehlenden Spalten aktivieren.
names : Optional[List[str]]

Liste der zu verwendenden Spaltennamen.
lineterminator : Optional[str]

Zeichen, an dem Zeilen umbrochen werden.
columns : Optional[Dict[str, str]]

Spaltenzuordnung für das Schema.
auto_type_candidates : Optional[List[str]]

Liste der Spalten für die automatische Typableitung.
max_line_size : Optional[int]

Maximale Zeilengröße in Bytes.
ignore_errors : Optional[bool]

Parsefehler ignorieren.
store_rejects : Optional[bool]

Abgelehnte Zeilen speichern.
rejects_table : Optional[str]

Tabellenname zum Speichern abgelehnter Zeilen.
rejects_scan : Optional[str]

Scan für abgelehnte Zeilen.
rejects_limit : Optional[int]

Begrenzt die Anzahl gespeicherter Ablehnungen.
force_not_null : Optional[List[str]]

Liste der Spalten, die als NOT NULL erzwungen werden.
buffer_size : Optional[int]

Puffergröße in Bytes.
decimal : Optional[str]

Zeichen, das als Dezimalpunkt erkannt wird.
allow_quoted_nulls : Optional[bool]

Gequotete NULL-Werte zulassen.
filename : Optional[bool], Optional[str]

Dateinamen-Spalte hinzufügen oder Dateiname angeben.
hive_partitioning : Optional[bool]

Hive-Partitionierung aktivieren.
union_by_name : Optional[bool]

Dateien nach Spaltenname statt nach Position vereinigen.
hive_types : Optional[Dict[str, str]]

Hive-Typen für Spalten.
hive_types_autocast : Optional[bool]

Hive-Typen automatisch casten.
connection : DuckDBPyConnection

Zu verwendende DuckDB-Verbindung.

Beispiel

import csv
import duckdb

duckdb_conn = duckdb.connect()

with open('code_example.csv', 'w', newline='') as csvfile:
    fieldnames = ['id', 'text']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerow({'id': '1', 'text': 'a'})

rel = duckdb_conn.from_csv_auto("code_example.csv")

rel.show()

Ergebnis

┌───────┬─────────┐
│  id   │  text   │
│ int64 │ varchar │
├───────┼─────────┤
│     1 │ a       │
└───────┴─────────┘

`from_df`

Signatur

from_df(self: _duckdb.DuckDBPyConnection, df: pandas.DataFrame) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt ein Relation-Objekt aus dem DataFrame in df

Parameter

df : pandas.DataFrame

Ein pandas DataFrame, das in eine DuckDB-Relation umgewandelt wird.

Beispiel

import duckdb
import pandas as pd

df = pd.DataFrame(data = {'id': [1], "text":["a"]})

duckdb_conn = duckdb.connect()

rel = duckdb_conn.from_df(df)

rel.show()

Ergebnis

┌───────┬─────────┐
│  id   │  text   │
│ int64 │ varchar │
├───────┼─────────┤
│     1 │ a       │
└───────┴─────────┘

`from_parquet`

Signatur

from_parquet(*args, **kwargs)
Overloaded function.

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

Create a relation object from the Parquet files in file_glob

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

Create a relation object from the Parquet files in file_globs

Beschreibung

Erstellt ein Relation-Objekt aus den Parquet-Dateien

Aliase: read_parquet

Parameter

file_glob : str

Dateipfad oder Glob-Muster, das auf zu lesende Parquet-Dateien zeigt.
binary_as_string : bool, default: False

Binärspalten als Zeichenketten statt als Blobs interpretieren.
file_row_number : bool, default: False

Eine Spalte mit der Zeilennummer innerhalb jeder Datei hinzufügen.
filename : bool, default: False

Eine Spalte mit dem Namen der Datei, aus der jede Zeile stammt, hinzufügen.
hive_partitioning : bool, default: False

Automatische Erkennung von Hive-Partitionen in Dateipfaden aktivieren.
union_by_name : bool, default: False

Parquet-Dateien anhand passender Spaltennamen statt Positionen vereinigen.
compression : object

Optionaler Kompressionscodec beim Lesen der Parquet-Dateien.

Beispiel

import duckdb
import pyarrow as pa
import pyarrow.parquet as pq

ids = pa.array([1], type=pa.int8())
texts = pa.array(['a'], type=pa.string())
example_table = pa.table([ids, texts], names=["id", "text"])

pq.write_table(example_table, "code_example.parquet")

duckdb_conn = duckdb.connect()

rel = duckdb_conn.from_parquet("code_example.parquet")

rel.show()

Ergebnis

┌──────┬─────────┐
│  id  │  text   │
│ int8 │ varchar │
├──────┼─────────┤
│    1 │ a       │
└──────┴─────────┘

`from_query`

Signatur

from_query(self: _duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) -> _duckdb.DuckDBPyRelation

Beschreibung

Führt eine SQL-Abfrage aus. Ist es eine SELECT-Anweisung, wird ein Relation-Objekt aus der SQL-Abfrage erstellt, andernfalls wird die Abfrage unverändert ausgeführt.

Warnung. Das Übergeben von params an diese Methode wird wegen erheblichem Leistungsaufwand nicht empfohlen. Verwenden Sie stattdessen execute() für parametrisierte Abfragen.

Aliase: query, sql

Parameter

query : object

Die SQL-Abfrage oder Unterabfrage, die ausgeführt und in eine Relation umgewandelt wird.
alias : str, default: ‘’

Optionaler Aliasname für die resultierende Relation.
params : object

Optionale Abfrageparameter. Nicht empfohlen wegen erheblichem Leistungsaufwand. Verwenden Sie stattdessen execute() für parametrisierte Abfragen.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.from_query("from range(1,2) tbl(id)")

rel.show()

Ergebnis

┌───────┐
│  id   │
│ int64 │
├───────┤
│     1 │
└───────┘

`query`

Signatur

query(self: _duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) -> _duckdb.DuckDBPyRelation

Beschreibung

Führt eine SQL-Abfrage aus. Ist es eine SELECT-Anweisung, wird ein Relation-Objekt aus der SQL-Abfrage erstellt, andernfalls wird die Abfrage unverändert ausgeführt.

Warnung. Das Übergeben von params an diese Methode wird wegen erheblichem Leistungsaufwand nicht empfohlen. Verwenden Sie stattdessen execute() für parametrisierte Abfragen.

Aliase: from_query, sql

Parameter

query : object

Die SQL-Abfrage oder Unterabfrage, die ausgeführt und in eine Relation umgewandelt wird.
alias : str, default: ‘’

Optionaler Aliasname für die resultierende Relation.
params : object

Optionale Abfrageparameter. Nicht empfohlen wegen erheblichem Leistungsaufwand. Verwenden Sie stattdessen execute() für parametrisierte Abfragen.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.query("from range(1,2) tbl(id)")

rel.show()

Ergebnis

┌───────┐
│  id   │
│ int64 │
├───────┤
│     1 │
└───────┘

`read_csv`

Signatur

read_csv(self: _duckdb.DuckDBPyConnection, path_or_buffer: object, **kwargs) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt ein Relation-Objekt aus der CSV-Datei in ‘name’

Aliase: from_csv_auto

Parameter

path_or_buffer : Union[str, StringIO, TextIOBase]

Pfad zur CSV-Datei oder zum Puffer, aus dem gelesen wird.
header : Optional[bool], Optional[int]

Zeilennummer(n) als Spaltennamen, oder None, wenn kein Header vorhanden ist.
compression : Optional[str]

Kompressionstyp (z. B. ‘gzip’, ‘bz2’).
sep : Optional[str]

Zu verwendendes Trennzeichen; Standard ist Komma.
delimiter : Optional[str]

Alternatives Trennzeichen.
dtype : Optional[Dict[str, str]], Optional[List[str]]

Datentypen für Spalten.
na_values : Optional[str], Optional[List[str]]

Zusätzliche Zeichenketten, die als NA/NaN erkannt werden.
skiprows : Optional[int]

Anzahl der am Anfang zu überspringenden Zeilen.
quotechar : Optional[str]

Zeichen zum Quoten von Feldern.
escapechar : Optional[str]

Zeichen zum Escapen von Trenn- oder Quote-Zeichen.
encoding : Optional[str]

Kodierung für UTF beim Lesen/Schreiben.
parallel : Optional[bool]

Paralleles Lesen aktivieren.
date_format : Optional[str]

Format zum Parsen von Datumsangaben.
timestamp_format : Optional[str]

Format zum Parsen von Zeitstempeln.
sample_size : Optional[int]

Anzahl der zu samplenden Zeilen zur Schemaableitung.
all_varchar : Optional[bool]

Alle Spalten als VARCHAR behandeln.
normalize_names : Optional[bool]

Spaltennamen auf Kleinbuchstaben normalisieren.
null_padding : Optional[bool]

Null-Padding für Zeilen mit fehlenden Spalten aktivieren.
names : Optional[List[str]]

Liste der zu verwendenden Spaltennamen.
lineterminator : Optional[str]

Zeichen, an dem Zeilen umbrochen werden.
columns : Optional[Dict[str, str]]

Spaltenzuordnung für das Schema.
auto_type_candidates : Optional[List[str]]

Liste der Spalten für die automatische Typableitung.
max_line_size : Optional[int]

Maximale Zeilengröße in Bytes.
ignore_errors : Optional[bool]

Parsefehler ignorieren.
store_rejects : Optional[bool]

Abgelehnte Zeilen speichern.
rejects_table : Optional[str]

Tabellenname zum Speichern abgelehnter Zeilen.
rejects_scan : Optional[str]

Scan für abgelehnte Zeilen.
rejects_limit : Optional[int]

Begrenzt die Anzahl gespeicherter Ablehnungen.
force_not_null : Optional[List[str]]

Liste der Spalten, die als NOT NULL erzwungen werden.
buffer_size : Optional[int]

Puffergröße in Bytes.
decimal : Optional[str]

Zeichen, das als Dezimalpunkt erkannt wird.
allow_quoted_nulls : Optional[bool]

Gequotete NULL-Werte zulassen.
filename : Optional[bool], Optional[str]

Dateinamen-Spalte hinzufügen oder Dateiname angeben.
hive_partitioning : Optional[bool]

Hive-Partitionierung aktivieren.
union_by_name : Optional[bool]

Dateien nach Spaltenname statt nach Position vereinigen.
hive_types : Optional[Dict[str, str]]

Hive-Typen für Spalten.
hive_types_autocast : Optional[bool]

Hive-Typen automatisch casten.
connection : DuckDBPyConnection

Zu verwendende DuckDB-Verbindung.

Beispiel

import csv
import duckdb

duckdb_conn = duckdb.connect()

with open('code_example.csv', 'w', newline='') as csvfile:
    fieldnames = ['id', 'text']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerow({'id': '1', 'text': 'a'})

rel = duckdb_conn.read_csv("code_example.csv")

rel.show()

Ergebnis

┌───────┬─────────┐
│  id   │  text   │
│ int64 │ varchar │
├───────┼─────────┤
│     1 │ a       │
└───────┴─────────┘

`read_json`

Signatur

read_json(self: _duckdb.DuckDBPyConnection, path_or_buffer: object, *, columns: typing.Optional[object] = None, sample_size: typing.Optional[object] = None, maximum_depth: typing.Optional[object] = None, records: typing.Optional[str] = None, format: typing.Optional[str] = None, date_format: typing.Optional[object] = None, timestamp_format: typing.Optional[object] = None, compression: typing.Optional[object] = None, maximum_object_size: typing.Optional[object] = None, ignore_errors: typing.Optional[object] = None, convert_strings_to_integers: typing.Optional[object] = None, field_appearance_threshold: typing.Optional[object] = None, map_inference_threshold: typing.Optional[object] = None, maximum_sample_files: typing.Optional[object] = None, filename: typing.Optional[object] = None, hive_partitioning: typing.Optional[object] = None, union_by_name: typing.Optional[object] = None, hive_types: typing.Optional[object] = None, hive_types_autocast: typing.Optional[object] = None) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt ein Relation-Objekt aus der JSON-Datei in ‘name’

Parameter

path_or_buffer : object

Dateipfad oder dateiähnliches Objekt mit zu lesenden JSON-Daten.
columns : object

Optionale Liste der aus den JSON-Daten zu projizierenden Spaltennamen.
sample_size : object

Anzahl der zu samplenden Zeilen zur Ableitung des JSON-Schemas.
maximum_depth : object

Maximale Tiefe, bis zu der JSON-Objekte geparst werden.
records : str

Formatzeichenkette, die angibt, ob JSON im Records-Modus vorliegt.
format : str

Format der JSON-Daten (z. B. ‘auto’, ‘newline_delimited’).
date_format : object

Formatzeichenkette zum Parsen von Datumsfeldern.
timestamp_format : object

Formatzeichenkette zum Parsen von Zeitstempelfeldern.
compression : object

Kompressionscodec der JSON-Daten (z. B. ‘gzip’).
maximum_object_size : object

Maximale Größe in Bytes für einzelne JSON-Objekte.
ignore_errors : object

Wenn True, JSON-Datensätze mit Parsefehlern überspringen.
convert_strings_to_integers : object

Wenn True, Zeichenketten wo sinnvoll in Ganzzahlen umwandeln.
field_appearance_threshold : object

Schwellenwert zur Ableitung optionaler Felder in verschachteltem JSON.
map_inference_threshold : object

Schwellenwert zur Ableitung von Maps aus JSON-Objektmustern.
maximum_sample_files : object

Maximale Anzahl der für die Schemaableitung zu samplenden Dateien.
filename : object

Wenn True, eine Spalte mit dem Quelldateinamen für jede Zeile aufnehmen.
hive_partitioning : object

Wenn True, Hive-Partitionierung anhand der Verzeichnisstruktur aktivieren.
union_by_name : object

Wenn True, JSON-Spalten nach Namen statt nach Position ausrichten.
hive_types : object

Wenn True, Hive-Typen aus der Verzeichnisstruktur für das Schema verwenden.
hive_types_autocast : object

Wenn True, Datentypen automatisch auf Hive-Typen casten.

Beispiel

import duckdb
import json

with open("code_example.json", mode="w") as f:
    json.dump([{'id': 1, "text":"a"}], f)

duckdb_conn = duckdb.connect()

rel = duckdb_conn.read_json("code_example.json")

rel.show()

Ergebnis

┌───────┬─────────┐
│  id   │  text   │
│ int64 │ varchar │
├───────┼─────────┤
│     1 │ a       │
└───────┴─────────┘

`read_parquet`

Signatur

read_parquet(*args, **kwargs)
Overloaded function.

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

Create a relation object from the Parquet files in file_glob

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

Create a relation object from the Parquet files in file_globs

Beschreibung

Erstellt ein Relation-Objekt aus den Parquet-Dateien

Aliase: from_parquet

Parameter

file_glob : str

Dateipfad oder Glob-Muster, das auf zu lesende Parquet-Dateien zeigt.
binary_as_string : bool, default: False

Binärspalten als Zeichenketten statt als Blobs interpretieren.
file_row_number : bool, default: False

Eine Spalte mit der Zeilennummer innerhalb jeder Datei hinzufügen.
filename : bool, default: False

Eine Spalte mit dem Namen der Datei, aus der jede Zeile stammt, hinzufügen.
hive_partitioning : bool, default: False

Automatische Erkennung von Hive-Partitionen in Dateipfaden aktivieren.
union_by_name : bool, default: False

Parquet-Dateien anhand passender Spaltennamen statt Positionen vereinigen.
compression : object

Optionaler Kompressionscodec beim Lesen der Parquet-Dateien.

Beispiel

import duckdb
import pyarrow as pa
import pyarrow.parquet as pq

ids = pa.array([1], type=pa.int8())
texts = pa.array(['a'], type=pa.string())
example_table = pa.table([ids, texts], names=["id", "text"])

pq.write_table(example_table, "code_example.parquet")

duckdb_conn = duckdb.connect()

rel = duckdb_conn.read_parquet("code_example.parquet")

rel.show()

Ergebnis

┌──────┬─────────┐
│  id  │  text   │
│ int8 │ varchar │
├──────┼─────────┤
│    1 │ a       │
└──────┴─────────┘

`sql`

Signatur

sql(self: _duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) -> _duckdb.DuckDBPyRelation

Beschreibung

Führt eine SQL-Abfrage aus. Ist es eine SELECT-Anweisung, wird ein Relation-Objekt aus der SQL-Abfrage erstellt, andernfalls wird die Abfrage unverändert ausgeführt.

Warnung. Das Übergeben von params an diese Methode wird wegen erheblichem Leistungsaufwand nicht empfohlen. Verwenden Sie stattdessen execute() für parametrisierte Abfragen.

Aliase: from_query, query

Parameter

query : object

Die SQL-Abfrage oder Unterabfrage, die ausgeführt und in eine Relation umgewandelt wird.
alias : str, default: ‘’

Optionaler Aliasname für die resultierende Relation.
params : object

Optionale Abfrageparameter. Nicht empfohlen wegen erheblichem Leistungsaufwand. Verwenden Sie stattdessen execute() für parametrisierte Abfragen.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("from range(1,2) tbl(id)")

rel.show()

Ergebnis

┌───────┐
│  id   │
│ int64 │
├───────┤
│     1 │
└───────┘

`table`

Signatur

table(self: _duckdb.DuckDBPyConnection, table_name: str) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt ein Relation-Objekt für die benannte Tabelle

Parameter

table_name : str

Name der Tabelle, aus der eine Relation erstellt wird.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

duckdb_conn.sql("create table code_example as select * from range(1,2) tbl(id)")

rel = duckdb_conn.table("code_example")

rel.show()

Ergebnis

┌───────┐
│  id   │
│ int64 │
├───────┤
│     1 │
└───────┘

`table_function`

Signatur

table_function(self: _duckdb.DuckDBPyConnection, name: str, parameters: object = None) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt ein Relation-Objekt aus der benannten Tabellenfunktion mit den angegebenen Parametern

Parameter

name : str

Name der aufzurufenden Tabellenfunktion.
parameters : object

Optionale Parameter, die an die Tabellenfunktion übergeben werden.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

duckdb_conn.sql("""
    create macro get_record_for(x) as table
    select x*range from range(1,2)
""")

rel = duckdb_conn.table_function(name="get_record_for", parameters=[1])

rel.show()

Ergebnis

┌───────────────┐
│ (1 * "range") │
│     int64     │
├───────────────┤
│             1 │
└───────────────┘

`values`

Signatur

values(self: _duckdb.DuckDBPyConnection, *args) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt ein Relation-Objekt aus den übergebenen Werten

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.values([1, 'a'])

rel.show()

Ergebnis

┌───────┬─────────┐
│ col0  │  col1   │
│ int32 │ varchar │
├───────┼─────────┤
│     1 │ a       │
└───────┴─────────┘

`view`

Signatur

view(self: _duckdb.DuckDBPyConnection, view_name: str) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt ein Relation-Objekt für die benannte View

Parameter

view_name : str

Name der View, aus der eine Relation erstellt wird.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

duckdb_conn.sql("create table code_example as select * from range(1,2) tbl(id)")

rel = duckdb_conn.view("code_example")

rel.show()

Ergebnis

┌───────┐
│  id   │
│ int64 │
├───────┤
│     1 │
└───────┘

Relation Definition Details

Dieser Abschnitt beschreibt, wie eine Relation inspiziert wird.

Name	Beschreibung
`alias`	Gibt den Namen des aktuellen Alias zurück
`columns`	Gibt eine Liste mit den Namen der Spalten der Relation zurück.
`describe`	Liefert Basisstatistiken (z. B. min, max) und ob NULL in jeder Spalte der Relation vorkommt.
`description`	Gibt die Beschreibung des Ergebnisses zurück
`dtypes`	Gibt eine Liste mit den Typen der Spalten der Relation zurück.
`explain`	explain(self: _duckdb.DuckDBPyRelation, type: _duckdb.ExplainType = ‘standard’) -> str
`query`	Führt die SQL-Abfrage in sql_query auf der View namens virtual_table_name aus, die auf das Relation-Objekt verweist
`set_alias`	Benennt das Relation-Objekt in einen neuen Alias um
`shape`	Tupel aus Anzahl der Zeilen und Anzahl der Spalten in der Relation.
`show`	Zeigt eine Zusammenfassung der Daten an
`sql_query`	Gibt die SQL-Abfrage zurück, die der Relation entspricht
`type`	Gibt den Typ der Relation zurück.
`types`	Gibt eine Liste mit den Typen der Spalten der Relation zurück.

`alias`

Beschreibung

Gibt den Namen des aktuellen Alias zurück

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.alias

Ergebnis

unnamed_relation_43c808c247431be5

`columns`

Beschreibung

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

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.columns

Ergebnis

 ['id', 'description', 'value', 'created_timestamp']

`describe`

Signatur

describe(self: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation

Beschreibung

Liefert Basisstatistiken (z. B. min, max) und ob NULL in jeder Spalte der Relation vorkommt.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.describe()

Ergebnis

┌─────────┬──────────────────────────────────────┬─────────────────┬────────────────────┬────────────────────────────┐
│  aggr   │                  id                  │   description   │       value        │     created_timestamp      │
│ varchar │               varchar                │     varchar     │       double       │          varchar           │
├─────────┼──────────────────────────────────────┼─────────────────┼────────────────────┼────────────────────────────┤
│ count   │ 9                                    │ 9               │                9.0 │ 9                          │
│ mean    │ NULL                                 │ NULL            │                5.0 │ NULL                       │
│ stddev  │ NULL                                 │ NULL            │ 2.7386127875258306 │ NULL                       │
│ min     │ 08fdcbf8-4e53-4290-9e81-423af263b518 │ value is even   │                1.0 │ 2025-04-09 15:41:20.642+02 │
│ max     │ fb10390e-fad5-4694-91cb-e82728cb6f9f │ value is uneven │                9.0 │ 2025-04-09 15:49:20.642+02 │
│ median  │ NULL                                 │ NULL            │                5.0 │ NULL                       │
└─────────┴──────────────────────────────────────┴─────────────────┴────────────────────┴────────────────────────────┘

`description`

Beschreibung

Gibt die Beschreibung des Ergebnisses zurück

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.description

Ergebnis

[('id', 'UUID', None, None, None, None, None),
 ('description', 'STRING', None, None, None, None, None),
 ('value', 'NUMBER', None, None, None, None, None),
 ('created_timestamp', 'DATETIME', None, None, None, None, None)]

`dtypes`

Beschreibung

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

Aliase: types

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.dtypes

Ergebnis

 [UUID, VARCHAR, BIGINT, TIMESTAMP WITH TIME ZONE]

`explain`

Beschreibung

explain(self: _duckdb.DuckDBPyRelation, type: _duckdb.ExplainType = ‘standard’) -> str

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.explain()

Ergebnis

┌───────────────────────────┐
│         PROJECTION        │
│    ────────────────────   │
│             id            │
│        description        │
│           value           │
│     created_timestamp     │
│                           │
│          ~9 Rows          │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│           RANGE           │
│    ────────────────────   │
│      Function: RANGE      │
│                           │
│          ~9 Rows          │
└───────────────────────────┘

`query`

Signatur

query(self: _duckdb.DuckDBPyRelation, virtual_table_name: str, sql_query: str) -> _duckdb.DuckDBPyRelation

Beschreibung

Führt die SQL-Abfrage in sql_query auf der View namens virtual_table_name aus, die auf das Relation-Objekt verweist

Parameter

virtual_table_name : str

Der Name, der der aktuellen Relation zugewiesen wird, wenn sie in der SQL-Abfrage referenziert wird.
sql_query : str

Die SQL-Abfragezeichenkette, die den virtuellen Tabellennamen verwendet, um die Relation abzufragen.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.query(virtual_table_name="rel_view", sql_query="from rel")

duckdb_conn.sql("show rel_view")

Ergebnis

┌───────────────────┬──────────────────────────┬─────────┬─────────┬─────────┬─────────┐
│    column_name    │       column_type        │  null   │   key   │ default │  extra  │
│      varchar      │         varchar          │ varchar │ varchar │ varchar │ varchar │
├───────────────────┼──────────────────────────┼─────────┼─────────┼─────────┼─────────┤
│ id                │ UUID                     │ YES     │ NULL    │ NULL    │ NULL    │
│ description       │ VARCHAR                  │ YES     │ NULL    │ NULL    │ NULL    │
│ value             │ BIGINT                   │ YES     │ NULL    │ NULL    │ NULL    │
│ created_timestamp │ TIMESTAMP WITH TIME ZONE │ YES     │ NULL    │ NULL    │ NULL    │
└───────────────────┴──────────────────────────┴─────────┴─────────┴─────────┴─────────┘

`set_alias`

Signatur

set_alias(self: _duckdb.DuckDBPyRelation, alias: str) -> _duckdb.DuckDBPyRelation

Beschreibung

Benennt das Relation-Objekt in einen neuen Alias um

Parameter

alias : str

Der Aliasname, der der Relation zugewiesen wird.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.set_alias('abc').select('abc.id')

Ergebnis

In the SQL query, the alias will be `abc`

`shape`

Beschreibung

Tupel aus Anzahl der Zeilen und Anzahl der Spalten in der Relation.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.shape

Ergebnis

(9, 4)

`show`

Signatur

show(self: _duckdb.DuckDBPyRelation, *, max_width: typing.Optional[typing.SupportsInt] = None, max_rows: typing.Optional[typing.SupportsInt] = None, max_col_width: typing.Optional[typing.SupportsInt] = None, null_value: typing.Optional[str] = None, render_mode: object = None) -> None

Beschreibung

Zeigt eine Zusammenfassung der Daten an

Parameter

max_width : int

Maximale Anzeigebreite der gesamten Ausgabe in Zeichen.
max_rows : int

Maximale Anzahl anzuzeigender Zeilen.
max_col_width : int

Maximale Anzahl anzuzeigender Zeichen pro Spalte.
null_value : str

Zeichenkette, die anstelle von NULL-Werten angezeigt wird.
render_mode : object

Rendermodus für die Anzeige der Ausgabe.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.show()

Ergebnis

┌──────────────────────────────────────┬─────────────────┬───────┬────────────────────────────┐
│                  id                  │   description   │ value │     created_timestamp      │
│                 uuid                 │     varchar     │ int64 │  timestamp with time zone  │
├──────────────────────────────────────┼─────────────────┼───────┼────────────────────────────┤
│ 642ea3d7-793d-4867-a759-91c1226c25a0 │ value is uneven │     1 │ 2025-04-09 15:41:20.642+02 │
│ 6817dd31-297c-40a8-8e40-8521f00b2d08 │ value is even   │     2 │ 2025-04-09 15:42:20.642+02 │
│ 45143f9a-e16e-4e59-91b2-3a0800eed6d6 │ value is uneven │     3 │ 2025-04-09 15:43:20.642+02 │
│ fb10390e-fad5-4694-91cb-e82728cb6f9f │ value is even   │     4 │ 2025-04-09 15:44:20.642+02 │
│ 111ced5c-9155-418e-b087-c331b814db90 │ value is uneven │     5 │ 2025-04-09 15:45:20.642+02 │
│ 66a870a6-aef0-4085-87d5-5d1b35d21c66 │ value is even   │     6 │ 2025-04-09 15:46:20.642+02 │
│ a7e8e796-bca0-44cd-a269-1d71090fb5cc │ value is uneven │     7 │ 2025-04-09 15:47:20.642+02 │
│ 74908d48-7f2d-4bdd-9c92-1e7920b115b5 │ value is even   │     8 │ 2025-04-09 15:48:20.642+02 │
│ 08fdcbf8-4e53-4290-9e81-423af263b518 │ value is uneven │     9 │ 2025-04-09 15:49:20.642+02 │
└──────────────────────────────────────┴─────────────────┴───────┴────────────────────────────┘

`sql_query`

Signatur

sql_query(self: _duckdb.DuckDBPyRelation) -> str

Beschreibung

Gibt die SQL-Abfrage zurück, die der Relation entspricht

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.sql_query()

Ergebnis

SELECT
    gen_random_uuid() AS id,
    concat('value is ', CASE  WHEN ((mod("range", 2) = 0)) THEN ('even') ELSE 'uneven' END) AS description,
    "range" AS "value",
    (now() + CAST(concat("range", ' ', 'minutes') AS INTERVAL)) AS created_timestamp
FROM "range"(1, 10)

`type`

Beschreibung

Gibt den Typ der Relation zurück.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.type

Ergebnis

QUERY_RELATION

`types`

Beschreibung

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

Aliase: dtypes

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.types

Ergebnis

[UUID, VARCHAR, BIGINT, TIMESTAMP WITH TIME ZONE]

Transformation

Dieser Abschnitt enthält die Methoden zum Verketten von Abfragen. Die Methoden werden verzögert ausgewertet.

Name	Beschreibung
`aggregate`	Berechnet die Aggregation aggr_expr nach den optionalen Gruppen group_expr auf der Relation
`apply`	Berechnet die Funktion einer einzelnen Spalte oder einer Liste von Spalten nach den optionalen Gruppen auf der Relation
`cross`	Erzeugt das Kreuz-/kartesische Produkt zweier Relation-Objekte
`except_`	Erzeugt die Mengendifferenz (EXCEPT) dieses Relation-Objekts mit einem weiteren Relation-Objekt in other_rel
`filter`	Filtert das Relation-Objekt mit dem Filter in filter_expr
`insert`	Fügt die angegebenen Werte in die Relation ein
`insert_into`	Fügt das Relation-Objekt in eine bestehende Tabelle namens table_name ein
`intersect`	Erzeugt die Mengenschnittmenge dieses Relation-Objekts mit einem weiteren Relation-Objekt in other_rel
`join`	Führt einen Join des Relation-Objekts mit einem weiteren Relation-Objekt in other_rel anhand des Join-Bedingungsausdrucks in join_condition durch. Unterstützte Typen sind ‘inner’, ‘left’, ‘right’, ‘outer’, ‘semi’ und ‘anti’
`limit`	Holt nur die ersten n Zeilen aus diesem Relation-Objekt, beginnend bei offset
`map`	Ruft die übergebene Funktion auf der Relation auf
`order`	Ordnet das Relation-Objekt nach order_expr neu
`project`	Projiziert das Relation-Objekt mit der Projektion in project_expr
`select`	Projiziert das Relation-Objekt mit der Projektion in project_expr
`sort`	Ordnet das Relation-Objekt nach den angegebenen Ausdrücken neu
`union`	Bildet die Mengenvereinigung dieser Relation mit einer anderen Relation in other_rel
`update`	Aktualisiert die gegebene Relation mit den angegebenen Ausdrücken

`aggregate`

Signatur

aggregate(self: _duckdb.DuckDBPyRelation, aggr_expr: object, group_expr: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Aggregation aggr_expr nach den optionalen Gruppen group_expr auf der Relation

Parameter

aggr_expr : str, list[Expression]

Die Liste der Spalten und Aggregationsfunktionen.
group_expr : str, default: ‘’

Die Liste der in group_by aufzunehmenden Spalten. Ist sie None, wird group by all angewendet.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel = rel.aggregate('max(value)')

Ergebnis

┌──────────────┐
│ max("value") │
│    int64     │
├──────────────┤
│            9 │
└──────────────┘

`apply`

Signatur

apply(self: _duckdb.DuckDBPyRelation, function_name: str, function_aggr: str, group_expr: str = '', function_parameter: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Funktion einer einzelnen Spalte oder einer Liste von Spalten nach den optionalen Gruppen auf der Relation

Parameter

function_name : str

Name der auf die Relation anzuwendenden Funktion.
function_aggr : str

Die Liste der Spalten, auf die die Funktion angewendet wird.
group_expr : str, default: ‘’

Optionaler SQL-Ausdruck für die Gruppierung.
function_parameter : str, default: ‘’

Optionale Parameter, die an die Funktion übergeben werden.
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.apply(
    function_name="count",
    function_aggr="id",
    group_expr="description",
    projected_columns="description"
)

Ergebnis

┌─────────────────┬───────────┐
│   description   │ count(id) │
│     varchar     │   int64   │
├─────────────────┼───────────┤
│ value is uneven │         5 │
│ value is even   │         4 │
└─────────────────┴───────────┘

`cross`

Signatur

cross(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation

Beschreibung

Erzeugt das Kreuz-/kartesische Produkt zweier Relation-Objekte

Parameter

other_rel : _duckdb.DuckDBPyRelation

Eine weitere Relation für das Kreuzprodukt.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.cross(other_rel=rel.set_alias("other_rel"))

Ergebnis

┌─────────────────────────────┬─────────────────┬───────┬───────────────────────────┬──────────────────────────────────────┬─────────────────┬───────┬───────────────────────────┐
│             id              │   description   │ value │     created_timestamp     │                  id                  │   description   │ value │     created_timestamp     │
│            uuid             │     varchar     │ int64 │ timestamp with time zone  │                 uuid                 │     varchar     │ int64 │ timestamp with time zone  │
├─────────────────────────────┼─────────────────┼───────┼───────────────────────────┼──────────────────────────────────────┼─────────────────┼───────┼───────────────────────────┤
│ cb2b453f-1a06-4f5e-abe1-b…  │ value is uneven │     1 │ 2025-04-10 09:53:29.78+02 │ cb2b453f-1a06-4f5e-abe1-bfd413581bcf │ value is uneven │     1 │ 2025-04-10 09:53:29.78+02 │
...

`except_`

Signatur

except_(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation

Beschreibung

Erzeugt die Mengendifferenz (EXCEPT) dieses Relation-Objekts mit einem weiteren Relation-Objekt in other_rel

Parameter

other_rel : _duckdb.DuckDBPyRelation

Die Relation, die von der aktuellen Relation abgezogen wird (Mengendifferenz).

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.except_(other_rel=rel.set_alias("other_rel"))

Ergebnis

The relation query is executed twice, therefore generating different ids and timestamps:
┌──────────────────────────────────────┬─────────────────┬───────┬────────────────────────────┐
│                  id                  │   description   │ value │     created_timestamp      │
│                 uuid                 │     varchar     │ int64 │  timestamp with time zone  │
├──────────────────────────────────────┼─────────────────┼───────┼────────────────────────────┤
│ f69ed6dd-a7fe-4de2-b6af-1c2418096d69 │ value is uneven │     3 │ 2025-04-10 11:43:05.711+02 │
│ 08ad11dc-a9c2-4aaa-9272-760b27ad1f5d │ value is uneven │     7 │ 2025-04-10 11:47:05.711+02 │
...

`filter`

Signatur

filter(self: _duckdb.DuckDBPyRelation, filter_expr: object) -> _duckdb.DuckDBPyRelation

Beschreibung

Filtert das Relation-Objekt mit dem Filter in filter_expr

Parameter

filter_expr : str, Expression

Der Filterausdruck, der auf die Relation angewendet wird.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.filter("value = 2")

Ergebnis

┌──────────────────────────────────────┬───────────────┬───────┬───────────────────────────┐
│                  id                  │  description  │ value │     created_timestamp     │
│                 uuid                 │    varchar    │ int64 │ timestamp with time zone  │
├──────────────────────────────────────┼───────────────┼───────┼───────────────────────────┤
│ b0684ab7-fcbf-41c5-8e4a-a51bdde86926 │ value is even │     2 │ 2025-04-10 09:54:29.78+02 │
└──────────────────────────────────────┴───────────────┴───────┴───────────────────────────┘

`insert`

Signatur

insert(self: _duckdb.DuckDBPyRelation, values: object) -> None

Beschreibung

Fügt die angegebenen Werte in die Relation ein

Parameter

values : object

Ein Tupel von Werten, das der Spaltenliste der Relation entspricht und eingefügt wird.

Beispiel

import duckdb

from datetime import datetime
from uuid import uuid4

duckdb_conn = duckdb.connect()

duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
).to_table("code_example")

rel = duckdb_conn.table("code_example")

rel.insert(
    (
        uuid4(),
        'value is even',
        10,
        datetime.now()
    )
)

rel.filter("value = 10")

Ergebnis

┌──────────────────────────────────────┬───────────────┬───────┬───────────────────────────────┐
│                  id                  │  description  │ value │       created_timestamp       │
│                 uuid                 │    varchar    │ int64 │   timestamp with time zone    │
├──────────────────────────────────────┼───────────────┼───────┼───────────────────────────────┤
│ c6dfab87-fae6-4213-8f76-1b96a8d179f6 │ value is even │    10 │ 2025-04-10 10:02:24.652218+02 │
└──────────────────────────────────────┴───────────────┴───────┴───────────────────────────────┘

`insert_into`

Signatur

insert_into(self: _duckdb.DuckDBPyRelation, table_name: str) -> None

Beschreibung

Fügt das Relation-Objekt in eine bestehende Tabelle namens table_name ein

Parameter

table_name : str

Der Tabellenname, in den die Daten eingefügt werden. Die Relation muss die Spaltenreihenfolge der Tabelle einhalten.

Beispiel

import duckdb

from datetime import datetime
from uuid import uuid4

duckdb_conn = duckdb.connect()

duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
).to_table("code_example")

rel = duckdb_conn.values(
    [
        uuid4(),
        'value is even',
        10,
        datetime.now()
    ]
)

rel.insert_into("code_example")

duckdb_conn.table("code_example").filter("value = 10")

Ergebnis

┌──────────────────────────────────────┬───────────────┬───────┬───────────────────────────────┐
│                  id                  │  description  │ value │       created_timestamp       │
│                 uuid                 │    varchar    │ int64 │   timestamp with time zone    │
├──────────────────────────────────────┼───────────────┼───────┼───────────────────────────────┤
│ 271c5ddd-c1d5-4638-b5a0-d8c7dc9e8220 │ value is even │    10 │ 2025-04-10 14:29:18.616379+02 │
└──────────────────────────────────────┴───────────────┴───────┴───────────────────────────────┘

`intersect`

Signatur

intersect(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation

Beschreibung

Erzeugt die Mengenschnittmenge dieses Relation-Objekts mit einem weiteren Relation-Objekt in other_rel

Parameter

other_rel : _duckdb.DuckDBPyRelation

Die Relation, mit der die aktuelle Relation geschnitten wird (Mengenschnitt).

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.intersect(other_rel=rel.set_alias("other_rel"))

Ergebnis

The relation query is executed once with `rel` and once with `other_rel`,
therefore generating different ids and timestamps:
┌──────┬─────────────┬───────┬──────────────────────────┐
│  id  │ description │ value │    created_timestamp     │
│ uuid │   varchar   │ int64 │ timestamp with time zone │
├──────┴─────────────┴───────┴──────────────────────────┤
│                        0 rows                         │
└───────────────────────────────────────────────────────┘

`join`

Signatur

join(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation, condition: object, how: str = 'inner') -> _duckdb.DuckDBPyRelation

Beschreibung

Führt einen Join des Relation-Objekts mit einem weiteren Relation-Objekt in other_rel anhand des Join-Bedingungsausdrucks in join_condition durch. Unterstützte Typen sind ‘inner’, ‘left’, ‘right’, ‘outer’, ‘semi’ und ‘anti’

Je nachdem, wie der Parameter condition angegeben wird, lautet die erzeugte JOIN-Klausel:

USING

import duckdb

duckdb_conn = duckdb.connect()

rel1 = duckdb_conn.sql("select range as id, concat('dummy 1', range) as text from range(1,10)")
rel2 = duckdb_conn.sql("select range as id, concat('dummy 2', range) as text from range(5,7)")

rel1.join(rel2, condition="id", how="inner").sql_query()

mit folgendem SQL:

SELECT *
FROM (
        SELECT "range" AS id,
            concat('dummy 1', "range") AS "text"
        FROM "range"(1, 10)
    ) AS unnamed_relation_41bc15e744037078
INNER JOIN (
        SELECT "range" AS id,
        concat('dummy 2', "range") AS "text"
        FROM "range"(5, 7)
    ) AS unnamed_relation_307e245965aa2c2b
USING (id)

ON

import duckdb

duckdb_conn = duckdb.connect()

rel1 = duckdb_conn.sql("select range as id, concat('dummy 1', range) as text from range(1,10)")
rel2 = duckdb_conn.sql("select range as id, concat('dummy 2', range) as text from range(5,7)")

rel1.join(rel2, condition=f"{rel1.alias}.id = {rel2.alias}.id", how="inner").sql_query()

mit dem folgenden SQL:

SELECT *
FROM (
        SELECT "range" AS id,
            concat('dummy 1', "range") AS "text"
        FROM "range"(1, 10)
    ) AS unnamed_relation_41bc15e744037078
INNER JOIN (
        SELECT "range" AS id,
        concat('dummy 2', "range") AS "text"
        FROM "range"(5, 7)
    ) AS unnamed_relation_307e245965aa2c2b
ON ((unnamed_relation_41bc15e744037078.id = unnamed_relation_307e245965aa2c2b.id))

NATURAL-, POSITIONAL- und ASOF-Joins werden von der relationalen API nicht bereitgestellt. CROSS-Joins sind über die cross-Methode verfügbar.

Parameter

other_rel : _duckdb.DuckDBPyRelation

Die Relation, mit der die aktuelle Relation gejoint wird.
condition : object

Die Join-Bedingung, typischerweise ein SQL-Ausdruck oder der doppelte Spaltenname, über den gejoint wird.
how : str, default: ‘inner’

Die Art des Joins: ‘inner’, ‘left’, ‘right’, ‘outer’, ‘semi’ und ‘anti’.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel = rel.set_alias("rel").join(
    other_rel=rel.set_alias("other_rel"),
    condition="rel.id = other_rel.id",
    how="left"
)

rel.count("*")

Ergebnis

┌──────────────┐
│ count_star() │
│    int64     │
├──────────────┤
│            9 │
└──────────────┘

`limit`

Signatur

limit(self: _duckdb.DuckDBPyRelation, n: typing.SupportsInt, offset: typing.SupportsInt = 0) -> _duckdb.DuckDBPyRelation

Beschreibung

Holt nur die ersten n Zeilen aus diesem Relation-Objekt, beginnend bei offset

Parameter

n : int

Die maximale Anzahl zurückzugebender Zeilen.
offset : int, default: 0

Die Anzahl der Zeilen, die übersprungen werden, bevor Zeilen zurückgegeben werden.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.limit(1)

Ergebnis

┌──────────────────────────────────────┬─────────────────┬───────┬────────────────────────────┐
│                  id                  │   description   │ value │     created_timestamp      │
│                 uuid                 │     varchar     │ int64 │  timestamp with time zone  │
├──────────────────────────────────────┼─────────────────┼───────┼────────────────────────────┤
│ 4135597b-29e7-4cb9-a443-41f3d54f25df │ value is uneven │     1 │ 2025-04-10 10:52:03.678+02 │
└──────────────────────────────────────┴─────────────────┴───────┴────────────────────────────┘

`map`

Signatur

map(self: _duckdb.DuckDBPyRelation, map_function: collections.abc.Callable, *, schema: typing.Optional[object] = None) -> _duckdb.DuckDBPyRelation

Beschreibung

Ruft die übergebene Funktion auf der Relation auf

Parameter

map_function : Callable

Eine Python-Funktion, die ein DataFrame entgegennimmt und ein transformiertes DataFrame zurückgibt.
schema : object, default: None

Optionales Schema, das die Struktur der Ausgabe-Relation beschreibt.

Beispiel

import duckdb
from pandas import DataFrame

def multiply_by_2(df: DataFrame):
    df["id"] = df["id"] * 2
    return df

duckdb_conn = duckdb.connect()
rel = duckdb_conn.sql("select range as id, 'dummy' as text from range(1,3)")

rel.map(multiply_by_2, schema={"id": int, "text": str})

Ergebnis

┌───────┬─────────┐
│  id   │  text   │
│ int64 │ varchar │
├───────┼─────────┤
│     2 │ dummy   │
│     4 │ dummy   │
└───────┴─────────┘

`order`

Signatur

order(self: _duckdb.DuckDBPyRelation, order_expr: str) -> _duckdb.DuckDBPyRelation

Beschreibung

Ordnet das Relation-Objekt nach order_expr neu

Parameter

order_expr : str

SQL-Ausdruck, der die Sortierung der Ergebniszeilen festlegt.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.order("value desc").limit(1, offset=4)

Ergebnis

┌──────────────────────────────────────┬─────────────────┬───────┬────────────────────────────┐
│                  id                  │   description   │ value │     created_timestamp      │
│                 uuid                 │     varchar     │ int64 │  timestamp with time zone  │
├──────────────────────────────────────┼─────────────────┼───────┼────────────────────────────┤
│ 55899131-e3d3-463c-a215-f65cb8aef3bf │ value is uneven │     5 │ 2025-04-10 10:56:03.678+02 │
└──────────────────────────────────────┴─────────────────┴───────┴────────────────────────────┘

`project`

Signatur

project(self: _duckdb.DuckDBPyRelation, *args, groups: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Projiziert das Relation-Objekt mit der Projektion in project_expr

Aliase: select

Parameter

groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.project("description").limit(1)

Ergebnis

┌─────────────────┐
│   description   │
│     varchar     │
├─────────────────┤
│ value is uneven │
└─────────────────┘

`select`

Signatur

select(self: _duckdb.DuckDBPyRelation, *args, groups: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Projiziert das Relation-Objekt mit der Projektion in project_expr

Aliase: project

Parameter

groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.select("description").limit(1)

Ergebnis

┌─────────────────┐
│   description   │
│     varchar     │
├─────────────────┤
│ value is uneven │
└─────────────────┘

`sort`

Signatur

sort(self: _duckdb.DuckDBPyRelation, *args) -> _duckdb.DuckDBPyRelation

Beschreibung

Ordnet das Relation-Objekt nach den angegebenen Ausdrücken neu

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.sort("description")

Ergebnis

┌──────────────────────────────────────┬─────────────────┬───────┬────────────────────────────┐
│                  id                  │   description   │ value │     created_timestamp      │
│                 uuid                 │     varchar     │ int64 │  timestamp with time zone  │
├──────────────────────────────────────┼─────────────────┼───────┼────────────────────────────┤
│ 5e0dfa8c-de4d-4ccd-8cff-450dabb86bde │ value is even   │     6 │ 2025-04-10 16:52:15.605+02 │
│ 95f1ad48-facf-4a84-a971-0a4fecce68c7 │ value is even   │     2 │ 2025-04-10 16:48:15.605+02 │
...

`union`

Signatur

union(self: _duckdb.DuckDBPyRelation, union_rel: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation

Beschreibung

Erzeugt die Mengenvereinigung dieses Relation-Objekts mit einem weiteren Relation-Objekt in other_rel

Die Vereinigung ist union all. Für eindeutige Werte wenden Sie distinct an.

Parameter

union_rel : _duckdb.DuckDBPyRelation

Die Relation, die mit der aktuellen Relation vereinigt wird (Mengenvereinigung).

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel = rel.union(union_rel=rel)

rel.count("*")

Ergebnis

┌──────────────┐
│ count_star() │
│    int64     │
├──────────────┤
│           18 │
└──────────────┘

`update`

Signatur

update(self: _duckdb.DuckDBPyRelation, set: object, *, condition: object = None) -> None

Beschreibung

Aktualisiert die gegebene Relation mit den angegebenen Ausdrücken

Parameter

set : object

Zuordnung von Spalten zu neuen Werten für die Update-Operation.
condition : object, default: None

Optionale Bedingung, um festzulegen, welche Zeilen aktualisiert werden.

Beispiel

import duckdb

from duckdb import ColumnExpression

duckdb_conn = duckdb.connect()

duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
).to_table("code_example")

rel = duckdb_conn.table("code_example")

rel.update(set={"description":None}, condition=ColumnExpression("value") == 1)

# the update is executed on the table, but not reflected on the relationship
# the relationship has to be recreated to retrieve the modified data
rel = duckdb_conn.table("code_example")

rel.show()

Ergebnis

┌──────────────────────────────────────┬─────────────────┬───────┬────────────────────────────┐
│                  id                  │   description   │ value │     created_timestamp      │
│                 uuid                 │     varchar     │ int64 │  timestamp with time zone  │
├──────────────────────────────────────┼─────────────────┼───────┼────────────────────────────┤
│ 66dcaa14-f4a6-4a55-af3b-7f6aa23ab4ad │ NULL            │     1 │ 2025-04-10 16:54:49.317+02 │
│ c6a18a42-67fb-4c95-827b-c966f2f95b88 │ value is even   │     2 │ 2025-04-10 16:55:49.317+02 │
...

Functions

Dieser Abschnitt enthält die Funktionen, die auf eine Relation angewendet werden können, um ein (skalares) Ergebnis zu erhalten. Die Funktionen werden verzögert ausgewertet.

Name	Beschreibung
`any_value`	Gibt den ersten Nicht-NULL-Wert eines gegebenen Ausdrucks zurück
`arg_max`	Findet die Zeile mit dem Maximalwert einer Wertspalte und gibt den Wert dieser Zeile für eine Argumentspalte zurück
`arg_min`	Findet die Zeile mit dem Minimalwert einer Wertspalte und gibt den Wert dieser Zeile für eine Argumentspalte zurück
`avg`	Berechnet den Durchschnitt eines gegebenen Ausdrucks
`bit_and`	Berechnet das bitweise UND aller Bits in einem gegebenen Ausdruck
`bit_or`	Berechnet das bitweise ODER aller Bits in einem gegebenen Ausdruck
`bit_xor`	Berechnet das bitweise XOR aller Bits in einem gegebenen Ausdruck
`bitstring_agg`	Berechnet einen Bitstring mit gesetzten Bits für jeden eindeutigen Wert in einem gegebenen Ausdruck
`bool_and`	Berechnet das logische UND aller Werte in einem gegebenen Ausdruck
`bool_or`	Berechnet das logische ODER aller Werte in einem gegebenen Ausdruck
`count`	Berechnet die Anzahl der Elemente in einem gegebenen Ausdruck
`cume_dist`	Berechnet die kumulative Verteilung innerhalb der Partition
`dense_rank`	Berechnet den dichten Rang innerhalb der Partition
`distinct`	Holt eindeutige Zeilen aus diesem Relation-Objekt
`favg`	Berechnet den Durchschnitt aller Werte in einem gegebenen Ausdruck mit einer genaueren Gleitkomma-Summation (Kahan-Summe)
`first`	Gibt den ersten Wert eines gegebenen Ausdrucks zurück
`first_value`	Berechnet den ersten Wert innerhalb der Gruppe oder Partition
`fsum`	Berechnet die Summe aller Werte in einem gegebenen Ausdruck mit einer genaueren Gleitkomma-Summation (Kahan-Summe)
`geomean`	Berechnet das geometrische Mittel über alle Werte in einem gegebenen Ausdruck
`histogram`	Berechnet das Histogramm über alle Werte in einem gegebenen Ausdruck
`lag`	Berechnet den Lag innerhalb der Partition
`last`	Gibt den letzten Wert eines gegebenen Ausdrucks zurück
`last_value`	Berechnet den letzten Wert innerhalb der Gruppe oder Partition
`lead`	Berechnet den Lead innerhalb der Partition
`list`	Gibt eine Liste aller Werte in einem gegebenen Ausdruck zurück
`max`	Gibt den Maximalwert in einem gegebenen Ausdruck zurück
`mean`	Berechnet den Durchschnitt eines gegebenen Ausdrucks
`median`	Berechnet den Median über alle Werte in einem gegebenen Ausdruck
`min`	Gibt den Minimalwert in einem gegebenen Ausdruck zurück
`mode`	Berechnet den Modus über alle Werte in einem gegebenen Ausdruck
`n_tile`	Teilt die Partition möglichst gleichmäßig in num_buckets auf
`nth_value`	Berechnet den n-ten Wert innerhalb der Partition
`percent_rank`	Berechnet den relativen Rang innerhalb der Partition
`product`	Gibt das Produkt aller Werte in einem gegebenen Ausdruck zurück
`quantile`	Berechnet den exakten Quantilwert für einen gegebenen Ausdruck
`quantile_cont`	Berechnet den interpolierten Quantilwert für einen gegebenen Ausdruck
`quantile_disc`	Berechnet den exakten Quantilwert für einen gegebenen Ausdruck
`rank`	Berechnet den Rang innerhalb der Partition
`rank_dense`	Berechnet den dichten Rang innerhalb der Partition
`row_number`	Berechnet die Zeilennummer innerhalb der Partition
`select_dtypes`	Wählt Spalten aus der Relation aus, indem nach Typ(en) gefiltert wird
`select_types`	Wählt Spalten aus der Relation aus, indem nach Typ(en) gefiltert wird
`std`	Berechnet die Stichprobenstandardabweichung für einen gegebenen Ausdruck
`stddev`	Berechnet die Stichprobenstandardabweichung für einen gegebenen Ausdruck
`stddev_pop`	Berechnet die Populationsstandardabweichung für einen gegebenen Ausdruck
`stddev_samp`	Berechnet die Stichprobenstandardabweichung für einen gegebenen Ausdruck
`string_agg`	Verkettet die Werte in einem gegebenen Ausdruck mit einem Trennzeichen
`sum`	Berechnet die Summe aller Werte in einem gegebenen Ausdruck
`unique`	Gibt die eindeutigen Werte einer Spalte zurück.
`value_counts`	Berechnet die Anzahl der Elemente in einem gegebenen Ausdruck und projiziert zusätzlich den ursprünglichen Ausdruck
`var`	Berechnet die Stichprobenvarianz für einen gegebenen Ausdruck
`var_pop`	Berechnet die Populationsvarianz für einen gegebenen Ausdruck
`var_samp`	Berechnet die Stichprobenvarianz für einen gegebenen Ausdruck
`variance`	Berechnet die Stichprobenvarianz für einen gegebenen Ausdruck

`any_value`

Signatur

any_value(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Gibt den ersten Nicht-NULL-Wert eines gegebenen Ausdrucks zurück

Parameter

column : str

Der Spaltenname, aus dem ein beliebiger Wert geholt wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...).
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.any_value('id')

Ergebnis

┌──────────────────────────────────────┐
│            any_value(id)             │
│                 uuid                 │
├──────────────────────────────────────┤
│ 642ea3d7-793d-4867-a759-91c1226c25a0 │
└──────────────────────────────────────┘

`arg_max`

Signatur

arg_max(self: _duckdb.DuckDBPyRelation, arg_column: str, value_column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Findet die Zeile mit dem Maximalwert einer Wertspalte und gibt den Wert dieser Zeile für eine Argumentspalte zurück

Parameter

arg_column : str

Der Spaltenname, für den das Argument mit dem Maximalwert gesucht wird.
value_column : str

Der Spaltenname mit den Werten zur Bestimmung des Maximums.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...).
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.arg_max(arg_column="value", value_column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬───────────────────────────┐
│   description   │ arg_max("value", "value") │
│     varchar     │           int64           │
├─────────────────┼───────────────────────────┤
│ value is uneven │                         9 │
│ value is even   │                         8 │
└─────────────────┴───────────────────────────┘

`arg_min`

Signatur

arg_min(self: _duckdb.DuckDBPyRelation, arg_column: str, value_column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Findet die Zeile mit dem Minimalwert einer Wertspalte und gibt den Wert dieser Zeile für eine Argumentspalte zurück

Parameter

arg_column : str

Der Spaltenname, für den das Argument mit dem Minimalwert gesucht wird.
value_column : str

Der Spaltenname mit den Werten zur Bestimmung des Minimums.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.arg_min(arg_column="value", value_column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬───────────────────────────┐
│   description   │ arg_min("value", "value") │
│     varchar     │           int64           │
├─────────────────┼───────────────────────────┤
│ value is even   │                         2 │
│ value is uneven │                         1 │
└─────────────────┴───────────────────────────┘

`avg`

Signatur

avg(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den Durchschnitt eines gegebenen Ausdrucks

Parameter

column : str

Der Spaltenname, für den der Durchschnitt berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.avg('value')

Ergebnis

┌──────────────┐
│ avg("value") │
│    double    │
├──────────────┤
│          5.0 │
└──────────────┘

`bit_and`

Signatur

bit_and(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet das bitweise UND aller Bits in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname für die bitweise-UND-Aggregation.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel = rel.select("description, value::bit as value_bit")

rel.bit_and(column="value_bit", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────────────────────────────────────────────────────┐
│   description   │                        bit_and(value_bit)                        │
│     varchar     │                               bit                                │
├─────────────────┼──────────────────────────────────────────────────────────────────┤
│ value is uneven │ 0000000000000000000000000000000000000000000000000000000000000001 │
│ value is even   │ 0000000000000000000000000000000000000000000000000000000000000000 │
└─────────────────┴──────────────────────────────────────────────────────────────────┘

`bit_or`

Signatur

bit_or(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet das bitweise ODER aller Bits in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname für die bitweise-ODER-Aggregation.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel = rel.select("description, value::bit as value_bit")

rel.bit_or(column="value_bit", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────────────────────────────────────────────────────┐
│   description   │                        bit_or(value_bit)                         │
│     varchar     │                               bit                                │
├─────────────────┼──────────────────────────────────────────────────────────────────┤
│ value is uneven │ 0000000000000000000000000000000000000000000000000000000000001111 │
│ value is even   │ 0000000000000000000000000000000000000000000000000000000000001110 │
└─────────────────┴──────────────────────────────────────────────────────────────────┘

`bit_xor`

Signatur

bit_xor(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet das bitweise XOR aller Bits in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname für die bitweise-XOR-Aggregation.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel = rel.select("description, value::bit as value_bit")

rel.bit_xor(column="value_bit", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────────────────────────────────────────────────────┐
│   description   │                        bit_xor(value_bit)                        │
│     varchar     │                               bit                                │
├─────────────────┼──────────────────────────────────────────────────────────────────┤
│ value is even   │ 0000000000000000000000000000000000000000000000000000000000001000 │
│ value is uneven │ 0000000000000000000000000000000000000000000000000000000000001001 │
└─────────────────┴──────────────────────────────────────────────────────────────────┘

`bitstring_agg`

Signatur

bitstring_agg(self: _duckdb.DuckDBPyRelation, expression: str, min: typing.Optional[object] = None, max: typing.Optional[object] = None, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet einen Bitstring mit gesetzten Bits für jeden eindeutigen Wert in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, der als Bitstring aggregiert wird.
min : object, default: None

Optionaler minimaler Bitstring-Wert für die Aggregation.
max : object, default: None

Optionaler maximaler Bitstring-Wert für die Aggregation.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.bitstring_agg(column="value", groups="description", projected_columns="description", min=1, max=9)

Ergebnis

┌─────────────────┬────────────────────────┐
│   description   │ bitstring_agg("value") │
│     varchar     │          bit           │
├─────────────────┼────────────────────────┤
│ value is uneven │ 101010101              │
│ value is even   │ 010101010              │
└─────────────────┴────────────────────────┘

`bool_and`

Signatur

bool_and(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet das logische UND aller Werte in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname für die boolesche-UND-Aggregation.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel = rel.select("description, mod(value,2)::boolean as uneven")

rel.bool_and(column="uneven", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────┐
│   description   │ bool_and(uneven) │
│     varchar     │     boolean      │
├─────────────────┼──────────────────┤
│ value is even   │ false            │
│ value is uneven │ true             │
└─────────────────┴──────────────────┘

`bool_or`

Signatur

bool_or(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet das logische ODER aller Werte in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname für die boolesche-ODER-Aggregation.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel = rel.select("description, mod(value,2)::boolean as uneven")

rel.bool_or(column="uneven", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬─────────────────┐
│   description   │ bool_or(uneven) │
│     varchar     │     boolean     │
├─────────────────┼─────────────────┤
│ value is even   │ false           │
│ value is uneven │ true            │
└─────────────────┴─────────────────┘

`count`

Signatur

count(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Anzahl der Elemente in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname für die Zählung.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.count("id")

Ergebnis

┌───────────┐
│ count(id) │
│   int64   │
├───────────┤
│         9 │
└───────────┘

`cume_dist`

Signatur

cume_dist(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die kumulative Verteilung innerhalb der Partition

Parameter

window_spec : str

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.cume_dist(window_spec="over (partition by description order by value)", projected_columns="description, value")

Ergebnis

┌─────────────────┬───────┬──────────────────────────────────────────────────────────────┐
│   description   │ value │ cume_dist() OVER (PARTITION BY description ORDER BY "value") │
│     varchar     │ int64 │                            double                            │
├─────────────────┼───────┼──────────────────────────────────────────────────────────────┤
│ value is uneven │     1 │                                                          0.2 │
│ value is uneven │     3 │                                                          0.4 │
│ value is uneven │     5 │                                                          0.6 │
│ value is uneven │     7 │                                                          0.8 │
│ value is uneven │     9 │                                                          1.0 │
│ value is even   │     2 │                                                         0.25 │
│ value is even   │     4 │                                                          0.5 │
│ value is even   │     6 │                                                         0.75 │
│ value is even   │     8 │                                                          1.0 │
└─────────────────┴───────┴──────────────────────────────────────────────────────────────┘

`dense_rank`

Signatur

dense_rank(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den dichten Rang innerhalb der Partition

Aliase: rank_dense

Parameter

window_spec : str

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

 rel.dense_rank(window_spec="over (partition by description order by value)", projected_columns="description, value")

Ergebnis

┌─────────────────┬───────┬───────────────────────────────────────────────────────────────┐
│   description   │ value │ dense_rank() OVER (PARTITION BY description ORDER BY "value") │
│     varchar     │ int64 │                             int64                             │
├─────────────────┼───────┼───────────────────────────────────────────────────────────────┤
│ value is even   │     2 │                                                             1 │
│ value is even   │     4 │                                                             2 │
│ value is even   │     6 │                                                             3 │
│ value is even   │     8 │                                                             4 │
│ value is uneven │     1 │                                                             1 │
│ value is uneven │     3 │                                                             2 │
│ value is uneven │     5 │                                                             3 │
│ value is uneven │     7 │                                                             4 │
│ value is uneven │     9 │                                                             5 │
└─────────────────┴───────┴───────────────────────────────────────────────────────────────┘

`distinct`

Signatur

distinct(self: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation

Beschreibung

Holt eindeutige Zeilen aus diesem Relation-Objekt

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("select range from range(1,4)")

rel = rel.union(union_rel=rel)

rel.distinct().order("range")

Ergebnis

┌───────┐
│ range │
│ int64 │
├───────┤
│     1 │
│     2 │
│     3 │
└───────┘

`favg`

Signatur

favg(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den Durchschnitt aller Werte in einem gegebenen Ausdruck mit einer genaueren Gleitkomma-Summation (Kahan-Summe)

Parameter

column : str

Der Spaltenname, für den der Durchschnitt berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.favg(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬───────────────┐
│   description   │ favg("value") │
│     varchar     │    double     │
├─────────────────┼───────────────┤
│ value is uneven │           5.0 │
│ value is even   │           5.0 │
└─────────────────┴───────────────┘

`first`

Signatur

first(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Gibt den ersten Wert eines gegebenen Ausdrucks zurück

Parameter

column : str

Der Spaltenname, aus dem der erste Wert geholt wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.first(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────┐
│   description   │ "first"("value") │
│     varchar     │      int64       │
├─────────────────┼──────────────────┤
│ value is even   │                2 │
│ value is uneven │                1 │
└─────────────────┴──────────────────┘

`first_value`

Signatur

first_value(self: _duckdb.DuckDBPyRelation, expression: str, window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den ersten Wert innerhalb der Gruppe oder Partition

Parameter

column : str

Der Spaltenname, aus dem der erste Wert geholt wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.first_value(column="value", window_spec="over (partition by description order by value)", projected_columns="description").distinct()

Ergebnis

┌─────────────────┬───────────────────────────────────────────────────────────────────────┐
│   description   │ first_value("value") OVER (PARTITION BY description ORDER BY "value") │
│     varchar     │                                 int64                                 │
├─────────────────┼───────────────────────────────────────────────────────────────────────┤
│ value is even   │                                                                     2 │
│ value is uneven │                                                                     1 │
└─────────────────┴───────────────────────────────────────────────────────────────────────┘

`fsum`

Signatur

fsum(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Summe aller Werte in einem gegebenen Ausdruck mit einer genaueren Gleitkomma-Summation (Kahan-Summe)

Parameter

column : str

Der Spaltenname, für den die Summe berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.fsum(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬───────────────┐
│   description   │ fsum("value") │
│     varchar     │    double     │
├─────────────────┼───────────────┤
│ value is even   │          20.0 │
│ value is uneven │          25.0 │
└─────────────────┴───────────────┘

`geomean`

Signatur

geomean(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet das geometrische Mittel über alle Werte in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, für den das geometrische Mittel berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.geomean(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬───────────────────┐
│   description   │ geomean("value")  │
│     varchar     │      double       │
├─────────────────┼───────────────────┤
│ value is uneven │ 3.936283427035351 │
│ value is even   │ 4.426727678801287 │
└─────────────────┴───────────────────┘

`histogram`

Signatur

histogram(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet das Histogramm über alle Werte in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, für den das Histogramm berechnet wird.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.histogram(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬───────────────────────────┐
│   description   │    histogram("value")     │
│     varchar     │   map(bigint, ubigint)    │
├─────────────────┼───────────────────────────┤
│ value is uneven │ {1=1, 3=1, 5=1, 7=1, 9=1} │
│ value is even   │ {2=1, 4=1, 6=1, 8=1}      │
└─────────────────┴───────────────────────────┘

`lag`

Signatur

lag(self: _duckdb.DuckDBPyRelation, expression: str, window_spec: str, offset: typing.SupportsInt = 1, default_value: str = 'NULL', ignore_nulls: bool = False, projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den Lag innerhalb der Partition

Parameter

column : str

Der Spaltenname, auf den die Lag-Funktion angewendet wird.
window_spec : str

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
offset : int, default: 1

Die Anzahl der Zeilen, um die zurückgegriffen wird.
default_value : str, default: ‘NULL’

Der Standardwert, wenn der Lag-Offset außerhalb des gültigen Bereichs liegt.
ignore_nulls : bool, default: False

Ob NULL-Werte bei der Berechnung des Lag ignoriert werden.
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.lag(column="description", window_spec="over (order by value)", projected_columns="description, value")

Ergebnis

┌─────────────────┬───────┬───────────────────────────────────────────────────┐
│   description   │ value │ lag(description, 1, NULL) OVER (ORDER BY "value") │
│     varchar     │ int64 │                      varchar                      │
├─────────────────┼───────┼───────────────────────────────────────────────────┤
│ value is uneven │     1 │ NULL                                              │
│ value is even   │     2 │ value is uneven                                   │
│ value is uneven │     3 │ value is even                                     │
│ value is even   │     4 │ value is uneven                                   │
│ value is uneven │     5 │ value is even                                     │
│ value is even   │     6 │ value is uneven                                   │
│ value is uneven │     7 │ value is even                                     │
│ value is even   │     8 │ value is uneven                                   │
│ value is uneven │     9 │ value is even                                     │
└─────────────────┴───────┴───────────────────────────────────────────────────┘

`last`

Signatur

last(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Gibt den letzten Wert eines gegebenen Ausdrucks zurück

Parameter

column : str

Der Spaltenname, aus dem der letzte Wert geholt wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.last(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬─────────────────┐
│   description   │ "last"("value") │
│     varchar     │      int64      │
├─────────────────┼─────────────────┤
│ value is even   │               8 │
│ value is uneven │               9 │
└─────────────────┴─────────────────┘

`last_value`

Signatur

last_value(self: _duckdb.DuckDBPyRelation, expression: str, window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den letzten Wert innerhalb der Gruppe oder Partition

Parameter

column : str

Der Spaltenname, aus dem der letzte Wert innerhalb des Fensters geholt wird.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.last_value(column="value", window_spec="over (order by description)", projected_columns="description").distinct()

Ergebnis

┌─────────────────┬─────────────────────────────────────────────────┐
│   description   │ last_value("value") OVER (ORDER BY description) │
│     varchar     │                      int64                      │
├─────────────────┼─────────────────────────────────────────────────┤
│ value is uneven │                                               9 │
│ value is even   │                                               8 │
└─────────────────┴─────────────────────────────────────────────────┘

`lead`

Signatur

lead(self: _duckdb.DuckDBPyRelation, expression: str, window_spec: str, offset: typing.SupportsInt = 1, default_value: str = 'NULL', ignore_nulls: bool = False, projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den Lead innerhalb der Partition

Parameter

column : str

Der Spaltenname, auf den die Lead-Funktion angewendet wird.
window_spec : str

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
offset : int, default: 1

Die Anzahl der Zeilen, um die vorgegriffen wird.
default_value : str, default: ‘NULL’

Der Standardwert, wenn der Lead-Offset außerhalb des gültigen Bereichs liegt.
ignore_nulls : bool, default: False

Ob NULL-Werte bei der Berechnung des Lead ignoriert werden.
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.lead(column="description", window_spec="over (order by value)", projected_columns="description, value")

Ergebnis

┌─────────────────┬───────┬────────────────────────────────────────────────────┐
│   description   │ value │ lead(description, 1, NULL) OVER (ORDER BY "value") │
│     varchar     │ int64 │                      varchar                       │
├─────────────────┼───────┼────────────────────────────────────────────────────┤
│ value is uneven │     1 │ value is even                                      │
│ value is even   │     2 │ value is uneven                                    │
│ value is uneven │     3 │ value is even                                      │
│ value is even   │     4 │ value is uneven                                    │
│ value is uneven │     5 │ value is even                                      │
│ value is even   │     6 │ value is uneven                                    │
│ value is uneven │     7 │ value is even                                      │
│ value is even   │     8 │ value is uneven                                    │
│ value is uneven │     9 │ NULL                                               │
└─────────────────┴───────┴────────────────────────────────────────────────────┘

`list`

Signatur

list(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Gibt eine Liste aller Werte in einem gegebenen Ausdruck zurück

Parameter

column : str

Der Spaltenname, dessen Werte in eine Liste aggregiert werden.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.list(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬─────────────────┐
│   description   │  list("value")  │
│     varchar     │     int64[]     │
├─────────────────┼─────────────────┤
│ value is even   │ [2, 4, 6, 8]    │
│ value is uneven │ [1, 3, 5, 7, 9] │
└─────────────────┴─────────────────┘

`max`

Signatur

max(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Gibt den Maximalwert in einem gegebenen Ausdruck zurück

Parameter

column : str

Der Spaltenname, für den der Maximalwert berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

 rel.max(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────┐
│   description   │ max("value") │
│     varchar     │    int64     │
├─────────────────┼──────────────┤
│ value is even   │            8 │
│ value is uneven │            9 │
└─────────────────┴──────────────┘

`mean`

Signatur

mean(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den Durchschnitt eines gegebenen Ausdrucks

Parameter

column : str

Der Spaltenname, für den der Mittelwert berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.mean(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────┐
│   description   │ avg("value") │
│     varchar     │    double    │
├─────────────────┼──────────────┤
│ value is even   │          5.0 │
│ value is uneven │          5.0 │
└─────────────────┴──────────────┘

`median`

Signatur

median(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den Median über alle Werte in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, für den der Median berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.median(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬─────────────────┐
│   description   │ median("value") │
│     varchar     │     double      │
├─────────────────┼─────────────────┤
│ value is even   │             5.0 │
│ value is uneven │             5.0 │
└─────────────────┴─────────────────┘

`min`

Signatur

min(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Gibt den Minimalwert in einem gegebenen Ausdruck zurück

Parameter

column : str

Der Spaltenname, für den der Minimalwert berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.min(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────┐
│   description   │ min("value") │
│     varchar     │    int64     │
├─────────────────┼──────────────┤
│ value is uneven │            1 │
│ value is even   │            2 │
└─────────────────┴──────────────┘

`mode`

Signatur

mode(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den Modus über alle Werte in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, für den der Modus (häufigster Wert) berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.mode(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬─────────────────┐
│   description   │ "mode"("value") │
│     varchar     │      int64      │
├─────────────────┼─────────────────┤
│ value is uneven │               1 │
│ value is even   │               2 │
└─────────────────┴─────────────────┘

`n_tile`

Signatur

n_tile(self: _duckdb.DuckDBPyRelation, window_spec: str, num_buckets: typing.SupportsInt, projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Teilt die Partition möglichst gleichmäßig in num_buckets auf

Parameter

window_spec : str

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
num_buckets : int

Die Anzahl der Buckets, in die die Zeilen aufgeteilt werden.
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.n_tile(window_spec="over (partition by description)", num_buckets=2, projected_columns="description, value")

Ergebnis

┌─────────────────┬───────┬──────────────────────────────────────────┐
│   description   │ value │ ntile(2) OVER (PARTITION BY description) │
│     varchar     │ int64 │                  int64                   │
├─────────────────┼───────┼──────────────────────────────────────────┤
│ value is uneven │     1 │                                        1 │
│ value is uneven │     3 │                                        1 │
│ value is uneven │     5 │                                        1 │
│ value is uneven │     7 │                                        2 │
│ value is uneven │     9 │                                        2 │
│ value is even   │     2 │                                        1 │
│ value is even   │     4 │                                        1 │
│ value is even   │     6 │                                        2 │
│ value is even   │     8 │                                        2 │
└─────────────────┴───────┴──────────────────────────────────────────┘

`nth_value`

Signatur

nth_value(self: _duckdb.DuckDBPyRelation, expression: str, window_spec: str, offset: typing.SupportsInt, ignore_nulls: bool = False, projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den n-ten Wert innerhalb der Partition

Parameter

column : str

Der Spaltenname, aus dem der n-te Wert innerhalb des Fensters geholt wird.
window_spec : str

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
offset : int

Die Position des zu holenden Werts innerhalb des Fensters (1-basierter Index).
ignore_nulls : bool, default: False

Ob NULL-Werte bei der Berechnung des n-ten Werts ignoriert werden.
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.nth_value(column="value", window_spec="over (partition by description)", projected_columns="description", offset=1)

Ergebnis

┌─────────────────┬───────────────────────────────────────────────────────┐
│   description   │ nth_value("value", 1) OVER (PARTITION BY description) │
│     varchar     │                         int64                         │
├─────────────────┼───────────────────────────────────────────────────────┤
│ value is even   │                                                     2 │
│ value is even   │                                                     2 │
│ value is even   │                                                     2 │
│ value is even   │                                                     2 │
│ value is uneven │                                                     1 │
│ value is uneven │                                                     1 │
│ value is uneven │                                                     1 │
│ value is uneven │                                                     1 │
│ value is uneven │                                                     1 │
└─────────────────┴───────────────────────────────────────────────────────┘

`percent_rank`

Signatur

percent_rank(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den relativen Rang innerhalb der Partition

Parameter

window_spec : str

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.percent_rank(window_spec="over (partition by description order by value)", projected_columns="description, value")

Ergebnis

┌─────────────────┬───────┬─────────────────────────────────────────────────────────────────┐
│   description   │ value │ percent_rank() OVER (PARTITION BY description ORDER BY "value") │
│     varchar     │ int64 │                             double                              │
├─────────────────┼───────┼─────────────────────────────────────────────────────────────────┤
│ value is even   │     2 │                                                             0.0 │
│ value is even   │     4 │                                              0.3333333333333333 │
│ value is even   │     6 │                                              0.6666666666666666 │
│ value is even   │     8 │                                                             1.0 │
│ value is uneven │     1 │                                                             0.0 │
│ value is uneven │     3 │                                                            0.25 │
│ value is uneven │     5 │                                                             0.5 │
│ value is uneven │     7 │                                                            0.75 │
│ value is uneven │     9 │                                                             1.0 │
└─────────────────┴───────┴─────────────────────────────────────────────────────────────────┘

`product`

Signatur

product(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Gibt das Produkt aller Werte in einem gegebenen Ausdruck zurück

Parameter

column : str

Der Spaltenname, für den das Produkt berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.product(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────┐
│   description   │ product("value") │
│     varchar     │      double      │
├─────────────────┼──────────────────┤
│ value is uneven │            945.0 │
│ value is even   │            384.0 │
└─────────────────┴──────────────────┘

`quantile`

Signatur

quantile(self: _duckdb.DuckDBPyRelation, expression: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den exakten Quantilwert für einen gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, für den das Quantil berechnet wird.
q : object, default: 0.5

Der zu berechnende Quantilwert (z. B. 0.5 für den Median).
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.quantile(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────────────────────┐
│   description   │ quantile_disc("value", 0.500000) │
│     varchar     │              int64               │
├─────────────────┼──────────────────────────────────┤
│ value is uneven │                                5 │
│ value is even   │                                4 │
└─────────────────┴──────────────────────────────────┘

`quantile_cont`

Signatur

quantile_cont(self: _duckdb.DuckDBPyRelation, expression: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den interpolierten Quantilwert für einen gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, für den das stetige Quantil berechnet wird.
q : object, default: 0.5

Der zu berechnende Quantilwert (z. B. 0.5 für den Median).
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.quantile_cont(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────────────────────┐
│   description   │ quantile_cont("value", 0.500000) │
│     varchar     │              double              │
├─────────────────┼──────────────────────────────────┤
│ value is even   │                              5.0 │
│ value is uneven │                              5.0 │
└─────────────────┴──────────────────────────────────┘

`quantile_disc`

Signatur

quantile_disc(self: _duckdb.DuckDBPyRelation, expression: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den exakten Quantilwert für einen gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, für den das diskrete Quantil berechnet wird.
q : object, default: 0.5

Der zu berechnende Quantilwert (z. B. 0.5 für den Median).
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.quantile_disc(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────────────────────┐
│   description   │ quantile_disc("value", 0.500000) │
│     varchar     │              int64               │
├─────────────────┼──────────────────────────────────┤
│ value is even   │                                4 │
│ value is uneven │                                5 │
└─────────────────┴──────────────────────────────────┘

`rank`

Signatur

rank(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den Rang innerhalb der Partition

Parameter

window_spec : str

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.rank(window_spec="over (partition by description order by value)", projected_columns="description, value")

Ergebnis

┌─────────────────┬───────┬─────────────────────────────────────────────────────────┐
│   description   │ value │ rank() OVER (PARTITION BY description ORDER BY "value") │
│     varchar     │ int64 │                          int64                          │
├─────────────────┼───────┼─────────────────────────────────────────────────────────┤
│ value is uneven │     1 │                                                       1 │
│ value is uneven │     3 │                                                       2 │
│ value is uneven │     5 │                                                       3 │
│ value is uneven │     7 │                                                       4 │
│ value is uneven │     9 │                                                       5 │
│ value is even   │     2 │                                                       1 │
│ value is even   │     4 │                                                       2 │
│ value is even   │     6 │                                                       3 │
│ value is even   │     8 │                                                       4 │
└─────────────────┴───────┴─────────────────────────────────────────────────────────┘

`rank_dense`

Signatur

rank_dense(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet den dichten Rang innerhalb der Partition

Aliase: dense_rank

Parameter

window_spec : str

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

 rel.rank_dense(window_spec="over (partition by description order by value)", projected_columns="description, value")

Ergebnis

┌─────────────────┬───────┬───────────────────────────────────────────────────────────────┐
│   description   │ value │ dense_rank() OVER (PARTITION BY description ORDER BY "value") │
│     varchar     │ int64 │                             int64                             │
├─────────────────┼───────┼───────────────────────────────────────────────────────────────┤
│ value is uneven │     1 │                                                             1 │
│ value is uneven │     3 │                                                             2 │
│ value is uneven │     5 │                                                             3 │
│ value is uneven │     7 │                                                             4 │
│ value is uneven │     9 │                                                             5 │
│ value is even   │     2 │                                                             1 │
│ value is even   │     4 │                                                             2 │
│ value is even   │     6 │                                                             3 │
│ value is even   │     8 │                                                             4 │
└─────────────────┴───────┴───────────────────────────────────────────────────────────────┘

`row_number`

Signatur

row_number(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Zeilennummer innerhalb der Partition

Parameter

window_spec : str

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.row_number(window_spec="over (partition by description order by value)", projected_columns="description, value")

Ergebnis

┌─────────────────┬───────┬───────────────────────────────────────────────────────────────┐
│   description   │ value │ row_number() OVER (PARTITION BY description ORDER BY "value") │
│     varchar     │ int64 │                             int64                             │
├─────────────────┼───────┼───────────────────────────────────────────────────────────────┤
│ value is uneven │     1 │                                                             1 │
│ value is uneven │     3 │                                                             2 │
│ value is uneven │     5 │                                                             3 │
│ value is uneven │     7 │                                                             4 │
│ value is uneven │     9 │                                                             5 │
│ value is even   │     2 │                                                             1 │
│ value is even   │     4 │                                                             2 │
│ value is even   │     6 │                                                             3 │
│ value is even   │     8 │                                                             4 │
└─────────────────┴───────┴───────────────────────────────────────────────────────────────┘

`select_dtypes`

Signatur

select_dtypes(self: _duckdb.DuckDBPyRelation, types: object) -> _duckdb.DuckDBPyRelation

Beschreibung

Wählt Spalten aus der Relation aus, indem nach Typ(en) gefiltert wird

Aliase: select_types

Parameter

types : object

Datentyp(en), nach denen Spalten ausgewählt werden. Kann ein einzelner Typ oder eine Sammlung von Typen sein.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.select_dtypes(types=[duckdb.sqltypes.VARCHAR]).distinct()

Ergebnis

┌─────────────────┐
│   description   │
│     varchar     │
├─────────────────┤
│ value is even   │
│ value is uneven │
└─────────────────┘

`select_types`

Signatur

select_types(self: _duckdb.DuckDBPyRelation, types: object) -> _duckdb.DuckDBPyRelation

Beschreibung

Wählt Spalten aus der Relation aus, indem nach Typ(en) gefiltert wird

Aliase: select_dtypes

Parameter

types : object

Datentyp(en), nach denen Spalten ausgewählt werden. Kann ein einzelner Typ oder eine Sammlung von Typen sein.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.select_types(types=[duckdb.sqltypes.VARCHAR]).distinct()

Ergebnis

┌─────────────────┐
│   description   │
│     varchar     │
├─────────────────┤
│ value is even   │
│ value is uneven │
└─────────────────┘

`std`

Signatur

std(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Stichprobenstandardabweichung für einen gegebenen Ausdruck

Aliase: stddev, stddev_samp

Parameter

column : str

Der Spaltenname, für den die Standardabweichung berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.std(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────────┐
│   description   │ stddev_samp("value") │
│     varchar     │        double        │
├─────────────────┼──────────────────────┤
│ value is uneven │   3.1622776601683795 │
│ value is even   │    2.581988897471611 │
└─────────────────┴──────────────────────┘

`stddev`

Signatur

stddev(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Stichprobenstandardabweichung für einen gegebenen Ausdruck

Aliase: std, stddev_samp

Parameter

column : str

Der Spaltenname, für den die Standardabweichung berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.stddev(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────────┐
│   description   │ stddev_samp("value") │
│     varchar     │        double        │
├─────────────────┼──────────────────────┤
│ value is even   │    2.581988897471611 │
│ value is uneven │   3.1622776601683795 │
└─────────────────┴──────────────────────┘

`stddev_pop`

Signatur

stddev_pop(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Populationsstandardabweichung für einen gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, für den die Standardabweichung berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.stddev_pop(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬─────────────────────┐
│   description   │ stddev_pop("value") │
│     varchar     │       double        │
├─────────────────┼─────────────────────┤
│ value is even   │    2.23606797749979 │
│ value is uneven │  2.8284271247461903 │
└─────────────────┴─────────────────────┘

`stddev_samp`

Signatur

stddev_samp(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Stichprobenstandardabweichung für einen gegebenen Ausdruck

Aliase: stddev, std

Parameter

column : str

Der Spaltenname, für den die Standardabweichung berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.stddev_samp(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────────┐
│   description   │ stddev_samp("value") │
│     varchar     │        double        │
├─────────────────┼──────────────────────┤
│ value is even   │    2.581988897471611 │
│ value is uneven │   3.1622776601683795 │
└─────────────────┴──────────────────────┘

`string_agg`

Signatur

string_agg(self: _duckdb.DuckDBPyRelation, expression: str, sep: str = ',', groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Verkettet die Werte in einem gegebenen Ausdruck mit einem Trennzeichen

Parameter

column : str

Der Spaltenname, aus dem Werte verkettet werden.
sep : str, default: ‘,’

Trennzeichen zwischen verketteten Werten.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.string_agg(column="value", sep=",", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────────────┐
│   description   │ string_agg("value", ',') │
│     varchar     │         varchar          │
├─────────────────┼──────────────────────────┤
│ value is even   │ 2,4,6,8                  │
│ value is uneven │ 1,3,5,7,9                │
└─────────────────┴──────────────────────────┘

`sum`

Signatur

sum(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Summe aller Werte in einem gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, für den die Summe berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.sum(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────┐
│   description   │ sum("value") │
│     varchar     │    int128    │
├─────────────────┼──────────────┤
│ value is even   │           20 │
│ value is uneven │           25 │
└─────────────────┴──────────────┘

`unique`

Signatur

unique(self: _duckdb.DuckDBPyRelation, unique_aggr: str) -> _duckdb.DuckDBPyRelation

Beschreibung

Gibt die eindeutigen Werte einer Spalte zurück.

Parameter

unique_aggr : str

Die Spalte, für die die eindeutigen Werte ermittelt werden.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.unique(unique_aggr="description")

Ergebnis

┌─────────────────┐
│   description   │
│     varchar     │
├─────────────────┤
│ value is even   │
│ value is uneven │
└─────────────────┘

`value_counts`

Signatur

value_counts(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Anzahl der Elemente in einem gegebenen Ausdruck und projiziert zusätzlich den ursprünglichen Ausdruck

Parameter

column : str

Der Spaltenname, aus dem Werte gezählt werden.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.value_counts(column="description", groups="description")

Ergebnis

┌─────────────────┬────────────────────┐
│   description   │ count(description) │
│     varchar     │       int64        │
├─────────────────┼────────────────────┤
│ value is uneven │                  5 │
│ value is even   │                  4 │
└─────────────────┴────────────────────┘

`var`

Signatur

var(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Stichprobenvarianz für einen gegebenen Ausdruck

Aliase: variance, var_samp

Parameter

column : str

Der Spaltenname, für den die Stichprobenvarianz berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.var(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬───────────────────┐
│   description   │ var_samp("value") │
│     varchar     │      double       │
├─────────────────┼───────────────────┤
│ value is even   │ 6.666666666666667 │
│ value is uneven │              10.0 │
└─────────────────┴───────────────────┘

`var_pop`

Signatur

var_pop(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Populationsvarianz für einen gegebenen Ausdruck

Parameter

column : str

Der Spaltenname, für den die Populationsvarianz berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.var_pop(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬──────────────────┐
│   description   │ var_pop("value") │
│     varchar     │      double      │
├─────────────────┼──────────────────┤
│ value is even   │              5.0 │
│ value is uneven │              8.0 │
└─────────────────┴──────────────────┘

`var_samp`

Signatur

var_samp(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Stichprobenvarianz für einen gegebenen Ausdruck

Aliase: variance, var

Parameter

column : str

Der Spaltenname, für den die Stichprobenvarianz berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.var_samp(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬───────────────────┐
│   description   │ var_samp("value") │
│     varchar     │      double       │
├─────────────────┼───────────────────┤
│ value is even   │ 6.666666666666667 │
│ value is uneven │              10.0 │
└─────────────────┴───────────────────┘

`variance`

Signatur

variance(self: _duckdb.DuckDBPyRelation, expression: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation

Beschreibung

Berechnet die Stichprobenvarianz für einen gegebenen Ausdruck

Aliase: var, var_samp

Parameter

column : str

Der Spaltenname, für den die Stichprobenvarianz berechnet wird.
groups : str, default: ‘’

Kommagetrennte Liste der in den group by aufzunehmenden Spalten.
window_spec : str, default: ‘’

Optionale Fensterspezifikation für Fensterfunktionen, angegeben als over (partition by ... order by ...)
projected_columns : str, default: ‘’

Kommagetrennte Liste der in das Ergebnis aufzunehmenden Spalten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.variance(column="value", groups="description", projected_columns="description")

Ergebnis

┌─────────────────┬───────────────────┐
│   description   │ var_samp("value") │
│     varchar     │      double       │
├─────────────────┼───────────────────┤
│ value is even   │ 6.666666666666667 │
│ value is uneven │              10.0 │
└─────────────────┴───────────────────┘

Output

Dieser Abschnitt enthält die Funktionen, die eine SQL-Ausführung auslösen und die Daten abrufen.

Name	Beschreibung
`arrow`	Alias von to_arrow_reader(). Wir empfehlen stattdessen to_arrow_reader().
`close`	Schließt das Ergebnis
`create`	Erstellt eine neue Tabelle namens table_name mit dem Inhalt des Relation-Objekts
`create_view`	Erstellt eine View namens view_name, die auf das Relation-Objekt verweist
`df`	Führt aus und holt alle Zeilen als pandas DataFrame
`execute`	Wandelt die Relation in eine Ergebnismenge um
`fetch_arrow_reader`	Führt aus und gibt einen Arrow Record Batch Reader zurück, der alle Zeilen liefert
`fetch_arrow_table`	Führt aus und holt alle Zeilen als Arrow Table
`fetch_df_chunk`	Führt aus und holt einen Chunk der Zeilen
`fetch_record_batch`	Führt aus und gibt einen Arrow Record Batch Reader zurück, der alle Zeilen liefert
`fetchall`	Führt aus und holt alle Zeilen als Liste von Tupeln
`fetchdf`	Führt aus und holt alle Zeilen als pandas DataFrame
`fetchmany`	Führt aus und holt den nächsten Satz Zeilen als Liste von Tupeln
`fetchnumpy`	Führt aus und holt alle Zeilen als Python-dict, das jede Spalte auf ein numpy-Array abbildet
`fetchone`	Führt aus und holt eine einzelne Zeile als Tupel
`pl`	Führt aus und holt alle Zeilen als Polars DataFrame
`tf`	Holt ein Ergebnis als dict von TensorFlow Tensors
`to_arrow_reader`	Führt aus und gibt einen Arrow Record Batch Reader zurück, der alle Zeilen liefert
`to_arrow_table`	Führt aus und holt alle Zeilen als Arrow Table
`to_csv`	Schreibt das Relation-Objekt in eine CSV-Datei in ‘file_name’
`to_df`	Führt aus und holt alle Zeilen als pandas DataFrame
`to_parquet`	Schreibt das Relation-Objekt in eine Parquet-Datei in ‘file_name’
`to_table`	Erstellt eine neue Tabelle namens table_name mit dem Inhalt des Relation-Objekts
`to_view`	Erstellt eine View namens view_name, die auf das Relation-Objekt verweist
`torch`	Holt ein Ergebnis als dict von PyTorch Tensors
`write_csv`	Schreibt das Relation-Objekt in eine CSV-Datei in ‘file_name’
`write_parquet`	Schreibt das Relation-Objekt in eine Parquet-Datei in ‘file_name’

`arrow`

Signatur

arrow(self: _duckdb.DuckDBPyRelation, batch_size: typing.SupportsInt = 1000000) -> pyarrow.lib.RecordBatchReader

Beschreibung

Alias von to_arrow_reader(). Wir empfehlen stattdessen to_arrow_reader().

Wir empfehlen stattdessen to_arrow_reader().

Aliase: to_arrow_reader

Parameter

batch_size : int, default: 1000000

Die Batch-Größe für das Abrufen der Daten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

pa_reader = rel.arrow(batch_size=1)

pa_reader.read_next_batch()

Ergebnis

pyarrow.RecordBatch
id: string
description: string
value: int64
created_timestamp: timestamp[us, tz=Europe/Amsterdam]
----
id: ["e4ab8cb4-4609-40cb-ad7e-4304ed5ed4bd"]
description: ["value is even"]
value: [2]
created_timestamp: [2025-04-10 09:25:51.259000Z]

`close`

Signatur

close(self: _duckdb.DuckDBPyRelation) -> None

Beschreibung

Schließt das Ergebnis

`create`

Signatur

create(self: _duckdb.DuckDBPyRelation, table_name: str) -> None

Beschreibung

Erstellt eine neue Tabelle namens table_name mit dem Inhalt des Relation-Objekts

Aliase: to_table

Parameter

table_name : str

Der Name der zu erstellenden Tabelle. Es darf keine andere Tabelle mit demselben Namen existieren.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.create("table_code_example")

duckdb_conn.table("table_code_example").limit(1)

Ergebnis

┌──────────────────────────────────────┬─────────────────┬───────┬────────────────────────────┐
│                  id                  │   description   │ value │     created_timestamp      │
│                 uuid                 │     varchar     │ int64 │  timestamp with time zone  │
├──────────────────────────────────────┼─────────────────┼───────┼────────────────────────────┤
│ 3ac9e0ba-8390-4a02-ad72-33b1caea6354 │ value is uneven │     1 │ 2025-04-10 11:07:12.614+02 │
└──────────────────────────────────────┴─────────────────┴───────┴────────────────────────────┘

`create_view`

Signatur

create_view(self: _duckdb.DuckDBPyRelation, view_name: str, replace: bool = True) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt eine View namens view_name, die auf das Relation-Objekt verweist

Aliase: to_view

Parameter

view_name : str

Der Name der zu erstellenden View.
replace : bool, default: True

Ob die View mit CREATE OR REPLACE erstellt werden soll. Bei False darf keine andere View mit demselben view_name existieren.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.create_view("view_code_example", replace=True)

duckdb_conn.table("view_code_example").limit(1)

Ergebnis

┌──────────────────────────────────────┬─────────────────┬───────┬────────────────────────────┐
│                  id                  │   description   │ value │     created_timestamp      │
│                 uuid                 │     varchar     │ int64 │  timestamp with time zone  │
├──────────────────────────────────────┼─────────────────┼───────┼────────────────────────────┤
│ 3ac9e0ba-8390-4a02-ad72-33b1caea6354 │ value is uneven │     1 │ 2025-04-10 11:07:12.614+02 │
└──────────────────────────────────────┴─────────────────┴───────┴────────────────────────────┘

`df`

Signatur

df(self: _duckdb.DuckDBPyRelation, *, date_as_object: bool = False) -> pandas.DataFrame

Beschreibung

Führt aus und holt alle Zeilen als pandas DataFrame

Aliase: fetchdf, to_df

Parameter

date_as_object : bool, default: False

Ob Datumsspalten als Python-date-Objekte interpretiert werden sollen.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.df()

Ergebnis

                                     id      description  value                created_timestamp
0  3ac9e0ba-8390-4a02-ad72-33b1caea6354  value is uneven      1 2025-04-10 11:07:12.614000+02:00
1  8b844392-1404-4bbc-b731-120f42c8ca27    value is even      2 2025-04-10 11:08:12.614000+02:00
2  ca5584ca-8e97-4fca-a295-ae3c16c32f5b  value is uneven      3 2025-04-10 11:09:12.614000+02:00
...

`execute`

Signatur

execute(self: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation

Beschreibung

Wandelt die Relation in eine Ergebnismenge um

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.execute()

Ergebnis

┌──────────────────────────────────────┬─────────────────┬───────┬────────────────────────────┐
│                  id                  │   description   │ value │     created_timestamp      │
│                 uuid                 │     varchar     │ int64 │  timestamp with time zone  │
├──────────────────────────────────────┼─────────────────┼───────┼────────────────────────────┤
│ 3ac9e0ba-8390-4a02-ad72-33b1caea6354 │ value is uneven │     1 │ 2025-04-10 11:07:12.614+02 │
│ 8b844392-1404-4bbc-b731-120f42c8ca27 │ value is even   │     2 │ 2025-04-10 11:08:12.614+02 │
│ ca5584ca-8e97-4fca-a295-ae3c16c32f5b │ value is uneven │     3 │ 2025-04-10 11:09:12.614+02 │

`fetch_arrow_reader`

Signatur

fetch_arrow_reader(self: object, batch_size: typing.SupportsInt = 1000000) -> object

Beschreibung

Führt aus und gibt einen Arrow Record Batch Reader zurück, der alle Zeilen liefert

Veraltet fetch_arrow_reader() ist veraltet. Verwenden Sie stattdessen to_arrow_reader().

Parameter

batch_size : int, default: 1000000

Die Batch-Größe für das Abrufen der Daten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

pa_reader = rel.fetch_arrow_reader(batch_size=1)

pa_reader.read_next_batch()

Ergebnis

pyarrow.RecordBatch
id: string
description: string
value: int64
created_timestamp: timestamp[us, tz=Europe/Amsterdam]
----
id: ["e4ab8cb4-4609-40cb-ad7e-4304ed5ed4bd"]
description: ["value is even"]
value: [2]
created_timestamp: [2025-04-10 09:25:51.259000Z]

`fetch_arrow_table`

Signatur

fetch_arrow_table(self: object, batch_size: typing.SupportsInt = 1000000) -> object

Beschreibung

Führt aus und holt alle Zeilen als Arrow Table

Veraltet fetch_arrow_table() ist veraltet. Verwenden Sie stattdessen to_arrow_table().

Aliase: arrow, to_arrow_table

Parameter

batch_size : int, default: 1000000

Die Batch-Größe für das Abrufen der Daten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.fetch_arrow_table()

Ergebnis

pyarrow.Table
id: string
description: string
value: int64
created_timestamp: timestamp[us, tz=Europe/Amsterdam]
----
id: [["1587b4b0-3023-49fe-82cf-06303ca136ac","e4ab8cb4-4609-40cb-ad7e-4304ed5ed4bd","3f8ad67a-290f-4a22-b41b-0173b8e45afa","9a4e37ef-d8bd-46dd-ab01-51cf4973549f","12baa624-ebc9-45ae-b73e-6f4029e31d2d","56d41292-53cc-48be-a1b8-e1f5d6ca5581","1accca18-c950-47c1-9108-aef8afbd5249","56d8db75-72c4-4d40-90d2-a3c840579c37","e19f6201-8646-401c-b019-e37c42c39632"]]
description: [["value is uneven","value is even","value is uneven","value is even","value is uneven","value is even","value is uneven","value is even","value is uneven"]]
value: [[1,2,3,4,5,6,7,8,9]]
created_timestamp: [[2025-04-10 09:24:51.259000Z,2025-04-10 09:25:51.259000Z,2025-04-10 09:26:51.259000Z,2025-04-10 09:27:51.259000Z,2025-04-10 09:28:51.259000Z,2025-04-10 09:29:51.259000Z,2025-04-10 09:30:51.259000Z,2025-04-10 09:31:51.259000Z,2025-04-10 09:32:51.259000Z]]

`fetch_df_chunk`

Signatur

fetch_df_chunk(self: _duckdb.DuckDBPyRelation, vectors_per_chunk: typing.SupportsInt = 1, *, date_as_object: bool = False) -> pandas.DataFrame

Beschreibung

Führt aus und holt einen Chunk der Zeilen

Parameter

vectors_per_chunk : int, default: 1

Anzahl der zu verarbeitenden Daten-Chunks vor der Umwandlung in ein DataFrame.
date_as_object : bool, default: False

Ob Datumsspalten als Python-date-Objekte interpretiert werden sollen.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.fetch_df_chunk()

Ergebnis

                                     id      description  value                created_timestamp
0  1587b4b0-3023-49fe-82cf-06303ca136ac  value is uneven      1 2025-04-10 11:24:51.259000+02:00
1  e4ab8cb4-4609-40cb-ad7e-4304ed5ed4bd    value is even      2 2025-04-10 11:25:51.259000+02:00
2  3f8ad67a-290f-4a22-b41b-0173b8e45afa  value is uneven      3 2025-04-10 11:26:51.259000+02:00
...

`fetch_record_batch`

Signatur

fetch_record_batch(self: object, rows_per_batch: typing.SupportsInt = 1000000) -> object

Beschreibung

Führt aus und gibt einen Arrow Record Batch Reader zurück, der alle Zeilen liefert

Veraltet fetch_record_batch() ist veraltet. Verwenden Sie stattdessen to_arrow_reader().

Aliase: record_batch

Parameter

rows_per_batch : int, default: 1000000

Die Anzahl der Zeilen pro Batch.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

pa_reader = rel.fetch_record_batch(rows_per_batch=1)

pa_reader.read_next_batch()

Ergebnis

pyarrow.RecordBatch
id: string
description: string
value: int64
created_timestamp: timestamp[us, tz=Europe/Amsterdam]
----
id: ["908cf67c-a086-4b94-9017-2089a83e4a6c"]
description: ["value is uneven"]
value: [1]
created_timestamp: [2025-04-10 09:52:55.249000Z]

`fetchall`

Signatur

fetchall(self: _duckdb.DuckDBPyRelation) -> list

Beschreibung

Führt aus und holt alle Zeilen als Liste von Tupeln

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.limit(1).fetchall()

Ergebnis

[(UUID('1587b4b0-3023-49fe-82cf-06303ca136ac'),
  'value is uneven',
  1,
  datetime.datetime(2025, 4, 10, 11, 24, 51, 259000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))]

`fetchdf`

Signatur

fetchdf(self: _duckdb.DuckDBPyRelation, *, date_as_object: bool = False) -> pandas.DataFrame

Beschreibung

Führt aus und holt alle Zeilen als pandas DataFrame

Aliase: df, to_df

Parameter

date_as_object : bool, default: False

Ob Datumsspalten als Python-date-Objekte interpretiert werden sollen.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.fetchdf()

Ergebnis

                                     id      description  value                created_timestamp
0  1587b4b0-3023-49fe-82cf-06303ca136ac  value is uneven      1 2025-04-10 11:24:51.259000+02:00
1  e4ab8cb4-4609-40cb-ad7e-4304ed5ed4bd    value is even      2 2025-04-10 11:25:51.259000+02:00
2  3f8ad67a-290f-4a22-b41b-0173b8e45afa  value is uneven      3 2025-04-10 11:26:51.259000+02:00
...

`fetchmany`

Signatur

fetchmany(self: _duckdb.DuckDBPyRelation, size: typing.SupportsInt = 1) -> list

Beschreibung

Führt aus und holt den nächsten Satz Zeilen als Liste von Tupeln

Warnung Wird während des Abrufs der Daten aus einer Aggregat-Relation eine Operation ausgeführt, wird die Ergebnismenge geschlossen.

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
      select
          gen_random_uuid() as id,
          concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
          range as value,
          now() + concat(range,' ', 'minutes')::interval as created_timestamp
      from range(1, 10)
   """
)

agg_rel = rel.aggregate("value")

while res := agg_rel.fetchmany(size=1):
   print(res)
   rel.show()

Parameter

size : int, default: 1

Die Anzahl der abzurufenden Datensätze.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

while res := rel.fetchmany(size=1):
    print(res)

Ergebnis

[(UUID('cf4c5e32-d0aa-4699-a3ee-0092e900f263'), 'value is uneven', 1, datetime.datetime(2025, 4, 30, 16, 23, 5, 310000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))]
[(UUID('cec335ac-24ac-49a3-ae9a-bb35f71fc88d'), 'value is even', 2, datetime.datetime(2025, 4, 30, 16, 24, 5, 310000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))]
[(UUID('2423295d-9bb0-453c-a385-21bdacba03b6'), 'value is uneven', 3, datetime.datetime(2025, 4, 30, 16, 25, 5, 310000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))]
[(UUID('88806b21-192d-41e7-a293-c789aad636ba'), 'value is even', 4, datetime.datetime(2025, 4, 30, 16, 26, 5, 310000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))]
[(UUID('05837a28-dacf-4121-88a6-a374aefb8a07'), 'value is uneven', 5, datetime.datetime(2025, 4, 30, 16, 27, 5, 310000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))]
[(UUID('b9c1f7e9-6156-4554-b80e-67d3b5d810bb'), 'value is even', 6, datetime.datetime(2025, 4, 30, 16, 28, 5, 310000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))]
[(UUID('4709c7fa-d286-4864-bb48-69748b447157'), 'value is uneven', 7, datetime.datetime(2025, 4, 30, 16, 29, 5, 310000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))]
[(UUID('30e48457-b103-4fa5-95cf-1c7f0143335b'), 'value is even', 8, datetime.datetime(2025, 4, 30, 16, 30, 5, 310000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))]
[(UUID('036b7f4b-bd78-4ffb-a351-964d93f267b7'), 'value is uneven', 9, datetime.datetime(2025, 4, 30, 16, 31, 5, 310000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))]

`fetchnumpy`

Signatur

fetchnumpy(self: _duckdb.DuckDBPyRelation) -> dict

Beschreibung

Führt aus und holt alle Zeilen als Python-dict, das jede Spalte auf ein numpy-Array abbildet

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.fetchnumpy()

Ergebnis

{'id': array([UUID('1587b4b0-3023-49fe-82cf-06303ca136ac'),
        UUID('e4ab8cb4-4609-40cb-ad7e-4304ed5ed4bd'),
        UUID('3f8ad67a-290f-4a22-b41b-0173b8e45afa'),
        UUID('9a4e37ef-d8bd-46dd-ab01-51cf4973549f'),
        UUID('12baa624-ebc9-45ae-b73e-6f4029e31d2d'),
        UUID('56d41292-53cc-48be-a1b8-e1f5d6ca5581'),
        UUID('1accca18-c950-47c1-9108-aef8afbd5249'),
        UUID('56d8db75-72c4-4d40-90d2-a3c840579c37'),
        UUID('e19f6201-8646-401c-b019-e37c42c39632')], dtype=object),
 'description': array(['value is uneven', 'value is even', 'value is uneven',
        'value is even', 'value is uneven', 'value is even',
        'value is uneven', 'value is even', 'value is uneven'],
       dtype=object),
 'value': array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
 'created_timestamp': array(['2025-04-10T09:24:51.259000', '2025-04-10T09:25:51.259000',
        '2025-04-10T09:26:51.259000', '2025-04-10T09:27:51.259000',
        '2025-04-10T09:28:51.259000', '2025-04-10T09:29:51.259000',
        '2025-04-10T09:30:51.259000', '2025-04-10T09:31:51.259000',
        '2025-04-10T09:32:51.259000'], dtype='datetime64[us]')}

`fetchone`

Signatur

fetchone(self: _duckdb.DuckDBPyRelation) -> typing.Optional[tuple]

Beschreibung

Führt aus und holt eine einzelne Zeile als Tupel

Warnung Wird während des Abrufs der Daten aus einer Aggregat-Relation eine Operation ausgeführt, wird die Ergebnismenge geschlossen.

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
      select
          gen_random_uuid() as id,
          concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
          range as value,
          now() + concat(range,' ', 'minutes')::interval as created_timestamp
      from range(1, 10)
   """
)

agg_rel = rel.aggregate("value")

while res := agg_rel.fetchone():
   print(res)
   rel.show()

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

while res := rel.fetchone():
    print(res)

Ergebnis

(UUID('fe036411-f4c7-4f52-9ddd-80cd2bb56613'), 'value is uneven', 1, datetime.datetime(2025, 4, 30, 12, 59, 8, 912000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))
(UUID('466c9b43-e9f0-4237-8f26-155f259a5b59'), 'value is even', 2, datetime.datetime(2025, 4, 30, 13, 0, 8, 912000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))
(UUID('5755cf16-a94f-41ef-a16d-21e856d71f9f'), 'value is uneven', 3, datetime.datetime(2025, 4, 30, 13, 1, 8, 912000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))
(UUID('05b52c93-bd68-45e1-b02a-a08d682c33d5'), 'value is even', 4, datetime.datetime(2025, 4, 30, 13, 2, 8, 912000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))
(UUID('cf61ef13-2840-4541-900d-f493767d7622'), 'value is uneven', 5, datetime.datetime(2025, 4, 30, 13, 3, 8, 912000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))
(UUID('033e7c68-e800-4ee8-9787-6cf50aabc27b'), 'value is even', 6, datetime.datetime(2025, 4, 30, 13, 4, 8, 912000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))
(UUID('8b8d6545-ff54-45d6-b69a-97edb63dfe43'), 'value is uneven', 7, datetime.datetime(2025, 4, 30, 13, 5, 8, 912000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))
(UUID('7da79dfe-b29c-462b-a414-9d5e3cc80139'), 'value is even', 8, datetime.datetime(2025, 4, 30, 13, 6, 8, 912000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))
(UUID('f83ffff2-33b9-4f86-9d14-46974b546bab'), 'value is uneven', 9, datetime.datetime(2025, 4, 30, 13, 7, 8, 912000, tzinfo=<DstTzInfo 'Europe/Amsterdam' CEST+2:00:00 DST>))

`pl`

Signatur

pl(self: _duckdb.DuckDBPyRelation, batch_size: typing.SupportsInt = 1000000, *, lazy: bool = False) -> duckdb::PolarsDataFrame

Beschreibung

Führt aus und holt alle Zeilen als Polars DataFrame

Parameter

batch_size : int, default: 1000000

Die Anzahl der pro Batch abzurufenden Datensätze.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.pl(batch_size=1)

Ergebnis

shape: (9, 4)
┌─────────────────────────────────┬─────────────────┬───────┬────────────────────────────────┐
│ id                              ┆ description     ┆ value ┆ created_timestamp              │
│ ---                             ┆ ---             ┆ ---   ┆ ---                            │
│ str                             ┆ str             ┆ i64   ┆ datetime[μs, Europe/Amsterdam] │
╞═════════════════════════════════╪═════════════════╪═══════╪════════════════════════════════╡
│ b2f92c3c-9372-49f3-897f-2c86fc… ┆ value is uneven ┆ 1     ┆ 2025-04-10 11:49:51.886 CEST   │

`tf`

Signatur

tf(self: _duckdb.DuckDBPyRelation) -> dict

Beschreibung

Holt ein Ergebnis als dict von TensorFlow Tensors

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.select("description, value").tf()

Ergebnis

{'description': <tf.Tensor: shape=(9,), dtype=string, numpy=
 array([b'value is uneven', b'value is even', b'value is uneven',
        b'value is even', b'value is uneven', b'value is even',
        b'value is uneven', b'value is even', b'value is uneven'],
       dtype=object)>,
 'value': <tf.Tensor: shape=(9,), dtype=int64, numpy=array([1, 2, 3, 4, 5, 6, 7, 8, 9])>}

`to_arrow_reader`

Signatur

to_arrow_reader(self: _duckdb.DuckDBPyRelation, batch_size: typing.SupportsInt = 1000000) -> pyarrow.lib.RecordBatchReader

Beschreibung

Führt aus und gibt einen Arrow Record Batch Reader zurück, der alle Zeilen liefert

Aliase: arrow

Parameter

batch_size : int, default: 1000000

Die Batch-Größe für das Abrufen der Daten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

pa_reader = rel.to_arrow_reader(batch_size=1)

pa_reader.read_next_batch()

Ergebnis

pyarrow.RecordBatch
id: string
description: string
value: int64
created_timestamp: timestamp[us, tz=Europe/Amsterdam]
----
id: ["e4ab8cb4-4609-40cb-ad7e-4304ed5ed4bd"]
description: ["value is even"]
value: [2]
created_timestamp: [2025-04-10 09:25:51.259000Z]

`to_arrow_table`

Signatur

to_arrow_table(self: _duckdb.DuckDBPyRelation, batch_size: typing.SupportsInt = 1000000) -> pyarrow.lib.Table

Beschreibung

Führt aus und holt alle Zeilen als Arrow Table

Aliase: fetch_arrow_table

Parameter

batch_size : int, default: 1000000

Die Batch-Größe für das Abrufen der Daten.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.to_arrow_table()

Ergebnis

pyarrow.Table
id: string
description: string
value: int64
created_timestamp: timestamp[us, tz=Europe/Amsterdam]
----
id: [["86b2011d-3818-426f-a41e-7cd5c7321f79","07fa4f89-0bba-4049-9acd-c933332a66d5","f2f1479e-f582-4fe4-b82f-9b753b69634c","529d3c63-5961-4adb-b0a8-8249188fc82a","aa9eea7d-7fac-4dcf-8f32-4a0b5d64f864","4852aa32-03f2-40d3-8006-b8213904775a","c0127203-f2e3-4925-9810-655bc02a3c19","2a1356ba-5707-44d6-a492-abd0a67e5efb","800a1c24-231c-4dae-bd68-627654c8a110"]]
description: [["value is uneven","value is even","value is uneven","value is even","value is uneven","value is even","value is uneven","value is even","value is uneven"]]
value: [[1,2,3,4,5,6,7,8,9]]
created_timestamp: [[2025-04-10 09:54:24.015000Z,2025-04-10 09:55:24.015000Z,2025-04-10 09:56:24.015000Z,2025-04-10 09:57:24.015000Z,2025-04-10 09:58:24.015000Z,2025-04-10 09:59:24.015000Z,2025-04-10 10:00:24.015000Z,2025-04-10 10:01:24.015000Z,2025-04-10 10:02:24.015000Z]]

`to_csv`

Signatur

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

Beschreibung

Schreibt das Relation-Objekt in eine CSV-Datei in ‘file_name’

Aliase: write_csv

Parameter

file_name : str

Name der Ausgabe-CSV-Datei.
sep : str, default: ‘,’

Feldtrennzeichen für die Ausgabedatei.
na_rep : str, default: ‘’

Darstellung fehlender Daten.
header : bool, default: True

Ob Spaltenüberschriften geschrieben werden.
quotechar : str, default: ‘“’

Zeichen zum Quoten von Feldern mit Sonderzeichen.
escapechar : str, default: None

Zeichen zum Escapen des Trennzeichens, wenn Quoting auf QUOTE_NONE gesetzt ist.
date_format : str, default: None

Benutzerdefinierte Formatzeichenkette für DATE-Werte.
timestamp_format : str, default: None

Benutzerdefinierte Formatzeichenkette für TIMESTAMP-Werte.
quoting : int, default: csv.QUOTE_MINIMAL

Steuert das Quoting von Feldern (z. B. QUOTE_MINIMAL, QUOTE_ALL).
encoding : str, default: ‘utf-8’

Zeichenkodierung für die Ausgabedatei.
compression : str, default: auto

Kompressionstyp (z. B. ‘gzip’, ‘bz2’, ‘zstd’).
overwrite : bool, default: False

Bei true werden alle bestehenden Dateien in den Zielverzeichnissen entfernt (nicht auf entfernten Dateisystemen unterstützt). Wirkt nur zusammen mit partition_by.
per_thread_output : bool, default: False

Bei true wird eine Datei pro Thread geschrieben statt einer einzigen Datei. Das ermöglicht schnelleres paralleles Schreiben.
use_tmp_file : bool, default: False

Zuerst in eine temporäre Datei schreiben und dann umbenennen, um partielle Schreibvorgänge zu vermeiden.
partition_by : list[str], default: None

Liste der Spaltennamen, nach denen die Ausgabe partitioniert wird (erzeugt eine Ordnerstruktur).
write_partition_columns : bool, default: False

Ob Partitionsspalten in die Dateien geschrieben werden. Wirkt nur zusammen mit partition_by.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.to_csv("code_example.csv")

Ergebnis

The data is exported to a CSV file, named code_example.csv

`to_df`

Signatur

to_df(self: _duckdb.DuckDBPyRelation, *, date_as_object: bool = False) -> pandas.DataFrame

Beschreibung

Führt aus und holt alle Zeilen als pandas DataFrame

Aliase: fetchdf, df

Parameter

date_as_object : bool, default: False

Ob Datumsspalten als Python-date-Objekte interpretiert werden sollen.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.to_df()

Ergebnis

                                     id      description  value                created_timestamp
0  e1f79925-60fd-4ee2-ae67-5eff6b0543d1  value is uneven      1 2025-04-10 11:56:04.452000+02:00
1  caa619d4-d79c-4c00-b82e-9319b086b6f8    value is even      2 2025-04-10 11:57:04.452000+02:00
2  64c68032-99b9-4e8f-b4a3-6c522d5419b3  value is uneven      3 2025-04-10 11:58:04.452000+02:00
...

`to_parquet`

Signatur

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

Beschreibung

Schreibt das Relation-Objekt in eine Parquet-Datei in ‘file_name’

Aliase: write_parquet

Parameter

file_name : str

Name der Ausgabe-Parquet-Datei.
compression : str, default: ‘snappy’

Das zu verwendende Kompressionsformat (uncompressed, snappy, gzip, zstd, brotli, lz4, lz4_raw).
field_ids : STRUCT

Die field_id für jede Spalte. Übergeben Sie auto, um eine automatische Ableitung zu versuchen.
row_group_size_bytes : int, default: row_group_size * 1024

Die Zielgröße jeder Row Group. Sie können eine lesbare Zeichenkette übergeben, z. B. 2MB, oder eine Ganzzahl, d. h. die Anzahl der Bytes. Diese Option wird nur verwendet, wenn Sie SET preserve_insertion_order = false; gesetzt haben, andernfalls wird sie ignoriert.
row_group_size : int, default: 122880

Die Zielgröße, d. h. die Anzahl der Zeilen, jeder Row Group.
overwrite : bool, default: False

Wenn True, die Datei überschreiben, falls sie existiert.
per_thread_output : bool, default: False

Bei True wird eine Datei pro Thread geschrieben statt einer einzigen Datei. Das ermöglicht schnelleres paralleles Schreiben.
use_tmp_file : bool, default: False

Zuerst in eine temporäre Datei schreiben und dann umbenennen, um partielle Schreibvorgänge zu vermeiden.
partition_by : list[str], default: None

Liste der Spaltennamen, nach denen die Ausgabe partitioniert wird (erzeugt eine Ordnerstruktur).
write_partition_columns : bool, default: False

Ob Partitionsspalten in die Dateien geschrieben werden. Wirkt nur zusammen mit partition_by.
append : bool, default: False

Bei True wird ein bereits existierendes Dateinamensmuster neu erzeugt, damit keine bestehenden Dateien überschrieben werden. Wirkt nur zusammen mit partition_by.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.to_parquet("code_example.parquet")

Ergebnis

The data is exported to a Parquet file, named code_example.parquet

`to_table`

Signatur

to_table(self: _duckdb.DuckDBPyRelation, table_name: str) -> None

Beschreibung

Erstellt eine neue Tabelle namens table_name mit dem Inhalt des Relation-Objekts

Aliase: create

Parameter

table_name : str

Der Name der zu erstellenden Tabelle. Es darf keine andere Tabelle mit demselben Namen existieren.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.to_table("table_code_example")

Ergebnis

A table, named table_code_example, is created with the data of the relation

`to_view`

Signatur

to_view(self: _duckdb.DuckDBPyRelation, view_name: str, replace: bool = True) -> _duckdb.DuckDBPyRelation

Beschreibung

Erstellt eine View namens view_name, die auf das Relation-Objekt verweist

Aliase: create_view

Parameter

view_name : str

Der Name der zu erstellenden View.
replace : bool, default: True

Ob die View mit CREATE OR REPLACE erstellt werden soll. Bei False darf keine andere View mit demselben view_name existieren.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.to_view("view_code_example", replace=True)

Ergebnis

A view, named view_code_example, is created with the query definition of the relation

`torch`

Signatur

torch(self: _duckdb.DuckDBPyRelation) -> dict

Beschreibung

Holt ein Ergebnis als dict von PyTorch Tensors

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.select("value").torch()

Ergebnis

{'value': tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])}

`write_csv`

Signatur

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

Beschreibung

Schreibt das Relation-Objekt in eine CSV-Datei in ‘file_name’

Aliase: to_csv

Parameter

file_name : str

Name der Ausgabe-CSV-Datei.
sep : str, default: ‘,’

Feldtrennzeichen für die Ausgabedatei.
na_rep : str, default: ‘’

Darstellung fehlender Daten.
header : bool, default: True

Ob Spaltenüberschriften geschrieben werden.
quotechar : str, default: ‘“’

Zeichen zum Quoten von Feldern mit Sonderzeichen.
escapechar : str, default: None

Zeichen zum Escapen des Trennzeichens, wenn Quoting auf QUOTE_NONE gesetzt ist.
date_format : str, default: None

Benutzerdefinierte Formatzeichenkette für DATE-Werte.
timestamp_format : str, default: None

Benutzerdefinierte Formatzeichenkette für TIMESTAMP-Werte.
quoting : int, default: csv.QUOTE_MINIMAL

Steuert das Quoting von Feldern (z. B. QUOTE_MINIMAL, QUOTE_ALL).
encoding : str, default: ‘utf-8’

Zeichenkodierung für die Ausgabedatei.
compression : str, default: auto

Kompressionstyp (z. B. ‘gzip’, ‘bz2’, ‘zstd’).
overwrite : bool, default: False

Bei true werden alle bestehenden Dateien in den Zielverzeichnissen entfernt (nicht auf entfernten Dateisystemen unterstützt). Wirkt nur zusammen mit partition_by.
per_thread_output : bool, default: False

Bei true wird eine Datei pro Thread geschrieben statt einer einzigen Datei. Das ermöglicht schnelleres paralleles Schreiben.
use_tmp_file : bool, default: False

Zuerst in eine temporäre Datei schreiben und dann umbenennen, um partielle Schreibvorgänge zu vermeiden.
partition_by : list[str], default: None

Liste der Spaltennamen, nach denen die Ausgabe partitioniert wird (erzeugt eine Ordnerstruktur).
write_partition_columns : bool, default: False

Ob Partitionsspalten in die Dateien geschrieben werden. Wirkt nur zusammen mit partition_by.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.write_csv("code_example.csv")

Ergebnis

The data is exported to a CSV file, named code_example.csv

`write_parquet`

Signatur

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

Beschreibung

Schreibt das Relation-Objekt in eine Parquet-Datei in ‘file_name’

Aliase: to_parquet

Parameter

file_name : str

Name der Ausgabe-Parquet-Datei.
compression : str, default: ‘snappy’

Das zu verwendende Kompressionsformat (uncompressed, snappy, gzip, zstd, brotli, lz4, lz4_raw).
field_ids : STRUCT

Die field_id für jede Spalte. Übergeben Sie auto, um eine automatische Ableitung zu versuchen.
row_group_size_bytes : int, default: row_group_size * 1024

Die Zielgröße jeder Row Group. Sie können eine lesbare Zeichenkette übergeben, z. B. 2MB, oder eine Ganzzahl, d. h. die Anzahl der Bytes. Diese Option wird nur verwendet, wenn Sie SET preserve_insertion_order = false; gesetzt haben, andernfalls wird sie ignoriert.
row_group_size : int, default: 122880

Die Zielgröße, d. h. die Anzahl der Zeilen, jeder Row Group.
overwrite : bool, default: False

Wenn True, die Datei überschreiben, falls sie existiert.
per_thread_output : bool, default: False

Bei True wird eine Datei pro Thread geschrieben statt einer einzigen Datei. Das ermöglicht schnelleres paralleles Schreiben.
use_tmp_file : bool, default: False

Zuerst in eine temporäre Datei schreiben und dann umbenennen, um partielle Schreibvorgänge zu vermeiden.
partition_by : list[str], default: None

Liste der Spaltennamen, nach denen die Ausgabe partitioniert wird (erzeugt eine Ordnerstruktur).
write_partition_columns : bool, default: False

Ob Partitionsspalten in die Dateien geschrieben werden. Wirkt nur zusammen mit partition_by.
append : bool, default: False

Bei True wird ein bereits existierendes Dateinamensmuster neu erzeugt, damit keine bestehenden Dateien überschrieben werden. Wirkt nur zusammen mit partition_by.

Beispiel

import duckdb

duckdb_conn = duckdb.connect()

rel = duckdb_conn.sql("""
        select
            gen_random_uuid() as id,
            concat('value is ', case when mod(range,2)=0 then 'even' else 'uneven' end) as description,
            range as value,
            now() + concat(range,' ', 'minutes')::interval as created_timestamp
        from range(1, 10)
    """
)

rel.write_parquet("code_example.parquet")

Ergebnis

The data is exported to a Parquet file, named code_example.parquet