#include "postgres.h"
#include <ctype.h>
#include <unistd.h>
#include <sys/stat.h>
#include "access/sysattr.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/pg_authid.h"
#include "commands/copy.h"
#include "commands/defrem.h"
#include "executor/executor.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "optimizer/optimizer.h"
#include "parser/parse_coerce.h"
#include "parser/parse_collate.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/rls.h"

Include dependency graph for copy.c:

Functions
void	DoCopy (ParseState pstate, const CopyStmt stmt, int stmt_location, int stmt_len, uint64 *processed)

static CopyHeaderChoice	defGetCopyHeaderChoice (DefElem *def, bool is_from)

static CopyOnErrorChoice	defGetCopyOnErrorChoice (DefElem def, ParseState pstate, bool is_from)

static int64	defGetCopyRejectLimitOption (DefElem *def)

static CopyLogVerbosityChoice	defGetCopyLogVerbosityChoice (DefElem def, ParseState pstate)

void	ProcessCopyOptions (ParseState pstate, CopyFormatOptions opts_out, bool is_from, List *options)

List *	CopyGetAttnums (TupleDesc tupDesc, Relation rel, List *attnamelist)

Function Documentation

◆ CopyGetAttnums()

List* CopyGetAttnums	(	TupleDesc	tupDesc,
		Relation	rel,
		List *	attnamelist
	)

Definition at line 945 of file copy.c.

 {
     List       *attnums = NIL;
  
     if (attnamelist == NIL)
     {
         /* Generate default column list */
         int         attr_count = tupDesc->natts;
         int         i;
  
         for (i = 0; i < attr_count; i++)
         {
             if (TupleDescAttr(tupDesc, i)->attisdropped)
                 continue;
             if (TupleDescAttr(tupDesc, i)->attgenerated)
                 continue;
             attnums = lappend_int(attnums, i + 1);
         }
     }
     else
     {
         /* Validate the user-supplied list and extract attnums */
         ListCell   *l;
  
         foreach(l, attnamelist)
         {
             char       *name = strVal(lfirst(l));
             int         attnum;
             int         i;
  
             /* Lookup column name */
             attnum = InvalidAttrNumber;
             for (i = 0; i < tupDesc->natts; i++)
             {
                 Form_pg_attribute att = TupleDescAttr(tupDesc, i);
  
                 if (att->attisdropped)
                     continue;
                 if (namestrcmp(&(att->attname), name) == 0)
                 {
                     if (att->attgenerated)
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                                  errmsg("column \"%s\" is a generated column",
                                         name),
                                  errdetail("Generated columns cannot be used in COPY.")));
                     attnum = att->attnum;
                     break;
                 }
             }
             if (attnum == InvalidAttrNumber)
             {
                 if (rel != NULL)
                     ereport(ERROR,
                             (errcode(ERRCODE_UNDEFINED_COLUMN),
                              errmsg("column \"%s\" of relation \"%s\" does not exist",
                                     name, RelationGetRelationName(rel))));
                 else
                     ereport(ERROR,
                             (errcode(ERRCODE_UNDEFINED_COLUMN),
                              errmsg("column \"%s\" does not exist",
                                     name)));
             }
             /* Check for duplicates */
             if (list_member_int(attnums, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_DUPLICATE_COLUMN),
                          errmsg("column \"%s\" specified more than once",
                                 name)));
             attnums = lappend_int(attnums, attnum);
         }
     }
  
     return attnums;
 }

References attnum, ereport, errcode(), errdetail(), errmsg(), ERROR, i, InvalidAttrNumber, lappend_int(), lfirst, list_member_int(), name, namestrcmp(), TupleDescData::natts, NIL, RelationGetRelationName, strVal, and TupleDescAttr.

Referenced by BeginCopyFrom(), BeginCopyTo(), and DoCopy().

◆ defGetCopyHeaderChoice()

static CopyHeaderChoice defGetCopyHeaderChoice	(	DefElem *	def,
		bool	is_from
	)

static

