1COPY(7) PostgreSQL 15.4 Documentation COPY(7)
2
6 COPY - copy data between a file and a table
7
9 COPY table_name [ ( column_name [, ...] ) ]
10 FROM { 'filename' | PROGRAM 'command' | STDIN }
11 [ [ WITH ] ( option [, ...] ) ]
12 [ WHERE condition ]
13 COPY { table_name [ ( column_name [, ...] ) ] | ( query ) }
15 TO { 'filename' | PROGRAM 'command' | STDOUT }
16 [ [ WITH ] ( option [, ...] ) ]
17 where option can be one of:
19 FORMAT format_name
21 FREEZE [ boolean ]
22 DELIMITER 'delimiter_character'
23 NULL 'null_string'
24 HEADER [ boolean | MATCH ]
25 QUOTE 'quote_character'
26 ESCAPE 'escape_character'
27 FORCE_QUOTE { ( column_name [, ...] ) | * }
28 FORCE_NOT_NULL ( column_name [, ...] )
29 FORCE_NULL ( column_name [, ...] )
30 ENCODING 'encoding_name'
31
33 COPY moves data between PostgreSQL tables and standard file-system
34 files. COPY TO copies the contents of a table to a file, while COPY
35 FROM copies data from a file to a table (appending the data to whatever
36 is in the table already). COPY TO can also copy the results of a
37 SELECT query.
38 If a column list is specified, COPY TO copies only the data in the
40 specified columns to the file. For COPY FROM, each field in the file is
41 inserted, in order, into the specified column. Table columns not
42 specified in the COPY FROM column list will receive their default
43 values.
44 COPY with a file name instructs the PostgreSQL server to directly read
46 from or write to a file. The file must be accessible by the PostgreSQL
47 user (the user ID the server runs as) and the name must be specified
48 from the viewpoint of the server. When PROGRAM is specified, the server
49 executes the given command and reads from the standard output of the
50 program, or writes to the standard input of the program. The command
51 must be specified from the viewpoint of the server, and be executable
52 by the PostgreSQL user. When STDIN or STDOUT is specified, data is
53 transmitted via the connection between the client and the server.
54 Each backend running COPY will report its progress in the
56 pg_stat_progress_copy view. See Section 28.4.6 for details.
57
59 table_name
60 The name (optionally schema-qualified) of an existing table.
61 column_name
63 An optional list of columns to be copied. If no column list is
64 specified, all columns of the table except generated columns will
65 be copied.
66 query
68 A SELECT, VALUES, INSERT, UPDATE, or DELETE command whose results
69 are to be copied. Note that parentheses are required around the
70 query.
71 For INSERT, UPDATE and DELETE queries a RETURNING clause must be
73 provided, and the target relation must not have a conditional rule,
74 nor an ALSO rule, nor an INSTEAD rule that expands to multiple
75 statements.
76 filename
78 The path name of the input or output file. An input file name can
79 be an absolute or relative path, but an output file name must be an
80 absolute path. Windows users might need to use an E'' string and
81 double any backslashes used in the path name.
82 PROGRAM
84 A command to execute. In COPY FROM, the input is read from standard
85 output of the command, and in COPY TO, the output is written to the
86 standard input of the command.
87 Note that the command is invoked by the shell, so if you need to
89 pass any arguments to shell command that come from an untrusted
90 source, you must be careful to strip or escape any special
91 characters that might have a special meaning for the shell. For
92 security reasons, it is best to use a fixed command string, or at
93 least avoid passing any user input in it.
94 STDIN
96 Specifies that input comes from the client application.
97 STDOUT
99 Specifies that output goes to the client application.
100 boolean
102 Specifies whether the selected option should be turned on or off.
103 You can write TRUE, ON, or 1 to enable the option, and FALSE, OFF,
104 or 0 to disable it. The boolean value can also be omitted, in which
105 case TRUE is assumed.
106 FORMAT
108 Selects the data format to be read or written: text, csv (Comma
109 Separated Values), or binary. The default is text.
110 FREEZE
112 Requests copying the data with rows already frozen, just as they
113 would be after running the VACUUM FREEZE command. This is intended
114 as a performance option for initial data loading. Rows will be
115 frozen only if the table being loaded has been created or truncated
116 in the current subtransaction, there are no cursors open and there
117 are no older snapshots held by this transaction. It is currently
118 not possible to perform a COPY FREEZE on a partitioned table.
119 Note that all other sessions will immediately be able to see the
121 data once it has been successfully loaded. This violates the normal
122 rules of MVCC visibility and users specifying should be aware of
123 the potential problems this might cause.
124 DELIMITER
126 Specifies the character that separates columns within each row
127 (line) of the file. The default is a tab character in text format,
128 a comma in CSV format. This must be a single one-byte character.
129 This option is not allowed when using binary format.
130 NULL
132 Specifies the string that represents a null value. The default is
133 \N (backslash-N) in text format, and an unquoted empty string in
134 CSV format. You might prefer an empty string even in text format
135 for cases where you don't want to distinguish nulls from empty
136 strings. This option is not allowed when using binary format.
137 Note
139 When using COPY FROM, any data item that matches this string
140 will be stored as a null value, so you should make sure that
141 you use the same string as you used with COPY TO.
142 HEADER
144 Specifies that the file contains a header line with the names of
145 each column in the file. On output, the first line contains the
146 column names from the table. On input, the first line is discarded
147 when this option is set to true (or equivalent Boolean value). If
148 this option is set to MATCH, the number and names of the columns in
149 the header line must match the actual column names of the table, in
150 order; otherwise an error is raised. This option is not allowed
151 when using binary format. The MATCH option is only valid for COPY
152 FROM commands.
153 QUOTE
155 Specifies the quoting character to be used when a data value is
156 quoted. The default is double-quote. This must be a single one-byte
157 character. This option is allowed only when using CSV format.
158 ESCAPE
160 Specifies the character that should appear before a data character
161 that matches the QUOTE value. The default is the same as the QUOTE
162 value (so that the quoting character is doubled if it appears in
163 the data). This must be a single one-byte character. This option is
164 allowed only when using CSV format.
165 FORCE_QUOTE
167 Forces quoting to be used for all non-NULL values in each specified
168 column. NULL output is never quoted. If * is specified, non-NULL
169 values will be quoted in all columns. This option is allowed only
170 in COPY TO, and only when using CSV format.
171 FORCE_NOT_NULL
173 Do not match the specified columns' values against the null string.
174 In the default case where the null string is empty, this means that
175 empty values will be read as zero-length strings rather than nulls,
176 even when they are not quoted. This option is allowed only in COPY
177 FROM, and only when using CSV format.
178 FORCE_NULL
180 Match the specified columns' values against the null string, even
181 if it has been quoted, and if a match is found set the value to
182 NULL. In the default case where the null string is empty, this
183 converts a quoted empty string into NULL. This option is allowed
184 only in COPY FROM, and only when using CSV format.
185 ENCODING
187 Specifies that the file is encoded in the encoding_name. If this
188 option is omitted, the current client encoding is used. See the
189 Notes below for more details.
190 WHERE
192 The optional WHERE clause has the general form
193 WHERE condition
195 where condition is any expression that evaluates to a result of
197 type boolean. Any row that does not satisfy this condition will not
198 be inserted to the table. A row satisfies the condition if it
199 returns true when the actual row values are substituted for any
200 variable references.
201 Currently, subqueries are not allowed in WHERE expressions, and the
203 evaluation does not see any changes made by the COPY itself (this
204 matters when the expression contains calls to VOLATILE functions).
205
207 On successful completion, a COPY command returns a command tag of the
208 form
209 COPY count
211 The count is the number of rows copied.
213 Note
215 psql will print this command tag only if the command was not COPY
216 ... TO STDOUT, or the equivalent psql meta-command \copy ... to
217 stdout. This is to prevent confusing the command tag with the data
218 that was just printed.
219
221 COPY TO can be used only with plain tables, not views, and does not
222 copy rows from child tables or child partitions. For example, COPY
223 table TO copies the same rows as SELECT * FROM ONLY table. The syntax
224 COPY (SELECT * FROM table) TO ... can be used to dump all of the rows
225 in an inheritance hierarchy, partitioned table, or view.
226 COPY FROM can be used with plain, foreign, or partitioned tables or
228 with views that have INSTEAD OF INSERT triggers.
229 You must have select privilege on the table whose values are read by
231 COPY TO, and insert privilege on the table into which values are
232 inserted by COPY FROM. It is sufficient to have column privileges on
233 the column(s) listed in the command.
234 If row-level security is enabled for the table, the relevant SELECT
236 policies will apply to COPY table TO statements. Currently, COPY FROM
237 is not supported for tables with row-level security. Use equivalent
238 INSERT statements instead.
239 Files named in a COPY command are read or written directly by the
241 server, not by the client application. Therefore, they must reside on
242 or be accessible to the database server machine, not the client. They
243 must be accessible to and readable or writable by the PostgreSQL user
244 (the user ID the server runs as), not the client. Similarly, the
245 command specified with PROGRAM is executed directly by the server, not
246 by the client application, must be executable by the PostgreSQL user.
247 COPY naming a file or command is only allowed to database superusers or
248 users who are granted one of the roles pg_read_server_files,
249 pg_write_server_files, or pg_execute_server_program, since it allows
250 reading or writing any file or running a program that the server has
251 privileges to access.
252 Do not confuse COPY with the psql instruction \copy. \copy invokes
254 COPY FROM STDIN or COPY TO STDOUT, and then fetches/stores the data in
255 a file accessible to the psql client. Thus, file accessibility and
256 access rights depend on the client rather than the server when \copy is
257 used.
258 It is recommended that the file name used in COPY always be specified
260 as an absolute path. This is enforced by the server in the case of COPY
261 TO, but for COPY FROM you do have the option of reading from a file
262 specified by a relative path. The path will be interpreted relative to
263 the working directory of the server process (normally the cluster's
264 data directory), not the client's working directory.
265 Executing a command with PROGRAM might be restricted by the operating
267 system's access control mechanisms, such as SELinux.
268 COPY FROM will invoke any triggers and check constraints on the
270 destination table. However, it will not invoke rules.
271 For identity columns, the COPY FROM command will always write the
273 column values provided in the input data, like the INSERT option
274 OVERRIDING SYSTEM VALUE.
275 COPY input and output is affected by DateStyle. To ensure portability
277 to other PostgreSQL installations that might use non-default DateStyle
278 settings, DateStyle should be set to ISO before using COPY TO. It is
279 also a good idea to avoid dumping data with IntervalStyle set to
280 sql_standard, because negative interval values might be misinterpreted
281 by a server that has a different setting for IntervalStyle.
282 Input data is interpreted according to ENCODING option or the current
284 client encoding, and output data is encoded in ENCODING or the current
285 client encoding, even if the data does not pass through the client but
286 is read from or written to a file directly by the server.
287 COPY stops operation at the first error. This should not lead to
289 problems in the event of a COPY TO, but the target table will already
290 have received earlier rows in a COPY FROM. These rows will not be
291 visible or accessible, but they still occupy disk space. This might
292 amount to a considerable amount of wasted disk space if the failure
293 happened well into a large copy operation. You might wish to invoke
294 VACUUM to recover the wasted space.
295 FORCE_NULL and FORCE_NOT_NULL can be used simultaneously on the same
297 column. This results in converting quoted null strings to null values
298 and unquoted null strings to empty strings.
299
301 Text Format
302 When the text format is used, the data read or written is a text file
303 with one line per table row. Columns in a row are separated by the
304 delimiter character. The column values themselves are strings generated
305 by the output function, or acceptable to the input function, of each
306 attribute's data type. The specified null string is used in place of
307 columns that are null. COPY FROM will raise an error if any line of
308 the input file contains more or fewer columns than are expected.
309 End of data can be represented by a single line containing just
311 backslash-period (\.). An end-of-data marker is not necessary when
312 reading from a file, since the end of file serves perfectly well; it is
313 needed only when copying data to or from client applications using
314 pre-3.0 client protocol.
315 Backslash characters (\) can be used in the COPY data to quote data
317 characters that might otherwise be taken as row or column delimiters.
318 In particular, the following characters must be preceded by a backslash
319 if they appear as part of a column value: backslash itself, newline,
320 carriage return, and the current delimiter character.
321 The specified null string is sent by COPY TO without adding any
323 backslashes; conversely, COPY FROM matches the input against the null
324 string before removing backslashes. Therefore, a null string such as \N
325 cannot be confused with the actual data value \N (which would be
326 represented as \\N).
327 The following special backslash sequences are recognized by COPY FROM:
329 ┌─────────┬────────────────────────────┐
331 │Sequence │ Represents │
332 ├─────────┼────────────────────────────┤
333 │\b │ Backspace (ASCII 8) │
334 ├─────────┼────────────────────────────┤
335 │\f │ Form feed (ASCII 12) │
336 ├─────────┼────────────────────────────┤
337 │\n │ Newline (ASCII 10) │
338 ├─────────┼────────────────────────────┤
339 │\r │ Carriage return (ASCII 13) │
340 ├─────────┼────────────────────────────┤
341 │\t │ Tab (ASCII 9) │
342 ├─────────┼────────────────────────────┤
343 │\v │ Vertical tab (ASCII 11) │
344 ├─────────┼────────────────────────────┤
345 │\digits │ Backslash followed by one │
346 │ │ to three octal digits │
347 │ │ specifies │
348 │ │ the byte with that │
349 │ │ numeric code │
350 ├─────────┼────────────────────────────┤
351 │\xdigits │ Backslash x followed by │
352 │ │ one or two hex digits │
353 │ │ specifies │
354 │ │ the byte with that │
355 │ │ numeric code │
356 └─────────┴────────────────────────────┘
357 Presently, COPY TO will never emit an octal or hex-digits backslash
358 sequence, but it does use the other sequences listed above for those
359 control characters.
360 Any other backslashed character that is not mentioned in the above
362 table will be taken to represent itself. However, beware of adding
363 backslashes unnecessarily, since that might accidentally produce a
364 string matching the end-of-data marker (\.) or the null string (\N by
365 default). These strings will be recognized before any other backslash
366 processing is done.
367 It is strongly recommended that applications generating COPY data
369 convert data newlines and carriage returns to the \n and \r sequences
370 respectively. At present it is possible to represent a data carriage
371 return by a backslash and carriage return, and to represent a data
372 newline by a backslash and newline. However, these representations
373 might not be accepted in future releases. They are also highly
374 vulnerable to corruption if the COPY file is transferred across
375 different machines (for example, from Unix to Windows or vice versa).
376 All backslash sequences are interpreted after encoding conversion. The
378 bytes specified with the octal and hex-digit backslash sequences must
379 form valid characters in the database encoding.
380 COPY TO will terminate each row with a Unix-style newline (“\n”).
382 Servers running on Microsoft Windows instead output carriage
383 return/newline (“\r\n”), but only for COPY to a server file; for
384 consistency across platforms, COPY TO STDOUT always sends “\n”
385 regardless of server platform. COPY FROM can handle lines ending with
386 newlines, carriage returns, or carriage return/newlines. To reduce the
387 risk of error due to un-backslashed newlines or carriage returns that
388 were meant as data, COPY FROM will complain if the line endings in the
389 input are not all alike.
390 CSV Format
392 This format option is used for importing and exporting the Comma
393 Separated Value (CSV) file format used by many other programs, such as
394 spreadsheets. Instead of the escaping rules used by PostgreSQL's
395 standard text format, it produces and recognizes the common CSV
396 escaping mechanism.
397 The values in each record are separated by the DELIMITER character. If
399 the value contains the delimiter character, the QUOTE character, the
400 NULL string, a carriage return, or line feed character, then the whole
401 value is prefixed and suffixed by the QUOTE character, and any
402 occurrence within the value of a QUOTE character or the ESCAPE
403 character is preceded by the escape character. You can also use
404 FORCE_QUOTE to force quotes when outputting non-NULL values in specific
405 columns.
406 The CSV format has no standard way to distinguish a NULL value from an
408 empty string. PostgreSQL's COPY handles this by quoting. A NULL is
409 output as the NULL parameter string and is not quoted, while a non-NULL
410 value matching the NULL parameter string is quoted. For example, with
411 the default settings, a NULL is written as an unquoted empty string,
412 while an empty string data value is written with double quotes ("").
413 Reading values follows similar rules. You can use FORCE_NOT_NULL to
414 prevent NULL input comparisons for specific columns. You can also use
415 FORCE_NULL to convert quoted null string data values to NULL.
416 Because backslash is not a special character in the CSV format, \., the
418 end-of-data marker, could also appear as a data value. To avoid any
419 misinterpretation, a \. data value appearing as a lone entry on a line
420 is automatically quoted on output, and on input, if quoted, is not
421 interpreted as the end-of-data marker. If you are loading a file
422 created by another application that has a single unquoted column and
423 might have a value of \., you might need to quote that value in the
424 input file.
425 Note
427 In CSV format, all characters are significant. A quoted value
428 surrounded by white space, or any characters other than DELIMITER,
429 will include those characters. This can cause errors if you import
430 data from a system that pads CSV lines with white space out to some
431 fixed width. If such a situation arises you might need to
432 preprocess the CSV file to remove the trailing white space, before
433 importing the data into PostgreSQL.
434 Note
436 CSV format will both recognize and produce CSV files with quoted
437 values containing embedded carriage returns and line feeds. Thus
438 the files are not strictly one line per table row like text-format
439 files.
440 Note
442 Many programs produce strange and occasionally perverse CSV files,
443 so the file format is more a convention than a standard. Thus you
444 might encounter some files that cannot be imported using this
445 mechanism, and COPY might produce files that other programs cannot
446 process.
447 Binary Format
449 The binary format option causes all data to be stored/read as binary
450 format rather than as text. It is somewhat faster than the text and CSV
451 formats, but a binary-format file is less portable across machine
452 architectures and PostgreSQL versions. Also, the binary format is very
453 data type specific; for example it will not work to output binary data
454 from a smallint column and read it into an integer column, even though
455 that would work fine in text format.
456 The binary file format consists of a file header, zero or more tuples
458 containing the row data, and a file trailer. Headers and data are in
459 network byte order.
460 Note
462 PostgreSQL releases before 7.4 used a different binary file format.
463 File Header
465 The file header consists of 15 bytes of fixed fields, followed by a
466 variable-length header extension area. The fixed fields are:
467 Signature
469 11-byte sequence PGCOPY\n\377\r\n\0 — note that the zero byte
470 is a required part of the signature. (The signature is designed
471 to allow easy identification of files that have been munged by
472 a non-8-bit-clean transfer. This signature will be changed by
473 end-of-line-translation filters, dropped zero bytes, dropped
474 high bits, or parity changes.)
475 Flags field
477 32-bit integer bit mask to denote important aspects of the file
478 format. Bits are numbered from 0 (LSB) to 31 (MSB). Note that
479 this field is stored in network byte order (most significant
480 byte first), as are all the integer fields used in the file
481 format. Bits 16–31 are reserved to denote critical file format
482 issues; a reader should abort if it finds an unexpected bit set
483 in this range. Bits 0–15 are reserved to signal
484 backwards-compatible format issues; a reader should simply
485 ignore any unexpected bits set in this range. Currently only
486 one flag bit is defined, and the rest must be zero:
487 Bit 16
489 If 1, OIDs are included in the data; if 0, not. Oid system
490 columns are not supported in PostgreSQL anymore, but the
491 format still contains the indicator.
492 Header extension area length
494 32-bit integer, length in bytes of remainder of header, not
495 including self. Currently, this is zero, and the first tuple
496 follows immediately. Future changes to the format might allow
497 additional data to be present in the header. A reader should
498 silently skip over any header extension data it does not know
499 what to do with.
500 The header extension area is envisioned to contain a sequence of
502 self-identifying chunks. The flags field is not intended to tell
503 readers what is in the extension area. Specific design of header
504 extension contents is left for a later release.
505 This design allows for both backwards-compatible header additions
507 (add header extension chunks, or set low-order flag bits) and
508 non-backwards-compatible changes (set high-order flag bits to
509 signal such changes, and add supporting data to the extension area
510 if needed).
511 Tuples
513 Each tuple begins with a 16-bit integer count of the number of
514 fields in the tuple. (Presently, all tuples in a table will have
515 the same count, but that might not always be true.) Then, repeated
516 for each field in the tuple, there is a 32-bit length word followed
517 by that many bytes of field data. (The length word does not include
518 itself, and can be zero.) As a special case, -1 indicates a NULL
519 field value. No value bytes follow in the NULL case.
520 There is no alignment padding or any other extra data between
522 fields.
523 Presently, all data values in a binary-format file are assumed to
525 be in binary format (format code one). It is anticipated that a
526 future extension might add a header field that allows per-column
527 format codes to be specified.
528 To determine the appropriate binary format for the actual tuple
530 data you should consult the PostgreSQL source, in particular the
531 *send and *recv functions for each column's data type (typically
532 these functions are found in the src/backend/utils/adt/ directory
533 of the source distribution).
534 If OIDs are included in the file, the OID field immediately follows
536 the field-count word. It is a normal field except that it's not
537 included in the field-count. Note that oid system columns are not
538 supported in current versions of PostgreSQL.
539 File Trailer
541 The file trailer consists of a 16-bit integer word containing -1.
542 This is easily distinguished from a tuple's field-count word.
543 A reader should report an error if a field-count word is neither -1
545 nor the expected number of columns. This provides an extra check
546 against somehow getting out of sync with the data.
547
549 The following example copies a table to the client using the vertical
550 bar (|) as the field delimiter:
551 COPY country TO STDOUT (DELIMITER '|');
553 To copy data from a file into the country table:
555 COPY country FROM '/usr1/proj/bray/sql/country_data';
557 To copy into a file just the countries whose names start with 'A':
559 COPY (SELECT * FROM country WHERE country_name LIKE 'A%') TO '/usr1/proj/bray/sql/a_list_countries.copy';
561 To copy into a compressed file, you can pipe the output through an
563 external compression program:
564 COPY country TO PROGRAM 'gzip > /usr1/proj/bray/sql/country_data.gz';
566 Here is a sample of data suitable for copying into a table from STDIN:
568 AF AFGHANISTAN
570 AL ALBANIA
571 DZ ALGERIA
572 ZM ZAMBIA
573 ZW ZIMBABWE
574 Note that the white space on each line is actually a tab character.
576 The following is the same data, output in binary format. The data is
578 shown after filtering through the Unix utility od -c. The table has
579 three columns; the first has type char(2), the second has type text,
580 and the third has type integer. All the rows have a null value in the
581 third column.
582 0000000 P G C O P Y \n 377 \r \n \0 \0 \0 \0 \0 \0
584 0000020 \0 \0 \0 \0 003 \0 \0 \0 002 A F \0 \0 \0 013 A
585 0000040 F G H A N I S T A N 377 377 377 377 \0 003
586 0000060 \0 \0 \0 002 A L \0 \0 \0 007 A L B A N I
587 0000100 A 377 377 377 377 \0 003 \0 \0 \0 002 D Z \0 \0 \0
588 0000120 007 A L G E R I A 377 377 377 377 \0 003 \0 \0
589 0000140 \0 002 Z M \0 \0 \0 006 Z A M B I A 377 377
590 0000160 377 377 \0 003 \0 \0 \0 002 Z W \0 \0 \0 \b Z I
591 0000200 M B A B W E 377 377 377 377 377 377
592
594 There is no COPY statement in the SQL standard.
595 The following syntax was used before PostgreSQL version 9.0 and is
597 still supported:
598 COPY table_name [ ( column_name [, ...] ) ]
600 FROM { 'filename' | STDIN }
601 [ [ WITH ]
602 [ BINARY ]
603 [ DELIMITER [ AS ] 'delimiter_character' ]
604 [ NULL [ AS ] 'null_string' ]
605 [ CSV [ HEADER ]
606 [ QUOTE [ AS ] 'quote_character' ]
607 [ ESCAPE [ AS ] 'escape_character' ]
608 [ FORCE NOT NULL column_name [, ...] ] ] ]
609 COPY { table_name [ ( column_name [, ...] ) ] | ( query ) }
611 TO { 'filename' | STDOUT }
612 [ [ WITH ]
613 [ BINARY ]
614 [ DELIMITER [ AS ] 'delimiter_character' ]
615 [ NULL [ AS ] 'null_string' ]
616 [ CSV [ HEADER ]
617 [ QUOTE [ AS ] 'quote_character' ]
618 [ ESCAPE [ AS ] 'escape_character' ]
619 [ FORCE QUOTE { column_name [, ...] | * } ] ] ]
620 Note that in this syntax, BINARY and CSV are treated as independent
622 keywords, not as arguments of a FORMAT option.
623 The following syntax was used before PostgreSQL version 7.3 and is
625 still supported:
626 COPY [ BINARY ] table_name
628 FROM { 'filename' | STDIN }
629 [ [USING] DELIMITERS 'delimiter_character' ]
630 [ WITH NULL AS 'null_string' ]
631 COPY [ BINARY ] table_name
633 TO { 'filename' | STDOUT }
634 [ [USING] DELIMITERS 'delimiter_character' ]
635 [ WITH NULL AS 'null_string' ]
636
638 Section 28.4.6
639PostgreSQL 15.4 2023 COPY(7)