COPY-Anweisung

Beispiele

Eine CSV-Datei in die Tabelle lineitem einlesen, mit automatisch erkannten CSV-Optionen:

COPY lineitem FROM 'lineitem.csv';

Eine CSV-Datei in die Tabelle lineitem einlesen, mit manuell angegebenen CSV-Optionen:

COPY lineitem FROM 'lineitem.csv' (DELIMITER '|');

Eine Parquet-Datei in die Tabelle lineitem einlesen:

COPY lineitem FROM 'lineitem.pq' (FORMAT parquet);

Eine JSON-Datei in die Tabelle lineitem einlesen, mit automatisch erkannten Optionen:

COPY lineitem FROM 'lineitem.json' (FORMAT json, AUTO_DETECT true);

Eine CSV-Datei in die Tabelle lineitem einlesen, mit doppelten Anführungszeichen:

COPY lineitem FROM "lineitem.csv";

Eine CSV-Datei in die Tabelle lineitem einlesen, ohne Anführungszeichen:

COPY lineitem FROM lineitem.csv;

Eine Tabelle in eine CSV-Datei schreiben:

COPY lineitem TO 'lineitem.csv' (FORMAT csv, DELIMITER '|', HEADER);

Eine Tabelle in eine CSV-Datei schreiben, mit doppelten Anführungszeichen:

COPY lineitem TO "lineitem.csv";

Eine Tabelle in eine CSV-Datei schreiben, ohne Anführungszeichen:

COPY lineitem TO lineitem.csv;

Das Ergebnis einer Abfrage in eine Parquet-Datei schreiben:

COPY (SELECT l_orderkey, l_partkey FROM lineitem) TO 'lineitem.parquet' (COMPRESSION zstd);

Den gesamten Inhalt der Datenbank db1 in die Datenbank db2 kopieren:

COPY FROM DATABASE db1 TO db2;

Nur das Schema (Katalogelemente) kopieren, aber keine Daten:

COPY FROM DATABASE db1 TO db2 (SCHEMA);

Überblick

COPY bewegt Daten zwischen DuckDB und externen Dateien. COPY ... FROM importiert Daten aus einer externen Datei in DuckDB. COPY ... TO schreibt Daten aus DuckDB in eine externe Datei. Der COPY-Befehl kann für CSV-, PARQUET- und JSON-Dateien verwendet werden.

`COPY ... FROM`

COPY ... FROM importiert Daten aus einer externen Datei in eine vorhandene Tabelle. Die Daten werden an die bereits in der Tabelle vorhandenen Daten angehängt. Die Anzahl der Spalten in der Datei muss mit der Anzahl der Spalten in der Tabelle tbl übereinstimmen, und der Inhalt der Spalten muss in die Spaltentypen der Tabelle umwandelbar sein. Ist das nicht möglich, wird ein Fehler geworfen.

Ist eine Spaltenliste angegeben, kopiert COPY nur die Daten der angegebenen Spalten aus der Datei. Gibt es in der Tabelle Spalten, die nicht in der Spaltenliste stehen, fügt COPY ... FROM für diese Spalten die Standardwerte ein.

Den Inhalt einer kommagetrennten Datei test.csv ohne Header in die Tabelle test kopieren:

COPY test FROM 'test.csv';

Den Inhalt einer kommagetrennten Datei mit Header in die Tabelle category kopieren:

COPY category FROM 'categories.csv' (HEADER);

Den Inhalt von lineitem.tbl in die Tabelle lineitem kopieren, wobei der Inhalt durch ein Pipe-Zeichen (|) getrennt ist:

COPY lineitem FROM 'lineitem.tbl' (DELIMITER '|');

Den Inhalt von lineitem.tbl in die Tabelle lineitem kopieren, wobei Trennzeichen, Anführungszeichen und das Vorhandensein eines Headers automatisch erkannt werden:

COPY lineitem FROM 'lineitem.tbl' (AUTO_DETECT true);

Den Inhalt einer kommagetrennten Datei names.csv in die Spalte name der Tabelle category einlesen. Alle anderen Spalten dieser Tabelle werden mit ihrem Standardwert gefüllt:

COPY category(name) FROM 'names.csv';

Den Inhalt einer Parquet-Datei lineitem.parquet in die Tabelle lineitem einlesen:

COPY lineitem FROM 'lineitem.parquet' (FORMAT parquet);