Definition at line 329 of file copy.c.

 {
     /*
      * If no parameter value given, assume "true" is meant.
      */
     if (def->arg == NULL)
         return COPY_HEADER_TRUE;
  
     /*
      * Allow 0, 1, "true", "false", "on", "off", or "match".
      */
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             switch (intVal(def->arg))
             {
                 case 0:
                     return COPY_HEADER_FALSE;
                 case 1:
                     return COPY_HEADER_TRUE;
                 default:
                     /* otherwise, error out below */
                     break;
             }
             break;
         default:
             {
                 char       *sval = defGetString(def);
  
                 /*
                  * The set of strings accepted here should match up with the
                  * grammar's opt_boolean_or_string production.
                  */
                 if (pg_strcasecmp(sval, "true") == 0)
                     return COPY_HEADER_TRUE;
                 if (pg_strcasecmp(sval, "false") == 0)
                     return COPY_HEADER_FALSE;
                 if (pg_strcasecmp(sval, "on") == 0)
                     return COPY_HEADER_TRUE;
                 if (pg_strcasecmp(sval, "off") == 0)
                     return COPY_HEADER_FALSE;
                 if (pg_strcasecmp(sval, "match") == 0)
                 {
                     if (!is_from)
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("cannot use \"%s\" with HEADER in COPY TO",
                                         sval)));
                     return COPY_HEADER_MATCH;
                 }
             }
             break;
     }
     ereport(ERROR,
             (errcode(ERRCODE_SYNTAX_ERROR),
              errmsg("%s requires a Boolean value or \"match\"",
                     def->defname)));
     return COPY_HEADER_FALSE;   /* keep compiler quiet */
 }

References DefElem::arg, COPY_HEADER_FALSE, COPY_HEADER_MATCH, COPY_HEADER_TRUE, defGetString(), DefElem::defname, ereport, errcode(), errmsg(), ERROR, intVal, nodeTag, and pg_strcasecmp().

Referenced by ProcessCopyOptions().

◆ defGetCopyLogVerbosityChoice()

static CopyLogVerbosityChoice defGetCopyLogVerbosityChoice	(	DefElem *	def,
		ParseState *	pstate
	)

static

Definition at line 456 of file copy.c.

 {
     char       *sval;
  
     /*
      * Allow "silent", "default", or "verbose" values.
      */
     sval = defGetString(def);
     if (pg_strcasecmp(sval, "silent") == 0)
         return COPY_LOG_VERBOSITY_SILENT;
     if (pg_strcasecmp(sval, "default") == 0)
         return COPY_LOG_VERBOSITY_DEFAULT;
     if (pg_strcasecmp(sval, "verbose") == 0)
         return COPY_LOG_VERBOSITY_VERBOSE;
  
     ereport(ERROR,
             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     /*- translator: first %s is the name of a COPY option, e.g. ON_ERROR */
              errmsg("COPY %s \"%s\" not recognized", "LOG_VERBOSITY", sval),
              parser_errposition(pstate, def->location)));
     return COPY_LOG_VERBOSITY_DEFAULT;  /* keep compiler quiet */
 }

References COPY_LOG_VERBOSITY_DEFAULT, COPY_LOG_VERBOSITY_SILENT, COPY_LOG_VERBOSITY_VERBOSE, defGetString(), ereport, errcode(), errmsg(), ERROR, DefElem::location, parser_errposition(), and pg_strcasecmp().

Referenced by ProcessCopyOptions().

◆ defGetCopyOnErrorChoice()

static CopyOnErrorChoice defGetCopyOnErrorChoice	(	DefElem *	def,
		ParseState *	pstate,
		bool	is_from
	)

static

Definition at line 393 of file copy.c.

 {
     char       *sval = defGetString(def);
  
     if (!is_from)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
         /*- translator: first %s is the name of a COPY option, e.g. ON_ERROR,
          second %s is a COPY with direction, e.g. COPY TO */
                  errmsg("COPY %s cannot be used with %s", "ON_ERROR", "COPY TO"),
                  parser_errposition(pstate, def->location)));
  
     /*
      * Allow "stop", or "ignore" values.
      */
     if (pg_strcasecmp(sval, "stop") == 0)
         return COPY_ON_ERROR_STOP;
     if (pg_strcasecmp(sval, "ignore") == 0)
         return COPY_ON_ERROR_IGNORE;
  
     ereport(ERROR,
             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     /*- translator: first %s is the name of a COPY option, e.g. ON_ERROR */
              errmsg("COPY %s \"%s\" not recognized", "ON_ERROR", sval),
              parser_errposition(pstate, def->location)));
     return COPY_ON_ERROR_STOP;  /* keep compiler quiet */
 }

References COPY_ON_ERROR_IGNORE, COPY_ON_ERROR_STOP, defGetString(), ereport, errcode(), errmsg(), ERROR, DefElem::location, parser_errposition(), and pg_strcasecmp().

Referenced by ProcessCopyOptions().

◆ defGetCopyRejectLimitOption()