Den Inhalt einer zeilenumbruchgetrennten JSON-Datei lineitem.ndjson in die Tabelle lineitem einlesen:

COPY lineitem FROM 'lineitem.ndjson' (FORMAT json);

Den Inhalt einer JSON-Datei lineitem.json in die Tabelle lineitem einlesen:

COPY lineitem FROM 'lineitem.json' (FORMAT json, ARRAY true);

Ein Ausdruck kann als Quelle eines COPY ... FROM-Befehls verwendet werden, wenn er in Klammern steht.

Den Inhalt einer Datei, deren Pfad in einer Variable gespeichert ist, in die Tabelle lineitem einlesen:

SET VARIABLE source_file = 'lineitem.json';
COPY lineitem FROM (getvariable('source_file'));

Den Inhalt einer Datei, die als Parameter einer vorbereiteten Anweisung übergeben wird, in die Tabelle lineitem einlesen:

PREPARE v1 AS COPY lineitem FROM ($1);
EXECUTE v1('lineitem.json');

Syntax

Um die Kompatibilität mit PostgreSQL sicherzustellen, akzeptiert DuckDB COPY ... FROM-Anweisungen, die nicht vollständig dem hier gezeigten Railroad-Diagramm entsprechen. Zum Beispiel ist das Folgende eine gültige Anweisung:
COPY tbl FROM 'tbl.csv' WITH DELIMITER '|' CSV HEADER;

`COPY ... TO`

COPY ... TO exportiert Daten aus DuckDB in eine externe CSV-, Parquet-, JSON- oder BLOB-Datei. Es hat weitgehend dieselbe Menge von Optionen wie COPY ... FROM; bei COPY ... TO geben die Optionen jedoch an, wie die Datei auf die Festplatte geschrieben werden soll. Jede von COPY ... TO erzeugte Datei kann mit COPY ... FROM und einer ähnlichen Menge von Optionen wieder in die Datenbank kopiert werden.

Die Funktion COPY ... TO kann mit einem Tabellennamen oder einer Abfrage aufgerufen werden. Wird ein Tabellenname angegeben, wird der Inhalt der gesamten Tabelle in die resultierende Datei geschrieben. Wird eine Abfrage angegeben, wird die Abfrage ausgeführt und das Ergebnis der Abfrage in die resultierende Datei geschrieben.

Den Inhalt der Tabelle lineitem in eine CSV-Datei mit Header kopieren:

COPY lineitem TO 'lineitem.csv';

Den Inhalt der Tabelle lineitem in die Datei lineitem.tbl kopieren, wobei die Spalten durch ein Pipe-Zeichen (|) getrennt sind, einschließlich einer Header-Zeile:

COPY lineitem TO 'lineitem.tbl' (DELIMITER '|');

Tabulatortrenner verwenden, um eine TSV-Datei ohne Header zu erzeugen:

COPY lineitem TO 'lineitem.tsv' (DELIMITER '\t', HEADER false);

Die Spalte l_orderkey der Tabelle lineitem in die Datei orderkey.tbl kopieren:

COPY lineitem(l_orderkey) TO 'orderkey.tbl' (DELIMITER '|');

Das Ergebnis einer Abfrage in die Datei query.csv kopieren, einschließlich eines Headers mit Spaltennamen:

COPY (SELECT 42 AS a, 'hello' AS b) TO 'query.csv' (DELIMITER ',');

Das Ergebnis einer Abfrage in die Parquet-Datei query.parquet kopieren:

COPY (SELECT 42 AS a, 'hello' AS b) TO 'query.parquet' (FORMAT parquet);

Das Ergebnis einer Abfrage in die zeilenumbruchgetrennte JSON-Datei query.ndjson kopieren:

COPY (SELECT 42 AS a, 'hello' AS b) TO 'query.ndjson' (FORMAT json);

Das Ergebnis einer Abfrage in die JSON-Datei query.json kopieren:

COPY (SELECT 42 AS a, 'hello' AS b) TO 'query.json' (FORMAT json, ARRAY true);

Die Dateien und ihre Spaltenstatistiken zurückgeben, die als Teil der COPY-Anweisung geschrieben wurden:

COPY (SELECT l_orderkey, l_comment FROM lineitem) TO 'lineitem_part.parquet' (RETURN_STATS);

filename	count	file_size_bytes	footer_size_bytes	column_statistics	partition_keys
lineitem_part.parquet	600572	8579141	1445	{‘“l_comment”’={column_size_bytes=7642227, max=zzle. slyly, min=’ Tiresias above the blit’, null_count=0}, ‘“l_orderkey”’={column_size_bytes=935457, max=600000, min=1, null_count=0}}	NULL

Hinweis: Bei verschachtelten Spalten (z. B. Structs) werden die Spaltenstatistiken für jeden Teil definiert. Haben wir zum Beispiel eine Spalte name STRUCT(field1 INTEGER, field2 INTEGER), haben die Spaltenstatistiken Stats für name.field1 und name.field2.

Ein Ausdruck kann als Ziel eines COPY ... TO-Befehls verwendet werden, wenn er in Klammern steht.

Das Ergebnis einer Abfrage in eine Datei kopieren, deren Pfad in einer Variable gespeichert ist:

SET VARIABLE target_file = 'target_file.parquet';
COPY (SELECT 'hello world') TO (getvariable('target_file'));

In eine Datei kopieren, die als Parameter einer vorbereiteten Anweisung übergeben wird:

PREPARE v1 AS COPY (SELECT 42 AS i) to $1;
EXECUTE v1('file.csv');

Ausdrücke können auch für Optionen verwendet werden. In eine Datei mit einem in einer Variable gespeicherten Format kopieren:

SET VARIABLE my_format = 'parquet';
COPY (SELECT 42 AS i) TO 'file' (FORMAT getvariable('my_format'));

Optionen für `COPY ... TO`

Null oder mehr Copy-Optionen können als Teil der Copy-Operation angegeben werden. Der Spezifizierer WITH ist optional, aber wenn Optionen angegeben sind, sind die Klammern erforderlich. Parameterwerte können mit oder ohne einfache Anführungszeichen übergeben werden. Für Parameterwerte können beliebige Ausdrücke verwendet werden.

Jede boolesche Option kann auf mehrere Arten aktiviert oder deaktiviert werden. Sie können true, ON oder 1 schreiben, um die Option zu aktivieren, und false, OFF oder 0, um sie zu deaktivieren. Der BOOLEAN-Wert kann auch weggelassen werden, z. B. durch nur (HEADER), in welchem Fall true angenommen wird.

Mit wenigen Ausnahmen gelten die folgenden Optionen für alle mit COPY geschriebenen Formate.