static int64 defGetCopyRejectLimitOption ( DefElem * def )

static

Definition at line 429 of file copy.c.

 {
     int64       reject_limit;
  
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a numeric value",
                         def->defname)));
     else if (nodeTag(def->arg) == T_String)
         reject_limit = pg_strtoint64(strVal(def->arg));
     else
         reject_limit = defGetInt64(def);
  
     if (reject_limit <= 0)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("REJECT_LIMIT (%lld) must be greater than zero",
                         (long long) reject_limit)));
  
     return reject_limit;
 }

References DefElem::arg, defGetInt64(), DefElem::defname, ereport, errcode(), errmsg(), ERROR, nodeTag, pg_strtoint64(), and strVal.

Referenced by ProcessCopyOptions().

◆ DoCopy()

void DoCopy	(	ParseState *	pstate,
		const CopyStmt *	stmt,
		int	stmt_location,
		int	stmt_len,
		uint64 *	processed
	)

Definition at line 62 of file copy.c.

 {
     bool        is_from = stmt->is_from;
     bool        pipe = (stmt->filename == NULL);
     Relation    rel;
     Oid         relid;
     RawStmt    *query = NULL;
     Node       *whereClause = NULL;
  
     /*
      * Disallow COPY to/from file or program except to users with the
      * appropriate role.
      */
     if (!pipe)
     {
         if (stmt->is_program)
         {
             if (!has_privs_of_role(GetUserId(), ROLE_PG_EXECUTE_SERVER_PROGRAM))
                 ereport(ERROR,
                         (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                          errmsg("permission denied to COPY to or from an external program"),
                          errdetail("Only roles with privileges of the \"%s\" role may COPY to or from an external program.",
                                    "pg_execute_server_program"),
                          errhint("Anyone can COPY to stdout or from stdin. "
                                  "psql's \\copy command also works for anyone.")));
         }
         else
         {
             if (is_from && !has_privs_of_role(GetUserId(), ROLE_PG_READ_SERVER_FILES))
                 ereport(ERROR,
                         (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                          errmsg("permission denied to COPY from a file"),
                          errdetail("Only roles with privileges of the \"%s\" role may COPY from a file.",
                                    "pg_read_server_files"),
                          errhint("Anyone can COPY to stdout or from stdin. "
                                  "psql's \\copy command also works for anyone.")));
  
             if (!is_from && !has_privs_of_role(GetUserId(), ROLE_PG_WRITE_SERVER_FILES))
                 ereport(ERROR,
                         (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                          errmsg("permission denied to COPY to a file"),
                          errdetail("Only roles with privileges of the \"%s\" role may COPY to a file.",
                                    "pg_write_server_files"),
                          errhint("Anyone can COPY to stdout or from stdin. "
                                  "psql's \\copy command also works for anyone.")));
         }
     }
  
     if (stmt->relation)
     {
         LOCKMODE    lockmode = is_from ? RowExclusiveLock : AccessShareLock;
         ParseNamespaceItem *nsitem;
         RTEPermissionInfo *perminfo;
         TupleDesc   tupDesc;
         List       *attnums;
         ListCell   *cur;
  
         Assert(!stmt->query);
  
         /* Open and lock the relation, using the appropriate lock type. */
         rel = table_openrv(stmt->relation, lockmode);
  
         relid = RelationGetRelid(rel);
  
         nsitem = addRangeTableEntryForRelation(pstate, rel, lockmode,
                                                NULL, false, false);
  
         perminfo = nsitem->p_perminfo;
         perminfo->requiredPerms = (is_from ? ACL_INSERT : ACL_SELECT);
  
         if (stmt->whereClause)
         {
             /* add nsitem to query namespace */
             addNSItemToQuery(pstate, nsitem, false, true, true);
  
             /* Transform the raw expression tree */
             whereClause = transformExpr(pstate, stmt->whereClause, EXPR_KIND_COPY_WHERE);
  
             /* Make sure it yields a boolean result. */
             whereClause = coerce_to_boolean(pstate, whereClause, "WHERE");
  
             /* we have to fix its collations too */
             assign_expr_collations(pstate, whereClause);
  
             whereClause = eval_const_expressions(NULL, whereClause);
  
             whereClause = (Node *) canonicalize_qual((Expr *) whereClause, false);
             whereClause = (Node *) make_ands_implicit((Expr *) whereClause);
         }
  
         tupDesc = RelationGetDescr(rel);
         attnums = CopyGetAttnums(tupDesc, rel, stmt->attlist);
         foreach(cur, attnums)
         {
             int         attno;
             Bitmapset **bms;
  
             attno = lfirst_int(cur) - FirstLowInvalidHeapAttributeNumber;
             bms = is_from ? &perminfo->insertedCols : &perminfo->selectedCols;
  
             *bms = bms_add_member(*bms, attno);
         }
         ExecCheckPermissions(pstate->p_rtable, list_make1(perminfo), true);
  
         /*
          * Permission check for row security policies.
          *
          * check_enable_rls will ereport(ERROR) if the user has requested
          * something invalid and will otherwise indicate if we should enable
          * RLS (returns RLS_ENABLED) or not for this COPY statement.
          *
          * If the relation has a row security policy and we are to apply it
          * then perform a "query" copy and allow the normal query processing
          * to handle the policies.
          *
          * If RLS is not enabled for this, then just fall through to the
          * normal non-filtering relation handling.
          */
         if (check_enable_rls(relid, InvalidOid, false) == RLS_ENABLED)
         {
             SelectStmt *select;
             ColumnRef  *cr;
             ResTarget  *target;
             RangeVar   *from;
             List       *targetList = NIL;
  
             if (is_from)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("COPY FROM not supported with row-level security"),
                          errhint("Use INSERT statements instead.")));
  
             /*
              * Build target list
              *
              * If no columns are specified in the attribute list of the COPY
              * command, then the target list is 'all' columns. Therefore, '*'
              * should be used as the target list for the resulting SELECT
              * statement.
              *
              * In the case that columns are specified in the attribute list,
              * create a ColumnRef and ResTarget for each column and add them
              * to the target list for the resulting SELECT statement.
              */
             if (!stmt->attlist)
             {
                 cr = makeNode(ColumnRef);
                 cr->fields = list_make1(makeNode(A_Star));
                 cr->location = -1;
  
                 target = makeNode(ResTarget);
                 target->name = NULL;
                 target->indirection = NIL;
                 target->val = (Node *) cr;
                 target->location = -1;
  
                 targetList = list_make1(target);
             }
             else
             {
                 ListCell   *lc;
  
                 foreach(lc, stmt->attlist)
                 {
                     /*
                      * Build the ColumnRef for each column.  The ColumnRef
                      * 'fields' property is a String node that corresponds to
                      * the column name respectively.
                      */
                     cr = makeNode(ColumnRef);
                     cr->fields = list_make1(lfirst(lc));
                     cr->location = -1;
  
                     /* Build the ResTarget and add the ColumnRef to it. */
                     target = makeNode(ResTarget);
                     target->name = NULL;
                     target->indirection = NIL;
                     target->val = (Node *) cr;
                     target->location = -1;
  
                     /* Add each column to the SELECT statement's target list */
                     targetList = lappend(targetList, target);
                 }
             }
  
             /*
              * Build RangeVar for from clause, fully qualified based on the
              * relation which we have opened and locked.  Use "ONLY" so that
              * COPY retrieves rows from only the target table not any
              * inheritance children, the same as when RLS doesn't apply.
              */
             from = makeRangeVar(get_namespace_name(RelationGetNamespace(rel)),
                                 pstrdup(RelationGetRelationName(rel)),
                                 -1);
             from->inh = false;  /* apply ONLY */
  
             /* Build query */
             select = makeNode(SelectStmt);
             select->targetList = targetList;
             select->fromClause = list_make1(from);
  
             query = makeNode(RawStmt);
             query->stmt = (Node *) select;
             query->stmt_location = stmt_location;
             query->stmt_len = stmt_len;
  
             /*
              * Close the relation for now, but keep the lock on it to prevent
              * changes between now and when we start the query-based COPY.
              *
              * We'll reopen it later as part of the query-based COPY.
              */
             table_close(rel, NoLock);
             rel = NULL;
         }
     }
     else
     {
         Assert(stmt->query);
  
         query = makeNode(RawStmt);
         query->stmt = stmt->query;
         query->stmt_location = stmt_location;
         query->stmt_len = stmt_len;
  
         relid = InvalidOid;
         rel = NULL;
     }
  
     if (is_from)
     {
         CopyFromState cstate;
  
         Assert(rel);
  
         /* check read-only transaction and parallel mode */
         if (XactReadOnly && !rel->rd_islocaltemp)
             PreventCommandIfReadOnly("COPY FROM");
  
         cstate = BeginCopyFrom(pstate, rel, whereClause,
                                stmt->filename, stmt->is_program,
                                NULL, stmt->attlist, stmt->options);
         *processed = CopyFrom(cstate);  /* copy from file to database */
         EndCopyFrom(cstate);
     }
     else
     {
         CopyToState cstate;
  
         cstate = BeginCopyTo(pstate, rel, query, relid,
                              stmt->filename, stmt->is_program,
                              NULL, stmt->attlist, stmt->options);
         *processed = DoCopyTo(cstate);  /* copy from database to file */
         EndCopyTo(cstate);
     }
  
     if (rel != NULL)
         table_close(rel, NoLock);
 }