Name	Beschreibung	Typ	Standard
`FORMAT`	Gibt die zu verwendende Copy-Funktion an. Der Standard wird aus der Dateierweiterung gewählt (z. B. führt `.parquet` dazu, dass eine Parquet-Datei geschrieben/gelesen wird). Ist die Dateierweiterung unbekannt, wird `CSV` gewählt. Vanilla DuckDB stellt `CSV`, `PARQUET` und `JSON` bereit, zusätzliche Copy-Funktionen können durch `Extensions` hinzugefügt werden.	`VARCHAR`	`auto`
`USE_TMP_FILE`	Ob zuerst in eine temporäre Datei geschrieben werden soll, wenn die Originaldatei existiert (`target.csv.tmp`). Das verhindert das Überschreiben einer vorhandenen Datei mit einer beschädigten Datei, falls das Schreiben abgebrochen wird.	`BOOL`	`auto`
`OVERWRITE_OR_IGNORE`	Ob das Überschreiben vorhandener Dateien erlaubt ist. Wirkt nur bei Optionen, die mehrere Dateien schreiben, etwa `PARTITION_BY`, `PER_THREAD_OUTPUT` oder `FILE_SIZE_BYTES`.	`BOOL`	`false`
`OVERWRITE`	Wenn `true`, werden alle vorhandenen Dateien in den Zielverzeichnissen entfernt (nicht auf entfernten Dateisystemen unterstützt). Wirkt nur bei Optionen, die mehrere Dateien schreiben, etwa `PARTITION_BY`, `PER_THREAD_OUTPUT` oder `FILE_SIZE_BYTES`.	`BOOL`	`false`
`APPEND`	Wenn `true`, wird bei einem bereits existierenden Dateinamensmuster der Pfad neu erzeugt, damit keine vorhandenen Dateien überschrieben werden. Wirkt nur bei Optionen, die mehrere Dateien schreiben, etwa `PARTITION_BY`, `PER_THREAD_OUTPUT` oder `FILE_SIZE_BYTES`.	`BOOL`	`false`
`FILENAME_PATTERN`	Ein Muster für den Dateinamen setzen; kann optional `{uuid}` / `{uuidv4}` oder `{uuidv7}` enthalten, die mit einer erzeugten UUID (v4 bzw. v7) gefüllt werden, sowie `{i}`, das durch einen hochzählenden Index ersetzt wird. Wirkt nur bei Optionen, die mehrere Dateien schreiben, etwa `PARTITION_BY`, `PER_THREAD_OUTPUT` oder `FILE_SIZE_BYTES`.	`VARCHAR`	`auto`
`FILE_EXTENSION`	Die Dateierweiterung setzen, die den erzeugten Datei(en) zugewiesen werden soll.	`VARCHAR`	`auto`
`PER_THREAD_OUTPUT`	Wenn `true`, erzeugt der `COPY`-Befehl eine Datei pro Thread statt einer Datei insgesamt. Das ermöglicht schnelleres paralleles Schreiben.	`BOOL`	`false`
`FILE_SIZE_BYTES`	Ist dieser Parameter gesetzt, erzeugt der `COPY`-Prozess ein Verzeichnis, das die exportierten Dateien enthält. Überschreitet eine Datei das gesetzte Limit (angegeben als Bytes wie `1000` oder in menschenlesbarer Form wie `1k`), erzeugt der Prozess eine neue Datei im Verzeichnis. Dieser Parameter wirkt zusammen mit `PER_THREAD_OUTPUT`. Beachten Sie, dass die Größe als Näherung verwendet wird und Dateien gelegentlich leicht über dem Limit liegen können.	`VARCHAR` oder `BIGINT`	(leer)
`PARTITION_BY`	Die Spalten, nach denen mit einem Hive-Partitionierungsschema partitioniert werden soll, siehe den Abschnitt Partitionierte Schreibvorgänge.	`VARCHAR[]`	(leer)
`PRESERVE_ORDER`	Ob die Reihenfolge während der Copy-Operation erhalten bleiben soll. Standard ist der Wert der Konfigurationsoption `preserve_insertion_order`.	`BOOL`	(*)
`RETURN_FILES`	Ob die erzeugten Dateipfade (als Spalte `files VARCHAR[]`) im Abfrageergebnis enthalten sein sollen.	`BOOL`	`false`
`RETURN_STATS`	Ob die Dateien und ihre Spaltenstatistiken zurückgegeben werden sollen, die als Teil der `COPY`-Anweisung geschrieben wurden.	`BOOL`	`false`
`WRITE_PARTITION_COLUMNS`	Ob Partitionsspalten in Dateien geschrieben werden sollen. Wirkt nur bei Verwendung mit `PARTITION_BY`.	`BOOL`	`false`

Syntax

Um die Kompatibilität mit PostgreSQL sicherzustellen, akzeptiert DuckDB COPY ... TO-Anweisungen, die nicht vollständig dem hier gezeigten Railroad-Diagramm entsprechen. Zum Beispiel ist das Folgende eine gültige Anweisung:
COPY (SELECT 42 AS x, 84 AS y) TO 'out.csv' WITH DELIMITER '|' CSV HEADER;

`COPY FROM DATABASE ... TO`

Die Anweisung COPY FROM DATABASE ... TO kopiert den gesamten Inhalt von einer angehängten Datenbank in eine andere angehängte Datenbank. Dazu gehören das Schema einschließlich Constraints, Indexes, Sequenzen, Makros und die Daten selbst.

ATTACH 'db1.db' AS db1;
CREATE TABLE db1.tbl AS SELECT 42 AS x, 3 AS y;
CREATE MACRO db1.two_x_plus_y(x, y) AS 2 * x + y;

ATTACH 'db2.db' AS db2;
COPY FROM DATABASE db1 TO db2;
SELECT db2.two_x_plus_y(x, y) AS z FROM db2.tbl;

z
87

Um nur das Schema von db1 nach db2 zu kopieren, aber das Kopieren der Daten wegzulassen, fügen Sie SCHEMA zur Anweisung hinzu:

COPY FROM DATABASE db1 TO db2 (SCHEMA);

Syntax

Formatspezifische Optionen

CSV-Optionen

Die folgenden Optionen gelten beim Schreiben von CSV-Dateien.

Name	Beschreibung	Typ	Standard
`COMPRESSION`	Der Kompressionstyp für die Datei. Standardmäßig wird er automatisch aus der Dateierweiterung erkannt (z. B. verwendet `file.csv.gz` `gzip`, `file.csv.zst` verwendet `zstd` und `file.csv` verwendet `none`). Optionen sind `none`, `gzip`, `zstd`.	`VARCHAR`	`auto`
`DATEFORMAT`	Gibt das Datumsformat zum Schreiben von Daten an. Siehe Datumsformat.	`VARCHAR`	(leer)
`DELIM` oder `SEP`	Das Zeichen, das zum Trennen von Spalten innerhalb jeder Zeile geschrieben wird.	`VARCHAR`	`,`
`NEW_LINE`	Das Zeichen, das zum Trennen jeder Zeile geschrieben wird. Verwenden Sie escaped Strings, z. B. `E'\x1e'`	`VARCHAR`	`\n`
`ESCAPE`	Das Zeichen, das vor einem Zeichen erscheinen soll, das dem `quote`-Wert entspricht.	`VARCHAR`	`"`
`FORCE_QUOTE`	Die Liste der Spalten, die immer in Anführungszeichen gesetzt werden, auch wenn nicht erforderlich.	`VARCHAR[]`	`[]`
`HEADER`	Ob ein Header für die CSV-Datei geschrieben werden soll.	`BOOL`	`true`
`NULLSTR`	Der String, der geschrieben wird, um einen `NULL`-Wert darzustellen.	`VARCHAR`	(leer)
`PREFIX`	Stellt der CSV-Datei einen angegebenen String voran. Diese Option muss zusammen mit `SUFFIX` verwendet werden und erfordert, dass `HEADER` auf `false` gesetzt ist.	`VARCHAR`	(leer)
`SUFFIX`	Hängt einen angegebenen String als Suffix an die CSV-Datei an. Diese Option muss zusammen mit `PREFIX` verwendet werden und erfordert, dass `HEADER` auf `false` gesetzt ist.	`VARCHAR`	(leer)
`QUOTE`	Das Anführungszeichen, das verwendet wird, wenn ein Datenwert in Anführungszeichen gesetzt wird.	`VARCHAR`	`"`
`TIMESTAMPFORMAT`	Gibt das Datumsformat zum Schreiben von Zeitstempeln an. Siehe Datumsformat.	`VARCHAR`	(leer)

Parquet-Optionen

Die folgenden Optionen gelten beim Schreiben von Parquet-Dateien.