References AccessShareLock, ACL_INSERT, ACL_SELECT, addNSItemToQuery(), addRangeTableEntryForRelation(), Assert, assign_expr_collations(), BeginCopyFrom(), BeginCopyTo(), bms_add_member(), canonicalize_qual(), check_enable_rls(), coerce_to_boolean(), CopyFrom(), CopyGetAttnums(), cur, DoCopyTo(), EndCopyFrom(), EndCopyTo(), ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, eval_const_expressions(), ExecCheckPermissions(), EXPR_KIND_COPY_WHERE, ColumnRef::fields, FirstLowInvalidHeapAttributeNumber, get_namespace_name(), GetUserId(), has_privs_of_role(), ResTarget::indirection, RangeVar::inh, RTEPermissionInfo::insertedCols, InvalidOid, lappend(), lfirst, lfirst_int, list_make1, ColumnRef::location, ResTarget::location, make_ands_implicit(), makeNode, makeRangeVar(), ResTarget::name, NIL, NoLock, ParseNamespaceItem::p_perminfo, ParseState::p_rtable, PreventCommandIfReadOnly(), pstrdup(), RelationData::rd_islocaltemp, RelationGetDescr, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, RTEPermissionInfo::requiredPerms, RLS_ENABLED, RowExclusiveLock, select, RTEPermissionInfo::selectedCols, RawStmt::stmt, stmt, RawStmt::stmt_len, RawStmt::stmt_location, table_close(), table_openrv(), transformExpr(), ResTarget::val, and XactReadOnly.