Name	Beschreibung	Typ	Standard
`COMPRESSION`	Das zu verwendende Kompressionsformat (`uncompressed`, `snappy`, `gzip`, `zstd`, `brotli`, `lz4`, `lz4_raw`).	`VARCHAR`	`snappy`
`COMPRESSION_LEVEL`	Kompressionsstufe, gesetzt zwischen 1 (niedrigste Kompression, schnellste) und 22 (höchste Kompression, langsamste). Nur für zstd-Kompression unterstützt.	`BIGINT`	`3`
`FIELD_IDS`	Die `field_id` für jede Spalte. Übergeben Sie `auto`, um eine automatische Ableitung zu versuchen.	`STRUCT`	(leer)
`ROW_GROUP_SIZE_BYTES`	Die Zielgröße jeder Row Group. Sie können entweder einen menschenlesbaren String ü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;` ausgeführt haben, andernfalls wird sie ignoriert.	`BIGINT`	`row_group_size * 1024`
`ROW_GROUP_SIZE`	Die Zielgröße, d. h. die Zeilenzahl, jeder Row Group.	`BIGINT`	122880
`ROW_GROUPS_PER_FILE`	Eine neue Parquet-Datei anlegen, wenn die aktuelle eine angegebene Anzahl von Row Groups hat. Sind mehrere Threads aktiv, kann die Anzahl der Row Groups in einer Datei die angegebene Anzahl leicht überschreiten, um die Menge an Locking zu begrenzen – ähnlich dem Verhalten von `FILE_SIZE_BYTES`. Ist jedoch `per_thread_output` gesetzt, schreibt nur ein Thread in jede Datei, und es wird wieder genau.	`BIGINT`	(leer)
`PARQUET_VERSION`	Die zu verwendende Parquet-Version (`V1`, `V2`).	`VARCHAR`	`V1`
`CHUNK_SIZE`	Alias für `ROW_GROUP_SIZE`.	`BIGINT`	122880
`KV_METADATA`	Benutzerdefinierte Schlüssel-Wert-Metadaten, die in den Dateifooter eingebettet werden, als `STRUCT` von Schlüsseln zu Werten. `BLOB`-Werte werden als Rohbytes geschrieben; andere Werte werden zu String gecastet.	`STRUCT`	(leer)
`SHREDDING`	Ein `STRUCT`, der `VARIANT`-Spaltennamen auf den Typ abbildet, in den sie geschreddert werden sollen, z. B. `{variant_col: 'STRUCT(name VARCHAR, age INTEGER)'}`. Ermöglicht typisierte (geschredderte) Speicherung von `VARIANT`-Spalten.	`STRUCT`	(leer)
`DICTIONARY_SIZE_LIMIT`	Die maximale Größe des für Dictionary Encoding verwendeten Dictionarys, in Anzahl unterschiedlicher Werte. Setzen Sie den Wert auf `0`, um Dictionary Encoding zu deaktivieren.	`BIGINT`	`ROW_GROUP_SIZE / 5`
`WRITE_BLOOM_FILTER`	Ob Bloom-Filter geschrieben werden sollen, die Lesern das Überspringen von Row Groups erlauben.	`BOOLEAN`	`true`
`BLOOM_FILTER_FALSE_POSITIVE_RATIO`	Das Ziel-False-Positive-Verhältnis der geschriebenen Bloom-Filter.	`DOUBLE`	`0.01`
`GEOPARQUET_VERSION`	Welche GeoParquet-Metadatenversion für Geometriespalten geschrieben werden soll (`NONE`, `V1`, `V2`, `BOTH`). `NONE` deaktiviert GeoParquet-Metadaten.	`VARCHAR`	`V1`

Einige Beispiele für FIELD_IDS sind die folgenden.

field_ids automatisch zuweisen:

COPY
    (SELECT 128 AS i)
    TO 'my.parquet'
    (FIELD_IDS 'auto');

Setzt die field_id der Spalte i auf 42:

COPY
    (SELECT 128 AS i)
    TO 'my.parquet'
    (FIELD_IDS {i: 42});

Setzt die field_id der Spalte i auf 42 und der Spalte j auf 43:

COPY
    (SELECT 128 AS i, 256 AS j)
    TO 'my.parquet'
    (FIELD_IDS {i: 42, j: 43});

Setzt die field_id der Spalte my_struct auf 42 und der Spalte i (verschachtelt in my_struct) auf 43:

COPY
    (SELECT {i: 128} AS my_struct)
    TO 'my.parquet'
    (FIELD_IDS {my_struct: {__duckdb_field_id: 42, i: 43}});

Setzt die field_id der Spalte my_list auf 42 und der Spalte element (Standardname des Listenelements) auf 43:

COPY
    (SELECT [128, 256] AS my_list)
    TO 'my.parquet'
    (FIELD_IDS {my_list: {__duckdb_field_id: 42, element: 43}});

Setzt die field_id der Spalte my_map auf 42 und der Spalten key und value (Standardnamen der Map-Kinder) auf 43 und 44:

COPY
    (SELECT MAP {'key1' : 128, 'key2': 256} my_map)
    TO 'my.parquet'
    (FIELD_IDS {my_map: {__duckdb_field_id: 42, key: 43, value: 44}});

JSON-Optionen

Die folgenden Optionen gelten beim Schreiben von JSON-Dateien.

Name	Beschreibung	Typ	Standard
`ARRAY`	Ob ein JSON-Array geschrieben werden soll. Wenn `true`, wird ein JSON-Array von Records geschrieben, wenn `false`, wird zeilenumbruchgetrenntes JSON geschrieben	`BOOL`	`false`
`COMPRESSION`	Der Kompressionstyp für die Datei. Standardmäßig wird er automatisch aus der Dateierweiterung erkannt (z. B. verwendet `file.json.gz` `gzip`, `file.json.zst` verwendet `zstd` und `file.json` verwendet `none`). Optionen sind `none`, `gzip`, `zstd`.	`VARCHAR`	`auto`
`DATEFORMAT`	Gibt das Datumsformat zum Schreiben von Daten an. Siehe Datumsformat.	`VARCHAR`	(leer)
`TIMESTAMPFORMAT`	Gibt das Datumsformat zum Schreiben von Zeitstempeln an. Siehe Datumsformat.	`VARCHAR`	(leer)

Setzt den Wert der Spalte hello auf QUACK! und gibt die Ergebnisse nach quack.json aus:

COPY (SELECT 'QUACK!' AS hello) TO 'quack.json';
--RETURNS: {"hello":"QUACK!"}

Setzt den Wert der Spalte num_list auf [1,2,3] und gibt die Ergebnisse nach numbers.json aus:

COPY (SELECT [1, 2, 3] AS num_list) TO 'numbers.json';
--RETURNS: {"num_list":[1,2,3]}

Setzt den Wert der Spalte compression_type auf gzip_explicit und gibt die Ergebnisse nach compression.json.gz mit expliziter Kompression aus:

COPY (SELECT 'gzip_explicit' AS compression_type) TO 'explicit_compression.json' (FORMAT json, COMPRESSION 'GZIP');
-- RETURNS: {"compression_type":"gzip_explicit"}

Setzt alle Werte einzelner Zeilen als verschachtelte Arrays nach array_true.json:

COPY (SELECT 1 AS id, 'Alice' AS name, [1, 2, 3] AS numbers
      UNION ALL
      SELECT 2, 'Bob', [4, 5, 6] AS numbers)
TO 'array_true.json' (FORMAT json, ARRAY true);

-- RETURNS:
/*
[
    {"id":1,"name":"Alice","numbers":[1,2,3]},
    {"id":2,"name":"Bob","numbers":[1,2,3]}
]
*/

Setzt alle Werte einzelner Zeilen als nicht-verschachtelte Arrays nach array_false.json:

COPY (SELECT 1 AS id, 'Alice' AS name, [1, 2, 3] AS numbers
      UNION ALL
      SELECT 2, 'Bob', [4, 5, 6] AS numbers)
TO 'array_false.json' (FORMAT json, ARRAY false);

-- RETURNS:
/*
{"id":1,"name":"Alice","numbers":[1,2,3]}
{"id":2,"name":"Bob","numbers":[4,5,6]}
*/

BLOB-Optionen

Die Formatoption BLOB erlaubt es, eine einzelne Spalte einer DuckDB-Tabelle in eine .blob-Datei auszuwählen. Die Spalte muss in den Datentyp BLOB gecastet werden. Details zum Typecasting finden Sie in der Casting-Operations-Matrix.

Die folgenden Optionen gelten beim Schreiben von BLOB-Dateien.

Name	Beschreibung	Typ	Standard
`COMPRESSION`	Der Kompressionstyp für die Datei. Standardmäßig wird er automatisch aus der Dateierweiterung erkannt (z. B. verwendet `file.blob.gz` `gzip`, `file.blob.zst` verwendet `zstd` und `file.blob` verwendet `none`). Optionen sind `none`, `gzip`, `zstd`.	`VARCHAR`	`auto`

Typecastet den Stringwert foo auf den Datentyp BLOB und gibt die Ergebnisse nach blob_output.blob aus:

COPY (select 'foo'::BLOB) TO 'blob_output.blob' (FORMAT BLOB);

Typecastet den Stringwert foo auf den Datentyp BLOB und gibt die Ergebnisse nach blob_output_gzip.blob.gz mit gzip-Kompression aus:

COPY (select 'foo'::BLOB) TO 'blob_output_gzip.blob' (FORMAT BLOB, COMPRESSION 'GZIP');

Einschränkungen

COPY unterstützt das Kopieren zwischen Tabellen nicht. Um zwischen Tabellen zu kopieren, verwenden Sie eine INSERT-Anweisung:

INSERT INTO tbl2
    FROM tbl1;

COPY-Anweisung

Beispiele

Überblick

COPY ... FROM

Syntax

COPY ... TO

Optionen für COPY ... TO

Syntax

COPY FROM DATABASE ... TO

Syntax

Formatspezifische Optionen

CSV-Optionen

Parquet-Optionen

JSON-Optionen

BLOB-Optionen

Einschränkungen

`COPY ... FROM`

`COPY ... TO`

Optionen für `COPY ... TO`

`COPY FROM DATABASE ... TO`