Referenced by standard_ProcessUtility().

◆ ProcessCopyOptions()

void ProcessCopyOptions	(	ParseState *	pstate,
		CopyFormatOptions *	opts_out,
		bool	is_from,
		List *	options
	)

Definition at line 496 of file copy.c.

 {
     bool        format_specified = false;
     bool        freeze_specified = false;
     bool        header_specified = false;
     bool        on_error_specified = false;
     bool        log_verbosity_specified = false;
     bool        reject_limit_specified = false;
     ListCell   *option;
  
     /* Support external use for option sanity checking */
     if (opts_out == NULL)
         opts_out = (CopyFormatOptions *) palloc0(sizeof(CopyFormatOptions));
  
     opts_out->file_encoding = -1;
  
     /* Extract options from the statement node tree */
     foreach(option, options)
     {
         DefElem    *defel = lfirst_node(DefElem, option);
  
         if (strcmp(defel->defname, "format") == 0)
         {
             char       *fmt = defGetString(defel);
  
             if (format_specified)
                 errorConflictingDefElem(defel, pstate);
             format_specified = true;
             if (strcmp(fmt, "text") == 0)
                  /* default format */ ;
             else if (strcmp(fmt, "csv") == 0)
                 opts_out->csv_mode = true;
             else if (strcmp(fmt, "binary") == 0)
                 opts_out->binary = true;
             else
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                          errmsg("COPY format \"%s\" not recognized", fmt),
                          parser_errposition(pstate, defel->location)));
         }
         else if (strcmp(defel->defname, "freeze") == 0)
         {
             if (freeze_specified)
                 errorConflictingDefElem(defel, pstate);
             freeze_specified = true;
             opts_out->freeze = defGetBoolean(defel);
         }
         else if (strcmp(defel->defname, "delimiter") == 0)
         {
             if (opts_out->delim)
                 errorConflictingDefElem(defel, pstate);
             opts_out->delim = defGetString(defel);
         }
         else if (strcmp(defel->defname, "null") == 0)
         {
             if (opts_out->null_print)
                 errorConflictingDefElem(defel, pstate);
             opts_out->null_print = defGetString(defel);
         }
         else if (strcmp(defel->defname, "default") == 0)
         {
             if (opts_out->default_print)
                 errorConflictingDefElem(defel, pstate);
             opts_out->default_print = defGetString(defel);
         }
         else if (strcmp(defel->defname, "header") == 0)
         {
             if (header_specified)
                 errorConflictingDefElem(defel, pstate);
             header_specified = true;
             opts_out->header_line = defGetCopyHeaderChoice(defel, is_from);
         }
         else if (strcmp(defel->defname, "quote") == 0)
         {
             if (opts_out->quote)
                 errorConflictingDefElem(defel, pstate);
             opts_out->quote = defGetString(defel);
         }
         else if (strcmp(defel->defname, "escape") == 0)
         {
             if (opts_out->escape)
                 errorConflictingDefElem(defel, pstate);
             opts_out->escape = defGetString(defel);
         }
         else if (strcmp(defel->defname, "force_quote") == 0)
         {
             if (opts_out->force_quote || opts_out->force_quote_all)
                 errorConflictingDefElem(defel, pstate);
             if (defel->arg && IsA(defel->arg, A_Star))
                 opts_out->force_quote_all = true;
             else if (defel->arg && IsA(defel->arg, List))
                 opts_out->force_quote = castNode(List, defel->arg);
             else
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                          errmsg("argument to option \"%s\" must be a list of column names",
                                 defel->defname),
                          parser_errposition(pstate, defel->location)));
         }
         else if (strcmp(defel->defname, "force_not_null") == 0)
         {
             if (opts_out->force_notnull || opts_out->force_notnull_all)
                 errorConflictingDefElem(defel, pstate);
             if (defel->arg && IsA(defel->arg, A_Star))
                 opts_out->force_notnull_all = true;
             else if (defel->arg && IsA(defel->arg, List))
                 opts_out->force_notnull = castNode(List, defel->arg);
             else
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                          errmsg("argument to option \"%s\" must be a list of column names",
                                 defel->defname),
                          parser_errposition(pstate, defel->location)));
         }
         else if (strcmp(defel->defname, "force_null") == 0)
         {
             if (opts_out->force_null || opts_out->force_null_all)
                 errorConflictingDefElem(defel, pstate);
             if (defel->arg && IsA(defel->arg, A_Star))
                 opts_out->force_null_all = true;
             else if (defel->arg && IsA(defel->arg, List))
                 opts_out->force_null = castNode(List, defel->arg);
             else
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                          errmsg("argument to option \"%s\" must be a list of column names",
                                 defel->defname),
                          parser_errposition(pstate, defel->location)));
         }
         else if (strcmp(defel->defname, "convert_selectively") == 0)
         {
             /*
              * Undocumented, not-accessible-from-SQL option: convert only the
              * named columns to binary form, storing the rest as NULLs. It's
              * allowed for the column list to be NIL.
              */
             if (opts_out->convert_selectively)
                 errorConflictingDefElem(defel, pstate);
             opts_out->convert_selectively = true;
             if (defel->arg == NULL || IsA(defel->arg, List))
                 opts_out->convert_select = castNode(List, defel->arg);
             else
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                          errmsg("argument to option \"%s\" must be a list of column names",
                                 defel->defname),
                          parser_errposition(pstate, defel->location)));
         }
         else if (strcmp(defel->defname, "encoding") == 0)
         {
             if (opts_out->file_encoding >= 0)
                 errorConflictingDefElem(defel, pstate);
             opts_out->file_encoding = pg_char_to_encoding(defGetString(defel));
             if (opts_out->file_encoding < 0)
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                          errmsg("argument to option \"%s\" must be a valid encoding name",
                                 defel->defname),
                          parser_errposition(pstate, defel->location)));
         }
         else if (strcmp(defel->defname, "on_error") == 0)
         {
             if (on_error_specified)
                 errorConflictingDefElem(defel, pstate);
             on_error_specified = true;
             opts_out->on_error = defGetCopyOnErrorChoice(defel, pstate, is_from);
         }
         else if (strcmp(defel->defname, "log_verbosity") == 0)
         {
             if (log_verbosity_specified)
                 errorConflictingDefElem(defel, pstate);
             log_verbosity_specified = true;
             opts_out->log_verbosity = defGetCopyLogVerbosityChoice(defel, pstate);
         }
         else if (strcmp(defel->defname, "reject_limit") == 0)
         {
             if (reject_limit_specified)
                 errorConflictingDefElem(defel, pstate);
             reject_limit_specified = true;
             opts_out->reject_limit = defGetCopyRejectLimitOption(defel);
         }
         else
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("option \"%s\" not recognized",
                             defel->defname),
                      parser_errposition(pstate, defel->location)));
     }
  
     /*
      * Check for incompatible options (must do these three before inserting
      * defaults)
      */
     if (opts_out->binary && opts_out->delim)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
         /*- translator: %s is the name of a COPY option, e.g. ON_ERROR */
                  errmsg("cannot specify %s in BINARY mode", "DELIMITER")));
  
     if (opts_out->binary && opts_out->null_print)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("cannot specify %s in BINARY mode", "NULL")));
  
     if (opts_out->binary && opts_out->default_print)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("cannot specify %s in BINARY mode", "DEFAULT")));
  
     /* Set defaults for omitted options */
     if (!opts_out->delim)
         opts_out->delim = opts_out->csv_mode ? "," : "\t";
  
     if (!opts_out->null_print)
         opts_out->null_print = opts_out->csv_mode ? "" : "\\N";
     opts_out->null_print_len = strlen(opts_out->null_print);
  
     if (opts_out->csv_mode)
     {
         if (!opts_out->quote)
             opts_out->quote = "\"";
         if (!opts_out->escape)
             opts_out->escape = opts_out->quote;
     }
  
     /* Only single-byte delimiter strings are supported. */
     if (strlen(opts_out->delim) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY delimiter must be a single one-byte character")));
  
     /* Disallow end-of-line characters */
     if (strchr(opts_out->delim, '\r') != NULL ||
         strchr(opts_out->delim, '\n') != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("COPY delimiter cannot be newline or carriage return")));
  
     if (strchr(opts_out->null_print, '\r') != NULL ||
         strchr(opts_out->null_print, '\n') != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("COPY null representation cannot use newline or carriage return")));
  
     if (opts_out->default_print)
     {
         opts_out->default_print_len = strlen(opts_out->default_print);
  
         if (strchr(opts_out->default_print, '\r') != NULL ||
             strchr(opts_out->default_print, '\n') != NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                      errmsg("COPY default representation cannot use newline or carriage return")));
     }
  
     /*
      * Disallow unsafe delimiter characters in non-CSV mode.  We can't allow
      * backslash because it would be ambiguous.  We can't allow the other
      * cases because data characters matching the delimiter must be
      * backslashed, and certain backslash combinations are interpreted
      * non-literally by COPY IN.  Disallowing all lower case ASCII letters is
      * more than strictly necessary, but seems best for consistency and
      * future-proofing.  Likewise we disallow all digits though only octal
      * digits are actually dangerous.
      */
     if (!opts_out->csv_mode &&
         strchr("\\.abcdefghijklmnopqrstuvwxyz0123456789",
                opts_out->delim[0]) != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("COPY delimiter cannot be \"%s\"", opts_out->delim)));
  
     /* Check header */
     if (opts_out->binary && opts_out->header_line)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         /*- translator: %s is the name of a COPY option, e.g. ON_ERROR */
                  errmsg("cannot specify %s in BINARY mode", "HEADER")));
  
     /* Check quote */
     if (!opts_out->csv_mode && opts_out->quote != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         /*- translator: %s is the name of a COPY option, e.g. ON_ERROR */
                  errmsg("COPY %s requires CSV mode", "QUOTE")));
  
     if (opts_out->csv_mode && strlen(opts_out->quote) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY quote must be a single one-byte character")));
  
     if (opts_out->csv_mode && opts_out->delim[0] == opts_out->quote[0])
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("COPY delimiter and quote must be different")));
  
     /* Check escape */
     if (!opts_out->csv_mode && opts_out->escape != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         /*- translator: %s is the name of a COPY option, e.g. ON_ERROR */
                  errmsg("COPY %s requires CSV mode", "ESCAPE")));
  
     if (opts_out->csv_mode && strlen(opts_out->escape) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY escape must be a single one-byte character")));
  
     /* Check force_quote */
     if (!opts_out->csv_mode && (opts_out->force_quote || opts_out->force_quote_all))
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         /*- translator: %s is the name of a COPY option, e.g. ON_ERROR */
                  errmsg("COPY %s requires CSV mode", "FORCE_QUOTE")));
     if ((opts_out->force_quote || opts_out->force_quote_all) && is_from)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         /*- translator: first %s is the name of a COPY option, e.g. ON_ERROR,
          second %s is a COPY with direction, e.g. COPY TO */
                  errmsg("COPY %s cannot be used with %s", "FORCE_QUOTE",
                         "COPY FROM")));
  
     /* Check force_notnull */
     if (!opts_out->csv_mode && (opts_out->force_notnull != NIL ||
                                 opts_out->force_notnull_all))
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         /*- translator: %s is the name of a COPY option, e.g. ON_ERROR */
                  errmsg("COPY %s requires CSV mode", "FORCE_NOT_NULL")));
     if ((opts_out->force_notnull != NIL || opts_out->force_notnull_all) &&
         !is_from)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
         /*- translator: first %s is the name of a COPY option, e.g. ON_ERROR,
          second %s is a COPY with direction, e.g. COPY TO */
                  errmsg("COPY %s cannot be used with %s", "FORCE_NOT_NULL",
                         "COPY TO")));
  
     /* Check force_null */
     if (!opts_out->csv_mode && (opts_out->force_null != NIL ||
                                 opts_out->force_null_all))
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         /*- translator: %s is the name of a COPY option, e.g. ON_ERROR */
                  errmsg("COPY %s requires CSV mode", "FORCE_NULL")));
  
     if ((opts_out->force_null != NIL || opts_out->force_null_all) &&
         !is_from)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
         /*- translator: first %s is the name of a COPY option, e.g. ON_ERROR,
          second %s is a COPY with direction, e.g. COPY TO */
                  errmsg("COPY %s cannot be used with %s", "FORCE_NULL",
                         "COPY TO")));
  
     /* Don't allow the delimiter to appear in the null string. */
     if (strchr(opts_out->null_print, opts_out->delim[0]) != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
         /*- translator: %s is the name of a COPY option, e.g. NULL */
                  errmsg("COPY delimiter character must not appear in the %s specification",
                         "NULL")));
  
     /* Don't allow the CSV quote char to appear in the null string. */
     if (opts_out->csv_mode &&
         strchr(opts_out->null_print, opts_out->quote[0]) != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
         /*- translator: %s is the name of a COPY option, e.g. NULL */
                  errmsg("CSV quote character must not appear in the %s specification",
                         "NULL")));
  
     /* Check freeze */
     if (opts_out->freeze && !is_from)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
         /*- translator: first %s is the name of a COPY option, e.g. ON_ERROR,
          second %s is a COPY with direction, e.g. COPY TO */
                  errmsg("COPY %s cannot be used with %s", "FREEZE",
                         "COPY TO")));
  
     if (opts_out->default_print)
     {
         if (!is_from)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             /*- translator: first %s is the name of a COPY option, e.g. ON_ERROR,
              second %s is a COPY with direction, e.g. COPY TO */
                      errmsg("COPY %s cannot be used with %s", "DEFAULT",
                             "COPY TO")));
  
         /* Don't allow the delimiter to appear in the default string. */
         if (strchr(opts_out->default_print, opts_out->delim[0]) != NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             /*- translator: %s is the name of a COPY option, e.g. NULL */
                      errmsg("COPY delimiter character must not appear in the %s specification",
                             "DEFAULT")));
  
         /* Don't allow the CSV quote char to appear in the default string. */
         if (opts_out->csv_mode &&
             strchr(opts_out->default_print, opts_out->quote[0]) != NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             /*- translator: %s is the name of a COPY option, e.g. NULL */
                      errmsg("CSV quote character must not appear in the %s specification",
                             "DEFAULT")));
  
         /* Don't allow the NULL and DEFAULT string to be the same */
         if (opts_out->null_print_len == opts_out->default_print_len &&
             strncmp(opts_out->null_print, opts_out->default_print,
                     opts_out->null_print_len) == 0)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("NULL specification and DEFAULT specification cannot be the same")));
     }
     /* Check on_error */
     if (opts_out->binary && opts_out->on_error != COPY_ON_ERROR_STOP)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("only ON_ERROR STOP is allowed in BINARY mode")));
  
     if (opts_out->reject_limit && !opts_out->on_error)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
         /*- translator: first and second %s are the names of COPY option, e.g.
          * ON_ERROR, third is the value of the COPY option, e.g. IGNORE */
                  errmsg("COPY %s requires %s to be set to %s",
                         "REJECT_LIMIT", "ON_ERROR", "IGNORE")));
 }

Referenced by BeginCopyFrom(), BeginCopyTo(), and file_fdw_validator().

Functions

Function Documentation

◆ CopyGetAttnums()

◆ defGetCopyHeaderChoice()

◆ defGetCopyLogVerbosityChoice()

◆ defGetCopyOnErrorChoice()

◆ defGetCopyRejectLimitOption()

◆ DoCopy()

◆ ProcessCopyOptions()